下面列出了怎么用org.junit.internal.runners.ErrorReportingRunner的API类实例代码及写法,或者点击链接到github查看源代码。
@Override
public List<TestUnit> findTestUnits(final Class<?> clazz) {
final Runner runner = AdaptedJUnitTestUnit.createRunner(clazz);
if ((runner == null)
|| runner.getClass().isAssignableFrom(ErrorReportingRunner.class)) {
return Collections.emptyList();
}
if (isParameterizedTest(runner)) {
return handleParameterizedTest(clazz, runner.getDescription());
}
return Collections.emptyList();
}
@Test
public void builderHandlesNotATest() throws Throwable {
Runner selectedRunner = androidLogOnlyBuilder.runnerForClass(NotATest.class);
if (scanningPath) {
assertThat(selectedRunner, nullValue());
} else {
assertThat(selectedRunner, notNullValue());
assertThat(selectedRunner.getClass(), typeCompatibleWith(ErrorReportingRunner.class));
runWithRunner(selectedRunner, 1, 1);
}
}
private void checkForErrorRunner(final Runner runner) {
if (runner instanceof ErrorReportingRunner) {
LOG.warning("JUnit error for class " + this.clazz + " : "
+ runner.getDescription());
}
}
private boolean isNotARunnableTest(final Runner runner,
final String className) {
try {
return (runner == null)
|| runner.getClass().isAssignableFrom(ErrorReportingRunner.class)
|| isParameterizedTest(runner)
|| isAJUnitThreeErrorOrWarning(runner)
|| isJUnitThreeSuiteMethodNotForOwnClass(runner, className);
} catch (final RuntimeException ex) {
// some runners (looking at you spock) can throw a runtime exception
// when the getDescription method is called
return true;
}
}
@Override
public Runner runnerForClass(Class<?> testClass) throws Throwable {
// Increment the number of runners created.
++runnerCount;
// Build non executing runners for JUnit3 test classes
if (isJUnit3Test(testClass)) {
// If scanning the path then make sure that it has at least one test method before
// trying to run it.
if (scanningPath && !hasJUnit3TestMethod(testClass)) {
return null;
}
return new JUnit38ClassRunner(new NonExecutingTestSuite(testClass));
} else if (hasSuiteMethod(testClass)) {
if (runnerParams.isIgnoreSuiteMethods()) {
return null;
}
Test test = SuiteMethod.testFromSuiteMethod(testClass);
if (!(test instanceof TestSuite)) {
// this should not be possible
throw new IllegalArgumentException(
testClass.getName() + "#suite() did not return a TestSuite");
}
return new JUnit38ClassRunner(new NonExecutingTestSuite((TestSuite) test));
} else {
// Reset the count of the number of Runners created for the supplied testClass. Save
// away the number created for the parent testClass.
int oldRunnerCount = runnerCount;
Runner runner = builder.runnerForClass(testClass);
if (null == runner) {
// If the runner could not be created then do not wrap it.
return null;
} else if (runner instanceof ErrorReportingRunner) {
// Preserve behavior where a failure during construction results in an error,
// even while in logOnly mode, by simply returning the runner rather than
// wrapping it.
return runner;
} else if (runnerCount > oldRunnerCount) {
// If constructing the testClass caused us to reenter here to build Runner
// instances, e.g. for Suite or Enclosed, then this must not wrap runner in a
// NonExecutingRunner as that would cause problems if any of the nested classes
// were JUnit 3 ones.
return runner;
} else {
return new NonExecutingRunner(runner);
}
}
}
@Test
public void testLoadTests_runWith() {
// This fails because it has no @Test annotated methods.
assertLoadTestSuccess(JUnit4RunTest.class, ErrorReportingRunner.class);
}
@Test
public void testLoadTests_all() {
Collection<String> classNames =
Arrays.asList(
JUnit3Test.class.getName(),
EmptyJUnit3Test.class.getName(),
JUnit4Test.class.getName(),
JUnit4RunTest.class.getName(),
NotATest.class.getName(),
CustomTest.class.getName(),
"notexist",
AbstractTest.class.getName(),
SubClassJUnit4Test.class.getName(),
SubClassAbstractTest.class.getName());
List<Runner> runners = loader.getRunnersFor(classNames, false);
List<Class<? extends Runner>> runnerClasses = new ArrayList<>();
for (Runner runner : runners) {
runnerClasses.add(runner == null ? null : runner.getClass());
}
List<Class<? extends Runner>> expectedRunnerClasses;
if (scanningPath) {
// When scanning path TestLoader is stricter about what it will accept as a test.
expectedRunnerClasses =
Arrays.asList(
JUnit38ClassRunner.class,
AndroidJUnit4ClassRunner.class,
ErrorReportingRunner.class,
UnloadableClassRunner.class,
AndroidJUnit4ClassRunner.class,
JUnit38ClassRunner.class);
} else {
expectedRunnerClasses =
Arrays.asList(
JUnit38ClassRunner.class,
JUnit38ClassRunner.class,
AndroidJUnit4ClassRunner.class,
ErrorReportingRunner.class,
ErrorReportingRunner.class,
ErrorReportingRunner.class,
UnloadableClassRunner.class,
JUnit38ClassRunner.class,
AndroidJUnit4ClassRunner.class,
JUnit38ClassRunner.class);
}
assertEquals(expectedRunnerClasses, runnerClasses);
}
@Test
public void testLoadTests_notATest() {
assertScanningLoadsAnyClass(NotATest.class, ErrorReportingRunner.class);
}
@Test
public void testLoadTests_CustomTest() {
assertScanningLoadsAnyClass(CustomTest.class, ErrorReportingRunner.class);
}
@SuppressWarnings({"ThrowableInstanceNeverThrown"})
private static Request createErrorReportingRequestForFilterError(Filter filter) {
ErrorReportingRunner runner = new ErrorReportingRunner(Filter.class, new Exception(
String.format("No tests found matching %s", filter.describe())));
return Request.runner(runner);
}