Testing / JUnit6 Interview Questions

<!-- Maven BOM: single version for all modules in JUnit 6 -->
<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.junit</groupId>
      <artifactId>junit-bom</artifactId>
      <version>6.1.1</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

<dependencies>
  <dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <scope>test</scope>
    <!-- Version resolved by BOM: 6.1.1 -->
  </dependency>
</dependencies>

<!-- JUnit 5 used different version numbers:
     Platform: 1.x.x
     Jupiter:  5.x.x
     Vintage:  5.x.x

     JUnit 6: all three use 6.x.x -->

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

@DisplayName("Order service tests")
class OrderServiceTest {

    OrderService service;

    @BeforeAll
    static void initAll() {
        System.out.println("Runs once before all tests");
    }

    @BeforeEach
    void setUp() {
        service = new OrderService();
    }

    @Test
    @DisplayName("New order has PENDING status")
    void newOrderIsPending() {
        Order order = service.create("item-1", 2);
        assertEquals(Status.PENDING, order.getStatus());
    }

    @Test
    @Disabled("Not implemented yet")
    void cancelledOrderIsRefunded() {
        // TODO
    }

    @AfterEach
    void tearDown() {
        service = null;
    }

    @AfterAll
    static void tearDownAll() {
        System.out.println("Runs once after all tests");
    }
}

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

class AssertionsDemo {

    @Test
    void basicAssertions() {
        assertEquals(4, 2 + 2);
        assertNotEquals(5, 2 + 2);
        assertTrue(4 > 3);
        assertFalse(4 < 3);
        assertNull(null);
        assertNotNull("hello");
    }

    @Test
    void assertionsWithMessages() {
        // Message is lazily evaluated (supplier) -- no cost if test passes
        assertEquals(4, 2 + 2, () -> "Expected 4 but was " + (2 + 2));
    }

    @Test
    void groupedAssertions() {
        // assertAll: ALL assertions run even if some fail
        // Reports ALL failures, not just the first one
        assertAll("address",
            () -> assertEquals("London",  address.city()),
            () -> assertEquals("UK",      address.country()),
            () -> assertEquals("EC1A 1BB", address.postcode())
        );
    }

    @Test
    void exceptionAssertions() {
        // assertThrows: passes only if the lambda throws the expected type
        Exception ex = assertThrows(IllegalArgumentException.class,
            () -> new Order(null, -1));
        assertEquals("Quantity must be positive", ex.getMessage());
    }

    @Test
    void doesNotThrow() {
        assertDoesNotThrow(() -> new Order("item", 1));
    }

    @Test
    void timeoutAssertions() {
        // Fails if the lambda takes longer than 1 second
        assertTimeout(Duration.ofSeconds(1), () -> Thread.sleep(500));
    }
}

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.*;

class ParameterizedDemo {

    // @ValueSource: simple single-argument tests
    @ParameterizedTest
    @ValueSource(ints = {1, 2, 3, 4, 5})
    void isPositive(int n) {
        assertTrue(n > 0);
    }

    // @CsvSource: multiple arguments per invocation
    @ParameterizedTest(name = "{index}: add({0}, {1}) = {2}")
    @CsvSource({
        "1, 2, 3",
        "10, 20, 30",
        "-5, 5, 0"
    })
    void additionTest(int a, int b, int expected) {
        assertEquals(expected, a + b);
    }

    // @MethodSource: call a static method returning a Stream
    @ParameterizedTest
    @MethodSource("provideStrings")
    void blankStringsAreRejected(String input) {
        assertThrows(IllegalArgumentException.class,
            () -> new Username(input));
    }

    static Stream<String> provideStrings() {
        return Stream.of("", " ", "  ", null);
    }

    // @EnumSource: test all or selected enum values
    @ParameterizedTest
    @EnumSource(value = Status.class, names = {"PENDING", "PROCESSING"})
    void activeStatusesAreNotFinal(Status s) {
        assertFalse(s.isFinal());
    }

    // @NullSource / @EmptySource / @NullAndEmptySource
    @ParameterizedTest
    @NullAndEmptySource
    void nullAndEmptyAreRejected(String input) {
        assertThrows(IllegalArgumentException.class,
            () -> new Username(input));
    }
}

// JUnit 6: CancellationToken -- test and extension authors can check
// for cancellation between steps and abort cleanly.

// Extensions can check cancellation:
class CleanupExtension implements BeforeEachCallback {
    @Override
    public void beforeEach(ExtensionContext context) throws Exception {
        // Check if the test run has been cancelled before starting setup
        if (context.getCancellationToken().isCancellationRequested()) {
            return;  // skip setup gracefully
        }
        // ... normal setup ...
    }
}

// --fail-fast mode in ConsoleLauncher:
// The first test failure triggers a CancellationToken that propagates
// through the test suite, stopping remaining tests cleanly.
java -jar junit-platform-console-standalone-6.1.1.jar \
    --scan-class-path \
    --fail-fast
// Equivalent in Maven Surefire:
// <configuration>
//   <runOrder>random</runOrder>
//   <forkCount>1</forkCount>
// </configuration>
// (use --fail-at-end or failIfNoTests per tool docs)

// JUnit 6 API example with JSpecify annotations:
// (simplified from actual JUnit 6 source)

@NullMarked  // all unannotated types are non-null by default
public class Assertions {

    // @Nullable return type: assertNull can only be called with a
    // value the compiler considers potentially null
    public static void assertNull(@Nullable Object actual) { ... }

    // Non-null enforced: message MUST be non-null
    public static void assertEquals(
        Object expected,
        Object actual,
        String message  // @NonNull from @NullMarked
    ) { ... }
}

// Kotlin benefit: Kotlin compiler recognises JSpecify annotations
// Smart casts work after assertNotNull():
val result: String? = getValue()
assertNotNull(result)        // Kotlin sees NonNull contract
println(result.length)       // No !! needed -- compiler knows non-null

// JUnit 5 problem:
assertNotNull(result)        // JUnit 5 had no contract
println(result!!.length)     // !! still needed -- compiler didnt know

// JUnit 5 (before): runBlocking required
class NetworkServiceTest {
    @Test
    fun `should fetch user`(): Unit = runBlocking {
        val user = service.fetchUser("user-1")
        assertEquals("Alice", user.name)
    }

    @BeforeEach
    fun setUp(): Unit = runBlocking {
        service = NetworkService()
        service.connect()  // suspend function
    }
}

// JUnit 6 (now): suspend directly supported
class NetworkServiceTest {
    @Test
    suspend fun `should fetch user`() {  // No runBlocking needed!
        val user = service.fetchUser("user-1")
        assertEquals("Alice", user.name)
    }

    @BeforeEach
    suspend fun setUp() {   // Lifecycle methods can also be suspend
        service = NetworkService()
        service.connect()   // suspend function -- no wrapping needed
    }

    @AfterEach
    suspend fun tearDown() {
        service.disconnect()
    }
}

// IMPORTANT NOTE: JUnit 6's suspend support is equivalent to
// runBlocking -- it does NOT replace kotlin-coroutines-test
// for testing concurrent behaviour, StateFlow, etc.
// For full coroutine test control, use kotlinx-coroutines-test's
// runTest in addition to JUnit 6.

// Custom extension: time each test and log slow ones
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@ExtendWith(TimingExtension.class)
public @interface Timed { long thresholdMs() default 100; }

public class TimingExtension
        implements BeforeTestExecutionCallback, AfterTestExecutionCallback {

    private static final String START = "start_time";

    @Override
    public void beforeTestExecution(ExtensionContext ctx) {
        ctx.getStore(GLOBAL).put(START, System.currentTimeMillis());
    }

    @Override
    public void afterTestExecution(ExtensionContext ctx) {
        long start = ctx.getStore(GLOBAL).remove(START, long.class);
        long elapsed = System.currentTimeMillis() - start;
        Timed ann = ctx.getRequiredTestMethod().getAnnotation(Timed.class);
        if (ann != null && elapsed > ann.thresholdMs()) {
            System.out.printf("[SLOW] %s took %dms%n",
                ctx.getDisplayName(), elapsed);
        }
    }
}

// Usage:
@Test
@Timed(thresholdMs = 200)
void slowIntegrationTest() { ... }

import org.junit.jupiter.api.*;

@DisplayName("Shopping cart")
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
class ShoppingCartTest {

    Cart cart;

    @BeforeEach
    void init() { cart = new Cart(); }

    @Test @Order(1)
    @DisplayName("is empty on creation")
    void isEmpty() { assertTrue(cart.isEmpty()); }

    // @TestMethodOrder(MethodOrderer.OrderAnnotation.class) inherited
    // by @Nested classes in JUnit 6 -- no need to repeat the annotation
    @Nested
    @DisplayName("when items are added")
    class WhenItemsAdded {

        @BeforeEach
        void addItems() { cart.add(new Item("apple", 1.00)); }

        @Test @Order(1)
        @DisplayName("is not empty")
        void isNotEmpty() { assertFalse(cart.isEmpty()); }

        @Test @Order(2)
        @DisplayName("total reflects added items")
        void totalIsCorrect() { assertEquals(1.00, cart.total()); }

        @Nested
        @DisplayName("when item is removed")
        class WhenItemRemoved {

            @BeforeEach
            void remove() { cart.remove("apple"); }

            @Test @Order(1)
            @DisplayName("is empty again")
            void isEmptyAgain() { assertTrue(cart.isEmpty()); }
        }
    }
}

// @ParameterizedTest: repeats one method
class OrderTest {
    @ParameterizedTest
    @CsvSource({"PENDING,false", "SHIPPED,true", "CANCELLED,true"})
    void isFinalStatus(Status status, boolean expected) {
        assertEquals(expected, status.isFinal());
    }
    // Problem: if 10 methods need the same data source, you repeat
    // the annotation 10 times
}

// @ParameterizedClass: repeats the WHOLE class (JUnit 6)
@ParameterizedClass
@CsvSource({"PENDING,false", "SHIPPED,true", "CANCELLED,true"})
class StatusTest {

    @Parameter(0) Status status;      // field injection
    @Parameter(1) boolean expectedFinal;

    @Test
    void isFinalStatus() {
        assertEquals(expectedFinal, status.isFinal());
    }

    @Test
    void descriptionIsNotEmpty() {
        assertFalse(status.description().isBlank());
    }

    @Test
    void statusToStringContainsName() {
        assertTrue(status.toString().contains(status.name()));
    }

    // All 3 tests run for each of the 3 CSV rows:
    // 9 total test executions instead of 3x@ParameterizedTest
}

// Display name format in JUnit 6: "status = PENDING, expectedFinal = false"
// JUnit 5 style was: "status=PENDING, expectedFinal=false" (no spaces)

// JUnit 5: this was silently accepted (malformed CSV)
@CsvSource({"'foo'INVALID,'bar'"})

// JUnit 6: throws exception -- "extra characters after closing quote"
// Fix: remove the extra characters
@CsvSource({"'foo','bar'"})

// JUnit 5: @CsvFileSource with explicit line separator
@CsvFileSource(resources = "/data.csv", lineSeparator = "\n")
// JUnit 6: lineSeparator removed -- auto-detected
@CsvFileSource(resources = "/data.csv")
// Auto-detection handles \r, \n, and \r\n correctly

// New in JUnit 6: configure commentCharacter
// Previously # was hardcoded and conflicted with some delimiters
@CsvSource(
    value = {"1, 2, 3", "# this is a comment"},
    commentCharacter = '#'   // can now be customised or disabled
)
void additionTest(int a, int b, int expected) { ... }

// JUnit 5: @RunWith(JUnitPlatform.class) -- REMOVED
@RunWith(JUnitPlatform.class)  // Does not exist in JUnit 6
public class MyJUnit4Suite { ... }

// JUnit 6: use @Suite directly
@Suite
@SelectClasses({OrderTest.class, UserTest.class})
public class MyTestSuite { }

// JUnit 5: MethodOrderer.Alphanumeric -- REMOVED
@TestMethodOrder(MethodOrderer.Alphanumeric.class)  // Compile error in JUnit 6
class OldOrderedTest { ... }

// JUnit 6: use MethodOrderer.MethodName instead
@TestMethodOrder(MethodOrderer.MethodName.class)
class OrderedTest { ... }

// Check for removed APIs before upgrading:
// grep -r "JUnitPlatform\|Alphanumeric\|platform-runner\|platform-jfr" src/

<!-- Step 1: Update the BOM version in pom.xml -->
<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.junit</groupId>
      <artifactId>junit-bom</artifactId>
      <version>6.1.1</version>  <!-- was 5.14.x -->
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

<!-- Step 2: Update Maven Surefire/Failsafe to 3.x -->
<!-- (versions older than 3.0.0 are no longer supported by JUnit 6) -->
<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-surefire-plugin</artifactId>
  <version>3.5.0</version>
</plugin>

<!-- Gradle: -->
// build.gradle.kts
dependencies {
    testImplementation(platform("org.junit:junit-bom:6.1.1"))
    testImplementation("org.junit.jupiter:junit-jupiter")
}
tasks.test {
    useJUnitPlatform()
}

/* Step 3: Fix compiler errors from removed APIs:
   - Replace Alphanumeric with MethodName
   - Remove junit-platform-runner dependency
   - Remove @RunWith(JUnitPlatform.class) usages
   - Fix malformed @CsvSource data (extra chars after quotes)
   - Ensure Java 17+ baseline

   Step 4: Run the test suite and fix any FastCSV-related
   failures from stricter CSV parsing */

import static org.junit.jupiter.api.Assumptions.*;

class AssumptionsDemo {

    @Test
    void runOnlyOnCi() {
        // Abort (skip) the test if CI environment variable is not set
        assumeTrue("true".equals(System.getenv("CI")),
            "Skipping: not running in CI environment");
        // Test only executes here if the assumption held
        performSlowIntegrationTest();
    }

    @Test
    void runOnlyOnLinux() {
        assumeTrue(System.getProperty("os.name").startsWith("Linux"));
        // OS-specific test code
    }

    @Test
    void assumptionWithSupplierMessage() {
        // Lazy message evaluation
        String env = System.getenv("APP_ENV");
        assumeFalse("production".equals(env),
            () -> "Skipping destructive test in env: " + env);
        cleanDatabase();
    }

    @Test
    void runSubsetOnlyWhenDatabaseAvailable() {
        // assumingThat: run a block only if condition holds
        // but do NOT abort the whole test
        boolean dbAvailable = isDatabaseAvailable();
        assumingThat(dbAvailable, () -> {
            // Only this block is skipped if db is unavailable
            assertDbRecordExists("user-1");
        });
        // This assertion always runs:
        assertFalse(dbAvailable && isReadOnly());
    }
}

// Default: PER_METHOD (new instance per test)
class DefaultLifecycleTest {
    int count = 0;

    @Test void first()  { count++; assertEquals(1, count); }  // pass
    @Test void second() { count++; assertEquals(1, count); }  // pass
    // Each @Test gets its own instance, so count starts at 0 each time
}

// PER_CLASS: single shared instance
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
class SharedInstanceTest {
    int count = 0;

    @Test @Order(1) void first()  { count++; assertEquals(1, count); }
    @Test @Order(2) void second() { count++; assertEquals(2, count); }
    // Same instance: count accumulates across tests

    // Benefits of PER_CLASS:
    // 1. @BeforeAll and @AfterAll can be NON-STATIC
    @BeforeAll
    void setUpAll() {  // no static required!
        database = Database.connect();
    }

    @AfterAll
    void tearDownAll() {  // no static required!
        database.close();
    }

    // 2. Shared expensive state (database, server)
    //    without static fields
    Database database;
}

// @ExtendWith: declarative, no configuration
@ExtendWith(MockitoExtension.class)
class SimpleTest { ... }

// @RegisterExtension: programmatic, configurable
class ConfigurableTest {

    // Static field: extension scope covers ALL tests (like @BeforeAll)
    @RegisterExtension
    static WireMockExtension server =
        WireMockExtension.newInstance()
            .options(WireMockConfiguration.options().port(8089))
            .build();

    // Instance field: extension scope covers EACH test (like @BeforeEach)
    @RegisterExtension
    TempDirectory tempDir = new TempDirectory();

    @Test
    void callsExternalApi() {
        server.stubFor(get("/orders")
            .willReturn(aResponse().withStatus(200)));
        // test code
    }

    @Test
    void writesToTempFile() throws IOException {
        Path file = tempDir.getRoot().resolve("output.txt");
        Files.writeString(file, "hello");
        assertEquals("hello", Files.readString(file));
    }
}

// Key rule: static @RegisterExtension field
// -> extension callbacks run around the class (BeforeAll/AfterAll)
// Instance @RegisterExtension field
// -> callbacks run around each test (BeforeEach/AfterEach)

import org.junit.jupiter.api.io.TempDir;
import java.nio.file.Path;
import java.io.File;

class TempDirTest {

    // Method parameter injection: per-test temp directory
    @Test
    void writesAndReadsFile(@TempDir Path tempDir) throws Exception {
        Path file = tempDir.resolve("report.txt");
        Files.writeString(file, "Test output");
        assertEquals("Test output", Files.readString(file));
        // Directory is automatically deleted after the test
    }

    // Field injection: same directory reused across tests in class
    @TempDir
    static Path sharedTempDir;  // static = shared across all tests

    @Test
    void firstTestUsesSharedDir() throws Exception {
        Files.writeString(sharedTempDir.resolve("a.txt"), "hello");
    }

    @Test
    void secondTestSeesFilesFromFirst() throws Exception {
        // sharedTempDir persists between tests (static)
        assertTrue(Files.exists(sharedTempDir.resolve("a.txt")));
    }

    // Can also inject as java.io.File:
    @Test
    void withFileType(@TempDir File tempDir) {
        File output = new File(tempDir, "result.csv");
        // ... file operations
    }
}

import org.junit.jupiter.api.DynamicTest;
import org.junit.jupiter.api.TestFactory;
import static org.junit.jupiter.api.DynamicTest.dynamicTest;

class DynamicTestsDemo {

    // Basic: generate tests from a list at runtime
    @TestFactory
    Stream<DynamicTest> dynamicAdditionTests() {
        return Stream.of(
            dynamicTest("1 + 1 = 2", () -> assertEquals(2, 1 + 1)),
            dynamicTest("5 + 3 = 8", () -> assertEquals(8, 5 + 3)),
            dynamicTest("-1 + 1 = 0", () -> assertEquals(0, -1 + 1))
        );
    }

    // Useful: load test data from a file, database, or API at runtime
    @TestFactory
    Stream<DynamicTest> testsFromDatabase() {
        return testDataRepository.findAll().stream()
            .map(data -> dynamicTest(
                "Validate: " + data.id(),
                () -> {
                    Result result = service.process(data);
                    assertEquals(data.expectedStatus(), result.status());
                    assertNotNull(result.processedAt());
                }
            ));
    }

    // Dynamic node containers (hierarchical dynamic tests)
    @TestFactory
    Stream<DynamicNode> hierarchical() {
        return Stream.of(
            dynamicContainer("Positive numbers",
                Stream.of(
                    dynamicTest("1 is positive", () -> assertTrue(1 > 0)),
                    dynamicTest("100 is positive", () -> assertTrue(100 > 0))
                )
            )
        );
    }
}

# Enable parallel execution in junit-platform.properties
# (src/test/resources/junit-platform.properties)

# Enable parallelism globally
junit.jupiter.execution.parallel.enabled=true

# Strategy: dynamic (uses available processors)
junit.jupiter.execution.parallel.config.strategy=dynamic
junit.jupiter.execution.parallel.config.dynamic.factor=1.5

# OR: fixed thread count
junit.jupiter.execution.parallel.config.strategy=fixed
junit.jupiter.execution.parallel.config.fixed.parallelism=4

# Default mode: all test classes run sequentially,
# all methods within a class run sequentially.
# Override with:
junit.jupiter.execution.parallel.mode.default=concurrent
junit.jupiter.execution.parallel.mode.classes.default=concurrent

// @Execution annotation: fine-grained control per class or method
import org.junit.jupiter.api.parallel.*;

@Execution(ExecutionMode.CONCURRENT)  // this class runs in parallel
class FastParallelTest {
    @Test void first()  { ... }
    @Test void second() { ... }
}

@Execution(ExecutionMode.SAME_THREAD)  // always sequential
class OrderDependentTest {
    @Test @Order(1) void setup()  { ... }
    @Test @Order(2) void execute(){ ... }
}

// @ResourceLock: prevent concurrent access to shared resources
class DatabaseTest {
    @Test
    @ResourceLock(value = "database", mode = ResourceAccessMode.READ_WRITE)
    void writesToDatabase() { ... }

    @Test
    @ResourceLock(value = "database", mode = ResourceAccessMode.READ)
    void readsFromDatabase() { ... }
    // Reads run concurrently with each other
    // Writes are exclusive (no concurrency with reads or other writes)
}

import org.junit.jupiter.params.ParameterizedClass;
import org.junit.jupiter.params.provider.MethodSource;
import org.junit.jupiter.api.*;

// @ParameterizedClass: the ENTIRE class runs once per argument
@ParameterizedClass
@MethodSource("locales")
@DisplayName("Cart service in locale")
class CartServiceLocaleTest {

    // Arguments injected via constructor or field
    private final Locale locale;

    CartServiceLocaleTest(Locale locale) {
        this.locale = locale;
    }

    static Stream<Locale> locales() {
        return Stream.of(Locale.US, Locale.UK, Locale.DE);
    }

    @Test
    void currencySymbolIsCorrect() {
        CartService svc = new CartService(locale);
        assertNotNull(svc.getCurrencySymbol());
    }

    @Test
    void priceFormattingMatchesLocale() {
        CartService svc = new CartService(locale);
        String price = svc.format(9.99);
        assertTrue(price.contains(svc.getCurrencySymbol()));
    }
}
// Runs 2 tests x 3 locales = 6 test invocations total

// Compare with @ParameterizedTest (method-level):
class CartServiceTest {
    @ParameterizedTest
    @MethodSource("locales")
    void currencySymbolIsCorrect(Locale locale) {  // single method only
        assertNotNull(new CartService(locale).getCurrencySymbol());
    }
}

// JUnit 5: this was silently tolerated (malformed CSV)
@CsvSource({"'foo'INVALID,'bar'"})
void test(String a, String b) { ... }
// ^ JUnit 6: throws exception -- extra chars after closing quote

// JUnit 6: lineSeparator removed -- auto-detected
// JUnit 5:
@CsvFileSource(resources = "/data.csv", lineSeparator = "\n")
// JUnit 6:
@CsvFileSource(resources = "/data.csv")  // lineSeparator attribute gone

// JUnit 6: new commentCharacter attribute (needed if # appears in data)
@CsvSource(value = {
    "#this is a comment -- skipped",
    "1, 2, 3",
}, commentCharacter = '#')
void additionTest(int a, int b, int expected) { ... }

// Conflicting delimiter bug fix (from 6.0.1):
// A regression in 6.0.0 caused exception when delimiter=# in @CsvSource
// because # was ALSO the comment character with no way to override.
// 6.0.1 added commentCharacter attribute to fix this.

// PER_METHOD (default): new instance per test
class DefaultLifecycleTest {
    int counter = 0;

    @Test void firstTest()  { counter++; assertEquals(1, counter); }
    @Test void secondTest() { counter++; assertEquals(1, counter); }  // passes!
    // Each test gets a fresh instance with counter=0
}

// PER_CLASS: single shared instance
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
class SharedInstanceTest {
    int counter = 0;

    @Test void firstTest()  { counter++; assertEquals(1, counter); }
    @Test void secondTest() { counter++; assertEquals(2, counter); }  // passes!
    // Shared instance: counter carries over

    // @BeforeAll and @AfterAll can be non-static:
    @BeforeAll
    void initAll() {
        System.out.println("Runs once, non-static -- only possible with PER_CLASS");
    }
}

// PER_CLASS is common for @Nested tests where
// the outer class must hold shared state accessed by inner classes.

import org.junit.jupiter.api.*;

@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
class OrderedTest {

    @Test @Order(1) void firstStep()  { System.out.println("1"); }
    @Test @Order(2) void secondStep() { System.out.println("2"); }
    @Test @Order(3) void thirdStep()  { System.out.println("3"); }

    // JUnit 6: @TestMethodOrder is inherited by @Nested classes
    @Nested
    class NestedSteps {
        // No @TestMethodOrder needed -- inherited from outer class
        @Test @Order(1) void nestedFirst()  { System.out.println("N1"); }
        @Test @Order(2) void nestedSecond() { System.out.println("N2"); }
    }
}

// Random order with seed (reproducible):
@TestMethodOrder(MethodOrderer.Random.class)
class RandomOrderTest {
    // Set seed for reproducible random:
    // junit.jupiter.execution.order.random.seed=42
    // in junit-platform.properties
}

<!-- BEFORE (JUnit 5 with platform runner) -->
<dependency>
    <groupId>org.junit.platform</groupId>
    <artifactId>junit-platform-runner</artifactId>  <!-- REMOVED in JUnit 6 -->
    <scope>test</scope>
</dependency>

<!-- AFTER (JUnit 6): use Maven Surefire 3.x directly -->
<plugin>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>3.3.0</version>  <!-- Maven Surefire 3.x required for JUnit 6 -->
</plugin>
<!-- Surefire 3.x discovers JUnit Platform tests natively
     without needing junit-platform-runner -->

<!-- jupiter-migrationsupport: deprecated but still present in 6.0.x
     Remove before JUnit 7 ships -->
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-migrationsupport</artifactId>  <!-- DEPRECATED -->
    <scope>test</scope>
</dependency>

<!-- Maven migration: change the BOM version -->
<!-- BEFORE (JUnit 5) -->
<dependency>
    <groupId>org.junit</groupId>
    <artifactId>junit-bom</artifactId>
    <version>5.11.4</version>  <!-- old -->
    <type>pom</type><scope>import</scope>
</dependency>

<!-- AFTER (JUnit 6) -->
<dependency>
    <groupId>org.junit</groupId>
    <artifactId>junit-bom</artifactId>
    <version>6.1.1</version>   <!-- updated -->
    <type>pom</type><scope>import</scope>
</dependency>

<!-- Kotlin tests: remove runBlocking -->
// BEFORE
@Test
fun fetchUser(): Unit = runBlocking {
    val u = service.fetchUser("1")
    assertEquals("Alice", u.name)
}

// AFTER
@Test
suspend fun fetchUser() {
    val u = service.fetchUser("1")
    assertEquals("Alice", u.name)
}

import static org.junit.jupiter.api.Assumptions.*;

class AssumptionsDemo {

    @Test
    void runOnlyOnLinux() {
        assumeTrue(System.getProperty("os.name").toLowerCase().contains("linux"),
            "Skipped: not running on Linux");
        // Test body: only executes on Linux
        // On Windows/macOS: test is ABORTED (not failed)
    }

    @Test
    void runOnlyInCiEnvironment() {
        // assumingThat: execute body only if condition true; continue otherwise
        assumingThat(
            "CI".equals(System.getenv("ENV")),
            () -> {
                // This block runs only in CI
                verifyDeploymentHealth();
            }
        );
        // This line always runs regardless of the assumption
        assertEquals(1, 1);
    }

    @Test
    void skipOnNullDatabase() {
        assumeFalse(System.getenv("DB_URL") == null,
            "Skipped: DB_URL not configured");
        // Integration test body
    }
}

import org.junit.jupiter.api.io.TempDir;
import org.junit.jupiter.api.io.CleanupMode;

class TempDirDemo {

    // Field injection: directory shared across all tests in class
    @TempDir
    static Path sharedTempDir;

    // Parameter injection: fresh directory per test method
    @Test
    void writeAndReadFile(@TempDir Path tempDir) throws Exception {
        Path file = tempDir.resolve("output.txt");
        Files.writeString(file, "Hello JUnit 6");
        assertEquals("Hello JUnit 6", Files.readString(file));
        // tempDir is automatically deleted after this test
    }

    // JUnit 6: cleanup attribute -- control when directory is deleted
    @Test
    void keepDirOnFailure(
        @TempDir(cleanup = CleanupMode.ON_SUCCESS) Path debugDir
    ) throws Exception {
        Files.writeString(debugDir.resolve("log.txt"), "debug info");
        // If test PASSES: directory is deleted
        // If test FAILS:  directory is KEPT for inspection
    }

    // cleanup modes:
    // ALWAYS (default): always delete
    // ON_SUCCESS:       keep on failure (useful for debugging)
    // NEVER:            never delete (manual cleanup)
}

# junit-platform.properties (in src/test/resources/)

# Enable parallel execution
junit.jupiter.execution.parallel.enabled=true

# Strategy: DYNAMIC (based on CPU count) or FIXED (explicit thread count)
junit.jupiter.execution.parallel.config.strategy=dynamic
junit.jupiter.execution.parallel.config.dynamic.factor=2
# thread count = processor count * factor  (e.g. 4 cores * 2 = 8 threads)

# OR: fixed thread count
# junit.jupiter.execution.parallel.config.strategy=fixed
# junit.jupiter.execution.parallel.config.fixed.parallelism=4

# Default execution mode: SAME_THREAD (sequential) or CONCURRENT
junit.jupiter.execution.parallel.mode.default=concurrent
junit.jupiter.execution.parallel.mode.classes.default=concurrent

// Fine-grained control with @Execution:
import org.junit.jupiter.api.parallel.*;

@Execution(ExecutionMode.CONCURRENT)  // This class runs in parallel
class ParallelTests {

    @Test void test1() { /* can run in parallel with test2 */ }
    @Test void test2() { /* can run in parallel with test1 */ }
}

@Execution(ExecutionMode.SAME_THREAD)  // This class runs sequentially
class SequentialTests {
    // Useful for tests with shared mutable state or DB transactions
}

// @ResourceLock: prevent concurrent access to named resources
@ResourceLock(value = "database", mode = ResourceAccessMode.READ_WRITE)
void dbWriteTest() { /* exclusive DB access */ }

@ResourceLock(value = "database", mode = ResourceAccessMode.READ)
void dbReadTest() { /* shared read access -- can run with other READ tests */ }

// @ExtendWith: declarative, no constructor args
@ExtendWith(MockitoExtension.class)
class MockitoTest {
    @Mock
    UserRepository repo;

    @Test
    void test() { ... }
}

// @RegisterExtension: programmatic, with constructor args
class WireMockTest {

    // Static field -> class-scoped lifecycle (like @BeforeAll/@AfterAll)
    @RegisterExtension
    static WireMockExtension wireMock = WireMockExtension.newInstance()
        .options(wireMockConfig().port(8080))
        .build();

    // Instance field -> method-scoped lifecycle (fresh per test)
    @RegisterExtension
    DatabaseExtension db = new DatabaseExtension("jdbc:h2:mem:test");

    @Test
    void callsExternalService() {
        wireMock.stubFor(get("/api/users").willReturn(okJson("[]")));
        // ...
    }
}

// Multiple extensions can be combined:
@ExtendWith({MockitoExtension.class, SpringExtension.class})
class SpringMockitoTest { ... }

import org.junit.jupiter.api.RepeatedTest;
import org.junit.jupiter.api.RepetitionInfo;

class RepeatedTestDemo {

    // Simple: run exactly 5 times
    @RepeatedTest(5)
    void repeatedTest() {
        assertTrue(Math.random() >= 0.0);
    }

    // Custom display name with placeholders:
    // {displayName}, {currentRepetition}, {totalRepetitions}
    @RepeatedTest(
        value = 5,
        name = "Repetition {currentRepetition} of {totalRepetitions}"
    )
    void namedRepetitions() {
        // Runs 5 times with names: "Repetition 1 of 5", "Repetition 2 of 5"...
    }

    // Inject RepetitionInfo to know which repetition you are in:
    @RepeatedTest(3)
    void withRepetitionInfo(RepetitionInfo info) {
        System.out.printf("Running repetition %d of %d%n",
            info.getCurrentRepetition(),
            info.getTotalRepetitions());

        // Common pattern: fail only on last repetition
        // to verify eventual consistency:
        if (info.getCurrentRepetition() == info.getTotalRepetitions()) {
            assertEquals("done", checkEventualState());
        }
    }
}

// Common use cases for @RepeatedTest:
// - Flaky test isolation (run 10x to catch intermittent failures)
// - Cache warm-up tests (first invocation is slow, later are fast)
// - Thread safety tests (repeated concurrent invocations)
// - Eventual consistency checks (state converges by Nth repetition)

// ExtensionContext.Store: share data between callbacks within an extension
public class TimingExtension
        implements BeforeTestExecutionCallback, AfterTestExecutionCallback {

    // Namespace prevents collisions between multiple extensions
    private static final Namespace NS =
        Namespace.create(TimingExtension.class);

    @Override
    public void beforeTestExecution(ExtensionContext ctx) {
        // Store the start time under this test's context
        getStore(ctx).put("startTime", System.currentTimeMillis());
    }

    @Override
    public void afterTestExecution(ExtensionContext ctx) {
        long startTime = getStore(ctx).remove("startTime", long.class);
        long elapsed   = System.currentTimeMillis() - startTime;
        System.out.printf("%s took %d ms%n", ctx.getDisplayName(), elapsed);
    }

    private ExtensionContext.Store getStore(ExtensionContext ctx) {
        return ctx.getStore(NS);
    }
}

// ExtensionContext key methods:
// ctx.getDisplayName()           -- test display name
// ctx.getRequiredTestMethod()    -- the @Test Method object
// ctx.getRequiredTestClass()     -- the test class
// ctx.getTags()                  -- Set<String> of @Tag values
// ctx.getTestInstance()          -- Optional<Object> test instance
// ctx.getCancellationToken()     -- JUnit 6: cooperative cancellation
// ctx.getStore(namespace)        -- scoped key-value store
// ctx.getRoot()                  -- root context (global scope)

// Annotate tests with @Tag
@Tag("fast")
@Tag("unit")
class FastUnitTest {
    @Test void test1() { ... }
}

@Tag("slow")
@Tag("integration")
class SlowIntegrationTest {
    @Test void dbTest() { ... }
}

// Composed annotation to avoid repetition:
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Tag("fast")
@Tag("unit")
public @interface UnitTest { }

@UnitTest  // same as @Tag("fast") @Tag("unit")
class OrderServiceTest { ... }

<!-- Maven Surefire: run only fast unit tests -->
<plugin>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>3.3.0</version>
    <configuration>
        <groups>fast & unit</groups>
        <excludedGroups>slow | integration</excludedGroups>
    </configuration>
</plugin>

<!-- ConsoleLauncher: tag expression syntax -->
java -jar junit-platform-console-standalone-6.1.1.jar \
    --scan-class-path \
    --include-tag "fast" \
    --exclude-tag "slow"

# Gradle: filter by tag
test {
    useJUnitPlatform {
        includeTags "fast"
        excludeTags "slow", "integration"
    }
}

import org.junit.jupiter.api.DynamicTest;
import org.junit.jupiter.api.TestFactory;
import static org.junit.jupiter.api.DynamicTest.dynamicTest;

class DynamicTestDemo {

    // @TestFactory: generates tests at runtime from a Stream
    @TestFactory
    Stream<DynamicTest> dynamicTestsFromStream() {
        return Stream.of("apple", "banana", "cherry")
            .map(fruit ->
                dynamicTest(
                    "Is non-empty: " + fruit,
                    () -> assertFalse(fruit.isEmpty())
                )
            );
    }

    // Generate tests from external data source (database, file)
    @TestFactory
    Stream<DynamicTest> testsFromDatabase() {
        return testDataRepository.findAll().stream()
            .map(scenario -> dynamicTest(
                scenario.getName(),
                () -> {
                    Result result = service.process(scenario.getInput());
                    assertEquals(scenario.getExpected(), result);
                }
            ));
    }

    // DynamicContainer: nested dynamic structure
    @TestFactory
    Stream<DynamicNode> nestedDynamic() {
        return Stream.of("cats", "dogs")
            .map(category -> DynamicContainer.dynamicContainer(
                "Tests for " + category,
                Stream.of(
                    dynamicTest("has species", () -> assertNotNull(category)),
                    dynamicTest("is not empty", () -> assertFalse(category.isEmpty()))
                )
            ));
    }
}

<!-- Maven: complete JUnit 6 setup -->
<properties>
    <java.version>17</java.version>
    <maven.compiler.source>17</maven.compiler.source>
    <maven.compiler.target>17</maven.compiler.target>
</properties>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.junit</groupId>
            <artifactId>junit-bom</artifactId>
            <version>6.1.1</version>
            <type>pom</type><scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

<build>
    <plugins>
        <plugin>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>3.3.0</version>  <!-- 3.x required for JUnit 6 -->
        </plugin>
    </plugins>
</build>

// Gradle: complete JUnit 6 setup (build.gradle.kts)
plugins {
    java
}

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(17)
    }
}

dependencies {
    testImplementation(platform("org.junit:junit-bom:6.1.1"))
    testImplementation("org.junit.jupiter:junit-jupiter")
    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
}

tasks.test {
    useJUnitPlatform()          // Required: tells Gradle to use JUnit Platform
    maxParallelForks = Runtime.getRuntime().availableProcessors()
}

import org.junit.platform.suite.api.*;

// Basic suite: select specific test classes
@Suite
@SelectClasses({
    OrderServiceTest.class,
    PaymentServiceTest.class,
    InventoryServiceTest.class
})
class SmokeTestSuite {}

// Suite by package (runs all tests in the package)
@Suite
@SelectPackages({"com.example.unit", "com.example.integration"})
class AllTestsSuite {}

// Suite with tag filtering
@Suite
@SelectPackages("com.example")
@IncludeTags("fast")
@ExcludeTags({"slow", "integration"})
class FastTestSuite {}

// Suite with class name pattern
@Suite
@SelectPackages("com.example")
@IncludeClassNamePatterns(".*IT")   // only classes ending in IT
class IntegrationTestSuite {}

// Maven: run suites explicitly
// <configuration>
//   <includes>
//     <include>**/*Suite.class</include>
//   </includes>
// </configuration>

// Custom ParameterResolver: inject a configured HttpClient
public class HttpClientExtension
        implements ParameterResolver, BeforeEachCallback, AfterEachCallback {

    private final Map<ExtensionContext, HttpClient> clients = new ConcurrentHashMap<>();

    @Override
    public boolean supportsParameter(
            ParameterContext paramCtx,
            ExtensionContext extCtx) {
        // Only resolve HttpClient parameters
        return paramCtx.getParameter().getType() == HttpClient.class;
    }

    @Override
    public Object resolveParameter(
            ParameterContext paramCtx,
            ExtensionContext extCtx) {
        // Create and return an HttpClient for this test
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(5))
            .build();
        clients.put(extCtx, client);
        return client;
    }

    @Override
    public void afterEach(ExtensionContext ctx) {
        HttpClient client = clients.remove(ctx);
        if (client != null) client.close();
    }
}

// Usage:
@ExtendWith(HttpClientExtension.class)
class ApiIntegrationTest {

    @Test
    void fetchUsers(HttpClient client) {  // injected by extension!
        HttpResponse<String> resp = client.send(
            HttpRequest.newBuilder(URI.create("https://api.example.com/users")).build(),
            HttpResponse.BodyHandlers.ofString()
        );
        assertEquals(200, resp.statusCode());
    }
}

import org.junit.jupiter.api.condition.*;

class ConditionalTests {

    @Test
    @EnabledOnOs(OS.LINUX)
    void linuxOnlyTest() { ... }

    @Test
    @DisabledOnOs({OS.WINDOWS, OS.MAC})
    void notOnWindowsOrMac() { ... }

    @Test
    @EnabledOnJre(JRE.JAVA_21)
    void java21Feature() { ... }

    @Test
    @EnabledForJreRange(min = JRE.JAVA_17, max = JRE.JAVA_21)
    void java17to21Only() { ... }

    @Test
    @EnabledIfEnvironmentVariable(named = "ENV", matches = "CI")
    void ciOnlyTest() { ... }

    @Test
    @EnabledIfSystemProperty(named = "db.available", matches = "true")
    void databaseTest() { ... }

    // @EnabledIf: call a custom static method
    @Test
    @EnabledIf("isWeekend")
    void weekendTest() { ... }

    static boolean isWeekend() {
        DayOfWeek day = LocalDate.now().getDayOfWeek();
        return day == DayOfWeek.SATURDAY || day == DayOfWeek.SUNDAY;
    }
}