import org.junit.jupiter.params.provider.ArgumentsSource; //导入依赖的package包/类
@Override
public Stream<TestTemplateInvocationContext> provideTestTemplateInvocationContexts(ExtensionContext context) {
    Method templateMethod = Preconditions.notNull(context.getTestMethod().orElse(null),
            "test method must not be null");
    AutoTestNameFormatter formatter = createNameFormatter(templateMethod);
    AtomicLong invocationCount = new AtomicLong(0L);
    return (Stream) findRepeatableAnnotations(templateMethod, ArgumentsSource.class)
            .stream()
            .map(ArgumentsSource::value)
            .map(ReflectionUtils::newInstance)
            .map(provider -> AnnotationConsumerInitializer.initialize(templateMethod, provider))
            .flatMap(provider -> arguments(provider, context))
            .map(Arguments::get)
            .map((arguments) -> {
                return new AutoTestInvocationContext(formatter, arguments);
            })
            .peek((invocationContext) -> {
                invocationCount.incrementAndGet();
            }).onClose(() -> {
                Preconditions.condition(invocationCount.get() > 0L, () -> {
                    return "当使用注解 @" + AutoTest.class.getSimpleName() + " 的时候,测试方法需要至少一个参数";
                });
            });

}
 

import org.junit.jupiter.params.provider.ArgumentsSource; //导入依赖的package包/类
@ParameterizedTest
@DisplayName("it returns successfully with valid arguments")
@ArgumentsSource(ValidArgumentsProvider.class)
void testValidArgumentsSucceed(Sleep sleep,
                               Duration initialDelay,
                               Duration defaultTimeout,
                               PatientExecutionHandler executionHandler,
                               DelaySupplierFactory delaySupplierFactory,
                               PatientExecutable<Boolean> executable,
                               Predicate<Boolean> filter,
                               Supplier<String> messageSupplier) {
    try {
        Assertions.assertNotNull(getInstance(sleep,
                                             initialDelay,
                                             defaultTimeout,
                                             executionHandler,
                                             delaySupplierFactory,
                                             executable,
                                             filter,
                                             messageSupplier),
                                 "Should have returned a non-null instance for valid arguments.");
    } catch (Throwable thrown) {
        Assertions.fail("Expected to construct a PatientWaitFuture with valid arguments but throwable was caught: " + thrown);
    }
}
 

import org.junit.jupiter.params.provider.ArgumentsSource; //导入依赖的package包/类
@ParameterizedTest
@DisplayName("it returns successfully with valid arguments and a null message")
@ArgumentsSource(ValidArgumentsProvider.class)
void testSucceedsWithNullMessage(Sleep sleep,
                                 Duration initialDelay,
                                 Duration defaultTimeout,
                                 PatientExecutionHandler executionHandler,
                                 DelaySupplierFactory delaySupplierFactory,
                                 PatientExecutable<Boolean> executable,
                                 Predicate<Boolean> filter) {
    try {
        Assertions.assertNotNull(getInstance(sleep,
                                             initialDelay,
                                             defaultTimeout,
                                             executionHandler,
                                             delaySupplierFactory,
                                             executable,
                                             filter,
                                             (String) null),
                                 "Should have returned a non-null instance for valid arguments.");
    } catch (Throwable thrown) {
        Assertions.fail("Expected to construct a PatientWaitFuture with valid arguments but throwable was caught: " + thrown);
    }
}
 

import org.junit.jupiter.params.provider.ArgumentsSource; //导入依赖的package包/类
@ParameterizedTest
@DisplayName("it throws an exception for invalid arguments")
@ArgumentsSource(InvalidArgumentsProvider.class)
void testInvalidArgumentsThrowsException(Sleep sleep,
                                         Duration initialDelay,
                                         Duration defaultTimeout,
                                         PatientExecutionHandler executionHandler,
                                         DelaySupplierFactory delaySupplierFactory,
                                         PatientExecutable<Boolean> executable,
                                         Predicate<Boolean> filter,
                                         Supplier<String> messageSupplier) {
    Assertions.assertThrows(IllegalArgumentException.class,
                            () -> getInstance(sleep,
                                              initialDelay,
                                              defaultTimeout,
                                              executionHandler,
                                              delaySupplierFactory,
                                              executable,
                                              filter,
                                              messageSupplier),
                            "Should have thrown an exception for an invalid argument");
}
 

import org.junit.jupiter.params.provider.ArgumentsSource; //导入依赖的package包/类
@ParameterizedTest
@DisplayName("it returns successfully with valid arguments")
@ArgumentsSource(PatientRetryFutureTest.ValidArgumentsProvider.class)
void testValidArgumentsSucceed(Sleep sleep,
                               Duration initialDelay,
                               int defaultNumberOfRetries,
                               PatientExecutionHandler executionHandler,
                               DelaySupplierFactory delaySupplierFactory,
                               PatientExecutable<Boolean> executable,
                               Predicate<Boolean> filter,
                               Supplier<String> messageSupplier) {
    try {
        Assertions.assertNotNull(getInstance(sleep,
                                             initialDelay,
                                             defaultNumberOfRetries,
                                             executionHandler,
                                             delaySupplierFactory,
                                             executable,
                                             filter,
                                             messageSupplier),
                                 "Should have returned a non-null instance for valid arguments.");
    } catch (Throwable thrown) {
        Assertions.fail("Expected to construct a PatientRetryFuture with valid arguments but throwable was caught: " + thrown);
    }
}
 

import org.junit.jupiter.params.provider.ArgumentsSource; //导入依赖的package包/类
@ParameterizedTest
@DisplayName("it returns successfully with valid arguments and a null message")
@ArgumentsSource(PatientRetryFutureTest.ValidArgumentsProvider.class)
void testSucceedsWithNullMessage(Sleep sleep,
                                 Duration initialDelay,
                                 int defaultNumberOfRetries,
                                 PatientExecutionHandler executionHandler,
                                 DelaySupplierFactory delaySupplierFactory,
                                 PatientExecutable<Boolean> executable,
                                 Predicate<Boolean> filter) {
    try {
        Assertions.assertNotNull(getInstance(sleep,
                                             initialDelay,
                                             defaultNumberOfRetries,
                                             executionHandler,
                                             delaySupplierFactory,
                                             executable,
                                             filter,
                                             (String) null),
                                 "Should have returned a non-null instance for valid arguments.");
    } catch (Throwable thrown) {
        Assertions.fail("Expected to construct a PatientRetryFuture with valid arguments but throwable was caught: " + thrown);
    }
}
 

import org.junit.jupiter.params.provider.ArgumentsSource; //导入依赖的package包/类
@ParameterizedTest
@DisplayName("it throws an exception for invalid arguments")
@ArgumentsSource(PatientRetryFutureTest.InvalidArgumentsProvider.class)
void testInvalidArgumentsThrowsException(Sleep sleep,
                                         Duration initialDelay,
                                         int defaultNumberOfRetries,
                                         PatientExecutionHandler executionHandler,
                                         DelaySupplierFactory delaySupplierFactory,
                                         PatientExecutable<Boolean> executable,
                                         Predicate<Boolean> filter,
                                         Supplier<String> messageSupplier) {
    Assertions.assertThrows(IllegalArgumentException.class,
                            () -> getInstance(sleep,
                                              initialDelay,
                                              defaultNumberOfRetries,
                                              executionHandler,
                                              delaySupplierFactory,
                                              executable,
                                              filter,
                                              messageSupplier),
                            "Should have thrown an exception for an invalid argument");
}
 

import org.junit.jupiter.params.provider.ArgumentsSource; //导入依赖的package包/类
@ParameterizedTest
@ArgumentsSources({ @ArgumentsSource(CustomArgumentsProvider1.class),
        @ArgumentsSource(CustomArgumentsProvider2.class) })
void testWithArgumentsSource(String first, int second) {
    System.out.println("Parameterized test with (String) " + first
            + " and (int) " + second);

    assertNotNull(first);
    assertTrue(second > 0);
}
 

import org.junit.jupiter.params.provider.ArgumentsSource; //导入依赖的package包/类
@ParameterizedTest
@ArgumentsSource(CustomArgumentsProvider1.class)
void testWithArgumentsSource(String first, int second) {
    System.out.println("Parameterized test with (String) " + first
            + " and (int) " + second);

    assertNotNull(first);
    assertTrue(second > 0);
}
 

import org.junit.jupiter.params.provider.ArgumentsSource; //导入依赖的package包/类
@ParameterizedTest
@ArgumentsSource(SerializedMessageRequestsProvider.class)
void testDeserialization(JsonNode json) {
    MoreAssertions.assertSerializable(json,
            MessageRequest.class,
            MessageRequestTests::assertValid);
}
 

import org.junit.jupiter.params.provider.ArgumentsSource; //导入依赖的package包/类
@ParameterizedTest
@ArgumentsSource(SerializedAttachmentsProvider.class)
void testDeserialization(JsonNode json) {
    MoreAssertions.assertSerializable(json,
            Attachment.class,
            AttachmentTests::assertValid);
}
 

import org.junit.jupiter.params.provider.ArgumentsSource; //导入依赖的package包/类
@ParameterizedTest
@ArgumentsSource(SerializedColorsProvider.class)
void testSerialization(JsonNode json) {
    MoreAssertions.assertSerializable(json,
            Color.class,
            ColorTests::assertValid);
}
 

import org.junit.jupiter.params.provider.ArgumentsSource; //导入依赖的package包/类
@ParameterizedTest
@ArgumentsSource(SerializedFootersProvider.class)
void testDeserialization(JsonNode json) {
    MoreAssertions.assertSerializable(json,
            Footer.class,
            FooterTests::assertValid);
}
 

import org.junit.jupiter.params.provider.ArgumentsSource; //导入依赖的package包/类
@ParameterizedTest
@ArgumentsSource(SerializedAuthorsProvider.class)
void testSerialization(JsonNode json) {
    MoreAssertions.assertSerializable(json,
            Author.class,
            AuthorTests::assertValid);
}
 

import org.junit.jupiter.params.provider.ArgumentsSource; //导入依赖的package包/类
@ParameterizedTest
@ArgumentsSource(SerializedFieldsProvider.class)
void testSerialization(JsonNode json) {
    MoreAssertions.assertSerializable(json,
            Field.class,
            FieldTests::assertValid);
}
 

import org.junit.jupiter.params.provider.ArgumentsSource; //导入依赖的package包/类
@ParameterizedTest
@ArgumentsSource(SerializedTitlesProvider.class)
void testDeserialization(JsonNode json) {
    MoreAssertions.assertSerializable(json,
            Title.class,
            TitleTests::assertValid);
}
 

import org.junit.jupiter.params.provider.ArgumentsSource; //导入依赖的package包/类
@ParameterizedTest
@ArgumentsSource(MessageRequestProvider.class)
void testSendMessage(MessageRequest messageRequest, TestInfo testInfo) {
    assertThat(SlackWebHookService.with(assumingEnvironmentWebHookToken())
                    .sendMessage(EnrichTestMessageRequest.get().apply(messageRequest, testInfo)),
            is(equalTo(ResponseCode.OK)));
}
 

import org.junit.jupiter.params.provider.ArgumentsSource; //导入依赖的package包/类
@ParameterizedTest
@DisplayName("it returns a non-null instance successfully for valid arguments")
@ArgumentsSource(ValidArgumentsProvider.class)
void testCanInstantiateWithValidArguments(Sleep sleep,
                                          Duration initialDelay,
                                          Duration defaultTimeout,
                                          PatientExecutionHandler handler,
                                          DelaySupplierFactory delaySupplierFactory) {
    try {
        Assertions.assertNotNull(getInstance(sleep, initialDelay, defaultTimeout, handler, delaySupplierFactory),
                                 "Should have received a non-null instance with valid arguments.");
    } catch (Throwable thrown) {
        Assertions.fail("Should have been able to construct a PatientWait with valid arguments but caught throwable: " + thrown);
    }
}
 

import org.junit.jupiter.params.provider.ArgumentsSource; //导入依赖的package包/类
@ParameterizedTest
@DisplayName("it throws an exception for invalid arguments")
@ArgumentsSource(InvalidArgumentsProvider.class)
void testThrowsExceptionWithInvalidArguments(Sleep sleep,
                                             Duration initialDelay,
                                             Duration defaultTimeout,
                                             PatientExecutionHandler handler,
                                             DelaySupplierFactory delaySupplierFactory) {
    Assertions.assertThrows(IllegalArgumentException.class,
                            () -> getInstance(sleep, initialDelay, defaultTimeout, handler, delaySupplierFactory),
                            "Should have thrown an exception when the constructor is called with an invalid argument.");
}
 

import org.junit.jupiter.params.provider.ArgumentsSource; //导入依赖的package包/类
@ParameterizedTest
@DisplayName("it returns a non-null instance successfully for valid arguments")
@ArgumentsSource(ValidArgumentsProvider.class)
void testCanInstantiateWithValidArguments(Sleep sleep,
                                          Duration initialDelay,
                                          int defaultNumberOfRetries,
                                          PatientExecutionHandler handler,
                                          DelaySupplierFactory delaySupplierFactory) {
    try {
        Assertions.assertNotNull(getInstance(sleep, initialDelay, defaultNumberOfRetries, handler, delaySupplierFactory),
                                 "Should have received a non-null instance with valid arguments.");
    } catch (Throwable thrown) {
        Assertions.fail("Should have been able to construct a PatientRetry with valid arguments but caught throwable: " + thrown);
    }
}