made test really a test and not just a print

Author: pmbittner

src/main/java/de/variantsync/evolution/variability/sequenceextraction/Domino.java

@@ -33,14 +33,14 @@ public static <C extends Commit> Stack<Stack<C>> Sort(final Iterable<EvolutionSt
          */
         final Stack<Stack<C>> chains = new Stack<>();
 
-        System.out.println("Step 1: Build Chains");
+//        System.out.println("Step 1: Build Chains");
         buildChains : for (final EvolutionStep<C> domino : dominos) {
-            System.out.println("  Found " + domino);
+//            System.out.println("  Found " + domino);
             // push the domino to an existing stack if possible
             for (final Stack<C> row : chains) {
                 if (row.peek().equals(domino.parent())) {
                     row.push(domino.child());
-                    System.out.println("  Pushed it to chain " + row);
+//                    System.out.println("  Pushed it to chain " + row);
                     continue buildChains;
                 }
             }
@@ -50,39 +50,39 @@ public static <C extends Commit> Stack<Stack<C>> Sort(final Iterable<EvolutionSt
             newRow.add(domino.parent());
             newRow.add(domino.child());
             chains.push(newRow);
-            System.out.println("  Created new chain " + newRow);
+//            System.out.println("  Created new chain " + newRow);
         }
 
 
-        System.out.println("Result of step 1: " + chains);
+//        System.out.println("Result of step 1: " + chains);
 
         /*
          * Second, merge all chains by stacking them ontop of each other.
          * Repeat this until we cannot merge any chains.
          */
-        System.out.println("Step 2: Merge Chains");
+//        System.out.println("Step 2: Merge Chains");
         final Stack<Stack<C>> finalRows = new Stack<>();
         while (!chains.isEmpty()) {
             // Pick one of the chains ...
             Stack<C> current = chains.pop();
-            System.out.println("  Inspecting " + current);
+//            System.out.println("  Inspecting " + current);
             // ... and merge it with the other chains as long as possible.
             final Set<Stack<C>> mergedStacks = new HashSet<>();
             do {
                 mergedStacks.clear();
                 for (final Stack<C> other : chains) {
                     if (current.firstElement().equals(other.lastElement())) {
-                        System.out.println("    pushing it to " + other);
+//                        System.out.println("    pushing it to " + other);
                         other.pop();
                         StackUtil.pushAToB(current, other);
                         current = other;
-                        System.out.println("    got " + current);
+//                        System.out.println("    got " + current);
                         mergedStacks.add(other);
                     } else if (other.firstElement().equals(current.lastElement())) {
-                        System.out.println("    pushed " + other + " onto it");
+//                        System.out.println("    pushed " + other + " onto it");
                         current.pop();
                         StackUtil.pushAToB(other, current);
-                        System.out.println("    got " + current);
+//                        System.out.println("    got " + current);
                         mergedStacks.add(other);
                     }
                 }

src/test/java/de/variantsync/evolution/EvolutionStepTest.java

@@ -6,28 +6,68 @@
 import de.variantsync.evolution.variability.EvolutionStep;
 import de.variantsync.evolution.variability.sequenceextraction.CleaningEvolutionStepsStream;
 import org.junit.Assert;
+import org.junit.Before;
 import org.junit.Test;
 
-import java.util.List;
-import java.util.Stack;
+import java.util.*;
 
 public class EvolutionStepTest {
     private static class TestCommit extends Commit implements CachedValue {
+        private boolean forgot = false;
         public TestCommit(final String commitId) {
             super(commitId);
         }
         @Override
         public void forget() {
+            forgot = true;
             System.out.println("forget(" + super.id() + ")");
         }
+
+        public boolean forgotten() {
+            return forgot;
+        }
     }
 
-    private static TestCommit commit(final String id) {
-        return new TestCommit(id);
+    private static TestCommit commit(final int id) {
+        return new TestCommit("" + id);
     }
 
-    private static EvolutionStep<TestCommit> step(final String parent, final String child) {
-        return new EvolutionStep<>(commit(parent), commit(child));
+    private static EvolutionStep<TestCommit> step(final TestCommit parent, final TestCommit child) {
+        return new EvolutionStep<>(parent, child);
+    }
+
+    private static EvolutionStep<TestCommit> step(final Map<Integer, TestCommit> commits, final int parent, final int child) {
+        return step(commits.get(parent), commits.get(child));
+    }
+
+    private Map<Integer, TestCommit> successCommits;
+    // valid pairs of commits
+    private EvolutionStep<TestCommit>
+            s12,
+            s23,
+            s34,
+            s45,
+            s1011,
+            s1112,
+            s1213;
+
+    @Before
+    public void generateInput() {
+        successCommits = new HashMap<>();
+        for (int i = 1; i <= 5; ++i) {
+            successCommits.put(i, commit(i));
+        }
+        for (int i = 10; i <= 13; ++i) {
+            successCommits.put(i, commit(i));
+        }
+
+        s12 = step(successCommits, 1, 2);
+        s23 = step(successCommits, 2, 3);
+        s34 = step(successCommits, 3, 4);
+        s45 = step(successCommits, 4, 5);
+        s1011 = step(successCommits, 10, 11);
+        s1112 = step(successCommits, 11, 12);
+        s1213 = step(successCommits, 12, 13);
     }
 
     @Test
@@ -50,22 +90,52 @@ public void testMergeStacks() {
 
     @Test
     public void evolSteps() {
+        // random order of commit pairs
         final List<EvolutionStep<TestCommit>> input = List.of(
-                step("1", "2"),
-                step("4", "5"),
-                step("2", "3"),
-                step("3", "4"),
-
-                step("12", "13"),
-                step("10", "11"),
-                step("11", "12")
+                s12,
+                s45,
+                s23,
+                s34,
+
+                s1213,
+                s1011,
+                s1112
+        );
+
+        // we expect two ordered sublists (in reverse order)
+        final List<List<EvolutionStep<TestCommit>>> expectedOutputSequences = List.of(
+                new ArrayList<>(List.of(s45, s34, s23, s12)),
+                new ArrayList<>(List.of(s1213, s1112, s1011))
         );
 
         final CleaningEvolutionStepsStream<TestCommit> steps = new CleaningEvolutionStepsStream<>(input);
         System.out.println("Sorted steps: " + steps);
 
+        List<EvolutionStep<TestCommit>> currentExpectedOutput = null;
         for (final EvolutionStep<TestCommit> step : steps) {
-            System.out.println("Processing " + step);
+//            System.out.println("Processing " + step);
+
+            if (currentExpectedOutput == null) {
+                for (final List<EvolutionStep<TestCommit>> expectedChain : expectedOutputSequences) {
+                    if (!expectedChain.isEmpty() && step.equals(expectedChain.get(0))) {
+                        currentExpectedOutput = expectedChain;
+                        break;
+                    }
+                }
+                if (currentExpectedOutput == null) {
+                    Assert.fail("Found step " + step + " is not the start of any expected output sequence " + expectedOutputSequences + "!");
+                }
+            }
+
+            Assert.assertEquals(step, currentExpectedOutput.get(0));
+            currentExpectedOutput.remove(0);
+            if (currentExpectedOutput.isEmpty()) {
+                currentExpectedOutput = null;
+            }
+        }
+
+        for (final TestCommit c : successCommits.values()) {
+            Assert.assertTrue("Commit " + c + " is still cached!", c.forgotten());
         }
     }
 }