String filter(Throwable error) { return getFilteredTrace(error); } }
/** * @since Ant 1.6.2 */ private static int launch(final JUnitTest t, final String[] methods, final boolean haltError, final boolean stackfilter, final boolean haltFail, final boolean showOut, final boolean outputToFormat, final boolean logTestListenerEvents) { final JUnitTestRunner runner = new JUnitTestRunner(t, methods, haltError, stackfilter, haltFail, showOut, logTestListenerEvents, null); runner.forked = true; runner.outputToFormatters = outputToFormat; transferFormatters(runner, t); runner.run(); return runner.getRetCode(); }
/** * Interface TestListener for JUnit > 3.4. * * <p>A Test failed. * @param test the test. * @param t the assertion thrown by the test. */ @Override public void addFailure(final Test test, final AssertionFailedError t) { addFailure(test, (Throwable) t); }
public void run() { res = new IgnoredTestResult(); res.addListener(wrapListener(this)); for (JUnitTaskMirror.JUnitResultFormatterMirror f : formatters) { res.addListener(wrapListener((TestListener) f)); setupIOStreams(outStrm, errStrm); && !containsTests(testClass, junit4)) { return; fireStartTestSuite(); startTestSuiteSuccess = true; if (exception != null) { // had an exception constructing suite } else { try { logTestListenerEvent("tests to run: " + suite.countTestCases()); suite.run(res); } finally { if (junit4 || suite.getClass().getName().equals(JUNIT_4_TEST_ADAPTER)) { final int[] cnts = findJUnit4FailureErrorCount(res); junitTest.setCounts(res.runCount() + res.ignoredCount(), cnts[0], cnts[1], res.ignoredCount() + res.skippedCount()); sendOutAndErr(out, err); fireEndTestSuite();
} else if (arg.startsWith(Constants.CRASHFILE)) { crashFile = arg.substring(Constants.CRASHFILE.length()); registerTestCase(Constants.BEFORE_FIRST_TEST); } else if (arg.startsWith(Constants.FORMATTER)) { try { createAndStoreFormatter(arg.substring(Constants.FORMATTER.length())); } catch (final BuildException be) { System.err.println(be.getMessage()); t.setSkipNonTests(skipNonTests); t.setThread(antThreadID); code = launch(t, testMethodNames, haltError, stackfilter, haltFail, showOut, outputToFormat, logTestListenerEvents); if (errorOccurred || failureOccurred) { if ((errorOccurred && haltError) || (failureOccurred && haltFail)) { registerNonCrash(); System.exit(code); } else { t.setProperties(props); t.setSkipNonTests(skipNonTests); returnCode = launch(t, methods, haltError, stackfilter, haltFail, showOut, outputToFormat, logTestListenerEvents); registerNonCrash(); System.exit(returnCode);
private void setupIOStreams(final ByteArrayOutputStream o, final ByteArrayOutputStream e) { systemOut = new PrintStream(o); systemError = new PrintStream(e); if (forked) { if (!outputToFormatters) { if (!showOutput) { savedOut = System.out; savedErr = System.err; System.setOut(createEmptyStream()); System.setErr(createEmptyStream()); } } else { savedOut = System.out; savedErr = System.err; if (!showOutput) { System.setOut(systemOut); System.setErr(systemError); } else { System.setOut(createTeePrint(savedOut, systemOut)); System.setErr(createTeePrint(savedErr, systemError)); } perm = null; } } else { if (perm != null) { perm.setSecurityManager(); } } }
/** {@inheritDoc}. */ @Override public JUnitTaskMirror.JUnitTestRunnerMirror newJUnitTestRunner(JUnitTest test, String[] methods, boolean haltOnError, boolean filterTrace, boolean haltOnFailure, boolean showOutput, boolean logTestListenerEvents, AntClassLoader classLoader) { return new JUnitTestRunner(test, methods, haltOnError, filterTrace, haltOnFailure, showOutput, logTestListenerEvents, classLoader); }
/** * Returns a filtered stack trace. * This is ripped out of junit.runner.BaseTestRunner. * @param t the exception to filter. * @return the filtered stack trace. */ public static String getFilteredTrace(final Throwable t) { final String trace = StringUtils.getStackTrace(t); return JUnitTestRunner.filterStack(trace); }
/** * Filters stack frames from internal JUnit and Ant classes * @param stack the stack trace to filter. * @return the filtered stack. */ public static String filterStack(final String stack) { if (!filtertrace) { return stack; } final StringWriter sw = new StringWriter(); final BufferedWriter pw = new BufferedWriter(sw); final StringReader sr = new StringReader(stack); final BufferedReader br = new BufferedReader(sr); String line; try { boolean firstLine = true; while ((line = br.readLine()) != null) { if (firstLine || !filterLine(line)) { pw.write(line); pw.newLine(); } firstLine = false; } } catch (final Exception e) { return stack; // return the stack unfiltered } finally { FileUtils.close(pw); } return sw.toString(); }
if (containsTests(innerClass, isJUnit4) || containsTests(innerClass, !isJUnit4)) { return true;
private static void transferFormatters(final JUnitTestRunner runner, final JUnitTest test) { runner.addFormatter(new JUnitResultFormatter() { fe.setOutfile(destFile); runner.addFormatter((JUnitResultFormatter) fe.createFormatter());
String filter(Throwable error) { return getFilteredTrace(error); } }
private void formatError(final String type, final Test test, final Throwable t) { if (test != null) { endTest(test); failedTests.put(test, test); } final Element nested = doc.createElement(type); Element currentTest = test == null ? rootElement : testElements.get(createDescription(test)); currentTest.appendChild(nested); final String message = t.getMessage(); if (message != null && !message.isEmpty()) { nested.setAttribute(ATTR_MESSAGE, t.getMessage()); } nested.setAttribute(ATTR_TYPE, t.getClass().getName()); final String strace = JUnitTestRunner.getFilteredTrace(t); final Text trace = doc.createTextNode(strace); nested.appendChild(trace); }
private void formatError(String type, Test test, Throwable t) { synchronized (wri) { if (test != null) { endTest(test); failed.put(test, Boolean.TRUE); } try { wri.write(type); wri.newLine(); wri.write(String.valueOf(t.getMessage())); wri.newLine(); String strace = JUnitTestRunner.getFilteredTrace(t); wri.write(strace); wri.newLine(); } catch (IOException ex) { throw new BuildException(ex); } } }
/** * Format an error and print it. * @param type the type of error * @param test the test that failed * @param error the exception that the test threw */ protected synchronized void formatError(String type, Test test, Throwable error) { if (test != null) { endTest(test); } try { resultWriter.write(formatTest(test) + type); resultWriter.newLine(); resultWriter.write(String.valueOf(error.getMessage())); resultWriter.newLine(); String strace = JUnitTestRunner.getFilteredTrace(error); resultWriter.write(strace); resultWriter.newLine(); resultWriter.newLine(); } catch (IOException ex) { throw new BuildException(ex); } }