ALevin配置环境所需要的基础包——JUnit

/* * Copyright 2015-2021 the original author or authors. * * All rights reserved. This program and the accompanying materials are * made available under the terms of the Eclipse Public License v2.0 which * accompanies this distribution and is available at * * https://www.eclipse.org/legal/epl-v20.html */ package org.junit.jupiter.api; import static org.apiguardian.api.API.Status.EXPERIMENTAL; import static org.apiguardian.api.API.Status.STABLE; import java.time.Duration; import java.util.Arrays; import java.util.Collection; import java.util.List; import java.util.Objects; import java.util.function.BooleanSupplier; import java.util.function.Supplier; import java.util.stream.Stream; import org.apiguardian.api.API; import org.junit.jupiter.api.function.Executable; import org.junit.jupiter.api.function.ThrowingSupplier; import org.opentest4j.MultipleFailuresError; /** * {@code Assertions} is a collection of utility methods that support asserting * conditions in tests. * * <p>Unless otherwise noted, a <em>failed</em> assertion will throw an * {@link org.opentest4j.AssertionFailedError} or a subclass thereof. * * <h3>Object Equality</h3> * * <p>Assertion methods comparing two objects for <em>equality</em>, such as the * {@code assertEquals(expected, actual)} and {@code assertNotEquals(unexpected, actual)} * variants, are <em>only</em> intended to test equality for an (un-)expected value * and an actual value. They are not designed for testing whether a class correctly * implements {@link Object#equals(Object)}. For example, {@code assertEquals()} * might immediately return {@code true} when provided the same object for the * expected and actual values, without calling {@code equals(Object)} at all. * Tests that aim to verify the {@code equals(Object)} implementation should instead * be written to explicitly verify the {@link Object#equals(Object)} contract by * using {@link #assertTrue(boolean) assertTrue()} or {@link #assertFalse(boolean) * assertFalse()} &mdash; for example, {@code assertTrue(expected.equals(actual))}, * {@code assertTrue(actual.equals(expected))}, {@code assertFalse(expected.equals(null))}, * etc. * * <h3>Kotlin Support</h3> * * <p>Additional <a href="https://kotlinlang.org/">Kotlin</a> assertions can be * found as <em>top-level functions</em> in the {@link org.junit.jupiter.api} * package. * * <h3>Preemptive Timeouts</h3> * * <p>The various {@code assertTimeoutPreemptively()} methods in this class * execute the provided {@code executable} or {@code supplier} in a different * thread than that of the calling code. This behavior can lead to undesirable * side effects if the code that is executed within the {@code executable} or * {@code supplier} relies on {@link ThreadLocal} storage. * * <p>One common example of this is the transactional testing support in the Spring * Framework. Specifically, Spring's testing support binds transaction state to * the current thread (via a {@code ThreadLocal}) before a test method is invoked. * Consequently, if an {@code executable} or {@code supplier} provided to * {@code assertTimeoutPreemptively()} invokes Spring-managed components that * participate in transactions, any actions taken by those components will not be * rolled back with the test-managed transaction. On the contrary, such actions * will be committed to the persistent store (e.g., relational database) even * though the test-managed transaction is rolled back. * * <p>Similar side effects may be encountered with other frameworks that rely on * {@code ThreadLocal} storage. * * <h3>Extensibility</h3> * * <p>Although it is technically possible to extend this class, extension is * strongly discouraged. The JUnit Team highly recommends that the methods * defined in this class be used via <em>static imports</em>. * * @since 5.0 * @see org.opentest4j.AssertionFailedError * @see Assumptions */ @API(status = STABLE, since = "5.0") public class Assertions { /** * Protected constructor allowing subclassing but not direct instantiation. * * @since 5.3 */ @API(status = STABLE, since = "5.3") protected Assertions() { /* no-op */ } // --- fail ---------------------------------------------------------------- /** * <em>Fail</em> the test <em>without</em> a failure message. * * <p>Although failing <em>with</em> an explicit failure message is recommended, * this method may be useful when maintaining legacy code. * * <p>See Javadoc for {@link #fail(String)} for an explanation of this method's * generic return type {@code V}. */ public static <V> V fail() { AssertionUtils.fail(); return null; // appeasing the compiler: this line will never be executed. } /** * <em>Fail</em> the test with the given failure {@code message}. * * <p>The generic return type {@code V} allows this method to be used * directly as a single-statement lambda expression, thereby avoiding the * need to implement a code block with an explicit return value. Since this * method throws an {@link org.opentest4j.AssertionFailedError} before its * return statement, this method never actually returns a value to its caller. * The following example demonstrates how this may be used in practice. * * <pre>{@code * Stream.of().map(entry -> fail("should not be called")); * }</pre> */ public static <V> V fail(String message) { AssertionUtils.fail(message); return null; // appeasing the compiler: this line will never be executed. } /** * <em>Fail</em> the test with the given failure {@code message} as well * as the underlying {@code cause}. * * <p>See Javadoc for {@link #fail(String)} for an explanation of this method's * generic return type {@code V}. */ public static <V> V fail(String message, Throwable cause) { AssertionUtils.fail(message, cause); return null; // appeasing the compiler: this line will never be executed. } /** * <em>Fail</em> the test with the given underlying {@code cause}. * * <p>See Javadoc for {@link #fail(String)} for an explanation of this method's * generic return type {@code V}. */ public static <V> V fail(Throwable cause) { AssertionUtils.fail(cause); return null; // appeasing the compiler: this line will never be executed. } /** * <em>Fail</em> the test with the failure message retrieved from the * given {@code messageSupplier}. * * <p>See Javadoc for {@link #fail(String)} for an explanation of this method's * generic return type {@code V}. */ public static <V> V fail(Supplier<String> messageSupplier) { AssertionUtils.fail(messageSupplier); return null; // appeasing the compiler: this line will never be executed. } // --- assertTrue ---------------------------------------------------------- /** * <em>Assert</em> that the supplied {@code condition} is {@code true}. */ public static void assertTrue(boolean condition) { AssertTrue.assertTrue(condition); } /** * <em>Assert</em> that the supplied {@code condition} is {@code true}. * <p>If necessary, the failure message will be retrieved lazily from the supplied {@code messageSupplier}. */ public static void assertTrue(boolean condition, Supplier<String> messageSupplier) { AssertTrue.assertTrue(condition, messageSupplier); } /** * <em>Assert</em> that the boolean condition supplied by {@code booleanSupplier} is {@code true}. */ public static void assertTrue(BooleanSupplier booleanSupplier) { AssertTrue.assertTrue(booleanSupplier); } /** * <em>Assert</em> that the boolean condition supplied by {@code booleanSupplier} is {@code true}. * <p>Fails with the supplied failure {@code message}. */ public static void assertTrue(BooleanSupplier booleanSupplier, String message) { AssertTrue.assertTrue(booleanSupplier, message); } /** * <em>Assert</em> that the supplied {@code condition} is {@code true}. * <p>Fails with the supplied failure {@code message}. */ public static void assertTrue(b