Branch generation

Author: jamesrcounts

src/main/java/org/teachingextensions/approvals/lite/Approvals.java

@@ -19,12 +19,17 @@ public static void verify(String response) throws Exception {
   }
 
   public static <T> void verifyAll(String header, T[] values) {
-    Approvals.verifyAll(header, Arrays.asList(values), new Function1<T, String>() {
+    Approvals.verifyAll(header, Arrays.asList(values));
+  }
+
+  public static <T> void verifyAll(String header, Iterable<T> values) {
+    Approvals.verifyAll(header, values, new Function1<T, String>() {
       @Override
       public String call(T i) {
         return i + "";
       }
     });
+
   }
 
   public static <T> void verifyAll(String header, T[] values,

src/main/java/org/teachingextensions/approvals/lite/reporters/macosx/BeyondCompareReporter.java

@@ -0,0 +1,16 @@
+package org.teachingextensions.approvals.lite.reporters.macosx;
+
+import org.teachingextensions.approvals.lite.reporters.GenericDiffReporter;
+
+import java.text.MessageFormat;
+
+public class BeyondCompareReporter extends GenericDiffReporter {
+  public static final BeyondCompareReporter INSTANCE     = new BeyondCompareReporter();
+  static final        String                DIFF_PROGRAM = "/usr/local/bin/bcompare";
+  static final        String                MESSAGE      = MessageFormat.format(
+      "Unable to find Beyond Compare at {0}", DIFF_PROGRAM);
+
+  public BeyondCompareReporter() {
+    super(DIFF_PROGRAM, MESSAGE);
+  }
+}

src/main/java/org/teachingextensions/approvals/lite/reporters/macosx/DiffMergeReporter.java

@@ -5,12 +5,12 @@
 import java.text.MessageFormat;
 
 public class DiffMergeReporter extends GenericDiffReporter {
-    private static final String DIFF_PROGRAM = "/Applications/DiffMerge.app/Contents/MacOS/DiffMerge";
-    static final String MESSAGE = MessageFormat.format("Unable to find DiffMerge at {0}",
-            DIFF_PROGRAM);
-    public static final DiffMergeReporter INSTANCE = new DiffMergeReporter();
+  public static final  DiffMergeReporter INSTANCE     = new DiffMergeReporter();
+  private static final String            DIFF_PROGRAM = "/Applications/DiffMerge.app/Contents/MacOS/DiffMerge";
+  static final         String            MESSAGE      = MessageFormat.format("Unable to find DiffMerge at {0}",
+      DIFF_PROGRAM);
 
-    public DiffMergeReporter() {
-        super(DIFF_PROGRAM, GenericDiffReporter.STANDARD_ARGUMENTS, MESSAGE, GenericDiffReporter.TEXT_FILE_EXTENSIONS);
-    }
+  public DiffMergeReporter() {
+    super(DIFF_PROGRAM, GenericDiffReporter.STANDARD_ARGUMENTS, MESSAGE, GenericDiffReporter.TEXT_FILE_EXTENSIONS);
+  }
 }

src/main/java/org/teachingextensions/logo/Puzzle.java

@@ -46,4 +46,9 @@ public Puzzle swapBlank(int target) {
     copy[target] = 8;
     return new Puzzle(copy);
   }
+
+  @Override
+  public String toString() {
+    return Arrays.toString(cells);
+  }
 }

src/main/java/org/teachingextensions/logo/PuzzleState.java

@@ -1,16 +1,80 @@
 package org.teachingextensions.logo;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Stack;
+
 /**
  * Represents a node in the puzzle-solving graph.  Keeps track of the current puzzle arrangement and the actions
  * required to arrive at the current arrangement from the starting arrangement.
  */
 public class PuzzleState {
-  public enum Directions {
+  private final Puzzle           puzzle;
+  private final Stack<Direction> history;
+
+  public PuzzleState(Puzzle puzzle) {
+    this(puzzle, new Stack<Direction>());
+  }
+
+  public PuzzleState(Puzzle puzzle, Stack<Direction> history) {
+    this.puzzle = puzzle;
+    this.history = history;
+  }
+
+  public boolean isSolution() {
+    return puzzle.isSolved();
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder b = new StringBuilder();
+    if (!history.isEmpty()) {
+      b.append(history.peek());
+      b.append(" to ");
+    }
+
+    b.append(puzzle);
+    return b.toString();
+  }
+
+
+  public List<PuzzleState> getBranches() {
+    List<PuzzleState> branches = new ArrayList<>(4);
+    int blank = puzzle.getBlankIndex();
+    int x = blank % 3;
+    int y = blank / 3;
+    for (Direction d : Direction.values()) {
+      if (d == Direction.Left && x == 0) {
+        continue;
+      }
+
+      if (d == Direction.Right && x == 2) {
+        continue;
+      }
+
+      if (d == Direction.Up && y == 0) {
+        continue;
+      }
+
+      if (d == Direction.Down && y == 2) {
+        continue;
+      }
+
+      Stack<Direction> h = new Stack<>();
+      h.addAll(history);
+      h.push(d);
+      branches.add(new PuzzleState(puzzle.swapBlank(blank + d.getValue()), h));
+    }
+
+    return branches;
+  }
+
+  public enum Direction {
     Left(-1), Right(1), Up(-3), Down(3);
 
     private final int value;
 
-    private Directions(int i) {
+    private Direction(int i) {
       this.value = i;
     }
 

src/test/java/org/teachingextensions/logo/PuzzleStateTest.java

@@ -2,18 +2,76 @@
 
 import org.junit.Test;
 import org.teachingextensions.approvals.lite.Approvals;
-import org.teachingextensions.approvals.lite.reporters.FileLauncherReporter;
 import org.teachingextensions.approvals.lite.reporters.UseReporter;
+import org.teachingextensions.approvals.lite.reporters.macosx.BeyondCompareReporter;
 
-@UseReporter(FileLauncherReporter.class)
+import static org.junit.Assert.assertTrue;
+
+@UseReporter(BeyondCompareReporter.class)
 public class PuzzleStateTest {
 
+  private static Puzzle getSolvedPuzzle() {
+    int[] solved = {0, 1, 2, 3, 4, 5, 6, 7, 8};
+    return new Puzzle(solved);
+  }
+
+  private static Puzzle getPuzzle(int blank) {
+    return getSolvedPuzzle().swapBlank(blank);
+  }
+
   /**
    * The state can tell you what moves are allowed from cell to cell
    */
   @Test
-  public void state_has_move_directions(){
-  StringBuilder b = new StringBuilder();
-    Approvals.verifyAll("Directions", PuzzleState.Directions.values());
+  public void state_has_move_directions() {
+    Approvals.verifyAll("Directions", PuzzleState.Direction.values());
+  }
+
+  /**
+   * The state can tell you if it is a solution to the puzzle
+   */
+  @Test
+  public void state_can_be_solution() {
+    Puzzle p = getSolvedPuzzle();
+    PuzzleState s = new PuzzleState(p);
+    assertTrue(s.isSolution());
+  }
+
+  /**
+   * The state can tell you all possible next moves for its puzzle.
+   */
+  @Test
+  public void tells_you_next_moves() {
+    PuzzleState s = new PuzzleState(getSolvedPuzzle());
+    Approvals.verifyAll("Branches for " + s, s.getBranches());
+  }
+
+  /**
+   * Or we can see the next moves from the top right corner
+   */
+  @Test
+  public void moves_from_top_right() {
+    Puzzle p = getPuzzle(2);
+    PuzzleState s = new PuzzleState(p);
+    Approvals.verifyAll("Branches for " + s, s.getBranches());
+  }
+
+  /**
+   * Or we can see the next moves from the center
+   */
+  @Test
+  public void moves_from_center(){
+    Puzzle p = getPuzzle(4);
+    PuzzleState s = new PuzzleState(p);
+    Approvals.verifyAll("Branches for " + s, s.getBranches());
+  }
+
+  /**
+   * Finally, lets see what moves we can do from top center.
+   */
+  @Test
+  public void moves_from_top_center(){
+    PuzzleState s = new PuzzleState(getPuzzle(1));
+    Approvals.verifyAll("Branches for " + s, s.getBranches());
   }
 }

src/test/java/org/teachingextensions/logo/PuzzleStateTest.moves_from_center.approved.txt

@@ -0,0 +1,7 @@
+Branches for [0, 1, 2, 3, 8, 5, 6, 7, 4]
+
+
+{Left = -1} to [0, 1, 2, 8, 3, 5, 6, 7, 4]
+{Right = 1} to [0, 1, 2, 3, 5, 8, 6, 7, 4]
+{Up = -3} to [0, 8, 2, 3, 1, 5, 6, 7, 4]
+{Down = 3} to [0, 1, 2, 3, 7, 5, 6, 8, 4]

src/test/java/org/teachingextensions/logo/PuzzleStateTest.moves_from_top_center.approved.txt

@@ -0,0 +1,6 @@
+Branches for [0, 8, 2, 3, 4, 5, 6, 7, 1]
+
+
+{Left = -1} to [8, 0, 2, 3, 4, 5, 6, 7, 1]
+{Right = 1} to [0, 2, 8, 3, 4, 5, 6, 7, 1]
+{Down = 3} to [0, 4, 2, 3, 8, 5, 6, 7, 1]

src/test/java/org/teachingextensions/logo/PuzzleStateTest.moves_from_top_right.approved.txt

@@ -0,0 +1,5 @@
+Branches for [0, 1, 8, 3, 4, 5, 6, 7, 2]
+
+
+{Left = -1} to [0, 8, 1, 3, 4, 5, 6, 7, 2]
+{Down = 3} to [0, 1, 5, 3, 4, 8, 6, 7, 2]

src/test/java/org/teachingextensions/logo/PuzzleStateTest.tells_you_next_moves.approved.txt

@@ -0,0 +1,5 @@
+Branches for [0, 1, 2, 3, 4, 5, 6, 7, 8]
+
+
+{Left = -1} to [0, 1, 2, 3, 4, 5, 6, 8, 7]
+{Up = -3} to [0, 1, 2, 3, 4, 8, 6, 7, 5]