JUnit Testing Interview Questions

JUnit testing interview questions are commonly asked to check your understanding of Java unit testing concepts and how to write reliable and maintainable test cases. These questions mainly cover both JUnit 4 and JUnit 5 features used in real-world testing.

• Focuses on annotations, assertions, lifecycle methods, parameterized tests, and exception testing
• Includes mocking basics, test suites, and best practices for clean unit testing

1. What is JUnit?

JUnit is a popular Java testing framework used to write and run unit test cases. It helps developers verify that each method or module works correctly and ensures code quality by catching bugs early in the development process.

• Used to test Java classes and methods automatically
• Supports annotations like @Test, @BeforeEach, and @AfterEach
• Commonly used with Maven/Gradle and Spring Boot projects

2. Why is unit testing important?

Unit testing is important because it helps ensure that each small part of the application (like a method or class) works correctly before integrating it with other parts. It reduces bugs, improves code quality, and makes future changes safer.

• Detects bugs early in development
• Makes code easier to maintain and refactor
• Improves confidence before deployment

3. What is the difference between JUnit 4 and JUnit 5?

JUnit 5 is the modern version of JUnit with better modular architecture and more advanced features compared to JUnit 4.

4. What are the main modules of JUnit 5?

JUnit 5 is designed in a modular way, which makes it more flexible and powerful than older versions. It is mainly divided into three core modules that work together to run and manage test cases.

• JUnit Platform: Provides the foundation to launch testing frameworks on the JVM
• JUnit Jupiter: Contains new annotations and APIs to write and run tests in JUnit 5
• JUnit Vintage: Supports running older JUnit 3 and JUnit 4 tests in JUnit 5

5. What is the use of @Test annotation?

The @Test annotation is used to mark a method as a test case in JUnit. When the test suite runs, JUnit automatically detects and executes all methods annotated with @Test to verify the expected behavior of the code.

• Identifies a method as a unit test
• JUnit executes it automatically during test runs
• Helps validate output using assertions like assertEquals()

6. What are assertions in JUnit?

Assertions in JUnit are used to check whether the actual output matches the expected output in a test case. If an assertion fails, JUnit marks the test as failed, helping developers identify issues quickly.

• Used to validate expected results in unit tests
• If an assertion fails, the test case is marked as FAILED
• Common methods: assertEquals(), assertTrue(), assertFalse()
• Also supports checks like assertNotNull() and assertThrows()

7. What is the use of @BeforeEach in JUnit 5?

@BeforeEach in JUnit 5 is used to run a method before every test case in a test class. It is mainly used for setting up common test data or initializing objects so that each test runs with a fresh setup.

• Executes before each @Test method
• Used for initializing objects and test data
• Helps avoid repeated setup code inside every test method
• Ensures test cases run independently with a clean state

8. What is the use of @AfterEach in JUnit 5?

@AfterEach in JUnit 5 is used to run a method after every test case in a test class. It is mainly used for cleanup tasks like closing resources, resetting values, or releasing memory after each test execution.

• Executes after each @Test method
• Used for cleanup operations (closing files, DB connections, etc.)
• Helps keep test environment clean for the next test
• Ensures resources are properly released after every test run

9. What is @BeforeAll and @AfterAll in JUnit?

@BeforeAll and @AfterAll in JUnit are used to run methods only once for the entire test class. @BeforeAll runs before all test methods, and @AfterAll runs after all test methods, mainly for global setup and cleanup.

• @BeforeAll runs once before any test method executes
• @AfterAll runs once after all test methods finish
• Methods must be static (by default) in JUnit 5
• Used for one-time setup/cleanup like DB connection, server start/stop

10. What is a Test Suite in JUnit?

A Test Suite in JUnit is a collection of multiple test classes that are executed together as a single group. It is useful when you want to run all related test cases at once, such as running all tests for a module or feature.

• Groups multiple test classes into one execution
• Helps run complete module or project testing together
• Improves test organization and management
• Can be created using suite annotations in JUnit

11. What is the difference between @BeforeEach and @BeforeAll?

BeforeEach and @BeforeAll are both setup annotations in JUnit 5, but they run at different times. @BeforeEach runs before every test method, while @BeforeAll runs only once before all test methods in the class.

12. What is @Disabled annotation in JUnit 5?

@Disabled in JUnit 5 is used to temporarily skip a test method or an entire test class during execution. It is helpful when a test is under development, failing due to a known issue, or not ready to run.

• Skips the test method or test class during test execution
• Useful for temporarily disabling failing or incomplete tests
• Can include a reason like @Disabled("Feature not ready")
• Helps avoid test suite failures without deleting code

Example:

@Disabled("Not implemented yet")
@Test
void testFeature() {
}

13. How do you test exceptions in JUnit 5?

In JUnit 5, exceptions are tested using the assertThrows() method. It checks whether a specific exception is thrown when executing a piece of code, and the test passes only if the expected exception occurs.

• Test passes only when the expected exception is thrown
• Helps validate error handling logic in code
• You can also verify the exception message if needed

Example:

assertThrows(ArithmeticException.class, () -> {
int result = 10 / 0;
});

14. What is Parameterized Test in JUnit 5?

A Parameterized Test in JUnit 5 is a type of test that runs the same test method multiple times with different input values. It helps reduce duplicate test code and improves test coverage by testing multiple scenarios in one method.

• Written using @ParameterizedTest instead of @Test
• Accepts multiple inputs using sources like @ValueSource, @CsvSource
• Runs the same test logic for each input value
• Useful for validating multiple test cases efficiently

15. What is @ValueSource in parameterized tests?

@ValueSource in JUnit 5 is used to provide a single list of values as input to a parameterized test. It allows the same test method to run multiple times, once for each value given in the annotation.

• Used with @ParameterizedTest
• Supports types like int, long, double, String, etc.
• Runs the test method for each value provided

Example:

@ParameterizedTest

@ValueSource(ints = {1, 2, 3})

void testPositiveNumbers(int num) {

assertTrue(num > 0);

}

16. What is @CsvSource in JUnit?

@CsvSource in JUnit 5 is used in parameterized tests to provide multiple sets of input values in CSV (comma-separated) format. It allows you to pass more than one argument to a test method and run the test multiple times with different data.

• Used with @ParameterizedTest for multiple inputs
• Each line represents one test case with multiple parameters
• Useful for testing method outputs with different combinations

Example:

@ParameterizedTest

@CsvSource({"1,2,3", "5,5,10"})

void testAdd(int a, int b, int sum) {

assertEquals(sum, a + b);

}

17. What is the use of @RepeatedTest?

@RepeatedTest in JUnit 5 is used to run the same test method multiple times. It is helpful when you want to verify consistency, test flaky behavior, or run a test repeatedly under the same conditions.

• Executes the same test case multiple times
• Useful for testing stability and repeated execution scenarios
• Can specify count like @RepeatedTest(5)
• Provides repetition info using RepetitionInfo if needed

Example:

@RepeatedTest(5)

void testMultipleTimes() {

}

18. What is the use of @DisplayName?

@DisplayName in JUnit 5 is used to give a custom readable name to a test class or test method. It makes test reports more meaningful and easy to understand instead of showing method names.

• Improves readability of test output and reports
• Can be used on both test methods and test classes
• Supports spaces and special characters in names

Example:

@DisplayName("Check if sum works correctly")
@Test
void testSum() {
}

19. What is the use of @Nested in JUnit 5?

@Nested in JUnit 5 is used to create inner test classes inside a test class to organize test cases in a structured way. It is helpful when you want to group related tests together, such as testing different scenarios of the same feature.

• Helps group test cases logically inside one class
• Improves readability and structure of test code
• Nested classes can have their own setup methods like @BeforeEach
• Useful for scenario-based testing (valid/invalid cases)

20. What is the difference between unit testing and integration testing?

Unit testing and integration testing are both important in software testing, but they focus on different levels. Unit testing checks individual methods or classes, while integration testing verifies how multiple components work together (like service + database).

21. What is mocking in testing?

Mocking in testing means creating a fake object that behaves like a real dependency. It is mainly used in unit testing to isolate the code being tested, without calling real database, API, or external services.

• Helps test a class independently without real dependencies
• Used to simulate method responses and behaviors
• Commonly done using Mockito framework
• Makes unit tests faster and more reliable

22. What is the use of assertAll() in JUnit 5?

assertAll() in JUnit 5 is used to execute multiple assertions together in a single test. It ensures that all assertions are checked, and even if one fails, the remaining assertions still run, showing all failures at once.

• Runs multiple assertions in one test method
• Reports all assertion failures together
• Useful for validating multiple fields/conditions
• Helps avoid stopping the test at the first failure

Example:

assertAll(

() -> assertEquals(10, result),

() -> assertTrue(result > 0)

);

23. What is test-driven development (TDD)?

Test-Driven Development (TDD) is a software development approach where you write test cases before writing the actual code. The goal is to develop code in small steps by first failing a test, then writing code to pass it, and finally improving the code.

• Follow the cycle: Red -> Green -> Refactor
• Ensures better code quality and fewer bugs
• Helps in designing clean and testable code
• Makes development more structured and reliable

24. What is the purpose of @TestInstance in JUnit 5?

@TestInstance in JUnit 5 is used to control the lifecycle of the test class instance. By default, JUnit creates a new instance for each test method, but using @TestInstance you can make JUnit use a single instance for all tests.

• Controls whether JUnit creates new instance per test or single instance
• Supports Lifecycle.PER_METHOD (default) and Lifecycle.PER_CLASS
• Useful when you want to use non-static @BeforeAll and @AfterAll
• Helps maintain shared state across tests (when needed)