// FLAKY: static counter shared across all test instances
private static int requestCounter = 0;

@Test
void firstRequestIncreasesCounterToOne() {
    service.processRequest();
    requestCounter++;
    assertEquals(1, requestCounter); // FLAKY if other tests also increment
}

// FIX: reset state before each test with @BeforeEach
private int requestCounter;  // instance field, NOT static

@BeforeEach
void resetCounter() {
    requestCounter = 0;  // fresh state for every test, guaranteed
    service.reset();     // also reset the service under test
}

@Test
void firstRequestIncreasesCounterToOne() {
    service.processRequest();
    requestCounter++;
    assertEquals(1, requestCounter); // always passes: counter starts at 0
}

org.opentest4j.AssertionFailedError: Order status should be CONFIRMED     <-- 1. Custom message (your clue)
  expected: <CONFIRMED>                                                    <-- 2. What you expected
   but was: <PENDING>                                                      <-- 3. What actually happened
	 at com.example.OrderServiceTest.lambda$0(OrderServiceTest.java:47)      <-- 4. Lambda inside assertAll
	 at org.junit.jupiter.api.AssertAll...                                   <-- framework frames (ignore)
	 at com.example.OrderServiceTest.placingValidOrderConfirmsIt(            <-- 5. Your test method
              OrderServiceTest.java:43)                                     <-- 6. Exact line in YOUR code

Decomposing the failure:
  1. "Order status should be CONFIRMED" — written by you in assertEquals(CONFIRMED, ..., "Order status..")
  2. expected: CONFIRMED — what the test asserts
  3. but was: PENDING   — what the code returned — THE REAL CLUE
  4. Lambda line — the assertion inside assertAll
  5+6. Your test method at line 43 — go here first

# Run just the failing test class
mvn test -Dtest=OrderServiceTest

# Run just the failing method
mvn test -Dtest=OrderServiceTest#placingValidOrderConfirmsIt

# Gradle equivalent
./gradlew test --tests "com.example.OrderServiceTest.placingValidOrderConfirmsIt"

# Run with verbose output to see all System.out from the test
mvn test -Dtest=OrderServiceTest -Dsurefire.useFile=false

<!-- BEFORE: JUnit 4 -->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
    <scope>test</scope>
</dependency>

<!-- AFTER: JUnit 6 aggregator + Vintage engine for gradual migration -->
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>6.0.0</version>
    <scope>test</scope>
</dependency>

<!-- Vintage engine: allows JUnit 4 tests to run on JUnit 6 Platform during migration -->
<dependency>
    <groupId>org.junit.vintage</groupId>
    <artifactId>junit-vintage-engine</artifactId>
    <version>6.0.0</version>
    <scope>test</scope>
</dependency>

// TOO DRY: setup extracted so aggressively that test is unreadable in isolation
@BeforeEach
void setUp() {
    // 40 lines of setup that 8 different tests depend on
    // Reader must scroll up to understand what ANY test is doing
}

@Test
void testScenarioA() {
    result = service.doThing(complexSharedObject);
    assertEquals("expected-A", result);
    // What is complexSharedObject? Requires scrolling. Confusing.
}

// DAMP: each test is self-contained and understandable alone
@Test
@DisplayName("Premium customer receives 20% loyalty discount")
void premiumCustomerReceivesTwentyPercentDiscount() {
    // Arrange: ALL context right here—no scrolling required
    Customer premiumCustomer = Customer.builder()
        .id(1L)
        .tier(CustomerTier.PREMIUM)
        .loyaltyPoints(5000)
        .build();
    Order order = new Order(null, premiumCustomer, 100.00);

    // Act
    double finalPrice = discountService.applyLoyaltyDiscount(order);

    // Assert
    assertEquals(80.00, finalPrice, 0.001,
        "Premium customers with 5000+ points get 20% off");
}

// UNIT TEST: Tests OrderService in complete isolation.
// No Spring context, no database, no HTTP — dependencies mocked.
@ExtendWith(MockitoExtension.class)
@DisplayName("OrderService — unit tests")
class OrderServiceUnitTest {

    @Mock private OrderRepository orderRepository; // mocked
    @Mock private PaymentGateway  paymentGateway;  // mocked
    @Mock private EmailService    emailService;    // mocked
    @InjectMocks private OrderService orderService; // real class under test

    @Test
    @Tag("unit")
    @DisplayName("Placing a valid order saves it and sends a confirmation email")
    void placingValidOrderSavesItAndSendsEmail() {
        // Arrange: define mock behaviour
        Order savedOrder = new Order(1L, "[email protected]", 49.99, OrderStatus.CONFIRMED);
        when(paymentGateway.authorise(anyDouble())).thenReturn("AUTH-001");
        when(orderRepository.save(any())).thenReturn(savedOrder);

        // Act
        Order result = orderService.place("[email protected]", 49.99);

        // Assert behaviour AND interactions
        assertEquals(OrderStatus.CONFIRMED, result.getStatus());
        verify(emailService, times(1)).sendConfirmation("[email protected]");
    }

    @Test
    @Tag("unit")
    @DisplayName("Payment gateway failure cancels order immediately")
    void paymentGatewayFailureCancelsOrder() {
        when(paymentGateway.authorise(anyDouble()))
            .thenThrow(new PaymentDeclinedException("Card declined"));

        assertThrows(PaymentDeclinedException.class,
            () -> orderService.place("[email protected]", 49.99));

        // Repository must NOT be called if payment fails
        verifyNoInteractions(orderRepository, emailService);
    }
}