integrated new Permuter in argument generation

nl.jssl.autounit.testclasses.BooleanArguments.xml

@@ -4,9 +4,9 @@
     <results>
       <contents>
         <case>
-          <input class="args">
+          <input class="nl.jssl.autounit.utils.Permuter$Tuple">
-            <arg1>false</arg1>
+            <element1 class="boolean">false</element1>
-            <arg1>false</arg1>
+            <element2 class="boolean">false</element2>
           </input>
           <output class="string">falsefalse</output>
         </case>

nl.jssl.autounit.testclasses.ByteArguments.xml

@@ -4,14 +4,14 @@
     <results>
       <contents>
         <case>
-          <input class="args">
+          <input class="nl.jssl.autounit.utils.Permuter$Tuple">
-            <arg1>-128</arg1>
+            <element1 class="byte">-128</element1>
           </input>
           <output class="int">-256</output>
         </case>
         <case>
-          <input class="args">
+          <input class="nl.jssl.autounit.utils.Permuter$Tuple">
-            <arg1>0</arg1>
+            <element1 class="byte">0</element1>
           </input>
           <output class="int">11</output>
         </case>

nl.jssl.autounit.testclasses.FloatArguments.xml

@@ -4,8 +4,8 @@
     <results>
       <contents>
         <case>
-          <input class="args">
+          <input class="nl.jssl.autounit.utils.Permuter$Tuple">
-            <arg1>-Infinity</arg1>
+            <element1 class="float">-2.006128E38</element1>
           </input>
           <output class="int">-2147483648</output>
         </case>

nl.jssl.autounit.testclasses.IntArguments.xml

@@ -1,36 +1,36 @@
 <map>
-  <entry>
-    <string>public int randomOther(int arg1)</string>
-    <results>
-      <contents>
-        <case>
-          <input class="args">
-            <arg1>-2147483648</arg1>
-          </input>
-          <output class="int">0</output>
-        </case>
-      </contents>
-    </results>
-  </entry>
   <entry>
     <string>public java.lang.String evenOrUneven(int arg1,int arg2)</string>
     <results>
       <contents>
         <case>
-          <input class="args">
+          <input class="nl.jssl.autounit.utils.Permuter$Tuple">
-            <arg1>-2147483648</arg1>
+            <element1 class="int">-2147483648</element1>
-            <arg1>-2147483648</arg1>
+            <element2 class="int">-2147483648</element2>
           </input>
           <output class="string">even</output>
         </case>
         <case>
-          <input class="args">
+          <input class="nl.jssl.autounit.utils.Permuter$Tuple">
-            <arg1>-1</arg1>
+            <element1 class="int">-2147483648</element1>
-            <arg1>-1</arg1>
+            <element2 class="int">-1</element2>
           </input>
           <output class="string">uneven</output>
         </case>
       </contents>
     </results>
   </entry>
+  <entry>
+    <string>public int randomOther(int arg1)</string>
+    <results>
+      <contents>
+        <case>
+          <input class="nl.jssl.autounit.utils.Permuter$Tuple">
+            <element1 class="int">-2147483648</element1>
+          </input>
+          <output class="int">0</output>
+        </case>
+      </contents>
+    </results>
+  </entry>
 </map>

src/nl/jssl/autounit/MethodcallExecutor.java

@@ -4,6 +4,7 @@ import java.lang.reflect.Method;
 import java.util.List;
 
 import nl.jssl.autounit.inputs.ArgumentsForSingleCall;
+import nl.jssl.autounit.utils.Permuter.Tuple;
 
 /**
  * voert 1 methode uit met wisselende input parameters en bewaart het resultaat.
@@ -22,10 +23,10 @@ public class MethodcallExecutor {
 		this.result = new MethodCallResults(instrumentedTestTarget, m);
 	}
 
-	public MethodCallResults execute(List<ArgumentsForSingleCall> inputs) {
+	public MethodCallResults execute(List<Tuple> inputs) {
 		int missedLines = Integer.MAX_VALUE;
 		InvocationResult lastInvocationResult = null, previous = null;
-		for (ArgumentsForSingleCall input : inputs) {
+		for (Tuple input : inputs) {
 			previous = lastInvocationResult;
 			lastInvocationResult = analyseMethodCall(m, input);
 			int missedCount = lastInvocationResult.coverage.getLineCounter().getMissedCount();
@@ -46,7 +47,7 @@ public class MethodcallExecutor {
 		return result;
 	}
 
-	private InvocationResult analyseMethodCall(Method m, ArgumentsForSingleCall input) {
+	private InvocationResult analyseMethodCall(Method m, Tuple input) {
 		return coverageAnalyser.analyse(instrumentedTestTarget, m, input.toArray());
 	}
 

src/nl/jssl/autounit/Recorder.java

@@ -9,6 +9,7 @@ import java.util.Map;
 
 import nl.jssl.autounit.inputs.ArgumentsForSingleCall;
 import nl.jssl.autounit.inputs.CombinedInputSetFactory;
+import nl.jssl.autounit.utils.Permuter.Tuple;
 
 public class Recorder {
 	private Class<?> testTarget;
@@ -42,7 +43,7 @@ public class Recorder {
 	}
 
 	private MethodCallResults recordMethod(Method m) {
-		List<ArgumentsForSingleCall> inputSet = new CombinedInputSetFactory().getInputs(testTarget, m);
+		List<Tuple> inputSet = new CombinedInputSetFactory().getInputs(testTarget, m);
 		MethodcallExecutor methodcallExecutor = new MethodcallExecutor(testTarget, m);
 		methodcallExecutor.execute(inputSet);
 		return methodcallExecutor.getResult();

src/nl/jssl/autounit/inputs/CombinedInputSetFactory.java

@@ -6,7 +6,8 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
-import nl.jssl.autounit.utils.Permutator;
+import nl.jssl.autounit.utils.Permuter;
+import nl.jssl.autounit.utils.Permuter.Tuple;
 
 public class CombinedInputSetFactory {
 	private final Map<Class<?>, InputsFactory<?>> primitivesFactories;
@@ -16,60 +17,37 @@ public class CombinedInputSetFactory {
 		populateFactories();
 	}
 
-	public List<ArgumentsForSingleCall> getInputs(Class<?> testTarget, Method m) {
+	public List<Tuple> getInputs(Class<?> testTarget, Method m) {
 		return combine(getInputSetsForAllArguments(testTarget, m));
 	}
 
-	private List<ArgumentsForSingleCall> combine(List<SingleTypeInputs<?>> inputSetsForAllArguments) {
+	private List<Tuple> combine(List<List<?>> inputSetsForAllArguments) {
 		int nrOfParameters = inputSetsForAllArguments.size();
 		if (nrOfParameters == 1) {
 			// simple case
 			return makeArgumentsForSingleParameterCall(inputSetsForAllArguments);
 		} else {
-			List<ArgumentsForSingleCall> allPossibleArguments = new ArrayList<>();
+			return Permuter.permute(inputSetsForAllArguments);
-
-//			for (SingleTypeInputs<?> inputs : inputSetsForAllArguments) {
-//				// make list of all permutations of first argument values
-//				List<?> permutatedInputs = Permutator.permute(inputs);
-//				int index = 0;
-//				for (Object variable : permutatedInputs) {
-//					// all lists ("columns") are combined into "rows"
-//					if (index >= allPossibleArguments.size()) {
-//						ArgumentsForSingleCall a = new ArgumentsForSingleCall();
-//						a.add(variable);
-//						allPossibleArguments.add(a);
-//					} else {
-//						ArgumentsForSingleCall argumentsForSingleCall = allPossibleArguments.get(index);
-//						argumentsForSingleCall.add(variable);
-//					}
-//					index++;
-//				}
-//			}
-			// the row view
-			
-			return allPossibleArguments;
 		}
-
 	}
 
-	private List<ArgumentsForSingleCall> makeArgumentsForSingleParameterCall(
+	private List<Tuple> makeArgumentsForSingleParameterCall(
-			List<SingleTypeInputs<?>> generatedInputSetsForAllArguments) {
+			List<List<?>> generatedInputSetsForAllArguments) {
-		List<ArgumentsForSingleCall> allPossibleArguments = new ArrayList<ArgumentsForSingleCall>();
+		List<Tuple> allPossibleArguments = new ArrayList<Tuple>();
 
-		SingleTypeInputs<?> generatedInputs = generatedInputSetsForAllArguments.iterator().next();
+		List<?> generatedInputs = generatedInputSetsForAllArguments.iterator().next();
 
 		for (Object variable : generatedInputs) {
-			ArgumentsForSingleCall argument = new ArgumentsForSingleCall();
+			Tuple argument = new Tuple(variable);
-			argument.add(variable);
 			allPossibleArguments.add(argument);
 		}
 		return allPossibleArguments;
 	}
 
-	private List<SingleTypeInputs<?>> getInputSetsForAllArguments(Class<?> testTarget, Method m) {
+	private List<List<?>> getInputSetsForAllArguments(Class<?> testTarget, Method m) {
-		List<SingleTypeInputs<?>> singleInputSets = new ArrayList<>();
+		List<List<?>> singleInputSets = new ArrayList<>();
 		for (Class<?> parametertype : m.getParameterTypes()) {
-			SingleTypeInputs<?> inputs = tryPrimitives(testTarget, parametertype);
+			List<?> inputs = tryPrimitives(testTarget, parametertype);
 
 			if (inputs == null) {
 				inputs = new MocksFactory().getMockInputs(testTarget, parametertype);

src/nl/jssl/autounit/utils/Permutator.java

@@ -1,25 +0,0 @@
-package nl.jssl.autounit.utils;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
-public class Permutator {
-	public static List<?> permute(List<? extends Object> arr) {
-		List<Object> all = new ArrayList<>();
-		permute(new ArrayList<Object>(arr), 0, all);
-		return all;
-	}
-
-	private static void permute(List<?> arr, int k, List<Object> all) {
-		for (int i = k; i < arr.size(); i++) {
-			Collections.swap(arr, i, k);
-			permute(arr, k + 1, all);
-			Collections.swap(arr, k, i);
-		}
-		if (k == arr.size() - 1) {
-			all.addAll(arr);
-		}
-	}
-
-}

src/nl/jssl/autounit/utils/Permuter.java

@@ -34,10 +34,15 @@ public class Permuter {
 		return pairs;
 	}
 
-	public static class Tuple implements Iterable<Object> {
+	public static class Tuple implements Iterable {
 		public final Object element1;
 		public final Object element2;
 
+		public Tuple(Object element1) {
+			this.element1 = element1;
+			this.element2 = null;
+		}
+
 		public Tuple(Object element1, Object element2) {
 			super();
 			this.element1 = element1;
@@ -46,10 +51,18 @@ public class Permuter {
 
 		@Override
 		public Iterator<Object> iterator() {
+			return asList().iterator();
+		}
+
+		private List<Object> asList() {
 			List<Object> list = new ArrayList<>();
-			add(element1, list);
+			if (element1 != null) {
-			add(element2, list);
+				add(element1, list);
-			return list.iterator();
+			}
+			if (element2 != null) {
+				add(element2, list);
+			}
+			return list;
 		}
 
 		private void add(Object element, List<Object> list) {
@@ -70,5 +83,9 @@ public class Permuter {
 			}
 			return string;
 		}
+
+		public Object[] toArray() {
+			return asList().toArray();
+		}
 	}
 }