@Override public void testFailure(Failure failure) throws Exception { TestDescriptorInternal testInternal; synchronized (lock) { testInternal = executing.get(failure.getDescription()); } boolean needEndEvent = false; if (testInternal == null) { // This can happen when, for example, a @BeforeClass or @AfterClass method fails needEndEvent = true; testInternal = nullSafeDescriptor(idGenerator.generateId(), failure.getDescription()); resultProcessor.started(testInternal, startEvent()); } resultProcessor.failure(testInternal.getId(), failure.getException()); if (needEndEvent) { resultProcessor.completed(testInternal.getId(), new TestCompleteEvent(timeProvider.getCurrentTime())); } }
/** * Called when an atomic test fails. * * @param failure * describes the test that failed and the exception that was thrown */ @Override public void testFailure(Failure failure) throws Exception { Display.getDefault().syncExec(new Runnable() { @Override public void run() { IWorkbenchWindow[] windows = N4IDEXpectUIPlugin.getDefault().getWorkbench().getWorkbenchWindows(); try { N4IDEXpectView view = (N4IDEXpectView) windows[0].getActivePage().showView( N4IDEXpectView.ID); view.notifyFailedExecutionOf(failure); } catch (PartInitException e) { N4IDEXpectUIPlugin.logError("cannot refresh test view window", e); } } }); }
/** * Called when an atomic test flags that it assumes a condition that is false * * describes the test that failed and the {@link AssumptionViolatedException} that was thrown */ @Override public void testAssumptionFailure(Failure failure) { Display.getDefault().syncExec(new Runnable() { @Override public void run() { IWorkbenchWindow[] windows = N4IDEXpectUIPlugin.getDefault().getWorkbench().getWorkbenchWindows(); try { N4IDEXpectView view = (N4IDEXpectView) windows[0].getActivePage().showView( N4IDEXpectView.ID); view.notifyFailedExecutionOf(failure); } catch (PartInitException e) { N4IDEXpectUIPlugin.logError("cannot refresh test view window", e); } } }); }
@Override public void endTest(final PlaybackResult result) { if (!exploratoryTest) { Platform.runLater(new Runnable() { @Override public void run() { resultPane.addResult(result); } }); } if (!needReports()) { return; } if (!exploratoryTest && result.hasFailure()) { MarathonAssertion assertion = new MarathonAssertion(result.failures(), getFilePath()); runListener.testAssumptionFailure( new Failure(Description.createTestDescription(MarathonTestCase.class, getFilePath()), assertion)); } TestAttributes.put("test_object", testCase); runListener.testFinished(Description.createTestDescription(MarathonTestCase.class, getFilePath())); addScreenCaptures(); }
@Test(timeout=30000) public void testThreadDumpAndDeadlocks() throws Exception { new Deadlock(); String s = null; while (true) { s = TimedOutTestsListener.buildDeadlockInfo(); if (s != null) break; Thread.sleep(100); } Assert.assertEquals(3, countStringOccurrences(s, "BLOCKED")); Failure failure = new Failure( null, new Exception(TimedOutTestsListener.TEST_TIMED_OUT_PREFIX)); StringWriter writer = new StringWriter(); new TimedOutTestsListener(new PrintWriter(writer)).testFailure(failure); String out = writer.toString(); Assert.assertTrue(out.contains("THREAD DUMP")); Assert.assertTrue(out.contains("DEADLOCKS DETECTED")); System.out.println(out); }
@Override public void testFailure(Failure failure) throws Exception { // Ignore assumptions. if (failure.getException() instanceof AssumptionViolatedException) { return; } final StringBuilder b = new StringBuilder("REPRODUCE WITH: gradle "); String task = System.getProperty("tests.task"); // TODO: enforce (intellij still runs the runner?) or use default "test" but that won't work for integ b.append(task); GradleMessageBuilder gradleMessageBuilder = new GradleMessageBuilder(b); gradleMessageBuilder.appendAllOpts(failure.getDescription()); // Client yaml suite tests are a special case as they allow for additional parameters if (ESClientYamlSuiteTestCase.class.isAssignableFrom(failure.getDescription().getTestClass())) { gradleMessageBuilder.appendClientYamlSuiteProperties(); } System.err.println(b.toString()); }
/** * (non-Javadoc) * @see org.junit.runner.notification.RunListener#testAssumptionFailure(org.junit.runner.notification.Failure) */ @Override public void testAssumptionFailure( Failure failure ) { if (log.isDebugEnabled()) { log.debug("testAssumptionFailure(): Test failed: " + failure.toString() + "| Description: " + failure.getDescription()); } log.info("Test assumption failure received. It will be stored in DB as test failed event."); try { testFailure(failure); } catch (Exception e) { log.error("Error while processing testFailure event", e); } super.testAssumptionFailure(failure); }
public static void main(String[] args) { final Result result = JUnitCore.runClasses( codeu.chat.common.SecretTest.class, codeu.chat.relay.ServerTest.class, codeu.chat.server.BasicControllerTest.class, codeu.chat.server.RawControllerTest.class, codeu.chat.util.TimeTest.class, codeu.chat.util.TokenizerTest.class, codeu.chat.util.UuidTest.class, codeu.chat.util.store.StoreTest.class ); for (final Failure failure : result.getFailures()) { System.out.println(failure.toString()); } System.out.println(result.wasSuccessful()); }
private boolean isKnownIssue(Failure failure) { if (failure == null) { return false; } if (failure.getDescription() == null) { return false; } final KnownIssue knownIssue = failure.getDescription().getAnnotation(KnownIssue.class); final String message = failure.getMessage(); if (knownIssue == null || message == null || knownIssue.value() == null) { return false; } if (message.contains(knownIssue.value())) { return true; } return false; }
@Override protected void runChild(final ArchTestExecution child, final RunNotifier notifier) { ExpectedViolation expectedViolation = ExpectedViolation.none(); HandlingAssertion handlingAssertion = HandlingAssertion.none(); Description description = describeChild(child); notifier.fireTestStarted(description); try { ExpectedViolationDefinition violationDefinition = extractExpectedConfiguration(child); violationDefinition.configure(expectedViolation); violationDefinition.configure(handlingAssertion); expectedViolation.apply(new IntegrationTestStatement(child, handlingAssertion), description).evaluate(); } catch (Throwable throwable) { notifier.fireTestFailure(new Failure(description, throwable)); } finally { notifier.fireTestFinished(description); } }
/** * Creates and runs a JUnit test runner for testSuite. * * @param testSuite the class defining test cases to run * @param view a UI component to report test failures to * @return the counts of failures and total test cases. */ static RunResult runTestSuiteAgainst(Class testSuite, View view) { if(testSuite == null) throw new NullPointerException("testSuite"); if(view == null) throw new NullPointerException("view"); Result result = new JUnitCore().run(testSuite); if (result.getFailureCount() > 0) { for (Failure f : result.getFailures()) view.declarePassProgramTestFailure(f.getTrace()); } return new RunResult(result.getFailureCount(), result.getRunCount()); }
@Test public void failsWithExpectedTimeoutButWrongError() { Result result = TestRunner.runTest(FailsWithExpectedTimeoutButWrongError.class); assertThat(result.wasSuccessful()).isFalse(); List<Failure> failures = result.getFailures(); assertThat(failures.size()).as("Failures: " + failures).isEqualTo(1); Failure failure = failures.get(0); String expectedMessage = "\n" + "Expected: (an instance of java.util.concurrent.TimeoutException and exception with message a string containing \"this is a message for FailsWithExpectedTimeoutButWrongError\")" + "\n" + " " + "but: an instance of java.util.concurrent.TimeoutException <java.lang.NullPointerException> is a java.lang.NullPointerException"; assertThat(failure.getException()).isExactlyInstanceOf(AssertionError.class) .hasMessageContaining(expectedMessage); }
@Test(timeout=500) public void testThreadDumpAndDeadlocks() throws Exception { new Deadlock(); String s = null; while (true) { s = TimedOutTestsListener.buildDeadlockInfo(); if (s != null) break; Thread.sleep(100); } Assert.assertEquals(3, countStringOccurrences(s, "BLOCKED")); Failure failure = new Failure( null, new Exception(TimedOutTestsListener.TEST_TIMED_OUT_PREFIX)); StringWriter writer = new StringWriter(); new TimedOutTestsListener(new PrintWriter(writer)).testFailure(failure); String out = writer.toString(); Assert.assertTrue(out.contains("THREAD DUMP")); Assert.assertTrue(out.contains("DEADLOCKS DETECTED")); System.out.println(out); }
public static void main(String[] args) { final Result result = JUnitCore.runClasses( codeu.chat.common.SecretTest.class, codeu.chat.relay.ServerTest.class, codeu.chat.server.BasicControllerTest.class, codeu.chat.server.RawControllerTest.class, codeu.chat.util.TimeTest.class, codeu.chat.util.UuidTest.class, codeu.chat.util.store.StoreTest.class ); for (final Failure failure : result.getFailures()) { System.out.println(failure.toString()); } System.out.println(result.wasSuccessful()); }
private static JUnit4TestListener createListener(final StringBuffer buf) { return new JUnit4TestListener(new PrintStream(new OutputStream() { @Override public void write(int b) throws IOException { buf.append(new String(new byte[]{(byte)b})); } })) { @Override protected long currentTime() { return 0; } @Override protected String getTrace(Failure failure) { return StringUtil.convertLineSeparators(super.getTrace(failure)); } }; }
/** * Chama o motor de testes JUnit. */ private static void executarTodosOs50Testes() { final Result result = JUnitCore.runClasses( GrafoTest.class ); final StringBuilder mensagem = new StringBuilder(); if( result.getFailureCount() > 0 ) { mensagem.append( "############## OS SEGUINTES TESTES FALHARAM!! " + "#####################################\n" ); } else { mensagem.append( "############## TODOS OS TESTES FORAM EXECUTADOS " + "COM SUCESSO!! #######################\n" ); } for( final Failure failure: result.getFailures() ) { mensagem.append( failure.getDescription() ).append( '\n' ); mensagem.append( failure.getMessage() ).append( '\n' ); } System.out.println( mensagem ); }
@Test public void shouldValidateUnsuccessfullyForInjectMocksPresence() throws Exception { // given RunNotifier notifier = mock(RunNotifier.class); TestClass testClass = new TestClass(getClass()); DelayedInjectionRunnerValidator validator = new DelayedInjectionRunnerValidator(notifier, testClass); Description description = mock(Description.class); // when validator.testFinished(description); // then ArgumentCaptor<Failure> captor = ArgumentCaptor.forClass(Failure.class); verify(notifier).fireTestFailure(captor.capture()); Failure failure = captor.getValue(); assertThat(failure.getMessage(), containsString("Do not use @InjectMocks")); }
public static void main(String[] args) { System.out.println("Trying to run tests"); org.junit.runner.JUnitCore jc = new org.junit.runner.JUnitCore(); Result run = jc.run(GlacierCheckerTests.class); if (run.wasSuccessful()) { System.out.println("Run was successful with " + run.getRunCount() + " test(s)!"); } else { System.out.println("Run had " + run.getFailureCount() + " failure(s) out of " + run.getRunCount() + " run(s)!"); for (Failure f : run.getFailures()) { System.out.println(f.toString()); } } }
@Override public void run(final RunNotifier notifier) { ClassRoadie classRoadie = new ClassRoadie(notifier, getTestClass(), getDescription(), new Runnable() { public void run() { runMethods(notifier); } }); Unitils.getInstance().getTestContext().setRunner(this); try { getTestListener().beforeTestClass(getTestClass().getJavaClass()); classRoadie.runProtected(); } catch (Throwable t) { notifier.fireTestFailure(new Failure(getDescription(), t)); } }
@Test public void run() { JUnitCore junitCore = new JUnitCore(); Result result = junitCore.run(TestDummy.class); List<Failure>failures = result.getFailures(); if(!(failures == null || failures.isEmpty())) { for(Failure f : failures) { System.out.println(f.getMessage()); } } Assert.assertEquals(2, result.getRunCount()); Assert.assertEquals(0, result.getIgnoreCount()); Assert.assertEquals(0, result.getFailureCount()); Assert.assertEquals("After was not executed", "true", System.getProperty("JUnit_After")); Assert.assertEquals("AfterClass was not executed", "true", System.getProperty("JUnit_AfterClass")); }
public void testRunFinished(Result result) { logger.info("Time: " + elapsedTimeAsString(result.getRunTime())); if (result.wasSuccessful()) { logger.info("OK (" + result.getRunCount() + " test" + (result.getRunCount() == 1 ? "" : "s") + ")"); } else { final List<Failure> failures = result.getFailures(); if (failures.size() == 1) { logger.error("There was " + failures.size() + " failure:"); } else { logger.error("There were " + failures.size() + " failures:"); } for (Failure failure : failures) { logger.error(failure.getTestHeader()); logger.error(failure.getTrace()); } logger.info("FAILURE Tests run: " + result.getRunCount() + ", Failures: " + result.getFailureCount()); } }
private static void runTests(){ JUnitCore junit = new JUnitCore(); Result result = junit.run(Tests.class); System.err.println("Ran " + result.getRunCount() + " tests in "+ result.getRunTime() +"ms."); if (result.wasSuccessful()) System.out.println("All tests were successfull!"); else { System.err.println(result.getFailureCount() + "Failures:"); for (Failure fail: result.getFailures()){ System.err.println("Failure in: "+ fail.getTestHeader()); System.err.println(fail.getMessage()); System.err.println(fail.getTrace()); System.err.println(); } } }
private void testFailure(Failure failure, String messageName, String methodName) { final Map attrs = new HashMap(); attrs.put("name", methodName); final long duration = currentTime() - myCurrentTestStart; if (duration > 0) { attrs.put("duration", Long.toString(duration)); } try { final String trace = getTrace(failure); final Throwable ex = failure.getException(); final ComparisonFailureData notification = createExceptionNotification(ex); ComparisonFailureData.registerSMAttributes(notification, trace, failure.getMessage(), attrs, ex); } catch (Throwable e) { final StringWriter stringWriter = new StringWriter(); final PrintWriter writer = new PrintWriter(stringWriter); e.printStackTrace(writer); ComparisonFailureData.registerSMAttributes(null, stringWriter.toString(), e.getMessage(), attrs, e); } finally { myPrintStream.println("\n" + MapSerializerUtil.asString(messageName, attrs)); } }
public static void printSummary(Result result) { if (!result.wasSuccessful()) System.out.println("\n\nErrors:"); for (Failure failure : result.getFailures()) { // System.out.println(failure.getMessage()); // System.out.println(failure.getTestHeader()); // System.out.println(failure.getDescription()); // System.out.println(failure.getException()); System.out.println(failure.getTestHeader()); System.out.println(failure.getTrace()); // System.out.println(failure.toString()); } int run = result.getRunCount(); int failed = result.getFailureCount(); int ignored = result.getIgnoreCount(); int passed = run - failed; System.out.println("PASSED: " + passed); System.out.println("FAILED: " + failed); System.out.println("IGNORED: " + ignored); System.out.println("All passed?: " + String.valueOf( result.wasSuccessful() ).toUpperCase()); }
private static void printSummary(Result result) { if (!result.wasSuccessful()) println("\n\nERRORS:"); for (Failure failure : result.getFailures()) { // System.out.println(failure.getMessage()); // System.out.println(failure.getTestHeader()); // System.out.println(failure.getDescription()); // System.out.println(failure.getException()); System.out.println(failure.getTestHeader()); System.out.println(failure.getTrace()); // System.out.println(failure.toString()); } int run = result.getRunCount(); int failed = result.getFailureCount(); int ignored = result.getIgnoreCount(); int passed = run - failed; println("PASSED: " + passed); println("FAILED: " + failed); println("IGNORED: " + ignored); println("All passed?: " + String.valueOf( result.wasSuccessful() ).toUpperCase()); }
Boolean handleAssertionFailed(RunNotifier notifier, Description description, String scenarioName, String stepName, List<AssertionReport> failureReportList) { /** * Generate error report and display clearly which expectation(s) did not match */ logger.info(String.format("Failed assertion during Scenario:%s, --> Step:%s, Details: %s\n", scenarioName, stepName, StringUtils.join(failureReportList, "\n"))); notifier.fireTestFailure(new Failure(description, new RuntimeException( String.format("Assertion failed for :- \n\n[%s] \n\t|\n\t|\n\t+---Step --> [%s] \n\nFailures:\n--------- %n%s%n", scenarioName, stepName, StringUtils.join(failureReportList, "\n" + deckedUpLine(maxEntryLengthOf(failureReportList)) + "\n")) ))); return false; }
protected Statement prepareMethodBlock(final FrameworkMethod method, final RunNotifier notifier) { final Statement methodBlock = superMethodBlock(method); return new Statement() { @Override public void evaluate() throws Throwable { try { methodBlock.evaluate(); Description description = describeChild(method); try { notifier.fireTestStarted(description); notifier.fireTestAssumptionFailed(new Failure(description, new AssumptionViolatedException("Method " + method.getName() + " did parse any input"))); } finally { notifier.fireTestFinished(description); } } catch(TestDataCarrier testData) { AbstractParallelScenarioRunner.this.testData.put(method, testData.getData()); } } }; }
/** * Checks that result has no failures. * Print all the failures in error message if there are any. */ public static void assertResultHasNoFailures(Result result) { List<Failure> failures = result.getFailures(); assertThat(failures) .as("No failures expected. Failures: %s", failures.stream() .map(ResultAssertions::formFailureDescription) .collect(Collectors.toList())) .isEmpty(); }
@Override public void run(RunNotifier notifier) { Description description = getDescription(); notifier.fireTestStarted(description); notifier.fireTestFailure(new Failure(description, failure)); notifier.fireTestFinished(description); }
@Override public void testStarted(Description description) { Description translated = translateDescription(description); notifier.fireTestStarted(translated); if (!started && !complete) { try { assertCanExecute(); started = true; before(); } catch (Throwable t) { notifier.fireTestFailure(new Failure(translated, t)); } } }
public static void main(String[] args) throws Exception { Result result = JUnitCore.runClasses(Bug_for_Next.class); for (Failure fail : result.getFailures()) { System.out.println(fail.toString()); } if (result.wasSuccessful()) { System.out.println("All tests finished successfully..."); } }
/** Mark execution of given {@link Description} as failed. Parent descriptions may be updated accordingly. */ public void executionFailed(Failure failure) { Description description = failure.getDescription(); allStatuses.put(description, ExecutionStatus.FAILED); allFailures.put(description, failure); updateParents(description, ExecutionStatus.FAILED); }
public static void main(String[] args) { final Result result = JUnitCore.runClasses( codeu.chat.common.SecretTest.class, codeu.chat.relay.ServerTest.class, codeu.chat.server.BasicControllerTest.class, codeu.chat.server.RawControllerTest.class, codeu.chat.util.TimeTest.class, codeu.chat.util.UuidTest.class, codeu.chat.util.store.StoreTest.class, codeu.chat.util.TokenizerTest.class, codeu.chat.server.ControllerTest.class ); System.out.println("\n===================== Test Status ===================="); System.out.println(String.format("%d tests run.", result.getRunCount())); if (result.wasSuccessful()) { System.out.println("All tests passed."); } else { System.out.println(String.format("%d tests failed.", result.getFailureCount())); System.out.println("\nFailures:"); for (final Failure failure : result.getFailures()) { System.out.println(failure.toString()); } } System.out.println("======================================================\n"); System.exit(result.wasSuccessful() ? 0 : -1); }
@Override public void testAssumptionFailure(Failure failure) { Test t = (Test) TestAttributes.get("test_object"); TestTreeItem testNode = findTestItem(t); testNode.setThrowable(new AssertionFailedError(failure.getMessage())); testNode.setState(State.FAILURE); testTree.refresh(); Platform.runLater(() -> { progressBar.setError(true); progressBar.incrementFailures(); }); }
@Override public void testFailure(Failure failure) throws Exception { Test t = (Test) TestAttributes.get("test_object"); TestTreeItem testNode = findTestItem(t); testNode.setThrowable(failure.getException()); testNode.setState(State.ERROR); testTree.refresh(); Platform.runLater(() -> { progressBar.setError(true); progressBar.incrementErrors(); }); }
@Override public void testFailure(Failure failure) { if (failure.getDescription().isTest()) { fireTestCaseFailure(failure.getException()); } else { startFakeTestCase(failure.getDescription()); fireTestCaseFailure(failure.getException()); finishFakeTestCase(); } }
@Override public void testFinished(Description description) { Test test = (Test) TestAttributes.get("test_object"); if (test != null && test instanceof MarathonTestCase) { StringBuilder failed = new StringBuilder(); List<CheckList> checklists = ((MarathonTestCase) test).getChecklists(); for (CheckList checkList : checklists) { String name = checkList.getName(); ByteArrayOutputStream out = new ByteArrayOutputStream(); checkList.saveHTML(out); getLifecycle().fire(new MakeAttachmentEvent(out.toByteArray(), name, "text/html")); if (checkList.getCaptureFile() != null) { File captureFile = new File(System.getProperty(Constants.PROP_IMAGE_CAPTURE_DIR), "ext-" + checkList.getCaptureFile()); try { getLifecycle().fire(new MakeAttachmentEvent(Files.readAllBytes(captureFile.toPath()), name + "(ScreenCapture)", "image/png")); } catch (IOException e) { e.printStackTrace(); } } if ("Fail".equals(checkList.getStatus())) { failed.append(checkList.getName()).append(", "); } } if (failed.length() > 0) { failed.setLength(failed.length() - 2); net.sourceforge.marathon.runtime.api.Failure[] failures = new net.sourceforge.marathon.runtime.api.Failure[] { null }; failures[0] = new net.sourceforge.marathon.runtime.api.Failure("Failed Checklists: " + failed.toString(), new SourceLine[0], null); MarathonAssertion assertion = new MarathonAssertion(failures, ((MarathonTestCase) test).getName()); testAssumptionFailure(new Failure(description, assertion)); } } getLifecycle().fire(new TestCaseFinishedEvent()); }