Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
Apache Ant Source Code Files
Apache Ant Source Code Files are inside the Apache Ant source package file like apache-ant-1.10.10-src.zip. Unzip the source package file and go to the "src/main" sub-directory, you will see source code files.
Here is the list of Java source code files of the Apache Ant 1.10.10 in \Users\fyicenter\apache-ant-1.10.10\src\main:
✍: FYIcenter.com
⏎ org/apache/tools/ant/taskdefs/optional/junit/JUnitTestRunner.java
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * https://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * */ package org.apache.tools.ant.taskdefs.optional.junit; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.io.PrintStream; import java.io.StringReader; import java.io.StringWriter; import java.lang.annotation.Annotation; import java.lang.reflect.Method; import java.lang.reflect.Modifier; import java.nio.file.Files; import java.nio.file.Paths; import java.util.Enumeration; import java.util.Properties; import java.util.StringTokenizer; import java.util.Vector; import junit.framework.AssertionFailedError; import junit.framework.Test; import junit.framework.TestCase; import junit.framework.TestFailure; import junit.framework.TestListener; import junit.framework.TestResult; import junit.framework.TestSuite; import org.apache.tools.ant.BuildException; import org.apache.tools.ant.MagicNames; import org.apache.tools.ant.Project; import org.apache.tools.ant.types.Permissions; import org.apache.tools.ant.util.FileUtils; import org.apache.tools.ant.util.StringUtils; import org.apache.tools.ant.util.TeeOutputStream; /** * Simple Testrunner for JUnit that runs all tests of a testsuite. * * <p>This TestRunner expects a name of a TestCase class as its * argument. If this class provides a static suite() method it will be * called and the resulting Test will be run. So, the signature should be * <pre> * public static junit.framework.Test suite() * </pre> * * <p>If no such method exists, all public methods starting with * "test" and taking no argument will be run.</p> * * <p>Summary output is generated at the end.</p> * * @since Ant 1.2 */ public class JUnitTestRunner implements TestListener, JUnitTaskMirror.JUnitTestRunnerMirror { private static final String JUNIT_4_TEST_ADAPTER = "junit.framework.JUnit4TestAdapter"; private static final String[] DEFAULT_TRACE_FILTERS = new String[] {"junit.framework.TestCase", "junit.framework.TestResult", "junit.framework.TestSuite", "junit.framework.Assert.", // don't filter AssertionFailure "junit.swingui.TestRunner", "junit.awtui.TestRunner", "junit.textui.TestRunner", "java.lang.reflect.Method.invoke(", "sun.reflect.", MagicNames.ANT_CORE_PACKAGE + ".", // JUnit 4 support: "org.junit.", "junit.framework.JUnit4TestAdapter", " more"}; /** * Do we filter junit.*.* stack frames out of failure and error exceptions. */ private static boolean filtertrace = true; /** Running more than one test suite? */ private static boolean multipleTests = false; /** * The file used to indicate that the build crashed. * File will be empty in case the build did not crash. */ private static String crashFile = null; /** * Holds the registered formatters. */ private final Vector<JUnitTaskMirror.JUnitResultFormatterMirror> formatters = new Vector<>(); /** * Collects TestResults. */ private IgnoredTestResult res; /** * Do we send output to System.out/.err in addition to the formatters? */ private boolean showOutput = false; private boolean outputToFormatters = true; /** * The permissions set for the test to run. */ private Permissions perm = null; /** * Do we stop on errors. */ private boolean haltOnError = false; /** * Do we stop on test failures. */ private boolean haltOnFailure = false; /** * Returncode */ private int retCode = SUCCESS; /** * The TestSuite we are currently running. */ private final JUnitTest junitTest; /** output written during the test */ private PrintStream systemError; /** Error output during the test */ private PrintStream systemOut; /** is this runner running in forked mode? */ private boolean forked = false; /** ClassLoader passed in in non-forked mode. */ private final ClassLoader loader; /** Do we print TestListener events? */ private boolean logTestListenerEvents = false; /** Turned on if we are using JUnit 4 for this test suite. see #38811 */ private boolean junit4; /** Names of test methods to execute */ private String[] methods = null; /** * Constructor for fork=true or when the user hasn't specified a * classpath. * @param test the test to run. * @param haltOnError whether to stop the run if an error is found. * @param filtertrace whether to filter junit.*.* stack frames out of exceptions * @param haltOnFailure whether to stop the run if failure is found. */ public JUnitTestRunner(final JUnitTest test, final boolean haltOnError, final boolean filtertrace, final boolean haltOnFailure) { this(test, haltOnError, filtertrace, haltOnFailure, false); } /** * Constructor for fork=true or when the user hasn't specified a * classpath. * @param test the test to run. * @param haltOnError whether to stop the run if an error is found. * @param filtertrace whether to filter junit.*.* stack frames out of exceptions * @param haltOnFailure whether to stop the run if failure is found. * @param showOutput whether to send output to System.out/.err as well as formatters. */ public JUnitTestRunner(final JUnitTest test, final boolean haltOnError, final boolean filtertrace, final boolean haltOnFailure, final boolean showOutput) { this(test, haltOnError, filtertrace, haltOnFailure, showOutput, false); } /** * Constructor for fork=true or when the user hasn't specified a * classpath. * @param test the test to run. * @param haltOnError whether to stop the run if an error is found. * @param filtertrace whether to filter junit.*.* stack frames out of exceptions * @param haltOnFailure whether to stop the run if failure is found. * @param showOutput whether to send output to System.out/.err as well as formatters. * @param logTestListenerEvents whether to print TestListener events. * @since Ant 1.7 */ public JUnitTestRunner(final JUnitTest test, final boolean haltOnError, final boolean filtertrace, final boolean haltOnFailure, final boolean showOutput, final boolean logTestListenerEvents) { this(test, null, haltOnError, filtertrace, haltOnFailure, showOutput, logTestListenerEvents, null); } /** * Constructor for fork=true or when the user hasn't specified a * classpath. * @param test the test to run. * @param methods names of methods of the test to be executed. * @param haltOnError whether to stop the run if an error is found. * @param filtertrace whether to filter junit.*.* stack frames out of exceptions * @param haltOnFailure whether to stop the run if failure is found. * @param showOutput whether to send output to System.out/.err as well as formatters. * @param logTestListenerEvents whether to print TestListener events. * @since 1.8.2 */ public JUnitTestRunner(final JUnitTest test, final String[] methods, final boolean haltOnError, final boolean filtertrace, final boolean haltOnFailure, final boolean showOutput, final boolean logTestListenerEvents) { this(test, methods, haltOnError, filtertrace, haltOnFailure, showOutput, logTestListenerEvents, null); } /** * Constructor to use when the user has specified a classpath. * @param test the test to run. * @param haltOnError whether to stop the run if an error is found. * @param filtertrace whether to filter junit.*.* stack frames out of exceptions * @param haltOnFailure whether to stop the run if failure is found. * @param loader the classloader to use running the test. */ public JUnitTestRunner(final JUnitTest test, final boolean haltOnError, final boolean filtertrace, final boolean haltOnFailure, final ClassLoader loader) { this(test, haltOnError, filtertrace, haltOnFailure, false, loader); } /** * Constructor to use when the user has specified a classpath. * @param test the test to run. * @param haltOnError whether to stop the run if an error is found. * @param filtertrace whether to filter junit.*.* stack frames out of exceptions * @param haltOnFailure whether to stop the run if failure is found. * @param showOutput whether to send output to System.out/.err as well as formatters. * @param loader the classloader to use running the test. */ public JUnitTestRunner(final JUnitTest test, final boolean haltOnError, final boolean filtertrace, final boolean haltOnFailure, final boolean showOutput, final ClassLoader loader) { this(test, haltOnError, filtertrace, haltOnFailure, showOutput, false, loader); } /** * Constructor to use when the user has specified a classpath. * @param test the test to run. * @param haltOnError whether to stop the run if an error is found. * @param filtertrace whether to filter junit.*.* stack frames out of exceptions * @param haltOnFailure whether to stop the run if failure is found. * @param showOutput whether to send output to System.out/.err as well as formatters. * @param logTestListenerEvents whether to print TestListener events. * @param loader the classloader to use running the test. * @since Ant 1.7 */ public JUnitTestRunner(final JUnitTest test, final boolean haltOnError, final boolean filtertrace, final boolean haltOnFailure, final boolean showOutput, final boolean logTestListenerEvents, final ClassLoader loader) { this(test, null, haltOnError, filtertrace, haltOnFailure, showOutput, logTestListenerEvents, loader); } /** * Constructor to use when the user has specified a classpath. * @param test JUnitTest * @param methods String[] * @param haltOnError boolean * @param filtertrace boolean * @param haltOnFailure boolean * @param showOutput boolean * @param logTestListenerEvents boolean * @param loader ClassLoader * @since 1.8.2 */ public JUnitTestRunner(final JUnitTest test, final String[] methods, final boolean haltOnError, final boolean filtertrace, final boolean haltOnFailure, final boolean showOutput, final boolean logTestListenerEvents, final ClassLoader loader) { super(); JUnitTestRunner.filtertrace = filtertrace; // TODO clumsy, should use instance field somehow this.junitTest = test; this.haltOnError = haltOnError; this.haltOnFailure = haltOnFailure; this.showOutput = showOutput; this.logTestListenerEvents = logTestListenerEvents; this.methods = methods != null ? methods.clone() : null; this.loader = loader; } private PrintStream savedOut = null; private PrintStream savedErr = null; private PrintStream createEmptyStream() { return new PrintStream( new OutputStream() { @Override public void write(final int b) { } }); } private PrintStream createTeePrint(final PrintStream ps1, final PrintStream ps2) { return new PrintStream(new TeeOutputStream(ps1, ps2)); } 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(); } } } /** * Run the test. */ @Override public void run() { res = new IgnoredTestResult(); res.addListener(wrapListener(this)); for (JUnitTaskMirror.JUnitResultFormatterMirror f : formatters) { res.addListener(wrapListener((TestListener) f)); } final ByteArrayOutputStream errStrm = new ByteArrayOutputStream(); final ByteArrayOutputStream outStrm = new ByteArrayOutputStream(); setupIOStreams(outStrm, errStrm); Test suite = null; Throwable exception = null; boolean startTestSuiteSuccess = false; try { try { Class<?> testClass; if (loader == null) { testClass = Class.forName(junitTest.getName(), false, getClass().getClassLoader()); } else { testClass = Class.forName(junitTest.getName(), false, loader); } final boolean testMethodsSpecified = (methods != null); // check for a static suite method first, even when using // JUnit 4 Method suiteMethod = null; if (!testMethodsSpecified) { try { // check if there is a suite method suiteMethod = testClass.getMethod("suite"); } catch (final NoSuchMethodException e) { // no appropriate suite method found. We don't report any // error here since it might be perfectly normal. } } if (suiteMethod != null) { // if there is a suite method available, then try // to extract the suite from it. If there is an error // here it will be caught below and reported. suite = (Test) suiteMethod.invoke(null); } else { Class<?> junit4TestAdapterClass = null; Class<?> junit4TestAdapterCacheClass = null; boolean useSingleMethodAdapter = false; if (junit.framework.TestCase.class.isAssignableFrom(testClass)) { // Do not use JUnit 4 API for running JUnit 3.x // tests - it is not able to run individual test // methods. // // Technical details: // org.junit.runner.Request.method(Class, String).getRunner() // would return a runner which always executes all // test methods. The reason is that the Runner would be // an instance of class // org.junit.internal.runners.OldTestClassRunner // that does not implement interface Filterable - so it // is unable to filter out test methods not matching // the requested name. } else { // Check for JDK 5 first. Will *not* help on JDK 1.4 // if only junit-4.0.jar in CP because in that case // linkage of whole task will already have failed! But // will help if CP has junit-3.8.2.jar:junit-4.0.jar. // In that case first C.fN will fail with CNFE and we // will avoid UnsupportedClassVersionError. try { Class.forName("java.lang.annotation.Annotation"); junit4TestAdapterCacheClass = Class.forName( "org.apache.tools.ant.taskdefs.optional.junit.CustomJUnit4TestAdapterCache"); if (loader == null) { junit4TestAdapterClass = Class.forName(JUNIT_4_TEST_ADAPTER); if (testMethodsSpecified) { /* * We cannot try to load the JUnit4TestAdapter * before trying to load JUnit4TestMethodAdapter * because it might fail with * NoClassDefFoundException, instead of plain * ClassNotFoundException. */ junit4TestAdapterClass = Class.forName( "org.apache.tools.ant.taskdefs.optional.junit.JUnit4TestMethodAdapter"); useSingleMethodAdapter = true; } } else { junit4TestAdapterClass = Class.forName(JUNIT_4_TEST_ADAPTER, true, loader); if (testMethodsSpecified) { junit4TestAdapterClass = Class.forName( "org.apache.tools.ant.taskdefs.optional.junit.JUnit4TestMethodAdapter", true, loader); useSingleMethodAdapter = true; } } } catch (final ClassNotFoundException e) { // OK, fall back to JUnit 3. } } junit4 = junit4TestAdapterClass != null; if (junitTest.isSkipNonTests() && !containsTests(testClass, junit4)) { return; } if (junit4) { // Let's use it! Class<?>[] formalParams; Object[] actualParams; if (useSingleMethodAdapter) { formalParams = new Class[] {Class.class, String[].class}; actualParams = new Object[] {testClass, methods}; } else { formalParams = new Class[] {Class.class, Class.forName( "junit.framework.JUnit4TestAdapterCache")}; actualParams = new Object[] {testClass, junit4TestAdapterCacheClass .getMethod("getInstance").invoke(null)}; } suite = junit4TestAdapterClass.asSubclass(Test.class) .getConstructor(formalParams).newInstance(actualParams); } else { // Use JUnit 3. // try to extract a test suite automatically this // will generate warnings if the class is no // suitable Test if (!testMethodsSpecified) { suite = new TestSuite(testClass); } else if (methods.length == 1) { suite = TestSuite.createTest(testClass, methods[0]); } else { final TestSuite testSuite = new TestSuite(testClass.getName()); for (String method : methods) { testSuite.addTest(TestSuite.createTest(testClass, method)); } suite = testSuite; } } } } catch (final Throwable e) { retCode = ERRORS; exception = e; } final long start = System.currentTimeMillis(); fireStartTestSuite(); startTestSuiteSuccess = true; if (exception != null) { // had an exception constructing suite for (JUnitTaskMirror.JUnitResultFormatterMirror f : formatters) { ((TestListener) f).addError(null, exception); } junitTest.setCounts(1, 0, 1, 0); junitTest.setRunTime(0); } 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()); } else { junitTest.setCounts(res.runCount() + res.ignoredCount(), res.failureCount(), res.errorCount(), res.ignoredCount() + res.skippedCount()); } junitTest.setRunTime(System.currentTimeMillis() - start); } } } finally { if (perm != null) { perm.restoreSecurityManager(); } if (savedOut != null) { System.setOut(savedOut); } if (savedErr != null) { System.setErr(savedErr); } systemError.close(); systemError = null; systemOut.close(); systemOut = null; if (startTestSuiteSuccess) { String out, err; try { out = new String(outStrm.toByteArray()); } catch (final OutOfMemoryError ex) { out = "out of memory on output stream"; } try { err = new String(errStrm.toByteArray()); } catch (final OutOfMemoryError ex) { err = "out of memory on error stream"; } sendOutAndErr(out, err); } } fireEndTestSuite(); // junitTest has the correct counts for JUnit4, while res doesn't if (retCode != SUCCESS || junitTest.errorCount() != 0) { retCode = ERRORS; } else if (junitTest.failureCount() != 0) { retCode = FAILURES; } } private static boolean containsTests(final Class<?> testClass, final boolean isJUnit4) { Class<? extends Annotation> testAnnotation = null; Class<? extends Annotation> suiteAnnotation = null; Class<? extends Annotation> runWithAnnotation = null; try { testAnnotation = Class.forName("org.junit.Test").asSubclass(Annotation.class); } catch (final ClassNotFoundException e) { if (isJUnit4) { // odd - we think we're JUnit4 but don't support the test annotation. We therefore can't have any tests! return false; } // else... we're a JUnit3 test and don't need the annotation } try { suiteAnnotation = Class.forName("org.junit.Suite.SuiteClasses") .asSubclass(Annotation.class); } catch (final ClassNotFoundException ex) { // ignore - we don't have this annotation so make sure we don't check for it } try { runWithAnnotation = Class.forName("org.junit.runner.RunWith") .asSubclass(Annotation.class); } catch (final ClassNotFoundException ex) { // also ignore as this annotation doesn't exist so tests can't use it } if (!isJUnit4 && !TestCase.class.isAssignableFrom(testClass)) { //a test we think is JUnit3 but does not extend TestCase. Can't really be a test. return false; } // check if we have any inner classes that contain suitable test methods for (final Class<?> innerClass : testClass.getDeclaredClasses()) { if (containsTests(innerClass, isJUnit4) || containsTests(innerClass, !isJUnit4)) { return true; } } if (Modifier.isAbstract(testClass.getModifiers()) || Modifier.isInterface(testClass.getModifiers())) { // can't instantiate class and no inner classes are tests either return false; } if (isJUnit4) { if (suiteAnnotation != null && testClass.getAnnotation(suiteAnnotation) != null) { // class is marked as a suite. Let JUnit try and work its magic on it. return true; } if (runWithAnnotation != null && testClass.getAnnotation(runWithAnnotation) != null) { /* Class is marked with @RunWith. If this class is badly written (no test methods, * multiple constructors, private constructor etc) then the class is automatically * run and fails in the IDEs I've tried... so I'm happy handing the class to JUnit * to try and run, and let JUnit report a failure if a bad test case is provided. * Trying to do anything else is likely to result in us filtering out cases that * could be valid for future versions of JUnit so would just increase future * maintenance work. */ return true; } } for (final Method m : testClass.getMethods()) { if (isJUnit4) { // check if suspected JUnit4 classes have methods with @Test annotation if (m.getAnnotation(testAnnotation) != null) { return true; } } else { // check if JUnit3 class have public or protected no-args methods starting with // names starting with test if (m.getName().startsWith("test") && m.getParameterTypes().length == 0 && (Modifier.isProtected(m.getModifiers()) || Modifier.isPublic(m.getModifiers()))) { return true; } } // check if JUnit3 or JUnit4 test have a public or protected, static, // no-args 'suite' method if ("suite".equals(m.getName()) && m.getParameterTypes().length == 0 && (Modifier.isProtected(m.getModifiers()) || Modifier.isPublic(m.getModifiers())) && Modifier.isStatic(m.getModifiers())) { return true; } } // no test methods found return false; } /** * Returns what System.exit() would return in the standalone version. * * @return 2 if errors occurred, 1 if tests failed else 0. */ @Override public int getRetCode() { return retCode; } /** * Interface TestListener. * * <p>A new Test is started. * @param t the test. */ @Override public void startTest(final Test t) { final String testName = JUnitVersionHelper.getTestCaseName(t); logTestListenerEvent("startTest(" + testName + ")"); } /** * Interface TestListener. * * <p>A Test is finished. * @param test the test. */ @Override public void endTest(final Test test) { final String testName = JUnitVersionHelper.getTestCaseName(test); logTestListenerEvent("endTest(" + testName + ")"); } private void logTestListenerEvent(String message) { if (logTestListenerEvents) { @SuppressWarnings("resource") final PrintStream out = savedOut != null ? savedOut : System.out; out.flush(); final StringTokenizer messageLines = new StringTokenizer(String.valueOf(message), "\r\n", false); while (messageLines.hasMoreTokens()) { out.println(JUnitTask.TESTLISTENER_PREFIX + messageLines.nextToken()); } out.flush(); } } /** * Interface TestListener for JUnit <= 3.4. * * <p>A Test failed. * @param test the test. * @param t the exception thrown by the test. */ public void addFailure(final Test test, final Throwable t) { final String testName = JUnitVersionHelper.getTestCaseName(test); logTestListenerEvent("addFailure(" + testName + ", " + t.getMessage() + ")"); if (haltOnFailure) { res.stop(); } } /** * 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); } /** * Interface TestListener. * * <p>An error occurred while running the test. * @param test the test. * @param t the error thrown by the test. */ @Override public void addError(final Test test, final Throwable t) { final String testName = JUnitVersionHelper.getTestCaseName(test); logTestListenerEvent("addError(" + testName + ", " + t.getMessage() + ")"); if (haltOnError) { res.stop(); } } /** * Permissions for the test run. * @since Ant 1.6 * @param permissions the permissions to use. */ @Override public void setPermissions(final Permissions permissions) { perm = permissions; } /** * Handle a string destined for standard output. * @param output the string to output */ @Override public void handleOutput(final String output) { if (!logTestListenerEvents && output.startsWith(JUnitTask.TESTLISTENER_PREFIX)) { // ignore } else if (systemOut != null) { systemOut.print(output); } } /** * Handle input. * @param buffer not used. * @param offset not used. * @param length not used. * @return -1 always. * @throws IOException never. * @see org.apache.tools.ant.Task#handleInput(byte[], int, int) * * @since Ant 1.6 */ @Override public int handleInput(final byte[] buffer, final int offset, final int length) throws IOException { return -1; } /** {@inheritDoc}. */ @Override public void handleErrorOutput(final String output) { if (systemError != null) { systemError.print(output); } } /** {@inheritDoc}. */ @Override public void handleFlush(final String output) { if (systemOut != null) { systemOut.print(output); } } /** {@inheritDoc}. */ @Override public void handleErrorFlush(final String output) { if (systemError != null) { systemError.print(output); } } private void sendOutAndErr(final String out, final String err) { for (JUnitTaskMirror.JUnitResultFormatterMirror f : formatters) { final JUnitResultFormatter formatter = (JUnitResultFormatter) f; formatter.setSystemOutput(out); formatter.setSystemError(err); } } private void fireStartTestSuite() { for (JUnitTaskMirror.JUnitResultFormatterMirror f : formatters) { ((JUnitResultFormatter) f).startTestSuite(junitTest); } } private void fireEndTestSuite() { for (JUnitTaskMirror.JUnitResultFormatterMirror f : formatters) { ((JUnitResultFormatter) f).endTestSuite(junitTest); } } /** * Add a formatter. * @param f the formatter to add. */ public void addFormatter(final JUnitResultFormatter f) { formatters.addElement(f); } /** {@inheritDoc}. */ @Override public void addFormatter(final JUnitTaskMirror.JUnitResultFormatterMirror f) { formatters.addElement(f); } /** * Entry point for standalone (forked) mode. * <p> * Parameters: testcaseclassname plus parameters in the format * key=value, none of which is required. * </p> * <table border="1"> * <caption>Test runner attributes</caption> * <tr> * <th>key</th><th>description</th><th>default value</th> * </tr> * <tr> * <td>haltOnError</td><td>halt test on errors?</td><td>false</td> * </tr> * <tr> * <td>haltOnFailure</td><td>halt test on failures?</td><td>false</td> * </tr> * <tr> * <td>formatter</td><td>A JUnitResultFormatter given as * classname,filename. If filename is omitted, System.out is * assumed.</td><td>none</td> * </tr> * <tr> * <td>showoutput</td><td>send output to System.err/.out as * well as to the formatters?</td><td>false</td> * </tr> * <tr> * <td>logtestlistenerevents</td><td>log TestListener events to * System.out.</td><td>false</td> * </tr> * <tr> * <td>methods</td><td>Comma-separated list of names of individual * test methods to execute.</td><td>null</td> * </tr> * </table> * @param args the command line arguments. * @throws IOException on error. */ public static void main(final String[] args) throws IOException { String[] methods = null; boolean haltError = false; boolean haltFail = false; boolean stackfilter = true; final Properties props = new Properties(); boolean showOut = false; boolean outputToFormat = true; boolean logFailedTests = true; boolean logTestListenerEvents = false; boolean skipNonTests = false; /* Ant id of thread running this unit test, 0 in single-threaded mode */ int antThreadID = 0; if (args.length == 0) { System.err.println("required argument TestClassName missing"); System.exit(ERRORS); } if (args[0].startsWith(Constants.TESTSFILE)) { multipleTests = true; args[0] = args[0].substring(Constants.TESTSFILE.length()); } for (String arg : args) { if (arg.startsWith(Constants.METHOD_NAMES)) { try { final String methodsList = arg.substring(Constants.METHOD_NAMES.length()); methods = JUnitTest.parseTestMethodNamesList(methodsList); } catch (final IllegalArgumentException ex) { System.err.println("Invalid specification of test method names: " + arg); System.exit(ERRORS); } } else if (arg.startsWith(Constants.HALT_ON_ERROR)) { haltError = Project.toBoolean(arg.substring(Constants.HALT_ON_ERROR.length())); } else if (arg.startsWith(Constants.HALT_ON_FAILURE)) { haltFail = Project.toBoolean(arg.substring(Constants.HALT_ON_FAILURE.length())); } else if (arg.startsWith(Constants.FILTERTRACE)) { stackfilter = Project.toBoolean(arg.substring(Constants.FILTERTRACE.length())); } 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()); System.exit(ERRORS); } } else if (arg.startsWith(Constants.PROPSFILE)) { final InputStream in = Files.newInputStream(Paths.get(arg .substring(Constants.PROPSFILE.length()))); props.load(in); in.close(); } else if (arg.startsWith(Constants.SHOWOUTPUT)) { showOut = Project.toBoolean(arg.substring(Constants.SHOWOUTPUT.length())); } else if (arg.startsWith(Constants.LOGTESTLISTENEREVENTS)) { logTestListenerEvents = Project.toBoolean( arg.substring(Constants.LOGTESTLISTENEREVENTS.length())); } else if (arg.startsWith(Constants.OUTPUT_TO_FORMATTERS)) { outputToFormat = Project.toBoolean( arg.substring(Constants.OUTPUT_TO_FORMATTERS.length())); } else if (arg.startsWith(Constants.LOG_FAILED_TESTS)) { logFailedTests = Project.toBoolean( arg.substring(Constants.LOG_FAILED_TESTS.length())); } else if (arg.startsWith(Constants.SKIP_NON_TESTS)) { skipNonTests = Project.toBoolean( arg.substring(Constants.SKIP_NON_TESTS.length())); } else if (arg.startsWith(Constants.THREADID)) { antThreadID = Integer.parseInt(arg.substring(Constants.THREADID.length())); } } // Add/overlay system properties on the properties from the Ant project System.getProperties().forEach(props::put); int returnCode = SUCCESS; if (multipleTests) { try (final BufferedReader reader = new BufferedReader(new FileReader(args[0]))) { int code = 0; boolean errorOccurred = false; boolean failureOccurred = false; String line = null; while ((line = reader.readLine()) != null) { final StringTokenizer st = new StringTokenizer(line, ","); final String testListSpec = st.nextToken(); final int colonIndex = testListSpec.indexOf(':'); String testCaseName; String[] testMethodNames; if (colonIndex == -1) { testCaseName = testListSpec; testMethodNames = null; } else { testCaseName = testListSpec.substring(0, colonIndex); testMethodNames = JUnitTest.parseTestMethodNamesList( testListSpec .substring(colonIndex + 1) .replace('+', ',')); } final JUnitTest t = new JUnitTest(testCaseName); t.setTodir(new File(st.nextToken())); t.setOutfile(st.nextToken()); t.setProperties(props); t.setSkipNonTests(skipNonTests); t.setThread(antThreadID); code = launch(t, testMethodNames, haltError, stackfilter, haltFail, showOut, outputToFormat, logTestListenerEvents); errorOccurred = (code == ERRORS); failureOccurred = (code != SUCCESS); if (errorOccurred || failureOccurred) { if ((errorOccurred && haltError) || (failureOccurred && haltFail)) { registerNonCrash(); System.exit(code); } else { if (code > returnCode) { returnCode = code; } if (logFailedTests) { System.out.println("TEST " + t.getName() + " FAILED"); } } } } } catch (final IOException e) { e.printStackTrace(); //NOSONAR } } else { final JUnitTest t = new JUnitTest(args[0]); t.setThread(antThreadID); t.setProperties(props); t.setSkipNonTests(skipNonTests); returnCode = launch(t, methods, haltError, stackfilter, haltFail, showOut, outputToFormat, logTestListenerEvents); } registerNonCrash(); System.exit(returnCode); } private static Vector<FormatterElement> fromCmdLine = new Vector<>(); private static void transferFormatters(final JUnitTestRunner runner, final JUnitTest test) { runner.addFormatter(new JUnitResultFormatter() { @Override public void startTestSuite(final JUnitTest suite) throws BuildException { } @Override public void endTestSuite(final JUnitTest suite) throws BuildException { } @Override public void setOutput(final OutputStream out) { } @Override public void setSystemOutput(final String out) { } @Override public void setSystemError(final String err) { } @Override public void addError(final Test arg0, final Throwable arg1) { } @Override public void addFailure(final Test arg0, final AssertionFailedError arg1) { } @Override public void endTest(final Test arg0) { } @Override public void startTest(final Test arg0) { registerTestCase(JUnitVersionHelper.getTestCaseName(arg0)); } }); for (FormatterElement fe : fromCmdLine) { if (multipleTests && fe.getUseFile()) { final File destFile = new File(test.getTodir(), test.getOutfile() + fe.getExtension()); fe.setOutfile(destFile); } runner.addFormatter((JUnitResultFormatter) fe.createFormatter()); } } /** * Line format is: formatter=<classname>(,<pathname>)? * * @param line String */ private static void createAndStoreFormatter(final String line) throws BuildException { final FormatterElement fe = new FormatterElement(); final int pos = line.indexOf(','); if (pos == -1) { fe.setClassname(line); fe.setUseFile(false); } else { fe.setClassname(line.substring(0, pos)); fe.setUseFile(true); if (!multipleTests) { fe.setOutfile(new File(line.substring(pos + 1))); } else { final int fName = line.indexOf(IGNORED_FILE_NAME); if (fName > -1) { fe.setExtension(line.substring(fName + IGNORED_FILE_NAME.length())); } } } fromCmdLine.addElement(fe); } /** * 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(); } private static boolean filterLine(final String line) { for (String filter : DEFAULT_TRACE_FILTERS) { if (line.contains(filter)) { return true; } } return false; } /** * @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(); } /** * @since Ant 1.7 */ private static void registerNonCrash() throws IOException { if (crashFile != null) { try (FileWriter out = new FileWriter(crashFile)) { out.write(Constants.TERMINATED_SUCCESSFULLY + "\n"); out.flush(); } } } private static void registerTestCase(final String testCase) { if (crashFile != null) { try (FileWriter out = new FileWriter(crashFile)) { out.write(testCase + "\n"); out.flush(); } catch (final IOException e) { // ignored. } } } /** * Modifies a TestListener when running JUnit 4: treats AssertionFailedError * as a failure not an error. * * @since Ant 1.7 */ private TestListenerWrapper wrapListener(final TestListener testListener) { return new TestListenerWrapper(testListener) { @Override public void addError(final Test test, final Throwable t) { if (junit4 && t instanceof AssertionFailedError) { // JUnit 4 does not distinguish between errors and failures // even in the JUnit 3 adapter. // So we need to help it a bit to retain compatibility for JUnit 3 tests. testListener.addFailure(test, (AssertionFailedError) t); } else if (junit4 && t instanceof AssertionError) { // Not strictly necessary but probably desirable. // JUnit 4-specific test GUIs will show just "failures". // But Ant's output shows "failures" vs. "errors". // We would prefer to show "failure" for things that logically are. final String message = t.getMessage(); final AssertionFailedError failure = message != null ? new AssertionFailedError(message) : new AssertionFailedError(); failure.initCause(t.getCause()); failure.setStackTrace(t.getStackTrace()); testListener.addFailure(test, failure); } else { testListener.addError(test, t); } } @Override public void addFailure(final Test test, final AssertionFailedError t) { testListener.addFailure(test, t); } @SuppressWarnings("unused") public void addFailure(final Test test, final Throwable t) { // pre-3.4 if (t instanceof AssertionFailedError) { testListener.addFailure(test, (AssertionFailedError) t); } else { testListener.addError(test, t); } } @Override public void endTest(final Test test) { testListener.endTest(test); } @Override public void startTest(final Test test) { testListener.startTest(test); } }; } /** * Use instead of TestResult.get{Failure,Error}Count on JUnit 4, * since the adapter claims that all failures are errors. * @since Ant 1.7 */ private int[] findJUnit4FailureErrorCount(final TestResult result) { int failures = 0; int errors = 0; { @SuppressWarnings("unchecked") Enumeration<TestFailure> e = result.failures(); while (e.hasMoreElements()) { e.nextElement(); failures++; } } @SuppressWarnings("unchecked") Enumeration<TestFailure> e = result.errors(); while (e.hasMoreElements()) { final Throwable t = e.nextElement().thrownException(); if (t instanceof AssertionFailedError || t instanceof AssertionError) { failures++; } else { errors++; } } return new int[] {failures, errors}; } }
⏎ org/apache/tools/ant/taskdefs/optional/junit/JUnitTestRunner.java
Or download all of them as a single archive file:
File name: apache-ant-1.10.10-fyi.zip File size: 2392938 bytes Release date: 2021-04-17 Download
⇐ Download Apache Ant Source Package
2021-07-10, 110304👍, 0💬
Popular Posts:
How to perform XML Schema validation with dom\Writer.java provided in the Apache Xerces package? You...
Jackson is "the Java JSON library" or "the best JSON parser for Java". Or simply as "JSON for Java"....
Apache Ant Source Code Files are inside the Apache Ant source package file like apache-ant-1.10.10-s...
JRE 8 rt.jar is the JAR file for JRE 8 RT (Runtime) libraries. JRE (Java Runtime) 8 is the runtime e...
What Is jsse.jar (JDK 6) Java Secure Socket Extension? jsse.jar, Java Secure Socket Extension, is Ja...