Java PrintableResult类代码示例

import org.junit.experimental.results.PrintableResult; //导入依赖的package包/类
@Theory(nullsAccepted = false)
public void backTraceHasGoodToString(String descriptionName,
        final String stackTraceClassName) {
    Failure failure = new Failure(Description
            .createSuiteDescription(descriptionName), new Throwable() {
        private static final long serialVersionUID = 1L;

        @Override
        public StackTraceElement[] getStackTrace() {
            return new StackTraceElement[]{new StackTraceElement(
                    stackTraceClassName, "methodName", "fileName", 1)};
        }
    });

    assertThat(new PrintableResult(asList(failure)).toString(), allOf(
            containsString(descriptionName), containsString(stackTraceClassName)));
}
 

import org.junit.experimental.results.PrintableResult; //导入依赖的package包/类
@Test
public void whereTypeVariablesAbound() {
    PrintableResult result = testResult(TypeVariablesAbound.class);
    assertThat(result, failureCountIs(7));
    assertThat(result, hasFailureContaining("unresolved type variable A"));
    assertThat(result, hasFailureContaining("unresolved type variable B"));
    assertThat(result, hasFailureContaining("unresolved type variable C"));
    assertThat(result, hasFailureContaining("unresolved type variable D"));
    assertThat(result, hasFailureContaining("unresolved type variable E"));
    assertThat(result, hasFailureContaining("unresolved type variable F"));
    assertThat(result, hasFailureContaining("unresolved type variable G"));
}
 

import org.junit.experimental.results.PrintableResult; //导入依赖的package包/类
@Test
public void dataPointFieldsMustBeStatic() {
    assertThat(
            testResult(DataPointFieldsMustBeStatic.class),
            CoreMatchers.<PrintableResult>both(failureCountIs(2))
                    .and(
                            hasFailureContaining("DataPoint field THREE must be static"))
                    .and(
                            hasFailureContaining("DataPoint field FOURS must be static")));
}
 

import org.junit.experimental.results.PrintableResult; //导入依赖的package包/类
@Test
public void dataPointMethodsMustBeStatic() {
    assertThat(
            testResult(DataPointMethodsMustBeStatic.class),
            CoreMatchers.<PrintableResult>both(failureCountIs(2))
            .and(
                    hasFailureContaining("DataPoint method singleDataPointMethod must be static"))
            .and(
                    hasFailureContaining("DataPoint method dataPointArrayMethod must be static")));
}
 

import org.junit.experimental.results.PrintableResult; //导入依赖的package包/类
@Test
public void dataPointFieldsMustBePublic() {
    PrintableResult result = testResult(DataPointFieldsMustBePublic.class);        
    assertEquals(6, result.failureCount());

    assertThat(result,
            allOf(hasFailureContaining("DataPoint field THREE must be public"),
                  hasFailureContaining("DataPoint field THREES must be public"),
                  hasFailureContaining("DataPoint field FOUR must be public"),
                  hasFailureContaining("DataPoint field FOURS must be public"),
                  hasFailureContaining("DataPoint field FIVE must be public"),
                  hasFailureContaining("DataPoint field FIVES must be public")));
}
 

import org.junit.experimental.results.PrintableResult; //导入依赖的package包/类
@Test
public void dataPointMethodsMustBePublic() {
    PrintableResult result = testResult(DataPointMethodsMustBePublic.class);        
    assertEquals(6, result.failureCount());

    assertThat(result,
            allOf(hasFailureContaining("DataPoint method three must be public"),
                  hasFailureContaining("DataPoint method threes must be public"),
                  hasFailureContaining("DataPoint method four must be public"),
                  hasFailureContaining("DataPoint method fours must be public"),
                  hasFailureContaining("DataPoint method five must be public"),
                  hasFailureContaining("DataPoint method fives must be public")));
}
 

import org.junit.experimental.results.PrintableResult; //导入依赖的package包/类
@Test
public void testWatcherSkippedThrowsException() {
    PrintableResult result = testResult(TestWatcherSkippedThrowsExceptionTest.class);
    assertThat(result, failureCountIs(2));
    assertThat(result, hasFailureContaining("test failure"));
    assertThat(result, hasFailureContaining("watcher failure"));
}
 

import org.junit.experimental.results.PrintableResult; //导入依赖的package包/类
@Test
public void testWatcherFailedThrowsException() {
    PrintableResult result = testResult(TestWatcherFailedThrowsExceptionTest.class);
    assertThat(result, failureCountIs(2));
    assertThat(result, hasFailureContaining("test failure"));
    assertThat(result, hasFailureContaining("watcher failure"));
}
 

import org.junit.experimental.results.PrintableResult; //导入依赖的package包/类
@Test
public void testWatcherStartingThrowsException() {
    PrintableResult result = testResult(TestWatcherStartingThrowsExceptionTest.class);
    assertThat(result, failureCountIs(2));
    assertThat(result, hasFailureContaining("test failure"));
    assertThat(result, hasFailureContaining("watcher failure"));
}
 

import org.junit.experimental.results.PrintableResult; //导入依赖的package包/类
@Test
public void testWatcherFailedAndFinishedThrowsException() {
    PrintableResult result = testResult(TestWatcherFailedAndFinishedThrowsExceptionTest.class);
    assertThat(result, failureCountIs(3));
    assertThat(result, hasFailureContaining("test failure"));
    assertThat(result, hasFailureContaining("watcher failed failure"));
    assertThat(result, hasFailureContaining("watcher finished failure"));
}
 

import org.junit.experimental.results.PrintableResult; //导入依赖的package包/类
@Test
public void usedErrorCollectorCheckThatShouldFail() {
    PrintableResult testResult = testResult(UsesErrorCollectorCheckThat.class);
    assertThat(testResult, hasFailureContaining("was <3>"));
    assertThat(testResult, hasFailureContaining("was <5>"));
    assertThat(testResult, hasFailureContaining("reason 1"));
    assertThat(testResult, hasFailureContaining("was <7>"));
    assertThat(testResult, hasFailureContaining("reason 2"));
    assertThat(testResult, hasFailureContaining("was <9>"));
}
 

import org.junit.experimental.results.PrintableResult; //导入依赖的package包/类
@Theory
public void includeMultipleFailures(String secondExceptionName) {
    PrintableResult backtrace = new PrintableResult(Arrays.asList(
            new Failure(Description.createSuiteDescription("firstName"),
                    new RuntimeException("firstException")), new Failure(
            Description.createSuiteDescription("secondName"),
            new RuntimeException(secondExceptionName))));
    assertThat(backtrace.toString(), containsString(secondExceptionName));
}
 

import org.junit.experimental.results.PrintableResult; //导入依赖的package包/类
@Test
public void dataPointsMustBeStatic() {
    assertThat(
            testResult(DataPointsMustBeStatic.class),
            CoreMatchers.<PrintableResult>both(failureCountIs(2))
                    .and(
                            hasFailureContaining("DataPoint field THREE must be static"))
                    .and(
                            hasFailureContaining("DataPoint field FOUR must be static")));
}
 

import org.junit.experimental.results.PrintableResult; //导入依赖的package包/类
@Test
public void whereTypeVariableIsOnTheTheory() {
    PrintableResult result = testResult(TypeVariableOnTheoryOnly.class);
    assertThat(result, isSuccessful());
}
 

import org.junit.experimental.results.PrintableResult; //导入依赖的package包/类
@Test
public void whereTypeVariableIsOnTheoryParm() {
    PrintableResult result = testResult(TypeVariableOnTheoryParm.class);
    assertThat(result, hasSingleFailureContaining("unresolved type variable T"));
}