The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

JUnit

Next ►
►

JUnit is a popular testing framework for Java that allows developers to write and run repeatable tests. It is an essential tool for ensuring the quality and reliability of your code. In this section, we will cover the basics of JUnit, how to set it up, and how to write and run tests.

What is JUnit?

JUnit is a unit testing framework for Java programming language. It plays a crucial role in test-driven development (TDD) and is widely used for writing and running tests. JUnit provides annotations to identify test methods and assertions to test expected results.

Key Features of JUnit:

  • Annotations: Simplify the process of writing tests.
  • Assertions: Provide methods to test expected results.
  • Test Runners: Execute tests and report results.
  • Test Suites: Group multiple test cases.

Setting Up JUnit

To use JUnit, you need to add it to your project. If you are using a build tool like Maven or Gradle, you can add JUnit as a dependency.

Adding JUnit with Maven

Add the following dependency to your pom.xml file:

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
    <scope>test</scope>
</dependency>

Adding JUnit with Gradle

Add the following dependency to your build.gradle file:

testImplementation 'junit:junit:4.13.2'

Writing Your First Test

Let's start by writing a simple test case. We'll create a class Calculator with a method add and write a test for it.

Calculator Class

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

Test Class

Create a test class CalculatorTest:

import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class CalculatorTest {

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

Explanation

  • @Test: This annotation identifies the testAdd method as a test method.
  • assertEquals: This assertion checks if the expected result (5) matches the actual result.

Running Tests

You can run JUnit tests in various ways:

  • IDE: Most IDEs like IntelliJ IDEA, Eclipse, and NetBeans have built-in support for running JUnit tests.
  • Command Line: You can use Maven or Gradle to run tests from the command line.

Running Tests in IntelliJ IDEA

  1. Right-click on the test class or method.
  2. Select "Run 'CalculatorTest'".

Running Tests with Maven

Execute the following command in the terminal:

mvn test

Common Annotations

JUnit provides several annotations to control the test lifecycle:

  • @Before: Runs before each test method.
  • @After: Runs after each test method.
  • @BeforeClass: Runs once before any test methods in the class.
  • @AfterClass: Runs once after all test methods in the class.
  • @Ignore: Ignores the test method.

Example

import org.junit.*;

public class LifecycleTest {

    @BeforeClass
    public static void beforeClass() {
        System.out.println("Before Class");
    }

    @AfterClass
    public static void afterClass() {
        System.out.println("After Class");
    }

    @Before
    public void before() {
        System.out.println("Before Test");
    }

    @After
    public void after() {
        System.out.println("After Test");
    }

    @Test
    public void test1() {
        System.out.println("Test 1");
    }

    @Test
    public void test2() {
        System.out.println("Test 2");
    }
}

Output

Before Class
Before Test
Test 1
After Test
Before Test
Test 2
After Test
After Class

Assertions

JUnit provides various assertion methods to test expected results:

  • assertEquals(expected, actual): Checks if two values are equal.
  • assertTrue(condition): Checks if a condition is true.
  • assertFalse(condition): Checks if a condition is false.
  • assertNull(object): Checks if an object is null.
  • assertNotNull(object): Checks if an object is not null.
  • assertArrayEquals(expectedArray, actualArray): Checks if two arrays are equal.

Example

import org.junit.Test;
import static org.junit.Assert.*;

public class AssertionTest {

    @Test
    public void testAssertions() {
        // Test data
        String str1 = new String("abc");
        String str2 = new String("abc");
        String str3 = null;
        String str4 = "abc";
        String str5 = "abc";

        int val1 = 5;
        int val2 = 6;

        String[] expectedArray = {"one", "two", "three"};
        String[] resultArray = {"one", "two", "three"};

        // Check that two objects are equal
        assertEquals(str1, str2);

        // Check that a condition is true
        assertTrue(val1 < val2);

        // Check that a condition is false
        assertFalse(val1 > val2);

        // Check that an object isn't null
        assertNotNull(str1);

        // Check that an object is null
        assertNull(str3);

        // Check if two object references point to the same object
        assertSame(str4, str5);

        // Check if two object references do not point to the same object
        assertNotSame(str1, str3);

        // Check whether two arrays are equal to each other.
        assertArrayEquals(expectedArray, resultArray);
    }
}

Practical Exercise

Exercise 1: Write a Test for a Subtraction Method

  1. Create a Calculator class with a subtract method.
  2. Write a test class CalculatorTest with a test method testSubtract.
  3. Use assertions to verify the result.

Solution

Calculator Class

public class Calculator {
    public int subtract(int a, int b) {
        return a - b;
    }
}

Test Class

import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class CalculatorTest {

    @Test
    public void testSubtract() {
        Calculator calculator = new Calculator();
        int result = calculator.subtract(5, 3);
        assertEquals(2, result);
    }
}

Conclusion

In this section, we covered the basics of JUnit, including setting it up, writing and running tests, and using common annotations and assertions. JUnit is a powerful tool for ensuring the quality and reliability of your code, and mastering it is essential for any Java developer. In the next module, we will explore more advanced topics in Java programming.

◄ Previous
◄
Next ►
►

Java Programming Course

Module 1: Introduction to Java

Module 2: Control Flow

Module 3: Object-Oriented Programming

Module 4: Advanced Object-Oriented Programming

Module 5: Data Structures and Collections

Module 6: Exception Handling

Module 7: File I/O

Module 8: Multithreading and Concurrency

Module 9: Networking

Module 10: Advanced Topics

Module 11: Java Frameworks and Libraries

Module 12: Building Real-World Applications

The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved