[JUnit] Updated junit for the use of Gherkin v4.0.0.

Author: brasmusson

junit/src/main/java/cucumber/api/junit/Cucumber.java

@@ -1,6 +1,8 @@
 package cucumber.api.junit;
 
 import cucumber.api.CucumberOptions;
+import cucumber.api.event.TestRunFinished;
+import cucumber.api.formatter.Formatter;
 import cucumber.runtime.ClassFinder;
 import cucumber.runtime.Runtime;
 import cucumber.runtime.RuntimeOptions;
@@ -21,6 +23,8 @@
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
+import java.util.regex.Pattern;
 
 /**
  * <p>
@@ -39,6 +43,7 @@ public class Cucumber extends ParentRunner<FeatureRunner> {
     private final JUnitReporter jUnitReporter;
     private final List<FeatureRunner> children = new ArrayList<FeatureRunner>();
     private final Runtime runtime;
+    private final Formatter formatter;
 
     /**
      * Constructor called by JUnit.
@@ -57,10 +62,10 @@ public Cucumber(Class clazz) throws InitializationError, IOException {
 
         ResourceLoader resourceLoader = new MultiLoader(classLoader);
         runtime = createRuntime(resourceLoader, classLoader, runtimeOptions);
-
+        formatter = runtimeOptions.formatter(classLoader);
         final JUnitOptions junitOptions = new JUnitOptions(runtimeOptions.getJunitOptions());
-        final List<CucumberFeature> cucumberFeatures = runtimeOptions.cucumberFeatures(resourceLoader);
-        jUnitReporter = new JUnitReporter(runtimeOptions.reporter(classLoader), runtimeOptions.formatter(classLoader), runtimeOptions.isStrict(), junitOptions);
+        final List<CucumberFeature> cucumberFeatures = runtimeOptions.cucumberFeatures(resourceLoader, runtime.getEventBus());
+        jUnitReporter = new JUnitReporter(runtime.getEventBus(), runtimeOptions.isStrict(), junitOptions);
         addChildren(cucumberFeatures);
     }
 
@@ -98,14 +103,16 @@ protected void runChild(FeatureRunner child, RunNotifier notifier) {
     @Override
     public void run(RunNotifier notifier) {
         super.run(notifier);
-        jUnitReporter.done();
-        jUnitReporter.close();
+        runtime.getEventBus().send(new TestRunFinished());
         runtime.printSummary();
     }
 
     private void addChildren(List<CucumberFeature> cucumberFeatures) throws InitializationError {
         for (CucumberFeature cucumberFeature : cucumberFeatures) {
-            children.add(new FeatureRunner(cucumberFeature, runtime, jUnitReporter));
+            FeatureRunner featureRunner = new FeatureRunner(cucumberFeature, runtime, jUnitReporter);
+            if (!featureRunner.isEmpty()) {
+                children.add(featureRunner);
+            }
         }
     }
 }

junit/src/main/java/cucumber/runtime/junit/ExamplesRunner.java

@@ -1,48 +1,45 @@
 package cucumber.runtime.junit;
 
-import cucumber.runtime.Runtime;
-import cucumber.runtime.model.CucumberScenario;
-import gherkin.formatter.model.Step;
+import cucumber.runner.Runner;
+import gherkin.pickles.Pickle;
+import gherkin.pickles.PickleStep;
 import org.junit.runner.Description;
 import org.junit.runner.notification.RunNotifier;
 import org.junit.runners.ParentRunner;
 import org.junit.runners.model.InitializationError;
 
-import java.util.ArrayList;
+import java.io.Serializable;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
 /**
  * Runs a scenario, or a "synthetic" scenario derived from an Examples row.
  */
-public class ExecutionUnitRunner extends ParentRunner<Step> {
-    private final Runtime runtime;
-    private final CucumberScenario cucumberScenario;
+public class ExecutionUnitRunner extends ParentRunner<PickleStep> {
+    private final Runner runner;
+    private final Pickle pickle;
+    private final String language;
     private final JUnitReporter jUnitReporter;
+    private final Map<PickleStep, Description> stepDescriptions = new HashMap<PickleStep, Description>();
     private Description description;
-    private final Map<Step, Description> stepDescriptions = new HashMap<Step, Description>();
-    private final List<Step> runnerSteps = new ArrayList<Step>();
 
-    public ExecutionUnitRunner(Runtime runtime, CucumberScenario cucumberScenario, JUnitReporter jUnitReporter) throws InitializationError {
+    public ExecutionUnitRunner(Runner runner, Pickle pickle, String language, JUnitReporter jUnitReporter) throws InitializationError {
         super(ExecutionUnitRunner.class);
-        this.runtime = runtime;
-        this.cucumberScenario = cucumberScenario;
+        this.runner = runner;
+        this.pickle = pickle;
+        this.language = language;
         this.jUnitReporter = jUnitReporter;
     }
 
-    public List<Step> getRunnerSteps() {
-    	return runnerSteps;
-    }
-
     @Override
-    protected List<Step> getChildren() {
-        return cucumberScenario.getSteps();
+    protected List<PickleStep> getChildren() {
+        return pickle.getSteps();
     }
 
     @Override
     public String getName() {
-        String name = cucumberScenario.getVisualName();
+        String name = pickle.getName();
         if (jUnitReporter.useFilenameCompatibleNames()) {
             return makeNameFilenameCompatible(name);
         } else {
@@ -53,43 +50,27 @@ public String getName() {
     @Override
     public Description getDescription() {
         if (description == null) {
-            description = Description.createSuiteDescription(getName(), cucumberScenario.getGherkinModel());
-
-            if (cucumberScenario.getCucumberBackground() != null) {
-                for (Step backgroundStep : cucumberScenario.getCucumberBackground().getSteps()) {
-                    // We need to make a copy of that step, so we have a unique one per scenario
-                    Step copy = new Step(
-                            backgroundStep.getComments(),
-                            backgroundStep.getKeyword(),
-                            backgroundStep.getName(),
-                            backgroundStep.getLine(),
-                            backgroundStep.getRows(),
-                            backgroundStep.getDocString()
-                    );
-                    description.addChild(describeChild(copy));
-                    runnerSteps.add(copy);
-                }
-            }
+            String nameForDescription = getName().isEmpty() ? "EMPTY_NAME" : getName();
+            description = Description.createSuiteDescription(nameForDescription, new PickleWrapper(pickle));
 
-            for (Step step : getChildren()) {
+            for (PickleStep step : getChildren()) {
                 description.addChild(describeChild(step));
-                runnerSteps.add(step);
             }
         }
         return description;
     }
 
     @Override
-    protected Description describeChild(Step step) {
+    protected Description describeChild(PickleStep step) {
         Description description = stepDescriptions.get(step);
         if (description == null) {
             String testName;
             if (jUnitReporter.useFilenameCompatibleNames()) {
-                testName = makeNameFilenameCompatible(step.getKeyword() + step.getName());
+                testName = makeNameFilenameCompatible(step.getText());
             } else {
-                testName = step.getKeyword() + step.getName();
+                testName = step.getText();
             }
-            description = Description.createTestDescription(getName(), testName, step);
+            description = Description.createTestDescription(getName(), testName, new PickleStepWrapper(step));
             stepDescriptions.put(step, description);
         }
         return description;
@@ -99,12 +80,12 @@ protected Description describeChild(Step step) {
     public void run(final RunNotifier notifier) {
         jUnitReporter.startExecutionUnit(this, notifier);
         // This causes runChild to never be called, which seems OK.
-        cucumberScenario.run(jUnitReporter, jUnitReporter, runtime);
+        runner.runPickle(pickle, language);
         jUnitReporter.finishExecutionUnit();
     }
 
     @Override
-    protected void runChild(Step step, RunNotifier notifier) {
+    protected void runChild(PickleStep step, RunNotifier notifier) {
         // The way we override run(RunNotifier) causes this method to never be called.
         // Instead it happens via cucumberScenario.run(jUnitReporter, jUnitReporter, runtime);
         throw new UnsupportedOperationException();
@@ -115,3 +96,21 @@ private String makeNameFilenameCompatible(String name) {
         return name.replaceAll("[^A-Za-z0-9_]", "_");
     }
 }
+
+class PickleWrapper implements Serializable {
+    private static final long serialVersionUID = 1L;
+    private Pickle pickle;
+
+    public PickleWrapper(Pickle pickle) {
+        this.pickle = pickle;
+    }
+}
+
+class PickleStepWrapper implements Serializable {
+    private static final long serialVersionUID = 1L;
+    private PickleStep step;
+
+    public PickleStepWrapper(PickleStep step) {
+        this.step = step;
+    }
+}

junit/src/main/java/cucumber/runtime/junit/ExecutionUnitRunner.java

@@ -3,10 +3,9 @@
 import cucumber.runtime.CucumberException;
 import cucumber.runtime.Runtime;
 import cucumber.runtime.model.CucumberFeature;
-import cucumber.runtime.model.CucumberScenario;
-import cucumber.runtime.model.CucumberScenarioOutline;
-import cucumber.runtime.model.CucumberTagStatement;
-import gherkin.formatter.model.Feature;
+import gherkin.ast.Feature;
+import gherkin.pickles.Compiler;
+import gherkin.pickles.Pickle;
 import org.junit.runner.Description;
 import org.junit.runner.notification.RunNotifier;
 import org.junit.runners.ParentRunner;
@@ -19,35 +18,35 @@ public class FeatureRunner extends ParentRunner<ParentRunner> {
     private final List<ParentRunner> children = new ArrayList<ParentRunner>();
 
     private final CucumberFeature cucumberFeature;
-    private final Runtime runtime;
-    private final JUnitReporter jUnitReporter;
     private Description description;
 
     public FeatureRunner(CucumberFeature cucumberFeature, Runtime runtime, JUnitReporter jUnitReporter) throws InitializationError {
         super(null);
         this.cucumberFeature = cucumberFeature;
-        this.runtime = runtime;
-        this.jUnitReporter = jUnitReporter;
-        buildFeatureElementRunners();
+        buildFeatureElementRunners(runtime, jUnitReporter);
     }
 
     @Override
     public String getName() {
-        Feature feature = cucumberFeature.getGherkinFeature();
+        Feature feature = cucumberFeature.getGherkinFeature().getFeature();
         return feature.getKeyword() + ": " + feature.getName();
     }
 
     @Override
     public Description getDescription() {
         if (description == null) {
-            description = Description.createSuiteDescription(getName(), cucumberFeature.getGherkinFeature());
+            description = Description.createSuiteDescription(getName(), cucumberFeature);
             for (ParentRunner child : getChildren()) {
                 description.addChild(describeChild(child));
             }
         }
         return description;
     }
 
+    public boolean isEmpty() {
+        return children.isEmpty();
+    }
+
     @Override
     protected List<ParentRunner> getChildren() {
         return children;
@@ -65,24 +64,21 @@ protected void runChild(ParentRunner child, RunNotifier notifier) {
 
     @Override
     public void run(RunNotifier notifier) {
-        jUnitReporter.uri(cucumberFeature.getPath());
-        jUnitReporter.feature(cucumberFeature.getGherkinFeature());
         super.run(notifier);
-        jUnitReporter.eof();
     }
 
-    private void buildFeatureElementRunners() {
-        for (CucumberTagStatement cucumberTagStatement : cucumberFeature.getFeatureElements()) {
-            try {
-                ParentRunner featureElementRunner;
-                if (cucumberTagStatement instanceof CucumberScenario) {
-                    featureElementRunner = new ExecutionUnitRunner(runtime, (CucumberScenario) cucumberTagStatement, jUnitReporter);
-                } else {
-                    featureElementRunner = new ScenarioOutlineRunner(runtime, (CucumberScenarioOutline) cucumberTagStatement, jUnitReporter);
+    private void buildFeatureElementRunners(Runtime runtime, JUnitReporter jUnitReporter) {
+        Compiler compiler = new Compiler();
+        List<Pickle> pickles = compiler.compile(cucumberFeature.getGherkinFeature(), cucumberFeature.getPath());
+        for (Pickle pickle : pickles) {
+            if (runtime.matchesFilters(pickle)) {
+                try {
+                    ParentRunner pickleRunner;
+                    pickleRunner = new ExecutionUnitRunner(runtime.getRunner(), pickle, cucumberFeature.getLanguage(), jUnitReporter);
+                    children.add(pickleRunner);
+                } catch (InitializationError e) {
+                    throw new CucumberException("Failed to create scenario runner", e);
                 }
-                children.add(featureElementRunner);
-            } catch (InitializationError e) {
-                throw new CucumberException("Failed to create scenario runner", e);
             }
         }
     }

junit/src/main/java/cucumber/runtime/junit/FeatureRunner.java

@@ -1,7 +1,7 @@
 package cucumber.runtime.junit;
 
 import cucumber.runtime.CucumberException;
-import gherkin.util.FixJava;
+import cucumber.util.FixJava;
 
 import java.io.InputStreamReader;
 import java.io.Reader;