Assertions in java with examples

Содержание

Java Assertions
Enabling Assertions
Example 1: Java assertion
Another form of assertion statement
Example 2: Java assertion with expression example
Enabling assertion for specific classes and packages
Disabling Assertions
Advantages of Assertion
When to use Assertions
1. Unreachable codes
2. Documenting assumptions
When not to use Assertions
1. Argument checking in public methods
2. To evaluate expressions that affect the program operation
Table of Contents
Java Assertion
How does Assertion work in Java?
Steps to use Eclipse Java Assertion
Examples to Implement Java Assertion
Example #1
Example #2
Example #3
Advantages of using Assertion in Java
Conclusion
Recommended Articles

Java Assertions

Assertions in Java help to detect bugs by testing code we assume to be true.

An assertion is made using the assert keyword.

Here, condition is a boolean expression that we assume to be true when the program executes.

Enabling Assertions

By default, assertions are disabled and ignored at runtime.

To enable assertions, we use:

java -enableassertions:arguments

When assertions are enabled and the condition is true , the program executes normally.

But if the condition evaluates to false while assertions are enabled, JVM throws an AssertionError , and the program stops immediately.

Example 1: Java assertion

class Main < public static void main(String args[]) < String[] weekends = ; assert weekends.length == 2; System.out.println("There are " + weekends.length + " weekends in a week"); > >

There are 3 weekends in a week

We get the above output because this program has no compilation errors and by default, assertions are disabled.

After enabling assertions, we get the following output:

Exception in thread "main" java.lang.AssertionError

Another form of assertion statement

assert condition : expression;

In this form of assertion statement, an expression is passed to the constructor of the AssertionError object. This expression has a value that is displayed as the error’s detail message if the condition is false .

The detailed message is used to capture and transmit the information of the assertion failure to help in debugging the problem.

Example 2: Java assertion with expression example

class Main < public static void main(String args[]) < String[] weekends = ; assert weekends.length==2 : "There are only 2 weekends in a week"; System.out.println("There are " + weekends.length + " weekends in a week"); > >

Exception in thread "main" java.lang.AssertionError: There are only 2 weekends in a week

As we see from the above example, the expression is passed to the constructor of the AssertionError object. If our assumption is false and assertions are enabled, an exception is thrown with an appropriate message.

This message helps in diagnosing and fixing the error that caused the assertion to fail.

Enabling assertion for specific classes and packages

If we do not provide any arguments to the assertion command-line switches,

This enables assertions in all classes except system classes.

We can also enable assertion for specific classes and packages using arguments. The arguments that can be provided to these command-line switches are:

Enable assertion in class names

To enable assertion for all classes of our program Main,

This enables assertion in only the AnimalClass in the Main program.

Enable assertion in package names

To enable assertions for package com.animal and its sub-packages only,

Enable assertion in unnamed packages

To enable assertion in unnamed packages (when we don’t use a package statement) in the current working directory.

Enable assertion in system classes

To enable assertion in system classes, we use a different command-line switch:

java -enablesystemassertions:arguments

The arguments that can be provided to these switches are the same.

Disabling Assertions

To disable assertions, we use:

java -disableassertions arguments

To disable assertion in system classes, we use:

java -disablesystemassertions:arguments

The arguments that can be passed while disabling assertions are the same as while enabling them.

Advantages of Assertion

Quick and efficient for detecting and correcting bugs.
Assertion checks are done only during development and testing. They are automatically removed in the production code at runtime so that it won’t slow the execution of the program.
It helps remove boilerplate code and make code more readable.
Refactors and optimizes code with increased confidence that it functions correctly.

When to use Assertions

1. Unreachable codes

Unreachable codes are codes that do not execute when we try to run the program. Use assertions to make sure unreachable codes are actually unreachable.

void unreachableCodeMethod() < System.out.println("Reachable code"); return; // Unreachable code System.out.println("Unreachable code"); assert false; >

Let’s take another example of a switch statement without a default case.

The above switch statement indicates that the days of the week can be only one of the above 7 values. Having no default case means that the programmer believes that one of these cases will always be executed.

However, there might be some cases that have not yet been considered where the assumption is actually false.

This assumption should be checked using an assertion to make sure that the default switch case is not reached.

default: assert false: dayofWeek + " is invalid day";

If dayOfWeek has a value other than the valid days, an AssertionError is thrown.

2. Documenting assumptions

To document their underlying assumptions, many programmers use comments. Let’s take an example.

Comments can get out-of-date and out-of-sync as the program grows. However, we will be forced to update the assert statements; otherwise, they might fail for valid conditions too.

When not to use Assertions

1. Argument checking in public methods

Arguments in public methods may be provided by the user.

So, if an assertion is used to check these arguments, the conditions may fail and result in AssertionError .

Instead of using assertions, let it result in the appropriate runtime exceptions and handle these exceptions.

2. To evaluate expressions that affect the program operation

Do not call methods or evaluate exceptions that can later affect the program operation in assertion conditions.

Let us take an example of a list weekdays which contains the names of all the days in a week.

 ArrayList weekdays = new ArrayList<>(Arrays.asList("Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" )); ArrayList weekends= new ArrayList<>(Arrays.asList("Sunday", "Saturday" )); assert weekdays.removeAll(weekends);

Here, we are trying to remove elements Saturday and Sunday from the ArrayList weekdays .

If the assertion is enabled, the program works fine. However, if assertions are disabled, the elements from the list are not removed. This may result in program failure.

Instead, assign the result to a variable and then use that variable for assertion.

ArrayList weekdays = new ArrayList<>(Arrays.asList("Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" )); ArrayList weekends= new ArrayList<>(Arrays.asList("Sunday", "Saturday" )); boolean weekendsRemoved = weekdays.removeAll(weekends); assert weekendsRemoved;

In this way, we can ensure that all the weekends are removed from the weekdays regardless of the assertion being enabled or disabled. As a result, it does not affect the program operation in the future.

Источник

Java Assertion

In Java, Assertion is a statement that ensures or tests the correctness of the assumptions made in a program. It is done with the help of the assert statement. When the written assumption is executed, it is considered as true. If it is false, an assertion error will be thrown by the Java Virtual Machine.

Web development, programming languages, Software testing & others

The main reasons why Assertions are used are:

To confirm whether an unreachable code is reachable.
To check whether the assumptions available in the comments are correct or not.
To confirm, the default case in the switch is not reached.
After the invocation of a method.
To check the state of an object.

Below is the syntax of the Java Assertion statement.

Any of these syntaxes can be used based on the requirement.

How does Assertion work in Java?

As already mentioned, assert can be written in two forms.

The syntax asserts expression; is used in order to test the expressions of Boolean form. If the particular expression is false, the program gets terminated by throwing an AssertionError. Unlike the normal exceptions, these errors are disabled during runtime.
However, the syntax asserts expr1: expr2; it is used in cases where the program has some extra information that helps diagnose certain failures.
Similar to the uncaught exceptions in Java, assertion errors are commonly labeled in stack trace along with the file as well as line number from which the exception is thrown.

Even though these are the main pros of Assertion, there are certain situations where Assertions should not be used. They are:

Error message replacement.
Argument checking in public methods
Command-line arguments.

java –enable assertions programname

Steps to use Eclipse Java Assertion

In Eclipse, it can be done using the below steps.

Step 1: Select Run Configurations.

Step 2: Go to the left panel and select Java Application, and Right-click on it.

Step 3: Select New configuration and type –ea on VM Arguments. Once it is done, click.

Similarly, assertions can be disabled using the syntax given below. Java –da programname

Examples to Implement Java Assertion

Now, let us see some sample programs for the assertion in order to get a clear idea of the same.

Example #1

Java program to check whether a particular value is higher than 20.

class AssertionExample< public static void main( String args[] )< int val = 14; assert val>=20:" Value is not valid"; System.out.println("The given value is: "+ val); > >

It can be clearly seen that assertion is not checked here since the value is greater than 20 is not checked.
In order to enable assertion, -ea has to be set before compiling. For that, perform the steps mentioned in NOTE.
If you again try to run the code, it can be clearly seen that an AssertionError has been thrown since the value is less than 20.

Example #2

Java program to check whether a particular user input value is higher than 20.

import java.util.Scanner; class AssertionExample< public static void main( String args[] )< Scanner sc = new Scanner( System.in ); System.out.print("Enter a number to check assertion "); //store the input value to the variable val int val = sc.nextInt(); //assertion check whether the input value is greater than 20 assert val>=20:" Value is not valid"; System.out.println("The given value is: "+ val); > >

The user will be asked to input a number on executing the code. In the below result, the number 13 is given as input. Since it is less than 20, an AssertionError has been thrown.

At the same time, when a value which is greater than 20 is given, no errors are thrown, and the message gets displayed.

Example #3

Java program to check the number of days in a week.

class AssertionExample < //main method public static void main(String args[]) < //declare a string days String[] days = ; //set the assertion as 7 assert days.length==7 : "7 days are present in a week, Your input is wrong"; //print the line below System.out.println("There are " + days.length + " days in a week"); > >

On executing the code, an assertion error is thrown as the number of days in a week is 7, and the string input given contains more than that.

Yes. The line gets printed as the assertion value satisfies the input value.

Advantages of using Assertion in Java

The following are the main advantages of using Assertion.

Efficient detection and correction of bugs.
Boilerplate code will be removed and helps in creating a readable code.
Execution time won’t be affected since it gets removed automatically during runtime.
Quick bug detection and correction.
Code optimization and refactoring is done with high confidence in order to function correctly.

In addition to the above points, below are the important points that have to be known while studying Assertions.

An assertion in Java is introduced in the version JDK 1.4
Assert is the keyword used in order to implement assertion.
Enabling and disabling of assertion can be done at runtime with the help of corresponding syntaxes.
Even though assertion compliments the exception, it does not replace the exception.
It does not replace the unit testing even if it helps in the validation of conditions.
Never use assertion for arguments or parameters validation of a method that is public.

Conclusion

Java Assertion is a statement that checks the trueness of a particular condition. It is commonly used in testing during software development. Moreover, they are used with certain Boolean expressions. In this article, several aspects such as syntax, working, pros, cons, and examples of Assertion is explained in detail.