15.4. JUnit Basics

JUnit 5 Annotations

JUnit 5 provides a set of annotations that help define tests and the order in which they are executed. The @Test annotation indicates that a method is a test case, which JUnit runs to verify the correctness of code. @BeforeEach and @AfterEach are executed before and after each test method, respectively, allowing for setup and cleanup operations that need to be performed for each test, such as initializing objects or clearing resources. @BeforeAll and @AfterAll are used for methods that should run once for the entire test class, allowing initial setup or final teardown that applies to all tests. The @Disabled annotation can be used to temporarily skip a test method during execution.

Think of a class in school where each student performs an experiment (test). Each time a student (test case) is about to conduct their experiment, the teacher (JUnit) prepares the class by ensuring materials are set up beforehand (setup using @BeforeEach). After each experiment, they clean up (cleanup using @AfterEach). If a student needs to run an experiment only once for the class, they do it at the beginning (using @BeforeAll) or at the end (using @AfterAll). If someone decides not to perform their experiment today (skipping with @Disabled), it's recorded, but they aren’t required to participate in that class's session.

JUnit Assertions

• assertEquals(expected, actual)
• assertTrue(condition)
• assertFalse(condition)
• assertNull(value)
• assertNotNull(value)
• assertThrows(Exception.class, () -> method())

Assertions in JUnit are used to verify that the code behaves as expected. The assertEquals method checks if the expected value is equal to the actual value; if not, the test fails. The assertTrue and assertFalse methods evaluate a boolean condition and fail the test if the condition is not satisfied. assertNull and assertNotNull ensure that a value is or isn’t null, which is critical to avoid null pointer exceptions. Lastly, assertThrows checks if a specific exception occurs when executing a block of code, which is important for testing error handling mechanisms in your code.

Imagine you're a teacher grading students' exams. Using assert is like defining what a correct answer looks like. When you check assertEquals, you are comparing the student's answer (actual) to the correct answer (expected). If they wrote '4' for a math question but the answer is '5', the assertEquals will let you know there’s a mistake. When ensuring students answered correctly (using assertTrue or assertFalse), you're confirming if their statements are factually correct. When verifying if students wrote an answer (using assertNotNull), you're checking if they provided a response at all. assertThrows is like saying, 'If you don’t write an answer for a question, what happens?' This confirms expected behavior happens when the student deviates from instructions.

Example: Basic Unit Test Using JUnit

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class CalculatorTest {
    @Test
    void testAddition() {
        Calculator calc = new Calculator();
        assertEquals(5, calc.add(2, 3));
    }
}

This example demonstrates a basic unit test written using JUnit. The CalculatorTest class contains a single test method, testAddition. The method is annotated with @Test, indicating that it is a test case. Inside the method, a Calculator object is created, and the add method is invoked with the parameters 2 and 3. The test then asserts that the result matches the expected value of 5 using the assertEquals assertion. If the implementation of the add functionality is correct, the test will pass; otherwise, it will fail, signaling an issue in the code.

Think of this unit test like a baking test. You’re trying to bake cookies (the method being tested) using a specific recipe (the add method). The test checks if the result matches what a perfect cookie should look like (expected result of 5). Each time you try a different recipe (a new value you test), you're confirming whether your baking skills are on point. If you follow the recipe and the cookies come out perfectly, you celebrate and continue baking (the test passes). But if they come out burnt or raw (the test fails), you know you need to adjust something in your method (code).

--