[JUnit] Implement Cucumber as a Junit Platform Engine

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

@@ -4,6 +4,7 @@
 import cucumber.runtime.CucumberException;
 import cucumber.runtime.StepDefinition;
 import cucumber.runtime.StepDefinitionMatch;
+import gherkin.pickles.PickleLocation;
 import gherkin.pickles.PickleStep;
 import io.cucumber.cucumberexpressions.CucumberExpressionException;
 import io.cucumber.datatable.CucumberDataTableException;
@@ -15,10 +16,8 @@
 
 class PickleStepDefinitionMatch extends Match implements StepDefinitionMatch {
     private final StepDefinition stepDefinition;
-    private final transient String featurePath;
-    // The official JSON gherkin format doesn't have a step attribute, so we're marking this as transient
-    // to prevent it from ending up in the JSON.
-    private final transient PickleStep step;
+    private final String featurePath;
+    private final PickleStep step;
 
     public PickleStepDefinitionMatch(List<Argument> arguments, StepDefinition stepDefinition, String featurePath, PickleStep step) {
         super(arguments, stepDefinition.getLocation(false));
@@ -148,12 +147,17 @@ StepDefinition getStepDefinition() {
         return stepDefinition;
     }
 
+    PickleStep getStep() {
+        return step;
+    }
+
     @Override
     public String getCodeLocation() {
         return stepDefinition.getLocation(false);
     }
 
     private static int getStepLine(PickleStep step) {
-        return step.getLocations().get(step.getLocations().size() - 1).getLine();
+        List<PickleLocation> locations = step.getLocations();
+        return locations.get(locations.size() - 1).getLine();
     }
 }

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

@@ -80,7 +80,7 @@ private void addTestStepsForPickleSteps(List<PickleStepTestStep> testSteps, Pick
                     if (!snippets.isEmpty()) {
                         bus.send(new SnippetsSuggestedEvent(bus.getTime(), pickleEvent.uri, step.getLocations(), snippets));
                     }
-                    match = new UndefinedPickleStepDefinitionMatch(step);
+                    match = new UndefinedPickleStepDefinitionMatch(pickleEvent.uri, step);
                 }
             } catch (AmbiguousStepDefinitionsException e) {
                 match = new AmbiguousPickleStepDefinitionsMatch(pickleEvent.uri, step, e);

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

@@ -13,7 +13,8 @@ abstract class TestStep implements cucumber.api.TestStep {
     private static final String[] ASSUMPTION_VIOLATED_EXCEPTIONS = {
         "org.junit.AssumptionViolatedException",
         "org.junit.internal.AssumptionViolatedException",
-        "org.testng.SkipException"
+        "org.testng.SkipException",
+        "org.opentest4j.TestAbortedException"
     };
 
     static {
@@ -85,9 +86,6 @@ private Result.Type mapThrowableToStatus(Throwable t) {
     }
 
     private Result mapStatusToResult(Result.Type status, Throwable error, long duration) {
-        if (status == Result.Type.UNDEFINED) {
-            return Result.UNDEFINED;
-        }
         return new Result(status, duration, error);
     }
 }

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

@@ -1,24 +1,30 @@
 package cucumber.runner;
 
-import io.cucumber.stepexpression.Argument;
 import cucumber.api.Scenario;
 import gherkin.pickles.PickleStep;
+import io.cucumber.stepexpression.Argument;
 
 import java.util.Collections;
 
 class UndefinedPickleStepDefinitionMatch extends PickleStepDefinitionMatch {
 
-    UndefinedPickleStepDefinitionMatch(PickleStep step) {
-        super(Collections.<Argument>emptyList(), new NoStepDefinition(), null, step);
+    UndefinedPickleStepDefinitionMatch(String uri, PickleStep step) {
+        super(Collections.<Argument>emptyList(), new NoStepDefinition(), uri, step);
     }
 
     @Override
     public void runStep(Scenario scenario) {
-        throw new UndefinedStepDefinitionException();
+        throw createUndefinedStepDefinitionException();
+    }
+
+    private UndefinedStepDefinitionException createUndefinedStepDefinitionException() {
+        UndefinedStepDefinitionException undefined = new UndefinedStepDefinitionException(getStep().getText());
+        undefined.setStackTrace(new StackTraceElement[]{getStepLocation()});
+        return undefined;
     }
 
     @Override
-    public void dryRunStep(Scenario scenario) throws Throwable {
+    public void dryRunStep(Scenario scenario) {
         runStep(scenario);
     }
 

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

@@ -1,10 +1,8 @@
 package cucumber.runner;
 
-import cucumber.runtime.CucumberException;
+final class UndefinedStepDefinitionException extends RuntimeException {
 
-final class UndefinedStepDefinitionException extends CucumberException {
-
-    UndefinedStepDefinitionException() {
-        super("No step definitions found");
+    UndefinedStepDefinitionException(String stepText) {
+        super("Step not defined: '" + stepText + "'");
     }
 }

core/src/main/java/cucumber/runtime/DefaultTypeRegistryConfiguration.java

@@ -5,7 +5,7 @@
 
 import java.util.Locale;
 
-public class DefaultTypeRegistryConfiguration implements TypeRegistryConfigurer {
+class DefaultTypeRegistryConfiguration implements TypeRegistryConfigurer {
 
     @Override
     public Locale locale() {

core/src/main/java/cucumber/runtime/formatter/JSONFormatter.java

@@ -144,7 +144,7 @@ private void handleTestStepStarted(TestStepStarted event) {
                 currentBeforeStepHookList.clear();
             }
             currentStepsList.add(currentStepOrHookMap);
-        } else if(event.testStep instanceof HookTestStep) {
+        } else if (event.testStep instanceof HookTestStep) {
             HookTestStep hookTestStep = (HookTestStep) event.testStep;
             currentStepOrHookMap = createHookStep(hookTestStep);
             addHookStepToTestCaseMap(currentStepOrHookMap, hookTestStep.getHookType());
@@ -262,7 +262,7 @@ private Map<String, Object> createTestStep(PickleStepTestStep testStep) {
 
     private Map<String, Object> createDocStringMap(Argument argument) {
         Map<String, Object> docStringMap = new HashMap<String, Object>();
-        PickleString docString = ((PickleString)argument);
+        PickleString docString = ((PickleString) argument);
         docStringMap.put("value", docString.getContent());
         docStringMap.put("line", docString.getLocation().getLine());
         docStringMap.put("content_type", docString.getContentType());
@@ -271,7 +271,7 @@ private Map<String, Object> createDocStringMap(Argument argument) {
 
     private List<Map<String, Object>> createDataTableList(Argument argument) {
         List<Map<String, Object>> rowList = new ArrayList<Map<String, Object>>();
-        for (PickleRow row : ((PickleTable)argument).getRows()) {
+        for (PickleRow row : ((PickleTable) argument).getRows()) {
             Map<String, Object> rowMap = new HashMap<String, Object>();
             rowMap.put("cells", createCellList(row));
             rowList.add(rowMap);
@@ -313,29 +313,29 @@ private void addHookStepToTestCaseMap(Map<String, Object> currentStepOrHookMap,
             case AfterStep:
                 mapToAddTo = currentStepsList.get(currentStepsList.size() - 1);
                 break;
-             default:
-                 mapToAddTo = currentTestCaseMap;
+            default:
+                mapToAddTo = currentTestCaseMap;
         }
 
         if (!mapToAddTo.containsKey(hookName)) {
             mapToAddTo.put(hookName, new ArrayList<Map<String, Object>>());
         }
-        ((List<Map<String, Object>>)mapToAddTo.get(hookName)).add(currentStepOrHookMap);
+        ((List<Map<String, Object>>) mapToAddTo.get(hookName)).add(currentStepOrHookMap);
     }
 
     private void addOutputToHookMap(String text) {
         if (!currentStepOrHookMap.containsKey("output")) {
             currentStepOrHookMap.put("output", new ArrayList<String>());
         }
-        ((List<String>)currentStepOrHookMap.get("output")).add(text);
+        ((List<String>) currentStepOrHookMap.get("output")).add(text);
     }
 
     private void addEmbeddingToHookMap(byte[] data, String mimeType) {
         if (!currentStepOrHookMap.containsKey("embeddings")) {
             currentStepOrHookMap.put("embeddings", new ArrayList<Map<String, Object>>());
         }
         Map<String, Object> embedMap = createEmbeddingMap(data, mimeType);
-        ((List<Map<String, Object>>)currentStepOrHookMap.get("embeddings")).add(embedMap);
+        ((List<Map<String, Object>>) currentStepOrHookMap.get("embeddings")).add(embedMap);
     }
 
     private Map<String, Object> createEmbeddingMap(byte[] data, String mimeType) {
@@ -347,7 +347,7 @@ private Map<String, Object> createEmbeddingMap(byte[] data, String mimeType) {
 
     private Map<String, Object> createMatchMap(TestStep step, Result result) {
         Map<String, Object> matchMap = new HashMap<String, Object>();
-        if(step instanceof PickleStepTestStep) {
+        if (step instanceof PickleStepTestStep) {
             PickleStepTestStep testStep = (PickleStepTestStep) step;
             if (!testStep.getDefinitionArgument().isEmpty()) {
                 List<Map<String, Object>> argumentList = new ArrayList<Map<String, Object>>();
@@ -371,11 +371,13 @@ private Map<String, Object> createMatchMap(TestStep step, Result result) {
     private Map<String, Object> createResultMap(Result result) {
         Map<String, Object> resultMap = new HashMap<String, Object>();
         resultMap.put("status", result.getStatus().lowerCaseName());
-        if (result.getErrorMessage() != null) {
-            resultMap.put("error_message", result.getErrorMessage());
-        }
-        if (result.getDuration() != null && result.getDuration() != 0) {
-            resultMap.put("duration", result.getDuration());
+        if (!result.is(Result.Type.UNDEFINED)) {
+            if (result.getErrorMessage() != null) {
+                resultMap.put("error_message", result.getErrorMessage());
+            }
+            if (result.getDuration() != null && result.getDuration() != 0) {
+                resultMap.put("duration", result.getDuration());
+            }
         }
         return resultMap;
     }

core/src/main/java/cucumber/runtime/formatter/PrettyFormatter.java

@@ -5,7 +5,6 @@
 import cucumber.api.Result;
 import cucumber.api.TestCase;
 import cucumber.api.TestStep;
-import cucumber.api.event.ConcurrentEventListener;
 import cucumber.api.event.EventHandler;
 import cucumber.api.event.EventListener;
 import cucumber.api.event.EventPublisher;
@@ -31,6 +30,8 @@
 import java.net.URI;
 import java.util.List;
 
+import static cucumber.api.Result.Type.UNDEFINED;
+
 final class PrettyFormatter implements EventListener, ColorAware {
     private static final String SCENARIO_INDENT = "  ";
     private static final String STEP_INDENT = "    ";
@@ -170,13 +171,13 @@ private void handleStartOfFeature(TestCaseStarted event) {
     private void handleScenarioOutline(TestCaseStarted event) {
         TestSourcesModel.AstNode astNode = testSources.getAstNode(currentFeatureFile, event.testCase.getLine());
         if (TestSourcesModel.isScenarioOutlineScenario(astNode)) {
-            ScenarioOutline scenarioOutline = (ScenarioOutline)TestSourcesModel.getScenarioDefinition(astNode);
+            ScenarioOutline scenarioOutline = (ScenarioOutline) TestSourcesModel.getScenarioDefinition(astNode);
             if (currentScenarioOutline == null || !currentScenarioOutline.equals(scenarioOutline)) {
                 currentScenarioOutline = scenarioOutline;
                 printScenarioOutline(currentScenarioOutline);
             }
             if (currentExamples == null || !currentExamples.equals(astNode.parent.node)) {
-                currentExamples = (Examples)astNode.parent.node;
+                currentExamples = (Examples) astNode.parent.node;
                 printExamples(currentExamples);
             }
         } else {
@@ -289,6 +290,7 @@ private void printFeature(String path) {
     private void printTags(List<Tag> tags) {
         printTags(tags, "");
     }
+
     private void printTags(List<Tag> tags, String indent) {
         if (!tags.isEmpty()) {
             out.println(indent + FixJava.join(FixJava.map(tags, tagNameMapper), " "));
@@ -333,6 +335,10 @@ private void printScenarioDefinition(TestCase testCase) {
     }
 
     private void printError(Result result) {
+        if (result.is(UNDEFINED)) {
+            return;
+        }
+
         if (result.getError() != null) {
             out.println("      " + formats.get(result.getStatus().lowerCaseName()).text(result.getErrorMessage()));
         }

core/src/main/java/cucumber/runtime/formatter/Stats.java

@@ -1,7 +1,7 @@
 package cucumber.runtime.formatter;
 
-import cucumber.api.Result;
 import cucumber.api.PickleStepTestStep;
+import cucumber.api.Result;
 import cucumber.api.event.EventHandler;
 import cucumber.api.event.EventListener;
 import cucumber.api.event.EventPublisher;
@@ -11,10 +11,6 @@
 import cucumber.api.event.TestStepFinished;
 import cucumber.api.formatter.ColorAware;
 import cucumber.api.formatter.StrictAware;
-import cucumber.runtime.formatter.AnsiFormats;
-import cucumber.runtime.formatter.Format;
-import cucumber.runtime.formatter.Formats;
-import cucumber.runtime.formatter.MonochromeFormats;
 
 import java.io.PrintStream;
 import java.text.DecimalFormat;
@@ -23,6 +19,8 @@
 import java.util.List;
 import java.util.Locale;
 
+import static cucumber.api.Result.Type.UNDEFINED;
+
 public class Stats implements EventListener, ColorAware, StrictAware {
     static final long ONE_SECOND = 1000000000;
     static final long ONE_MINUTE = 60 * ONE_SECOND;
@@ -47,7 +45,7 @@ public void receive(TestRunStarted event) {
         @Override
         public void receive(TestStepFinished event) {
             Result result = event.result;
-            if (result.getError() != null) {
+            if (!result.is(UNDEFINED) && result.getError() != null) {
                 addError(result.getError());
             }
             if (event.testStep instanceof PickleStepTestStep) {

core/src/main/java/cucumber/runtime/io/FileResourceIterator.java

@@ -10,11 +10,11 @@
 class FileResourceIterator implements Iterator<Resource> {
     private final FlatteningIterator<Resource> flatteningIterator = new FlatteningIterator<Resource>();
 
-    static FileResourceIterator createFileResourceIterator(File root, File file, final String suffix) {
+    static Iterator<Resource> createFileResourceIterator(File root, File file, final String suffix) {
         return new FileResourceIterator(root, file, suffix, false);
     }
 
-    static FileResourceIterator createClasspathFileResourceIterator(File classpathRoot, File file, final String suffix) {
+    static Iterator<Resource> createClasspathFileResourceIterator(File classpathRoot, File file, final String suffix) {
         return new FileResourceIterator(classpathRoot, file, suffix, true);
     }
 

core/src/test/java/cucumber/runner/TestCaseTest.java

@@ -57,7 +57,7 @@ public class TestCaseTest {
 
     @Test
     public void run_wraps_execute_in_test_case_started_and_finished_events() throws Throwable {
-        doThrow(new UndefinedStepDefinitionException()).when(definitionMatch1).runStep(isA(Scenario.class));
+        doThrow(new UndefinedStepDefinitionException("step text")).when(definitionMatch1).runStep(isA(Scenario.class));
 
         createTestCase(testStep1).run(bus);
 
@@ -79,7 +79,7 @@ public void run_all_steps() throws Throwable {
 
     @Test
     public void run_hooks_after_the_first_non_passed_result_for_gherkin_step() throws Throwable {
-        doThrow(new UndefinedStepDefinitionException()).when(definitionMatch1).runStep(isA(Scenario.class));
+        doThrow(new UndefinedStepDefinitionException("step text")).when(definitionMatch1).runStep(isA(Scenario.class));
 
         TestCase testCase = createTestCase(testStep1, testStep2);
         testCase.run(bus);
@@ -93,7 +93,7 @@ public void run_hooks_after_the_first_non_passed_result_for_gherkin_step() throw
 
     @Test
     public void skip_hooks_of_step_after_skipped_step() throws Throwable {
-        doThrow(new UndefinedStepDefinitionException()).when(definitionMatch1).runStep(isA(Scenario.class));
+        doThrow(new UndefinedStepDefinitionException("step text")).when(definitionMatch1).runStep(isA(Scenario.class));
 
         TestCase testCase = createTestCase(testStep1, testStep2);
         testCase.run(bus);
@@ -106,7 +106,7 @@ public void skip_hooks_of_step_after_skipped_step() throws Throwable {
 
     @Test
     public void skip_steps_at_first_gherkin_step_after_non_passed_result() throws Throwable {
-        doThrow(new UndefinedStepDefinitionException()).when(definitionMatch1).runStep(isA(Scenario.class));
+        doThrow(new UndefinedStepDefinitionException("step text")).when(definitionMatch1).runStep(isA(Scenario.class));
 
         TestCase testCase = createTestCase(testStep1, testStep2);
         testCase.run(bus);

core/src/test/java/cucumber/runner/UndefinedStepDefinitionMatchTest.java

@@ -1,23 +1,30 @@
 package cucumber.runner;
 
 import cucumber.api.Scenario;
+import gherkin.pickles.Argument;
+import gherkin.pickles.PickleLocation;
 import gherkin.pickles.PickleStep;
 import org.junit.Test;
 
+import java.util.Collections;
+
+import static java.util.Collections.singletonList;
 import static org.junit.Assert.fail;
 import static org.mockito.Mockito.mock;
 
 public class UndefinedStepDefinitionMatchTest {
-    public final UndefinedPickleStepDefinitionMatch match = new UndefinedPickleStepDefinitionMatch(mock(PickleStep.class));
 
-    @Test(expected=UndefinedStepDefinitionException.class)
-    public void throws_ambiguous_step_definitions_exception_when_run() throws Throwable {
+    private PickleStep pickleStep = new PickleStep("text", Collections.<Argument>emptyList(), singletonList(new PickleLocation(5, 5)));
+    public final UndefinedPickleStepDefinitionMatch match = new UndefinedPickleStepDefinitionMatch("path/to.feature", pickleStep);
+
+    @Test(expected = UndefinedStepDefinitionException.class)
+    public void throws_ambiguous_step_definitions_exception_when_run() {
         match.runStep(mock(Scenario.class));
         fail("UndefinedStepDefinitionsException expected");
     }
 
-    @Test(expected=UndefinedStepDefinitionException.class)
-    public void throws_ambiguous_step_definitions_exception_when_dry_run() throws Throwable {
+    @Test(expected = UndefinedStepDefinitionException.class)
+    public void throws_ambiguous_step_definitions_exception_when_dry_run() {
         match.dryRunStep(mock(Scenario.class));
         fail("UndefinedStepDefinitionsException expected");
     }

examples/java-calculator-junit5/.gitignore

@@ -0,0 +1,3 @@
+/.settings
+/.classpath
+/.project