Some more hacks to fix recent java8 bugs. Needs cleanup.

aslakhellesoy · brasmusson · commit bd0c0accd4a6 · 2016-07-31T14:38:54.000+02:00
diff --git a/History.md b/History.md
@@ -1,5 +1,6 @@
 ## [1.2.5-SNAPSHOT](https://github.com/cucumber/cucumber-jvm/compare/v1.2.4...master) (In Git)
 
+* [Java8] 
 * [Java8] Fix IllegalArgumentException on JDK 1.8.0_60 ([#912](https://github.com/cucumber/cucumber-jvm/issues/912), [#914](https://github.com/cucumber/cucumber-jvm/pull/914) Michael Wilkerson)
 * [Core] Double-check for directory exists in the ensureParentDirExists(File) ([#978](https://github.com/cucumber/cucumber-jvm/pull/978) Pavel Ordenko)
 * [picocontainer] Picocontainer lifecycle support([#994](https://github.com/cucumber/cucumber-jvm/pull/994), [#993](https://github.com/cucumber/cucumber-jvm/issues/993), [#992](https://github.com/cucumber/cucumber-jvm/pull/992) Richard Bradley)
diff --git a/java/src/main/java/cucumber/runtime/java/Java8StepDefinition.java b/java/src/main/java/cucumber/runtime/java/Java8StepDefinition.java
@@ -11,6 +11,7 @@
 import gherkin.formatter.model.Step;
 
 import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 import java.util.ArrayList;
 import java.util.List;
@@ -39,7 +40,27 @@ public Java8StepDefinition(Pattern pattern, long timeoutMillis, StepdefBody body
 
         Class<? extends StepdefBody> bodyClass = body.getClass();
 
-        ArrayList<Method> acceptMethods = new ArrayList<Method>();
+        this.method = getAcceptMethod(bodyClass);
+        this.parameterInfos = getParameterInfos(bodyClass, typeIntrospector, method.getParameterTypes().length);
+    }
+
+    private List<ParameterInfo> getParameterInfos(Class<? extends StepdefBody> bodyClass, TypeIntrospector typeIntrospector, int parameterCount) throws Exception {
+        Type genericInterface = bodyClass.getGenericInterfaces()[0];
+        Type[] argumentTypes;
+        if (genericInterface instanceof ParameterizedType) {
+            argumentTypes = ((ParameterizedType) genericInterface).getActualTypeArguments();
+        } else {
+            argumentTypes = typeIntrospector.getGenericTypes(bodyClass);
+        }
+        Type[] argumentTypesOfCorrectLength = new Type[parameterCount];
+        System.arraycopy(argumentTypes, argumentTypes.length - parameterCount, argumentTypesOfCorrectLength, 0, parameterCount);
+        verifyNotListOrMap(argumentTypesOfCorrectLength);
+
+        return ParameterInfo.fromTypes(argumentTypesOfCorrectLength);
+    }
+
+    private Method getAcceptMethod(Class<? extends StepdefBody> bodyClass) {
+        List<Method> acceptMethods = new ArrayList<Method>();
         for (Method method : bodyClass.getDeclaredMethods()) {
             if (!method.isBridge() && !method.isSynthetic() && "accept".equals(method.getName())) {
                 acceptMethods.add(method);
@@ -49,25 +70,22 @@ public Java8StepDefinition(Pattern pattern, long timeoutMillis, StepdefBody body
             throw new IllegalStateException(String.format("Expected single 'accept' method on body class, found " +
                     "'%s'", acceptMethods));
         }
-        this.method = acceptMethods.get(0);
-        Type[] argumentTypes = method.getGenericParameterTypes();
-        verifyNotListOrMap(argumentTypes);
-        this.parameterInfos = ParameterInfo.fromTypes(argumentTypes);
+        return acceptMethods.get(0);
     }
 
     private void verifyNotListOrMap(Type[] argumentTypes) {
         for (Type argumentType : argumentTypes) {
-            if(argumentType instanceof Class) {
+            if (argumentType instanceof Class) {
                 Class<?> argumentClass = (Class<?>) argumentType;
-                if(List.class.isAssignableFrom(argumentClass) || Map.class.isAssignableFrom(argumentClass)) {
+                if (List.class.isAssignableFrom(argumentClass) || Map.class.isAssignableFrom(argumentClass)) {
                     throw withLocation(new CucumberException("Can't use " + argumentClass.getName() + " in lambda step definition. Declare a DataTable argument instead and convert manually with asList/asLists/asMap/asMaps"));
                 }
             }
         }
     }
 
     private CucumberException withLocation(CucumberException exception) {
-        exception.setStackTrace(new StackTraceElement[] {this.location});
+        exception.setStackTrace(new StackTraceElement[]{this.location});
         return exception;
     }
 
diff --git a/java/src/test/java/cucumber/runtime/java/Java8StepDefinitionTest.java b/java/src/test/java/cucumber/runtime/java/Java8StepDefinitionTest.java
diff --git a/java8/src/test/java/cucumber/runtime/java8/test/Java8StepDefinitionTest.java b/java8/src/test/java/cucumber/runtime/java8/test/Java8StepDefinitionTest.java
@@ -0,0 +1,56 @@
+package cucumber.runtime.java8.test;
+
+import cucumber.api.java8.StepdefBody;
+import cucumber.runtime.CucumberException;
+import cucumber.runtime.java.Java8StepDefinition;
+import cucumber.runtime.java.TypeIntrospector;
+import cucumber.runtime.java8.ConstantPoolTypeIntrospector;
+import org.junit.Test;
+
+import java.util.List;
+import java.util.regex.Pattern;
+
+import static org.junit.Assert.assertEquals;
+
+public class Java8StepDefinitionTest {
+    private final TypeIntrospector typeIntrospector = new ConstantPoolTypeIntrospector();
+
+    @Test
+    public void should_calculate_parameters_count_from_body_with_one_param() throws Exception {
+        StepdefBody body = (StepdefBody.A1<String>) p1 -> {
+        };
+        Java8StepDefinition def = new Java8StepDefinition(Pattern.compile("^I have (\\d) some step (.*)$"), 0, body, typeIntrospector);
+        assertEquals(new Integer(1), def.getParameterCount());
+    }
+
+    @Test
+    public void should_calculate_parameters_count_from_body_with_two_params() throws Exception {
+        StepdefBody body = (StepdefBody.A2<String, String>) (p1, p2) -> {
+        };
+        Java8StepDefinition def = new Java8StepDefinition(Pattern.compile("^I have some step $"), 0, body, typeIntrospector);
+        assertEquals(new Integer(2), def.getParameterCount());
+    }
+
+    @Test
+    public void should_fail_for_param_with_non_generic_list() throws Exception {
+        try {
+            StepdefBody body = (StepdefBody.A1<List>) p1 -> {
+            };
+            new Java8StepDefinition(Pattern.compile("^I have (\\d) some step (.*)$"), 0, body, typeIntrospector);
+        } catch (CucumberException expected) {
+            assertEquals("Can't use java.util.List in lambda step definition. Declare a DataTable argument instead and convert manually with asList/asLists/asMap/asMaps", expected.getMessage());
+        }
+    }
+
+    @Test
+    public void should_pass_for_param_with_generic_list() throws Exception {
+        try {
+            StepdefBody body = (StepdefBody.A1<List<String>>) p1 -> {
+            };
+            new Java8StepDefinition(Pattern.compile("^I have (\\d) some step (.*)$"), 0, body, typeIntrospector);
+        } catch (CucumberException expected) {
+            assertEquals("Can't use java.util.List in lambda step definition. Declare a DataTable argument instead and convert manually with asList/asLists/asMap/asMaps", expected.getMessage());
+        }
+    }
+
+}
diff --git a/java8/src/test/java/cucumber/runtime/java8/test/LambdaStepdefs.java b/java8/src/test/java/cucumber/runtime/java8/test/LambdaStepdefs.java
@@ -1,10 +1,8 @@
 package cucumber.runtime.java8.test;
 
 import cucumber.api.DataTable;
-import cucumber.api.PendingException;
 import cucumber.api.Scenario;
 import cucumber.api.java8.En;
-import cucumber.api.java8.StepdefBody;
 
 import java.util.List;
 
@@ -19,13 +17,17 @@ public LambdaStepdefs() {
             assertNotSame(this, lastInstance);
             lastInstance = this;
         });
+
         Given("^this data table:$", (DataTable peopleTable) -> {
             List<Person> people = peopleTable.asList(Person.class);
             assertEquals("Hellesøy", people.get(0).last);
         });
+
         Integer alreadyHadThisManyCukes = 1;
-        Given("^I have 42 cukes in my belly$", () -> {
+
+        Given("^I have (\\d+) cukes in my belly$", (Long n) -> {
             assertEquals((Integer) 1, alreadyHadThisManyCukes);
+            assertEquals((Long) 42L, n);
         });
     }
 
