iDSpeedy Pull Request #1

.gitignore

@@ -4,3 +4,5 @@ target/
 .*.swp
 *.o
 *.hi
+*.idea
+*.iml

src/main/java/edu/illinois/cs/dt/tools/detection/DetectorPathManager.java

@@ -13,6 +13,7 @@ public class DetectorPathManager extends PathManager {
     public static final Path ORIGINAL_RESULTS_LOG = Paths.get("original-results-ids");
     public static final Path MVN_TEST_LOG = Paths.get("mvn-test.log");
     public static final Path MVN_TEST_TIME_LOG = Paths.get("mvn-test-time.log");
+    public static final Path PREVIOUS_ORDERS = Paths.get("previous-orders.json");
 
     public static Path detectionResults() {
         return path(DETECTION_RESULTS);
@@ -57,4 +58,6 @@ public static Path mvnTestLog() {
     public static Path mvnTestTimeLog() {
         return parentPath(MVN_TEST_TIME_LOG);
     }
+
+    public static Path previousOrders() {return path(PREVIOUS_ORDERS);}
 }

src/main/java/edu/illinois/cs/dt/tools/detection/SmartShuffler.java

@@ -1,14 +1,19 @@
 package edu.illinois.cs.dt.tools.detection;
 
+import com.google.common.math.IntMath;
+import com.google.gson.Gson;
+import com.google.gson.reflect.TypeToken;
+import com.google.gson.stream.JsonReader;
 import com.reedoei.eunomia.collections.RandomList;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Set;
+import edu.illinois.cs.dt.tools.utility.MD5;
+
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.nio.file.Files;
+import java.nio.file.StandardOpenOption;
+import java.util.*;
 import java.util.stream.Collectors;
 
 public class SmartShuffler {
@@ -19,6 +24,7 @@ public class SmartShuffler {
     private final HashMap<String, String> methodToClass;
 
     private final RandomList<String> tests;
+    private Set<String> alreadySeenOrders = new HashSet<>();
 
     public SmartShuffler(final List<String> tests) {
         this.tests = new RandomList<>(tests);
@@ -39,6 +45,18 @@ public SmartShuffler(final List<String> tests) {
             classToMethods.get(className).add(test);
             methodToClass.put(test, className);
         }
+
+        //Load all previous orders into alreadySeenOrders
+        try {
+            JsonReader getLocalJsonFile = new JsonReader(new FileReader(DetectorPathManager.previousOrders().toString()));
+            Type mapTokenType = new TypeToken<Set<String>>(){}.getType();
+            Set<String> jsonMapOrders = new Gson().fromJson(getLocalJsonFile, mapTokenType);
+            if(jsonMapOrders != null) {
+                alreadySeenOrders = jsonMapOrders;
+            }
+        } catch (FileNotFoundException e) {
+            System.out.println("No previous orders tracked");
+        }
     }
 
     private RandomList<String> testSiblings(final String testName) {
@@ -58,7 +76,22 @@ private final void addTestMethods(final List<String> order, final Optional<Strin
         }
     }
 
-    public List<String> nextOrder() {
+    public List<String> generateOrder(){
+        List<String> nextOrder = nextOrder();
+        String hashedOrder = MD5.md5(String.join("", nextOrder));
+        while(alreadySeenOrders.contains(hashedOrder)){
+            nextOrder = nextOrder();
+            hashedOrder = MD5.md5(String.join("", nextOrder));
+        }
+
+        alreadySeenOrders.add(hashedOrder);
+        if(toComeFirst.isEmpty() && toComeLast.isEmpty()) {
+            saveOrders();
+        }
+        return nextOrder;
+    }
+
+    private List<String> nextOrder() {
         final Optional<String> first = sample(toComeFirst);
         final Optional<String> last = first.isPresent() ? sample(toComeLast, first.get()) : sample(toComeLast);
 
@@ -82,7 +115,6 @@ public List<String> nextOrder() {
             order.remove(last.get());
             order.add(last.get());
         }
-
         return order;
     }
 
@@ -99,4 +131,36 @@ private Optional<String> sample(final RandomList<String> from, final Set<String>
 
         return Optional.empty();
     }
+
+    public int ordersTried(){
+        return alreadySeenOrders.size();
+    }
+
+    public void saveOrders(){
+        Gson gson = new Gson();
+        Type gsonType = new TypeToken<Set>(){}.getType();
+        String gsonString = gson.toJson(alreadySeenOrders, gsonType);
+        try {
+            Files.write(DetectorPathManager.previousOrders(), gsonString.getBytes(),
+                    Files.exists(DetectorPathManager.previousOrders()) ? StandardOpenOption.WRITE : StandardOpenOption.CREATE);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public long calculatePermutations() {
+        int numClasses = 0;
+        long numPermutations = 1;
+        Iterator<String> it = classToMethods.keySet().iterator();
+        while (it.hasNext()){
+            String className = it.next();
+            int numTests = classToMethods.get(className).size();
+            numPermutations *= IntMath.factorial(numTests);
+            numClasses++;
+        }
+
+        // formula
+        long maxPermutations = IntMath.factorial(numClasses) * numPermutations;
+        return maxPermutations;
+    }
 }

src/main/java/edu/illinois/cs/dt/tools/detection/TestShuffler.java

@@ -3,6 +3,8 @@
 import com.google.common.collect.Lists;
 import com.google.common.math.IntMath;
 import com.google.gson.Gson;
+import com.google.gson.reflect.TypeToken;
+import com.google.gson.stream.JsonReader;
 import com.reedoei.eunomia.collections.ListUtil;
 import com.reedoei.eunomia.collections.RandomList;
 import com.reedoei.eunomia.io.files.FileUtil;
@@ -11,9 +13,13 @@
 import edu.illinois.cs.testrunner.configuration.Configuration;
 import edu.illinois.cs.testrunner.data.results.TestRunResult;
 
+import java.io.FileNotFoundException;
+import java.io.FileReader;
 import java.io.IOException;
+import java.lang.reflect.Type;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -31,11 +37,13 @@ public static String className(final String testName) {
 
     private final String type;
     private final List<String> tests;
-    private final Set<String> alreadySeenOrders = new HashSet<>();
+    private Set<String> alreadySeenOrders = new HashSet<>();
+    private int roundsRemaining;
 
     public TestShuffler(final String type, final int rounds, final List<String> tests) {
         this.type = type;
         this.tests = tests;
+        this.roundsRemaining = rounds;
 
         classToMethods = new HashMap<>();
 
@@ -48,6 +56,18 @@ public TestShuffler(final String type, final int rounds, final List<String> test
 
             classToMethods.get(className).add(test);
         }
+
+        //Load all previous orders into alreadySeenOrders
+        try {
+            JsonReader getLocalJsonFile = new JsonReader(new FileReader(DetectorPathManager.previousOrders().toString()));
+            Type mapTokenType = new TypeToken<Set<String>>(){}.getType();
+            Set<String> jsonMapOrders = new Gson().fromJson(getLocalJsonFile, mapTokenType);
+            if(jsonMapOrders != null) {
+                alreadySeenOrders = jsonMapOrders;
+            }
+        } catch (FileNotFoundException e) {
+            System.out.println("No previous orders tracked");
+        }
     }
 
     private String historicalType() {
@@ -75,6 +95,34 @@ public List<String> shuffledOrder(final int i) {
         return generateShuffled();
     }
 
+    public long calculatePermutations() {
+        if (type.equals("random-class-method")) {
+            int numClasses = 0;
+            long numPermutations = 1;
+            Iterator<String> it = classToMethods.keySet().iterator();
+            while (it.hasNext()){
+                String className = it.next();
+                int numTests = classToMethods.get(className).size();
+                numPermutations *= IntMath.factorial(numTests);
+                numClasses++;
+            }
+
+            // formula
+            long maxPermutations = IntMath.factorial(numClasses) * numPermutations;
+            return maxPermutations;
+        }
+        else if (type.equals("random-class")) {
+            int numClasses = 0;
+            Iterator<String> it = classToMethods.keySet().iterator();
+            while (it.hasNext()){
+                numClasses++;
+            }
+            return (long) IntMath.factorial(numClasses);
+        }
+
+        return 0;
+    }
+
     private List<String> reverseOrder() {
         if ("reverse-class".equals(type)) {
             final List<String> reversedClassNames =
@@ -105,7 +153,21 @@ private List<String> generateHistorical(final List<String> historicalOrder) {
     }
 
     private List<String> generateShuffled() {
-        return generateWithClassOrder(new RandomList<>(classToMethods.keySet()).shuffled());
+        List<String> shuffledOrder = generateWithClassOrder(new RandomList<>(classToMethods.keySet()).shuffled());
+        String hashedOrder = MD5.md5(String.join("", shuffledOrder));
+        while(alreadySeenOrders.contains(hashedOrder)){
+            shuffledOrder = generateWithClassOrder(new RandomList<>(classToMethods.keySet()).shuffled());
+            hashedOrder = MD5.md5(String.join("", shuffledOrder));
+        }
+
+        alreadySeenOrders.add(hashedOrder);
+        roundsRemaining--;
+        if(roundsRemaining <= 0) {
+            saveOrders();
+        }
+
+        return shuffledOrder;
+        //return generateWithClassOrder(new RandomList<>(classToMethods.keySet()).shuffled());
     }
 
     private List<String> generateWithClassOrder(final List<String> classOrder) {
@@ -121,15 +183,30 @@ private List<String> generateWithClassOrder(final List<String> classOrder) {
             }
         }
 
-        alreadySeenOrders.add(MD5.md5(String.join("", fullTestOrder)));
-
         return fullTestOrder;
     }
 
     private List<String> classOrder(final List<String> historicalOrder) {
         return historicalOrder.stream().map(TestShuffler::className).distinct().collect(Collectors.toList());
     }
 
+    public int ordersTried(){
+        return alreadySeenOrders.size();
+    }
+
+    public void saveOrders(){
+        Gson gson = new Gson();
+        Type gsonType = new TypeToken<Set>(){}.getType();
+        String gsonString = gson.toJson(alreadySeenOrders, gsonType);
+        try {
+            System.out.println("Printing orders to file");
+            Files.write(DetectorPathManager.previousOrders(), gsonString.getBytes(),
+                    Files.exists(DetectorPathManager.previousOrders()) ? StandardOpenOption.WRITE : StandardOpenOption.CREATE);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
     @Deprecated
     private int permutations(final int rounds) {
         return permutations(IntMath.factorial(classToMethods.keySet().size()), classToMethods.values().iterator(), rounds);

src/main/java/edu/illinois/cs/dt/tools/detection/detectors/ExecutingDetector.java

@@ -96,6 +96,10 @@ public void writeTo(final Path dir) throws IOException {
         Files.write(listPath, StringUtil.unlines(dtList.names()).getBytes());
     }
 
+    protected abstract boolean triedAllOrders(int round);
+
+    protected abstract void printToFile();
+
     private class RunnerIterator implements Iterator<DependentTest> {
 
         private final long origStartTimeMs = System.currentTimeMillis();
@@ -109,10 +113,13 @@ private class RunnerIterator implements Iterator<DependentTest> {
 
         @Override
         public boolean hasNext() {
-            while (i < rounds && result.isEmpty()) {
+            while (i < rounds && result.isEmpty() && !triedAllOrders(i)) {
                 generate();
             }
-
+            if(triedAllOrders(i)) {
+                System.out.println("All orders have been run, ending detector execution");
+                printToFile();
+            }
             return !result.isEmpty();
         }
 

src/main/java/edu/illinois/cs/dt/tools/detection/detectors/OriginalDetector.java

@@ -34,4 +34,12 @@ public OriginalDetector(final Runner runner, final int rounds, final List<String
     public DetectionRound results() throws Exception {
         return makeDts(origResult, runList(tests));
     }
+
+    @Override
+    protected boolean triedAllOrders(int round) {
+        return false;
+    }
+
+    @Override
+    protected void printToFile(){return;}
 }

src/main/java/edu/illinois/cs/dt/tools/detection/detectors/RandomDetector.java

@@ -1,6 +1,9 @@
 package edu.illinois.cs.dt.tools.detection.detectors;
 
+import com.google.gson.Gson;
+import com.google.gson.reflect.TypeToken;
 import edu.illinois.cs.dt.tools.detection.DetectionRound;
+import edu.illinois.cs.dt.tools.detection.DetectorPathManager;
 import edu.illinois.cs.dt.tools.detection.DetectorUtil;
 import edu.illinois.cs.dt.tools.detection.TestShuffler;
 import edu.illinois.cs.dt.tools.detection.filters.ConfirmationFilter;
@@ -9,7 +12,12 @@
 import edu.illinois.cs.testrunner.data.results.TestRunResult;
 import edu.illinois.cs.testrunner.runner.Runner;
 
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.nio.file.Files;
+import java.nio.file.StandardOpenOption;
 import java.util.List;
+import java.util.Set;
 
 public class RandomDetector extends ExecutingDetector {
     private final List<String> tests;
@@ -41,4 +49,20 @@ public DetectionRound results() throws Exception {
 
         return makeDts(origResult, runList(fullTestOrder));
     }
+
+    @Override
+    protected boolean triedAllOrders(int rounds) {
+        long permutations = testShuffler.calculatePermutations();
+        int numTried = testShuffler.ordersTried();
+        if (numTried >= permutations) {
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    protected void printToFile(){
+        testShuffler.saveOrders();
+    }
+
 }

src/main/java/edu/illinois/cs/dt/tools/detection/detectors/ReverseDetector.java

@@ -32,4 +32,17 @@ public DetectionRound results() throws Exception {
         final List<String> reversed = testShuffler.shuffledOrder(absoluteRound.get());
         return makeDts(origResult, runList(reversed));
     }
+
+    @Override
+    protected boolean triedAllOrders(int round) {
+        if (round >= 1) {
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    protected void printToFile(){
+        testShuffler.saveOrders();
+    }
 }