BoardTest.java

import org.junit.Test;

import static junit.framework.TestCase.assertEquals;
import static junit.framework.TestCase.assertFalse;
import static junit.framework.TestCase.assertTrue;
import static org.junit.Assert.assertNotEquals;

public class BoardTest {

    @Test
    public void dimension() {
        // Arrange
        int[][] tiles = new int[][] {
                {1, 2, 3},
                {4, 5, 6},
                {7, 8, 0}
        };
        Board board = new Board(tiles);

        // Act
        int dimension = board.dimension();

        // Assert
        assertEquals(3, dimension);
    }

    @Test
    public void toString_whenSomeTilesPresent() {
        // Arrange
        int[][] tiles = new int[][] {
                {1, 0, 3},
                {4, 2, 5},
                {7, 8, 6}
        };
        Board board = new Board(tiles);

        // Act
        String expectedString = "3\n"
                + " 1 0 3\n"
                + " 4 2 5\n"
                + " 7 8 6";
        String boardString = board.toString();

        // Assert
        assertEquals(expectedString, boardString);
    }

    @Test
    public void equals_whenComparingToNull_isFalse() {
        // Arrange
        int[][] tiles = new int[][] {
                {1, 2, 3},
                {4, 5, 6},
                {7, 8, 0}
        };
        Board board = new Board(tiles);

        // Act
        boolean equal = board.equals(null);

        // Assert
        assertFalse(equal);
    }

    @Test
    public void equals_whenComparingToOtherType_isFalse() {
        // Arrange
        int[][] tiles = new int[][] {
                {1, 2, 3},
                {4, 5, 6},
                {7, 8, 0}
        };
        Board board = new Board(tiles);

        // Act
        boolean equal = board.equals(new Integer(0));

        // Assert
        assertFalse(equal);
    }

    @Test
    public void equals_whenOneTileIsDifferent_isFalse() {
        // Arrange
        Board boardA = new Board(new int[][] {
                {1, 2, 3},
                {4, 5, 6},
                {7, 8, 0}
        });
        Board boardB = new Board(new int[][] {
                {1, 2, 3},
                {4, 0, 6},
                {7, 8, 5}
        });

        // Act
        boolean equal = boardA.equals(boardB);

        // Assert
        assertFalse(equal);
    }

    @Test
    public void equals_whenMultipleTilesAreDifferent_isFalse() {
        // Arrange
        Board boardA = new Board(new int[][] {
                {3, 1},
                {2, 0}
        });
        Board boardB = new Board(new int[][] {
                {0, 3},
                {1, 2}
        });

        // Act
        boolean equal = boardA.equals(boardB);

        // Assert
        assertFalse(equal);
    }

    @Test
    public void equals_whenBoardsHaveDifferentDimensions_isFalse() {
        // Arrange
        Board boardA = new Board(new int[][] {
                {1, 2, 3},
                {4, 0, 6},
                {7, 8, 5}
        });
        Board boardB = new Board(new int[][] {
                {1, 2},
                {4, 0},
        });

        // Act
        boolean equal = boardA.equals(boardB);

        // Assert
        assertFalse(equal);
    }

    @Test
    public void equals_whenSameRef_isTrue() {
        // Arrange
        int[][] tiles = new int[][] {
                {1, 2, 3},
                {4, 5, 6},
                {7, 8, 0}
        };
        Board boardA = new Board(tiles);
        Board boardB = boardA;

        // Act
        boolean equal = boardA.equals(boardB);

        // Assert
        assertTrue(equal);
    }

    @Test
    public void equals_whenBoardsAreSame_isTrue() {
        // Arrange
        int[][] tiles = new int[][] {
                {1, 2, 3},
                {4, 5, 6},
                {7, 8, 0}
        };
        Board boardA = new Board(tiles);
        Board boardB = new Board(tiles);

        // Act
        boolean equal = boardA.equals(boardB);

        // Assert
        assertTrue(equal);
    }


    @Test
    public void hamming_exampleFromSpecification_returnsCorrectScore() {
        // Arrange
        int[][] tiles = new int[][] {
                {8, 1, 3},
                {4, 0, 2},
                {7, 6, 5}
        };
        Board board = new Board(tiles);

        // Act
        int hamming = board.hamming();

        // Assert
        assertEquals(5, hamming);
    }

    @Test
    public void hamming_exampleFromPuzzle17_returnsCorrectScore() {
        // Arrange
        int[][] tiles = new int[][] {
                {5, 1, 8},
                {2, 7, 3},
                {4, 0, 6}
        };
        Board board = new Board(tiles);

        // Act
        int hamming = board.hamming();

        // Assert
        assertEquals(8, hamming);
    }

    @Test
    public void hamming_exampleFromPuzzle27_returnsCorrectScore() {
        // Arrange
        int[][] tiles = new int[][] {
                {5, 8, 7},
                {1, 4, 6},
                {3, 0, 2}
        };
        Board board = new Board(tiles);

        // Act
        int hamming = board.hamming();

        // Assert
        assertEquals(7, hamming);
    }

    @Test
    public void hamming_exampleFromPuzzle2x2Usolvable_returnsCorrectScore() {
        // Arrange
        int[][] tiles = new int[][] {
                {1, 0},
                {2, 3}
        };
        Board board = new Board(tiles);

        // Act
        int hamming = board.hamming();

        // Assert
        assertEquals(2, hamming);
    }

    @Test
    public void hamming_whenAllTilesInGoadPosition_returnsZero() {
        // Arrange
        int[][] tiles = new int[][] {
                {1, 2, 3},
                {4, 5, 6},
                {7, 8, 0}
        };
        Board board = new Board(tiles);

        // Act
        int hamming = board.hamming();

        // Assert
        assertEquals(0, hamming);
    }

    @Test
    public void mangattan_whenUnsolvedBoard() {
        // Arrange
        int[][] tiles = new int[][] {
                {8, 1, 3},
                {4, 0, 2},
                {7, 6, 5}
        };
        Board board = new Board(tiles);

        // Act
        int manhattan = board.manhattan();

        // Assert
        assertEquals(10, manhattan);
    }

    @Test
    public void neighbors() {
        // Arrange
        int[][] tiles = new int[][] {
                {1, 0, 3},
                {4, 2, 5},
                {7, 8, 6}
        };
        Board board = new Board(tiles);

        String[] expectedNeighbors = { "3\n" + " 0 1 3\n"
                                             + " 4 2 5\n"
                                             + " 7 8 6",
                                       "3\n" + " 1 2 3\n"
                                             + " 4 0 5\n"
                                             + " 7 8 6",
                                       "3\n" + " 1 3 0\n"
                                             + " 4 2 5\n"
                                             + " 7 8 6"
                                      };

        // Act
        Iterable<Board> neighbors = board.neighbors();

        // Assert
        int neighborsIndex = 0;
        for (Board neighbor:
             neighbors) {
            assertEquals(expectedNeighbors[neighborsIndex], neighbor.toString());
            neighborsIndex++;
        }
    }

    @Test
    public void isGoal_whenFalse() {
        // Arrange
        int[][] tiles = new int[][] {
                {1, 0, 3},
                {4, 2, 5},
                {7, 8, 6}
        };
        Board board = new Board(tiles);

        // Act
        boolean isGoal = board.isGoal();

        // Assert
        assertFalse(isGoal);
    }

    @Test
    public void isGoal_whenTrue() {
        // Arrange
        int[][] tiles = new int[][] {
                {1, 2, 3},
                {4, 5, 6},
                {7, 8, 0}
        };
        Board board = new Board(tiles);

        // Act
        boolean isGoal = board.isGoal();

        // Assert
        assertTrue(isGoal);
    }

    @Test
    public void twin_notEqualToOriginal() {
        // Arrange
        int[][] tiles = new int[][] {
                {1, 2, 3},
                {4, 5, 6},
                {7, 8, 0}
        };
        Board board = new Board(tiles);

        // Act
        Board twin = board.twin();

        // Assert
        assertNotEquals(board, twin);
    }

    @Test
    public void twin_isImmutable() {
        // Arrange
        Board board = new Board(new int[][] {
                {1, 2, 3},
                {4, 5, 6},
                {7, 8, 0}
        });

        // Act
        Board twinFromFirstCall = board.twin();
        Board twinFromSecondCall = board.twin();

        // Assert
        assertEquals(twinFromFirstCall, twinFromSecondCall);

    }
}