junit5中Assertions替代了Assert

原創 二师兄-公众号-程序新视界 2020-03-06 18:06

最近基於Spring Boot2.x版本中的JUnit5進行單元測試，發現Assert類已經不存在了，在JUnit5中使用Assertions進行替代。而且Junit5不僅僅替代了這麼一個類，還有其他大量的類被重新定義和替換，在使用的時候大家需要留意。

同時Assertions中也提供了更多的方法，相關源碼實現如下：

@API(
    status = Status.STABLE,
    since = "5.0"
)
public class Assertions {
    @API(
        status = Status.STABLE,
        since = "5.3"
    )
    protected Assertions() {
    }

    public static <V> V fail() {
        AssertionUtils.fail();
        return null;
    }

    public static <V> V fail(String message) {
        AssertionUtils.fail(message);
        return null;
    }

    public static <V> V fail(String message, Throwable cause) {
        AssertionUtils.fail(message, cause);
        return null;
    }

    public static <V> V fail(Throwable cause) {
        AssertionUtils.fail(cause);
        return null;
    }

    public static <V> V fail(Supplier<String> messageSupplier) {
        AssertionUtils.fail(messageSupplier);
        return null;
    }

    public static void assertTrue(boolean condition) {
        AssertTrue.assertTrue(condition);
    }

    public static void assertTrue(boolean condition, Supplier<String> messageSupplier) {
        AssertTrue.assertTrue(condition, messageSupplier);
    }

    public static void assertTrue(BooleanSupplier booleanSupplier) {
        AssertTrue.assertTrue(booleanSupplier);
    }

    public static void assertTrue(BooleanSupplier booleanSupplier, String message) {
        AssertTrue.assertTrue(booleanSupplier, message);
    }

    public static void assertTrue(boolean condition, String message) {
        AssertTrue.assertTrue(condition, message);
    }

    public static void assertTrue(BooleanSupplier booleanSupplier, Supplier<String> messageSupplier) {
        AssertTrue.assertTrue(booleanSupplier, messageSupplier);
    }

    public static void assertFalse(boolean condition) {
        AssertFalse.assertFalse(condition);
    }

    public static void assertFalse(boolean condition, String message) {
        AssertFalse.assertFalse(condition, message);
    }

    public static void assertFalse(boolean condition, Supplier<String> messageSupplier) {
        AssertFalse.assertFalse(condition, messageSupplier);
    }

    public static void assertFalse(BooleanSupplier booleanSupplier) {
        AssertFalse.assertFalse(booleanSupplier);
    }

    public static void assertFalse(BooleanSupplier booleanSupplier, String message) {
        AssertFalse.assertFalse(booleanSupplier, message);
    }

    public static void assertFalse(BooleanSupplier booleanSupplier, Supplier<String> messageSupplier) {
        AssertFalse.assertFalse(booleanSupplier, messageSupplier);
    }

    public static void assertNull(Object actual) {
        AssertNull.assertNull(actual);
    }

    public static void assertNull(Object actual, String message) {
        AssertNull.assertNull(actual, message);
    }

    public static void assertNull(Object actual, Supplier<String> messageSupplier) {
        AssertNull.assertNull(actual, messageSupplier);
    }

    public static void assertNotNull(Object actual) {
        AssertNotNull.assertNotNull(actual);
    }

    public static void assertNotNull(Object actual, String message) {
        AssertNotNull.assertNotNull(actual, message);
    }

    public static void assertNotNull(Object actual, Supplier<String> messageSupplier) {
        AssertNotNull.assertNotNull(actual, messageSupplier);
    }

    public static void assertEquals(short expected, short actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(short expected, Short actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(Short expected, short actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Short expected, Short actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(short expected, short actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(short expected, Short actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(Short expected, short actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Short expected, Short actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(short expected, short actual, Supplier<String> messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(short expected, Short actual, Supplier<String> messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(Short expected, short actual, Supplier<String> messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Short expected, Short actual, Supplier<String> messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(byte expected, byte actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(byte expected, Byte actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(Byte expected, byte actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Byte expected, Byte actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(byte expected, byte actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(byte expected, Byte actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(Byte expected, byte actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Byte expected, Byte actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(byte expected, byte actual, Supplier<String> messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(byte expected, Byte actual, Supplier<String> messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(Byte expected, byte actual, Supplier<String> messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Byte expected, Byte actual, Supplier<String> messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(int expected, int actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(int expected, Integer actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(Integer expected, int actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Integer expected, Integer actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(int expected, int actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(int expected, Integer actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(Integer expected, int actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Integer expected, Integer actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(int expected, int actual, Supplier<String> messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(int expected, Integer actual, Supplier<String> messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(Integer expected, int actual, Supplier<String> messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Integer expected, Integer actual, Supplier<String> messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(long expected, long actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(long expected, Long actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(Long expected, long actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Long expected, Long actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(long expected, long actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(long expected, Long actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(Long expected, long actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Long expected, Long actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(long expected, long actual, Supplier<String> messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(long expected, Long actual, Supplier<String> messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(Long expected, long actual, Supplier<String> messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Long expected, Long actual, Supplier<String> messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(float expected, float actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(float expected, Float actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(Float expected, float actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Float expected, Float actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(float expected, float actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(float expected, Float actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(Float expected, float actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Float expected, Float actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(float expected, float actual, Supplier<String> messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(float expected, Float actual, Supplier<String> messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(Float expected, float actual, Supplier<String> messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Float expected, Float actual, Supplier<String> messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(float expected, float actual, float delta) {
        AssertEquals.assertEquals(expected, actual, delta);
    }

    public static void assertEquals(float expected, float actual, float delta, String message) {
        AssertEquals.assertEquals(expected, actual, delta, message);
    }

    public static void assertEquals(float expected, float actual, float delta, Supplier<String> messageSupplier) {
        AssertEquals.assertEquals(expected, actual, delta, messageSupplier);
    }

    public static void assertEquals(double expected, double actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(double expected, Double actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(Double expected, double actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Double expected, Double actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(double expected, double actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(double expected, Double actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(Double expected, double actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Double expected, Double actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(double expected, double actual, Supplier<String> messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(double expected, Double actual, Supplier<String> messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(Double expected, double actual, Supplier<String> messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Double expected, Double actual, Supplier<String> messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(double expected, double actual, double delta) {
        AssertEquals.assertEquals(expected, actual, delta);
    }

    public static void assertEquals(double expected, double actual, double delta, String message) {
        AssertEquals.assertEquals(expected, actual, delta, message);
    }

    public static void assertEquals(double expected, double actual, double delta, Supplier<String> messageSupplier) {
        AssertEquals.assertEquals(expected, actual, delta, messageSupplier);
    }

    public static void assertEquals(char expected, char actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(char expected, Character actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(Character expected, char actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Character expected, Character actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(char expected, char actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(char expected, Character actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(Character expected, char actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Character expected, Character actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(char expected, char actual, Supplier<String> messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(char expected, Character actual, Supplier<String> messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(Character expected, char actual, Supplier<String> messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertEquals(Character expected, Character actual, Supplier<String> messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertEquals(Object expected, Object actual) {
        AssertEquals.assertEquals(expected, actual);
    }

    public static void assertEquals(Object expected, Object actual, String message) {
        AssertEquals.assertEquals(expected, actual, message);
    }

    public static void assertEquals(Object expected, Object actual, Supplier<String> messageSupplier) {
        AssertEquals.assertEquals(expected, actual, messageSupplier);
    }

    public static void assertArrayEquals(boolean[] expected, boolean[] actual) {
        AssertArrayEquals.assertArrayEquals(expected, actual);
    }

    public static void assertArrayEquals(boolean[] expected, boolean[] actual, String message) {
        AssertArrayEquals.assertArrayEquals(expected, actual, message);
    }

    public static void assertArrayEquals(boolean[] expected, boolean[] actual, Supplier<String> messageSupplier) {
        AssertArrayEquals.assertArrayEquals(expected, actual, messageSupplier);
    }

    public static void assertArrayEquals(char[] expected, char[] actual) {
        AssertArrayEquals.assertArrayEquals(expected, actual);
    }

    public static void assertArrayEquals(char[] expected, char[] actual, String message) {
        AssertArrayEquals.assertArrayEquals(expected, actual, message);
    }

    public static void assertArrayEquals(char[] expected, char[] actual, Supplier<String> messageSupplier) {
        AssertArrayEquals.assertArrayEquals(expected, actual, messageSupplier);
    }

    public static void assertArrayEquals(byte[] expected, byte[] actual) {
        AssertArrayEquals.assertArrayEquals(expected, actual);
    }

    public static void assertArrayEquals(byte[] expected, byte[] actual, String message) {
        AssertArrayEquals.assertArrayEquals(expected, actual, message);
    }

    public static void assertArrayEquals(byte[] expected, byte[] actual, Supplier<String> messageSupplier) {
        AssertArrayEquals.assertArrayEquals(expected, actual, messageSupplier);
    }

    public static void assertArrayEquals(short[] expected, short[] actual) {
        AssertArrayEquals.assertArrayEquals(expected, actual);
    }

    public static void assertArrayEquals(short[] expected, short[] actual, String message) {
        AssertArrayEquals.assertArrayEquals(expected, actual, message);
    }

    public static void assertArrayEquals(short[] expected, short[] actual, Supplier<String> messageSupplier) {
        AssertArrayEquals.assertArrayEquals(expected, actual, messageSupplier);
    }

    public static void assertArrayEquals(int[] expected, int[] actual) {
        AssertArrayEquals.assertArrayEquals(expected, actual);
    }

    public static void assertArrayEquals(int[] expected, int[] actual, String message) {
        AssertArrayEquals.assertArrayEquals(expected, actual, message);
    }

    public static void assertArrayEquals(int[] expected, int[] actual, Supplier<String> messageSupplier) {
        AssertArrayEquals.assertArrayEquals(expected, actual, messageSupplier);
    }

    public static void assertArrayEquals(long[] expected, long[] actual) {
        AssertArrayEquals.assertArrayEquals(expected, actual);
    }

    public static void assertArrayEquals(long[] expected, long[] actual, String message) {
        AssertArrayEquals.assertArrayEquals(expected, actual, message);
    }

    public static void assertArrayEquals(long[] expected, long[] actual, Supplier<String> messageSupplier) {
        AssertArrayEquals.assertArrayEquals(expected, actual, messageSupplier);
    }

    public static void assertArrayEquals(float[] expected, float[] actual) {
        AssertArrayEquals.assertArrayEquals(expected, actual);
    }

    public static void assertArrayEquals(float[] expected, float[] actual, String message) {
        AssertArrayEquals.assertArrayEquals(expected, actual, message);
    }

    public static void assertArrayEquals(float[] expected, float[] actual, Supplier<String> messageSupplier) {
        AssertArrayEquals.assertArrayEquals(expected, actual, messageSupplier);
    }

    public static void assertArrayEquals(float[] expected, float[] actual, float delta) {
        AssertArrayEquals.assertArrayEquals(expected, actual, delta);
    }

    public static void assertArrayEquals(float[] expected, float[] actual, float delta, String message) {
        AssertArrayEquals.assertArrayEquals(expected, actual, delta, message);
    }

    public static void assertArrayEquals(float[] expected, float[] actual, float delta, Supplier<String> messageSupplier) {
        AssertArrayEquals.assertArrayEquals(expected, actual, delta, messageSupplier);
    }

    public static void assertArrayEquals(double[] expected, double[] actual) {
        AssertArrayEquals.assertArrayEquals(expected, actual);
    }

    public static void assertArrayEquals(double[] expected, double[] actual, String message) {
        AssertArrayEquals.assertArrayEquals(expected, actual, message);
    }

    public static void assertArrayEquals(double[] expected, double[] actual, Supplier<String> messageSupplier) {
        AssertArrayEquals.assertArrayEquals(expected, actual, messageSupplier);
    }

    public static void assertArrayEquals(double[] expected, double[] actual, double delta) {
        AssertArrayEquals.assertArrayEquals(expected, actual, delta);
    }

    public static void assertArrayEquals(double[] expected, double[] actual, double delta, String message) {
        AssertArrayEquals.assertArrayEquals(expected, actual, delta, message);
    }

    public static void assertArrayEquals(double[] expected, double[] actual, double delta, Supplier<String> messageSupplier) {
        AssertArrayEquals.assertArrayEquals(expected, actual, delta, messageSupplier);
    }

    public static void assertArrayEquals(Object[] expected, Object[] actual) {
        AssertArrayEquals.assertArrayEquals(expected, actual);
    }

    public static void assertArrayEquals(Object[] expected, Object[] actual, String message) {
        AssertArrayEquals.assertArrayEquals(expected, actual, message);
    }

    public static void assertArrayEquals(Object[] expected, Object[] actual, Supplier<String> messageSupplier) {
        AssertArrayEquals.assertArrayEquals(expected, actual, messageSupplier);
    }

    public static void assertIterableEquals(Iterable<?> expected, Iterable<?> actual) {
        AssertIterableEquals.assertIterableEquals(expected, actual);
    }

    public static void assertIterableEquals(Iterable<?> expected, Iterable<?> actual, String message) {
        AssertIterableEquals.assertIterableEquals(expected, actual, message);
    }

    public static void assertIterableEquals(Iterable<?> expected, Iterable<?> actual, Supplier<String> messageSupplier) {
        AssertIterableEquals.assertIterableEquals(expected, actual, messageSupplier);
    }

    public static void assertLinesMatch(List<String> expectedLines, List<String> actualLines) {
        AssertLinesMatch.assertLinesMatch(expectedLines, actualLines);
    }

    public static void assertLinesMatch(List<String> expectedLines, List<String> actualLines, String message) {
        AssertLinesMatch.assertLinesMatch(expectedLines, actualLines, message);
    }

    public static void assertLinesMatch(List<String> expectedLines, List<String> actualLines, Supplier<String> messageSupplier) {
        AssertLinesMatch.assertLinesMatch(expectedLines, actualLines, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(byte unexpected, byte actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(byte unexpected, Byte actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Byte unexpected, byte actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Byte unexpected, Byte actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(byte unexpected, byte actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(byte unexpected, Byte actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Byte unexpected, byte actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Byte unexpected, Byte actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(byte unexpected, byte actual, Supplier<String> messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(byte unexpected, Byte actual, Supplier<String> messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Byte unexpected, byte actual, Supplier<String> messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Byte unexpected, Byte actual, Supplier<String> messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(short unexpected, short actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(short unexpected, Short actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Short unexpected, short actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Short unexpected, Short actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(short unexpected, short actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(short unexpected, Short actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Short unexpected, short actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Short unexpected, Short actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(short unexpected, short actual, Supplier<String> messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(short unexpected, Short actual, Supplier<String> messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Short unexpected, short actual, Supplier<String> messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Short unexpected, Short actual, Supplier<String> messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(int unexpected, int actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(int unexpected, Integer actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Integer unexpected, int actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Integer unexpected, Integer actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(int unexpected, int actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(int unexpected, Integer actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Integer unexpected, int actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Integer unexpected, Integer actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(int unexpected, int actual, Supplier<String> messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(int unexpected, Integer actual, Supplier<String> messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Integer unexpected, int actual, Supplier<String> messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Integer unexpected, Integer actual, Supplier<String> messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(long unexpected, long actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(long unexpected, Long actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Long unexpected, long actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Long unexpected, Long actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(long unexpected, long actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(long unexpected, Long actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Long unexpected, long actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Long unexpected, Long actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(long unexpected, long actual, Supplier<String> messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(long unexpected, Long actual, Supplier<String> messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Long unexpected, long actual, Supplier<String> messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Long unexpected, Long actual, Supplier<String> messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(float unexpected, float actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(float unexpected, Float actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Float unexpected, float actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Float unexpected, Float actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(float unexpected, float actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(float unexpected, Float actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Float unexpected, float actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Float unexpected, Float actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(float unexpected, float actual, Supplier<String> messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(float unexpected, Float actual, Supplier<String> messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Float unexpected, float actual, Supplier<String> messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Float unexpected, Float actual, Supplier<String> messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(float unexpected, float actual, float delta) {
        AssertNotEquals.assertNotEquals(unexpected, actual, delta);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(float unexpected, float actual, float delta, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, delta, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(float unexpected, float actual, float delta, Supplier<String> messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, delta, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(double unexpected, double actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(double unexpected, Double actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Double unexpected, double actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Double unexpected, Double actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(double unexpected, double actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(double unexpected, Double actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Double unexpected, double actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Double unexpected, Double actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(double unexpected, double actual, Supplier<String> messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(double unexpected, Double actual, Supplier<String> messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Double unexpected, double actual, Supplier<String> messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Double unexpected, Double actual, Supplier<String> messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(double unexpected, double actual, double delta) {
        AssertNotEquals.assertNotEquals(unexpected, actual, delta);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(double unexpected, double actual, double delta, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, delta, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(double unexpected, double actual, double delta, Supplier<String> messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, delta, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(char unexpected, char actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(char unexpected, Character actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Character unexpected, char actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Character unexpected, Character actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(char unexpected, char actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(char unexpected, Character actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Character unexpected, char actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Character unexpected, Character actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(char unexpected, char actual, Supplier<String> messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(char unexpected, Character actual, Supplier<String> messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Character unexpected, char actual, Supplier<String> messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.4"
    )
    public static void assertNotEquals(Character unexpected, Character actual, Supplier<String> messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    public static void assertNotEquals(Object unexpected, Object actual) {
        AssertNotEquals.assertNotEquals(unexpected, actual);
    }

    public static void assertNotEquals(Object unexpected, Object actual, String message) {
        AssertNotEquals.assertNotEquals(unexpected, actual, message);
    }

    public static void assertNotEquals(Object unexpected, Object actual, Supplier<String> messageSupplier) {
        AssertNotEquals.assertNotEquals(unexpected, actual, messageSupplier);
    }

    public static void assertSame(Object expected, Object actual) {
        AssertSame.assertSame(expected, actual);
    }

    public static void assertSame(Object expected, Object actual, String message) {
        AssertSame.assertSame(expected, actual, message);
    }

    public static void assertSame(Object expected, Object actual, Supplier<String> messageSupplier) {
        AssertSame.assertSame(expected, actual, messageSupplier);
    }

    public static void assertNotSame(Object unexpected, Object actual) {
        AssertNotSame.assertNotSame(unexpected, actual);
    }

    public static void assertNotSame(Object unexpected, Object actual, String message) {
        AssertNotSame.assertNotSame(unexpected, actual, message);
    }

    public static void assertNotSame(Object unexpected, Object actual, Supplier<String> messageSupplier) {
        AssertNotSame.assertNotSame(unexpected, actual, messageSupplier);
    }

    public static void assertAll(Executable... executables) throws MultipleFailuresError {
        AssertAll.assertAll(executables);
    }

    public static void assertAll(String heading, Executable... executables) throws MultipleFailuresError {
        AssertAll.assertAll(heading, executables);
    }

    public static void assertAll(Collection<Executable> executables) throws MultipleFailuresError {
        AssertAll.assertAll(executables);
    }

    public static void assertAll(String heading, Collection<Executable> executables) throws MultipleFailuresError {
        AssertAll.assertAll(heading, executables);
    }

    public static void assertAll(Stream<Executable> executables) throws MultipleFailuresError {
        AssertAll.assertAll(executables);
    }

    public static void assertAll(String heading, Stream<Executable> executables) throws MultipleFailuresError {
        AssertAll.assertAll(heading, executables);
    }

    public static <T extends Throwable> T assertThrows(Class<T> expectedType, Executable executable) {
        return AssertThrows.assertThrows(expectedType, executable);
    }

    public static <T extends Throwable> T assertThrows(Class<T> expectedType, Executable executable, String message) {
        return AssertThrows.assertThrows(expectedType, executable, message);
    }

    public static <T extends Throwable> T assertThrows(Class<T> expectedType, Executable executable, Supplier<String> messageSupplier) {
        return AssertThrows.assertThrows(expectedType, executable, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.2"
    )
    public static void assertDoesNotThrow(Executable executable) {
        AssertDoesNotThrow.assertDoesNotThrow(executable);
    }

    @API(
        status = Status.STABLE,
        since = "5.2"
    )
    public static void assertDoesNotThrow(Executable executable, String message) {
        AssertDoesNotThrow.assertDoesNotThrow(executable, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.2"
    )
    public static void assertDoesNotThrow(Executable executable, Supplier<String> messageSupplier) {
        AssertDoesNotThrow.assertDoesNotThrow(executable, messageSupplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.2"
    )
    public static <T> T assertDoesNotThrow(ThrowingSupplier<T> supplier) {
        return AssertDoesNotThrow.assertDoesNotThrow(supplier);
    }

    @API(
        status = Status.STABLE,
        since = "5.2"
    )
    public static <T> T assertDoesNotThrow(ThrowingSupplier<T> supplier, String message) {
        return AssertDoesNotThrow.assertDoesNotThrow(supplier, message);
    }

    @API(
        status = Status.STABLE,
        since = "5.2"
    )
    public static <T> T assertDoesNotThrow(ThrowingSupplier<T> supplier, Supplier<String> messageSupplier) {
        return AssertDoesNotThrow.assertDoesNotThrow(supplier, messageSupplier);
    }

    public static void assertTimeout(Duration timeout, Executable executable) {
        AssertTimeout.assertTimeout(timeout, executable);
    }

    public static void assertTimeout(Duration timeout, Executable executable, String message) {
        AssertTimeout.assertTimeout(timeout, executable, message);
    }

    public static void assertTimeout(Duration timeout, Executable executable, Supplier<String> messageSupplier) {
        AssertTimeout.assertTimeout(timeout, executable, messageSupplier);
    }

    public static <T> T assertTimeout(Duration timeout, ThrowingSupplier<T> supplier) {
        return AssertTimeout.assertTimeout(timeout, supplier);
    }

    public static <T> T assertTimeout(Duration timeout, ThrowingSupplier<T> supplier, String message) {
        return AssertTimeout.assertTimeout(timeout, supplier, message);
    }

    public static <T> T assertTimeout(Duration timeout, ThrowingSupplier<T> supplier, Supplier<String> messageSupplier) {
        return AssertTimeout.assertTimeout(timeout, supplier, messageSupplier);
    }

    public static void assertTimeoutPreemptively(Duration timeout, Executable executable) {
        AssertTimeout.assertTimeoutPreemptively(timeout, executable);
    }

    public static void assertTimeoutPreemptively(Duration timeout, Executable executable, String message) {
        AssertTimeout.assertTimeoutPreemptively(timeout, executable, message);
    }

    public static void assertTimeoutPreemptively(Duration timeout, Executable executable, Supplier<String> messageSupplier) {
        AssertTimeout.assertTimeoutPreemptively(timeout, executable, messageSupplier);
    }

    public static <T> T assertTimeoutPreemptively(Duration timeout, ThrowingSupplier<T> supplier) {
        return AssertTimeout.assertTimeoutPreemptively(timeout, supplier);
    }

    public static <T> T assertTimeoutPreemptively(Duration timeout, ThrowingSupplier<T> supplier, String message) {
        return AssertTimeout.assertTimeoutPreemptively(timeout, supplier, message);
    }

    public static <T> T assertTimeoutPreemptively(Duration timeout, ThrowingSupplier<T> supplier, Supplier<String> messageSupplier) {
        return AssertTimeout.assertTimeoutPreemptively(timeout, supplier, messageSupplier);
    }
}

其實在真正使用的過程中，只用查看一下源碼或根據類名即可大概瞭解該方法的作用。

精品SpringBoot 2.x視頻教程

《Spring Boot 2.x 視頻教程全家桶》，精品Spring Boot 2.x視頻教程，打造一套最全的Spring Boot 2.x視頻教程。

程序新視界

公衆號“程序新視界”，一個讓你軟實力、硬技術同步提升的平臺

csdn-微信公衆號

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

Netty實戰九之單元測試

ChannelHandler是Netty應用程序的關鍵元素，所以徹底地測試他們應該是你的開發過程的一個標準部分。最佳實踐要求你的測試不僅要能夠證明你的實現是正確的，而且還要能夠很容易地隔離那些因修改代碼而突然出現的問題。這種類型的測試叫做

osc_12m05m5l 2024-05-14 00:19:17

面試官：說說你對序列化的理解

本文主要內容 背景 在Java語言中，程序運行的時候，會產生很多對象，而對象信息也只是在程序運行的時候纔在內存中保持其狀態，一旦程序停止，內存釋放，對象也就不存在了。 怎麼能讓對象永久的保存下來呢？--------對象序列化 。 何

osc_61miaq6u 2024-05-13 22:58:28

雲效 Pipeline as Code 來了！這些場景，用好它效率翻倍！

從可視化編排到支持 YAML 編排 雲效流水線 Flow 是開箱即用的企業級持續集成和持續交付工具，支持豐富的代碼源、構建、自動化測試工具、多種部署類型和部署方式，與阿里雲深度集成，還提供多種企業級特性，助力企業高效完成從開發到上線 CIC

原創 2024-05-11 21:15:05

【京東雲新品發佈月刊】2024年4月產品動態

京東雲4月產品動態： 1.【言犀AI虛擬主播】"採銷東哥"數字人是怎樣練成的？ “大家好，好久不見，我是你們的老朋友東哥……”面對衆網友喊話開直播，劉強東以新的形式與大家見面。4月16日下午6點18分，由京東雲言犀打造的“採銷東哥”AI數字

原創 2024-05-10 12:41:31

一種極簡單的SpringBoot單元測試方法| 京東零售技術團隊

前言 本文主要提供了一種單元測試方法，力求0基礎人員可以從本文中受到啓發，可以搭建一套好用的單元測試環境，並能切實的提高交付代碼的質量。極簡體現在除了POM依賴和單元測試類之外，其他什麼都不需要引入，只需要一個本地能啓動的springboo

原創 2024-05-10 00:30:06

降本增笑P0事故頻發，構建持續高可用系統的破局之道

2023年的互聯網世界，“草臺班子”、“降本增笑”、“開猿節流”成爲大家互相調侃的關鍵詞。苦笑過後，問題還在，事故終要覆盤，未來仍需規劃。從架構角度看，我們應該怎麼去認清高可用的本質，並真正在業務場景中做好高可用，這是本文想跟大家探討

原創 2024-05-08 23:17:58

AI 001 號員工通義靈碼入職阿里雲丨阿里云云原生 4 月產品月報

雲原生月度動態 雲原生是企業數字創新的最短路徑。 《阿里云云原生每月動態》，從趨勢熱點、產品新功能、服務客戶、開源與開發者動態等方面，爲企業提供數字化的路徑與指南。 趨勢熱點 🥇 Cloud Native Day - Indonesia 成

原創 2024-05-07 21:12:05

通義靈碼實戰系列：一個新項目如何快速啓動，如何維護遺留系統代碼庫？

作者：別象 進入 2024 年，AI 熱度持續上升，翻閱科技區的文章，AI 可謂是軍書十二卷，卷卷有爺名。而麥肯錫最近的研究報告顯示，軟件工程是 AI 影響最大的領域之一，AI 已經成爲了軟件工程的必選項，也有研究稱開發者每天的事務性工作可

原創 2024-04-30 21:12:20

當「軟件研發」遇上 AI 大模型

作者：陳鑫（神秀） 大家好，我是通義靈碼的產品技術負責人陳鑫。過去有八年時間，我都是在阿里集團做研發效能，即研發工具相關的工作。 我們從 2015 年開始做一站式 DevOps 平臺，然後打造了雲效，也就是將 DevOps 平臺實現雲化。到

原創 2024-04-30 21:12:13

讓研發規範管得住 - 我們爲什麼在流水線之上又做了研發流程？

作者：子醜 爲什麼會有研發規範 很多程序員入職一家新的公司，領完電腦再安裝完必備的開發工具，接下來最先接觸的恐怕就是新公司的研發規範了。幾乎所有的軟件企業都有或繁或簡的一套或多套研發規範，並且大部分軟件團隊都認爲他們的研發規範是不太一樣的，

原創 2024-04-28 21:12:17

流水線運行出錯排查難？AI 來幫你

“我的企業有幾千條流水線，每次流水線運行出錯，都要投入不少的技術人員進去排查，需要花費不少的時間。” 遇到這種情況，怎麼解決。在 AI 爆火的今天，AI 如何助力 DevOps 效率提升？ 雲效與阿里雲通義大模型合作，推出了流水線智能排查能

原創 2024-04-24 21:12:07

“AI 程序員入職系列”第二彈：如何利用通義靈碼光速改寫項目編程語言？

通義靈碼入職阿里云云原生團隊後，已經展示過 Ta 生成單元測試和自動生成代碼的強大實力。今天，阿里雲後端工程師雲徊將從項目開發的實際需求出發，演示通義靈碼在開發工作中可提供的幫助。 通義靈碼在 Git 開發項目中起到了哪些作用？ 雲徊所在的

原創 2024-04-22 21:12:11

下載量超 200 萬，最近頻繁登上熱搜的 AI 程序員，大家怎麼看

人狠話不多，會熟練使用 200 多種編程語言，寫得了代碼，做得了測試，7 天 24 小時隨叫隨到…… 硅基程序員通義靈碼首次入職阿里雲，有網友說：終於不穿格子衫了！ 還有網友說：這簡歷，作爲一個 HR 我很難不心動！ 人狠話不多的通義靈碼，

原創 2024-04-22 21:12:06

寫給職場新人｜從迷茫到屢獲殊榮的技術人成長之路

在這個時代，技術的每一次飛躍都在重塑我們的工作方式。借Up技術人專欄活動寫了這篇文章，回望一下我和計算機打交道的這幾年，希望能給學生或職場新人們一些幫助。 1.錨定方向：學生生涯的一次探險 如果用一個詞語概括我的本科階段，那大概就

原創 2024-04-19 23:17:23

聊聊Swift中的宏

聊聊Swift中的宏 宏，Macros是一種常見的編程技術，傳統的C語言中，即包含了宏功能。宏這種功能，簡單來說是在代碼的預編譯階段進行靜態替換，是一種非運行時的特性。但是往復雜了說，宏實際上也提供了一種”元編程“方式，即對程序本身進行編程

原創 2024-04-18 23:26:09