/** * Tests the deleteVertical method, by making a nice board with vertical combinations of 5,4 and 3 * Gems and checking if the method finds those combinations. */ @Test public final void testDeleteVertical() { board = new Board(5, 0, 0, false); gems = board.getGems(); for (int col = 0; col < 5; col++) { for (int row = 0; row < 5 - col; row++) { gems[row][col].setType(1); } } gems[4][1].setType(2); gems[3][2].setType(2); gems[4][2].setType(2); ArrayList<Gem> array1 = new ArrayList<Gem>(); array1.add(gems[1][0]); array1.add(gems[2][0]); array1.add(gems[3][0]); array1.add(gems[4][0]); ArrayList<Gem> array2 = board.deleteVertical(gems[0][0]); assertEquals(array1, array2); ArrayList<Gem> array3 = new ArrayList<Gem>(); array3.add(gems[1][1]); array3.add(gems[0][1]); array3.add(gems[3][1]); ArrayList<Gem> array4 = board.deleteVertical(gems[2][1]); assertEquals(array3, array4); ArrayList<Gem> array5 = new ArrayList<Gem>(); array5.add(gems[0][2]); array5.add(gems[2][2]); ArrayList<Gem> array6 = board.deleteVertical(gems[1][2]); assertEquals(array5, array6); }
/** * Tests the setGems and getGems methods, by first setting Gems[][] testgems, and then checking * whether it was set with the getGems method. */ @Test public final void setGemTest() { board = new Board(2, 0, 0, false); Gem[][] testgems = new Gem[2][2]; board.setGems(testgems); assertArrayEquals(testgems, board.getGems()); }
/** * Tests the setSecondGem and getSecondGem methods, by first setting a Gem on second and then * checking with getSecondGem if it was second. */ @Test public final void secondGemTest() { board = new Board(2, 0, 0, false); gems = board.getGems(); Gem gem = gems[0][0]; assertNull(board.getSecondGem()); board.setSecondGem(gem); assertEquals(board.getSecondGem(), gem); }
/** Tests the getUpper method by checking if the getUpper method returns the right Gem. */ @Test public final void testGetUpper() { board = new Board(2, 0, 0, false); gems = board.getGems(); Gem gem1 = gems[0][0]; Gem gem2 = gems[0][1]; Gem gem3 = gems[1][0]; assertEquals(board.getUpper(gem3), gem1); assertFalse(board.getUpper(gem3) == gem2); }
/** * Tests the colCheck method, by changing some types in a col and checking if the returned boolean * is right. */ @Test public final void testColCheck() { board = new Board(3, 0, 0, false); gems = board.getGems(); gems[0][0].setType(1); gems[1][0].setType(1); assertFalse(board.colCheck(2, 0, 1)); gems[0][0].setType(2); assertTrue(board.colCheck(2, 0, 1)); }
/** * Tests the rowCheck method, by changing some types in a row and checking if the returned boolean * is right. */ @Test public final void testRowCheck() { board = new Board(3, 0, 0, false); gems = board.getGems(); gems[0][0].setType(1); gems[0][1].setType(1); assertFalse(board.rowCheck(0, 2, 1)); gems[0][0].setType(2); assertTrue(board.rowCheck(0, 2, 1)); }
/** * Tests the swap method by swapping two gems and checking if their position has changed. Also, it * checks whether the gems are not changed if they are not next to each other. */ @Test public final void testSwap() { board = new Board(2, 0, 0, false); assertFalse(board.swap(0, 1, 1, 0)); gems = board.getGems(); Gem gem1 = gems[0][0]; Gem gem2 = gems[0][1]; assertTrue(board.swap(0, 0, 0, 1)); assertEquals(gems[0][0], gem2); assertEquals(gems[0][1], gem1); assertTrue(board.swap(0, 0, 1, 0)); }
/** * Tests the delete method, by deleting a gem and checking if it has disappeared and if the other * gems are on the right place. */ @Test public final void testDelete() { board = new Board(3, 0, 0, false); gems = board.getGems(); gems[0][0].setType(1); gems[1][0].setType(1); Gem gem1 = gems[0][0]; Gem gem2 = gems[1][0]; board.delete(2, 0); assertEquals(gems[2][0], gem2); assertEquals(gems[1][0], gem1); }
/** * Tests the fillBoard method, it check for every place on the board if there is a Gem with a type * from 1 to 6. */ @Test public final void testFillBoardIntInt() { board = new Board(3, 0, 0, false); board.fillBoard(0, 0); gems = board.getGems(); for (int row = 0; row < 3; row++) { for (int col = 0; col < 3; col++) { assertTrue(1 <= gems[row][col].getType()); assertTrue(gems[row][col].getType() <= 6); } } }
/** * Tests the areNeighbours method, by testing neighbours and also testing Gems that aren't * neighbours. */ @Test public final void testAreNeighbours() { board = new Board(2, 0, 0, false); gems = board.getGems(); Gem gem1 = gems[0][0]; Gem gem2 = gems[0][1]; Gem gem3 = gems[1][0]; Gem gem4 = gems[1][1]; assertTrue(board.areNeighbours(gem1, gem2)); assertTrue(board.areNeighbours(gem1, gem3)); assertFalse(board.areNeighbours(gem1, gem4)); }
/** * Tests the deleteRows method by setting up some combinations and testing whether the method * finds them. */ @Test public final void testDeleteRows() { board = new Board(3, 0, 0, false); gems = board.getGems(); gems[0][0].setType(1); gems[0][1].setType(1); gems[0][2].setType(1); assertTrue(board.deleteRows(gems[0][0]) > 0); gems[0][1].setType(2); gems[1][0].setType(2); gems[0][0].setType(1); assertTrue(board.deleteRows(gems[0][0]) == 0); }
/** * Tests the deleteAll method, by filling an ArrayList with gems and checking if those gems have * been deleted. */ @Test public final void testDeleteAll() { board = new Board(3, 0, 0, false); gems = board.getGems(); ArrayList<Gem> array = new ArrayList<Gem>(); Gem gem1 = gems[0][0]; Gem gem2 = gems[1][0]; Gem gem3 = gems[2][0]; array.add(gem3); array.add(gem1); array.add(gem2); board.deleteAll(array); assertFalse(gem1 == gems[0][0]); assertFalse(gem2 == gems[1][0]); assertFalse(gem3 == gems[2][0]); assertFalse(gem2 == gems[2][0]); }