org.junit.platform.launcher.listeners.TestExecutionSummary Java Examples

private static JkTestResult.JkFailure toFailure(TestExecutionSummary.Failure failure) {
    JkTestResult.JkTestIdentifier.JkType type;
    switch (failure.getTestIdentifier().getType()) {
        case CONTAINER:
            type = JkTestResult.JkTestIdentifier.JkType.CONTAINER;
            break;
        case CONTAINER_AND_TEST:
            type = JkTestResult.JkTestIdentifier.JkType.CONTAINER_AND_TEST;
            break;
        default:
            type = JkTestResult.JkTestIdentifier.JkType.TEST;
            break;
    }
    String testId = failure.getTestIdentifier().getUniqueId();
    String displayName = failure.getTestIdentifier().getDisplayName();
    Set<String> tags = failure.getTestIdentifier().getTags().stream().map(TestTag::toString)
            .collect(Collectors.toSet());
    JkTestResult.JkTestIdentifier id = JkTestResult.JkTestIdentifier.of(type, testId, displayName, tags);
    return JkTestResult.JkFailure.of(id, failure.getException().getMessage(),
            failure.getException().getStackTrace());
}
 

private static JkTestResult toTestResult(TestExecutionSummary summary) {
    JkTestResult.JkCount containerCount = JkTestResult.JkCount.of(
            summary.getContainersFoundCount(),
            summary.getContainersStartedCount(),
            summary.getContainersSkippedCount(),
            summary.getContainersAbortedCount(),
            summary.getContainersSucceededCount(),
            summary.getContainersFailedCount());
    JkTestResult.JkCount testCount = JkTestResult.JkCount.of(
            summary.getTestsFoundCount(),
            summary.getTestsStartedCount(),
            summary.getTestsSkippedCount(),
            summary.getTestsAbortedCount(),
            summary.getTestsSucceededCount(),
            summary.getTestsFailedCount());
    List<JkTestResult.JkFailure> failures = summary.getFailures().stream()
            .map(JunitPlatformDoer::toFailure).collect(Collectors.toList());
    return JkTestResult.of(summary.getTimeStarted(), summary.getTimeFinished(),
            containerCount, testCount, failures);
}
 

private String createJsonTestReport(TestExecutionSummary report, List<String> logLines) {
    var slime = new Slime();
    var root = slime.setObject();
    var summary = root.setObject("summary");
    summary.setLong("Total tests", report.getTestsFoundCount());
    summary.setLong("Test success", report.getTestsSucceededCount());
    summary.setLong("Test failed", report.getTestsFailedCount());
    summary.setLong("Test ignored", report.getTestsSkippedCount());
    summary.setLong("Test success", report.getTestsAbortedCount());
    summary.setLong("Test started", report.getTestsStartedCount());
    var failures = summary.setArray("failures");
    report.getFailures().forEach(failure -> serializeFailure(failure, failures.addObject()));

    var output = root.setArray("output");
    logLines.forEach(output::addString);

    return Exceptions.uncheck(() -> new String(SlimeUtils.toJsonBytes(slime), StandardCharsets.UTF_8));
}
 

@Test
@DisplayName("⚙️ Check a timeout diagnosis")
void checkTimeoutFailureTestWithIntermediateAsyncVerifier() {
  LauncherDiscoveryRequest request = LauncherDiscoveryRequestBuilder.request()
    .selectors(selectClass(EmbeddedWithARunner.TimingOut.class))
    .build();
  Launcher launcher = LauncherFactory.create();
  SummaryGeneratingListener listener = new SummaryGeneratingListener();
  launcher.registerTestExecutionListeners(listener);
  launcher.execute(request);
  TestExecutionSummary summary = listener.getSummary();
  assertThat(summary.getTestsStartedCount()).isEqualTo(1);
  assertThat(summary.getTestsFailedCount()).isEqualTo(1);
  Throwable exception = summary.getFailures().get(0).getException();
  assertThat(exception)
    .isInstanceOf(TimeoutException.class)
    .hasMessageContaining("checkpoint in file VertxExtensionTest.java");
}
 

public static void main(String[] args) {
    LauncherDiscoveryRequest request = LauncherDiscoveryRequestBuilder.request()
            .selectors(
                    selectPackage("btdex.sellContract.dispute"),
                    selectClass(TestTakeRetake.class),
                    selectClass(TestInvalidTakeTake.class),
                    selectClass(TestInvalidTakeReopenWithdraw.class)
            )
            .build();

    Launcher launcher = LauncherFactory.create();
    // Register a listener
    SummaryGeneratingListener listener = new SummaryGeneratingListener();
    launcher.registerTestExecutionListeners(listener);

    //TestPlan testPlan = launcher.discover(request);

    launcher.execute(request);

    TestExecutionSummary summary = listener.getSummary();
    printReport(summary);


}
 

private static void printReport(TestExecutionSummary summary) {
    System.out.println(
            "\n------------------------------------------" +
                    "\nTests started: " + summary.getTestsStartedCount() +
                    "\nTests failed: " + summary.getTestsFailedCount() +
                    "\nTests succeeded: " + summary.getTestsSucceededCount() +
                    "\n------------------------------------------"
    );

    if(summary.getTestsFailedCount() > 0) {
        for(TestExecutionSummary.Failure f: summary.getFailures()){
            System.out.println(f.getTestIdentifier().getSource() +
                                "\nException " + f.getException());
        }
    }
}
 

@Override
public void testPlanExecutionFinished(TestPlan testPlan) {

    TestExecutionSummary summary = getSummary();
    long testRunDuration = System.currentTimeMillis() - summary.getTimeStarted();

    long totalFailureCount = summary.getTotalFailureCount();
    long testsSkippedCount = summary.getTestsSkippedCount();
    long totalTestsFound = summary.getTestsFoundCount();

    Color ignoreColor = testsSkippedCount > 0 ? colorTheme.ignoreCount() : colorTheme.info();
    Color errorColor = totalFailureCount > 0 ? colorTheme.errorCount() : colorTheme.info();

    debugOrInfo(""
            + colorTheme.info().format("Test run finished: ")
            + errorColor.format(totalFailureCount + " failed")
            + colorTheme.info().format(", ")
            + ignoreColor.format(testsSkippedCount + " ignored")
            + colorTheme.info().format(", ")
            + colorTheme.info().format(totalTestsFound + " total, ")
            + colorTheme.info().format(testRunDuration/1000.0 + "s")
    );
}
 

@Test
@DisplayName("⚙️ Check a test failure")
void checkFailureTest() {
  LauncherDiscoveryRequest request = LauncherDiscoveryRequestBuilder.request()
    .selectors(selectClass(FailureTest.class))
    .build();
  Launcher launcher = LauncherFactory.create();
  SummaryGeneratingListener listener = new SummaryGeneratingListener();
  launcher.registerTestExecutionListeners(listener);
  launcher.execute(request);
  TestExecutionSummary summary = listener.getSummary();
  assertThat(summary.getTestsStartedCount()).isEqualTo(1);
  assertThat(summary.getTestsFailedCount()).isEqualTo(1);
  assertThat(summary.getFailures().get(0).getException()).isInstanceOf(AssertionError.class);
}
 

public static void main(String[] args) {
    RunJUnit5TestsFromJava runner = new RunJUnit5TestsFromJava();
    runner.runAll();

    TestExecutionSummary summary = runner.listener.getSummary();
    summary.printTo(new PrintWriter(System.out));

    runner.runOne();

    summary = runner.listener.getSummary();
    summary.printTo(new PrintWriter(System.out));
}
 

public void updatePassFailCount(SummaryGeneratingListener summaryListener) {
    TestExecutionSummary summary = summaryListener.getSummary();
    if (summary.getTotalFailureCount() > 0) {
        getFailedCounter().incrementAndGet();
        summary.getFailures().forEach(thisFailure -> {
            TestIdentifier testIdentifier = thisFailure.getTestIdentifier();
            String exceptionMessage = thisFailure.getException().getMessage();
            LOGGER.info("\n----------------------------------------------------------------------\n");
            LOGGER.info("\n###JUnit5: Test Failed Due To --> {}, \ntestIdentifier={}", exceptionMessage, testIdentifier);
            LOGGER.info("\n----------------------------------------------------------------------\n");
        });
    } else {
        getPassedCounter().incrementAndGet();
    }
}
 

@Test
@DisplayName("⚙️ Check a test failure with an intermediate async result verifier")
void checkFailureTestWithIntermediateAsyncVerifier() {
  LauncherDiscoveryRequest request = LauncherDiscoveryRequestBuilder.request()
    .selectors(selectClass(FailureWithIntermediateAsyncVerifierTest.class))
    .build();
  Launcher launcher = LauncherFactory.create();
  SummaryGeneratingListener listener = new SummaryGeneratingListener();
  launcher.registerTestExecutionListeners(listener);
  launcher.execute(request);
  TestExecutionSummary summary = listener.getSummary();
  assertThat(summary.getTestsStartedCount()).isEqualTo(1);
  assertThat(summary.getTestsFailedCount()).isEqualTo(1);
  assertThat(summary.getFailures().get(0).getException()).isInstanceOf(AssertionError.class);
}
 

@Test
@DisplayName("⚙️ Check a failure in the test method body rather than in a callback")
void checkDirectFailure() {
  LauncherDiscoveryRequest request = LauncherDiscoveryRequestBuilder.request()
    .selectors(selectClass(DirectFailureTest.class))
    .build();
  Launcher launcher = LauncherFactory.create();
  SummaryGeneratingListener listener = new SummaryGeneratingListener();
  launcher.registerTestExecutionListeners(listener);
  launcher.execute(request);
  TestExecutionSummary summary = listener.getSummary();
  assertThat(summary.getTestsStartedCount()).isEqualTo(1);
  assertThat(summary.getTestsFailedCount()).isEqualTo(1);
  assertThat(summary.getFailures().get(0).getException()).isInstanceOf(RuntimeException.class);
}
 

private void runTestAndAssertCounters(Class<?> testClass) {
	Launcher launcher = LauncherFactory.create();
	ExceptionTrackingListener listener = new ExceptionTrackingListener();
	launcher.registerTestExecutionListeners(listener);

	launcher.execute(request().selectors(selectClass(testClass)).build());
	TestExecutionSummary summary = listener.getSummary();

	String name = testClass.getSimpleName();
	int expectedStartedCount = getExpectedStartedCount(testClass);
	int expectedSucceededCount = getExpectedSucceededCount(testClass);
	int expectedFailedCount = getExpectedFailedCount(testClass);

	// @formatter:off
	assertAll(
		() -> assertEquals(1, summary.getTestsFoundCount(), () -> name + ": tests found"),
		() -> assertEquals(0, summary.getTestsSkippedCount(), () -> name + ": tests skipped"),
		() -> assertEquals(0, summary.getTestsAbortedCount(), () -> name + ": tests aborted"),
		() -> assertEquals(expectedStartedCount, summary.getTestsStartedCount(), () -> name + ": tests started"),
		() -> assertEquals(expectedSucceededCount, summary.getTestsSucceededCount(), () -> name + ": tests succeeded"),
		() -> assertEquals(expectedFailedCount, summary.getTestsFailedCount(), () -> name + ": tests failed")
	);
	// @formatter:on

	// Ensure it was an AssertionFailedError that failed the test and not
	// something else like an error in the @Configuration class, etc.
	if (expectedFailedCount > 0) {
		assertEquals(1, listener.exceptions.size(), "exceptions expected");
		Throwable exception = listener.exceptions.get(0);
		if (!(exception instanceof AssertionFailedError)) {
			throw new AssertionFailedError(
				exception.getClass().getName() + " is not an instance of " + AssertionFailedError.class.getName(),
				exception);
		}
	}
}
 

private void runTestAndAssertCounters(Class<?> testClass) {
	Launcher launcher = LauncherFactory.create();
	ExceptionTrackingListener listener = new ExceptionTrackingListener();
	launcher.registerTestExecutionListeners(listener);

	launcher.execute(request().selectors(selectClass(testClass)).build());
	TestExecutionSummary summary = listener.getSummary();

	String name = testClass.getSimpleName();
	int expectedStartedCount = getExpectedStartedCount(testClass);
	int expectedSucceededCount = getExpectedSucceededCount(testClass);
	int expectedFailedCount = getExpectedFailedCount(testClass);

	// @formatter:off
	assertAll(
		() -> assertEquals(1, summary.getTestsFoundCount(), () -> name + ": tests found"),
		() -> assertEquals(0, summary.getTestsSkippedCount(), () -> name + ": tests skipped"),
		() -> assertEquals(0, summary.getTestsAbortedCount(), () -> name + ": tests aborted"),
		() -> assertEquals(expectedStartedCount, summary.getTestsStartedCount(), () -> name + ": tests started"),
		() -> assertEquals(expectedSucceededCount, summary.getTestsSucceededCount(), () -> name + ": tests succeeded"),
		() -> assertEquals(expectedFailedCount, summary.getTestsFailedCount(), () -> name + ": tests failed")
	);
	// @formatter:on

	// Ensure it was an AssertionFailedError that failed the test and not
	// something else like an error in the @Configuration class, etc.
	if (expectedFailedCount > 0) {
		assertEquals(1, listener.exceptions.size(), "exceptions expected");
		Throwable exception = listener.exceptions.get(0);
		if (!(exception instanceof AssertionFailedError)) {
			throw new AssertionFailedError(
				exception.getClass().getName() + " is not an instance of " + AssertionFailedError.class.getName(),
				exception);
		}
	}
}
 

private static TestExecutionSummary runTestMethod(Class<?> testClass, String methodName) {
    MethodSelector testMethodSelector = selectMethod(testClass, methodName);
    LauncherDiscoveryRequest request = request().selectors(testMethodSelector)
                                      .build();

    SummaryGeneratingListener listener = new SummaryGeneratingListener();

    Launcher launcher = LauncherFactory.create();
    launcher.execute(request, listener);

    return listener.getSummary();
}
 

public JUnit5TestsResult run()  {
    launcher.execute(request);
    TestExecutionSummary testExecutionSummary = listener.getSummary();
    return new JUnit5TestsResult(testExecutionSummary);
}
 

private void runJUnit(String arg, LauncherDiscoveryRequest request) {
  Stopwatch stopwatch = Stopwatch.createStarted();
  System.out.println(String.format("Running %s", arg));
  System.out.println();

  Launcher launcher = LauncherFactory.create();
  SummaryGeneratingListener listener = new SummaryGeneratingListener();
  launcher.execute(request, listener);
  TestExecutionSummary summary = listener.getSummary();
  this.runCnt += summary.getTestsFoundCount();
  this.failureCnt += summary.getTestsFailedCount();
  this.ignoreCnt += summary.getTestsSkippedCount();
  this.ignoreCnt += summary.getTestsSkippedCount();

  System.out.println();

  if (summary.getTestsFailedCount() > 0) {
    System.out.println(
        String.format(
            "FAIL Tests run: %d, Failures: %d, Ignore: %d, Time elapsed: %s",
            summary.getTestsFoundCount(),
            summary.getTestsFailedCount(),
            summary.getTestsSkippedCount(),
            stopwatch.stop()));
    System.out.println("Failures:");
    for (TestExecutionSummary.Failure failure : summary.getFailures()) {
      System.out.println(failure.getTestIdentifier().getDisplayName());
      failure.getException().printStackTrace();
      System.out.println();
    }
  } else {
    System.out.println(
        String.format(
            "Tests run: %d, Failures: %d, Ignore: %d, Time elapsed: %s",
            summary.getTestsFoundCount(),
            summary.getTestsFailedCount(),
            summary.getTestsSkippedCount(),
            stopwatch.stop()));
    System.out.println("Success");
  }

  System.out.println(Strings.repeat("-", 80));
}
 

private List<Throwable> convertToThrowables(List<TestExecutionSummary.Failure> failures) {
    return failures.stream()
                   .map(TestExecutionSummary.Failure::getException)
                   .collect(toList());
}
 

private void serializeFailure(TestExecutionSummary.Failure failure, Cursor slime) {
    var testIdentifier = failure.getTestIdentifier();
    slime.setString("testName", testIdentifier.getUniqueId());
    slime.setString("testError",failure.getException().getMessage());
    slime.setString("exception", ExceptionUtils.getStackTraceAsString(failure.getException()));
}
 

public int getNumberOfFailures() {
    List<TestExecutionSummary.Failure> failures = testExecutionSummary.getFailures();
    return failures.size();
}
 

public JUnit5TestsResult(TestExecutionSummary testExecutionSummary) {
    this.testExecutionSummary = testExecutionSummary;
}
 

@Override
public TestIssue executeTestMethod(Class<?> testClass, String methodName) {
    TestExecutionSummary testResult = runTestMethod(testClass, methodName);

    List<TestExecutionSummary.Failure> failures = testResult.getFailures();

    List<Throwable> jUnit5failuresAsThrowables = convertToThrowables(failures);

    return TestIssue.buildInNewJvmFrom(jUnit5failuresAsThrowables);
}