下面列出了怎么用org.junit.runner.notification.StoppedByUserException的API类实例代码及写法,或者点击链接到github查看源代码。
@Override
public void run(RunNotifier notifier) {
currentNotifier = new ThreadSafeRunNotifier(notifier);
if (cancellationRequest.get() != NOT_REQUESTED) {
currentNotifier.pleaseStop();
}
if (cancellationRequest.get() == ORDERLY_STOP) {
return;
}
try {
delegate.run(currentNotifier);
} catch (StoppedByUserException e) {
if (cancellationRequest.get() == HARD_STOP) {
throw new RuntimeException("Test run interrupted", e);
} else if (cancellationRequest.get() == ORDERLY_STOP) {
e.printStackTrace();
return;
}
throw e;
}
}
@Test
public void testInterruptedTest() throws Exception {
config = createConfig();
mockRunListener = mock(RunListener.class);
JUnit4BazelMock component = createComponent(SampleSuite.class);
JUnit4Runner runner = component.runner();
final CancellableRequestFactory requestFactory = component.cancellableRequestFactory();
Description testDescription = Description.createTestDescription(SamplePassingTest.class,
"testThatAlwaysPasses");
doAnswer(cancelTestRun(requestFactory))
.when(mockRunListener).testStarted(testDescription);
RuntimeException e = assertThrows(RuntimeException.class, () -> runner.run());
assertThat(e).hasMessageThat().isEqualTo("Test run interrupted");
assertWithMessage("Expected cause to be a StoppedByUserException")
.that(e.getCause() instanceof StoppedByUserException)
.isTrue();
InOrder inOrder = inOrder(mockRunListener);
inOrder.verify(mockRunListener).testRunStarted(any(Description.class));
inOrder.verify(mockRunListener).testStarted(testDescription);
inOrder.verify(mockRunListener).testFinished(testDescription);
}
@Test
public void testCancelRunBeforeStarting() throws Exception {
final AtomicBoolean testRan = new AtomicBoolean(false);
// A runner that should never run its test
FakeRunner runner = new FakeRunner("shouldNotRun", new Runnable() {
@Override
public void run() {
testRan.set(true);
}
});
Request request = cancellableRequestFactory.createRequest(Request.runner(runner));
cancellableRequestFactory.cancelRun();
JUnitCore core = new JUnitCore();
RuntimeException e = assertThrows(RuntimeException.class, () -> core.run(request));
assertThat(e).hasMessageThat().isEqualTo("Test run interrupted");
assertThat(e).hasCauseThat().isInstanceOf(StoppedByUserException.class);
assertThat(testRan.get()).isFalse();
}
@Override
public void run(RunNotifier notifier) {
try {
if (launchMode == LaunchMode.PER_TEST_CLASS) {
doStart();
}
super.run(notifier);
if (launchMode == LaunchMode.PER_TEST_CLASS) {
doStop();
}
} catch (StoppedByUserException e) {
throw e;
} catch (Throwable t) {
notifyFailure(t, notifier);
}
}
private void doRunTest(Test testSuite) {
mode = Mode.RUNNING;
resetToolBar();
startTime = System.currentTimeMillis();
runnerThread = new Thread("TestRunner-Thread") {
@Override
public void run() {
try {
runner = new MarathonTestRunner();
runner.addListener(runListener);
runner.addListener(new AllureMarathonRunListener());
@SuppressWarnings("unused")
Result result = runner.run(testSuite);
runFinished(testSuite);
} catch (StoppedByUserException e) {
abort();
} finally {
// always return control to UI
if (interrupted()) {
abort();
}
MarathonTestCase.reset();
runnerThread = null;
System.gc();
}
}
private void abort() {
endTime = System.currentTimeMillis();
Platform.runLater(() -> status.setText("Aborted after " + (endTime - startTime) / 1000 + " seconds"));
mode = Mode.RESULTS;
resetToolBar();
}
};
createTestReportDir();
runnerThread.start();
}
@Override
public void run(final RunNotifier notifier) {
EachTestNotifier testNotifier = new EachTestNotifier(notifier, getDescription());
Statement statement = classBlock(notifier);
try {
statement.evaluate();
} catch (AssumptionViolatedException ave) {
testNotifier.fireTestIgnored();
} catch (StoppedByUserException sbue) {
throw sbue;
} catch (Throwable t) {
LOG.warning("Retry class: " + getDescription().getDisplayName());
retry(testNotifier, statement, t, getDescription());
}
}
@Override
public void fireTestStarted(final Description description) throws StoppedByUserException {
if (pleaseStop) {
throw new StoppedByUserException();
}
new SafeNotifier() {
@Override
protected void notifyListener(RunListener each) throws Exception {
each.testStarted(description);
}
}.run();
}
@Override
public void testStarted(final Description description) throws Exception {
if (this.failed) {
// If the JUnit test has been annotated with @BeforeClass or @AfterClass
// need to force the exit after the first failure as tests will be run as
// a block
// rather than individually.
// This is apparently the junit way.
throw new StoppedByUserException();
}
this.rc.notifyStart(this.description);
}
/**
* {@inheritDoc}<p>
*
* The implementation is almost an exact copy of the version in
* {@code RunNotifier} but is thread-safe.
*/
@Override
public void fireTestStarted(Description description) throws StoppedByUserException {
if (stopRequested) {
throw new StoppedByUserException();
}
getDelegate().fireTestStarted(description);
}
@Test(expected = StoppedByUserException.class)
public void shouldRunStoppedByUserExceptionIfMoreTestsRunAfterAFailure()
throws Exception {
this.testee.testFailure(new Failure(this.junitDesc, this.throwable));
this.testee.testStarted(this.junitDesc);
}
@Override
public void fireTestStarted(Description description) throws StoppedByUserException {
delegate.fireTestStarted(description);
}
@Override
public void fireTestStarted(Description description) throws StoppedByUserException {
delegate.fireTestStarted(description);
// Do not do apply the default timeout if the test has its own @Test(timeout).
if (hasJunitTimeout(description)) {
return;
}
// Schedule a timer that verifies that the test completed within the specified timeout.
TimerTask task =
new TimerTask() {
@Override
public void run() {
synchronized (finishedTests) {
// If the test already finished, then do nothing.
if (finishedTests.contains(description)) {
return;
}
hasTestThatExceededTimeout.set(true);
// Should report the failure. The Exception is modeled after the one created by
// org.junit.internal.runners.statements.FailOnTimeout#createTimeoutException(Thread).
Exception exception =
new Exception(
String.format(
"test timed out after %d milliseconds", defaultTestTimeoutMillis));
Failure failure = new Failure(description, exception);
fireTestFailure(failure);
fireTestFinished(description);
if (!finishedTests.contains(description)) {
throw new IllegalStateException("fireTestFinished() should update finishedTests.");
}
onTestRunFinished();
}
}
};
timer.schedule(task, defaultTestTimeoutMillis);
}