Unit testing concept in JUnit

Introduction

Unit testing helps check small parts of your code to make sure they work right. It finds mistakes early so fixing is easier.

When you write a new function and want to check it works as expected.

Before adding big changes to your code to avoid breaking things.

When fixing bugs to confirm the fix works and nothing else breaks.

To make sure each part of your program does its job correctly.

When you want to automate checks so you don't test manually every time.

Syntax

JUnit

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

class MyClassTest {
    @Test
    void testMethod() {
        // Arrange
        MyClass obj = new MyClass();
        
        // Act
        int result = obj.methodToTest();
        
        // Assert
        int expectedValue = 0; // define expectedValue appropriately
        assertEquals(expectedValue, result);
    }
}

Use @Test annotation to mark a method as a test.

Assertions like assertEquals check if the result matches what you expect.

Examples

This test checks if adding 2 and 3 returns 5.

JUnit

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

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

This test checks if the isEmpty method correctly identifies empty and non-empty strings.

JUnit

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

class StringUtilsTest {
    @Test
    void testIsEmpty() {
        assertTrue(StringUtils.isEmpty(""));
        assertFalse(StringUtils.isEmpty("abc"));
    }
}

Sample Program

This test checks if multiplying 4 by 5 returns 20 using the multiply method.

JUnit

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

class MathUtils {
    int multiply(int a, int b) {
        return a * b;
    }
}

class MathUtilsTest {
    @Test
    void testMultiply() {
        MathUtils math = new MathUtils();
        int result = math.multiply(4, 5);
        assertEquals(20, result);
    }
}

Important Notes

Write one test for each small piece of code (method or function).

Keep tests simple and clear to understand.

Run tests often to catch problems early.

Summary

Unit tests check small parts of code to find errors early.

Use @Test and assertions like assertEquals in JUnit.

Good unit tests make your code more reliable and easier to fix.

Practice

1. What is the main purpose of a unit test in JUnit?

easy

A. To check small parts of code for errors early

B. To test the entire application at once

C. To deploy the application automatically

D. To write documentation for the code

Solution

1. Step 1: Understand unit test scope

   Unit tests focus on small parts or units of code, not the whole app.

2. Step 2: Identify main goal

   The goal is to find errors early by testing these small parts individually.

3. Final Answer:

   To check small parts of code for errors early -> Option A

4. Quick Check:

   Unit test purpose = check small code parts early [OK]

Hint: Unit tests check small code parts, not whole app [OK]

Common Mistakes:

• Confusing unit tests with integration or system tests
• Thinking unit tests deploy or document code
• Assuming unit tests cover the entire application

2. Which annotation is used in JUnit to mark a method as a test?

easy

A. @Run

B. @Assert

C. @Test

D. @Check

Solution

1. Step 1: Recall JUnit test annotation

   JUnit uses @Test to mark methods as tests.

2. Step 2: Verify other options

   @Run, @Check, and @Assert are not valid JUnit test annotations.

3. Final Answer:

   @Test -> Option C

4. Quick Check:

   JUnit test method = @Test annotation [OK]

Hint: JUnit test methods use @Test annotation [OK]

Common Mistakes:

• Using @Run instead of @Test
• Confusing @Assert with test annotation
• Assuming @Check is a JUnit annotation

3. What will be the result of this JUnit test?

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

public class CalcTest {
    @Test
    void testSum() {
        int result = 2 + 3;
        assertEquals(5, result);
    }
}

medium

A. Test passes successfully

B. Test fails with assertion error

C. Compilation error due to missing import

D. Runtime exception occurs

Solution

1. Step 1: Analyze the test logic

   The test calculates 2 + 3 and stores 5 in result.

2. Step 2: Check assertion

   assertEquals(5, result) compares expected 5 with actual 5, so it matches.

3. Final Answer:

   Test passes successfully -> Option A

4. Quick Check:

   2+3=5 matches expected 5 [OK]

Hint: If expected equals actual, test passes [OK]

Common Mistakes:

• Assuming test fails when values match
• Thinking import is missing (it's present)
• Expecting runtime errors without cause

4. Identify the error in this JUnit test code:

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

public class SampleTest {
    @Test
    public void testMultiply() {
        int result = 3 * 4
        assertEquals(12, result);
    }
}

medium

A. Incorrect import statement

B. Wrong assertion method used

C. Test method missing @Test annotation

D. Missing semicolon after multiplication statement

Solution

1. Step 1: Check syntax in testMultiply method

   The line 'int result = 3 * 4' is missing a semicolon at the end.

2. Step 2: Verify other parts

   @Test annotation is present, assertion method is correct, imports are correct.

3. Final Answer:

   Missing semicolon after multiplication statement -> Option D

4. Quick Check:

   Java statements need semicolons [OK]

Hint: Look for missing semicolons in Java test methods [OK]

Common Mistakes:

• Ignoring missing semicolon errors
• Thinking @Test annotation is missing
• Assuming wrong assertion method

5. You want to write a unit test that checks if a method throws an exception when given invalid input. Which JUnit 5 feature should you use?

hard

A. Use @BeforeEach to catch exceptions

B. assertThrows to verify the exception is thrown

C. assertEquals to compare exception messages

D. Use @Disabled to skip the test

Solution

1. Step 1: Understand exception testing in JUnit 5

   JUnit 5 provides assertThrows to check if a specific exception is thrown by code.

2. Step 2: Evaluate other options

   assertEquals compares values, not exceptions; @BeforeEach runs before tests; @Disabled skips tests.

3. Final Answer:

   assertThrows to verify the exception is thrown -> Option B

4. Quick Check:

   Use assertThrows for exception tests [OK]

Hint: Use assertThrows to test exceptions in JUnit 5 [OK]

Common Mistakes:

• Using assertEquals to check exceptions
• Misusing @BeforeEach for exception handling
• Disabling tests instead of testing exceptions