Corporate Training
Request Demo
Click me
Let's Talk
Request Demo


Unit Testing with JUnit

25. Unit Testing with JUnit

JUnit is a popular testing framework for Java that enables developers to write and run unit tests for their code. Unit tests are small, focused tests that verify the correctness of individual components or units of code, such as classes or methods. In this Core Java tutorial, we'll explore unit testing with JUnit in detail, providing explanations and examples.

Setting Up JUnit:

Before you can start writing unit tests with JUnit, you need to set up your development environment by including the JUnit library in your project. Here are the steps to set up JUnit in a typical Java project:

  • Add JUnit to Your Build Tool: If you're using a build tool like Maven or Gradle, you can specify JUnit as a dependency in your project's build file. For example, in a Maven 'pom.xml':
        <version>4.13.2</version> <!-- Use the latest version -->

  • Download and Add JUnit JAR: If you're not using a build tool, you can download the JUnit JAR files from the official JUnit website ( and add them to your project's classpath.

Writing a Simple Test Case:

Once you've set up JUnit, you can start writing test cases. Test cases in JUnit are written as methods in a test class. A test method typically follows a naming convention where it starts with "test" and contains assertions to check the expected behavior of the code being tested.

Example of a Simple Test Case:

Suppose you have a simple 'Calculator' class with an 'add' method, and you want to write a test case for it.
import org.junit.Test;
import static org.junit.Assert.*;

public class CalculatorTest {

    public void testAdd() {
        Calculator calculator = new Calculator();
        int result = calculator.add(2, 3);
        assertEquals(5, result);

In this example, we create a 'CalculatorTest' class with a single test method named 'testAdd'. We create an instance of the 'Calculator'class, call the 'add' method with two integers, and use 'assertEquals' to assert that the result is equal to 5.

JUnit Annotations:

JUnit provides several annotations that you can use to define test methods and perform setup and teardown operations. Some commonly used annotations include:

  • '@Test': Marks a method as a test method.
  • '@Before': Marks a method to run before each test method.
  • '@After': Marks a method to run after each test method.
  • '@BeforeClass': Marks a method to run once before all test methods in the test class.
  • '@AfterClass': Marks a method to run once after all test methods in the test class.
Example Using Setup and Teardown Methods:
class MyClass {

    @MyAnnotation(value = "Custom value", count = 5)
    public void myMethod() {
        // Custom method implementation

In this example, we use the '@Before' and '@After'annotations to create a new 'Calculator' instance before each test and set it to 'null' after each test, ensuring a clean state for each test method.

Running Tests:

To run JUnit tests, you can use an integrated development environment (IDE) that supports JUnit, or you can use the 'junit' command-line tool.

  • Running tests in an IDE typically involves right-clicking the test class and selecting "Run" or "Run as JUnit test."

  • To run tests from the command line, you can use the 'junit' or 'java' 'org.junit.runner.JUnitCore'command, passing the name of the test class as an argument.
import java.lang.reflect.*;

class MyClass {
    private String privateField;

    public void publicMethod() {
        System.out.println("Public method");

    private void privateMethod() {
        System.out.println("Private method");

public class ReflectionExample {
    public static void main(String[] args) throws Exception {
        Class clazz = MyClass.class;

        // Get all methods, including private ones
        Method[] methods = clazz.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println("Method name: " + method.getName());
            System.out.println("Is private: " + Modifier.isPrivate(method.getModifiers()));

        // Access private field
        Field field = clazz.getDeclaredField("privateField");
        MyClass instance = new MyClass();
        field.set(instance, "Reflection");
        System.out.println("Private field value: " + field.get(instance));


JUnit provides a set of assertion methods in the 'org.junit.Assert' class to check whether the actual results match the expected results. Some commonly used assertion methods include:

  • 'assertEquals(expected, actual)': Asserts that two values are equal.
  • 'assertTrue(condition)': Asserts that a condition is true.
  • 'assertFalse(condition)': Asserts that a condition is false.
  • 'assertNull(object)': Asserts that an object is null.
  • 'assertNotNull(object)': Asserts that an object is not null.

Benefits of Unit Testing with JUnit:

Unit testing with JUnit offers several benefits:

  • Detecting Bugs Early: Unit tests can catch bugs and issues early in the development cycle, making them easier and less costly to fix.

  • Maintaining Code Quality: Tests serve as documentation for code behavior, making it easier for developers to understand and maintain code.

  • Regression Testing: Unit tests provide a safety net that allows you to catch regressions when making changes to your code.

  • Encouraging Good Practices: Writing tests encourages good coding practices, such as modular and testable code design.

  • Support for Continuous Integration: Automated tests, including unit tests, can be integrated into a continuous integration (CI) pipeline to ensure code quality.


JUnit is a widely used framework for writing and running unit tests in Java. It provides a simple and effective way to ensure the correctness of your code by testing individual components in isolation. By following best practices for unit testing, you can improve the quality and reliability of your Java applications.