void winner_fixes_kurmas_failure(CuTest *tc) {
int board[8][8];
ct_initialize(8, 8, board);
board[7][1] = 0;
board[6][1] = 1;
board[5][1] = 0;
board[4][1] = 1;
board[7][2] = 1;
board[6][2] = 0;
board[5][2] = 1;
board[4][2] = 0;
board[7][3] = 0;
board[6][3] = 1;
board[5][3] = 0;
board[4][3] = 1;
board[7][4] = 1;
int answer = winner(8, 8, 4, board);
CuAssertIntEquals_Msg(tc, "Player 1.", 1, answer);
}
void vertical_column1(CuTest* tc)
{
int num_rows = 7;
int num_columns = 7;
int array[num_rows][num_columns];
int answer;
ct_initialize(num_rows, num_columns, array);
placeToken(0, 1, num_rows, num_columns, array);
answer = winner(num_rows, num_columns, 4, array);
CuAssertIntEquals_Msg(tc, "Single 0 in column 1", NO_WINNER_YET, answer);
placeToken(0, 1, num_rows, num_columns, array);
answer = winner(num_rows, num_columns, 4, array);
CuAssertIntEquals_Msg(tc, "Two 0s in column 1", NO_WINNER_YET, answer);
placeToken(0, 1, num_rows, num_columns, array);
answer = winner(num_rows, num_columns, 4, array);
CuAssertIntEquals_Msg(tc, "Three 0s in column 1", NO_WINNER_YET, answer);
placeToken(0, 1, num_rows, num_columns, array);
answer = winner(num_rows, num_columns, 4, array);
CuAssertIntEquals_Msg(tc, "4 in a row, vertical", 0, answer);
}
void checkRightDiagonal_returns_negative_one_if_no_winner(CuTest *tc) {
int board[3][3];
ct_initialize(3, 3, board);
int answer = checkRightDiagonal(3, 3, board, 3);
CuAssertIntEquals_Msg(tc, "No winner.", -1, answer);
}
void horizontal_row0(CuTest* tc)
{
int num_rows = 7;
int num_columns = 7;
int array[num_rows][num_columns];
int answer;
ct_initialize(num_rows, num_columns, array);
placeToken(0, 0, num_rows, num_columns, array);
answer = winner(num_rows, num_columns, 4, array);
CuAssertIntEquals_Msg(tc, "Single 0 in column 0", NO_WINNER_YET, answer);
placeToken(0, 1, num_rows, num_columns, array);
answer = winner(num_rows, num_columns, 4, array);
CuAssertIntEquals_Msg(tc, "0s in columns {0,1}", NO_WINNER_YET, answer);
placeToken(0, 2, num_rows, num_columns, array);
answer = winner(num_rows, num_columns, 4, array);
CuAssertIntEquals_Msg(tc, "0s in columns {0,1, 2}", NO_WINNER_YET, answer);
placeToken(0, 3, num_rows, num_columns, array);
answer = winner(num_rows, num_columns, 4, array);
CuAssertIntEquals_Msg(tc, "4 in a row, horizontal", 0, answer);
}
void kurmas_test(CuTest *tc) {
int num_rows = 8;
int num_columns = 8;
int array[num_rows][num_columns];
int answer;
ct_initialize(num_rows, num_columns, array);
placeToken(0, 1, num_rows, num_columns, array);
placeToken(1, 1, num_rows, num_columns, array);
placeToken(0, 1, num_rows, num_columns, array);
placeToken(1, 1, num_rows, num_columns, array);
placeToken(1, 2, num_rows, num_columns, array);
placeToken(0, 2, num_rows, num_columns, array);
placeToken(1, 2, num_rows, num_columns, array);
placeToken(0, 2, num_rows, num_columns, array);
placeToken(0, 3, num_rows, num_columns, array);
placeToken(1, 3, num_rows, num_columns, array);
placeToken(0, 3, num_rows, num_columns, array);
placeToken(1, 3, num_rows, num_columns, array);
placeToken(1, 4, num_rows, num_columns, array);
answer = winner(num_rows, num_columns, 4, array);
CuAssertIntEquals_Msg(tc, "Player 1", 1, answer);
}
void checkRows_returns_negative_one_if_no_winner(CuTest *tc) {
int board[4][4];
ct_initialize(4, 4, board);
board[3][0] = 1;
board[3][1] = -1;
board[3][2] = 1;
board[3][3] = 1;
int answer = checkRows(4, 4, board, 4);
CuAssertIntEquals_Msg(tc, "No winner", -1, answer);
}
void checkRows_returns_winner_if_exists(CuTest *tc) {
int board[4][4];
ct_initialize(4, 4, board);
board[3][0] = 1;
board[3][1] = 1;
board[3][2] = 1;
board[3][3] = 1;
int answer = checkRows(4, 4, board, 4);
CuAssertIntEquals_Msg(tc, "Player 1.", 1, answer);
}
void checkRightDiagonal_returns_winner_if_there_is_one(CuTest *tc) {
int board[3][3];
ct_initialize(3, 3, board);
board[0][0] = 0;
board[1][1] = 0;
board[2][2] = 0;
int answer = checkRightDiagonal(3, 3, board, 3);
CuAssertIntEquals_Msg(tc, "Player 0.", 0, answer);
}
void checkLeftDiagonal_can_find_winners_above_below_largest_diagonal(CuTest *tc) {
int board[5][5];
ct_initialize(5, 5, board);
board[3][0] = 1;
board[2][1] = 1;
board[1][2] = 1;
int answer = checkLeftDiagonal(5, 5, board, 3);
CuAssertIntEquals_Msg(tc, "Player 0.", 1, answer);
}
void checkRightDiagonal_can_find_winners_below_largest_diagonal(CuTest *tc) {
int board[4][4];
ct_initialize(4, 4, board);
board[0][1] = 0;
board[1][2] = 0;
board[2][3] = 0;
int answer = checkRightDiagonal(4, 4, board, 3);
CuAssertIntEquals_Msg(tc, "Player 0.", 0, answer);
}
void checkRightDiagonal_can_use_larger_boards(CuTest *tc) {
int board[5][5];
ct_initialize(5, 5, board);
board[1][2] = 1;
board[2][3] = 1;
board[3][4] = 1;
int answer = checkRightDiagonal(5, 5, board, 3);
CuAssertIntEquals_Msg(tc, "Player 0.", 1, answer);
}
void checkColumns_returns_negative_one_if_no_winner(CuTest *tc) {
int board[4][4];
ct_initialize(4, 4, board);
board[0][1] = 1;
board[1][1] = 1;
board[2][1] = 0;
board[3][1] = 1;
int answer = winner(4, 4, 4, board);
CuAssertIntEquals_Msg(tc, "No one wins", -1, answer);
}
void place_token_invalid_index(CuTest *tc) {
int num_rows = 100;
int num_columns = 100;
int array[num_rows][num_columns];
int answer = 0;
ct_initialize(num_rows, num_columns, array);
answer = place_token(1, 100, num_rows, num_columns, array);
CuAssertIntEquals_Msg(tc, "Should return error, invalid index ", -1, answer);
answer = place_token(1, -1, num_rows, num_columns, array);
CuAssertIntEquals_Msg(tc, "Should return error, invalid index ", -1, answer);
}
void checkColumns_does_not_recognize_negative_one_as_winner(CuTest *tc) {
int board[4][4];
ct_initialize(4, 4, board);
board[0][1] = -1;
board[1][1] = -1;
board[2][1] = -1;
board[3][1] = -1;
int answer = winner(4, 4, 4, board);
CuAssertIntEquals_Msg(tc, "No one wins", -1, answer);
}
void winner_returns_left_diagonal_winner(CuTest *tc) {
int board[3][3];
ct_initialize(3, 3, board);
board[2][0] = 1;
board[1][1] = 1;
board[0][2] = 1;
int answer = winner(3, 3, 3, board);
CuAssertIntEquals_Msg(tc, "Player 1.", 1, answer);
}
void checkRightDiagonal_resets_count_properly(CuTest *tc) {
int board[5][5];
ct_initialize(5, 5, board);
board[0][0] = 0;
board[1][1] = 0;
board[2][2] = 1;
board[3][3] = 1;
int answer = checkRightDiagonal(5, 5, board, 3);
CuAssertIntEquals_Msg(tc, "No Winner.", -1, answer);
}
void winner_returns_vertical_winner(CuTest *tc) {
int board[4][4];
ct_initialize(4, 4, board);
board[0][2] = 1;
board[1][2] = 1;
board[2][2] = 1;
board[3][2] = 1;
int answer = winner(4, 4, 4, board);
CuAssertIntEquals_Msg(tc, "Player 1.", 1, answer);
}
void checkLeftDiagonal_properly_resets_count_top_loop(CuTest *tc) {
int board[5][5];
ct_initialize(5, 5, board);
board[4][1] = 0;
board[3][2] = 0;
board[2][3] = 1;
board[1][4] = 1;
int answer = checkLeftDiagonal(5, 5, board, 3);
CuAssertIntEquals_Msg(tc, "No winner.", -1, answer);
}
void winner_diagonal_r48(CuTest *tc) {
int num_rows = 100;
int num_columns = 100;
int array[num_rows][num_columns];
int answer;
ct_initialize(num_rows, num_columns, array);
for (int i = 48; i < 55; ++i) {
array[i][i + 2] = 0;
}
answer = winner(num_rows, num_columns, 7, array);
CuAssertIntEquals_Msg(tc, "Centered diagonal win", 0, answer);
}
void checkColumns_properly_resets_count(CuTest *tc) {
int board[5][5];
ct_initialize(5, 5, board);
board[0][1] = 1;
board[1][1] = 1;
board[2][1] = 0;
board[3][1] = 1;
board[4][1] = 1;
int answer = winner(5, 5, 3, board);
CuAssertIntEquals_Msg(tc, "No one wins", -1, answer);
}
void placeToken_recognizes_already_placed_tokens(CuTest *tc) {
int num_rows = 3;
int num_columns = 3;
int array[num_rows][num_columns];
ct_initialize(num_rows, num_columns, array);
placeToken(0, 2, num_rows, num_columns, array);
placeToken(1, 2, num_rows, num_columns, array);
CuAssertIntEquals_Msg(tc, "Drop 1 into empty column 3", 0, array[num_rows - 1][2]);
CuAssertIntEquals_Msg(tc, "Drop 1 into empty column 3", 1, array[num_rows - 2][2]);
}
void check_full_board_pass(CuTest *tc) {
int num_rows = 4;
int num_columns = 4;
int array[num_rows][num_columns];
int answer = 0;
ct_initialize(num_rows, num_columns, array);
for (int row = num_rows - 1; row > -1; --row) {
for (int col = 0; col < num_columns; ++col) {
array[row][col] = 0; // A number which is not -1
}
}
answer = check_full_board(num_rows, num_columns, array);
CuAssertIntEquals_Msg(tc, "Board should be full", 4, answer);
}
void placeToken_must_be_in_board(CuTest *tc) {
int num_rows = 3;
int num_columns = 3;
int array[num_rows][num_columns];
ct_initialize(num_rows, num_columns, array);
placeToken(0, 3, num_rows, num_columns, array);
placeToken(0, -1, num_rows, num_columns, array);
CuAssertIntEquals_Msg(tc, "Must drop into board.", -1, array[num_rows - 1][0]);
CuAssertIntEquals_Msg(tc, "Must drop into board.", -1, array[num_rows - 1][2]);
}
void check_full_board_fail(CuTest *tc) {
int num_rows = 7;
int num_columns = 7;
int array[num_rows][num_columns];
int answer = 0;
ct_initialize(num_rows, num_columns, array);
// Fill all but the "top" row
for (int row = num_rows - 1; row > 0; --row) {
for (int col = 0; col < num_columns; ++col) {
array[row][col] = 0; // A number which is not -1
}
}
array[0][3] = 1; // Fill one cell in "top" row
answer = check_full_board(num_rows, num_columns, array);
CuAssertIntEquals_Msg(tc, "Only one cell should be filled in top row", 1, answer);
}
/*******************************************************************************************
*
* Test winner function
*
* Note: This is just a sample of how you can test your own winner
* function. You may need to modify this code depending on how your
* organized your array. I will not be testing your winner function
* directly.
*
* Note: Be sure to add tests for different directions, quadrants, and board sizes.
*
******************************************************************************************/
void winner_horizontal_r0(CuTest *tc) {
int num_rows = 7;
int num_columns = 7;
int array[num_rows][num_columns];
int answer;
ct_initialize(num_rows, num_columns, array);
array[0][0] = 0;
array[0][1] = 0;
array[0][2] = 0;
array[0][3] = 0;
answer = winner(num_rows, num_columns, 4, array);
CuAssertIntEquals_Msg(tc, "0s in bottom row", 0, answer);
}
void loser_diagonal_r48(CuTest *tc) {
/* Test counter to ensure that one "skip" in the win_count
* doesn't let Player 1 win */
int num_rows = 100;
int num_columns = 100;
int array[num_rows][num_columns];
int answer;
ct_initialize(num_rows, num_columns, array);
for (int i = 48; i < 55; ++i) {
array[i][i + 2] = 0;
}
// Win skip
array[49][51] = 1;
answer = winner(num_rows, num_columns, 7, array);
CuAssertIntEquals_Msg(tc, "Centered diagonal loss", -1, answer);
}
void fullBoard_notices_an_empty_board(CuTest *tc) {
int board[3][3];
ct_initialize(3, 3, board);
board[0][1] = 0;
board[0][2] = 0;
board[1][0] = 0;
board[1][1] = 0;
board[1][2] = 0;
board[2][0] = 0;
board[2][1] = 0;
board[2][2] = 0;
int answer = fullBoard(3, 3, board);
CuAssertIntEquals_Msg(tc, "Full board", -1, answer);
}
void place_token_c99(CuTest *tc) {
int num_rows = 100;
int num_columns = 100;
int array[num_rows][num_columns];
ct_initialize(num_rows, num_columns, array);
place_token(1, 99, num_rows, num_columns, array);
CuAssertIntEquals_Msg(tc, "Drop 1 into empty column 99", 1, array[num_rows - 1][99]);
int r, c;
for (r = 0; r < num_rows; r++) {
for (c = 0; c < num_columns; c++) {
if (r != (num_rows - 1) || c != 99) {
CuAssertIntEquals_Msg(tc, "Should be empty", EMPTY, array[r][c]);
}
}
}
}
void placeToken_c1(CuTest *tc) {
int num_rows = 7;
int num_columns = 7;
int array[num_rows][num_columns];
ct_initialize(num_rows, num_columns, array);
placeToken(1, 3, num_rows, num_columns, array);
// make sure there is a 1 at the bottom of column 3 and a -1 everywhere else
CuAssertIntEquals_Msg(tc, "Drop 1 into empty column 3", 1, array[num_rows - 1][3]);
int r, c;
for (r = 0; r < num_rows; r++) {
for (c = 0; c < num_columns; c++) {
if (r != (num_rows - 1) || c != 3) {
CuAssertIntEquals_Msg(tc, "Should be empty", EMPTY, array[r][c]);
}
}
}
}
void place_token_c5(CuTest *tc) {
int num_rows = 7;
int num_columns = 7;
int array[num_rows][num_columns];
ct_initialize(num_rows, num_columns, array);
place_token(1, 5, num_rows, num_columns, array);
// make sure there is a 1 at the bottom of column 5 and a -1 everywhere else
CuAssertIntEquals_Msg(tc, "Drop 1 into empty column 5", 1, array[num_rows - 1][5]);
place_token(1, 5, num_rows, num_columns, array);
CuAssertIntEquals_Msg(tc, "Drop 1 into column 5 on 1 full", 1, array[num_rows - 2][5]);
place_token(1, 5, num_rows, num_columns, array);
CuAssertIntEquals_Msg(tc, "Drop 1 into column 5 on 2 full", 1, array[num_rows - 3][5]);
int r, c;
for (r = 0; r < num_rows; r++) {
for (c = 0; c < num_columns; c++) {
if (r < (num_rows - 3) || c != 5) {
CuAssertIntEquals_Msg(tc, "Should be empty", EMPTY, array[r][c]);
}
}
}
}
