Parallel support

android/src/main/java/cucumber/runtime/formatter/AndroidInstrumentationReporter.java

@@ -83,27 +83,8 @@ static class StatusCodes {
      */
     private int numberOfTests;
 
-    /**
-     * The severest step result of the current test execution.
-     * This might be a step or hook result.
-     */
-    private Result severestResult;
-
-    /**
-     * The uri of the feature file of the current test case.
-     */
-    private String currentUri;
-
-    /**
-     * The name of the current feature.
-     */
-    private String currentFeatureName;
-
-    /**
-     * The name of the current test case.
-     */
-    private String currentTestCaseName;
-
+    private ThreadLocal<CurrentFeature> featureUnderTest = new ThreadLocal<CurrentFeature>();
+
     /**
      * The event handler for the {@link TestSourceRead} events.
      */
@@ -172,40 +153,43 @@ void testSourceRead(final TestSourceRead event) {
     }
 
     void startTestCase(final TestCase testCase) {
-        if (!testCase.getUri().equals(currentUri)) {
-            currentUri = testCase.getUri();
-            currentFeatureName = testSources.getFeatureName(currentUri);
+        CurrentFeature currentFeature = featureUnderTest.get();
+        if (currentFeature == null || !testCase.getUri().equals(currentFeature.uri)) {
+            currentFeature = new CurrentFeature(testCase.getUri(), testSources.getFeatureName(testCase.getUri()));
+            featureUnderTest.set(currentFeature);
         }
         // Since the names of test cases are not guaranteed to be unique, we must check for unique names
-        currentTestCaseName = calculateUniqueTestName(testCase);
-        resetSeverestResult();
-        final Bundle testStart = createBundle(currentFeatureName, currentTestCaseName);
+        currentFeature.testCaseName = calculateUniqueTestName(testCase);
+        currentFeature.resetSeverestResult();
+        final Bundle testStart = createBundle(currentFeature.featureName, currentFeature.testCaseName);
         instrumentation.sendStatus(StatusCodes.START, testStart);
     }
 
     void finishTestStep(final Result result) {
-        checkAndSetSeverestStepResult(result);
+        CurrentFeature currentFeature = featureUnderTest.get();
+        currentFeature.checkAndSetSeverestStepResult(result);
     }
 
     void finishTestCase() {
-        final Bundle testResult = createBundle(currentFeatureName, currentTestCaseName);
+        final CurrentFeature currentFeature = featureUnderTest.get();
+        final Bundle testResult = createBundle(currentFeature.featureName, currentFeature.testCaseName);
 
-        switch (severestResult.getStatus()) {
+        switch (currentFeature.severestResult.getStatus()) {
             case FAILED:
-                if (severestResult.getError() instanceof AssertionError) {
-                    testResult.putString(StatusKeys.STACK, severestResult.getErrorMessage());
+                if (currentFeature.severestResult.getError() instanceof AssertionError) {
+                    testResult.putString(StatusKeys.STACK, currentFeature.severestResult.getErrorMessage());
                     instrumentation.sendStatus(StatusCodes.FAILURE, testResult);
                 } else {
-                    testResult.putString(StatusKeys.STACK, getStackTrace(severestResult.getError()));
+                    testResult.putString(StatusKeys.STACK, getStackTrace(currentFeature.severestResult.getError()));
                     instrumentation.sendStatus(StatusCodes.ERROR, testResult);
                 }
                 break;
             case AMBIGUOUS:
-                testResult.putString(StatusKeys.STACK, getStackTrace(severestResult.getError()));
+                testResult.putString(StatusKeys.STACK, getStackTrace(currentFeature.severestResult.getError()));
                 instrumentation.sendStatus(StatusCodes.ERROR, testResult);
                 break;
             case PENDING:
-                testResult.putString(StatusKeys.STACK, severestResult.getErrorMessage());
+                testResult.putString(StatusKeys.STACK, currentFeature.severestResult.getErrorMessage());
                 instrumentation.sendStatus(StatusCodes.ERROR, testResult);
                 break;
             case PASSED:
@@ -217,7 +201,7 @@ void finishTestCase() {
                 instrumentation.sendStatus(StatusCodes.ERROR, testResult);
                 break;
             default:
-                throw new IllegalStateException("Unexpected result status: " + severestResult.getStatus());
+                throw new IllegalStateException("Unexpected result status: " + currentFeature.severestResult.getStatus());
         }
     }
 
@@ -245,33 +229,6 @@ private String getLastSnippet() {
         return runtime.getSnippets().get(runtime.getSnippets().size() - 1);
     }
 
-    /**
-     * Resets the severest test result for the next scenario life cycle.
-     */
-    private void resetSeverestResult() {
-        severestResult = null;
-    }
-
-    /**
-     * Checks if the given {@code result} is more severe than the current {@code severestResult} and
-     * updates the {@code severestResult} if that should be the case.
-     *
-     * @param result the {@link Result} to check
-     */
-    private void checkAndSetSeverestStepResult(final Result result) {
-        final boolean firstResult = severestResult == null;
-        if (firstResult) {
-            severestResult = result;
-            return;
-        }
-
-        final boolean currentIsPassed = severestResult.is(Result.Type.PASSED);
-        final boolean nextIsNotPassed = !result.is(Result.Type.PASSED);
-        if (currentIsPassed && nextIsNotPassed) {
-            severestResult = result;
-        }
-    }
-
     /**
      * Creates a string representation of the given {@code throwable}'s stacktrace.
      *
@@ -331,4 +288,43 @@ private String calculateUniqueTestName(TestCase testCase) {
         return uniqueTestNameForTestCase.get(testCase);
     }
 
+    private class CurrentFeature {
+        private final String uri;
+        private final String featureName;
+        private String testCaseName;
+        private Result severestResult;
+
+        CurrentFeature(final String uri, final String featureName) {
+            this.uri = uri;
+            this.featureName = featureName;
+        }
+
+        /**
+         * Resets the severest test result for the next scenario life cycle.
+         */
+        private void resetSeverestResult() {
+            severestResult = null;
+        }
+
+        /**
+         * Checks if the given {@code result} is more severe than the current {@code severestResult} and
+         * updates the {@code severestResult} if that should be the case.
+         *
+         * @param result the {@link Result} to check
+         */
+        private void checkAndSetSeverestStepResult(final Result result) {
+            final boolean firstResult = severestResult == null;
+            if (firstResult) {
+                severestResult = result;
+                return;
+            }
+
+            final boolean currentIsPassed = severestResult.is(Result.Type.PASSED);
+            final boolean nextIsNotPassed = !result.is(Result.Type.PASSED);
+            if (currentIsPassed && nextIsNotPassed) {
+                severestResult = result;
+            }
+        }
+    }
+
 }

core/pom.xml

@@ -64,6 +64,13 @@
             <artifactId>webbit-rest</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.hamcrest</groupId>
+            <artifactId>hamcrest-junit</artifactId>
+            <version>2.0.0.0</version>
+            <scope>test</scope>
+        </dependency>
+
     </dependencies>
 
     <build>

core/src/main/java/cucumber/api/CucumberOptions.java

@@ -63,4 +63,8 @@
      */
     String[] junit() default {};
 
+    /**
+     * @return the number of parallel threads to run scenarios
+     */
+    int threads() default 1;
 }

core/src/main/java/cucumber/api/event/TestGroupRunFinished.java

@@ -0,0 +1,15 @@
+package cucumber.api.event;
+
+public class TestGroupRunFinished extends TimeStampedEvent {
+
+    private final String type;
+
+    public TestGroupRunFinished(final String type, final Long timeStamp) {
+        super(timeStamp);
+        this.type = type;
+    }
+
+    public String getType() {
+        return type;
+    }
+}

core/src/main/java/cucumber/api/event/TestGroupRunStarted.java

@@ -0,0 +1,27 @@
+package cucumber.api.event;
+
+public class TestGroupRunStarted extends TimeStampedEvent {
+
+    private final String type;
+    private final int threadCount;
+    private final int featureCount;
+
+    public TestGroupRunStarted(final String type, final int threadCount, final int featureCount, final Long timeStamp) {
+        super(timeStamp);
+        this.type = type;
+        this.threadCount = threadCount;
+        this.featureCount = featureCount;
+    }
+
+    public String getType() {
+        return type;
+    }
+
+    public int getThreadCount() {
+        return threadCount;
+    }
+
+    public int getFeatureCount() {
+        return featureCount;
+    }
+}

core/src/main/java/cucumber/api/formatter/Formatter.java

@@ -7,6 +7,8 @@
  * This is the interface you should implement if you want your own custom
  * formatter.
  *
+ * <b>NOTE: Implementations should be threadsafe to support '--threads' parameter</b>
+ *
  * @see EventListener
  * @see Plugin
  */

core/src/main/java/cucumber/api/formatter/NiceRetrievableAppendable.java

@@ -0,0 +1,15 @@
+package cucumber.api.formatter;
+
+public class NiceRetrievableAppendable extends NiceAppendable {
+
+    private final StringBuilder builder;
+
+    public NiceRetrievableAppendable(StringBuilder out) {
+        super(out);
+        this.builder = out;
+    }
+
+    public String printAll() {
+        return builder.toString();
+    }
+}

core/src/main/java/cucumber/runner/DefaultUnreportedStepExecutor.java

@@ -0,0 +1,53 @@
+package cucumber.runner;
+
+import cucumber.runtime.Glue;
+import cucumber.runtime.StepDefinitionMatch;
+import cucumber.runtime.UnreportedStepExecutor;
+import gherkin.pickles.Argument;
+import gherkin.pickles.PickleLocation;
+import gherkin.pickles.PickleRow;
+import gherkin.pickles.PickleStep;
+import gherkin.pickles.PickleString;
+import gherkin.pickles.PickleTable;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+//TODO: hmm not so sure about the Glue reference as have cloned() it since, but without some real usages I'm not sure at this point
+public class DefaultUnreportedStepExecutor implements UnreportedStepExecutor {
+
+    private final Glue glue;
+
+    public DefaultUnreportedStepExecutor(final Glue glue) {
+        this.glue = glue;
+    }
+
+    //TODO: Maybe this should go into the cucumber step execution model and it should return the result of that execution!
+    @Override
+    public void runUnreportedStep(final String featurePath, final String language, 
+                                  final String stepName, final int line, 
+                                  final List<PickleRow> dataTableRows, final PickleString docString) throws Throwable {
+        List<Argument> arguments = new ArrayList<Argument>();
+        if (dataTableRows != null && !dataTableRows.isEmpty()) {
+            arguments.add(new PickleTable(dataTableRows));
+        } else if (docString != null) {
+            arguments.add(docString);
+        }
+        PickleStep step = new PickleStep(stepName, arguments, Collections.<PickleLocation>emptyList());
+
+        StepDefinitionMatch match = glue.stepDefinitionMatch(featurePath, step);
+        if (match == null) {
+            UndefinedStepException error = new UndefinedStepException(step);
+
+            StackTraceElement[] originalTrace = error.getStackTrace();
+            StackTraceElement[] newTrace = new StackTraceElement[originalTrace.length + 1];
+            newTrace[0] = new StackTraceElement("✽", "StepDefinition", featurePath, line);
+            System.arraycopy(originalTrace, 0, newTrace, 1, originalTrace.length);
+            error.setStackTrace(newTrace);
+
+            throw error;
+        }
+        match.runStep(language, null);
+    }
+}