Changed single-valued datapoints back to deferred execution

Author: pimterry

src/main/java/org/junit/experimental/theories/internal/AllMembersSupplier.java

@@ -19,7 +19,34 @@
  * Supplies Theory parameters based on all public members of the target class.
  */
 public class AllMembersSupplier extends ParameterSupplier {
+    static class MethodParameterValue extends PotentialAssignment {
+        private final FrameworkMethod fMethod;
+
+        private MethodParameterValue(FrameworkMethod dataPointMethod) {
+            fMethod = dataPointMethod;
+        }
+
+        @Override
+        public Object getValue() throws CouldNotGenerateValueException {
+            try {
+                return fMethod.invokeExplosively(null);
+            } catch (IllegalArgumentException e) {
+                throw new RuntimeException(
+                        "unexpected: argument length is checked");
+            } catch (IllegalAccessException e) {
+                throw new RuntimeException(
+                        "unexpected: getMethods returned an inaccessible method");
+            } catch (Throwable e) {
+                throw new CouldNotGenerateValueException();
+                // do nothing, just look for more values
+            }
+        }    
 
+        @Override
+        public String getDescription() throws CouldNotGenerateValueException {
+            return fMethod.getName();
+        }
+    }           
     private final TestClass fClass;
 
     /**
@@ -57,19 +84,8 @@ private void addMultiPointMethods(ParameterSignature sig, List<PotentialAssignme
 
     private void addSinglePointMethods(ParameterSignature sig, List<PotentialAssignment> list) {
         for (FrameworkMethod dataPointMethod : getSingleDataPointMethods(sig)) {
-            if (sig.canPotentiallyAcceptType(dataPointMethod.getReturnType())) {
-                Object value;
-                
-                try {
-                    value = dataPointMethod.invokeExplosively(null);
-                } catch (Throwable e) {
-                    // ignore and move on
-                    continue;
-                }
-                    
-                if (sig.canAcceptValue(value)) {
-                    list.add(PotentialAssignment.forValue(dataPointMethod.getName(), value));
-                }
+            if (sig.canAcceptType(dataPointMethod.getType())) {
+                list.add(new MethodParameterValue(dataPointMethod));
             }
         }
     }

src/test/java/org/junit/tests/experimental/theories/internal/AllMembersSupplierTest.java

@@ -53,25 +53,6 @@ public void dataPointsArrayShouldBeRecognizedOnValueTypeNotFieldType() throws Ex
         assertEquals(2, assignments.size());
     }
 
-    public static class HasDataPointMethodWithMatchingButInaccurateTypes {
-        @DataPoint
-        public static Object object() {
-            return 1;
-        }
-
-        @Theory
-        public void theory(Integer param) {
-        }
-    }
-
-    @Test
-    public void dataPointMethodShouldBeRecognizedOnValueTypeNotFieldType() throws Exception {
-        List<PotentialAssignment> assignments = potentialAssignments(
-                HasDataPointMethodWithMatchingButInaccurateTypes.class.getMethod("theory", Integer.class));
-        
-        assertEquals(1, assignments.size());
-    }
-    
     public static class HasDataPointMethodWithOverlyGeneralTypes {
         @DataPoint
         public static Integer object() {

src/test/java/org/junit/tests/experimental/theories/runner/WithDataPointMethod.java

@@ -10,6 +10,7 @@
 import static org.junit.experimental.results.ResultMatchers.isSuccessful;
 import static org.junit.tests.experimental.theories.TheoryTestUtils.potentialAssignments;
 
+import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;
 
@@ -64,6 +65,31 @@ public void ignoreExceptionsFromDataPointMethods() {
         assertThat(testResult(HasUglyDataPointMethod.class), isSuccessful());
     }
 
+    @RunWith(Theories.class)
+    public static class DataPointMethodReturnsMutableObject {
+        @DataPoint
+        public static List<Object> empty() {
+            return new ArrayList<Object>();
+        }
+
+        @DataPoint
+        public static int ONE = 1;
+
+        @DataPoint
+        public static int TWO = 2;
+
+        @Theory
+        public void everythingsEmpty(List<Object> first, int number) {
+            assertThat(first.size(), is(0));
+            first.add("a");
+        }
+    }
+
+    @Test
+    public void mutableObjectsAreCreatedAfresh() {
+        assertThat(failures(DataPointMethodReturnsMutableObject.class), empty());
+    }
+
     @RunWith(Theories.class)
     public static class HasDateMethod {
         @DataPoint