How to use

getFailures

method

in

org.junit.runner.Result

/**
 * Returns the failures in this result.
 *
 * @since 4.13
 */
public List<Failure> failures() {
  return result.getFailures();
}

/**
 * Returns the number of failures in this result.
 */
public int failureCount() {
  return result.getFailures().size();
}

/**
 * Returns the number of failures in this result.
 */
public int failureCount() {
  return result.getFailures().size();
}

protected void printFailures(Result result) {
  List<Failure> failures = result.getFailures();
  if (failures.isEmpty()) {
    return;
  }
  if (failures.size() == 1) {
    getWriter().println("There was " + failures.size() + " failure:");
  } else {
    getWriter().println("There were " + failures.size() + " failures:");
  }
  int i = 1;
  for (Failure each : failures) {
    printFailure(each, "" + i++);
  }
}

protected void printFailures(Result result) {
  List<Failure> failures = result.getFailures();
  if (failures.size() == 0) {
    return;
  }
  if (failures.size() == 1) {
    getWriter().println("There was " + failures.size() + " failure:");
  } else {
    getWriter().println("There were " + failures.size() + " failures:");
  }
  int i = 1;
  for (Failure each : failures) {
    printFailure(each, "" + i++);
  }
}

public static Result runTestWithValidation(final Class<?> test) {
 JUnitCore junitCore = new JUnitCore();
 Result result = junitCore.run(Request.aClass(test).getRunner());
 List<Failure> failures = result.getFailures();
 if (!failures.isEmpty()) {
  Failure firstFailure = failures.get(0);
  throw new AssertionError(firstFailure.getException());
 }
 assertThat(result.wasSuccessful()).isTrue();
 return result;
}

@Test
public void failsOnThirdAttempt() {
 Result result = TestRunner.runTest(FailsOnThirdAttempt.class);
 assertThat(result.wasSuccessful()).isFalse();
 List<Failure> failures = result.getFailures();
 assertThat(failures.size()).as("Failures: " + failures).isEqualTo(1);
 Failure failure = failures.get(0);
 assertThat(failure.getException()).isExactlyInstanceOf(CustomException.class)
   .hasMessage(FailsOnThirdAttempt.message);
 assertThat(FailsOnThirdAttempt.count).isEqualTo(3);
}

@Test
public void shouldExecuteWhenUntilIsInPast() {
 Result result = TestRunner.runTest(ShouldExecuteWhenUntilIsInPast.class);
 assertThat(result.wasSuccessful()).isFalse();
 List<Failure> failures = result.getFailures();
 assertThat(failures.size()).as("Failures: " + failures).isEqualTo(1);
 Failure failure = failures.get(0);
 assertThat(failure.getException()).isExactlyInstanceOf(AssertionError.class)
   .hasMessage(ASSERTION_ERROR_MESSAGE);
 assertThat(ShouldExecuteWhenUntilIsInPast.count).isEqualTo(1);
}

@Test
public void failsOnThirdAttempt() {
 Result result = TestRunner.runTest(FailsOnThirdAttempt.class);
 assertThat(result.wasSuccessful()).isFalse();
 List<Failure> failures = result.getFailures();
 assertThat(failures.size()).as("Failures: " + failures).isEqualTo(1);
 Failure failure = failures.get(0);
 assertThat(failure.getException()).isExactlyInstanceOf(AssertionError.class)
   .hasMessage(FailsOnThirdAttempt.message);
 assertThat(FailsOnThirdAttempt.count).isEqualTo(3);
}

@Test
public void failsOnSecondAttempt() {
 Result result = TestRunner.runTest(FailsOnSecondAttempt.class);
 assertThat(result.wasSuccessful()).isFalse();
 List<Failure> failures = result.getFailures();
 assertThat(failures.size()).as("Failures: " + failures).isEqualTo(1);
 Failure failure = failures.get(0);
 assertThat(failure.getException()).isExactlyInstanceOf(CustomException.class)
   .hasMessage(FailsOnSecondAttempt.message);
 assertThat(FailsOnSecondAttempt.count).isEqualTo(2);
}

@Test
public void failsOnThirdAttempt() {
 Result result = TestRunner.runTest(FailsOnThirdAttempt.class);
 assertThat(result.wasSuccessful()).isFalse();
 List<Failure> failures = result.getFailures();
 assertThat(failures.size()).as("Failures: " + failures).isEqualTo(1);
 Failure failure = failures.get(0);
 assertThat(failure.getException()).isExactlyInstanceOf(CustomException.class)
   .hasMessage(FailsOnThirdAttempt.message);
 assertThat(FailsOnThirdAttempt.count).isEqualTo(3);
}

@Test
public void failsWithOne() {
 Result result = TestRunner.runTest(FailsWithOne.class);
 assertThat(result.wasSuccessful()).isFalse();
 List<Failure> failures = result.getFailures();
 assertThat(failures.size()).as("Failures: " + failures).isEqualTo(1);
 Failure failure = failures.get(0);
 assertThat(failure.getException()).isExactlyInstanceOf(AssertionError.class)
   .hasMessage(FailsWithOne.message);
 assertThat(FailsWithOne.count).isEqualTo(1);
}

@Test
public void failingTestShouldFailOneTimeWhenRepeatIsUnused() {
 Result result = TestRunner.runTest(FailingTestShouldFailOneTimeWhenRepeatIsUnused.class);
 assertThat(result.wasSuccessful()).isFalse();
 List<Failure> failures = result.getFailures();
 assertThat(failures.size()).as("Failures: " + failures).isEqualTo(1);
 Failure failure = failures.get(0);
 assertThat(failure.getException()).isExactlyInstanceOf(AssertionError.class)
   .hasMessage(ASSERTION_ERROR_MESSAGE);
 assertThat(FailingTestShouldFailOneTimeWhenRepeatIsUnused.count).isEqualTo(1);
}

@Test
public void failingTestShouldFailOneTimeWhenRepeatIsThree() {
 Result result = TestRunner.runTest(FailingTestShouldFailOneTimeWhenRepeatIsThree.class);
 assertThat(result.wasSuccessful()).isFalse();
 List<Failure> failures = result.getFailures();
 assertThat(failures.size()).as("Failures: " + failures).isEqualTo(1);
 Failure failure = failures.get(0);
 assertThat(failure.getException()).isExactlyInstanceOf(AssertionError.class)
   .hasMessage(ASSERTION_ERROR_MESSAGE);
 assertThat(FailingTestShouldFailOneTimeWhenRepeatIsThree.count).isEqualTo(1);
}

@Test
public void negativeValueShouldThrowIllegalArgumentException() {
 Result result = TestRunner.runTest(NegativeValueShouldThrowIllegalArgumentException.class);
 assertThat(result.wasSuccessful()).isFalse();
 List<Failure> failures = result.getFailures();
 assertThat(failures.size()).as("Failures: " + failures).isEqualTo(1);
 Failure failure = failures.get(0);
 assertThat(failure.getException()).isExactlyInstanceOf(IllegalArgumentException.class)
   .hasMessage("Repeat value must be a positive integer");
 assertThat(NegativeValueShouldThrowIllegalArgumentException.count).isEqualTo(0);
}

@Test
public void failingTestShouldFailOneTimeWhenRepeatIsOne() {
 Result result = TestRunner.runTest(FailingTestShouldFailOneTimeWhenRepeatIsOne.class);
 assertThat(result.wasSuccessful()).isFalse();
 List<Failure> failures = result.getFailures();
 assertThat(failures.size()).as("Failures: " + failures).isEqualTo(1);
 Failure failure = failures.get(0);
 assertThat(failure.getException()).isExactlyInstanceOf(AssertionError.class)
   .hasMessage(ASSERTION_ERROR_MESSAGE);
 assertThat(FailingTestShouldFailOneTimeWhenRepeatIsOne.count).isEqualTo(1);
}

@Test
public void failsWhenTimeoutIsEarly() {
 Result result = TestRunner.runTest(FailsWhenTimeoutIsEarly.class);
 assertThat(result.wasSuccessful()).isFalse();
 List<Failure> failures = result.getFailures();
 assertThat(failures.size()).as("Failures: " + failures).isEqualTo(1);
 Failure failure = failures.get(0);
 assertThat(failure.getException()).isExactlyInstanceOf(AssertionError.class)
   .hasMessage("Expected test to throw (an instance of " + TimeoutException.class.getName()
     + " and exception with message a string containing \"" + FailsWhenTimeoutIsEarly.message
     + "\")");
}

@Test
public void failsWithoutExpectedTimeoutException() {
 Result result = TestRunner.runTest(FailsWithoutExpectedTimeoutException.class);
 assertThat(result.wasSuccessful()).isFalse();
 List<Failure> failures = result.getFailures();
 assertThat(failures.size()).as("Failures: " + failures).isEqualTo(1);
 Failure failure = failures.get(0);
 assertThat(failure.getException()).isExactlyInstanceOf(AssertionError.class)
   .hasMessage("Expected test to throw (an instance of " + TimeoutException.class.getName()
     + " and exception with message a string containing \""
     + FailsWithoutExpectedTimeoutException.message + "\")");
}

private void assertNoFailures(Result result) {
 if (!result.wasSuccessful()) {
  for (Failure failure : result.getFailures()) {
   fail(failure.getMessage());
  }
 }
}

 @Test
 public void testReportLateFailures() {
  Result result;
  try {
   result = new JUnitCore().run(new BlockJUnit4ClassRunner(LateFailureReport.class));
  } catch (InitializationError initializationError) {
   throw new AssertionError(initializationError);
  }
  assertEquals(1, result.getFailureCount());
  assertEquals(IllegalStateException.class, result.getFailures().get(0).getException().getClass());
 }
}