Validate test-case arguments

Duplicate customisations for the same argument will throw an exception.

Refs: #91

Author: Nylle

src/main/java/com/github/nylle/javafixture/annotations/testcases/ReflectedTestCase.java

@@ -1,5 +1,7 @@
 package com.github.nylle.javafixture.annotations.testcases;
 
+import com.github.nylle.javafixture.SpecimenException;
+
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
@@ -9,21 +11,25 @@
 import java.util.Map;
 
 import static java.util.Arrays.stream;
+import static java.util.stream.Collectors.joining;
+import static java.util.stream.Collectors.toList;
 
 public class ReflectedTestCase {
 
-    private static final Map<Class<?>, Class<?>> primitiveWrapperMap = Map.of(
-            Boolean.class, Boolean.TYPE,
-            Character.class, Character.TYPE,
-            Byte.class, Byte.TYPE,
-            Short.class, Short.TYPE,
-            Integer.class, Integer.TYPE,
-            Long.class, Long.TYPE,
-            Float.class, Float.TYPE,
-            Double.class, Double.TYPE
+    private static final Map<Class<?>, ?> defaults = Map.of(
+            Class.class, Object.class,
+            String.class, "",
+            Boolean.class, false,
+            Character.class, Character.MIN_VALUE,
+            Byte.class, (byte) 0,
+            Short.class, (short) 0,
+            Integer.class, 0,
+            Long.class, 0L,
+            Float.class, 0.0f,
+            Double.class, 0.0d
     );
 
-    private Map<Class<?>, List<?>> matrix = new HashMap<>();
+    private final Map<Class<?>, List<?>> matrix = new HashMap<>();
 
     public ReflectedTestCase(TestCase testCase) {
         stream(TestCase.class.getDeclaredMethods())
@@ -33,7 +39,22 @@ public ReflectedTestCase(TestCase testCase) {
 
     @SuppressWarnings("unchecked")
     public <T> T getTestCaseValueFor(Class<T> type, int i) {
-        return (T) matrix.get(primitiveWrapperMap.getOrDefault(type, type)).get(i);
+        validate(type, i);
+        return (T) matrix.get(asPrimitive(type)).get(i);
+    }
+
+    private <T> void validate(Class<T> type, int i) {
+        var nonDefaultValues = defaults.keySet().stream()
+                .map(key -> matrix.get(asPrimitive(key)).get(i))
+                .filter(value -> !defaults.get(value.getClass()).equals(value))
+                .collect(toList());
+
+        if(isInvalid(type, nonDefaultValues)) {
+            throw new SpecimenException(String.format("Duplicate customisation found for argument at position %d, wanted: %s, found: %s",
+                    i + 1,
+                    type.getName(),
+                    nonDefaultValues.stream().map(x -> x.getClass().getName()).collect(joining(", "))));
+        }
     }
 
     @SuppressWarnings("unchecked")
@@ -54,4 +75,27 @@ private <T> List<T> addTo(List<T> list, T value) {
         return list;
     }
 
+    private static <T> boolean isInvalid(Class<T> type, List<?> nonDefaultValues) {
+        if(nonDefaultValues.size() < 1) {
+            return false;
+        }
+        if(nonDefaultValues.size() > 1) {
+            return true;
+        }
+        return asPrimitive(type) != asPrimitive(nonDefaultValues.get(0).getClass());
+    }
+
+    private static Class<?> asPrimitive(Class<?> type) {
+        Map<Class<?>, Class<?>> primitiveWrapperMap = Map.of(
+                Boolean.class, Boolean.TYPE,
+                Character.class, Character.TYPE,
+                Byte.class, Byte.TYPE,
+                Short.class, Short.TYPE,
+                Integer.class, Integer.TYPE,
+                Long.class, Long.TYPE,
+                Float.class, Float.TYPE,
+                Double.class, Double.TYPE
+        );
+        return primitiveWrapperMap.getOrDefault(type, type);
+    }
 }