JUnit5

Question 1

What is @Timeout used for?

Answer 1

@Timeout is used to define a timeout for a test method or a test class

Question 2

What is @RepeatedTest used for?

Answer 2

@RepeatedTest is used to repeat a test method a specified number of times

Question 3

What is @BeforeEach used for?

Answer 3

@BeforeEach is used to run code before each test method

Question 4

What is @AfterEach used for?

Answer 4

@AfterEach is used to run code after each test method

Question 5

What is @BeforeAll used for?

Answer 5

@BeforeAll is used to run code once before all test methods

Question 6

What is @AfterAll used for?

Answer 6

@AfterAll is used to run code once after all test methods

Question 7

What is @Disabled used for?

Answer 7

@Disabled is used to disable a test method from running

Question 8

What is @ParameterizedTest used for?

Answer 8

@ParameterizedTest is used to signal that a test method has parameters

Question 9

True or False

Although true unit tests typically should not rely on the order in which they are executed, there are times when it is necessary to enforce a specific test method execution order

Answer 9

True

Question 10

True or False

By default, JUnit creates a new instance of each test class before executing each test method

Answer 10

True

Question 11

True or False

Test classes, test methods, and lifecycle methods are not required to be public and cannot be private

Answer 11

True

Question 12

What must be done to be able to declare @BeforeAll and @AfterAll as non-static methods?

Answer 12

The test class must be annotated with @TestInstance(Lifecycle.PER_CLASS)

Question 13

True or False

@Timeout annotations declared at the class level are also applied to lifecycle methods

Answer 13

False

Question 14

True or False

@ExtendWith may also be declared on fields or on parameters in test class constructors, in test methods, and in @BeforeAll, @AfterAll, @BeforeEach, and @AfterEach lifecycle methods

Answer 14

True

Question 15

Valid or invalid

@ExtendWith({ DatabaseExtension.class, WebServerExtension.class })
class MyFirstTests {
    // ...
}

Answer 15

Valid

Question 16

What are the 4 lifecycle methods?

Answer 16

• @BeforeAll
• @AfterAll
• @BeforeEach
• @AfterEach

Question 17

True or False

The JUnit Team recommends that developers declare at most one @BeforeEach method and at most one @AfterEach method per test class or test interface unless there are no dependencies between the @BeforeEach methods or between the @AfterEach methods

Answer 17

True

JUnit Jupiter does not guarantee the execution order of multiple lifecycle methods that are declared within a single test class or test interface

Question 18

Valid or Invalid

@ParameterizedTest(name = "{index} - {0} is older than 40")
@ArgumentsSource(EmployeesArgumentsProvider.class)
void isEmployeeAgeGreaterThan40(Employee e) {
    assertTrue(Period.between(e.getDob(), LocalDate.now()).get(ChronoUnit.YEARS) > 40);
}

class EmployeesArgumentsProvider implements ArgumentsProvider {
    @Override
    public Stream<? extends Arguments> provideArguments(ExtensionContext context) {
        return Stream.of(
          Arguments.of(new Employee(1, "Alex", LocalDate.of(1980, 2, 3))),
          Arguments.of(new Employee(2, "Brian", LocalDate.of(1979, 2, 3))),
          Arguments.of(new Employee(3, "Charles", LocalDate.of(1978, 2, 3)))
        );
    }
}

Answer 18

Valid

Question 19

True or False

@ParameterizedTest methods must specify at least one ArgumentsProvider via @ArgumentsSource or a corresponding composed annotation (e.g., @ValueSource, @CsvSource, etc.). The provider is responsible for providing a Stream of Arguments that will be used to invoke the parameterized test method

Answer 19

True

Question 20

Valid or Invalid

@TestMethodOrder(OrderAnnotation.class)
class OrderedTestsDemo {

    @Test
    @Order(1)
    void nullValues() {
        // perform assertions against null values
    }

    @Test
    @Order(2)
    void emptyValues() {
        // perform assertions against empty values
    }

    @Test
    @Order(3)
    void validValues() {
        // perform assertions against valid values
    }

}

Answer 20

Valid

Question 21

True or False

It is generally recommended to omit the public modifier for test classes, test methods, and lifecycle methods unless there is a technical reason for doing so

Answer 21

True

Question 22

How do assumptions work?

Answer 22

If the assumption is true, the test will run as usual. If the assumption is false, the test is aborted and marked as ignored