/**
* @param frameworkMethod
* @param notifier
*/
@Override
protected void runChild(FrameworkMethod frameworkMethod, RunNotifier notifier) {
try {
beforeRunChild();
try {
// This will execute the createTest method below, the activeContainer handling relies on
// this.
System.out.println(
"START running test "
+ frameworkMethod.getName()
+ " for thread "
+ Thread.currentThread().toString());
super.runChild(frameworkMethod, notifier);
System.out.println(
"END running test "
+ frameworkMethod.getName()
+ " for thread "
+ Thread.currentThread().toString());
} finally {
afterRunChild();
}
} catch (Throwable e) {
e.printStackTrace();
Description description = describeChild(frameworkMethod);
notifier.fireTestFailure(new Failure(description, e));
notifier.fireTestFinished(description);
}
}
private Result run(Runner runner) throws InitializationError {
RunNotifier notifier = new RunNotifier();
Result result = new Result();
notifier.addListener(result.createListener());
runner.run(notifier);
return result;
}
@Override
protected void runChild(Interaction interaction, RunNotifier notifier) {
final Description description = describeChild(interaction);
notifier.fireTestStarted(description);
if (interaction.providerState().isDefined()) {
final Optional<FrameworkMethod> initializationMethod =
findProvderStateInitializationMethod(interaction.providerState().get());
if (initializationMethod.isPresent()) {
try {
invokeMethod(initializationMethod.get());
testPact(interaction);
notifier.fireTestFinished(description);
return;
} catch (Exception ex) {
notifier.fireTestFailure(new Failure(description, ex));
return;
}
} else {
notifier.fireTestIgnored(description);
return;
}
}
notifier.fireTestIgnored(description);
}
@Override
protected void runChild(TestCase testCase, RunNotifier notifier) {
notifier.fireTestStarted(testCase.name);
ByteArrayOutputStream out = new ByteArrayOutputStream();
try {
PolyglotEngine vm =
PolyglotEngine.newBuilder()
.setIn(
new ByteArrayInputStream(repeat(testCase.testInput, repeats).getBytes("UTF-8")))
.setOut(out)
.build();
String script = readAllLines(testCase.path);
PrintWriter printer = new PrintWriter(out);
SLLanguage.run(vm, testCase.path, null, printer, repeats, builtins);
printer.flush();
String actualOutput = new String(out.toByteArray());
Assert.assertEquals(script, repeat(testCase.expectedOutput, repeats), actualOutput);
} catch (Throwable ex) {
notifier.fireTestFailure(
new Failure(
testCase.name, new IllegalStateException("Cannot run " + testCase.sourceName, ex)));
} finally {
notifier.fireTestFinished(testCase.name);
}
}
void runTestMethod(Statement methodInvoker, RunNotifier notifier) {
Description methodDescription = describeMethod();
Description methodWithParams = findChildForParams(methodInvoker, methodDescription);
notifier.fireTestStarted(methodWithParams);
runMethodInvoker(notifier, methodDescription, methodInvoker, methodWithParams);
notifier.fireTestFinished(methodWithParams);
}
private void closeRunNotifier(
org.junit.runner.notification.RunListener main,
List<org.junit.runner.notification.RunListener> others) {
RunNotifier fNotifier = new RunNotifier();
fNotifier.removeListener(main);
for (org.junit.runner.notification.RunListener listener : others) {
fNotifier.removeListener(listener);
}
}
protected void runFullSuite(final RunNotifier notifier) {
JUnitHelper helper = createJUnitHelper(notifier);
try {
helper.assertSuitePasses(suiteName, suiteFilter, excludeSuiteFilter);
} catch (AssertionFailedError e) {
notifier.fireTestFailure(new Failure(Description.createSuiteDescription(suiteClass), e));
} catch (Exception e) {
notifier.fireTestFailure(new Failure(Description.createSuiteDescription(suiteClass), e));
}
}
@Override
protected void startup(RemoteRunNotifier remote) throws Throwable {
try {
RunNotifier notifier = new RunNotifier();
notifier.addListener(new RemoteRunListener(remote));
new RemoteTestRunner(this, remote, Class.forName(className)).run(notifier);
} catch (Throwable failure) {
runner = failure;
throw failure;
}
}
@Override
protected void runChild(String test, RunNotifier notifier) {
JUnitHelper helper = createJUnitHelper(notifier);
try {
helper.assertTestPasses(test);
} catch (AssertionFailedError e) {
notifier.fireTestFailure(new Failure(Description.createSuiteDescription(suiteClass), e));
} catch (Exception e) {
notifier.fireTestFailure(new Failure(Description.createSuiteDescription(suiteClass), e));
}
}
@Override
public void run(RunNotifier notifier) {
RunListener failureSpy = new ScreenshotCaptureListener();
notifier.removeListener(failureSpy);
notifier.addListener(failureSpy);
try {
super.run(notifier);
} finally {
notifier.removeListener(failureSpy);
}
}
@Override
protected void runChild(FrameworkMethod method, RunNotifier notifier) {
Description description = describeChild(method);
if (method.getAnnotation(Ignore.class) != null) {
notifier.fireTestIgnored(description);
return;
}
String methodName = method.getName();
String allowedMethodName = methodNames.get(description);
if (methodName != null && !methodName.equals(allowedMethodName)) {
// notifier.fireTestIgnored(description);
return;
}
try {
notifier.fireTestStarted(description);
HttpURLConnection connection = getUrl(methodName, "POST");
handleError(connection);
String enc = connection.getContentEncoding();
if (enc == null) {
enc = "ISO-8859-1";
}
InputStream is = connection.getInputStream();
BufferedReader reader = new BufferedReader(new InputStreamReader(is, Charset.forName(enc)));
String line = null;
while ((line = reader.readLine()) != null) {
if (line.startsWith("E")) {
System.err.println(line.substring(1).trim());
} else if (line.startsWith("O")) {
System.out.println(line.substring(1).trim());
} else if (line.startsWith("RSUCCESS")) {
break;
} else if (line.startsWith("RERROR")) {
StringBuilder error = new StringBuilder(line.substring(6));
while ((line = reader.readLine()) != null) {
error.append(line).append("\n");
}
throw new AssertionFailedError(error.toString());
} else {
log.error("Protocol error in response: {}", line);
}
}
is.close();
connection.disconnect();
} catch (Throwable e) {
e.printStackTrace();
notifier.fireTestFailure(new Failure(description, e));
} finally {
notifier.fireTestFinished(description);
}
}
private RunNotifier getRunNotifier(
org.junit.runner.notification.RunListener main,
Result result,
List<org.junit.runner.notification.RunListener> others) {
RunNotifier fNotifier = new RunNotifier();
fNotifier.addListener(main);
fNotifier.addListener(result.createListener());
for (org.junit.runner.notification.RunListener listener : others) {
fNotifier.addListener(listener);
}
return fNotifier;
}
/** Do not use. Testing purposes only. */
public Result run(Runner runner) {
Result result = new Result();
RunListener listener = result.createListener();
fNotifier.addFirstListener(listener);
try {
fNotifier.fireTestRunStarted(runner.getDescription());
runner.run(fNotifier);
fNotifier.fireTestRunFinished(result);
} finally {
removeListener(listener);
}
return result;
}
protected void invokeTestMethod(JUnit4TestMethod method, RunNotifier notifier) {
Description description = methodDescription(method);
Object test;
try {
test = createTest();
} catch (InvocationTargetException e) {
notifier.testAborted(description, e.getCause());
return;
} catch (Exception e) {
notifier.testAborted(description, e);
return;
}
new JUnit4MethodRoadie(test, method, notifier, description).run();
}
@Override
public void testStarted(WikiTestPage test) {
firstFailure = null;
if (test.isTestPage()) {
notifier.fireTestStarted(descriptionFor(test));
}
}
/** {@inheritDoc} */
private void notifyTestFinished(final Description junitDescription) {
if (junitRunNotifier != null && junitDescription != null) {
log.debug(junitDescription.getDisplayName() + " notifyTestFinished");
junitRunNotifier.fireTestFinished(junitDescription);
}
}
@Override
public void fireTestRunFinished(Result result) {
super.fireTestRunFinished(
result); // To change body of overridden methods use File | Settings | File Templates.
retryAwareRunNotifier.fireTestRunFinished(result);
}
protected void notifyOfTestSystemException(String testSystemName, Throwable cause) {
if (cause != null) {
Exception e =
new Exception("Exception while executing tests using: " + testSystemName, cause);
notifier.fireTestFailure(new Failure(Description.createSuiteDescription(mainClass), e));
}
}
public void afterScenario() {
notifier.fireTestFinished(currentScenario);
if (scenarioDescriptions.hasNext()) {
currentScenario = scenarioDescriptions.next();
finishedDescriptions.clear();
}
}
@Override
protected void runChild(FrameworkMethod method, RunNotifier notifier) {
if (canPersist && executeDbTests) {
super.runChild(method, notifier);
} else {
notifier.fireTestIgnored(describeChild(method));
}
}
@Override
public void evaluate() throws Throwable {
Error error = error();
notifier.addListener(listener);
try {
log.debug(displayName(description) + " STARTED");
for (int retry = 1; retry <= retryCount(); retry++) {
gotFailure = false;
onEnter(retry);
try {
log.debug(displayName(description) + " retry " + retry);
base.evaluate();
} catch (AssumptionViolatedException cause) {
Throwable t = new Throwable("On retry " + retry).initCause(cause);
error.addSuppressed(t);
notifier.fireTestAssumptionFailed(new Failure(description, t));
} catch (Throwable cause) {
// Repeat annotation is on method (else the Throwable is not raised up to here)
Throwable t = new Throwable("On retry " + retry).initCause(cause);
error.addSuppressed(t);
if (returnOnFailure()) {
notifier.fireTestFailure(new Failure(description, t));
} else {
gotFailure = true;
log.debug(displayName(description) + " FAILURE SWALLOW");
log.trace(t, t);
}
} finally {
onLeave();
}
if (gotFailure && returnOnFailure()) {
log.debug(displayName(description) + " returnOnFailure");
return;
}
if (!gotFailure && returnOnSuccess()) {
log.debug(displayName(description) + " returnOnSuccess");
return;
}
}
} finally {
log.debug(displayName(description) + " FINISHED");
notifier.removeListener(listener);
}
log.trace("throw " + error);
throw error;
}
/** {@inheritDoc} */
private void notifyTestFailed(final Description junitDescription, final Throwable cause) {
if (junitRunNotifier != null && junitDescription != null) {
log.debug(junitDescription.getDisplayName() + " notify running TestFailed");
log.debug(junitDescription.getDisplayName() + " notify TestFailed");
junitRunNotifier.fireTestFailure(new Failure(junitDescription, cause));
}
}
@Override
public void fireTestAssumptionFailed(Failure failure) {
log.debug("Test assumption failed: " + failure);
lastAssumptionFailure = failure;
testAssumptionFailed = true;
retryAwareRunNotifier.fireTestAssumptionFailed(failure);
}
@Override
public void fireTestFinished(Description description) {
testStartAlreadyFired = false;
log.debug("Test finished: " + description);
lastDescription = description;
retryAwareRunNotifier.fireTestFinished(description);
}
@Override
public void run(RunNotifier notifier) {
Result result = new Result();
notifier.addFirstListener(result.createListener());
JUnit5RunnerListener listener = new JUnit5RunnerListener(this.testTree, notifier, result);
this.launcher.registerTestExecutionListeners(listener);
this.launcher.execute(this.specification);
}
@Override
public void run(RunNotifier notifier) {
filteredTests.foreachDoEffect(
p -> {
Description desc = p._3();
notifier.fireTestStarted(desc);
CheckResult result = checkProperty(p._1(), p._2());
try {
CheckResult.summaryEx.showS(result);
} catch (Throwable t) {
notifier.fireTestFailure(new Failure(desc, t));
}
notifier.fireTestFinished(desc);
});
}
@Override
public void run(RunNotifier notifier) {
if (shouldInitMocks) {
// Allow Mockito to do its verification
notifier.addListener(new FrameworkUsageValidator(notifier));
}
super.run(notifier);
}
@Override
public void fireTestFailure(Failure failure) {
log.debug("Test failed: " + failure);
testStartAlreadyFired = false;
testFailed = true;
lastFailure = failure;
retryAwareRunNotifier.fireTestFailure(failure);
}
@Override
public void fireTestStarted(Description description) throws StoppedByUserException {
int progress = ++this.progress;
if (progress > total) {
total = progress;
}
console.indicateProgress(progress, total);
super.fireTestStarted(description);
}
// 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();
}