Test class organization in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of JUnit test class with multiple test methods

Consider the following JUnit 5 test class. What will be the output when running this test class?

JUnit

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

public class CalculatorTest {

    @Test
    void testAdd() {
        assertEquals(5, 2 + 3);
    }

    @Test
    void testSubtract() {
        assertEquals(1, 3 - 2);
    }

    @Test
    void testMultiply() {
        assertEquals(6, 2 * 3);
    }
}

A All three tests pass successfully.

B The testSubtract method fails due to wrong assertion.

C The testMultiply method throws an exception and fails.

D The testAdd method is skipped and not executed.

💡 Hint

Check each assertion carefully to see if the expected and actual values match.

Each test method uses assertEquals with correct expected and actual values. All assertions are true, so all tests pass.

❓ assertion

intermediate

Correct assertion to verify exception thrown in JUnit test

You want to test that a method throws an IllegalArgumentException when given a negative number. Which assertion correctly tests this in JUnit 5?

A assertTrue(method(-1) instanceof IllegalArgumentException);

B assertEquals(IllegalArgumentException.class, method(-1));

C assertThrows(IllegalArgumentException.class, () -> method(-1));

D assertDoesNotThrow(() -> method(-1));

💡 Hint

Look for the JUnit 5 method designed to check exceptions.

assertThrows expects the exception class and a lambda that runs the code. It passes if the exception is thrown.

🔧 Debug

advanced

Identify the problem in this JUnit test class setup

Examine the following JUnit 5 test class. What is the main issue that will cause tests not to run as expected?

JUnit

import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;

public class ServiceTest {

    private static Service service;

    @BeforeAll
    static void setup() {
        service = new Service();
    }

    @Test
    void testServiceMethod() {
        assertTrue(service.isReady());
    }
}

A The test class is missing a constructor, so tests won't run.

B The test method 'testServiceMethod' is missing the @BeforeEach annotation.

C The 'service' variable should not be static for @BeforeAll to work.

D The @BeforeAll method must be static, but 'setup' is not static.

💡 Hint

Check the rules for @BeforeAll methods in JUnit 5.

In JUnit 5, methods annotated with @BeforeAll must be static unless the test class is annotated with @TestInstance(Lifecycle.PER_CLASS).

❓ framework

advanced

Best practice for organizing test classes in a large Java project

In a large Java project using JUnit, what is the best practice for organizing test classes to keep tests maintainable and clear?

A Put all test classes in a single package regardless of the classes they test.

B Place test classes in the same package as the classes they test, but under a separate 'test' source folder.

C Mix test classes with production classes in the same source folder and package.

D Place test classes in a completely different project unrelated to the main codebase.

💡 Hint

Think about how to easily find tests related to each class.

Keeping test classes in the same package as the classes they test helps with package-private access and organization. Using a separate source folder for tests keeps production and test code separate.

🧠 Conceptual

expert

Understanding test class lifecycle annotations in JUnit 5

Which statement correctly describes the difference between @BeforeEach and @BeforeAll annotations in JUnit 5 test classes?

A @BeforeEach runs before each test method; @BeforeAll runs once before all tests.

B @BeforeEach runs once before all tests; @BeforeAll runs before each test method.

C @BeforeEach and @BeforeAll both run once before all tests but differ in visibility.

D @BeforeEach runs after each test; @BeforeAll runs after all tests.

💡 Hint

Think about how often each setup method runs during the test class execution.

@BeforeEach runs before every test method to set up fresh state. @BeforeAll runs once before any tests to set up shared resources.