org.junit.platform.engine.TestExecutionResult Java Examples

@Override
public void executionFinished(final TestIdentifier testIdentifier,
                              final TestExecutionResult testExecutionResult) {
    // skip root
    if (!testIdentifier.getParentId().isPresent()) {
        return;
    }
    final Status status = extractStatus(testExecutionResult);
    final StatusDetails statusDetails = testExecutionResult.getThrowable()
            .flatMap(ResultsUtils::getStatusDetails)
            .orElse(null);

    if (testIdentifier.isTest()) {
        stopTestCase(testIdentifier, status, statusDetails);
    } else if (testExecutionResult.getStatus() != TestExecutionResult.Status.SUCCESSFUL) {
        // report failed containers as fake test results
        startTestCase(testIdentifier);
        stopTestCase(testIdentifier, status, statusDetails);
    }
    stopTestContainer(testIdentifier);
}
 

public final Builder addResult(TestIdentifier identifier, TestExecutionResult result) {
  DisplayName displayName = getDisplayName(identifier);

  if (identifier.isTest()) {
    testsBuilder().add(displayName);
  }

  switch (result.getStatus()) {
    case SUCCESSFUL:
      successfulBuilder().add(displayName);
      return this;
    case FAILED:
      failuresBuilder().put(displayName, result.getThrowable().orElse(null));
      return this;
    default:
      throw new AssertionError("Unhandled case in enum: " + result.getStatus());
  }
}
 

@Override
public void executionFinished(TestIdentifier identifier, TestExecutionResult result) {

    CapturedOutputStream outputStream = outputStreamMap.remove(identifier.getUniqueId());
    if (null == outputStream) {
        return;
    }

    OutputCapture.deregister();

    if (isQuiet) {
        if (identifier.isTest()) {
            if (!SUCCESSFUL.equals(result.getStatus())) {
                outputStream.output.forEach(testLogger::info);
                outputStream.output.clear();
            }
        }
    }
}
 

@Override
public void executionFinished(TestIdentifier testIdentifier, TestExecutionResult testExecutionResult) {
    if (testIdentifier.getType().isTest()) {
        System.out.println(testExecutionResult.getStatus());
        System.out.println();
    }
}
 

private Status extractStatus(final TestExecutionResult testExecutionResult) {
    switch (testExecutionResult.getStatus()) {
        case FAILED:
            return testExecutionResult.getThrowable().isPresent()
                    ? getStatus(testExecutionResult.getThrowable().get())
                    : FAILED;
        case SUCCESSFUL:
            return PASSED;
        default:
            return SKIPPED;
    }
}
 

@Override
public void executionFinished(TestIdentifier testIdentifier, TestExecutionResult testExecutionResult) {
    if (testIdentifier.getType().isTest()) {
        silencer.silent(false);
        System.out.println(" : " + testExecutionResult.getStatus());
    }
    if(testIdentifier.getType().isContainer()) {
        nestedLevel --;
    }
}
 

@Override
public void executionFinished(TestIdentifier identifier, TestExecutionResult result) {

    try {

        String name = identifier.getDisplayName();

        Writer writer = new FileWriter("target/testsrun", true);
        writer.write(name + "\n");
        writer.close();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}
 

@Override
public void executionFinished(TestIdentifier identifier, TestExecutionResult result) {

    reportedIds.computeIfAbsent(identifier, key -> {

        final Status status;
        final Throwable throwable = result.getThrowable().orElse(null);
        final TaskName taskName = TaskName.of(testSuiteName, identifier);
        final long duration = calculateDuration(identifier);

        // dispatch only tests by default so that number of executed tests
        // match those from junit-interface

        boolean dispatch = identifier.isTest();

        switch (result.getStatus()) {
            case ABORTED:
                status = Status.Canceled;
                dispatch = true;
                break;
            case FAILED:
                status = Status.Failure;
                dispatch = true;
                break;
            case SUCCESSFUL:
                status = Status.Success;
                break;
            default:
                status = Status.Pending;
                dispatch = true;
                break;
        }

        if (dispatch) {
            eventHandler.handle(new DispatchEvent(taskName, status, duration, throwable));
        }

        return true;
    });
}
 

@Override
public void executionFinished(TestIdentifier identifier, TestExecutionResult result) {

    String duration = calculateDurationSuffix(identifier.getUniqueId());
    Throwable throwable = result.getThrowable().orElse(null);
    String fqn, message;

    switch (result.getStatus()) {
        case ABORTED:
            fqn = configuration.buildErrorName(identifier);
            message = configuration.buildErrorMessage(throwable);
            message = "Test assumption in test " + fqn + " failed: " + message + duration;
            logger.warn(message);
            break;
        case FAILED:
            fqn = configuration.buildErrorName(identifier);
            message = configuration.buildErrorMessage(throwable);
            message = "Test " + fqn + " failed: " + message + duration;
            logger.error(configuration.extractClassName(identifier), message, throwable);
            break;
        case SUCCESSFUL:
            fqn = configuration.formatIdentifier(testPlan, identifier);
            message = "Test " + fqn + " finished" + duration;
            logger.debug(message);
            break;
    }
}
 

@Override
public void executionFinished(TestIdentifier identifier, TestExecutionResult result) {

    Throwable throwable = result.getThrowable().orElse(null);
    String fqn, message;

    switch (result.getStatus()) {
        case ABORTED:
            fqn = configuration.buildErrorName(identifier);
            message = configuration.buildErrorMessage(throwable);
            message = "Test assumption in test " + fqn + " failed: " + message;
            logger.warn(message);
            break;
        case FAILED:
            fqn = configuration.buildErrorName(identifier);
            message = configuration.buildErrorMessage(throwable);
            message = "Test " + fqn + " failed: " + message;
            logger.error(configuration.extractClassName(identifier), message, throwable);
            break;
        case SUCCESSFUL:
            fqn = identifier.getLegacyReportingName();
            message = "Test " + fqn + " finished";
            logger.debug(message);
            break;
    }

    maybeDecreaseIndent(identifier);
}
 

@Override
public void executionFinished(TestDescriptor testDescriptor, TestExecutionResult testExecutionResult) {
    Optional<Throwable> throwable = testExecutionResult.getThrowable();
    if (throwable.isPresent()) {
        throw new UndeclaredThrowableException(throwable.get());
    }
}
 

@Override
public void executionFinished(TestIdentifier testIdentifier, TestExecutionResult testExecutionResult) {
    if(testIdentifier.getType().isTest()) {
        silencer.silent(false);
    }
}
 

@Override
public void executionFinished(TestIdentifier testIdentifier, TestExecutionResult testExecutionResult) {
	super.executionFinished(testIdentifier, testExecutionResult);
	testExecutionResult.getThrowable().ifPresent(exceptions::add);
}
 

@Override
public void executionFinished(TestIdentifier testIdentifier, TestExecutionResult testExecutionResult) {
	reset();
}
 

@Override
public void executionFinished(TestIdentifier testIdentifier, TestExecutionResult testExecutionResult) {
    if(testExecutionResult.getStatus().equals(FAILED)){
        passed = false;
    }
}
 

@Override
public void executionFinished(TestDescriptor testDescriptor, TestExecutionResult testExecutionResult) {
    allTestsPassed = allTestsPassed && testExecutionResult.getStatus() == SUCCESSFUL;
}
 

@Override
public void executionFinished(final TestIdentifier testIdentifier, final TestExecutionResult testExecutionResult) {
    final String id = identifyTest(testIdentifier);
    LOGGER.info("Finished {}.", id);
}
 

private String getFailedEventExceptionMessage(Event event) {
  return event.getPayload(TestExecutionResult.class)
      .flatMap(TestExecutionResult::getThrowable)
      .map(Throwable::getMessage)
      .orElseThrow();
}
 

FinishedTest(TestDescriptor testDescriptor, TestExecutionResult result) {
    this.testDescriptor = testDescriptor;
    this.result = result;
}
 

@Override
public void executionFinished(TestDescriptor testDescriptor, TestExecutionResult testExecutionResult) {
    finishedTests.add(new FinishedTest(testDescriptor, testExecutionResult));
}
 

@Override
public void executionFinished(TestIdentifier testIdentifier,
    TestExecutionResult testExecutionResult) {
  executionReportBuilder.addResult(testIdentifier, testExecutionResult);
}
 

@Override
public void executionFinished(final TestIdentifier testIdentifier, final TestExecutionResult testExecutionResult) {
	super.executionFinished(testIdentifier, testExecutionResult);
	testExecutionResult.getThrowable().ifPresent(throwables::add);
}
 

@Override
public void executionFinished(TestIdentifier testIdentifier, TestExecutionResult testExecutionResult) {
	super.executionFinished(testIdentifier, testExecutionResult);
	testExecutionResult.getThrowable().ifPresent(exceptions::add);
}