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);
}
static void test_shipspeed(CuTest *tc) {
ship *sh;
const ship_type *stype;
unit *cap, *crew;
test_setup();
sh = setup_ship();
stype = sh->type;
CuAssertIntEquals_Msg(tc, "ship without a captain cannot move", 0, shipspeed(sh, NULL));
setup_crew(sh, 0, &cap, &crew);
CuAssertPtrEquals(tc, cap, ship_owner(sh));
CuAssertIntEquals_Msg(tc, "ship with fully skilled crew can sail at max speed", 2, shipspeed(sh, cap));
CuAssertIntEquals_Msg(tc, "shipspeed without a hint defaults to captain", 2, shipspeed(sh, NULL));
set_level(cap, SK_SAILING, stype->cptskill + 5);
set_level(crew, SK_SAILING, (stype->sumskill - stype->cptskill) * 10);
CuAssertIntEquals_Msg(tc, "higher skills should not affect top speed", 2, shipspeed(sh, cap));
set_level(cap, SK_SAILING, stype->cptskill);
set_level(crew, SK_SAILING, stype->sumskill - stype->cptskill);
CuAssertIntEquals(tc, 2, shipspeed(sh, cap));
set_level(crew, SK_SAILING, (stype->sumskill - stype->cptskill) * 11);
set_level(cap, SK_SAILING, stype->cptskill + 10);
CuAssertIntEquals_Msg(tc, "regular skills should not exceed sh.range", 2, shipspeed(sh, cap));
test_teardown();
}
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);
}
static void test_shipspeed_max_range(CuTest *tc) {
ship *sh;
ship_type *stype;
region *r;
struct faction *f;
unit *cap, *crew;
test_setup();
sh = setup_ship();
setup_crew(sh, 0, &cap, &crew);
config_set("movement.shipspeed.skillbonus", "5");
r = sh->region;
f = test_create_faction(NULL);
assert(r && f);
stype = st_get_or_create(sh->type->_name);
set_level(cap, SK_SAILING, stype->cptskill + 4);
set_level(crew, SK_SAILING, (stype->sumskill - stype->cptskill) * 4);
CuAssertIntEquals_Msg(tc, "skill bonus requires at least movement.shipspeed.skillbonus points", 2, shipspeed(sh, cap));
set_level(cap, SK_SAILING, stype->cptskill + 5);
set_level(crew, SK_SAILING, (stype->sumskill - stype->cptskill) * 5);
CuAssertIntEquals_Msg(tc, "skill bonus from movement.shipspeed.skillbonus", 3, shipspeed(sh, cap));
set_level(cap, SK_SAILING, stype->cptskill + 15);
scale_number(crew, 15);
set_level(crew, SK_SAILING, stype->sumskill - stype->cptskill);
CuAssertIntEquals_Msg(tc, "skill-bonus cannot exceed max_range", 4, shipspeed(sh, cap));
test_teardown();
}
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 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 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]);
}
static void
test_world_player_foreach(CuTest *tc)
{
const char *err = "world.c PLAYER_FOREACH macro FAIL";
const char *username = "******";
int max = MAX_PLAYERS;
int mid = max / 2;
player_t *player;
player_t *plist[max];
int i;
if (max % 2 == 1) {
CuFail(tc, "world.c PLAYER_FOREACH macro FAIL -- "
"Rerun tests with even number of max players");
}
for (i = 0; i < max; ++i) {
player = get_unused_player_slot();
CuAssertIntEquals_Msg(tc, err, i + 1, player->index);
player->username = username;
if (i == mid - 1) {
remove_player(player);
continue;
}
plist[i] = player;
}
i = 0;
player = NULL;
PLAYER_LIST_FOREACH(player) {
if (player->index == UNUSED) {
++i;
continue;
}
CuAssertPtrEquals_Msg(tc, err, plist[i++], player);
}
player = get_unused_player_slot();
CuAssertIntEquals_Msg(tc, err, mid, player->index);
player = get_unused_player_slot();
CuAssertPtrEquals_Msg(tc, err, NULL, player);
#if UNIT_TESTING_VERBOSITY_LEVEL >= 1
printf("world.c PLAYER_FOREACH macro PASS\n");
#endif
}
void Test_uip_arp_arpin_2(CuTest *tc) {
u8_t temp_buf[]= "\x11\x22\x33\x44\x55\x66\x77\x88\x99\x00\xAA\xBB\x08\x06"
"\x00\x01"
"\x08\x00"
"\x06"
"\x04"
"\x00\x02"
"\x77\x88\x99\x00\xAA\xBB"
"\xC0\xA8\x00\x03"
"\x11\x22\x33\x44\x55\x66"
"\xC0\xA8\x00\x02"
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00";
u8_t expect_buf[]= "\x77\x88\x99\x00\xAA\xBB\x11\x22\x33\x44\x55\x66\x08\x06"
"\x00\x01"
"\x08\x00"
"\x06"
"\x04"
"\x00\x02"
"\x11\x22\x33\x44\x55\x66"
"\xC0\xA8\x00\x02"
"\x77\x88\x99\x00\xAA\xBB"
"\xC0\xA8\x00\x03";
memcpy(uip_buf,temp_buf,60);
uip_len=42;
uip_arp_arpin();
CuAssertIntEquals_Msg(tc,"arpin_len 2",0,uip_len);
CuAssertTrue_Msg(tc,"tabl check 2",0==memcmp(arp_table,"\xC0\xA8\x00\x03"
"\x77\x88\x99\x00\xAA\xBB\x00",11));
}
static void
parse_response(CuTest *tc, struct altera_syscons_parser *parser,
const char *input, const char *expected_result)
{
CuAssertPtrNotNull(tc, parser);
CuAssertPtrNotNull(tc, parser->parse_response);
const char *begin, *end;
int ret = parser->parse_response(input, strlen(input),
&begin, &end);
CuAssertIntEquals_Msg(tc, "parse error",
BERI_DEBUG_SUCCESS, ret);
CuAssertPtrNotNullMsg(tc, "parsed NULL 'begin'", begin);
CuAssertPtrNotNullMsg(tc, "parsed NULL 'end'", end);
CuAssert(tc, "begin > end", (begin <= end));
char result[end - begin + 1];
strncpy(result, begin, end - begin);
result[end - begin] = '\0';
CuAssertStrEquals_Msg(tc, "unexpected result",
expected_result, result);
}
static void
check_path(CuTest *tc, struct altera_syscons_parser *parser,
const char *input, const char *cable,
int expected_result, const char *expected_path)
{
const char *begin, *end;
CuAssertPtrNotNull(tc, parser);
CuAssertPtrNotNull(tc, parser->parse_service_path);
int ret = parser->parse_service_path(input, strlen(input), cable,
&begin, &end);
CuAssertIntEquals_Msg(tc, cable, expected_result, ret);
if (expected_result == BERI_DEBUG_SUCCESS) {
CuAssertPtrNotNullMsg(tc, "parsed NULL 'begin'", begin);
CuAssertPtrNotNullMsg(tc, "parsed NULL 'end'", end);
CuAssert(tc, "begin > end", (begin <= end));
char result[end - begin + 1];
strncpy(result, begin, end - begin);
result[end - begin] = '\0';
CuAssertStrEquals_Msg(tc, "unexpected path",
expected_path, result);
}
}
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 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 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);
}
static void test_shipspeed_damage(CuTest *tc) {
ship *sh;
unit *cap, *crew;
test_setup();
sh = setup_ship();
setup_crew(sh, 0, &cap, &crew);
assert(sh && cap && crew);
sh->damage = 1;
CuAssertIntEquals_Msg(tc, "minimally damaged ships lose no range", 2, shipspeed(sh, cap));
sh->damage = sh->size * DAMAGE_SCALE / 2;
CuAssertIntEquals_Msg(tc, "damaged ships lose range", 1, shipspeed(sh, cap));
sh->damage = sh->size * DAMAGE_SCALE;
CuAssertIntEquals_Msg(tc, "fully damaged ships have no range", 0, shipspeed(sh, cap));
test_teardown();
}
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 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 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 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 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 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 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_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 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 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 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 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);
}
