Add forkStyle attribute to <junit> with possible values of once,

perTest and perBatch.

once will create a single Java VM for all forked tests, perTest is
what we have traditionally (and the default), perBatch uses a VM per
<batchtest>.

Actually, this is not entirely true since only tests with the same
configuration of filtetrace and haltonfailure and friends can run
inside the same VM, so we may end up with mutliple VMs anyway - but
once really should be a lot faster than perTest in general.

Based on

PR: 24697
Submitted by:	Anton <anton at atlassian dot com>


git-svn-id: https://svn.apache.org/repos/asf/ant/core/trunk@276317 13f79535-47bb-0310-9956-ffa450edef68

CONTRIBUTORS

@@ -63,6 +63,7 @@ Glenn McAllister
 Glenn Twiggs
 Greg Nelson
 Harish Prabandham
+Haroon Rafique
 Hiroaki Nakamura
 Holger Engels
 Ingenonsya France
@@ -165,6 +166,7 @@ Roger Vaughn
 Russell Gold
 Sam Ruby
 Scott Carlson
+Scott M. Stirling
 Sean Egan
 Sean P. Kane
 Shiraz Kanga

build.xml

@@ -53,6 +53,7 @@
   <property name="junit.filtertrace" value="off"/>
   <property name="junit.summary" value="no"/>
   <property name="test.haltonfailure" value="yes" />
+  <property name="junit.forkstyle" value="once"/>
   <property name="unfiltered.files" value="**/*.gif,**/*.jpg,**/*.ico,**/*.pdf,**/*.zip"/>
 
   <!--
@@ -1428,7 +1429,7 @@
 
     <junit printsummary="${junit.summary}" haltonfailure="${test.haltonfailure}"
            filtertrace="${junit.filtertrace}"
-           fork="${junit.fork}"
+           fork="${junit.fork}" forkstyle="${junit.forkstyle}"
            failureproperty="tests.failed">
 <!--      <jvmarg value="-classic"/> -->
       <classpath refid="tests-classpath"/>

src/main/org/apache/tools/ant/taskdefs/optional/junit/FormatterElement.java

@@ -56,6 +56,13 @@ public class FormatterElement {
     private String ifProperty;
     private String unlessProperty;
 
+    public static final String XML_FORMATTER_CLASS_NAME =
+        "org.apache.tools.ant.taskdefs.optional.junit.XMLJUnitResultFormatter";
+    public static final String BRIEF_FORMATTER_CLASS_NAME =
+        "org.apache.tools.ant.taskdefs.optional.junit.BriefJUnitResultFormatter";
+    public static final String PLAIN_FORMATTER_CLASS_NAME =
+        "org.apache.tools.ant.taskdefs.optional.junit.PlainJUnitResultFormatter";
+
     /**
      * <p> Quick way to use a standard formatter.
      *
@@ -71,15 +78,13 @@ public class FormatterElement {
      */
     public void setType(TypeAttribute type) {
         if ("xml".equals(type.getValue())) {
-            setClassname("org.apache.tools.ant.taskdefs.optional.junit.XMLJUnitResultFormatter");
-            setExtension(".xml");
+            setClassname(XML_FORMATTER_CLASS_NAME);
         } else {
             if ("brief".equals(type.getValue())) {
-                setClassname("org.apache.tools.ant.taskdefs.optional.junit.BriefJUnitResultFormatter");
+                setClassname(BRIEF_FORMATTER_CLASS_NAME);
             } else { // must be plain, ensured by TypeAttribute
-                setClassname("org.apache.tools.ant.taskdefs.optional.junit.PlainJUnitResultFormatter");
+                setClassname(PLAIN_FORMATTER_CLASS_NAME);
             }
-            setExtension(".txt");
         }
     }
 
@@ -90,6 +95,13 @@ public class FormatterElement {
      */
     public void setClassname(String classname) {
         this.classname = classname;
+        if (XML_FORMATTER_CLASS_NAME.equals(classname)) {
+           setExtension(".xml");
+        } else if (PLAIN_FORMATTER_CLASS_NAME.equals(classname)) {
+           setExtension(".txt");
+        } else if (BRIEF_FORMATTER_CLASS_NAME.equals(classname)) {
+           setExtension(".txt");
+        }
     }
 
     /**

src/main/org/apache/tools/ant/taskdefs/optional/junit/JUnitTask.java

@@ -17,12 +17,21 @@
 
 package org.apache.tools.ant.taskdefs.optional.junit;
 
+import java.io.BufferedWriter;
 import java.io.File;
 import java.io.FileOutputStream;
+import java.io.FileWriter;
 import java.io.IOException;
 import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Enumeration;
+import java.util.HashMap;
 import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
 import java.util.Properties;
 import java.util.Vector;
 import org.apache.tools.ant.AntClassLoader;
@@ -138,13 +147,15 @@ public class JUnitTask extends Task {
     private File tmpDir;
     private AntClassLoader classLoader = null;
     private Permissions perm = null;
+    private ForkStyle forkStyle = new ForkStyle("perTest");
 
     private static final int STRING_BUFFER_SIZE = 128;
+
     /**
-    * If true, force ant to re-classload all classes for each JUnit TestCase
-    *
-    * @param value force class reloading for each test case
-    */
+     * If true, force ant to re-classload all classes for each JUnit TestCase
+     *
+     * @param value force class reloading for each test case
+     */
     public void setReloading(boolean value) {
         reloading = value;
     }
@@ -265,6 +276,29 @@ public class JUnitTask extends Task {
         }
     }
 
+    /**
+     * Set the bahvior when {@link #setFork fork} fork has been enabled.
+     *
+     * <p>Possible values are "once", "perTest" and "perBatch".  If
+     * set to "once", only a single Java VM will be forked for all
+     * tests, with "perTest" (the default) each test will run in a
+     * fresh Java VM and "perBatch" will run all tests from the same
+     * &lt;batchtest&gt; in the same Java VM.</p>
+     *
+     * <p>This attribute will be ignored if tests run in the same VM
+     * as Ant.</p>
+     *
+     * <p>Only tests with the same configuration of haltonerror,
+     * haltonfailure, errorproperty, failureproperty and filtertrace
+     * can share a forked Java VM, so even if you set the value to
+     * "once", Ant may need to fork mutliple VMs.</p>
+     *
+     * @since Ant 1.6.2
+     */
+    public void setForkStyle(ForkStyle style) {
+        this.forkStyle = style;
+    }
+
     /**
      * If true, print one-line statistics for each test, or "withOutAndErr"
      * to also show standard output and error.
@@ -599,12 +633,29 @@ public class JUnitTask extends Task {
      * @since Ant 1.2
      */
     public void execute() throws BuildException {
-        Enumeration list = getIndividualTests();
-        while (list.hasMoreElements()) {
-            JUnitTest test = (JUnitTest) list.nextElement();
-            if (test.shouldRun(getProject())) {
-                execute(test);
+        List testLists = new ArrayList();
+
+        boolean forkPerTest = forkStyle.getValue().equals(ForkStyle.PER_TEST);
+        if (forkPerTest || forkStyle.getValue().equals(ForkStyle.ONCE)) {
+            testLists.addAll(executeOrQueue(getIndividualTests(),
+                                            forkPerTest));
+        } else { /* forkStyle.getValue().equals(ForkStyle.PER_BATCH) */
+            final int count = batchTests.size();
+            for (int i = 0; i < count; i++) {
+                BatchTest batchtest = (BatchTest) batchTests.elementAt(i);
+                testLists.addAll(executeOrQueue(batchtest.elements(), false));
             }
+            testLists.addAll(executeOrQueue(tests.elements(), forkPerTest));
+        }
+
+        Iterator iter = testLists.iterator();
+        while (iter.hasNext()) {
+            List l = (List) iter.next();
+            if (l.size() == 1) {
+                execute((JUnitTest) l.get(0));
+            } else {
+                execute(l);
+            }            
         }
     }
 
@@ -632,34 +683,75 @@ public class JUnitTask extends Task {
             exitValue = executeInVM(test);
         } else {
             ExecuteWatchdog watchdog = createWatchdog();
-            exitValue = executeAsForked(test, watchdog);
+            exitValue = executeAsForked(test, watchdog, null);
             // null watchdog means no timeout, you'd better not check with null
             if (watchdog != null) {
                 wasKilled = watchdog.killedProcess();
             }
         }
+        actOnTestResult(exitValue, wasKilled, test, "Test " + test.getName());
+    }
 
-        // if there is an error/failure and that it should halt, stop
-        // everything otherwise just log a statement
-        boolean errorOccurredHere =
-            exitValue == JUnitTestRunner.ERRORS || wasKilled;
-        boolean failureOccurredHere =
-            exitValue != JUnitTestRunner.SUCCESS || wasKilled;
-        if (errorOccurredHere || failureOccurredHere) {
-            if ((errorOccurredHere && test.getHaltonerror())
-                || (failureOccurredHere && test.getHaltonfailure())) {
-                throw new BuildException("Test " + test.getName() + " failed"
-                    + (wasKilled ? " (timeout)" : ""), getLocation());
-            } else {
-                log("TEST " + test.getName() + " FAILED"
-                    + (wasKilled ? " (timeout)" : ""), Project.MSG_ERR);
-                if (errorOccurredHere && test.getErrorProperty() != null) {
-                    getProject().setNewProperty(test.getErrorProperty(), "true");
+    /**
+     * Execute a list of tests in a single forked Java VM.
+     */
+    protected void execute(List tests) throws BuildException {
+        JUnitTest test = null;
+        // Create a temporary file to pass the test cases to run to 
+        // the runner (one test case per line)
+        File casesFile = 
+            FileUtils.newFileUtils().createTempFile("junittestcases", 
+                                                    ".properties",
+                                                    getProject().getBaseDir());
+        casesFile.deleteOnExit();
+        PrintWriter writer = null;
+        try {
+            writer = 
+                new PrintWriter(new BufferedWriter(new FileWriter(casesFile)));
+            Iterator iter = tests.iterator();
+            while (iter.hasNext()) {
+                test = (JUnitTest) iter.next();
+                writer.print(test.getName()); 
+                if (test.getTodir() == null) {
+                    writer.print("," + getProject().resolveFile("."));
+                } else {
+                    writer.print("," + test.getTodir());
                 }
-                if (failureOccurredHere && test.getFailureProperty() != null) {
-                    getProject().setNewProperty(test.getFailureProperty(), "true");
+
+                if (test.getOutfile() == null) {
+                    writer.println("," + "TEST-" + test.getName());
+                } else {
+                    writer.println("," + test.getOutfile());
                 }
             }
+            writer.flush();
+            writer.close();
+            writer = null;
+
+            // execute the test and get the return code
+            int exitValue = JUnitTestRunner.ERRORS;
+            boolean wasKilled = false;
+            ExecuteWatchdog watchdog = createWatchdog();
+            exitValue = executeAsForked(test, watchdog, casesFile);
+            // null watchdog means no timeout, you'd better not check
+            // with null
+            if (watchdog != null) {
+                wasKilled = watchdog.killedProcess();
+            }
+            actOnTestResult(exitValue, wasKilled, test, "Tests");
+        } catch(IOException e) {
+            log(e.toString(), Project.MSG_ERR);
+            throw new BuildException(e);
+        } finally {
+            if (writer != null) {
+                writer.close();
+            }
+            
+            try {
+                casesFile.delete();
+            } catch (Exception e) {
+                log(e.toString(), Project.MSG_ERR);
+            }
         }
     }
 
@@ -674,17 +766,25 @@ public class JUnitTask extends Task {
      * @throws BuildException in case of error creating a temporary property file,
      * or if the junit process can not be forked
      */
-    private int executeAsForked(JUnitTest test, ExecuteWatchdog watchdog)
+    private int executeAsForked(JUnitTest test, ExecuteWatchdog watchdog, 
+                                File casesFile)
         throws BuildException {
 
-        if(perm != null) {
-            log("Permissions ignored when running in forked mode!", Project.MSG_WARN);
+        if (perm != null) {
+            log("Permissions ignored when running in forked mode!",
+                Project.MSG_WARN);
         }
 
         CommandlineJava cmd = (CommandlineJava) getCommandline().clone();
 
         cmd.setClassname("org.apache.tools.ant.taskdefs.optional.junit.JUnitTestRunner");
-        cmd.createArgument().setValue(test.getName());
+        if (casesFile == null) {
+            cmd.createArgument().setValue(test.getName());
+        } else {
+            log("Running multiple tests in the same VM", Project.MSG_VERBOSE);
+            cmd.createArgument().setValue("testsfile=" + casesFile);
+        }
+        
         cmd.createArgument().setValue("filtertrace=" + test.getFiltertrace());
         cmd.createArgument().setValue("haltOnError=" + test.getHaltonerror());
         cmd.createArgument().setValue("haltOnFailure="
@@ -1179,4 +1279,140 @@ public class JUnitTask extends Task {
         }
         return commandline;
     }
+
+    /**
+     * @since Ant 1.6.2
+     */
+    private final class ForkedTestConfiguration {
+        private boolean filterTrace;
+        private boolean haltOnError;
+        private boolean haltOnFailure;
+        private String errorProperty;
+        private String failureProperty;
+        ForkedTestConfiguration(boolean filterTrace, boolean haltOnError,
+                                boolean haltOnFailure, String errorProperty,
+                                String failureProperty) {
+            this.filterTrace = filterTrace;
+            this.haltOnError = haltOnError;
+            this.haltOnFailure = haltOnFailure;
+            this.errorProperty = errorProperty;
+            this.failureProperty = failureProperty;
+        }
+
+        public boolean equals(Object other) {
+            if (other == null 
+                || other.getClass() != ForkedTestConfiguration.class) {
+                return false;
+            }
+            ForkedTestConfiguration o = (ForkedTestConfiguration) other;
+            return filterTrace == o.filterTrace 
+                && haltOnError == o.haltOnError
+                && haltOnFailure == o.haltOnFailure
+                && ((errorProperty == null && o.errorProperty == null)
+                    || 
+                    (errorProperty != null 
+                     && errorProperty.equals(o.errorProperty)))
+                && ((failureProperty == null && o.failureProperty == null)
+                    || 
+                    (failureProperty != null 
+                     && failureProperty.equals(o.failureProperty)));
+        }
+
+        public int hashCode() {
+            return (filterTrace ? 1 : 0) 
+                + (haltOnError ? 2 : 0)
+                + (haltOnFailure ? 4 : 0);
+        }
+    }
+
+    /**
+     * @since 1.6.2
+     */
+    public static final class ForkStyle extends EnumeratedAttribute {
+        public static final String ONCE = "once";
+        public static final String PER_TEST = "perTest";
+        public static final String PER_BATCH = "perBatch";
+
+        public ForkStyle() {
+            super();
+        }
+
+        public ForkStyle(String value) {
+            super();
+            setValue(value);
+        }
+
+        public String[] getValues() {
+            return new String[] {ONCE, PER_TEST, PER_BATCH};
+        }
+    }
+
+    /**
+     * Executes all tests that don't need to be forked (or all tests
+     * if the runIndividual argument is true.  Returns a collection of
+     * lists of tests that share the same VM configuration and haven't
+     * been executed yet.
+     *
+     * @since 1.6.2
+     */
+    protected Collection executeOrQueue(Enumeration testList,
+                                        boolean runIndividual) {
+        Map testConfigurations = new HashMap();
+        while (testList.hasMoreElements()) {
+            JUnitTest test = (JUnitTest) testList.nextElement();
+            if (test.shouldRun(getProject())) {
+                if (runIndividual || !test.getFork()) {
+                    execute(test);
+                } else {
+                    ForkedTestConfiguration c =
+                        new ForkedTestConfiguration(test.getFiltertrace(),
+                                                    test.getHaltonerror(),
+                                                    test.getHaltonfailure(),
+                                                    test.getErrorProperty(),
+                                                    test.getFailureProperty());
+                    List l = (List) testConfigurations.get(c);
+                    if (l == null) {
+                        l = new ArrayList();
+                        testConfigurations.put(c, l);
+                    }
+                    l.add(test);
+                }
+            }
+        }
+        return testConfigurations.values();
+    }
+
+    /**
+     * Logs information about failed tests, potentially stops
+     * processing (by throwing a BuildException) if a failure/error
+     * occured or sets a property.
+     *
+     * @since Ant 1.6.2
+     */
+    protected void actOnTestResult(int exitValue, boolean wasKilled,
+                                   JUnitTest test, String name) {
+        // if there is an error/failure and that it should halt, stop
+        // everything otherwise just log a statement
+        boolean errorOccurredHere =
+            exitValue == JUnitTestRunner.ERRORS || wasKilled;
+        boolean failureOccurredHere =
+            exitValue != JUnitTestRunner.SUCCESS || wasKilled;
+        if (errorOccurredHere || failureOccurredHere) {
+            if ((errorOccurredHere && test.getHaltonerror())
+                || (failureOccurredHere && test.getHaltonfailure())) {
+                throw new BuildException(name + " failed"
+                    + (wasKilled ? " (timeout)" : ""), getLocation());
+            } else {
+                log(name + " FAILED"
+                    + (wasKilled ? " (timeout)" : ""), Project.MSG_ERR);
+                if (errorOccurredHere && test.getErrorProperty() != null) {
+                    getProject().setNewProperty(test.getErrorProperty(), "true");
+                }
+                if (failureOccurredHere && test.getFailureProperty() != null) {
+                    getProject().setNewProperty(test.getFailureProperty(), "true");
+                }
+            }
+        }
+    }
+
 }

src/main/org/apache/tools/ant/taskdefs/optional/junit/JUnitTestRunner.java

@@ -30,6 +30,7 @@ import java.lang.reflect.Method;
 import java.util.Enumeration;
 import java.util.Hashtable;
 import java.util.Properties;
+import java.util.StringTokenizer;
 import java.util.Vector;
 import junit.framework.AssertionFailedError;
 import junit.framework.Test;
@@ -154,6 +155,9 @@ public class JUnitTestRunner implements TestListener {
     /** is this runner running in forked mode? */
     private boolean forked = false;
 
+    /** Running more than one test suite? */
+    private static boolean multipleTests = false;
+
     /**
      * Constructor for fork=true or when the user hasn't specified a
      * classpath.
@@ -478,6 +482,11 @@ public class JUnitTestRunner implements TestListener {
             System.exit(ERRORS);
         }
 
+        if (args[0].startsWith("testsfile=")) {
+            multipleTests = true;
+            args[0] = args[0].substring(10 /* "testsfile=".length() */);
+        }
+
         for (int i = 1; i < args.length; i++) {
             if (args[i].startsWith("haltOnError=")) {
                 haltError = Project.toBoolean(args[i].substring(12));
@@ -502,30 +511,70 @@ public class JUnitTestRunner implements TestListener {
             }
         }
 
-        JUnitTest t = new JUnitTest(args[0]);
-
         // Add/overlay system properties on the properties from the Ant project
         Hashtable p = System.getProperties();
         for (Enumeration e = p.keys(); e.hasMoreElements();) {
             Object key = e.nextElement();
             props.put(key, p.get(key));
         }
-        t.setProperties(props);
 
-        JUnitTestRunner runner = new JUnitTestRunner(t, haltError, stackfilter,
-                                                     haltFail, showOut);
-        runner.forked = true;
-        transferFormatters(runner);
-        runner.run();
-        System.exit(runner.getRetCode());
+        int returnCode = SUCCESS;
+        if (multipleTests) {
+            try {
+                java.io.BufferedReader reader = 
+                    new java.io.BufferedReader(new java.io.FileReader(args[0]));
+                String testCaseName;
+                int code = 0;
+                boolean errorOccured = false;
+                boolean failureOccured = false;
+                String line = null;
+                while ((line = reader.readLine()) != null) {
+                    StringTokenizer st = new StringTokenizer(line, ",");
+                    testCaseName = st.nextToken();
+                    JUnitTest t = new JUnitTest(testCaseName);
+                    t.setTodir(new File(st.nextToken()));
+                    t.setOutfile(st.nextToken());
+                    code = launch(t, haltError, stackfilter, haltFail, 
+                                  showOut, props);
+                    errorOccured = (code == ERRORS);
+                    failureOccured = (code != SUCCESS);
+                    if (errorOccured || failureOccured ) {
+                        if ((errorOccured && haltError) 
+                            || (failureOccured && haltFail)) {
+                            System.exit(code);
+                        } else {
+                            if (code > returnCode) {
+                                returnCode = code;
+                            }
+                            System.out.println("TEST " + t.getName() 
+                                               + " FAILED");
+                        }
+                    }
+                }
+            } catch(IOException e) {
+                e.printStackTrace();
+            }
+        } else {
+            returnCode = launch(new JUnitTest(args[0]), haltError,
+                                stackfilter, haltFail, showOut, props);
+        }
+
+        System.exit(returnCode);
     }
 
     private static Vector fromCmdLine = new Vector();
 
-    private static void transferFormatters(JUnitTestRunner runner) {
+    private static void transferFormatters(JUnitTestRunner runner,
+                                           JUnitTest test) {
         for (int i = 0; i < fromCmdLine.size(); i++) {
-            runner.addFormatter((JUnitResultFormatter) fromCmdLine
-                                .elementAt(i));
+            FormatterElement fe = (FormatterElement) fromCmdLine.elementAt(i);
+            if (multipleTests && fe.getUseFile()) {
+                File destFile = 
+                    new File(test.getTodir(), 
+                             test.getOutfile() + fe.getExtension());
+                fe.setOutfile(destFile);
+            }
+            runner.addFormatter(fe.createFormatter());
         }
     }
 
@@ -538,17 +587,20 @@ public class JUnitTestRunner implements TestListener {
         int pos = line.indexOf(',');
         if (pos == -1) {
             fe.setClassname(line);
+            fe.setUseFile(false);
         } else {
             fe.setClassname(line.substring(0, pos));
-            fe.setOutfile(new File(line.substring(pos + 1)));
+            fe.setUseFile(true);
+            if (!multipleTests) {
+                fe.setOutfile(new File(line.substring(pos + 1)));
+            }
         }
-        fromCmdLine.addElement(fe.createFormatter());
+        fromCmdLine.addElement(fe);
     }
 
     /**
      * Returns a filtered stack trace.
      * This is ripped out of junit.runner.BaseTestRunner.
-     * Scott M. Stirling.
      */
     public static String getFilteredTrace(Throwable t) {
         String trace = StringUtils.getStackTrace(t);
@@ -589,4 +641,19 @@ public class JUnitTestRunner implements TestListener {
         return false;
     }
 
+    /**
+     * @since Ant 1.6.2
+     */
+    private static int launch(JUnitTest t, boolean haltError,
+                              boolean stackfilter, boolean haltFail, 
+                              boolean showOut, Properties props) {
+        t.setProperties(props);
+        JUnitTestRunner runner = 
+            new JUnitTestRunner(t, haltError, stackfilter, haltFail, showOut);
+        runner.forked = true;
+        transferFormatters(runner, t);
+
+        runner.run();
+        return runner.getRetCode();
+     }
 } // JUnitTestRunner