added correct permuter

nl.jssl.autounit.testclasses.FloatArguments.xml

@@ -5,7 +5,7 @@
       <contents>
         <case>
           <input class="args">
-            <arg1>-7.5912475E37</arg1>
+            <arg1>-Infinity</arg1>
           </input>
           <output class="int">-2147483648</output>
         </case>

nl.jssl.autounit.testclasses.IntArguments.xml

@@ -1,34 +1,36 @@
 <map>
-  <entry>
-    <string>public java.lang.String evenOrUneven(int arg1)</string>
-    <results>
-      <contents>
-        <case>
-          <input class="args">
-            <arg1>-819817314</arg1>
-          </input>
-          <output class="string">even</output>
-        </case>
-        <case>
-          <input class="args">
-            <arg1>-916902647</arg1>
-          </input>
-          <output class="string">uneven</output>
-        </case>
-      </contents>
-    </results>
-  </entry>
   <entry>
     <string>public int randomOther(int arg1)</string>
     <results>
       <contents>
         <case>
           <input class="args">
-            <arg1>-1762850486</arg1>
+            <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">
+            <arg1>-2147483648</arg1>
+            <arg1>-2147483648</arg1>
+          </input>
+          <output class="string">even</output>
+        </case>
+        <case>
+          <input class="args">
+            <arg1>-1</arg1>
+            <arg1>-1</arg1>
+          </input>
+          <output class="string">uneven</output>
+        </case>
+      </contents>
+    </results>
+  </entry>
 </map>

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

@@ -28,24 +28,25 @@ public class CombinedInputSetFactory {
 		} else {
 			List<ArgumentsForSingleCall> allPossibleArguments = new ArrayList<>();
 
-			for (SingleTypeInputs<?> inputs : inputSetsForAllArguments) {
+//			for (SingleTypeInputs<?> inputs : inputSetsForAllArguments) {
-				// make list of all permutations of first argument values
+//				// make list of all permutations of first argument values
-				List<?> permutatedInputs = Permutator.permute(inputs);
+//				List<?> permutatedInputs = Permutator.permute(inputs);
-				int index = 0;
+//				int index = 0;
-				for (Object variable : permutatedInputs) {
+//				for (Object variable : permutatedInputs) {
-					// all lists ("columns") are combined into "rows"
+//					// all lists ("columns") are combined into "rows"
-					if (index >= allPossibleArguments.size()) {
+//					if (index >= allPossibleArguments.size()) {
-						ArgumentsForSingleCall a = new ArgumentsForSingleCall();
+//						ArgumentsForSingleCall a = new ArgumentsForSingleCall();
-						a.add(variable);
+//						a.add(variable);
-						allPossibleArguments.add(a);
+//						allPossibleArguments.add(a);
-					} else {
+//					} else {
-						ArgumentsForSingleCall argumentsForSingleCall = allPossibleArguments.get(index);
+//						ArgumentsForSingleCall argumentsForSingleCall = allPossibleArguments.get(index);
-						argumentsForSingleCall.add(variable);
+//						argumentsForSingleCall.add(variable);
-					}
+//					}
-					index++;
+//					index++;
-				}
+//				}
-			}
+//			}
 			// the row view
+			
 			return allPossibleArguments;
 		}
 

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

@@ -4,15 +4,13 @@ public class IntegerInputsFactory implements InputsFactory<Integer> {
 
 	public SingleTypeInputs<Integer> getInputs(Class<?> testTarget) {
 		SingleTypeInputs<Integer> inputs = new SingleTypeInputs<Integer>();
-		for (int i = 0; i < 1000; i++) {
+//		for (int i = 0; i < 2; i++) {
-			inputs.add((int) ((2 * Math.random() - 2) * Integer.MAX_VALUE));
+//			inputs.add((int) ((2 * Math.random() - 2) * Integer.MAX_VALUE));
-		}
+//		}
 		inputs.add(Integer.MIN_VALUE);
-		inputs.add(-2);
 		inputs.add(-1);
 		inputs.add(0);
 		inputs.add(1);
-		inputs.add(2);
 		inputs.add(Integer.MAX_VALUE);
 		return inputs;
 	}

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

@@ -0,0 +1,72 @@
+package nl.jssl.autounit.utils;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public class Permuter {
+
+	public static List<Tuple> permute(List<List<?>> elements) {
+		if (elements.size() > 2) {
+			return permute(elements.get(0), elements.subList(1, elements.size() - 1));
+		} else if (elements.size() == 2) {
+			return permutePairs(elements.get(0), elements.get(1));
+		} else
+			throw new IllegalArgumentException("need at least 2");
+	}
+
+	private static List<Tuple> permute(List<?> list, List<List<?>> elements) {
+		if (elements.size() > 2) {
+			return permute(elements.get(0), elements.subList(1, elements.size() - 1));
+		} else {
+			return permutePairs(elements.get(0), elements.get(1));
+		}
+	}
+
+	private static List<Tuple> permutePairs(List<?> list1, List<?> list2) {
+		List<Tuple> pairs = new ArrayList<>();
+		for (Object element1 : list1) {
+			for (Object element2 : list2) {
+				pairs.add(new Tuple(element1, element2));
+			}
+		}
+		return pairs;
+	}
+
+	public static class Tuple implements Iterable<Object> {
+		public final Object element1;
+		public final Object element2;
+
+		public Tuple(Object element1, Object element2) {
+			super();
+			this.element1 = element1;
+			this.element2 = element2;
+		}
+
+		@Override
+		public Iterator<Object> iterator() {
+			List<Object> list = new ArrayList<>();
+			add(element1, list);
+			add(element2, list);
+			return list.iterator();
+		}
+
+		private void add(Object element, List<Object> list) {
+			if (!(element instanceof Tuple)) {
+				list.add(element);
+			} else {
+				Tuple pair = (Tuple) element;
+				add(pair.element1, list);
+				add(pair.element2, list);
+			}
+		}
+		@Override
+		public String toString() {
+			String string="";
+			for (Object o:this){
+				string+=o.toString()+",";
+			}
+			return string;
+		}
+	}
+}

testclasses/nl/jssl/autounit/testclasses/IntArguments.java

@@ -1,8 +1,8 @@
 package nl.jssl.autounit.testclasses;
 
 public class IntArguments {
-	public String evenOrUneven(int number) {
+	public String evenOrUneven(int number, int number2) {
-		if (number % 2 == 0)
+		if ((number+number2)/2 % 2 == 0)
 			return "even";
 		else
 			return "uneven";

tst/nl/jssl/autounit/ManualTest.java

@@ -1,19 +0,0 @@
-package nl.jssl.autounit;
-import junit.framework.Assert;
-
-import nl.jssl.autounit.testclasses.IntArguments;
-
-import org.junit.Test;
-
-public class ManualTest {
-    @Test
-    public void testEven() {
-        Assert.assertEquals("even", new IntArguments().evenOrUneven(2));
-    }
-
-    @Test
-    public void testUneven() {
-        Assert.assertEquals("uneven", new IntArguments().evenOrUneven(3));
-    }
-
-}

tst/nl/jssl/autounit/PrimtiveTypeTests.java

@@ -27,7 +27,7 @@ public class PrimtiveTypeTests {
 	public void testIntegerArgument() {
 		Map<String, MethodCallResults> results = new AutoTester().record(IntArguments.class);
 		Set<String> keys = results.keySet();
-		assertTrue(keys.contains("public java.lang.String evenOrUneven(int arg1)"));
+		assertTrue(keys.contains("public java.lang.String evenOrUneven(int arg1,int arg2)"));
 		MethodCallResults mcr = results.values().iterator().next();
 		System.out.println(mcr.getCoverageResult().getLineCounter().getMissedCount() + " missed lines");
 		System.out.println(mcr.getReport());

tst/nl/jssl/autounit/util/PermuterTests.java

@@ -0,0 +1,31 @@
+package nl.jssl.autounit.util;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import nl.jssl.autounit.utils.Permuter;
+import nl.jssl.autounit.utils.Permuter.Tuple;
+
+import org.junit.Test;
+
+public class PermuterTests {
+	@Test
+	public void test(){
+		List<Integer> integers=new ArrayList<>();
+		integers.add(1);
+		integers.add(2);
+		List<String> strings=new ArrayList<>();
+		strings.add("A");
+		strings.add("B");
+		List<List<?>> outer=new ArrayList<>();
+		outer.add(integers);
+		outer.add(strings);
+		List<Tuple> permuted = Permuter.permute(outer);
+		assertEquals("1,A,",permuted.get(0).toString());
+		assertEquals("1,B,",permuted.get(1).toString());
+		assertEquals("2,A,",permuted.get(2).toString());
+		assertEquals("2,B,",permuted.get(3).toString());
+	}
+}