Esempio n. 1
0
 /**
  * Check that the <code>Plies</code> the <code>Piece</code> would return match the given set of
  * correct <code>Plies</code>.
  */
 private void checkPlies(Set<Ply> correctPlies, Piece piece) {
   Set<Ply> obtainedPlies = new HashSet<Ply>(piece.getPlies());
   assertEquals(
       (piece.isWhite() ? "White" : "Black") + " Piece fails to" + " produce correct set of Plies",
       correctPlies,
       obtainedPlies);
 }
Esempio n. 2
0
 /**
  * Test that the <code>Piece</code> sets itself up exactly as many times as it needs, when some of
  * its initial positions correspond to unusable cells.
  */
 public void testSetUpLoopUnusable() {
   List<int[]> unusable = new ArrayList<int[]>(2);
   unusable.add(new int[] {6, 0});
   unusable.add(new int[] {1, 7});
   Board newBoard =
       new RectangularBoard(
           RectangularBoard.defaultLength, RectangularBoard.defaultHeight, unusable);
   Piece newKnight = new Knight(true, newBoard);
   try {
     newKnight.setUp();
     assertEquals(
         "Piece did not set up correctly", newKnight, newBoard.getPiece(new int[] {1, 0}));
     newKnight = new Knight(true, newBoard);
     newKnight.setUp();
     fail("Piece did not fail while setting up, as it should have");
   } catch (InvalidInitialPositionException e1) {
     try {
       newKnight = new Knight(false, newBoard);
       newKnight.setUp();
       assertEquals(
           "Piece did not set up correctly", newKnight, newBoard.getPiece(new int[] {6, 7}));
       newKnight = new Knight(false, newBoard);
       newKnight.setUp();
       fail("Piece did not fail while setting up, as it should have");
     } catch (InvalidInitialPositionException e2) {
       assertEquals("Number of Pieces in Board is incorrect", 1, newBoard.getPieces(true).size());
       assertEquals("Number of Pieces in Board is incorrect", 1, newBoard.getPieces(false).size());
       return;
     }
     fail("Black Piece set itself up successfully to an unusable cell.");
   }
   fail("White Piece set itself up successfully to an unusable cell.");
 }
Esempio n. 3
0
 /**
  * Test that the <code>Piece</code> sets itself up in a <code>Board</code> successfully and
  * correctly. It is set up as many times as it should handle.
  */
 public void testSetUpNormal() {
   // For a white Piece
   Piece newKnight = new Knight(true, board);
   try {
     whiteKnight.setUp();
     newKnight.setUp();
   } catch (Exception e) {
     fail("White Piece failed to set up appropriately");
   }
   assertTrue(
       "White Piece was not added to the Board after being set up", board.contains(whiteKnight));
   assertTrue(
       "White Piece was not added to the Board after being set up", board.contains(newKnight));
   assertEquals(
       "More than two Pieces (or less) were added when " + "setting up",
       2,
       board.getPieces(true).size());
   assertTrue(
       "Another Piece was added to the Board",
       board.getPiece(new int[] {1, 0}).getType().equals(new String("knight"))
           && board.getPiece(new int[] {6, 0}).getType().equals(new String("knight")));
   assertEquals(
       "White Piece did not set up itself at the correct position",
       whiteKnight,
       board.getPiece(new int[] {1, 0})); // Notice order
   assertEquals(
       "White Piece did not set up itself at the correct position",
       newKnight,
       board.getPiece(new int[] {6, 0}));
   // For a black Piece
   newKnight = new Knight(false, board);
   try {
     blackKnight.setUp();
     newKnight.setUp();
   } catch (Exception e) {
     fail("Black Piece failed to set up appropriately");
   }
   assertTrue(
       "Black Piece was not added to the Board after being set up", board.contains(blackKnight));
   assertTrue(
       "Black Piece was not added to the Board after being set up", board.contains(newKnight));
   assertEquals(
       "More than two Pieces (or less) were added when " + "setting up",
       2,
       board.getPieces(false).size());
   assertTrue(
       "Another Piece was added to the Board",
       board.getPiece(new int[] {1, 7}).getType().equals(new String("knight"))
           && board.getPiece(new int[] {6, 7}).getType().equals(new String("knight")));
   assertEquals(
       "Black Piece did not set up itself at the correct position",
       blackKnight,
       board.getPiece(new int[] {1, 7})); // Notice order
   assertEquals(
       "Black Piece did not set up itself at the correct position",
       newKnight,
       board.getPiece(new int[] {6, 7}));
 }
Esempio n. 4
0
 /** Test the getType() method. */
 public void testGetType() {
   assertEquals(
       "The toString() method is not returning what it should",
       new String("knight"),
       whiteKnight.getType());
   assertEquals(
       "The toString() method is not returning what it should",
       new String("knight"),
       blackKnight.getType());
 }
Esempio n. 5
0
 /**
  * Test valid <code>Plies</code> when the <code>Piece</code> is not in a <code>Board</code>. There
  * should be no valid <code>Plies</code>.
  */
 public void testPliesNone() {
   // For white Piece
   assertEquals(
       "White Piece fails to produce correct set of Plies",
       new ArrayList<Ply>(),
       whiteKnight.getPlies());
   // For black Piece
   assertEquals(
       "Black Piece fails to produce correct set of Plies",
       new ArrayList<Ply>(),
       blackKnight.getPlies());
 }
Esempio n. 6
0
 /** Test that the <code>Piece</code> fails to be set up more than once. */
 public void testSetUpTwice() {
   // For a white Piece
   while (true) {
     try {
       whiteKnight.setUp();
     } catch (IllegalStateException e) {
       assertTrue(
           "White Piece was not added to the Board after being set up",
           board.contains(whiteKnight));
       assertFalse(
           "A black Piece was added to the Board while testing a " + "white Piece",
           board.contains(blackKnight));
       assertEquals(
           "More than one white Piece (or no Pieces) was (were) " + "added when setting up",
           1,
           board.getPieces(true).size());
       assertEquals(
           "White Piece did not set up itself at the correct position",
           whiteKnight,
           board.getPiece(new int[] {1, 0}));
       break;
     } catch (InvalidInitialPositionException e) {
       fail(
           "White Piece threw an InvalidInitialPositionException while "
               + "setting up more than once. This should not happen.");
     }
   }
   // For a black Piece
   while (true) {
     try {
       blackKnight.setUp();
     } catch (IllegalStateException e) {
       assertTrue(
           "Black Piece was not added to the Board after being set up",
           board.contains(blackKnight));
       assertEquals(
           "More than one black Piece (or no Pieces) was (were) " + "added when setting up",
           1,
           board.getPieces(false).size());
       assertEquals(
           "Black Piece did not set up itself at the correct position",
           blackKnight,
           board.getPiece(new int[] {1, 7}));
       break;
     } catch (InvalidInitialPositionException e) {
       fail(
           "Black Piece threw an InvalidInitialPositionException while "
               + "setting up more than once. This should not happen.");
     }
   }
 }
Esempio n. 7
0
 /**
  * Test that the <code>Piece</code> sets itself up exactly as many times as it needs, assuming its
  * initial positions correspond to usable cells.
  */
 public void testSetUpLoopNormal() {
   // For a white Piece
   Piece newKnight = null;
   while (true) {
     try {
       newKnight = new Knight(true, board);
       newKnight.setUp();
     } catch (IllegalStateException e) { // not really needed
       fail(
           "White Piece threw an IllegalStateException while set"
               + "ting up to an occupied cell. This should not happen.");
     } catch (InvalidInitialPositionException e) {
       assertFalse(
           "White Piece was added to the Board after failing to set up",
           board.contains(newKnight));
       assertFalse(
           "A black Piece was added to the Board while testing a " + "white Piece",
           board.contains(newKnight));
       assertEquals(
           "More than two white Pieces (or less) were " + "added when setting up",
           2,
           board.getPieces(true).size());
       break;
     }
   }
   // For a black Piece
   while (true) {
     try {
       newKnight = new Knight(false, board);
       newKnight.setUp();
     } catch (IllegalStateException e) { // not really needed
       fail(
           "Black Piece threw an IllegalStateException while set"
               + "ting up to an occupied cell. This should not happen.");
     } catch (InvalidInitialPositionException e) {
       assertFalse(
           "Black Piece was added to the Board after failing to set up",
           board.contains(newKnight));
       assertEquals(
           "More than two black Pieces (or less) were " + "added when setting up",
           2,
           board.getPieces(false).size());
       break;
     }
   }
 }