Refine search
private void testAborted(RunNotifier notifier, Description description, Throwable e) { notifier.fireTestStarted(description); notifier.fireTestFailure(new Failure(description, e)); notifier.fireTestFinished(description); }
public static Result runTestWithValidation(final Class<?> test) { JUnitCore junitCore = new JUnitCore(); Result result = junitCore.run(Request.aClass(test).getRunner()); List<Failure> failures = result.getFailures(); if (!failures.isEmpty()) { Failure firstFailure = failures.get(0); throw new AssertionError(firstFailure.getException()); } assertThat(result.wasSuccessful()).isTrue(); return result; }
@Override public void testAssumptionFailure(Failure failure) { events.add( "ignored: " + failure.getDescription().getMethodName() + ": " + failure.getMessage()); }
ErrorEvent(Failure failure, Status status) { super(settings.buildErrorName(failure.getDescription()), settings.buildErrorMessage(failure.getException()), status, elapsedTime(failure.getDescription()), failure.getException()); } }
protected void printFailure(Failure each, String prefix) { getWriter().println(prefix + ") " + each.getTestHeader()); getWriter().print(each.getTrimmedTrace()); }
protected void printFailure(Failure each, String prefix) { getWriter().println(prefix + ") " + each.getTestHeader()); getWriter().print(each.getTrace()); }
@Test public void shouldWorkWithTimeout() throws Exception { TestRunnerAdaptor adaptor = mock(TestRunnerAdaptor.class); executeAllLifeCycles(adaptor); Result result = run(adaptor, ClassWithArquillianRunnerWithTimeout.class); Assert.assertFalse(result.wasSuccessful()); Assert.assertTrue(result.getFailures().get(0).getMessage().contains("timed out")); assertCycle(1, Cycle.BEFORE_CLASS, Cycle.BEFORE, Cycle.AFTER, Cycle.AFTER_CLASS); verify(adaptor, times(1)).beforeSuite(); verify(adaptor, times(1)).afterSuite(); }
@Override public void run(RunNotifier notifier) { Class<?> testClass = getTestClass().getJavaClass(); try { manager.beforeClass(stagedReactor, testClass); super.run(notifier); } // CHECKSTYLE:SKIP : catch all wanted catch (Throwable e) { // rethrowing the exception does not help, we have to use the notifier here Description description = Description.createSuiteDescription(testClass); notifier.fireTestFailure(new Failure(description, e)); } finally { manager.afterClass(stagedReactor, testClass); } }
private void testJVMBackendFrameworkMethod(final FrameworkMethod aFrameworkMethod, final RunNotifier aRunNotifier) { final Description theDescription = Description.createTestDescription(testClass.getJavaClass(), aFrameworkMethod.getName() + " JVM Target"); aRunNotifier.fireTestStarted(theDescription); try { // Simply invoke using reflection final Object theInstance = testClass.getJavaClass().getDeclaredConstructor().newInstance(); final Method theMethod = aFrameworkMethod.getMethod(); theMethod.invoke(theInstance); aRunNotifier.fireTestFinished(theDescription); } catch (final Exception e) { aRunNotifier.fireTestFailure(new Failure(theDescription, e)); } }
@Override public void fireTestFailure(Failure failure) { Description description = failure.getDescription(); String methodName = description.getMethodName(); Throwable throwable = failure.getException(); if (methodName == null) { LoggingUtil.INSTANCE.error("Test method '{}' failed", methodName, throwable); } else { LoggingUtil.INSTANCE.error("Test method failed", throwable); } runNotifier.fireTestFailure(failure); }
@org.junit.Test public void testSuiteFail() { Result result = run(TestSuiteFail.class); assertEquals(1, result.getRunCount()); assertEquals(1, result.getFailureCount()); Failure failure = result.getFailures().get(0); assertEquals("the_failure", failure.getMessage()); assertTrue(failure.getException() instanceof AssertionError); }
public void validateUnusedStubs(Class<?> testClass, RunNotifier notifier) { Collection<Invocation> unused = new UnusedStubbingsFinder().getUnusedStubbingsByLocation(mocks); if (unused.isEmpty()) { return; //whoa!!! All stubbings were used! } //Oups, there are unused stubbings Description unnecessaryStubbings = Description.createTestDescription(testClass, "unnecessary Mockito stubbings"); notifier.fireTestFailure(new Failure(unnecessaryStubbings, Reporter.formatUnncessaryStubbingException(testClass, unused))); }
@Override public void testFinished(Description description) throws Exception { super.testFinished(description); try { Mockito.validateMockitoUsage(); } catch(Throwable t) { notifier.fireTestFailure(new Failure(description, t)); } } }
@Override public void fireTestAssumptionFailed(Failure failure) { Description description = failure.getDescription(); String methodName = description.getMethodName(); Throwable throwable = failure.getException(); if (methodName == null) { LoggingUtil.INSTANCE.error("Test class assumption failed", throwable); } else { LoggingUtil.INSTANCE.error("Test method assumption failed", throwable); } runNotifier.fireTestAssumptionFailed(failure); }
protected void addFailure(Throwable e) { notifier.fireTestFailure(new Failure(description, e)); } }
public static void rethrowAnyTestMechanismFailures( Result run ) throws TestSetFailedException { for ( Failure failure : run.getFailures() ) { if ( isFailureInsideJUnitItself( failure.getDescription() ) ) { throw new TestSetFailedException( failure.getTestHeader() + " :: " + failure.getMessage(), failure.getException() ); } } }
/** * @param system * @args args from main() */ private Result runMain(JUnitSystem system, String... args) { system.out().println("JUnit version " + Version.id()); List<Class<?>> classes = new ArrayList<Class<?>>(); List<Failure> missingClasses = new ArrayList<Failure>(); for (String each : args) { try { classes.add(Class.forName(each)); } catch (ClassNotFoundException e) { system.out().println("Could not find class: " + each); Description description = Description.createSuiteDescription(each); Failure failure = new Failure(description, e); missingClasses.add(failure); } } RunListener listener = new TextListener(system); addListener(listener); Result result = run(classes.toArray(new Class[0])); for (Failure each : missingClasses) { result.getFailures().add(each); } return result; }
public static void main(String[] args) { try { H2O.main(args); TestUtil.stall_till_cloudsize(3); List<Class> tests = JUnitRunner.all(); Result r = org.junit.runner.JUnitCore.runClasses(tests.toArray(new Class[0])); if( r.getFailureCount() == 0 ) { System.out.println("Successfully ran the following tests in " + (r.getRunTime() / 1000) + "s"); for( Class c : tests ) System.out.println(c.getName()); } else { for( Failure f : r.getFailures() ) { System.err.println(f.getDescription()); if( f.getException() != null ) f.getException().printStackTrace(); } } System.exit(r.getFailureCount()); } catch( Throwable t ) { t.printStackTrace(); System.exit(1); } } }