Question 1

What is JUnit, and what are the main differences between JUnit 4 and JUnit 5?

Accepted Answer

JUnit is a popular unit testing framework for the Java programming language. JUnit 5 is a modular rewrite consisting of three sub-modules: JUnit Platform (runner engine), JUnit Jupiter (new annotations and extension API), and JUnit Vintage (supports backward compatibility for JUnit 3 and 4).

Question 2

List common JUnit 5 annotations and their JUnit 4 equivalents.

Accepted Answer

1. `@Test`: Defines a test method (same in both).
2. `@BeforeEach` (JUnit 5) vs `@Before` (JUnit 4): Runs before every test method.
3. `@AfterEach` (JUnit 5) vs `@After` (JUnit 4): Runs after every test method.
4. `@BeforeAll` (JUnit 5) vs `@BeforeClass` (JUnit 4): Runs once before all tests (must be static).
5. `@AfterAll` (JUnit 5) vs `@AfterClass` (JUnit 4): Runs once after all tests (must be static).
6. `@Disabled` (JUnit 5) vs `@Ignore` (JUnit 4): Disables/skips the test.

Question 3

How do you test that a method throws an exception in JUnit 5?

Accepted Answer

In JUnit 5, you assert exceptions using the `Assertions.assertThrows()` method. This accepts the expected Exception class and an executable lambda block. It returns the thrown exception instance, allowing you to assert detail messages.
Code Example:
@Test
void testException() {
    Exception exception = assertThrows(ArithmeticException.class, () -> {
        int result = 1 / 0;
    });
    assertEquals("/ by zero", exception.getMessage());
}

Question 4

Explain Parameterized Tests in JUnit 5.

Accepted Answer

JUnit 5 has built-in parameterized testing. You annotate the test with `@ParameterizedTest` and specify the data source using annotations like `@ValueSource`, `@CsvSource`, or `@MethodSource`.
Code Example:
@ParameterizedTest
@ValueSource(ints = {1, 2, 3})
void testWithValues(int argument) {
    assertTrue(argument > 0);
}

Question 5

What are assertions in JUnit? List some common ones.

Accepted Answer

Assertions are static methods in the `org.junit.jupiter.api.Assertions` class used to verify that test outputs match expectations. Common ones include `assertEquals()`, `assertTrue()`, `assertFalse()`, `assertNull()`, `assertNotNull()`, `assertSame()` (checks references), and `assertTimeout()`.

Question 6

Explain the difference between `assertTimeout()` and `assertTimeoutPreemptively()`.

Accepted Answer

`assertTimeout()` executes the test code inside the current main test thread, checking the execution duration *after* it completes. If it times out, the test fails but only after running to completion. `assertTimeoutPreemptively()` executes the test code in a separate thread and terminates it immediately when the timeout threshold is exceeded.

Question 7

What are Assumptions in JUnit 5, and how do they differ from Assertions?

Accepted Answer

Assertions check critical states; if an assertion fails, the test fails. **Assumptions** (declared in `Assumptions` class) evaluate conditions that must be true for the test to run (e.g. running only on local OS). If an assumption fails, the test is **aborted/skipped**, but it is not marked as failed.
Code Example:
@Test
void testOnlyOnWindows() {
    assumeTrue(System.getProperty("os.name").startsWith("Windows"));
    // Proceed with test
}

Question 8

What is `@DisplayName` annotation?

Accepted Answer

The `@DisplayName` annotation allows declaring a custom, readable string name for the test class or method that displays in test reports and IDE runner trees, supporting spaces and emojis.

Question 9

What is the Extension Model in JUnit 5, and what annotation replaces `@RunWith`?

Accepted Answer

JUnit 5 replaced the legacy runner/rule system of JUnit 4 with the extension model. The `@ExtendWith` annotation is used to register custom extensions (such as SpringExtension or MockitoExtension) to hook into the test execution lifecycle.

Question 10

Explain Grouped Assertions (`assertAll()`).

Accepted Answer

`assertAll()` allows executing multiple assertions in a single test block. If one assertion fails, JUnit still runs and evaluates all other assertions in the block, reporting all failures in the final log, rather than stopping on the first failure.
Code Example:
@Test
void testAddress() {
    Address address = new Address("Mumbai", "India");
    assertAll("address",
        () -> assertEquals("Mumbai", address.getCity()),
        () -> assertEquals("India", address.getCountry())
    );
}

Question 11

What is the default lifecycle of a test class instance in JUnit?

Accepted Answer

By default, JUnit creates a new instance of the test class for *every single test method* it executes. This isolates test states and prevents side effects. This behavior can be overridden to create a single instance per class by annotating the class with `@TestInstance(Lifecycle.PER_CLASS)`.

Question 12

Explain `@Nested` tests in JUnit 5.

Accepted Answer

The `@Nested` annotation allows declaring inner classes that represent nested test suites, grouping related tests hierarchically and sharing setup contexts in parent classes.

Question 13

What is the purpose of `@Tag` in JUnit 5?

Accepted Answer

The `@Tag` annotation is used to categorize test classes or methods (e.g. tagging with `@Tag("fast")` or `@Tag("db")`). Build tools (like Maven or Gradle) can filter tags to execute only specific test suites during builds.

Question 14

How do you run parameterized tests with CSV data files?

Accepted Answer

You annotate the parameterized test with `@CsvFileSource` and specify the file path located in your resources directory.
Code Example:
@ParameterizedTest
@CsvFileSource(resources = "/data.csv", numLinesToSkip = 1)
void testWithCsvFile(String country, int code) {
    assertNotNull(country);
}

Question 15

What is `@TempDir` in JUnit 5, and why is it used?

Accepted Answer

The `@TempDir` annotation automatically creates and deletes a temporary file directory on the disk during test execution. It is injected into test parameters or fields, facilitating file read/write tests without needing manual folder cleanup scripts.

Question 16

What is a dynamic test in JUnit 5?

Accepted Answer

Dynamic Tests (defined using `@TestFactory`) are tests generated dynamically at runtime by a factory method, allowing developers to construct tests from databases or dynamic data streams.

Question 17

How do you configure parallel test execution in JUnit 5?

Accepted Answer

You enable parallel execution by setting configurations in a `junit-platform.properties` configuration file, specifying node counts and thread execution strategies.
Code Example:
junit.jupiter.execution.parallel.enabled = true
junit.jupiter.execution.parallel.mode.default = concurrent

Question 18

What is `@RepeatedTest` in JUnit 5?

Accepted Answer

The `@RepeatedTest` annotation is used to run a specific test method multiple times in a row, useful for testing flaky operations or performance stabilities.

Question 19

Explain the use of the `@Mock` and `@InjectMocks` annotations in Mockito JUnit tests.

Accepted Answer

In Mockito-based JUnit tests, `@Mock` creates a mock object instance of a dependency class. `@InjectMocks` instantiates the class under test and automatically injects all mock dependencies into it.
Code Example:
@ExtendWith(MockitoExtension.class)
class UserServiceTest {
    @Mock UserRepository userRepository;
    @InjectMocks UserService userService; // userRepository is injected here
}

Question 20

How can you order the execution of test methods in JUnit 5?

Accepted Answer

By default, test execution order is not guaranteed. To specify order, you annotate the test class with `@TestMethodOrder` and pass an ordering strategy like `OrderAnnotation.class`, then specify `@Order(number)` on methods.

JUnit Java Testing Interview

Difficulty Filters

Tools & Options

What is JUnit, and what are the main differences between JUnit 4 and JUnit 5?

List common JUnit 5 annotations and their JUnit 4 equivalents.

How do you test that a method throws an exception in JUnit 5?

Explain Parameterized Tests in JUnit 5.

What are assertions in JUnit? List some common ones.

Explain the difference between `assertTimeout()` and `assertTimeoutPreemptively()`.

What are Assumptions in JUnit 5, and how do they differ from Assertions?

What is `@DisplayName` annotation?

What is the Extension Model in JUnit 5, and what annotation replaces `@RunWith`?

Explain Grouped Assertions (`assertAll()`).

What is the default lifecycle of a test class instance in JUnit?

Explain `@Nested` tests in JUnit 5.

What is the purpose of `@Tag` in JUnit 5?

How do you run parameterized tests with CSV data files?

What is `@TempDir` in JUnit 5, and why is it used?

What is a dynamic test in JUnit 5?

How do you configure parallel test execution in JUnit 5?

What is `@RepeatedTest` in JUnit 5?

Explain the use of the `@Mock` and `@InjectMocks` annotations in Mockito JUnit tests.

How can you order the execution of test methods in JUnit 5?

Technical Interview Mastery Blueprint

1. The Engineering STAR Technique

2. Defending Architectural Trade-Offs

3. Clean Code & Edge-Case Proactivity

4. Antipatterns to Avoid

Explore Related Tools

Ai Ml Interview

Ai Theory Interview

Angular Interview Questions

Artificial Intelligence Interview

Aws Interview Questions

Bitbucket Interview

Follow Us

Our Tools

Our Company

Special Tools