static void test_client_new(CuTest *tc) { const char *err = "client.c client_new FAIL"; client_t *c1, *c2; int max = STATIC_ALLOC_CLIENTS; /* For testing, use 10 is plenty */ int middle = max / 2; int i; if (STATIC_ALLOC_CLIENTS % 2 == 1) { CuFail(tc, "client.c client_new FAIL -- " "rerun with even number of clients allocated"); } for (i = 0; i < max; ++i) { c1 = client_new(); if (i == middle - 1) { //printf("Freeing client %d\n", i); client_free(c1); c1 = NULL; } } c1 = client_new(); client_free(c1); c2 = client_new(); CuAssertPtrEquals_Msg(tc, err, c1, c2); c1 = client_new(); CuAssertPtrEquals_Msg(tc, err, NULL, c1); #if UNIT_TESTING_VERBOSITY_LEVEL >= 1 printf("client.c client_new PASS\n"); #endif }
static void test_ev_watcher_new(CuTest *tc) { const char *err = "client.c ev_watcher_new FAIL"; struct ev_io *e1, *e2; int max = STATIC_ALLOC_CLIENTS; int middle = max / 2; int i, j; if (STATIC_ALLOC_CLIENTS % 2 == 1) { CuFail(tc, "client.c ev_watcher_new FAIL -- " "rerun with even number of clients allocated"); } for (i = 0; i < max; ++i) { e1 = ev_watcher_new(); if (i == middle - 1) { //printf("Freeing ev_io watcher %d\n", i); ev_watcher_free(e1); e1 = NULL; } } /* * Here we reacquire a pointer to the single ev_io struct that * was freed in the loop above. * We then free this again, and then acquire it again to make * sure that every single structure is checked before the * function returns NULL. * This means that e1 == e2, as we're reacquiring the same * ev_io struct. */ e1 = ev_watcher_new(); ev_watcher_free(e1); e2 = ev_watcher_new(); CuAssertPtrEquals_Msg(tc, err, e1, e2); /* * At this stage, all of the ev_io structures have been * allocated. * The function should loop over everything, and then return * NULL to indicate that there is no memory left. */ e1 = ev_watcher_new(); CuAssertPtrEquals_Msg(tc, err, NULL, e1); #if UNIT_TESTING_VERBOSITY_LEVEL >= 1 printf("client.c ev_watcher_new PASS\n"); #endif }
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 }
static void test_piracy_cmd_errors(CuTest * tc) { race *r; faction *f; unit *u, *u2; ship_type *st_boat; test_setup(); setup_piracy(); st_boat = st_get_or_create("boat"); r = test_create_race("pirates"); u = test_create_unit(f = test_create_faction(r), test_create_region(0, 0, get_or_create_terrain("ocean"))); f->locale = test_create_locale(); u->thisorder = create_order(K_PIRACY, f->locale, ""); assert(u && u->thisorder); piracy_cmd(u); CuAssertPtrNotNullMsg(tc, "must be on a ship for PIRACY", test_find_messagetype(f->msgs, "error144")); test_clear_messages(f); fset(r, RCF_SWIM); piracy_cmd(u); CuAssertPtrEquals_Msg(tc, "swimmers are pirates", 0, test_find_messagetype(f->msgs, "error144")); CuAssertPtrEquals_Msg(tc, "swimmers are pirates", 0, test_find_messagetype(f->msgs, "error146")); freset(r, RCF_SWIM); fset(r, RCF_FLY); CuAssertPtrEquals_Msg(tc, "flyers are pirates", 0, test_find_messagetype(f->msgs, "error144")); freset(r, RCF_FLY); test_clear_messages(f); u_set_ship(u, test_create_ship(u->region, st_boat)); u2 = test_create_unit(u->faction, u->region); u2->thisorder = create_order(K_PIRACY, f->locale, ""); u_set_ship(u2, u->ship); test_clear_messages(f); piracy_cmd(u2); CuAssertPtrNotNullMsg(tc, "must be owner for PIRACY", test_find_messagetype(f->msgs, "error146")); test_clear_messages(f); piracy_cmd(u); CuAssertPtrNotNullMsg(tc, "must specify target for PIRACY", test_find_messagetype(f->msgs, "piratenovictim")); CuAssertPtrNotNull(tc, u->thisorder); test_teardown(); }
static void test_attrib_add(CuTest * tc) { attrib_type at_foo = { "foo" }; attrib_type at_bar = { "bar" }; attrib *a, *alist = 0; CuAssertPtrNotNull(tc, (a = a_new(&at_foo))); CuAssertPtrEquals(tc, a, a_add(&alist, a)); CuAssertPtrEquals(tc, a, alist); CuAssertPtrNotNull(tc, (a = a_add(&alist, a_new(&at_foo)))); CuAssertPtrEquals_Msg(tc, "new attribute not added after existing", alist->next, a); CuAssertPtrNotNull(tc, (a = a_add(&alist, a_new(&at_bar)))); CuAssertPtrEquals_Msg(tc, "new atribute not added at end of list", alist->next->next, a); CuAssertPtrNotNull(tc, (a = a_add(&alist, a_new(&at_foo)))); CuAssertPtrEquals_Msg(tc, "messages not sorted by type", alist->next->next, a); a_removeall(&alist, &at_foo); a_removeall(&alist, &at_bar); }
void Test_iniparser_load(CuTest *tc) { DIR *dir; struct dirent *curr; struct stat curr_stat; dictionary *dic; char ini_path[256]; /* Dummy tests */ dic = iniparser_load("/you/shall/not/path"); CuAssertPtrEquals(tc, NULL, dic); /* Test all the good .ini files */ dir = opendir(GOOD_INI_PATH); CuAssertPtrNotNullMsg(tc, "Cannot open good .ini conf directory", dir); for (curr = readdir(dir); curr != NULL; curr = readdir(dir)) { sprintf(ini_path, "%s/%s", GOOD_INI_PATH, curr->d_name); stat(ini_path, &curr_stat); if (S_ISREG(curr_stat.st_mode)) { dic = iniparser_load(ini_path); CuAssertPtrNotNullMsg(tc, ini_path, dic); dictionary_del(dic); } } closedir(dir); /* Test all the bad .ini files */ dir = opendir(BAD_INI_PATH); CuAssertPtrNotNullMsg(tc, "Cannot open bad .ini conf directory", dir); for (curr = readdir(dir); curr != NULL; curr = readdir(dir)) { sprintf(ini_path, "%s/%s", BAD_INI_PATH, curr->d_name); stat(ini_path, &curr_stat); if (S_ISREG(curr_stat.st_mode)) { dic = iniparser_load(ini_path); CuAssertPtrEquals_Msg(tc, ini_path, NULL, dic); dictionary_del(dic); } } closedir(dir); }