import org.junit.jupiter.api.Timeout;
import java.util.concurrent.TimeUnit;

class OrderSearchPerformanceTest {

    // @Timeout: test fails if it takes longer than the specified duration
    // Applied at method level
    @Test
    @Timeout(value = 2, unit = TimeUnit.SECONDS)
    @Tag("performance")
    @DisplayName("Searching orders by customer email returns within 2 seconds")
    void searchingOrdersByEmailReturnsWithinTwoSeconds() {
        List<Order> results = orderRepository.findByEmail("[email protected]");
        assertNotNull(results);
        // If this takes >2s, test fails with:
        // org.opentest4j.AssertionFailedError: method timed out after 2 seconds
    }

    // Apply @Timeout at class level to set a default for ALL tests in the class
    @Timeout(5) // 5 seconds default for every test
    class AllSearchesMustBeFast {

        @Test
        void searchByEmailIsWithin5Seconds() { /* ... */ }

        @Test
        @Timeout(1) // override: this specific test must complete in 1 second
        void searchByIdIsWithin1Second() { /* ... */ }
    }
}

// Global timeout: set in junit-platform.properties
// junit.jupiter.execution.timeout.default=30s  (safety net for all tests)

import java.time.Duration;
import static org.junit.jupiter.api.Assertions.assertTimeout;

class DataProcessorPerformanceTest {

    @Test
    @Tag("performance")
    @DisplayName("Processing 10,000 records completes within 500ms")
    void processingTenThousandRecordsCompletesWithinFiveHundredMs() {
        List<Record> tenThousandRecords = generateTestRecords(10_000);

        // assertTimeout: runs the executable and fails if it takes longer than the duration
        // The executable always runs to completion (unlike assertTimeoutPreemptively)
        List<ProcessedRecord> results = assertTimeout(
            Duration.ofMillis(500),
            () -> dataProcessor.processAll(tenThousandRecords),
            "Processing 10,000 records should complete within 500ms on any hardware"
        );

        // Can also assert on the returned result
        assertEquals(10_000, results.size(), "All records must be processed");
    }

    @Test
    @DisplayName("Sorting 100,000 integers is faster than Comparable baseline")
    void customSorterFasterThanJavaBaseline() {
        List<Integer> data = IntStream.range(0, 100_000)
            .boxed().collect(Collectors.toList());
        Collections.shuffle(data, new Random(42)); // reproducible input

        // Measure Java built-in sort as baseline
        long javaStart = System.nanoTime();
        Collections.sort(new ArrayList<>(data));
        long javaMs = (System.nanoTime() - javaStart) / 1_000_000;

        // Measure custom sorter
        long customStart = System.nanoTime();
        customSorter.sort(new ArrayList<>(data));
        long customMs = (System.nanoTime() - customStart) / 1_000_000;

        assertTrue(customMs <= javaMs * 2,
            "Custom sorter should not be more than 2x slower than Java's built-in sort. "
            + "Java: " + javaMs + "ms, Custom: " + customMs + "ms");
    }
}

<dependency>
    <groupId>org.openjdk.jmh</groupId>
    <artifactId>jmh-core</artifactId>
    <version>1.37</version>
</dependency>
<dependency>
    <groupId>org.openjdk.jmh</groupId>
    <artifactId>jmh-generator-annprocess</artifactId>
    <version>1.37</version>
</dependency>

import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.infra.Blackhole;
import java.util.concurrent.TimeUnit;

// JMH benchmark for OrderService.findByEmail() performance
@BenchmarkMode(Mode.AverageTime)   // measure average time per operation
@OutputTimeUnit(TimeUnit.MICROSECONDS)  // report in microseconds
@State(Scope.Thread)               // each benchmark thread has its own state
@Warmup(iterations = 5, time = 1)  // 5 warm-up iterations x 1 second each
@Measurement(iterations = 10, time = 1) // 10 measurement iterations
@Fork(2)                           // run in 2 separate JVM forks for independence
public class OrderSearchBenchmark {

    private OrderRepository orderRepository;
    private List<String> testEmails;

    // @Setup: runs once before the benchmark to prepare state
    @Setup
    public void setUp() {
        orderRepository = new InMemoryOrderRepository();
        testEmails      = generateTestEmails(1000);
        seedTestOrders(orderRepository, testEmails);
    }

    // @Benchmark: the method to measure
    @Benchmark
    public void findOrderByEmail(Blackhole blackhole) {
        // Blackhole: consumes the result to prevent JIT dead-code elimination
        String email  = testEmails.get(0);
        List<Order> orders = orderRepository.findByEmail(email);
        blackhole.consume(orders);
    }

    @Benchmark
    public void findOrdersByStatusAndPage(Blackhole blackhole) {
        List<Order> orders = orderRepository.findByStatus(OrderStatus.PENDING, 0, 20);
        blackhole.consume(orders);
    }
}

// Run from main or JUnit 6 test:
public class RunBenchmarks {
    public static void main(String[] args) throws RunnerException {
        Options options = new OptionsBuilder()
            .include(OrderSearchBenchmark.class.getSimpleName())
            .build();
        new Runner(options).run();
    }
}

import org.openjdk.jmh.results.RunResult;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import java.util.Collection;

// Run JMH benchmark FROM a JUnit 6 test and assert on results
@Tag("performance")
class OrderSearchPerformanceBenchmarkTest {

    @Test
    @Timeout(value = 5, unit = TimeUnit.MINUTES) // JMH needs time to warm up
    @DisplayName("findByEmail benchmark: average time must be under 50 microseconds")
    void findByEmailBenchmarkMeetsPerformanceTarget() throws Exception {
        Options benchmarkOptions = new OptionsBuilder()
            .include(OrderSearchBenchmark.class.getSimpleName() + ".findOrderByEmail")
            .warmupIterations(3)   // fewer iterations for CI speed
            .measurementIterations(5)
            .forks(1)
            .build();

        Collection<RunResult> results = new Runner(benchmarkOptions).run();

        for (RunResult result : results) {
            double averageTimeUs = result.getPrimaryResult().getScore();
            // Assert: must be under 50 microseconds per call
            assertTrue(averageTimeUs < 50.0,
                "findByEmail average time " + averageTimeUs
                + " us exceeds 50 us threshold — performance regression detected!");
        }
    }
}