diff --git a/CHANGELOG.md b/CHANGELOG.md index 66d9e949c1..8c54ad2837 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -29,7 +29,16 @@ Please see [CONTRIBUTING.md](https://github.com/cucumber/cucumber/blob/master/CO * [Core] Use feature file language to parse numbers in the type registry - Unless explicitly set using the `TypeRegistryConfigurer` * [Core] Use Java Time API in Events ([#1620](https://github.com/cucumber/cucumber-jvm/pull/1620) Yatharth Zutshi) - + * [Core] Upgrade `cucumber-expressions` to 8.0.0 + - Simplify heuristics to distinguish between Cucumber Expressions and Regular Expressions ([#cucumber/515](https://github.com/cucumber/cucumber/issues/515), [#cucumber/581](https://github.com/cucumber/cucumber/pull/581), [#1581](https://github.com/cucumber/cucumber-jvm/issues/1581) M.P.Korstanje) + - Improve decimal number parsing ([#cucumber/600](https://github.com/cucumber/cucumber/issues/600), [#cucumber/605](https://github.com/cucumber/cucumber/pull/605), [#cucumber/669](https://github.com/cucumber/cucumber/issues/669), [#cucumber/672](https://github.com/cucumber/cucumber/pull/672), [#cucumber/675](https://github.com/cucumber/cucumber/pull/675), [#cucumber/677](https://github.com/cucumber/cucumber/pull/677) Aslak Hellesøy, Vincent Psarga, Luke Hill, M.P. Korstanje ) + - Recognize look around as a non-capturing regex group ([#cucumber/481](https://github.com/cucumber/cucumber/issues/576), [#cucumber/593](https://github.com/cucumber/cucumber/pull/593) Luke Hill) + - Prefer type from method over type from ParameterType ([#cucumber/658](https://github.com/cucumber/cucumber/pull/658) [#cucumber/659](https://github.com/cucumber/cucumber/pull/659) M.P. Korstanje) + * [Core] Upgrade `datatable` to 2.0.0 + - Empty cells are `null` values in `DataTable` ([1617](https://github.com/cucumber/cucumber-jvm/issues/1617) M.P. Korstanje) + - Improve handling of tables without header ([#cucumber/540](https://github.com/cucumber/cucumber/pull/540) M.P. Korstanje) + - Remove DataTableType convenience methods ([1643](https://github.com/cucumber/cucumber-jvm/issues/1643) M.P. Korstanje) + ### Deprecated * [Core] Deprecate `timeout` ([#1506](https://github.com/cucumber/cucumber-jvm/issues/1506), [#1694](https://github.com/cucumber/cucumber-jvm/issues/1694) M.P. Korstanje) - Prefer using library based solutions diff --git a/core/src/main/java/io/cucumber/core/stepexpression/DocStringTransformer.java b/core/src/main/java/io/cucumber/core/stepexpression/DocStringTransformer.java index 08f74d0821..033172d6ad 100644 --- a/core/src/main/java/io/cucumber/core/stepexpression/DocStringTransformer.java +++ b/core/src/main/java/io/cucumber/core/stepexpression/DocStringTransformer.java @@ -1,6 +1,6 @@ package io.cucumber.core.stepexpression; - +@FunctionalInterface interface DocStringTransformer { T transform(String docString); } diff --git a/core/src/main/java/io/cucumber/core/stepexpression/PickleTableConverter.java b/core/src/main/java/io/cucumber/core/stepexpression/PickleTableConverter.java index 24354ee247..ceff1cea99 100644 --- a/core/src/main/java/io/cucumber/core/stepexpression/PickleTableConverter.java +++ b/core/src/main/java/io/cucumber/core/stepexpression/PickleTableConverter.java @@ -14,11 +14,12 @@ private PickleTableConverter() { } static List> toTable(PickleTable pickleTable) { - List> table = new ArrayList>(); + List> table = new ArrayList<>(); for (PickleRow pickleRow : pickleTable.getRows()) { - List row = new ArrayList(); + List row = new ArrayList<>(); for (PickleCell pickleCell : pickleRow.getCells()) { - row.add(pickleCell.getValue()); + String value = pickleCell.getValue(); + row.add(value.isEmpty() ? null : value); } table.add(row); } diff --git a/core/src/main/java/io/cucumber/core/stepexpression/RawTableTransformer.java b/core/src/main/java/io/cucumber/core/stepexpression/RawTableTransformer.java index 594e9c3896..755287d5ad 100644 --- a/core/src/main/java/io/cucumber/core/stepexpression/RawTableTransformer.java +++ b/core/src/main/java/io/cucumber/core/stepexpression/RawTableTransformer.java @@ -2,6 +2,7 @@ import java.util.List; +@FunctionalInterface interface RawTableTransformer { T transform(List> raw); } diff --git a/core/src/main/java/io/cucumber/core/stepexpression/StepExpressionFactory.java b/core/src/main/java/io/cucumber/core/stepexpression/StepExpressionFactory.java index 4490018b64..52c7e47bcf 100644 --- a/core/src/main/java/io/cucumber/core/stepexpression/StepExpressionFactory.java +++ b/core/src/main/java/io/cucumber/core/stepexpression/StepExpressionFactory.java @@ -16,13 +16,6 @@ public final class StepExpressionFactory { private final io.cucumber.cucumberexpressions.ExpressionFactory expressionFactory; private final DataTableTypeRegistryTableConverter tableConverter; - private static final DocStringTransformer DOC_STRING_IDENTITY = new DocStringTransformer() { - @Override - public String transform(String input) { - return input; - } - }; - public StepExpressionFactory(TypeRegistry registry) { this.expressionFactory = new io.cucumber.cucumberexpressions.ExpressionFactory(registry.parameterTypeRegistry()); this.tableConverter = new DataTableTypeRegistryTableConverter(registry.dataTableTypeRegistry()); @@ -32,13 +25,9 @@ public StepExpression createExpression(String expressionString) { if (expressionString == null) throw new NullPointerException("expression can not be null"); Expression expression = expressionFactory.createExpression(expressionString); - RawTableTransformer toDataTable = new RawTableTransformer() { - @Override - public DataTable transform(List> raw) { - return DataTable.create(raw, tableConverter); - } - }; - return new StepExpression(expression, DOC_STRING_IDENTITY, toDataTable); + RawTableTransformer toDataTable = raw -> DataTable.create(raw, tableConverter); + DocStringTransformer toDocString = (String input) -> input; + return new StepExpression(expression, toDocString, toDataTable); } public StepExpression createExpression(String expressionString, Type tableOrDocStringType) { @@ -64,26 +53,20 @@ public StepExpression createExpression(String expressionString, final TypeResolv throw registerTypeInConfiguration(expressionString, e); } - RawTableTransformer tableTransform = new RawTableTransformer() { - @Override - public Object transform(List> raw) { - DataTable dataTable = DataTable.create(raw, StepExpressionFactory.this.tableConverter); - Type targetType = tableOrDocStringType.resolve(); - return dataTable.convert(Object.class.equals(targetType) ? DataTable.class : targetType, transpose); - } + RawTableTransformer tableTransform = (List> raw) -> { + DataTable dataTable = DataTable.create(raw, StepExpressionFactory.this.tableConverter); + Type targetType = tableOrDocStringType.resolve(); + return dataTable.convert(Object.class.equals(targetType) ? DataTable.class : targetType, transpose); }; - DocStringTransformer docStringTransform = new DocStringTransformer() { - @Override - public Object transform(String docString) { - Type targetType = tableOrDocStringType.resolve(); - if (Object.class.equals(targetType)) { - return docString; - } - - List> raw = singletonList(singletonList(docString)); - return DataTable.create(raw, StepExpressionFactory.this.tableConverter).convert(targetType, transpose); + DocStringTransformer docStringTransform = (String docString) -> { + Type targetType = tableOrDocStringType.resolve(); + if (Object.class.equals(targetType)) { + return docString; } + + List> raw = singletonList(singletonList(docString)); + return DataTable.create(raw, StepExpressionFactory.this.tableConverter).convert(targetType, transpose); }; return new StepExpression(expression, docStringTransform, tableTransform); } diff --git a/core/src/test/java/io/cucumber/core/runner/CoreStepDefinitionTest.java b/core/src/test/java/io/cucumber/core/runner/CoreStepDefinitionTest.java index 6f457c68fd..96eab018ec 100644 --- a/core/src/test/java/io/cucumber/core/runner/CoreStepDefinitionTest.java +++ b/core/src/test/java/io/cucumber/core/runner/CoreStepDefinitionTest.java @@ -25,6 +25,7 @@ import static org.hamcrest.core.Is.is; import static org.hamcrest.core.IsEqual.equalTo; import static org.junit.jupiter.api.Assertions.assertAll; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.Mockito.mock; public class CoreStepDefinitionTest { @@ -51,6 +52,16 @@ public void should_apply_identity_transform_to_data_table_when_target_type_is_ob assertThat(arguments.get(0).getValue(), is(equalTo(DataTable.create(singletonList(singletonList("content")))))); } + @Test + public void should_convert_empty_pickle_table_cells_to_null_values() { + StubStepDefinition stub = new StubStepDefinition("I have some step", Object.class); + CoreStepDefinition stepDefinition = new CoreStepDefinition(stub, typeRegistry); + + PickleTable table = new PickleTable(singletonList(new PickleRow(singletonList(new PickleCell(null, ""))))); + List arguments = stepDefinition.matchedArguments(new PickleStep("I have some step", singletonList(table), emptyList())); + assertEquals(DataTable.create(singletonList(singletonList(null))), arguments.get(0).getValue()); + } + public static class StepDefs { public void listOfListOfDoubles(List> listOfListOfDoubles) { diff --git a/core/src/test/java/io/cucumber/core/runner/StepDefinitionMatchTest.java b/core/src/test/java/io/cucumber/core/runner/StepDefinitionMatchTest.java index 8c378ca39e..fe6fb48b65 100644 --- a/core/src/test/java/io/cucumber/core/runner/StepDefinitionMatchTest.java +++ b/core/src/test/java/io/cucumber/core/runner/StepDefinitionMatchTest.java @@ -185,23 +185,16 @@ public ItemQuantity transform(String s) throws Throwable { public void throws_could_not_convert_exception_for_singleton_table_dimension_mismatch() { PickleTable table = new PickleTable( asList( - new PickleRow(asList(new PickleCell(mock(PickleLocation.class), "A"), new PickleCell(mock(PickleLocation.class), "B"))), - new PickleRow(asList(new PickleCell(mock(PickleLocation.class), "C"), new PickleCell(mock(PickleLocation.class), "D"))) + new PickleRow(singletonList(new PickleCell(mock(PickleLocation.class), "A"))), + new PickleRow(singletonList(new PickleCell(mock(PickleLocation.class), "B"))), + new PickleRow(singletonList(new PickleCell(mock(PickleLocation.class), "C"))), + new PickleRow(singletonList(new PickleCell(mock(PickleLocation.class), "D"))) ) ); - typeRegistry.defineDataTableType(new DataTableType( - ItemQuantity.class, - new TableCellTransformer() { - @Override - public ItemQuantity transform(String s) { - return new ItemQuantity(s); - } - } - - )); + typeRegistry.defineDataTableType(new DataTableType(ItemQuantity.class, ItemQuantity::new )); - PickleStep step = new PickleStep("I have some cukes in my belly", singletonList((gherkin.pickles.Argument) table), asList(mock(PickleLocation.class))); + PickleStep step = new PickleStep("I have some cukes in my belly", singletonList(table), singletonList(mock(PickleLocation.class))); StepDefinition stepDefinition = new StubStepDefinition("I have some cukes in my belly", ItemQuantity.class); CoreStepDefinition coreStepDefinition = new CoreStepDefinition(stepDefinition, typeRegistry); List arguments = coreStepDefinition.matchedArguments(step); diff --git a/core/src/test/java/io/cucumber/core/stepexpression/StepExpressionFactoryTest.java b/core/src/test/java/io/cucumber/core/stepexpression/StepExpressionFactoryTest.java index 5753019e10..04a3ec0f38 100644 --- a/core/src/test/java/io/cucumber/core/stepexpression/StepExpressionFactoryTest.java +++ b/core/src/test/java/io/cucumber/core/stepexpression/StepExpressionFactoryTest.java @@ -2,8 +2,11 @@ import io.cucumber.datatable.DataTable; import io.cucumber.datatable.DataTableType; +import io.cucumber.datatable.TableCellByTypeTransformer; +import io.cucumber.datatable.TableEntryByTypeTransformer; import io.cucumber.datatable.TableEntryTransformer; import io.cucumber.datatable.TableTransformer; +import io.cucumber.datatable.dependency.com.fasterxml.jackson.databind.ObjectMapper; import org.junit.jupiter.api.Test; import java.lang.reflect.Method; @@ -16,15 +19,16 @@ import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.core.Is.is; import static org.hamcrest.core.IsEqual.equalTo; +import static org.hamcrest.core.IsNull.nullValue; public class StepExpressionFactoryTest { private static final TypeResolver UNKNOWN_TYPE = () -> Object.class; static class Ingredient { - String name; - Integer amount; - String unit; + public String name; + public Integer amount; + public String unit; Ingredient() { } @@ -37,27 +41,20 @@ static class Ingredient { private TableEntryTransformer listBeanMapper(final TypeRegistry registry) { //Just pretend this is a bean mapper. - return new TableEntryTransformer() { - - @Override - public Ingredient transform(Map tableRow) { - Ingredient bean = new Ingredient(); - bean.amount = Integer.valueOf(tableRow.get("amount")); - bean.name = tableRow.get("name"); - bean.unit = tableRow.get("unit"); - return bean; - } + return tableRow -> { + Ingredient bean = new Ingredient(); + bean.amount = Integer.valueOf(tableRow.get("amount")); + bean.name = tableRow.get("name"); + bean.unit = tableRow.get("unit"); + return bean; }; } private TableTransformer beanMapper(final TypeRegistry registry) { - return new TableTransformer() { - @Override - public Ingredient transform(DataTable table) throws Throwable { - Map tableRow = table.transpose().asMaps().get(0); - return listBeanMapper(registry).transform(tableRow); - } + return table -> { + Map tableRow = table.transpose().asMaps().get(0); + return listBeanMapper(registry).transform(tableRow); }; } @@ -96,7 +93,7 @@ public void table_expression_with_list_type_creates_list_of_ingredients_from_tab List ingredients = (List) match.get(0).getValue(); Ingredient ingredient = ingredients.get(0); - assertThat(ingredient.name, is(equalTo("chocolate"))); + assertThat(ingredient.amount, is(equalTo(2))); } @Test @@ -107,13 +104,31 @@ public void unknown_target_type_does_no_transform_data_table() { } @Test - public void unknown_target_type_does_no_transform_doc_string() { + public void unknown_target_type_does_not_transform_doc_string() { String docString = "A rather long and boring string of documentation"; StepExpression expression = new StepExpressionFactory(registry).createExpression("Given some stuff:", UNKNOWN_TYPE); List match = expression.match("Given some stuff:", docString); assertThat(match.get(0).getValue(), is(equalTo(docString))); } + @Test + public void empty_table_cells_are_presented_as_null_to_transformer() { + registry.setDefaultDataTableEntryTransformer(new TableEntryByTypeTransformer() { + @Override + public T transform(Map map, Class aClass, TableCellByTypeTransformer tableCellByTypeTransformer) { + return new ObjectMapper().convertValue(map, aClass); + } + }); + + StepExpression expression = new StepExpressionFactory(registry).createExpression("Given some stuff:", getTypeFromStepDefinition()); + List> table = asList(asList("name", "amount", "unit"), asList("chocolate", null, "tbsp")); + List match = expression.match("Given some stuff:", table); + + List ingredients = (List) match.get(0).getValue(); + Ingredient ingredient = ingredients.get(0); + assertThat(ingredient.name, is(equalTo("chocolate"))); + + } private Type getTypeFromStepDefinition() { for (Method method : this.getClass().getMethods()) { diff --git a/core/src/test/java/io/cucumber/core/stepexpression/TableParser.java b/core/src/test/java/io/cucumber/core/stepexpression/TableParser.java deleted file mode 100644 index 2f9fbf911c..0000000000 --- a/core/src/test/java/io/cucumber/core/stepexpression/TableParser.java +++ /dev/null @@ -1,40 +0,0 @@ -package io.cucumber.core.stepexpression; - -import io.cucumber.datatable.DataTable; -import io.cucumber.datatable.DataTable.TableConverter; -import gherkin.AstBuilder; -import gherkin.Parser; -import gherkin.ast.GherkinDocument; -import gherkin.pickles.Compiler; -import gherkin.pickles.Pickle; -import gherkin.pickles.PickleTable; - -import java.util.List; - -import static io.cucumber.core.stepexpression.PickleTableConverter.toTable; - -public class TableParser { - - private TableParser() { - } - - public static DataTable parse(String source) { - return parse(source, null); - } - - public static DataTable parse(String source, TableConverter converter) { - String feature = "" + - "Feature:\n" + - " Scenario:\n" + - " Given x\n" + - source; - Parser parser = new Parser(new AstBuilder()); - Compiler compiler = new Compiler(); - List pickles = compiler.compile(parser.parse(feature)); - PickleTable pickleTable = (PickleTable) pickles.get(0).getSteps().get(0).getArgument().get(0); - if (converter == null) { - return DataTable.create(toTable(pickleTable)); - } - return DataTable.create(toTable(pickleTable), converter); - } -} diff --git a/core/src/test/java/io/cucumber/core/stepexpression/TypeRegistryTest.java b/core/src/test/java/io/cucumber/core/stepexpression/TypeRegistryTest.java index 483341fa06..d1246d3419 100644 --- a/core/src/test/java/io/cucumber/core/stepexpression/TypeRegistryTest.java +++ b/core/src/test/java/io/cucumber/core/stepexpression/TypeRegistryTest.java @@ -1,27 +1,27 @@ package io.cucumber.core.stepexpression; +import io.cucumber.cucumberexpressions.Expression; +import io.cucumber.cucumberexpressions.ExpressionFactory; import io.cucumber.cucumberexpressions.ParameterByTypeTransformer; import io.cucumber.cucumberexpressions.ParameterType; -import io.cucumber.cucumberexpressions.Transformer; import io.cucumber.datatable.DataTable; import io.cucumber.datatable.DataTableType; import io.cucumber.datatable.TableCellByTypeTransformer; import io.cucumber.datatable.TableEntryByTypeTransformer; -import io.cucumber.datatable.TableTransformer; import org.junit.jupiter.api.Test; -import java.lang.reflect.Type; import java.util.Date; import java.util.Map; +import java.util.regex.Pattern; import static java.util.Locale.ENGLISH; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.core.Is.is; -import static org.hamcrest.core.IsEqual.equalTo; public class TypeRegistryTest { private final TypeRegistry registry = new TypeRegistry(ENGLISH); + private final ExpressionFactory expressionFactory = new ExpressionFactory(registry.parameterTypeRegistry()); @Test public void should_define_parameter_type() { @@ -29,29 +29,23 @@ public void should_define_parameter_type() { "example", ".*", Object.class, - new Transformer() { - @Override - public Object transform(String s) { - return null; - } - } + (String s) -> null ); registry.defineParameterType(expected); - assertThat(registry.parameterTypeRegistry().lookupByTypeName("example"), is(equalTo(expected))); + Expression expresion = expressionFactory.createExpression("{example}"); + assertThat(expresion.getRegexp().pattern(), is("^(.*)$")); } @Test public void should_define_data_table_parameter_type() { DataTableType expected = new DataTableType(Date.class, (DataTable dataTable) -> null); registry.defineDataTableType(expected); - assertThat(registry.dataTableTypeRegistry().lookupTableTypeByType(Date.class), is(equalTo(expected))); } @Test public void should_set_default_parameter_transformer() { ParameterByTypeTransformer expected = (fromValue, toValueType) -> null; registry.setDefaultParameterTransformer(expected); - assertThat(registry.parameterTypeRegistry().getDefaultParameterTransformer(), is(equalTo(expected))); } @Test diff --git a/examples/java-calculator-testng/src/test/java/io/cucumber/examples/testng/RpnCalculatorStepdefs.java b/examples/java-calculator-testng/src/test/java/io/cucumber/examples/testng/RpnCalculatorStepdefs.java index d839ea87e6..3573bc214e 100644 --- a/examples/java-calculator-testng/src/test/java/io/cucumber/examples/testng/RpnCalculatorStepdefs.java +++ b/examples/java-calculator-testng/src/test/java/io/cucumber/examples/testng/RpnCalculatorStepdefs.java @@ -27,7 +27,7 @@ public void adding(int arg1, int arg2) { calc.push("+"); } - @Given("I press (.+)") + @Given("^I press (.+)$") public void I_press(String what) { calc.push(what); } diff --git a/examples/java-calculator/src/test/java/io/cucumber/examples/java/RpnCalculatorStepdefs.java b/examples/java-calculator/src/test/java/io/cucumber/examples/java/RpnCalculatorStepdefs.java index 47077aa2ba..543e640489 100644 --- a/examples/java-calculator/src/test/java/io/cucumber/examples/java/RpnCalculatorStepdefs.java +++ b/examples/java-calculator/src/test/java/io/cucumber/examples/java/RpnCalculatorStepdefs.java @@ -26,7 +26,7 @@ public void adding(int arg1, int arg2) { calc.push("+"); } - @Given("I press (.+)") + @Given("^I press (.+)$") public void I_press(String what) { calc.push(what); } diff --git a/examples/java8-calculator/src/test/java/io/cucumber/examples/java8/RpnCalculatorStepdefs.java b/examples/java8-calculator/src/test/java/io/cucumber/examples/java8/RpnCalculatorStepdefs.java index 8811b62a3c..47f1652b9b 100644 --- a/examples/java8-calculator/src/test/java/io/cucumber/examples/java8/RpnCalculatorStepdefs.java +++ b/examples/java8-calculator/src/test/java/io/cucumber/examples/java8/RpnCalculatorStepdefs.java @@ -23,12 +23,9 @@ public RpnCalculatorStepdefs() { }); - Given("I press (.+)", (String what) -> calc.push(what)); - - Then("the result is {double}", (Integer expected) -> assertEquals(expected, calc.value())); - - Then("the result is {int}", (Integer expected) -> assertEquals(expected.doubleValue(), calc.value())); + Given("^I press (.+)$", (String what) -> calc.push(what)); + Then("the result is {double}", (Double expected) -> assertEquals(expected, calc.value())); Before("not @foo", (Scenario scenario) -> { scenario.write("Runs before scenarios *not* tagged with @foo"); diff --git a/java/src/test/java/io/cucumber/java/JavaParameterTypeDefinitionTest.java b/java/src/test/java/io/cucumber/java/JavaParameterTypeDefinitionTest.java index 5a427cc666..4a238ccce4 100644 --- a/java/src/test/java/io/cucumber/java/JavaParameterTypeDefinitionTest.java +++ b/java/src/test/java/io/cucumber/java/JavaParameterTypeDefinitionTest.java @@ -2,8 +2,9 @@ import io.cucumber.core.backend.Lookup; import io.cucumber.cucumberexpressions.Argument; -import io.cucumber.cucumberexpressions.CucumberExpression; import io.cucumber.cucumberexpressions.CucumberExpressionException; +import io.cucumber.cucumberexpressions.Expression; +import io.cucumber.cucumberexpressions.ExpressionFactory; import io.cucumber.cucumberexpressions.ParameterTypeRegistry; import org.junit.jupiter.api.Test; @@ -33,7 +34,7 @@ public void can_define_parameter_type_converters_with_one_capture_group() throws Method method = JavaParameterTypeDefinitionTest.class.getMethod("convert_one_capture_group_to_string", String.class); JavaParameterTypeDefinition definition = new JavaParameterTypeDefinition("", "(.*)", method, false, false, lookup); registry.defineParameterType(definition.parameterType()); - CucumberExpression cucumberExpression = new CucumberExpression("{convert_one_capture_group_to_string}", registry); + Expression cucumberExpression = new ExpressionFactory(registry).createExpression("{convert_one_capture_group_to_string}"); List> test = cucumberExpression.match("test"); assertThat(test.get(0).getValue(), equalTo("convert_one_capture_group_to_string")); } @@ -47,7 +48,7 @@ public void can_define_parameter_type_converters_with_two_capture_groups() throw Method method = JavaParameterTypeDefinitionTest.class.getMethod("convert_two_capture_group_to_string", String.class, String.class); JavaParameterTypeDefinition definition = new JavaParameterTypeDefinition("", "([^ ]*) ([^ ]*)", method, false, false, lookup); registry.defineParameterType(definition.parameterType()); - CucumberExpression cucumberExpression = new CucumberExpression("{convert_two_capture_group_to_string}", registry); + Expression cucumberExpression = new ExpressionFactory(registry).createExpression("{convert_two_capture_group_to_string}"); List> test = cucumberExpression.match("test test"); assertThat(test.get(0).getValue(), equalTo("convert_two_capture_group_to_string")); } @@ -61,7 +62,7 @@ public void can_define_parameter_type_converters_with_var_args() throws NoSuchMe Method method = JavaParameterTypeDefinitionTest.class.getMethod("convert_varargs_capture_group_to_string", String[].class); JavaParameterTypeDefinition definition = new JavaParameterTypeDefinition("", "([^ ]*) ([^ ]*)", method, false, false, lookup); registry.defineParameterType(definition.parameterType()); - CucumberExpression cucumberExpression = new CucumberExpression("{convert_varargs_capture_group_to_string}", registry); + Expression cucumberExpression = new ExpressionFactory(registry).createExpression("{convert_varargs_capture_group_to_string}"); List> test = cucumberExpression.match("test test"); assertThat(test.get(0).getValue(), equalTo("convert_varargs_capture_group_to_string")); } @@ -75,7 +76,7 @@ public void arguments_must_match_captured_groups() throws NoSuchMethodException Method method = JavaParameterTypeDefinitionTest.class.getMethod("convert_two_capture_group_to_string", String.class, String.class); JavaParameterTypeDefinition definition = new JavaParameterTypeDefinition("", ".*", method, false, false, lookup); registry.defineParameterType(definition.parameterType()); - CucumberExpression cucumberExpression = new CucumberExpression("{convert_two_capture_group_to_string}", registry); + Expression cucumberExpression = new ExpressionFactory(registry).createExpression("{convert_two_capture_group_to_string}"); List> test = cucumberExpression.match("test"); assertThrows(CucumberExpressionException.class, () -> test.get(0).getValue()); } diff --git a/java/src/test/java/io/cucumber/java/JavaSnippetTest.java b/java/src/test/java/io/cucumber/java/JavaSnippetTest.java index a723d9fe90..c820f11b3c 100644 --- a/java/src/test/java/io/cucumber/java/JavaSnippetTest.java +++ b/java/src/test/java/io/cucumber/java/JavaSnippetTest.java @@ -123,17 +123,6 @@ public void generatesCopyPasteReadySnippetWhenStepHasIntegersInsideStringParamet assertThat(expected, snippetFor("the DI system receives a message saying \"{ dataIngestion: { feeds: [ feed: { merchantId: 666, feedId: 1, feedFileLocation: feed.csv } ] }\""), is(equalTo(expected))); } - @Test - public void generatesSnippetWithDollarSigns() { - String expected = "" + - "@Given(\"I have ${int}\")\n" + - "public void i_have_$(Integer int1) {\n" + - " // Write code here that turns the phrase above into concrete actions\n" + - " throw new io.cucumber.java.PendingException();\n" + - "}\n"; - assertThat(snippetFor("I have $5"), is(equalTo(expected))); - } - @Test public void generatesSnippetWithQuestionMarks() { String expected = "" + diff --git a/pom.xml b/pom.xml index 20fdcc62f6..b5b92850ac 100644 --- a/pom.xml +++ b/pom.xml @@ -43,8 +43,8 @@ 1.1.0 5.1.0 - 7.0.2 - 1.1.14 + 8.0.0 + 2.0.0 2.0.2