// This test uses BOTH JUnit 6 and Mockito — each doing its own job

import org.junit.jupiter.api.*;          // JUnit 6: @Test, @BeforeEach, @DisplayName
import org.mockito.*;                    // Mockito: @Mock, @InjectMocks
import org.mockito.junit.jupiter.*;      // Bridge: connects the two
import static org.junit.jupiter.api.Assertions.*; // JUnit 6: assertions
import static org.mockito.Mockito.*;     // Mockito: when(), verify()

// JUnit 6 discovers and runs this class
@ExtendWith(MockitoExtension.class)  // Mockito registers as a JUnit 6 extension
class OrderServiceTest {

    // ---- Mockito's job: create fake dependencies ----
    @Mock
    private OrderRepository orderRepository; // fake repository

    @Mock
    private EmailService emailService;       // fake email service

    @InjectMocks
    private OrderService orderService;       // real class under test

    // ---- JUnit 6's job: lifecycle management ----
    @BeforeEach
    void printTestStart() {
        System.out.println("Test starting...");
    }

    // ---- JUnit 6's job: discover and execute this test ----
    @Test
    @DisplayName("Placing an order persists it and sends a confirmation email")
    void placingOrderPersistsItAndSendsEmail() {

        // ---- Mockito's job: define stub behaviour ----
        Order savedOrder = new Order(1L, "[email protected]", 99.99, OrderStatus.CONFIRMED);
        when(orderRepository.save(any(Order.class))).thenReturn(savedOrder);

        // ---- The actual call under test ----
        Order result = orderService.placeOrder("[email protected]", 99.99);

        // ---- JUnit 6's job: assert the result ----
        assertNotNull(result.getId(),              "Order ID must be assigned");
        assertEquals(OrderStatus.CONFIRMED,        result.getStatus());

        // ---- Mockito's job: verify interactions ----
        verify(orderRepository, times(1)).save(any(Order.class));
        verify(emailService, times(1)).sendConfirmation("[email protected]");
    }
}

// Production class:
public class EmailValidator {
    public boolean isValid(String email) {
        if (email == null || email.isBlank()) return false;
        return email.matches("^[A-Za-z0-9+_.-]+@[A-Za-z0-9.-]+.[A-Za-z]{2,}$");
    }
}

// You type the class declaration and first @Test, Copilot fills in the rest:
class EmailValidatorTest {

    private final EmailValidator validator = new EmailValidator();

    // -- GitHub Copilot generated the following tests --

    @Test
    @DisplayName("Valid email address returns true")
    void validEmailAddressReturnsTrue() {
        assertTrue(validator.isValid("[email protected]"));
    }

    @Test
    @DisplayName("Null email returns false")
    void nullEmailReturnsFalse() {
        assertFalse(validator.isValid(null));
    }

    @Test
    @DisplayName("Empty email returns false")
    void emptyEmailReturnsFalse() {
        assertFalse(validator.isValid(""));
    }

    @Test
    @DisplayName("Email without @ returns false")
    void emailWithoutAtSignReturnsFalse() {
        assertFalse(validator.isValid("userexample.com"));
    }

    // Copilot also suggested:
    @ParameterizedTest(name = "Valid: {0}")
    @ValueSource(strings = {
        "[email protected]",
        "[email protected]",
        "[email protected]"
    })
    void validEmailFormatsReturnTrue(String validEmail) {
        assertTrue(validator.isValid(validEmail),
            validEmail + " should be a valid email");
    }

    @ParameterizedTest(name = "Invalid: {0}")
    @NullAndEmptySource
    @ValueSource(strings = {"plainaddress", "@missing-local.com", "missing-tld@example"})
    void invalidEmailFormatsReturnFalse(String invalidEmail) {
        assertFalse(validator.isValid(invalidEmail),
            invalidEmail + " should be an invalid email");
    }
}

<dependency>
    <groupId>net.jqwik</groupId>
    <artifactId>jqwik</artifactId>
    <version>1.9.0</version>
    <scope>test</scope>
</dependency>

<!-- jqwik runs on the JUnit Platform — ensure Surefire is 3.x -->
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>3.2.5</version>
</plugin>

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

class StringUtilsPropertyTest {

    // @Property runs this test ~1000 times with different random String values
    // @ForAll means jqwik generates arbitrary values of that type
    @Property
    void reversingAStringTwiceYieldsOriginal(@ForAll String anyString) {
        // Property: reverse(reverse(s)) == s for ANY string
        String reversed = StringUtils.reverse(anyString);
        String doubleReversed = StringUtils.reverse(reversed);

        assertEquals(anyString, doubleReversed,
            "Reversing any string twice must return the original string");
    }

    @Property
    void reversedStringHasSameLength(@ForAll String anyString) {
        // Property: reversing a string never changes its length
        assertEquals(anyString.length(), StringUtils.reverse(anyString).length(),
            "Reversed string must have same length as original");
    }
}

// WRONG: tests internal implementation details
@Test
void testOrderService() {
    orderService.placeOrder(order);
    // Verifying internal calls — breaks if you refactor without changing behaviour
    verify(orderRepository).findByCustomerId(anyLong());
    verify(cacheService).invalidate("orders:customer:1");
    verify(metricsService).increment("orders.placed");
    verify(auditLogger).log(any(AuditEvent.class));
    // This test breaks if you rename a method, add a cache layer, or change logging
}

// CORRECT: tests observable behaviour
@Test
@DisplayName("Placing an order persists it and confirms via email")
void placingOrderPersistsItAndSendsConfirmation() {
    Order placed = orderService.placeOrder(order);

    // Verify what the consumer of this service observes
    assertNotNull(placed.getId(),              "Order must be assigned an ID");
    assertEquals(OrderStatus.CONFIRMED,        placed.getStatus());
    verify(emailService).sendConfirmation(order.getCustomerEmail()); // external contract
    // Internal caching, metrics, auditing: tested in their own unit tests
}

// WRONG: failure message is cryptic
assertEquals("CONFIRMED", order.getStatus().name());
// Failure: expected: <CONFIRMED> but was: <PENDING>
// No context: WHICH order? After WHAT operation? In WHAT test scenario?

// CORRECT: failure message explains context
assertEquals(OrderStatus.CONFIRMED, order.getStatus(),
    "Order should be CONFIRMED after successful payment authorisation, "
    + "got: " + order.getStatus()
    + ", payment result: " + order.getPaymentResult());
// Failure message now contains everything needed to diagnose without running the test again