Table of contents
1.
Introduction
2.
Assertions in Java
3.
Two different ways
3.1.
1. Using the assert keyword:
3.2.
2. Using the Assert class
4.
Example
4.1.
Java
5.
Enabling Assertions
5.1.
1. Enabling assertions for a specific class
5.2.
2. Enabling assertions for a package and its subpackages
5.3.
3. Enabling assertions for the entire application
6.
Disabling Assertions
6.1.
1. Disabling assertions for a specific class
6.2.
2. Disabling assertions for a package and its subpackages
6.3.
3. Disabling assertions for the entire application:
7.
Why use Assertions
7.1.
1. Detecting logical errors early
7.2.
2. Documenting assumptions
7.3.
3. Debugging aid
7.4.
4. Improving code quality
7.5.
5. Enabling safe refactoring
8.
Assertion Vs Normal Exception Handling:
9.
Where to use Assertions
9.1.
1. Validating method preconditions
9.2.
2. Verifying postconditions
9.3.
3. Checking invariants
9.4.
4. Debugging and testing
9.5.
5. Documenting assumptions
10.
Where not to use Assertions
10.1.
1. Handling expected errors
10.2.
2. Validating user input
10.3.
3. Checking for resource availability
10.4.
4. Performance-critical code
10.5.
5. Production environments
11.
Example
11.1.
Java
12.
Frequently Asked Questions
12.1.
What happens if an assertion fails?
12.2.
Can assertions be used for input validation?
12.3.
Should assertions be enabled in production environments?
13.
Conclusion
Last Updated: Jul 20, 2024
Easy

Java Assert

Author Sinki Kumari
0 upvote
Career growth poll
Do you think IIT Guwahati certified course can help you in your career?

Introduction

Java is a popular programming language used by developers worldwide. It offers many features that make it a powerful tool for creating robust & efficient applications. One such feature is the assert keyword, which allows developers to add assertions to their code. Assertions are statements that check the validity of certain conditions & can help catch bugs early in the development process. 

Java Assert

In this article, we will learn what assertions are, how to use them in Java, & when they can be most effective.

Assertions in Java

In Java, an assertion is a statement that assumes something to be true. It is used to test your assumptions about the program. If the assumption is true, the assertion does nothing. However, if the assumption is false, the assertion throws an AssertionError exception. 

The syntax for an assertion in Java is:

assert condition;


or

assert condition : expression;


Here, the condition is a boolean expression that you assume to be true. If the condition evaluates to true, the assertion passes silently. If the condition evaluates to false, an AssertionError is thrown.

The optional expression after the colon is a message that is passed to the AssertionError constructor & is used to provide additional information about the failure.

Two different ways

There are two different ways to use assertions in Java:

1. Using the assert keyword:

As mentioned earlier, you can use the assert keyword followed by a boolean condition & an optional error message. Here's an example:

public void divide(int a, int b) {
    assert b != 0 : "Division by zero!";
    int result = a / b;
    System.out.println(result);
}


In this example, the assertion checks if the denominator (b) is not equal to zero. If b is zero, an AssertionError will be thrown with the message "Division by zero!".

2. Using the Assert class

Java also provides an Assert class in the org.junit.Assert package. This class offers various static methods for asserting conditions. Here's an example:

import org.junit.Assert;
public void testSum() {
    int a = 5;
    int b = 10;
    int sum = a + b;
    Assert.assertEquals(15, sum);
}


In this example, the assertEquals method from the Assert class is used to check if the sum of a & b equals 15. If the assertion fails, an AssertionError will be thrown.

Example

Let’s look at a more detailed example that demonstrates the usage of assertions in Java:

  • Java

Java

public class AssertionExample {
public static void main(String[] args) {
int[] numbers = {1, 2, 3, 4, 5};
assert numbers.length == 5 : "Array length is not 5";

for (int i = 0; i < numbers.length; i++) {
assert numbers[i] > 0 : "Number is not positive: " + numbers[i];
System.out.println(numbers[i]);
}

String str = null;
assert str != null : "String is null";

int result = divide(10, 2);
assert result == 5 : "Division result is incorrect";

System.out.println("All assertions passed!");
}

public static int divide(int a, int b) {
assert b != 0 : "Division by zero!";
return a / b;
}
}
You can also try this code with Online Java Compiler
Run Code


Output

1
2
3
4
5
All assertions passed!


In this example:

1. We have an array of numbers & an assertion to check if the array length is 5.
 

2. Inside the loop, we assert that each number is positive.
 

3. We intentionally assign null to the str variable & assert that it is not null.
 

4. We call the divide method with arguments 10 & 2, & assert that the result is 5.
 

5. If all assertions pass, the message "All assertions passed!" will be printed.


If any of the assertions fail, an AssertionError will be thrown, & the corresponding error message will be displayed.

Enabling Assertions

By default, assertions are disabled in Java. To enable assertions, you need to use the -enableassertions or -ea option when running the Java program from the command line. 

Here's how you can enable assertions:

 

1. Enabling assertions for a specific class

   java -ea:MyClass MyClass


This enables assertions only for the MyClass class.

2. Enabling assertions for a package and its subpackages

   java -ea:com.example... MyClass


This enables assertions for all classes in the com.example package and its subpackages.

3. Enabling assertions for the entire application

   java -ea MyClass


This enables assertions for all classes in the application.

You can also use the -enablesystemassertions or -esa option to enable assertions in system classes.

It's important to note that assertions should be used for debugging purposes and not for handling expected errors or normal program flow control. Assertions are typically disabled in production code to avoid performance overhead.

Disabling Assertions

Just as you can enable assertions, you can also disable them using the -disableassertions or -da option when running the Java program. Here are a few ways to disable assertions:

1. Disabling assertions for a specific class

   java -da:MyClass MyClass


This disables assertions only for the MyClass class.

2. Disabling assertions for a package and its subpackages

   java -da:com.example... MyClass


This disables assertions for all classes in the com.example package and its subpackages.

3. Disabling assertions for the entire application:

   java -da MyClass


This disables assertions for all classes in the application.

You can also use the -disablesystemassertions or -dsa option to disable assertions in system classes.

It's important to remeber that you can have a mix of enabled and disabled assertions in your application. For example, you can enable assertions for a specific package while disabling them for others.

Disabling assertions can be useful when you want to run the application without the overhead of assertion checks, especially in production environments where performance is critical.

Why use Assertions

Let’s look at some reasons why you should use assertions in your Java programs:

1. Detecting logical errors early

Assertions help detect logical errors and inconsistencies in your code at runtime. By placing assertions at critical points in your program, you can verify that certain conditions are met and that your assumptions about the state of the program are correct. If an assertion fails, it indicates a bug in your code that needs to be fixed.

2. Documenting assumptions

Assertions serve as a form of documentation for your code. They make your assumptions explicit and clear to other developers (including yourself) who may read or maintain the code in the future. Assertions help convey the expected behavior and invariants of your program.

3. Debugging aid

When an assertion fails, it provides valuable information about the location and cause of the problem. Assertions can help narrow down the search for bugs by pinpointing the specific line of code where the issue occurred. This can save significant time and effort during the debugging process.

4. Improving code quality

By using assertions consistently throughout your codebase, you can improve the overall quality and reliability of your program. Assertions act as a safety net, catching potential issues before they propagate and cause more severe problems down the line.

5. Enabling safe refactoring

Assertions can provide confidence when refactoring code. If you have a comprehensive set of assertions in place, you can make changes to your code with the assurance that any violations of the expected behavior will be caught by the assertions.

It's important to keep in mind that assertions should not be used for handling expected errors or normal program flow control. They are meant to catch programming errors and should be used judiciously to validate critical assumptions in your code.

Assertion Vs Normal Exception Handling:

Assertion

Normal Exception Handling

Assertions are used to detect logical errors and inconsistencies in the code.Exceptions are used to handle anticipated or unexpected error conditions that may occur during program execution.
Assertions are typically used during development and debugging phases.Exceptions are used in both development and production environments.
Assertions are disabled by default in production code for performance reasons.Exceptions are always enabled and are an integral part of the program's flow control.
Assertions are not meant to be caught or handled by the program.Exceptions can be caught and handled using try-catch blocks or propagated up the call stack.
Assertions are used to validate assumptions and preconditions within the code.Exceptions are used to handle error scenarios and gracefully recover from them.
If an assertion fails, it indicates a bug in the code that needs to be fixed.If an exception occurs, it can be caught and handled, allowing the program to continue execution or perform necessary cleanup actions.
Assertions should not be used for handling expected errors or normal program flow control.Exceptons are suitable for handling both expected and unexpected error conditions.

 

Where to use Assertions

Assertions are a useful tool for catching bugs and ensuring the correctness of your code. 

Let’s see the situations where we can use assertions effectively:

1. Validating method preconditions

Use assertions to check the validity of method parameters and ensure that they meet the expected conditions. For example:

   public void processData(String input) {
       assert input != null : "Input cannot be null";
       // Method logic goes here
   }

2. Verifying postconditions

Use assertions to check the state of objects or variables after a method completes its execution. This helps ensure that the method has performed its intended task correctly. For example:

   public int calculateSum(int a, int b) {
       int sum = a + b;
       assert sum >= a && sum >= b : "Sum should be greater than or equal to the operands";
       return sum;
   }

3. Checking invariants

Use assertions to verify that certain invariants or conditions hold true at specific points in your code. This can help catch logical errors and maintain the integrity of your program. For example:

   public void addElement(int element) {
       // Adding element to a list
       list.add(element);
       assert list.size() > 0 : "List should not be empty after adding an element";
   }

4. Debugging and testing

 Assertions can be valuable during the debugging and testing phases of development. You can temporarily add assertions to verify the state of variables, check the flow of execution, or ensure that certain conditions are met at critical points in your code.

5. Documenting assumptions

 Use assertions to document important assumptions made in your code. This helps other developers (including yourself) understand the expected behavior and catch any violations of those assumptions.

Remember, assertions should be used carefully and not as a replacement for proper error handling or input validation. They are meant to catch programming errors and should not be relied upon for handling expected error conditions.

Where not to use Assertions

While assertions are a powerful tool for catching bugs and ensuring code correctness, there are certain situations where you should avoid using them.Let’s see where you should not use assertions:

1. Handling expected errors

Assertions should not be used to handle expected error conditions or to control the normal flow of the program. For example, if you expect a method to throw an exception under certain conditions, you should use regular exception handling mechanisms (try-catch blocks) instead of assertions.

2. Validating user input

Assertions should not be used to validate user input or external data. User input should be validated using appropriate input validation techniques, such as checking for null values, validating data formats, or using regular expressions. Assertions are meant for catching programming errors, not for handling invalid user input.

3. Checking for resource availability

 Assertions should not be used to check for the availability of external resources, such as files, databases, or network connections. These resources may not be available due to factors outside the control of your program, and using assertions to check for their presence can lead to unexpected behavior. Instead, use appropriate error handling and exception mechanisms to handle resource-related issues.

4. Performance-critical code

 Assertions introduce runtime overhead, especially when enabled. In performance-critical sections of your code, excessive use of assertions can impact the overall performance of your application. Be mindful of the performance implications and use assertions judiciously in such scenarios.

5. Production environments

 Assertions are typically disabled in production environments to avoid the performance overhead they introduce. Therefore, you should not rely on assertions for critical functionality or error handling in production code. Use regular exception handling and logging mechanisms to handle errors and maintain the stability of your application.

It's important to distinguish between the role of assertions and other error handling mechanisms in your code. Assertions are primarily a development and debugging tool, while exceptions and error handling are essential for managing expected and unexpected error conditions in both development and production environments.

Example

Let’s look at a proper example that shows the appropriate use of assertions in a Java program:

  • Java

Java

public class BankAccount {

   private double balance;

   public BankAccount(double initialBalance) {

       assert initialBalance >= 0 : "Initial balance cannot be negative";

       balance = initialBalance;

   }

   public void deposit(double amount) {

       assert amount > 0 : "Deposit amount must be positive";

       balance += amount;

   }

   public void withdraw(double amount) {

       assert amount > 0 : "Withdrawal amount must be positive";

       assert balance >= amount : "Insufficient funds";

       balance -= amount;

   }

   public double getBalance() {

       return balance;

   }

}

public class Main {

   public static void main(String[] args) {

       BankAccount account = new BankAccount(1000);

       System.out.println("Initial balance: " + account.getBalance());

       account.deposit(500);

       System.out.println("Balance after deposit: " + account.getBalance());

       account.withdraw(200);

       System.out.println("Balance after withdrawal: " + account.getBalance());

       // Uncomment the following line to trigger an assertion error

       // account.withdraw(2000);

   }

}
You can also try this code with Online Java Compiler
Run Code

 

Output

Initial balance: 1000.0
Balance after deposit: 1500.0
Balance after withdrawal: 1300.0


In this example, we have a `BankAccount` class that represents a simple bank account with methods for depositing and withdrawing money. We use assertions to validate the following conditions:

1. In the constructor, we assert that the initial balance is not negative.
 

2. In the `deposit` method, we assert that the deposit amount is positive.
 

3. In the `withdraw` method, we assert that the withdrawal amount is positive and that the account has sufficient funds.
 

In the `Main` class, we create an instance of `BankAccount` with an initial balance of 1000. We then perform a deposit of 500 and a withdrawal of 200, printing the balance after each operation.

If we uncomment the line `account.withdraw(2000)`, it will trigger an assertion error because the withdrawal amount exceeds the available balance.

This example demonstrates how assertions can be used to validate preconditions, postconditions, and invariants in a Java program. By using assertions, we can catch logical errors early and ensure the correctness of our code.

Frequently Asked Questions

What happens if an assertion fails?

If an assertion fails, an AssertionError is thrown, indicating that a logical error or inconsistency has been detected in the code.

Can assertions be used for input validation?

No, assertions should not be used for input validation. Input validation should be handled using appropriate techniques such as null checks, data format validation, or regular expressions.

Should assertions be enabled in production environments?

No, assertions are typically disabled in production environments to avoid performance overhead. Assertions are primarily used during development and debugging phases.

Conclusion

In this article, we discussed the concept of assertions in Java. We learned that assertions are a powerful tool for detecting logical errors and inconsistencies in code during development and debugging. We explained how to enable and disable assertions, when to use them effectively, and situations where assertions should be avoided. With the help of  assertions, we can improve the quality and reliability of our Java programs. However, it's important to remember that assertions are not a substitute for proper error handling and should be used in accordance with other debugging and testing techniques.

You can also practice coding questions commonly asked in interviews on Coding Ninjas Code360

Also, check out some of the Guided Paths on topics such as Data Structure and AlgorithmsCompetitive ProgrammingOperating SystemsComputer Networks, DBMSSystem Design, etc., as well as some Contests, Test Series, and Interview Experiences curated by top Industry Experts.

Live masterclass