下面列出了怎么用org.junit.jupiter.api.RepeatedTest的API类实例代码及写法,或者点击链接到github查看源代码。
@DisabledIfSystemProperty(named = "aws-service.instance.type", matches = "remote")
@Test
@Timeout(value = 120)
@RepeatedTest(3)
public void testBasicSendReceiveUsingKafkaStyle() {
try {
Properties amazonProperties = awsService.getConnectionProperties();
ConnectorPropertyFactory testProperties = CamelAWSSQSPropertyFactory
.basic()
.withName("CamelAwssqsSinkConnectorKafkaStyle")
.withTopics(TestUtils.getDefaultTestTopic(this.getClass()))
.withAmazonConfig(amazonProperties, CamelAWSSQSPropertyFactory.KAFKA_STYLE)
.withQueueNameOrArn(queueName);
runTest(testProperties);
} catch (Exception e) {
LOG.error("Amazon SQS test failed: {}", e.getMessage(), e);
fail(e.getMessage());
}
}
@RepeatedTest(10)
void runTestsInParallel() {
Launcher launcher = LauncherFactory.create();
SummaryGeneratingListener listener = new SummaryGeneratingListener();
launcher.registerTestExecutionListeners(listener);
LauncherDiscoveryRequest request = request()//
.configurationParameter("junit.jupiter.execution.parallel.enabled", "true")//
.configurationParameter("junit.jupiter.execution.parallel.config.dynamic.factor", "10")//
.selectors(selectClass(TestCase.class))//
.build();
launcher.execute(request);
assertEquals(NUM_TESTS, listener.getSummary().getTestsSucceededCount(),
"number of tests executed successfully");
}
@RepeatedTest(10)
public void testDifferentDeterministicId() throws InterruptedException {
Date date = new Date();
SignatureParameters params = new SignatureParameters();
params.setSigningCertificate(signingCert);
params.bLevel().setSigningDate(date);
String deterministicId1 = params.getDeterministicId();
params = new SignatureParameters();
params.bLevel().setSigningDate(date);
String deterministicId2 = params.getDeterministicId();
Thread.sleep(1); // 1 millisecond
Date differentDate = new Date();
params = new SignatureParameters();
params.setSigningCertificate(signingCert);
params.bLevel().setSigningDate(differentDate);
String deterministicId3 = params.getDeterministicId();
assertNotEquals(deterministicId1, deterministicId2);
assertNotEquals(deterministicId1, deterministicId3);
}
@RepeatedTest(10)
void runTestsInParallel() {
Launcher launcher = LauncherFactory.create();
SummaryGeneratingListener listener = new SummaryGeneratingListener();
launcher.registerTestExecutionListeners(listener);
LauncherDiscoveryRequest request = request()//
.configurationParameter("junit.jupiter.execution.parallel.enabled", "true")//
.configurationParameter("junit.jupiter.execution.parallel.config.dynamic.factor", "10")//
.selectors(selectClass(TestCase.class))//
.build();
launcher.execute(request);
assertEquals(NUM_TESTS, listener.getSummary().getTestsSucceededCount(),
"number of tests executed successfully");
}
@Test
@RepeatedTest(100)
void testPost() {
// This is a regression test in that we had a problem where the Vert.x request was not paused
// before the authentication filters ran and the post message was thrown away by Vert.x because
// RESTEasy hadn't registered its request handlers yet.
given()
.header("Authorization", "Basic am9objpqb2hu")
.body("Bill")
.contentType(ContentType.TEXT)
.when()
.post("/foo/mapped/rest")
.then()
.statusCode(200)
.body(is("post success"));
}
@Tag("unstable")
@RepeatedTest(2)
public void asyncModeWithRacingTest() {
List<Integer> integers = Flowable.range(0, 10000000)
.toList()
.blockingGet();
TestSubscriberProducer<Integer> producer = Flowable.fromIterable(integers)
.hide()
.subscribeOn(Schedulers.io())
.observeOn(Schedulers.io(), true)
.subscribeWith(new TestSubscriberProducer<Integer>());
TestCallStreamObserver<Integer> downstream = new TestCallStreamObserver<Integer>(executorService);
producer.subscribe(downstream);
racePauseResuming(downstream, 10000);
Assertions.assertThat(downstream.awaitTerminal(1, TimeUnit.MINUTES)).isTrue();
Assertions.assertThat(downstream.e).isNull();
Assertions.assertThat(producer).hasFieldOrPropertyWithValue("sourceMode", 2);
Assertions.assertThat(downstream.collected)
.isEqualTo(integers);
Assertions.assertThat(unhandledThrowable).isEmpty();
}
@RepeatedTest(5)
public void isSubtypeOf_01() throws Exception {
ParseHelper<SarlScript> helper = getParseHelper();
SarlScript mas0 = helper.parse(SNIPSET1);
ResourceSet resourceSet = mas0.eResource().getResourceSet();
SarlScript mas1 = helper.parse(SNIPSET1, resourceSet);
assertSame(mas0.eResource().getResourceSet(), mas1.eResource().getResourceSet());
JvmTypeReference reference0 = this.typeReferences.getTypeForName("boolean", mas0);
StandardTypeReferenceOwner owner = new StandardTypeReferenceOwner(this.services, mas1);
LightweightTypeReference reference1 = owner.newParameterizedTypeReference(this.typeReferences.findDeclaredType("boolean", mas1));
assertTrue(reference1.isSubtypeOf(reference0.getType()));
}
@RepeatedTest(REPETITION_COUNT)
public void processAggregatedEventsForSingleKey() {
Map<ProductKey, InventoryCountEvent> expectedCounts;
expectedCounts = eventGenerator.generateRandomEvents(1, 5);
Map<ProductKey, InventoryCountEvent> originalCount = consumeActualInventoryCountEvents(5);
expectedCounts.forEach((key, value) ->
assertThat(originalCount.get(key).getCount()).isEqualTo(value.getCount()));
expectedCounts = eventGenerator.generateRandomEvents(1, 5);
Map<ProductKey, InventoryCountEvent> actualCount = consumeActualInventoryCountEvents(5);
expectedCounts.forEach((key, value) ->
assertThat(actualCount.get(key).getCount()).isEqualTo(value.getCount()));
}
@RepeatedTest(100)
void meterRegistrationShouldWorkConcurrently() throws InterruptedException {
this.composite.add(this.simple);
String meterName = "test.counter";
String tagName = "test.tag";
int count = 10000;
int tagCount = 100;
ExecutorService executor = Executors.newFixedThreadPool(10);
for (int i = 0; i < count; i++) {
int tagValue = i % tagCount;
executor.execute(() -> {
Counter counter = Counter.builder(meterName).tag(tagName, String.valueOf(tagValue))
.register(this.composite);
counter.increment();
});
}
executor.shutdown();
assertThat(executor.awaitTermination(1L, TimeUnit.SECONDS)).isTrue();
for (int i = 0; i < tagCount; i++) {
assertThat(this.composite.find(meterName).tag(tagName, String.valueOf(i)).counter().count())
.isEqualTo(count / tagCount);
}
}
@RepeatedTest(5)
public void isAssignableFrom_00() throws Exception {
SarlScript mas0 = file(getParseHelper(), SNIPSET1);
SarlScript mas1 = file(getParseHelper(), SNIPSET1);
assertNotSame(mas0.eResource().getResourceSet(), mas1.eResource().getResourceSet());
JvmTypeReference reference0 = this.typeReferences.getTypeForName("boolean", mas0);
StandardTypeReferenceOwner owner = new StandardTypeReferenceOwner(this.services, mas1);
LightweightTypeReference reference1 = owner.newParameterizedTypeReference(this.typeReferences.findDeclaredType("boolean", mas1));
assertFalse(reference1.isAssignableFrom(reference0.getType()));
}
@RepeatedTest(10)
void concurrentValueComputationShouldNotLeadToDuplicatedBackendAccess() throws Exception {
ConcurrentTestRunner.builder()
.operation((a, b) -> textExtractor.extractContent(INPUT_STREAM.get(), CONTENT_TYPE))
.threadCount(10)
.runSuccessfullyWithin(Duration.ofMinutes(1));
verify(wrappedTextExtractor, times(1)).extractContent(any(), any());
}
@RepeatedTest(10000)
public void testCBC() {
BlowfishManager manager = new BlowfishManager("drftpd", "CBC");
String text = "You need to specify a [email protected] to add " + Math.random();
String encrypt = manager.encrypt(text);
String decrypt = manager.decrypt(encrypt);
assertEquals(decrypt, text);
}
@RepeatedTest(3)
default void playersTableAndPlayerPageActivityIndexMatches() {
prepareForSessionSave();
List<Session> player1Sessions = RandomData.randomSessions(serverUUID(), worlds, playerUUID, player2UUID);
List<Session> player2Sessions = RandomData.randomSessions(serverUUID(), worlds, player2UUID, playerUUID);
player1Sessions.forEach(session -> execute(DataStoreQueries.storeSession(session)));
player2Sessions.forEach(session -> execute(DataStoreQueries.storeSession(session)));
long time = System.currentTimeMillis();
long playtimeThreshold = RandomData.randomLong(TimeUnit.HOURS.toMillis(1L), TimeUnit.DAYS.toMillis(2L));
PlayerContainer playerContainer = db().query(new PlayerContainerQuery(playerUUID));
TablePlayer tablePlayer = db().query(new ServerTablePlayersQuery(serverUUID(), time, playtimeThreshold, 5))
.stream().filter(player -> playerUUID.equals(player.getPlayerUUID())).findAny()
.orElseThrow(AssertionError::new);
SessionsMutator sessionsMutator = SessionsMutator.forContainer(playerContainer);
long week = TimeAmount.WEEK.toMillis(1L);
long weekAgo = time - week;
long twoWeeksAgo = time - 2L * week;
long threeWeeksAgo = time - 3L * week;
SessionsMutator weekOne = sessionsMutator.filterSessionsBetween(weekAgo, time);
SessionsMutator weekTwo = sessionsMutator.filterSessionsBetween(twoWeeksAgo, weekAgo);
SessionsMutator weekThree = sessionsMutator.filterSessionsBetween(threeWeeksAgo, twoWeeksAgo);
long playtime1 = weekOne.toActivePlaytime();
long playtime2 = weekTwo.toActivePlaytime();
long playtime3 = weekThree.toActivePlaytime();
double expected = playerContainer.getActivityIndex(time, playtimeThreshold).getValue();
double got = tablePlayer.getCurrentActivityIndex().orElseThrow(AssertionError::new).getValue();
assertEquals(expected, got, 0.001,
() -> "Activity Indexes between queries differed, expected: <" + expected + "> but was: <" + got + ">" +
". Playtime for reference container: <w1:" + playtime1 + ", w2:" + playtime2 + ", w3:" + playtime3 + ">"
);
}
@RepeatedTest(TestUtils.REPEATED_COUNT)
void test_multipleVarsInMapParam() {
JsonTemplate jsonTemplate = new JsonTemplate("{aField: @s(min=$min,max=$max)}")
.withVar("min", 10)
.withVar("max", 20);
DocumentContext document = parse(jsonTemplate);
assertThat(document.read("$.aField", String.class).length(),
is(both(greaterThanOrEqualTo(10)).and(lessThanOrEqualTo(20))));
}
@RepeatedTest(TestUtils.REPEATED_COUNT)
void test_varsMapInMapParam() {
Map<String, Object> values = new HashMap<>();
values.put("min", 10);
values.put("max", 20);
JsonTemplate jsonTemplate = new JsonTemplate("{aField: @s(min=$min,max=$max)}")
.withVars(values);
DocumentContext document = parse(jsonTemplate);
assertThat(document.read("$.aField", String.class).length(),
is(both(greaterThanOrEqualTo(10)).and(lessThanOrEqualTo(20))));
}
@RepeatedTest(3)
public void testGetKey() {
long startTime = Utils.now();
int i = 500;
while (i-- >=0) {
lastPriceCache.getLastPrice(RandomUtils.nextInt(1, 3));
}
System.out.println("testGetKey:" + Utils.diff(startTime));
}
@RepeatedTest(3)
public void testPackagingNew() {
long start = Utils.now();
for(int i = 0; i < count; i ++) {
startBasic += i;
}
System.out.println("testPackagingNew cost: " + Utils.diff(start));
}
@RepeatedTest(10)
void successTryLockProcesses(@TempDir Path folder) throws Exception {
Path fileLock = folder.resolve(LOCK_FILE);
Path file = folder.resolve("file.txt");
writeToFile(file, 0);
List<Process> processes = new ArrayList<>();
for (int i = 0; i < 5; i++) {
processes.add(runProcess(folder, fileLock, file));
}
for (Process process : processes) {
int exit = process.waitFor();
assertThat(exit).describedAs(new Description() {
@Override
public String value() {
return String.format("%nProcess exit code %s. %n%s", exit, readAll(process.getInputStream()));
}
}).isZero();
}
assertThat(Long.parseLong(readAll(Files.newInputStream(file)))).describedAs(new Description() {
@Override
public String value() {
return String.format("%n%s", readFromProcesses(processes));
}
}).isEqualTo(5);
}
@RepeatedTest(31)
void basicConsume_concurrent_queue_access() throws IOException, TimeoutException, InterruptedException {
try (Connection conn = new MockConnectionFactory().newConnection()) {
try (Channel channel = conn.createChannel()) {
String queueName = channel.queueDeclare().getQueue();
BlockingQueue<String> messages = new LinkedBlockingQueue<>();
channel.basicConsume("", new DefaultConsumer(channel) {
@Override
public void handleDelivery(String consumerTag,
Envelope envelope,
AMQP.BasicProperties properties,
byte[] body) {
messages.offer(new String(body));
}
});
int totalMessages = 101;
for (int i = 1; i <= totalMessages; i++) {
channel.basicPublish("", queueName, null, "test message".getBytes());
}
for (int i = 1; i <= totalMessages; i++) {
assertThat(messages.poll(200L, TimeUnit.MILLISECONDS)).isNotNull();
}
}
}
}
@RepeatedTest(3)
void http_server_check_response(Vertx vertx, VertxTestContext testContext) {
HttpClient client = vertx.createHttpClient();
client.get(8080, "localhost", "/")
.compose(HttpClientResponse::body)
.onComplete(testContext.succeeding(buffer -> testContext.verify(() -> {
assertThat(buffer.toString()).isEqualTo("Plop");
testContext.completeNow();
})));
}
@RepeatedTest(100)
void givenARange_WhenGenTimestamp_ShouldBeInRange() {
long aDay = TimeUnit.DAYS.toMillis(1);
long now = new Date().getTime();
Date hundredYearsAgo = new Date(now - aDay * 365 * 100);
Date tenDaysAgo = new Date(now - aDay * 10);
Date random = LegacyRandomDateTimes.between(hundredYearsAgo, tenDaysAgo);
assertThat(random).isBetween(hundredYearsAgo, tenDaysAgo);
}
@RepeatedTest(100)
void givenARange_WhenGenTimestamp_ShouldBeInRange() {
Instant hundredYearsAgo = Instant.now().minus(Duration.ofDays(100 * 365));
Instant tenDaysAgo = Instant.now().minus(Duration.ofDays(10));
Instant random = RandomDateTimes.between(hundredYearsAgo, tenDaysAgo);
assertThat(random).isBetween(hundredYearsAgo, tenDaysAgo);
}
@RepeatedTest(20)
public void testOidcAndVertxHandler() {
RestAssured.given().auth().oauth2(getAccessToken("alice"))
.when().body("Hello World").post("/vertx")
.then()
.statusCode(200)
.body(equalTo("Hello World"));
}
@RepeatedTest(100)
public void testPost() {
// This is a regression test in that we had a problem where the Vert.x request was not paused
// before the authentication filters ran and the post message was thrown away by Vert.x because
// RESTEasy hadn't registered its request handlers yet.
given()
.header("Authorization", "Basic am9objpqb2hu")
.body("Bill")
.contentType(ContentType.TEXT)
.when()
.post("/foo/")
.then()
.statusCode(200)
.body(is("hello Bill"));
}
@RepeatedTest(100)
void givenNoRange_WhenGenTimestamp_ShouldGenerateRandomTimestamps() {
Date random = LegacyRandomDateTimes.timestamp();
assertThat(random)
.isNotNull()
.isBetween(MIN_DATE, MAX_DATE);
}
@RepeatedTest(20)
void valueCountUnderflowThrows(RepetitionInfo info) {
var i = info.getCurrentRepetition();
var line = "-" + ",-".repeat(i - 1);
if (i < 9) {
var e = assertThrows(IllegalArgumentException.class, () -> new Item(line));
assertEquals("Expected at least 9 values, only got " + i + " in: " + line, e.getMessage());
} else {
assertDoesNotThrow(() -> new Item(line));
}
}
@RepeatedTest(2)
public void shouldSupportOnlySingleSubscriberTest() throws InterruptedException {
for (int i = 0; i < 1000; i++) {
final TestSubscriber<Integer> downstream1 = new TestSubscriber<Integer>(0);
final TestSubscriber<Integer> downstream2 = new TestSubscriber<Integer>(0);
final TestStreamObserverAndPublisher<Integer> processor = new TestStreamObserverAndPublisher<Integer>(null);
final CountDownLatch latch = new CountDownLatch(1);
executorService.execute(new Runnable() {
@Override
public void run() {
latch.countDown();
processor.subscribe(downstream1);
processor.onCompleted();
}
});
latch.await();
processor.subscribe(downstream2);
processor.onCompleted();
downstream1.awaitTerminalEvent();
downstream2.awaitTerminalEvent();
if (downstream1.errorCount() > 0) {
downstream1.assertError(IllegalStateException.class)
.assertErrorMessage(
"TestStreamObserverAndPublisher allows only a single Subscriber");
} else {
downstream2.assertError(IllegalStateException.class)
.assertErrorMessage(
"TestStreamObserverAndPublisher allows only a single Subscriber");
}
}
}
@RepeatedTest(2)
public void syncModeWithRacingTest() throws InterruptedException {
List<Integer> integers = Flowable.range(0, 10000000)
.toList()
.blockingGet();
final CountDownLatch startedLatch = new CountDownLatch(1);
final TestSubscriberProducer<Integer> producer = Flowable.fromIterable(integers)
.subscribeWith(new TestSubscriberProducer<Integer>());
final TestCallStreamObserver<Integer> downstream =
new TestCallStreamObserver<Integer>(executorService);
executorService.execute(new Runnable() {
@Override
public void run() {
producer.subscribe(downstream);
startedLatch.countDown();
}
});
startedLatch.await();
racePauseResuming(downstream, 10000);
Assertions.assertThat(downstream.awaitTerminal(1, TimeUnit.MINUTES)).isTrue();
Assertions.assertThat(downstream.e).isNull();
Assertions.assertThat(producer).hasFieldOrPropertyWithValue("sourceMode", 1);
Assertions.assertThat(downstream.collected)
.isEqualTo(integers);
Assertions.assertThat(unhandledThrowable).isEmpty();
}
@RepeatedTest(25)
public void whenCallRedisGetThroughGateway_thenOKStatusOrIsReceived() {
String url = "http://localhost:" + port + "/redis/get";
ResponseEntity<String> r = restTemplate.getForEntity(url, String.class);
// assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
LOGGER.info("Received: status->{}, reason->{}, remaining->{}",
r.getStatusCodeValue(), r.getStatusCode().getReasonPhrase(),
r.getHeaders().get("X-RateLimit-Remaining"));
}
@RepeatedTest(10)
public void test() {
DSSDocument documentToSign = new FileDocument(new File("src/test/resources/sample.xml"));
Date oneDayBefore = getDateWithHoursDifference(-24);
XAdESSignatureParameters signatureParameters = new XAdESSignatureParameters();
signatureParameters.bLevel().setSigningDate(oneDayBefore);
signatureParameters.setSigningCertificate(getSigningCert());
signatureParameters.setCertificateChain(getCertificateChain());
signatureParameters.setSignaturePackaging(SignaturePackaging.ENVELOPING);
signatureParameters.setSignatureLevel(SignatureLevel.XAdES_BASELINE_T);
CertificateVerifier certificateVerifier = getCompleteCertificateVerifier();
certificateVerifier.setAlertOnNoRevocationAfterBestSignatureTime(new ExceptionOnStatusAlert());
XAdESService service = new XAdESService(certificateVerifier);
service.setTspSource(getGoodTsaByTime(oneDayBefore));
TimestampToken contentTimestamp = service.getContentTimestamp(documentToSign, signatureParameters);
signatureParameters.setContentTimestamps(Arrays.asList(contentTimestamp));
signatureParameters.bLevel().setSigningDate(getDateWithHoursDifference(24));
service.setTspSource(getAlternateGoodTsa());
ToBeSigned dataToSign = service.getDataToSign(documentToSign, signatureParameters);
SignatureValue signatureValue = getToken().sign(dataToSign, signatureParameters.getDigestAlgorithm(),
signatureParameters.getMaskGenerationFunction(), getPrivateKeyEntry());
DSSDocument signedDocument = service.signDocument(documentToSign, signatureParameters, signatureValue);
signatureParameters.setSignatureLevel(SignatureLevel.XAdES_BASELINE_LT);
Exception exception = assertThrows(AlertException.class, () -> service.extendDocument(signedDocument, signatureParameters));
assertTrue(exception.getMessage().contains("Fresh revocation data is missing for one or more certificate(s)."));
}