Question 1

What is the difference between JUnit 4 and JUnit 5 (Jupiter)?

Accepted Answer

The 30-Second Answer: JUnit 5 (Jupiter) is a complete rewrite with a modular architecture, uses Java 8+ features like lambdas and streams, replaces @Before/@After with @BeforeEach/@AfterEach, adds new features like @DisplayName and parameterized tests, and separates the testing API from the execution platform. The 2-Minute Answer (If They Want More): JUnit 5 represents a fundamental architectural shift from JUnit 4.

Question 2

What is the difference between @BeforeEach and @BeforeAll?

Accepted Answer

The 30-Second Answer: @BeforeEach runs before every single test method in the class, creating fresh test fixtures for each test. @BeforeAll runs only once before all tests in the class, must be static, and is used for expensive shared setup. @BeforeEach ensures test isolation; @BeforeAll optimizes performance for costly operations. The 2-Minute Answer (If They Want More): The key difference between @BeforeEach and @BeforeAll lies in execution frequency, scope, and use cases.

Question 3

What is the difference between unit tests and integration tests?

Accepted Answer

The 30-Second Answer: Unit tests verify individual components in isolation using mocks for dependencies, run in milliseconds, and test business logic. Integration tests verify how multiple components work together using real implementations, run slower, and test that the system integrates correctly with databases, APIs, and other services. The 2-Minute Answer (If They Want More): Unit tests are focused, fast, and isolated.

Question 4

What is the difference between assertEquals(), assertSame(), and assertThat()?

Accepted Answer

The 30-Second Answer: assertEquals() compares object values using the equals() method, assertSame() checks if two references point to the exact same object instance using ==, and assertThat() is a Hamcrest-style matcher that provides more readable and flexible assertions with custom matchers. The 2-Minute Answer (If They Want More): These three assertion methods serve different purposes and use different comparison mechanisms.

Question 5

What is the difference between assertThrows() in JUnit 5 and @Test(expected) in JUnit 4?

Accepted Answer

The 30-Second Answer: assertThrows() in JUnit 5 provides precise control over which code should throw an exception and returns the exception for further inspection, while @Test(expected) in JUnit 4 only checks if any exception of the specified type occurs anywhere in the test method, without access to exception details. The 2-Minute Answer (If They Want More): The key difference is precision and capability. JUnit 4's @Test(expected = Exception.

Question 6

What is the difference between @NullAndEmptySource and combining @NullSource with @EmptySource?

Accepted Answer

The 30-Second Answer: @NullAndEmptySource is a convenience annotation that combines @NullSource and @EmptySource into a single annotation. There's no functional difference - it provides exactly the same null and empty values, just with less code and better readability. The 2-Minute Answer (If They Want More): @NullAndEmptySource is purely a convenience annotation that serves as a shorthand for using both @NullSource and @EmptySource together.

Question 7

What is JUnit and why is it the standard testing framework for Java?

Accepted Answer

The 30-Second Answer: JUnit is an open-source unit testing framework for Java that provides annotations, assertions, and test runners to write and execute automated tests. It's the de facto standard because of its simplicity, wide IDE integration, extensive ecosystem support, and 20+ years of proven reliability in the Java community. The 2-Minute Answer (If They Want More): JUnit is a regression testing framework that allows developers to write repeatable tests for Java code.

Question 8

What is the test lifecycle in JUnit 5?

Accepted Answer

The 30-Second Answer: JUnit 5's test lifecycle follows this order: @BeforeAll (once) â†’ [@BeforeEach â†’ @Test â†’ @AfterEach] (repeated for each test) â†’ @AfterAll (once). By default, JUnit creates a new test class instance for each @Test method, ensuring test isolation. @AfterEach and @AfterAll run even if tests fail. The 2-Minute Answer (If They Want More): Understanding the JUnit 5 test lifecycle is essential for managing test state, resources, and ensuring proper test isolation.

Question 9

What is @DisplayName and why would you use it?

Accepted Answer

The 30-Second Answer: @DisplayName lets you provide human-readable test names with spaces, special characters, and emoji instead of being limited to camelCase method names. Use it to make test reports more readable for non-developers, describe business requirements clearly, or create self-documenting test suites. It appears in IDE test runners and CI/CD reports.

Question 10

What is the AAA (Arrange-Act-Assert) pattern?

Accepted Answer

The 30-Second Answer: The AAA pattern structures tests into three clear sections: Arrange (set up test data and dependencies), Act (execute the code under test), and Assert (verify the expected outcome). This pattern makes tests readable and maintainable by creating a consistent structure. The 2-Minute Answer (If They Want More): The Arrange-Act-Assert pattern is a fundamental testing structure that organizes test methods into three distinct phases.

JUnit Fundamentals(10 questions)

What is JUnit and why is it the standard testing framework for Java?

What is the difference between JUnit 4 and JUnit 5 (Jupiter)?

Explain the JUnit 5 architecture (Platform, Jupiter, Vintage).

How do you set up JUnit 5 in a Maven or Gradle project?

What are the basic annotations in JUnit 5 (@Test, @BeforeEach, @AfterEach, @BeforeAll, @AfterAll)?

What is the difference between @BeforeEach and @BeforeAll?

How do you write a simple test case in JUnit 5?

What is the test lifecycle in JUnit 5?

How do you disable a test with @Disabled?

What is @DisplayName and why would you use it?

Testing Best Practices(10 questions)

What are the best practices for writing unit tests with JUnit and Mockito?

What is the AAA (Arrange-Act-Assert) pattern?

How do you achieve test isolation?

What should and shouldn't be mocked?

How do you avoid over-mocking?

What is the difference between unit tests and integration tests?

When should you use real objects vs mocks?

How do you test private methods (and should you)?

What are the common anti-patterns in mocking?

How do you write maintainable test code?

Code Coverage and Quality(5 questions)

How do you measure code coverage with JUnit tests?

What tools integrate with JUnit for code coverage (JaCoCo, Cobertura)?

What are meaningful coverage thresholds?

How do you interpret branch coverage vs line coverage?

What are the limitations of code coverage as a quality metric?

Integration and CI/CD(7 questions)

How do you run JUnit tests in Maven and Gradle?

What is the Maven Surefire plugin?

How do you run tests in parallel with JUnit 5?

How do you integrate JUnit tests with CI/CD pipelines?

How do you generate test reports in different formats?

What is the @Tag annotation for filtering tests in CI?

How do you handle flaky tests?

Troubleshooting and Common Issues(6 questions)

What causes "Unnecessary stubbings detected" exception?

How do you fix "org.mockito.exceptions.misusing.InvalidUseOfMatchersException"?

What causes "Wanted but not invoked" verification errors?

How do you debug failing mock verifications?

What are common causes of NullPointerException in mocked tests?

How do you handle "Cannot mock final class" errors?

JUnit Assertions(12 questions)

What are assertions in JUnit and why are they important?

What is the difference between assertEquals(), assertSame(), and assertThat()?

How do you use assertTrue() and assertFalse()?

What is assertNull() and assertNotNull()?

How do you test for exceptions with assertThrows()?

What is the difference between assertThrows() in JUnit 5 and @Test(expected) in JUnit 4?

How do you use assertAll() for grouped assertions?

What is assertTimeout() and assertTimeoutPreemptively()?

How do you compare arrays with assertArrayEquals()?

What is the purpose of fail() in JUnit?

How do you write custom assertion messages?

What is AssertJ and how does it compare to JUnit assertions?

JUnit Test Organization(8 questions)

How do you organize test classes and methods?

What is the @Nested annotation and when would you use it?

How do you use @Tag for categorizing tests?

What is @TestMethodOrder and how do you control test execution order?

How do you create test suites in JUnit 5?

What is the @TestInstance annotation and its lifecycle modes?

How do you use @RepeatedTest for running tests multiple times?

What is the naming convention for test classes and methods?

Parameterized Tests(9 questions)

What are parameterized tests and why are they useful?

How do you use @ParameterizedTest in JUnit 5?

What is @ValueSource and when would you use it?

How do you use @CsvSource and @CsvFileSource?

What is @MethodSource and how do you provide test arguments from a method?

How do you use @EnumSource for testing with enums?

What is @ArgumentsSource for custom argument providers?

How do you use @NullSource and @EmptySource?

What is the difference between @NullAndEmptySource and combining @NullSource with @EmptySource?