Equality checks

Author: jamesrcounts

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

@@ -16,6 +16,27 @@ public Puzzle(int[] cells) {
     this.cells = cells;
   }
 
+  @Override
+  public int hashCode() {
+    return Arrays.hashCode(cells);
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+
+    Puzzle puzzle = (Puzzle) o;
+
+    return Arrays.equals(cells, puzzle.cells);
+
+  }
+
+  @Override
+  public String toString() {
+    return Arrays.toString(cells);
+  }
+
   public boolean isSolved() {
     for (int i = 0; i < solution.length; i++) {
       if (solution[i] != cells[i]) {
@@ -36,7 +57,9 @@ public int getBlankIndex() {
 
   /**
    * Create a copy of the puzzle where the blank swapped with the value in the target position
-   * @param target move the blank to this location, and move the value from this location to the current blank location
+   *
+   * @param target
+   *     move the blank to this location, and move the value from this location to the current blank location
    * @return A copy of the puzzle with the blank and target swapped.
    */
   public Puzzle swapBlank(int target) {
@@ -46,9 +69,4 @@ 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/PuzzlePlayer.java

@@ -37,8 +37,6 @@ public PuzzleState solve() {
       if (!state.isSolution()) {
         this.search(state);
         state = getFrontier().remove();
-      }else{
-        continue;
       }
     } while (!state.isSolution());
 

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

@@ -88,10 +88,26 @@ public int compare(PuzzleState o1, PuzzleState o2) {
   }
 
   @Override
-  public int compareTo(PuzzleState o) {
+  public int compareTo( PuzzleState o) {
     return compare(this, o);
   }
 
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+
+    PuzzleState that = (PuzzleState) o;
+
+    return puzzle.equals(that.puzzle);
+
+  }
+
+  @Override
+  public int hashCode() {
+    return puzzle.hashCode();
+  }
+
   public enum Direction {
     Left(-1), Right(1), Up(-3), Down(3);
 

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

@@ -1,6 +1,7 @@
 package org.teachingextensions.logo;
 
 import org.junit.Test;
+import org.teachingextensions.approvals.lite.Approvals;
 import org.teachingextensions.approvals.lite.reporters.UseReporter;
 import org.teachingextensions.approvals.lite.reporters.macosx.BeyondCompareReporter;
 
@@ -27,4 +28,17 @@ public void solve_puzzle() throws Exception {
   public void solve_longer_puzzle() throws Exception {
     verifyLongSolution();
   }
+
+  /**
+   * Solve jumbo puzzle
+   */
+  @Test
+  public void solve_jumbo_puzzle() throws Exception {
+    int[] cells = {8, 0, 1, 2, 3, 4, 5, 6, 7};
+    Puzzle p = new Puzzle(cells);
+    PuzzlePlayer b = getPlayer(p);
+
+    PuzzleState s = b.solve();
+    Approvals.verifyAll("From " + p + " to " + s.getPuzzle(), s.getHistory());
+  }
 }

src/test/java/org/teachingextensions/logo/BreadthFirstPlayerTest.solve_jumbo_puzzle.approved.txt

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

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

@@ -7,8 +7,7 @@
 
 import java.util.Stack;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.*;
 
 @UseReporter(BeyondCompareReporter.class)
 public class PuzzleStateTest {
@@ -98,4 +97,36 @@ public void actual_cost_is_actual_steps() {
     PuzzleState s = new PuzzleState(getSolvedPuzzle(), history);
     assertEquals(2, s.getActualCost());
   }
+
+  /**
+   * Is not equal to another state when the puzzles are different
+   */
+  @Test
+  public void not_equal_to_state_with_different_puzzle() {
+    PuzzleState a = new PuzzleState(getSolvedPuzzle());
+    PuzzleState b = new PuzzleState(getPuzzle(2));
+    assertNotEquals(a, b);
+  }
+
+  /**
+   * Is equal to another state when the puzzles are the same
+   */
+  @Test
+  public void equal_to_state_with_same_puzzle() {
+    PuzzleState a = new PuzzleState(getPuzzle(1));
+    PuzzleState b = new PuzzleState(getPuzzle(1));
+    assertTrue(a.equals(b));
+  }
+
+  /**
+   * Is equal to state with same puzzle even when history differs
+   */
+  @Test
+  public void equal_even_with_different_history() {
+    Stack<PuzzleState.Direction> history = new Stack<>();
+    history.add(PuzzleState.Direction.Right);
+    PuzzleState a = new PuzzleState(getPuzzle(3), history);
+    PuzzleState b = new PuzzleState(getPuzzle(3));
+    assertEquals(a, b);
+  }
 }

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

@@ -4,9 +4,7 @@
 
 import java.util.Arrays;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.*;
 
 public class PuzzleTest {
   private static int[] getSolution() {
@@ -46,7 +44,7 @@ public void puzzle_not_solved() {
    * A puzzle has a blank
    */
   @Test
-  public void puzzle_has_blank(){
+  public void puzzle_has_blank() {
     Puzzle p = new Puzzle(getSolution());
     assertEquals(8, p.getBlankIndex());
   }
@@ -55,7 +53,7 @@ public void puzzle_has_blank(){
    * Blank can be anywhere
    */
   @Test
-  public void blank_can_be_anywhere(){
+  public void blank_can_be_anywhere() {
     int[] cells = swap(getSolution(), 8, 2);
     Puzzle p = new Puzzle(cells);
     assertEquals(2, p.getBlankIndex());
@@ -65,7 +63,7 @@ public void blank_can_be_anywhere(){
    * Puzzle can swap blank for you
    */
   @Test
-  public void puzzle_can_swap_blank(){
+  public void puzzle_can_swap_blank() {
     Puzzle p = new Puzzle(getSolution());
     Puzzle c = p.swapBlank(4);
     assertEquals(4, c.getBlankIndex());
@@ -75,10 +73,30 @@ public void puzzle_can_swap_blank(){
    * Puzzle can swap blank for you
    */
   @Test
-  public void blank_swap_leaves_original_as_is(){
+  public void blank_swap_leaves_original_as_is() {
     Puzzle p = new Puzzle(getSolution());
     p.swapBlank(4);
     assertEquals(8, p.getBlankIndex());
   }
 
+  /**
+   * Puzzle is not equal to a puzzle with different cells.
+   */
+  @Test
+  public void different_cells_means_different_puzzle() {
+    Puzzle a = new Puzzle(getSolution());
+    Puzzle b = new Puzzle(swap(getSolution(), 8, 2));
+    assertNotEquals(a, b);
+  }
+
+  /**
+   * Puzzle is equal to a puzzle with the same cells.
+   */
+  @Test
+  public void same_cells_means_same_puzzle() {
+    Puzzle a = new Puzzle(swap(getSolution(), 8, 3));
+    Puzzle b = new Puzzle(swap(getSolution(), 8, 3));
+    assertEquals(a, b);
+  }
+
 }