下面列出了怎么用org.junit.runner.Request的API类实例代码及写法，或者点击链接到github查看源代码。
@Test
public void testCreateModel_simpleSuite() throws Exception {
Class<?> suiteClass = SampleSuite.class;
Request request = Request.classWithoutSuiteMethod(suiteClass);
String suiteClassName = suiteClass.getCanonicalName();
JUnit4TestModelBuilder modelBuilder = builder(
request, suiteClassName, stubShardingEnvironment, null, xmlResultWriter);
Description topSuite = request.getRunner().getDescription();
Description innerSuite = topSuite.getChildren().get(0);
Description testOne = innerSuite.getChildren().get(0);
TestSuiteModel model = modelBuilder.get();
TestNode topSuiteNode = Iterables.getOnlyElement(model.getTopLevelTestSuites());
assertThat(topSuiteNode.getDescription()).isEqualTo(topSuite);
TestNode innerSuiteNode = Iterables.getOnlyElement(topSuiteNode.getChildren());
assertThat(innerSuiteNode.getDescription()).isEqualTo(innerSuite);
TestNode testOneNode = Iterables.getOnlyElement(innerSuiteNode.getChildren());
assertThat(testOneNode.getDescription()).isEqualTo(testOne);
assertThat(testOneNode.getChildren()).isEmpty();
assertThat(model.getNumTestCases()).isEqualTo(1);
}
public JUnit4RunnerFactory(
Supplier<Request> requestSupplier,
Supplier<CancellableRequestFactory> requestFactorySupplier,
Supplier<Supplier<TestSuiteModel>> modelSupplierSupplier,
Supplier<PrintStream> testRunnerOutSupplier,
Supplier<JUnit4Config> configSupplier,
Supplier<Set<RunListener>> runListenersSupplier,
Supplier<Set<JUnit4Runner.Initializer>> initializersSupplier) {
assert requestSupplier != null;
this.requestSupplier = requestSupplier;
assert requestFactorySupplier != null;
this.requestFactorySupplier = requestFactorySupplier;
assert modelSupplierSupplier != null;
this.modelSupplierSupplier = modelSupplierSupplier;
assert testRunnerOutSupplier != null;
this.testRunnerOutSupplier = testRunnerOutSupplier;
assert configSupplier != null;
this.configSupplier = configSupplier;
assert runListenersSupplier != null;
this.runListenersSupplier = runListenersSupplier;
assert initializersSupplier != null;
this.initializersSupplier = initializersSupplier;
}
/**
* Verify that a JUnit 3 suite method that returns a TestCase is not executed when skipExecution =
* true.
*/
@Test
public void testSkipExecution_JUnit3SuiteMethod_ReturnsTestCase() {
Request request =
builder
.setSkipExecution(true)
.addTestClass(JUnit3SuiteMethod_ReturnsTestCase.class.getName())
.build();
JUnitCore testRunner = new JUnitCore();
// Differs from standard JUnit behavior; a suite() method can return any implementation of
// junit.framework.Test not just TestSuite.
ensureAllTestsFailed(
testRunner.run(request),
1,
JUnit3SuiteMethod_ReturnsTestCase.class.getName() + "#suite() did not return a TestSuite");
}
@Test
public void testFailingRun() {
final AtomicBoolean testRan = new AtomicBoolean(false);
final RuntimeException expectedFailure = new RuntimeException();
// A runner that should run its test
FakeRunner runner = new FakeRunner("shouldRun", new Runnable() {
@Override
public void run() {
testRan.set(true);
throw expectedFailure;
}
});
Request request = cancellableRequestFactory.createRequest(Request.runner(runner));
JUnitCore core = new JUnitCore();
Result result = core.run(request);
assertThat(testRan.get()).isTrue();
assertThat(result.getRunCount()).isEqualTo(1);
assertThat(result.getFailureCount()).isEqualTo(1);
assertThat(result.getFailures().get(0).getException()).isSameInstanceAs(expectedFailure);
}
public static Factory<JUnit4Runner> create(
Supplier<Request> requestSupplier,
Supplier<CancellableRequestFactory> requestFactorySupplier,
Supplier<Supplier<TestSuiteModel>> modelSupplierSupplier,
Supplier<PrintStream> testRunnerOutSupplier,
Supplier<JUnit4Config> configSupplier,
Supplier<Set<RunListener>> runListenersSupplier,
Supplier<Set<JUnit4Runner.Initializer>> initializersSupplier) {
return new JUnit4RunnerFactory(
requestSupplier,
requestFactorySupplier,
modelSupplierSupplier,
testRunnerOutSupplier,
configSupplier,
runListenersSupplier,
initializersSupplier);
}
/** Execute the tests */
public Bundle execute(Request request) {
Bundle resultBundle = new Bundle();
Result junitResults = new Result();
try {
JUnitCore testRunner = new JUnitCore();
setUpListeners(testRunner);
junitResults = testRunner.run(request);
} catch (Throwable t) {
final String msg = "Fatal exception when running tests";
Log.e(LOG_TAG, msg, t);
junitResults.getFailures().add(new Failure(Description.createSuiteDescription(msg), t));
} finally {
ByteArrayOutputStream summaryStream = new ByteArrayOutputStream();
// create the stream used to output summary data to the user
PrintStream summaryWriter = new PrintStream(summaryStream);
reportRunEnded(listeners, summaryWriter, resultBundle, junitResults);
summaryWriter.close();
resultBundle.putString(
Instrumentation.REPORT_KEY_STREAMRESULT, String.format("\n%s", summaryStream.toString()));
}
return resultBundle;
}
/** Builds a {@link Request} based on given input arguments. */
@VisibleForTesting
Request buildRequest(RunnerArgs runnerArgs, Bundle bundleArgs) {
TestRequestBuilder builder = createTestRequestBuilder(this, bundleArgs);
builder.addPathsToScan(runnerArgs.classpathToScan);
if (runnerArgs.classpathToScan.isEmpty()) {
// Only scan for tests for current apk aka testContext
// Note that this represents a change from InstrumentationTestRunner where
// getTargetContext().getPackageCodePath() aka app under test was also scanned
// Only add the package classpath when no custom classpath is provided in order to
// avoid duplicate class issues.
builder.addPathToScan(getContext().getPackageCodePath());
}
builder.addFromRunnerArgs(runnerArgs);
registerUserTracker();
return builder.build();
}
/**
* .
* @param args .
* @throws ClassNotFoundException .
*/
public static void main(String... args) throws ClassNotFoundException {
int retCode = 0;
String resultMessage = "SUCCESS";
String[] classAndMethod = args[0].split("#");
Request request = Request.method(Class.forName(classAndMethod[0]),
classAndMethod[1]);
Result result = new JUnitCore().run(request);
if (!result.wasSuccessful()) {
retCode = 1;
resultMessage = "FAILURE";
}
System.out.println(resultMessage);
System.exit(retCode);
}
@Test
public void assumptionViolationsAreReportedAsSkippedTests() throws Exception {
TestSuiteModelSupplier mockModelSupplier = mock(TestSuiteModelSupplier.class);
TestSuiteModel mockModel = mock(TestSuiteModel.class);
CancellableRequestFactory mockRequestFactory = mock(CancellableRequestFactory.class);
OutputStream mockXmlStream = mock(OutputStream.class);
JUnit4TestXmlListener listener = new JUnit4TestXmlListener(
mockModelSupplier, mockRequestFactory, fakeSignalHandlers, mockXmlStream, errPrintStream);
Request request = Request.classWithoutSuiteMethod(TestWithAssumptionViolation.class);
Description suiteDescription = request.getRunner().getDescription();
Description testDescription = suiteDescription.getChildren().get(0);
when(mockModelSupplier.get()).thenReturn(mockModel);
JUnitCore core = new JUnitCore();
core.addListener(listener);
core.run(request);
assertWithMessage("no output to stderr expected").that(errStream.size()).isEqualTo(0);
InOrder inOrder = inOrder(mockModel);
inOrder.verify(mockModel).testSkipped(testDescription);
inOrder.verify(mockModel).writeAsXml(mockXmlStream);
verify(mockRequestFactory, never()).cancelRun();
}
/** Test provided multiple annotations to include. */
@Test
public void testTestSizeFilter_multipleAnnotation() {
Request request =
builder
.addAnnotationInclusionFilter(SmallTest.class.getName())
.addAnnotationInclusionFilter(FlakyTest.class.getName())
.addTestClass(SampleRunnerFilterSizeTest.class.getName())
.addTestClass(SampleMultipleAnnotation.class.getName())
.build();
JUnitCore testRunner = new JUnitCore();
Result result = testRunner.run(request);
// expect 1 test that failed
Assert.assertEquals(1, result.getRunCount());
Assert.assertEquals(1, result.getFailureCount());
Assert.assertEquals(
"testSmallSkipped", result.getFailures().get(0).getDescription().getMethodName());
}
/** Test that {@link SdkSuppress} filters tests as appropriate */
@Test
public void testSdkSuppress() throws Exception {
MockitoAnnotations.initMocks(this);
TestRequestBuilder b = createBuilder(mockDeviceBuild);
when(mockDeviceBuild.getSdkVersionInt()).thenReturn(16);
when(mockDeviceBuild.getCodeName()).thenReturn("REL");
Request request = b.addTestClass(SampleSdkSuppress.class.getName()).build();
JUnitCore testRunner = new JUnitCore();
Result result = testRunner.run(request);
Set<String> expected =
new HashSet<>(Arrays.asList("min15", "min16", "noSdkSuppress", "max19", "min14max16"));
Assert.assertEquals(expected.size(), result.getRunCount());
for (Failure f : result.getFailures()) {
assertTrue(
"Fail! " + expected + " doesn't contain \"" + f.getMessage() + "\" ",
expected.contains(f.getMessage()));
}
}
@Test
public void failuresAreReported() throws Exception {
TestSuiteModelSupplier mockModelSupplier = mock(TestSuiteModelSupplier.class);
TestSuiteModel mockModel = mock(TestSuiteModel.class);
CancellableRequestFactory mockRequestFactory = mock(CancellableRequestFactory.class);
OutputStream mockXmlStream = mock(OutputStream.class);
JUnit4TestXmlListener listener = new JUnit4TestXmlListener(
mockModelSupplier, mockRequestFactory, fakeSignalHandlers, mockXmlStream, errPrintStream);
Request request = Request.classWithoutSuiteMethod(FailingTest.class);
Description suiteDescription = request.getRunner().getDescription();
Description testDescription = suiteDescription.getChildren().get(0);
when(mockModelSupplier.get()).thenReturn(mockModel);
JUnitCore core = new JUnitCore();
core.addListener(listener);
core.run(request);
assertWithMessage("no output to stderr expected").that(errStream.size()).isEqualTo(0);
InOrder inOrder = inOrder(mockModel);
inOrder.verify(mockModel).testFailure(eq(testDescription), any(Throwable.class));
inOrder.verify(mockModel).writeAsXml(mockXmlStream);
verify(mockRequestFactory, never()).cancelRun();
}
@Test
public void testCreateModel_singleTestClass() throws Exception {
Class<?> testClass = SampleTestCaseWithTwoTests.class;
Request request = Request.classWithoutSuiteMethod(testClass);
String testClassName = testClass.getCanonicalName();
JUnit4TestModelBuilder modelBuilder = builder(
request, testClassName, stubShardingEnvironment, null, xmlResultWriter);
Description suite = request.getRunner().getDescription();
Description testOne = suite.getChildren().get(0);
Description testTwo = suite.getChildren().get(1);
TestSuiteModel model = modelBuilder.get();
TestNode suiteNode = Iterables.getOnlyElement(model.getTopLevelTestSuites());
assertThat(suiteNode.getDescription()).isEqualTo(suite);
List<TestNode> testCases = suiteNode.getChildren();
assertThat(testCases).hasSize(2);
TestNode testOneNode = testCases.get(0);
TestNode testTwoNode = testCases.get(1);
assertThat(testOneNode.getDescription()).isEqualTo(testOne);
assertThat(testTwoNode.getDescription()).isEqualTo(testTwo);
assertThat(testOneNode.getChildren()).isEmpty();
assertThat(testTwoNode.getChildren()).isEmpty();
assertThat(model.getNumTestCases()).isEqualTo(2);
}
private void runTestClass(String testClassName) throws ClassNotFoundException {
final Class<?> testClass = Class.forName(testClassName, false, applicationClassLoader);
Request request = Request.aClass(testClass);
if (options.hasCategoryConfiguration()) {
Transformer<Class<?>, String> transformer = new Transformer<Class<?>, String>() {
public Class<?> transform(final String original) {
try {
return applicationClassLoader.loadClass(original);
} catch (ClassNotFoundException e) {
throw new InvalidUserDataException(String.format("Can't load category class [%s].", original), e);
}
}
};
request = request.filterWith(new CategoryFilter(
CollectionUtils.collect(options.getIncludeCategories(), transformer),
CollectionUtils.collect(options.getExcludeCategories(), transformer)
));
}
if (!options.getIncludedTests().isEmpty()) {
request = request.filterWith(new MethodNameFilter(options.getIncludedTests()));
}
Runner runner = request.getRunner();
//In case of no matching methods junit will return a ErrorReportingRunner for org.junit.runner.manipulation.Filter.class.
//Will be fixed with adding class filters
if (!org.junit.runner.manipulation.Filter.class.getName().equals(runner.getDescription().getDisplayName())) {
RunNotifier notifier = new RunNotifier();
notifier.addListener(listener);
runner.run(notifier);
}
}
/** Verify that a JUnit 3 custom Test cannot be executed because it has no runnable methods. */
@Test
public void testNoSkipExecution_JUnit3CustomTest() throws Throwable {
Request request = builder.addTestClass(JUnit3FailingTestSuite.class.getName()).build();
JUnitCore testRunner = new JUnitCore();
ensureAllTestsFailed(testRunner.run(request), 1, "No runnable methods");
}
List<Description> getAllDescriptions(Description description, String className) {
final AllExceptIgnoredTestRunnerBuilder allExceptIgnoredTestRunnerBuilder = new AllExceptIgnoredTestRunnerBuilder();
try {
final Class<?> testClass = description.getClass().getClassLoader().loadClass(className);
Runner runner = allExceptIgnoredTestRunnerBuilder.runnerForClass(testClass);
if (runner == null) {
//fall back to default runner
runner = Request.aClass(testClass).getRunner();
}
final Description runnerDescription = runner.getDescription();
return runnerDescription.getChildren();
} catch (Throwable throwable) {
throw new TestSuiteExecutionException(String.format("Unable to process Ignored class %s.", className), throwable);
}
}
private static void runTest(String test) {
try {
String[] classAndMethod = test.split("#");
System.out.println(test);
Request request = Request.method(Class.forName(classAndMethod[0]), classAndMethod[1]);
JUnitCore junit = new JUnitCore();
junit.addListener(new TextListener(System.out));
junit.run(request);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
/**
* Verify that a JUnit 3 custom Test cannot be executed because it has no runnable methods, even
* when skipExecution = true.
*/
@Test
public void testSkipExecution_JUnit3CustomTest() throws Throwable {
Request request =
builder.setSkipExecution(true).addTestClass(JUnit3FailingTestSuite.class.getName()).build();
JUnitCore testRunner = new JUnitCore();
ensureAllTestsFailed(testRunner.run(request), 1, "No runnable methods");
}
/**
* args[0] test class
* args[1] test method (optional)
*
* @param args
*/
public static void main(String[] args) {
if (args.length < 1 || args.length > 2) {
System.err.println("Usage: java -cp .:JUnitRunner-0.0.1-SNAPSHOT.jar:<project cp> uk.ac.shef.JUnitRunner <full test class name> [test method name]");
System.exit(-1);
}
Class<?> clazz = null;
try {
clazz = Class.forName(args[0], false, JUnitRunner.class.getClassLoader());
} catch (ClassNotFoundException e) {
e.printStackTrace();
System.exit(-1);
}
Request request = null;
if (args.length == 1) {
request = Request.aClass(clazz);
} else if (args.length == 2) {
request = Request.method(clazz, args[1]);
}
JUnitListener listener = new JUnitListener();
JUnitCore runner = new JUnitCore();
runner.addListener(listener);
runner.run(request); // run test method
System.exit(0);
}
private ITestReference createFilteredTest(Class<?> clazz, String testName, String[] failureNames) {
DescriptionMatcher matcher= DescriptionMatcher.create(clazz, testName);
SubForestFilter filter= new SubForestFilter(matcher);
Request request= sortByFailures(Request.classWithoutSuiteMethod(clazz).filterWith(filter), failureNames);
Runner runner= request.getRunner();
Description description= getRootDescription(runner, matcher);
return new HybrisJUnitTestReference(runner, description);
}
/**
* Verify that @RunWith(Suite.class) annotated test that contains a JUnit 3 suite method that
* returns a TestSuite that contains a custom Test will execute the custom Test when skipExecution
* = false.
*/
@Test
public void testNoSkipExecution_RunWithSuite_WithCustomTest() {
Request request = builder.addTestClass(RunWithSuite_WithCustomTest.class.getName()).build();
JUnitCore testRunner = new JUnitCore();
ensureAllTestsFailed(testRunner.run(request), 1, "broken");
}
@Override
public Request get() {
Request request = JUnit4RunnerBaseModule.provideRequest(suiteClassSupplier.get());
if (request == null) {
throw new NullPointerException();
}
return request;
}
private Runnable createRunnable(Class<?> testClass, String testMathod) {
return () -> {
LOGGER.info(Thread.currentThread().getName() + " Parallel Junit test- *Start. Time = " + now());
Result result = (new JUnitCore()).run(Request.method(testClass, testMathod));
LOGGER.info(Thread.currentThread().getName() + " Parallel Junit test- * End. Time = " + now());
if (result.wasSuccessful()) {
passedCounter.incrementAndGet();
} else {
failedCounter.incrementAndGet();
}
};
}
@Test
public void testLoad_Pass() {
ExecutorServiceRunner executorServiceRunner = new ExecutorServiceRunner("load_config_test.properties");
final AtomicInteger passedCounter = new AtomicInteger();
final AtomicInteger failedCounter = new AtomicInteger();
Runnable taskSampleTest = () -> {
System.out.println(Thread.currentThread().getName() + " JunitTestSample test- Start. Time = " + LocalDateTime.now());
Result result = (new JUnitCore()).run(Request.method(JunitTestSample.class, "testFirstName"));
System.out.println(Thread.currentThread().getName() + " JunitTestSample test- *Finished Time, result = " + LocalDateTime.now() + " -" + result.wasSuccessful());
if(result.wasSuccessful()){
passedCounter.incrementAndGet();
} else {
failedCounter.incrementAndGet();
}
};
executorServiceRunner.addRunnable(taskSampleTest);
executorServiceRunner.runRunnables();
System.out.println(">>> passed count:" + passedCounter.get());
System.out.println(">>> failed count:" + failedCounter.get());
System.out.println(">>> Total test count:" + (failedCounter.get() + passedCounter.get()));
assertThat(failedCounter.get(), is(0));
}
@Test
public void testLoad_Fail() {
ExecutorServiceRunner executorServiceRunner = new ExecutorServiceRunner("load_config_test.properties");
final AtomicInteger passedCounter = new AtomicInteger();
final AtomicInteger failedCounter = new AtomicInteger();
Runnable taskSampleTest = () -> {
System.out.println(Thread.currentThread().getName() + " JunitTestSample test- Start. Time = " + LocalDateTime.now());
Result result = (new JUnitCore()).run(Request.method(JunitTestSample.class, "testFirstName_fail"));
System.out.println(Thread.currentThread().getName() + " JunitTestSample test- *Finished Time, result = " + LocalDateTime.now() + " -" + result.wasSuccessful());
if(result.wasSuccessful()){
passedCounter.incrementAndGet();
} else {
failedCounter.incrementAndGet();
}
};
executorServiceRunner.addRunnable(taskSampleTest);
executorServiceRunner.runRunnables();
System.out.println(">>> passed count:" + passedCounter.get());
System.out.println(">>> failed count:" + failedCounter.get());
System.out.println(">>> Total test count:" + (failedCounter.get() + passedCounter.get()));
assertThat(passedCounter.get(), is(0));
}
private static void runTest(String test) {
try {
String[] classAndMethod = test.split("#");
System.out.println(test);
Request request = Request.method(Class.forName(classAndMethod[0]), classAndMethod[1]);
JUnitCore junit = new JUnitCore();
junit.addListener(new TextListener(System.out));
junit.run(request);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
@BeforeClass
public static void addNotifierListener() {
notifier.addListener(mockRunListener);
assertThat(TestRunner.beforeClassCalled).isEqualTo(0);
Request.aClass(TestRunner.class).getRunner().run(notifier);
}
/** Verify suite() methods are not ignored when method filter is used */
@Test
public void testJUnit3Suite_NotFiltered() {
Request request =
builder.addTestMethod(JUnit3SuiteWithTest.class.getName(), "testPass").build();
JUnitCore testRunner = new JUnitCore();
Result result = testRunner.run(request);
Assert.assertEquals(3, result.getRunCount());
}
@Test
public void verifyTestRunnerIsNotExecuted() throws Exception {
RunNotifier notifier = new RunNotifier();
RunListener listener = mock(RunListener.class);
notifier.addListener(listener);
Request.aClass(TestRunnerIgnoredOnClassLevel.class).getRunner().run(notifier);
verify(listener, times(1)).testIgnored(any(Description.class));
Assertions.assertThat(TestRunnerIgnoredOnClassLevel.ignoredTestInputMethodNotCalled).isTrue();
}
@Test
public void accessProtectedMethodFromSameClassloaderAndPackage() throws ClassNotFoundException {
String qualifiedName = "test.dynamic.compiler.HelloWorld";
String qualifiedTestName = "test.dynamic.compiler.HelloWorldTest";
String code =
"package test.dynamic.compiler;" +
"public class HelloWorld {" +
" protected String message() {" +
" return \"Hello World!\";" +
" }" +
"}";
String testCode =
"package test.dynamic.compiler;" +
"import org.junit.Test;" +
"import static org.junit.Assert.assertEquals;" +
"public class HelloWorldTest {" +
" @Test" +
" public void protectedMethodTest() {" +
" assertEquals(\"Hello World!\", new HelloWorld().message());" +
" }" +
"}";
Map<String, String> sources = adHocMap(asList(qualifiedName, qualifiedTestName), asList(code, testCode));
ClassLoader loader = BytecodeClassLoaderBuilder.loaderFor(sources);
Class<?> testClass = loader.loadClass(qualifiedTestName);
Class<?> theClass = loader.loadClass(qualifiedName);
assertTrue(loader == theClass.getClassLoader());
assertTrue(loader == testClass.getClassLoader());
JUnitCore junit = new JUnitCore();
Request request = Request.method(testClass, "protectedMethodTest");
Result result = junit.run(request);
assertTrue(result.wasSuccessful());
}