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

@Test
@DisplayName("Placing a valid order confirms it")
void placingValidOrderConfirmsIt() {
    Order createdOrder = orderService.place("[email protected]", 99.99);

    // Diagnostic: print intermediate state to understand what is happening
    System.out.println("[DEBUG] Created order: " + createdOrder);
    System.out.println("[DEBUG] Order status: " + createdOrder.getStatus());
    System.out.println("[DEBUG] Payment result: " + createdOrder.getPaymentResult());

    // More granular assertions to pinpoint exactly where it goes wrong
    assertNotNull(createdOrder,                    "Order must be created");
    assertNotNull(createdOrder.getId(),             "Order ID must be assigned");
    assertNotNull(createdOrder.getPaymentResult(), "Payment must be processed before status check");
    assertTrue(createdOrder.getPaymentResult().isSuccessful(),
        "Payment must succeed: " + createdOrder.getPaymentResult().getErrorCode());

    // Final assertion: only fails here if all above pass
    assertEquals(OrderStatus.CONFIRMED, createdOrder.getStatus(),
        "Order should be CONFIRMED after successful payment, was: "
        + createdOrder.getStatus() + ", payment: " + createdOrder.getPaymentResult());
}

// Failure:
// java.lang.NullPointerException at OrderServiceTest.java:35

// Root cause checklist:
// 1. Is the object under test initialised in @BeforeEach?
// 2. Is @InjectMocks used but a required mock is missing?
// 3. Did the method return null when you expected an object?
// 4. Is there a @BeforeAll that should be static but is not?

// Fix: ensure setup is correct
@BeforeEach
void setUp() {
    // Was this missing or called from a wrong lifecycle method?
    orderService = new OrderService(orderRepository, emailService);
    // Or: @InjectMocks handles this if @ExtendWith(MockitoExtension.class) is present
}

// Assert non-null before using the result
Order order = orderService.create("[email protected]", 49.99);
assertNotNull(order, "create() must not return null for valid input"); // catch it here
assertNotNull(order.getId(), "Order ID must be set after creation");

// Symptom: mvn test -Dtest=OrderServiceTest passes, but mvn test fails
// Root cause: shared mutable state between tests

// BAD: static state shared across all tests
private static List<Order> globalOrderList = new ArrayList<>();

@Test
void testA() {
    globalOrderList.add(new Order()); // adds to shared state
    assertEquals(1, globalOrderList.size()); // passes alone
}

@Test
void testB() {
    globalOrderList.add(new Order()); // now list has 2 items because testA ran first
    assertEquals(1, globalOrderList.size()); // FAILS when testA ran before it
}

// FIX: instance state reset by @BeforeEach
private List<Order> orderList;

@BeforeEach
void setUp() {
    orderList = new ArrayList<>(); // fresh list for every test
}

@Test
void testA() {
    orderList.add(new Order());
    assertEquals(1, orderList.size()); // always passes
}

@Test
void testB() {
    orderList.add(new Order());
    assertEquals(1, orderList.size()); // always passes, independent of testA
}

// Failure:
// org.mockito.exceptions.misusing.UnnecessaryStubbingException:
// Unnecessary stubbing detected in test class OrderServiceTest

// Root cause: you stubbed a mock but the test never called the stubbed method
// MockitoExtension (strict mode) detects this — it is a sign of dead test code

// BAD: stub not needed for THIS test
@Test
void testOrderCreation() {
    when(emailService.send(any())).thenReturn(true);  // never called in this test
    Order order = orderService.createDraftOrder();    // doesn't send emails
    assertEquals(OrderStatus.DRAFT, order.getStatus());
}

// FIX 1: Remove the unnecessary stub
@Test
void testOrderCreation() {
    Order order = orderService.createDraftOrder();
    assertEquals(OrderStatus.DRAFT, order.getStatus());
}

// FIX 2: If the stub is needed only sometimes, use lenient() stubbing
@Test
void testOrderCreation() {
    lenient().when(emailService.send(any())).thenReturn(true); // won't fail if unused
    Order order = orderService.createDraftOrder();
    assertEquals(OrderStatus.DRAFT, order.getStatus());
}

// Confusing failure message:
// expected: <PENDING> but was: <CONFIRMED>
// Wait — PENDING is what the code returned? That seems backwards...

// Root cause: arguments are swapped — actual value passed as 'expected'
// WRONG order:
assertEquals(order.getStatus(), OrderStatus.CONFIRMED); // actual first!

// Failure message: "expected: <PENDING> but was: <CONFIRMED>"
// This is backwards and deeply confusing

// CORRECT order: expected value FIRST, actual value SECOND
assertEquals(OrderStatus.CONFIRMED, order.getStatus(), "Order status");
// Failure message: "Order status expected: <CONFIRMED> but was: <PENDING>"
// Now it reads correctly: you expected CONFIRMED, got PENDING