public InternalRemoteRunner(
Class<?> testClass, String endpoint, Class<? extends Runner> remoteRunnerClass)
throws InitializationError {
super(testClass);
this.testClass = testClass;
this.remoteRunnerClass = remoteRunnerClass;
TestClass tc = new TestClass(testClass);
description = Description.createTestDescription(testClass, tc.getName(), tc.getAnnotations());
for (FrameworkMethod method : tc.getAnnotatedMethods(Test.class)) {
String methodName = method.getName();
Description child =
Description.createTestDescription(testClass, methodName, method.getAnnotations());
methodNames.put(child, methodName);
description.addChild(child);
}
if (executorService == null) {
String ep = System.getProperty("junit.remote.endpoint");
if (ep == null) {
ep = endpoint;
}
for (String e : ep.split(",")) {
if (e.trim().equals("")) {
continue;
}
endpoints.add(e.trim());
}
executorService = Executors.newFixedThreadPool(endpoints.size());
}
setScheduler(
new RunnerScheduler() {
@Override
public void schedule(final Runnable childStatement) {
SEMAPHORE.reducePermits(1);
executorService.submit(new SemaphoreDelegate(childStatement));
}
@Override
public void finished() {
try {
SEMAPHORE.acquire();
SEMAPHORE.release();
} catch (InterruptedException ignore) {
Thread.currentThread().interrupt();
}
}
});
}
private Description asDescription(Test test) {
if (test instanceof Describable) {
Describable facade = (Describable) test;
return facade.getDescription();
}
return Description.createTestDescription(getEffectiveClass(test), getName(test));
}
/* 109: */
/* 110: */ private static Description makeDescription(Test test) /* 111: */ {
/* 112: 96 */ if ((test instanceof TestCase))
/* 113: */ {
/* 114: 97 */ TestCase tc = (TestCase) test;
/* 115: 98 */ return Description.createTestDescription(tc.getClass(), tc.getName());
/* 116: */ }
/* 117: 99 */ if ((test instanceof TestSuite))
/* 118: */ {
/* 119:100 */ TestSuite ts = (TestSuite) test;
/* 120:101 */ String name = ts.getName() == null ? createSuiteDescription(ts) : ts.getName();
/* 121:102 */ Description description =
Description.createSuiteDescription(name, new Annotation[0]);
/* 122:103 */ int n = ts.testCount();
/* 123:104 */ for (int i = 0; i < n; i++)
/* 124: */ {
/* 125:105 */ Description made = makeDescription(ts.testAt(i));
/* 126:106 */ description.addChild(made);
/* 127: */ }
/* 128:108 */ return description;
/* 129: */ }
/* 130:109 */ if ((test instanceof Describable))
/* 131: */ {
/* 132:110 */ Describable adapter = (Describable) test;
/* 133:111 */ return adapter.getDescription();
/* 134: */ }
/* 135:112 */ if ((test instanceof TestDecorator))
/* 136: */ {
/* 137:113 */ TestDecorator decorator = (TestDecorator) test;
/* 138:114 */ return makeDescription(decorator.getTest());
/* 139: */ }
/* 140:117 */ return Description.createSuiteDescription(test.getClass());
/* 141: */ }
public PropertyTestRunner(Class<?> clas) {
this.clas = clas;
this.allTests =
Check.properties(clas)
.map(p -> P.p(p._1(), p._3(), Description.createTestDescription(clas, p._2())));
this.filteredTests = allTests;
}
private static Description makeDescription(Test test) {
if (test instanceof TestCase) {
TestCase tc = (TestCase) test;
return Description.createTestDescription(tc.getClass(), tc.getName(), getAnnotations(tc));
} else if (test instanceof TestSuite) {
TestSuite ts = (TestSuite) test;
String name = ts.getName() == null ? createSuiteDescription(ts) : ts.getName();
Description description = Description.createSuiteDescription(name);
int n = ts.testCount();
for (int i = 0; i < n; i++) {
Description made = makeDescription(ts.testAt(i));
description.addChild(made);
}
return description;
} else if (test instanceof Describable) {
Describable adapter = (Describable) test;
return adapter.getDescription();
} else if (test instanceof TestDecorator) {
TestDecorator decorator = (TestDecorator) test;
return makeDescription(decorator.getTest());
} else {
// This is the best we can do in this case
return Description.createSuiteDescription(test.getClass());
}
}
/* 53: */
/* 54: */ private Description asDescription(Test test) /* 55: */ {
/* 56: 45 */ if ((test instanceof Describable))
/* 57: */ {
/* 58: 46 */ Describable facade = (Describable) test;
/* 59: 47 */ return facade.getDescription();
/* 60: */ }
/* 61: 49 */ return Description.createTestDescription(
getEffectiveClass(test), getName(test));
/* 62: */ }
private void runScenario(RunNotifier notifier, Scenario scenario) {
Description childDescription =
Description.createTestDescription(getClass(), scenario.getName());
descr.addChild(childDescription);
EachTestNotifier eachNotifier = new EachTestNotifier(notifier, childDescription);
try {
eachNotifier.fireTestStarted();
// If a KieSession is not available, fail fast
if (ksessions == null || ksessions.values().isEmpty()) {
eachNotifier.addFailure(
new NullKieSessionException(
"Unable to get a Session to run tests. Check the project for build errors."));
} else {
KieSession ksession = getKSession(scenario.getKSessions());
if (ksession == null) {
String ksessionName = getKSessionName(scenario.getKSessions());
if (ksessionName == null) {
eachNotifier.addFailure(
new NullPointerException(
"Test scenario runner could not find the default knowledge session."));
} else {
eachNotifier.addFailure(
new NullPointerException(
"Test scenario runner could not find a stateful knowledge session with the name \'"
+ ksessionName
+ "\'."));
}
} else {
final ScenarioRunner runner = new ScenarioRunner(ksession, maxRuleFirings);
runner.run(scenario);
if (!scenario.wasSuccessful()) {
StringBuilder builder = new StringBuilder();
for (String message : scenario.getFailureMessages()) {
builder.append(message).append("\n");
}
eachNotifier.addFailedAssumption(new AssumptionViolatedException(builder.toString()));
}
// FLUSSSSSH!
for (FactHandle factHandle : ksession.getFactHandles()) {
ksession.delete(factHandle);
}
}
}
} catch (Throwable t) {
eachNotifier.addFailure(t);
} finally {
// has to always be called as per junit docs
eachNotifier.fireTestFinished();
}
}
@Override
public Statement apply(Statement base, FrameworkMethod method, Object fixtureTarget) {
final Repeat actual = method.getAnnotation(Repeat.class);
if (actual == null) {
return base;
}
Class<?> fixtureType = fixtureTarget.getClass();
Description description =
Description.createTestDescription(fixtureType, method.getName(), method.getAnnotations());
return statement = onRepeat(actual, notifier, base, description);
}
@Override
public void run(final RunNotifier notifier) {
if (System.getProperty(IGNORE_SYS_PROP) != null) {
notifier.fireTestIgnored(
Description.createTestDescription(
getTestClass().getJavaClass(),
"System property to ignore integration tests is set."));
} else {
super.run(notifier);
}
}
/** {@inheritDoc} */
@Override
public void filter(final Filter filter) throws NoTestsRemainException {
computeTestMethods();
for (final ListIterator<FrameworkMethod> iter = testMethods_.listIterator(); iter.hasNext(); ) {
final FrameworkMethod method = iter.next();
// compute 2 descriptions to verify if it is the intended test:
// - one "normal", this is what Eclipse's filter awaits when typing Ctrl+X T
// when cursor is located on a test method
// - one with browser nickname, this is what is needed when re-running a test from
// the JUnit view
// as the list of methods is cached, this is what will be returned when computeTestMethods()
// is called
final Description description =
Description.createTestDescription(getTestClass().getJavaClass(), method.getName());
final Description description2 =
Description.createTestDescription(getTestClass().getJavaClass(), testName(method));
if (!filter.shouldRun(description) && !filter.shouldRun(description2)) {
iter.remove();
}
}
}
protected TestCase(
Class<?> testClass,
String baseName,
String sourceName,
Path path,
String testInput,
String expectedOutput) {
this.name = Description.createTestDescription(testClass, baseName);
this.sourceName = sourceName;
this.path = path;
this.testInput = testInput;
this.expectedOutput = expectedOutput;
}
Description describeMethod() {
Object[] params = paramsFromAnnotation();
Description parametrised = Description.createSuiteDescription(method.name());
for (int i = 0; i < params.length; i++) {
/*
Object paramSet = params[i];
parametrised.addChild(Description.createTestDescription(method.frameworkMethod.getMethod().getDeclaringClass(),
Utils.stringify(paramSet, i) + " (" + method.name() + ")", method.frameworkMethod.getAnnotations()));
*/
parametrised.addChild(
Description.createTestDescription(
method.frameworkMethod.getMethod().getDeclaringClass(),
method.name() + " [" + i + "]",
method.frameworkMethod.getAnnotations()));
}
return parametrised;
}
// Mostly taken from Junit4Provider.java
public RunResult invokeJunit4(Class<?> clazz, String requestedTestMethod)
throws TestSetFailedException {
final ReporterFactory reporterFactory = providerParameters.getReporterFactory();
RunListener reporter = reporterFactory.createReporter();
ConsoleOutputCapture.startCapture((ConsoleOutputReceiver) reporter);
JUnit4RunListener jUnit4TestSetReporter = new JUnit4RunListener(reporter);
Result result = new Result();
RunNotifier listeners = getRunNotifier(jUnit4TestSetReporter, result, customRunListeners);
listeners.fireTestRunStarted(Description.createTestDescription(clazz, requestedTestMethod));
final ReportEntry report =
new SimpleReportEntry(
getClass().getName() + "." + requestedTestMethod,
clazz.getName() + "." + requestedTestMethod);
reporter.testSetStarting(report);
try {
for (final Method method : clazz.getMethods()) {
if (method.getParameterTypes().length == 0
&& requestedTestMethod.equals(method.getName())) {
Request.method(clazz, method.getName()).getRunner().run(listeners);
}
}
} catch (Throwable e) {
reporter.testError(
SimpleReportEntry.withException(
report.getSourceName(),
report.getName(),
new PojoStackTraceWriter(report.getSourceName(), report.getName(), e)));
} finally {
reporter.testSetCompleted(report);
}
listeners.fireTestRunFinished(result);
JUnit4RunListener.rethrowAnyTestMechanismFailures(result);
closeRunNotifier(jUnit4TestSetReporter, customRunListeners);
return reporterFactory.close();
}
@Override
protected Description describeChild(Interaction interaction) {
return Description.createTestDescription(
pactToVerify.consumer().name(), interaction.description());
}
@Override
public Description getDescription() {
return Description.createTestDescription(this.getClass(), ScriptUtils.getFullName(script));
}
protected Description methodDescription(JUnit4TestMethod method) {
return Description.createTestDescription(
getTestClass().getJavaClass(), testName(method), testAnnotations(method.getTestMethod()));
}
private void reportTestAsNotApplicableInCurrentTestRun(Method method) {
Class<?> testClass = method.getDeclaringClass();
Description testDescription = Description.createTestDescription(testClass, method.getName());
runNotifier.fireTestAssumptionFailed(new Failure(testDescription, NOT_APPLICABLE));
}
private Description describeCause(Throwable child) {
return Description.createTestDescription(
runner.getTestClass().getJavaClass(), "initializationError");
}
@Override
protected Description describeChild(String child) {
return Description.createTestDescription(suiteClass, child);
}
/** @see org.junit.runners.ParentRunner#describeChild(java.lang.Object) */
@Override
protected Description describeChild(TestInfo child) {
return Description.createTestDescription(getTestClass().getJavaClass(), child.name);
}
@Override
protected Description describeChild(ProcessorTestCase child) {
return Description.createTestDescription(
getTestClass().getJavaClass(), child.processor.name().toLowerCase());
}
private Description descriptionFor(WikiTestPage test) {
return Description.createTestDescription(mainClass, test.getFullPath());
}