package de.joshuagleitze.tilinggame.test;
import static de.joshuagleitze.tilinggame.LineType.GREEN;
import static de.joshuagleitze.tilinggame.LineType.NONE;
import static de.joshuagleitze.tilinggame.LineType.RED;
import static de.joshuagleitze.tilinggame.LineType.YELLOW;
import static de.joshuagleitze.tilinggame.test.BoardTestHelper.EMPTY_BOARD_DEFINITION;
import static de.joshuagleitze.tilinggame.test.BoardTestHelper.INVALID_BOARD_DEFINITION;
import static de.joshuagleitze.tilinggame.test.BoardTestHelper.RED_ROUNDTRIP_BOARD_DEFINITION;
import static de.joshuagleitze.tilinggame.test.BoardTestHelper.ROUNDTRIP;
import static de.joshuagleitze.tilinggame.test.BoardTestHelper.VALID_BOARD_DEFINITION;
import static de.joshuagleitze.tilinggame.test.BoardTestHelper.board;
import static de.joshuagleitze.tilinggame.test.BoardTestHelper.concat;
import static de.joshuagleitze.tilinggame.test.BoardTestHelper.isCorrectingNewline;
import static de.joshuagleitze.tilinggame.test.TileTestHelper.EMPTY_TILE_DEFINITION;
import static de.joshuagleitze.tilinggame.test.TileTestHelper.isTile;
import static de.joshuagleitze.tilinggame.test.TileTestHelper.tile;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import org.junit.Test;
import de.joshuagleitze.tilinggame.Board;
import de.joshuagleitze.tilinggame.Tile;
public class BoardTest {
@Test
public void constructor() {
final Board board = new Board();
for (int position = 0; position < 12; position++) {
assertThat("the empty board has an empty tile at position " + position, board.getTile(position),
isTile(EMPTY_TILE_DEFINITION));
}
}
@Test
public void isEmpty() {
assertTrue(new Board().isEmpty());
assertTrue(board(EMPTY_BOARD_DEFINITION).isEmpty());
assertFalse(board(VALID_BOARD_DEFINITION).isEmpty());
assertFalse(board(INVALID_BOARD_DEFINITION).isEmpty());
final Board board = new Board();
assertTrue(board.isEmpty());
board.setTile(11, tile("----RR"));
assertFalse(board.isEmpty());
}
@Test
public void getTile() {
final Board board = board(VALID_BOARD_DEFINITION);
assertThat("getting at index 0 works", board.getTile(0), isTile("------"));
assertThat("getting at index 1 works", board.getTile(1), isTile("GGY-Y-"));
assertThat("getting at index 2 works", board.getTile(2), isTile("----RR"));
assertThat("getting at index 3 works", board.getTile(3), isTile("------"));
assertThat("getting at index 4 works", board.getTile(4), isTile("RGRGYY"));
assertThat("getting at index 5 works", board.getTile(5), isTile("GG----"));
assertThat("getting at index 6 works", board.getTile(6), isTile("--YGGY"));
assertThat("getting at index 7 works", board.getTile(7), isTile("G--RGR"));
assertThat("getting at index 8 works", board.getTile(8), isTile("-YY---"));
assertThat("getting at index 9 works", board.getTile(9), isTile("------"));
assertThat("getting at index 10 works", board.getTile(10), isTile("---YY-"));
assertThat("getting at index 11 works", board.getTile(11), isTile("Y----Y"));
}
@Test
public void setTile() {
Board board = new Board();
final String definition = "--RR--";
final Tile tile = tile(definition);
board.setTile(3, tile);
assertThat("setting a new tile works", board.getTile(3), isTile(tile));
board = board(VALID_BOARD_DEFINITION);
board.setTile(1, tile(EMPTY_TILE_DEFINITION));
board.setTile(2, tile(EMPTY_TILE_DEFINITION));
board.setTile(4, tile(EMPTY_TILE_DEFINITION));
board.setTile(5, tile(EMPTY_TILE_DEFINITION));
board.setTile(6, tile(EMPTY_TILE_DEFINITION));
board.setTile(7, tile(EMPTY_TILE_DEFINITION));
board.setTile(8, tile(EMPTY_TILE_DEFINITION));
board.setTile(10, tile(EMPTY_TILE_DEFINITION));
board.setTile(11, tile(EMPTY_TILE_DEFINITION));
assertTrue("once all tiles have been set to empty ones, the board is empty", board.isEmpty());
}
@Test
public void removeTile() {
final Board board = board(VALID_BOARD_DEFINITION);
board.removeTile(2);
assertThat(board.getTile(2), isTile(EMPTY_TILE_DEFINITION));
board.removeTile(1);
board.removeTile(4);
board.removeTile(5);
board.removeTile(6);
board.removeTile(7);
board.removeTile(8);
board.removeTile(10);
board.removeTile(11);
assertTrue("once all tiles have been removed, the board is empty", board.isEmpty());
}
@Test
public void rotateTileClockwise() {
final Board board = board(VALID_BOARD_DEFINITION);
board.rotateTileClockwise(5);
assertThat(board.getTile(5), isTile("-GG---"));
}
@Test
public void rotateTileCounterClockwise() {
final Board board = board(INVALID_BOARD_DEFINITION);
board.rotateTileCounterClockwise(1);
assertThat(board.getTile(1), isTile("GGY-Y-"));
}
@Test
public void getNumberOfColors() {
Board board = new Board();
assertThat("the empty board has no colors", board.getNumberOfColors(), is(0));
board.setTile(11, tile("RR----"));
assertThat(board.getNumberOfColors(), is(1));
board.setTile(10, tile("--R--R"));
assertThat(board.getNumberOfColors(), is(1));
board.setTile(9, tile("-Y---Y"));
assertThat(board.getNumberOfColors(), is(2));
board.setTile(8, tile("R-YY-R"));
assertThat(board.getNumberOfColors(), is(2));
board.setTile(7, tile("----GG"));
assertThat(board.getNumberOfColors(), is(3));
board.setTile(6, tile("RRGGYY"));
assertThat(board.getNumberOfColors(), is(3));
board = new Board();
board.setTile(2, tile("RGYRGY"));
assertThat(board.getNumberOfColors(), is(3));
board = new Board();
board.setTile(1, tile("R-YY-R"));
assertThat(board.getNumberOfColors(), is(2));
board.setTile(0, tile("-R--R-"));
assertThat(board.getNumberOfColors(), is(2));
board.setTile(0, tile("-G--G-"));
assertThat(board.getNumberOfColors(), is(3));
}
@Test
public void isValid() {
assertTrue("the empty board is valid", board(EMPTY_BOARD_DEFINITION).isValid());
Board board = board(RED_ROUNDTRIP_BOARD_DEFINITION);
assertTrue(board.isValid());
for (final int position : ROUNDTRIP) {
final Tile oldTile = board.getTile(position);
board.setTile(position,
tile(oldTile.toString().replaceFirst("R", "Y").replaceFirst("-", "R").replaceFirst("-", "Y")));
assertFalse("first connection edge of tile " + position + " is checked", board.isValid());
board.setTile(position, tile(
oldTile.toString().replaceFirst("R(-*)$", "Y$1").replaceFirst("-", "R").replaceFirst("-", "Y")));
board.setTile(position, tile(oldTile.toString().replace('R', 'Y')));
assertFalse("last connection edge of tile " + position + " is checked", board.isValid());
board.setTile(position, new Tile());
assertTrue("an empty tile anywhere does not destroy validity", board.isValid());
board.setTile(position, oldTile);
}
assertTrue(board(VALID_BOARD_DEFINITION).isValid());
assertFalse(board(INVALID_BOARD_DEFINITION).isValid());
board = board(VALID_BOARD_DEFINITION);
board.setTile(3, tile("--GG--"));
assertFalse(board.isValid());
}
@Test
public void getConnectedPathColor() {
final int[] threeRounds = concat(ROUNDTRIP, ROUNDTRIP, ROUNDTRIP);
final Board board = board(RED_ROUNDTRIP_BOARD_DEFINITION);
assertThat(board.getConnectedPathColor(ROUNDTRIP), is(RED));
assertThat(board.getConnectedPathColor(threeRounds), is(RED));
for (final int position : ROUNDTRIP) {
final Tile oldTile = board.getTile(position);
board.setTile(position, new Tile());
assertThat("path is broken if tile " + position + " is set to the empty tile",
board.getConnectedPathColor(ROUNDTRIP), is(NONE));
board.setTile(position, tile(oldTile.toString().replace('R', 'Y')));
assertThat("path is broken if tile " + position + " is yellow", board.getConnectedPathColor(ROUNDTRIP),
is(NONE));
board.setTile(position, tile(oldTile.toString().replaceFirst("R-", "-R")));
assertThat("path is proken if first line end of tile " + position + " is moved",
board.getConnectedPathColor(threeRounds), is(NONE));
board.setTile(position, tile(oldTile.toString().replaceFirst("-R(-*)$", "R-$1")));
assertThat("path is proken if second line end of tile " + position + " is moved",
board.getConnectedPathColor(threeRounds), is(NONE));
board.setTile(position, oldTile);
}
final Board validBoard = board(VALID_BOARD_DEFINITION);
assertThat(validBoard.getConnectedPathColor(new int[] {0, 3}), is(NONE));
assertThat(validBoard.getConnectedPathColor(new int[] {1, 4}), is(YELLOW));
assertThat(validBoard.getConnectedPathColor(new int[] {1, 2, 4}), is(NONE));
assertThat(validBoard.getConnectedPathColor(new int[] {4, 5, 7}), is(GREEN));
assertThat(validBoard.getConnectedPathColor(new int[] {4, 5, 7, 6, 4, 5, 7}), is(GREEN));
assertThat(validBoard.getConnectedPathColor(new int[] {8, 10, 11}), is(YELLOW));
assertThat(validBoard.getConnectedPathColor(new int[] {8, 10, 7}), is(NONE));
assertThat(validBoard.getConnectedPathColor(new int[] {8, 10, 11, 8}), is(YELLOW));
final Board invalidBoard = board(INVALID_BOARD_DEFINITION);
assertThat(invalidBoard.getConnectedPathColor(new int[] {0, 3}), is(NONE));
assertThat(invalidBoard.getConnectedPathColor(new int[] {1, 4}), is(NONE));
assertThat(invalidBoard.getConnectedPathColor(new int[] {1, 2, 4}), is(NONE));
assertThat(invalidBoard.getConnectedPathColor(new int[] {4, 5, 7}), is(GREEN));
assertThat(invalidBoard.getConnectedPathColor(new int[] {4, 5, 7, 6, 4, 5, 7}), is(NONE));
assertThat(invalidBoard.getConnectedPathColor(new int[] {8, 10, 11}), is(YELLOW));
assertThat(invalidBoard.getConnectedPathColor(new int[] {8, 10, 7}), is(NONE));
assertThat(invalidBoard.getConnectedPathColor(new int[] {8, 10, 11, 8}), is(NONE));
}
@Test
public void toStringT() {
assertThat(new Board().toString(), isCorrectingNewline(BoardTestHelper.EMPTY_BOARD_DEFINITION));
for (final String definition : new String[] {BoardTestHelper.EMPTY_BOARD_DEFINITION,
BoardTestHelper.VALID_BOARD_DEFINITION, BoardTestHelper.INVALID_BOARD_DEFINITION}) {
assertThat(board(definition).toString(), isCorrectingNewline(definition));
}
}
}