When diving into the world of Java testing, there’s a nifty feature in JUnit 5 that doesn’t get enough credit: @RepeatedTest. It’s like that trusty backpack you never knew you needed until you were halfway on a hike, snugly holding all those essentials for an error-free adventure. Essentially, it lets you run the same test multiple times, which is pretty cool when you’re trying to ensure your test cases are tough as nails. It’s especially handy for when you’re dealing with flaky tests – you know, those sneaky tests that fail without a valid reason or when randomness is a factor.

Why would you want to repeat a test, you ask? Imagine you’re testing a web app, and there’s this link that’s all touchy — it sometimes flips out with environmental errors, but after a click or two, it’s all sunshine and rainbows. Instead of your test throwing a fit every time and declaring a failure, you replay the scene a few times. Eventually, it learns to keep calm and carry on, giving you more reliable results. And there’s more! Consider scenarios where your code has to deal with unpredictable load times, like switching pages or hitting links that take a mystery tour through cyberspace. Running repeated tests helps you gather a nice average load time, handy for future thresholds.

Plugging @RepeatedTest into JUnit 5? As easy as pie. Picture this:

import org.junit.jupiter.api.RepeatedTest;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class RepeatedTestExample {

    @RepeatedTest(3)
    public void testAddition() {
        int actual = 2 + 3;
        int expected = 5;
        assertEquals(expected, actual);
        System.out.println("Test executed");
    }
}

Voilà, the testAddition method will run thrice — thanks to @RepeatedTest(3). This annotation is like a DJ playing your favorite track on loop.

But wait, there’s a cherry on top: custom display names. They’re like gift tags for your tests, perfect for logging and debugging. Check it:

@RepeatedTest(value = 3, name = "Test run {currentRepetition} of {totalRepetitions}")

It’s like personalizing each test run with its own little title, which is especially useful when scrolling through a gazillion logs.

Now, let’s talk lifecycle callbacks. Think of @BeforeEach and @AfterEach as loyal sidekicks to your tests, brushing up before the party starts and tidying up after everyone’s gone. Every repetition calls them again, which can be a double-edged sword. It’s all good if each test needs a fresh start, but what if they don’t?

Picture this: setup code for things only needed once, or cleanup stuff that shouldn’t be repeated. A workaround? A clever flagging system. Here’s how you do it:

import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.RepeatedTest;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class RepeatedTestExample {

    private boolean setupDone = false;
    private boolean cleanupDone = false;

    @BeforeEach
    void beforeEach() {
        if (!setupDone) {
            System.out.println("Before all tests");
            setupDone = true;
        }
    }

    @AfterEach
    void afterEach() {
        if (!cleanupDone) {
            System.out.println("After all tests");
            cleanupDone = true;
        }
    }

    @RepeatedTest(3)
    public void testAddition() {
        int actual = 2 + 3;
        int expected = 5;
        assertEquals(expected, actual);
        System.out.println("Test executed");
    }
}

But when things get wild, like failing a couple of times with assertEquals, you can wield the failureThreshold option. This is your secret weapon against repeated failures: if you decide a crisis is worth a threshold of two failed runs out of ten, it can skip the rest after reaching said threshold.

import org.junit.jupiter.api.RepeatedTest;
import static org.junit.jupiter.api.Assertions.fail;

public class RepeatedTestExample {

    @RepeatedTest(value = 10, failureThreshold = 2)
    public void testAddition(RepetitionInfo repetitionInfo) {
        if (repetitionInfo.getCurrentRepetition() % 2 == 0) {
            fail("Simulated failure");
        }
        int actual = 2 + 3;
        int expected = 5;
        assertEquals(expected, actual);
        System.out.println("Test executed");
    }
}

Now, one must tread carefully in parallel execution land. @Execution(SAME_THREAD) is your guiding star here, ensuring sequential test execution on the same thread so that the failure threshold behaves predictably.

import org.junit.jupiter.api.Execution;
import org.junit.jupiter.api.RepeatedTest;
import static org.junit.jupiter.api.Assertions.fail;

@Execution(org.junit.jupiter.api.ExecutionMode.SAME_THREAD)
public class RepeatedTestExample {

    @RepeatedTest(value = 10, failureThreshold = 2)
    public void testAddition(RepetitionInfo repetitionInfo) {
        if (repetitionInfo.getCurrentRepetition() % 2 == 0) {
            fail("Simulated failure");
        }
        int actual = 2 + 3;
        int expected = 5;
        assertEquals(expected, actual);
        System.out.println("Test executed");
    }
}

The final word about @RepeatedTest? It’s your hammer in the toolbox of testing, helpful for pounding out inefficiencies and silencing flaky gremlins. Whether your tests resemble a shaky bridge or face inconsistent hurdles, this feature empowers you to craft more resilient, rugged tests.