Marc
/
server
forked from github/server
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Do not use 0 to mean NULL pointers.

This commit is contained in:
Enno Rehling 2018-10-14 11:48:21 +02:00
parent 0cc8adeeef
commit a7b9f6dc3e
33 changed files with 226 additions and 224 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
clibs

@ -1 +1 @@
Subproject commit d86c8525489d7f11b7ba13e101bb59ecf160b871
Subproject commit 12139c7ce25e6731393f863e248ab16aa0578a3a

24
src/alchemy.test.c
View File

@ -45,16 +45,16 @@ static void test_herbsearch(CuTest * tc)
CuAssertPtrEquals(tc, u2, is_guarded(r, u));
herbsearch(u, INT_MAX);
CuAssertPtrNotNull(tc, test_find_messagetype(f->msgs, "error70"));
CuAssertPtrEquals(tc, 0, test_find_messagetype(f->msgs, "error59"));
CuAssertPtrEquals(tc, NULL, test_find_messagetype(f->msgs, "error59"));
test_clear_messages(f);
setguard(u2, false);
CuAssertPtrEquals(tc, 0, is_guarded(r, u));
CuAssertPtrEquals(tc, 0, (void *)rherbtype(r));
CuAssertPtrEquals(tc, NULL, is_guarded(r, u));
CuAssertPtrEquals(tc, NULL, (void *)rherbtype(r));
herbsearch(u, INT_MAX);
CuAssertPtrNotNull(tc, test_find_messagetype(f->msgs, "error108"));
CuAssertPtrEquals(tc, 0, test_find_messagetype(f->msgs, "error70"));
CuAssertPtrEquals(tc, 0, test_find_messagetype(f->msgs, "error59"));
CuAssertPtrEquals(tc, NULL, test_find_messagetype(f->msgs, "error70"));
CuAssertPtrEquals(tc, NULL, test_find_messagetype(f->msgs, "error59"));
test_clear_messages(f);
rsetherbtype(r, itype);
@ -62,9 +62,9 @@ static void test_herbsearch(CuTest * tc)
CuAssertIntEquals(tc, 0, rherbs(r));
herbsearch(u, INT_MAX);
CuAssertPtrNotNull(tc, test_find_messagetype(f->msgs, "researchherb_none"));
CuAssertPtrEquals(tc, 0, test_find_messagetype(f->msgs, "error108"));
CuAssertPtrEquals(tc, 0, test_find_messagetype(f->msgs, "error70"));
CuAssertPtrEquals(tc, 0, test_find_messagetype(f->msgs, "error59"));
CuAssertPtrEquals(tc, NULL, test_find_messagetype(f->msgs, "error108"));
CuAssertPtrEquals(tc, NULL, test_find_messagetype(f->msgs, "error70"));
CuAssertPtrEquals(tc, NULL, test_find_messagetype(f->msgs, "error59"));
test_clear_messages(f);
rsetherbs(r, 100);
@ -73,10 +73,10 @@ static void test_herbsearch(CuTest * tc)
CuAssertIntEquals(tc, 99, rherbs(r));
CuAssertIntEquals(tc, 1, i_get(u->items, itype));
CuAssertPtrNotNull(tc, test_find_messagetype(f->msgs, "herbfound"));
CuAssertPtrEquals(tc, 0, test_find_messagetype(f->msgs, "researchherb_none"));
CuAssertPtrEquals(tc, 0, test_find_messagetype(f->msgs, "error108"));
CuAssertPtrEquals(tc, 0, test_find_messagetype(f->msgs, "error70"));
CuAssertPtrEquals(tc, 0, test_find_messagetype(f->msgs, "error59"));
CuAssertPtrEquals(tc, NULL, test_find_messagetype(f->msgs, "researchherb_none"));
CuAssertPtrEquals(tc, NULL, test_find_messagetype(f->msgs, "error108"));
CuAssertPtrEquals(tc, NULL, test_find_messagetype(f->msgs, "error70"));
CuAssertPtrEquals(tc, NULL, test_find_messagetype(f->msgs, "error59"));
test_clear_messages(f);
test_teardown();

28
src/automate.c
View File

@ -36,20 +36,22 @@ int autostudy_init(scholar scholars[], int max_scholars, region *r)
for (u = r->units; u; u = u->next) {
keyword_t kwd = getkeyword(u->thisorder);
if (kwd == K_AUTOSTUDY) {
if (long_order_allowed(u) && unit_can_study(u)) {
scholar * st = scholars + nscholars;
init_order(u->thisorder, u->faction->locale);
st->sk = getskill(u->faction->locale);
st->level = effskill_study(u, st->sk);
st->learn = 0;
st->u = u;
if (++nscholars == max_scholars) {
log_fatal("you must increase MAXSCHOLARS");
if (long_order_allowed(u)) {
if (unit_can_study(u)) {
scholar * st = scholars + nscholars;
init_order(u->thisorder, u->faction->locale);
st->sk = getskill(u->faction->locale);
st->level = effskill_study(u, st->sk);
st->learn = 0;
st->u = u;
if (++nscholars == max_scholars) {
log_fatal("you must increase MAXSCHOLARS");
}
}
else {
ADDMSG(&u->faction->msgs, msg_feedback(u, u->thisorder, "error_race_nolearn", "race",
u_race(u)));
}
}
else {
ADDMSG(&u->faction->msgs, msg_feedback(u, u->thisorder, "error_race_nolearn", "race",
u_race(u)));
}
}
}

8
src/battle.test.c
View File

@ -78,7 +78,7 @@ static void test_make_fighter(CuTest * tc)
af = make_fighter(b, au, as, false);
CuAssertIntEquals(tc, 1, b->nfighters);
CuAssertPtrEquals(tc, 0, af->building);
CuAssertPtrEquals(tc, NULL, af->building);
CuAssertPtrEquals(tc, as, af->side);
CuAssertIntEquals(tc, 0, af->run.hp);
CuAssertIntEquals(tc, ST_BEHIND, af->status);
@ -216,7 +216,7 @@ static void test_defenders_get_building_bonus(CuTest * tc)
af = make_fighter(b, au, as, true);
CuAssertPtrEquals(tc, bld, df->building);
CuAssertPtrEquals(tc, 0, af->building);
CuAssertPtrEquals(tc, NULL, af->building);
dt.fighter = df;
dt.index = 0;
@ -261,7 +261,7 @@ static void test_attackers_get_no_building_bonus(CuTest * tc)
as = make_side(b, au->faction, 0, 0, 0);
af = make_fighter(b, au, as, true);
CuAssertPtrEquals(tc, 0, af->building);
CuAssertPtrEquals(tc, NULL, af->building);
free_battle(b);
test_teardown();
}
@ -298,7 +298,7 @@ static void test_building_bonus_respects_size(CuTest * tc)
df = make_fighter(b, du, as, false);
CuAssertPtrEquals(tc, bld, af->building);
CuAssertPtrEquals(tc, 0, df->building);
CuAssertPtrEquals(tc, NULL, df->building);
free_battle(b);
test_teardown();
}

12
src/economy.test.c
View File

@ -357,7 +357,7 @@ static void test_tax_cmd(CuTest *tc) {
set_level(u, SK_TAXING, 1);
tax_cmd(u, ord, &taxorders);
CuAssertPtrEquals(tc, 0, test_find_messagetype(u->faction->msgs, "error_no_tax_skill"));
CuAssertPtrEquals(tc, NULL, test_find_messagetype(u->faction->msgs, "error_no_tax_skill"));
CuAssertPtrNotNull(tc, taxorders);
rsetmoney(r, 11);
@ -415,8 +415,8 @@ static void test_maintain_buildings(CuTest *tc) {
b->flags = 0;
maintain_buildings(r);
CuAssertIntEquals(tc, BLD_MAINTAINED, fval(b, BLD_MAINTAINED));
CuAssertPtrEquals(tc, 0, f->msgs);
CuAssertPtrEquals(tc, 0, r->msgs);
CuAssertPtrEquals(tc, NULL, f->msgs);
CuAssertPtrEquals(tc, NULL, r->msgs);
req = calloc(2, sizeof(maintenance));
req[0].number = 100;
@ -438,8 +438,8 @@ static void test_maintain_buildings(CuTest *tc) {
maintain_buildings(r);
CuAssertIntEquals(tc, BLD_MAINTAINED, fval(b, BLD_MAINTAINED));
CuAssertIntEquals(tc, 0, i_get(u->items, itype));
CuAssertPtrEquals(tc, 0, r->msgs);
CuAssertPtrEquals(tc, 0, test_find_messagetype(f->msgs, "maintenance_nowork"));
CuAssertPtrEquals(tc, NULL, r->msgs);
CuAssertPtrEquals(tc, NULL, test_find_messagetype(f->msgs, "maintenance_nowork"));
CuAssertPtrNotNull(tc, test_find_messagetype(f->msgs, "maintenance"));
test_clear_messagelist(&f->msgs);
@ -448,7 +448,7 @@ static void test_maintain_buildings(CuTest *tc) {
b->flags = 0;
maintain_buildings(r);
CuAssertIntEquals(tc, 0, fval(b, BLD_MAINTAINED));
CuAssertPtrEquals(tc, 0, f->msgs);
CuAssertPtrEquals(tc, NULL, f->msgs);
CuAssertPtrNotNull(tc, test_find_messagetype(r->msgs, "maintenance_noowner"));
test_clear_messagelist(&r->msgs);

8
src/give.test.c
View File

@ -92,7 +92,7 @@ static void test_give_unit(CuTest * tc) {
give_unit(env.src, env.dst, NULL);
CuAssertPtrEquals(tc, env.f2, env.src->faction);
CuAssertIntEquals(tc, 1, env.f2->newbies);
CuAssertPtrEquals(tc, 0, env.f1->units);
CuAssertPtrEquals(tc, NULL, env.f1->units);
CuAssertPtrNotNull(tc, test_find_messagetype(env.f1->msgs, "give_person"));
CuAssertPtrNotNull(tc, test_find_messagetype(env.f2->msgs, "receive_person"));
test_teardown();
@ -304,7 +304,7 @@ static void test_give_men_requires_contact(CuTest * tc) {
ord = create_order(K_GIVE, env.f1->locale, "%s ALLES PERSONEN", itoa36(env.dst->no));
test_clear_messages(env.f1);
give_cmd(env.src, ord);
CuAssertPtrEquals(tc, 0, test_find_messagetype(env.f1->msgs, "give_person"));
CuAssertPtrEquals(tc, NULL, test_find_messagetype(env.f1->msgs, "give_person"));
CuAssertPtrNotNull(tc, test_find_messagetype(env.f1->msgs, "feedback_no_contact"));
msg_release(msg);
@ -408,7 +408,7 @@ static void test_give_okay(CuTest * tc) {
setup_give(&env);
config_set("rules.give.flags", "0");
CuAssertPtrEquals(tc, 0, check_give(env.src, env.dst, NULL));
CuAssertPtrEquals(tc, NULL, check_give(env.src, env.dst, NULL));
test_teardown();
}
@ -451,7 +451,7 @@ static void test_give_new_unit(CuTest * tc) {
setup_give(&env);
env.dst->number = 0;
fset(env.dst, UFL_ISNEW);
CuAssertPtrEquals(tc, 0, check_give(env.src, env.dst, NULL));
CuAssertPtrEquals(tc, NULL, check_give(env.src, env.dst, NULL));
test_teardown();
}

2
src/guard.test.c
View File

@ -29,7 +29,7 @@ static void test_is_guarded(CuTest *tc) {
r = test_create_region(0, 0, NULL);
u1 = test_create_unit(test_create_faction(NULL), r);
u2 = test_create_unit(test_create_faction(rc), r);
CuAssertPtrEquals(tc, 0, is_guarded(r, u1));
CuAssertPtrEquals(tc, NULL, is_guarded(r, u1));
setguard(u2, true);
CuAssertPtrEquals(tc, u2, is_guarded(r, u1));
test_teardown();

6
src/json.test.c
View File

@ -71,8 +71,8 @@ static cJSON *export_a_region(CuTest * tc, const struct terrain_type *terrain, r
json = cJSON_Parse(buf);
CuAssertPtrNotNull(tc, json);
CuAssertIntEquals(tc, cJSON_Object, json->type);
CuAssertPtrEquals(tc, 0, cJSON_GetObjectItem(json, "factions"));
CuAssertPtrEquals(tc, 0, cJSON_GetObjectItem(json, "units"));
CuAssertPtrEquals(tc, NULL, cJSON_GetObjectItem(json, "factions"));
CuAssertPtrEquals(tc, NULL, cJSON_GetObjectItem(json, "units"));
CuAssertPtrNotNull(tc, regs = cJSON_GetObjectItem(json, "regions"));
CuAssertIntEquals(tc, cJSON_Object, regs->type);
result = regs->child;
@ -111,7 +111,7 @@ static void test_export_ocean_region(CuTest * tc) {
test_setup();
terrain = test_create_terrain("ocean", SEA_REGION);
json = export_a_region(tc, terrain, 0);
CuAssertPtrEquals(tc, 0, cJSON_GetObjectItem(json, "name"));
CuAssertPtrEquals(tc, NULL, cJSON_GetObjectItem(json, "name"));
cJSON_Delete(json);
test_teardown();
}

28
src/kernel/alliance.test.c
View File

@ -34,14 +34,14 @@ static void test_alliance_make(CuTest *tc) {
CuAssertStrEquals(tc, "Hodor", al->name);
CuAssertIntEquals(tc, 1, al->id);
CuAssertIntEquals(tc, 0, al->flags);
CuAssertPtrEquals(tc, 0, al->members);
CuAssertPtrEquals(tc, 0, al->_leader);
CuAssertPtrEquals(tc, 0, al->allies);
CuAssertPtrEquals(tc, NULL, al->members);
CuAssertPtrEquals(tc, NULL, al->_leader);
CuAssertPtrEquals(tc, NULL, al->allies);
CuAssertPtrEquals(tc, al, findalliance(1));
CuAssertPtrEquals(tc, al, alliances);
free_alliances();
CuAssertPtrEquals(tc, 0, findalliance(1));
CuAssertPtrEquals(tc, 0, alliances);
CuAssertPtrEquals(tc, NULL, findalliance(1));
CuAssertPtrEquals(tc, NULL, alliances);
test_teardown();
}
@ -50,8 +50,8 @@ static void test_alliance_join(CuTest *tc) {
alliance * al;
setup_alliance(&fix);
CuAssertPtrEquals(tc, 0, fix.f1->alliance);
CuAssertPtrEquals(tc, 0, fix.f2->alliance);
CuAssertPtrEquals(tc, NULL, fix.f1->alliance);
CuAssertPtrEquals(tc, NULL, fix.f2->alliance);
al = makealliance(1, "Hodor");
setalliance(fix.f1, al);
CuAssertPtrEquals(tc, fix.f1, alliance_get_leader(al));
@ -99,7 +99,7 @@ static void test_alliance_cmd(CuTest *tc) {
unit_addorder(u2, create_order(K_ALLIANCE, u1->faction->locale, "%s %s", alliance_kwd[ALLIANCE_JOIN], itoa36(42)));
CuAssertTrue(tc, is_allied(u1->faction, u1->faction));
CuAssertTrue(tc, !is_allied(u1->faction, u2->faction));
CuAssertPtrEquals(tc, 0, f_get_alliance(u1->faction));
CuAssertPtrEquals(tc, NULL, f_get_alliance(u1->faction));
alliance_cmd();
al = f_get_alliance(u1->faction);
CuAssertPtrNotNull(tc, al);
@ -126,10 +126,10 @@ static void test_alliance_limits(CuTest *tc) {
unit_addorder(u1, create_order(K_ALLIANCE, u1->faction->locale, "%s %s", alliance_kwd[ALLIANCE_INVITE], itoa36(u2->faction->no)));
unit_addorder(u2, create_order(K_ALLIANCE, u1->faction->locale, "%s %s", alliance_kwd[ALLIANCE_JOIN], itoa36(42)));
CuAssertTrue(tc, !is_allied(u1->faction, u2->faction));
CuAssertPtrEquals(tc, 0, f_get_alliance(u1->faction));
CuAssertPtrEquals(tc, NULL, f_get_alliance(u1->faction));
alliance_cmd();
CuAssertPtrNotNull(tc, f_get_alliance(u1->faction));
CuAssertPtrEquals(tc, 0, f_get_alliance(u2->faction));
CuAssertPtrEquals(tc, NULL, f_get_alliance(u2->faction));
CuAssertTrue(tc, !is_allied(u1->faction, u2->faction));
CuAssertPtrNotNull(tc, test_find_messagetype(u2->faction->msgs, "too_many_units_in_alliance"));
test_teardown();
@ -152,7 +152,7 @@ static void test_alliance_cmd_kick(CuTest *tc) {
CuAssertTrue(tc, is_allied(u1->faction, u2->faction));
alliance_cmd();
CuAssertTrue(tc, !is_allied(u1->faction, u2->faction));
CuAssertPtrEquals(tc, 0, f_get_alliance(u2->faction));
CuAssertPtrEquals(tc, NULL, f_get_alliance(u2->faction));
test_teardown();
}
@ -168,10 +168,10 @@ static void test_alliance_cmd_no_invite(CuTest *tc) {
unit_addorder(u2, create_order(K_ALLIANCE, u1->faction->locale, "%s %s", alliance_kwd[ALLIANCE_JOIN], itoa36(42)));
CuAssertTrue(tc, is_allied(u1->faction, u1->faction));
CuAssertTrue(tc, !is_allied(u1->faction, u2->faction));
CuAssertPtrEquals(tc, 0, f_get_alliance(u1->faction));
CuAssertPtrEquals(tc, NULL, f_get_alliance(u1->faction));
alliance_cmd();
CuAssertPtrNotNull(tc, f_get_alliance(u1->faction));
CuAssertPtrEquals(tc, 0, f_get_alliance(u2->faction));
CuAssertPtrEquals(tc, NULL, f_get_alliance(u2->faction));
CuAssertTrue(tc, !is_allied(u1->faction, u2->faction));
test_teardown();
}
@ -193,7 +193,7 @@ static void test_alliance_cmd_leave(CuTest *tc) {
CuAssertTrue(tc, is_allied(u1->faction, u2->faction));
alliance_cmd();
CuAssertTrue(tc, !is_allied(u1->faction, u2->faction));
CuAssertPtrEquals(tc, 0, f_get_alliance(u1->faction));
CuAssertPtrEquals(tc, NULL, f_get_alliance(u1->faction));
test_teardown();
}

6
src/kernel/ally.test.c
View File

@ -15,8 +15,8 @@ static void test_ally(CuTest * tc)
CuAssertPtrEquals(tc, f1, ally_find(al, f1)->faction);
ally_remove(&al, f1);
CuAssertPtrEquals(tc, 0, al);
CuAssertPtrEquals(tc, 0, ally_find(al, f1));
CuAssertPtrEquals(tc, NULL, al);
CuAssertPtrEquals(tc, NULL, ally_find(al, f1));
}
static void test_ally_null(CuTest * tc)
@ -28,7 +28,7 @@ static void test_ally_null(CuTest * tc)
CuAssertPtrNotNull(tc, a1);
CuAssertPtrNotNull(tc, a2);
CuAssertPtrEquals(tc, a2, a1->next);
CuAssertPtrEquals(tc, 0, a2->next);
CuAssertPtrEquals(tc, NULL, a2->next);
free(a1);
free(a2);
}

22
src/kernel/attrib.test.c
View File

@ -15,11 +15,11 @@ static void test_attrib_new(CuTest * tc)
attrib_type at_test = { "test" };
attrib * a;
CuAssertPtrNotNull(tc, (a = a_new(&at_test)));
CuAssertPtrEquals(tc, 0, a->next);
CuAssertPtrEquals(tc, 0, a->nexttype);
CuAssertPtrEquals(tc, NULL, a->next);
CuAssertPtrEquals(tc, NULL, a->nexttype);
CuAssertPtrEquals(tc, (void *)a->type, (void *)&at_test);
a_remove(&a, a);
CuAssertPtrEquals(tc, 0, a);
CuAssertPtrEquals(tc, NULL, a);
}
static void test_attrib_add(CuTest * tc)
@ -51,7 +51,7 @@ static void test_attrib_remove_self(CuTest * tc) {
CuAssertPtrNotNull(tc, a_add(&alist, a_new(&at_foo)));
CuAssertPtrNotNull(tc, a = a_add(&alist, a_new(&at_foo)));
CuAssertPtrEquals(tc, a, alist->next);
CuAssertPtrEquals(tc, 0, alist->nexttype);
CuAssertPtrEquals(tc, NULL, alist->nexttype);
CuAssertIntEquals(tc, 1, a_remove(&alist, alist));
CuAssertPtrEquals(tc, a, alist);
a_removeall(&alist, NULL);
@ -66,11 +66,11 @@ static void test_attrib_removeall(CuTest * tc) {
a_add(&alist, a_new(&at_foo));
a_removeall(&alist, &at_foo);
CuAssertPtrEquals(tc, a, alist);
CuAssertPtrEquals(tc, 0, alist->next);
CuAssertPtrEquals(tc, NULL, alist->next);
a_add(&alist, a_new(&at_bar));
a_add(&alist, a_new(&at_foo));
a_removeall(&alist, NULL);
CuAssertPtrEquals(tc, 0, alist);
CuAssertPtrEquals(tc, NULL, alist);
}
static void test_attrib_remove(CuTest * tc)
@ -83,7 +83,7 @@ static void test_attrib_remove(CuTest * tc)
CuAssertIntEquals(tc, 1, a_remove(&alist, a));
CuAssertPtrNotNull(tc, alist);
CuAssertIntEquals(tc, 1, a_remove(&alist, alist));
CuAssertPtrEquals(tc, 0, alist);
CuAssertPtrEquals(tc, NULL, alist);
}
static void test_attrib_nexttype(CuTest * tc)
@ -92,16 +92,16 @@ static void test_attrib_nexttype(CuTest * tc)
attrib_type at_bar = { "bar" };
attrib *a, *alist = 0;
CuAssertPtrNotNull(tc, (a = a_new(&at_foo)));
CuAssertPtrEquals(tc, 0, a->nexttype);
CuAssertPtrEquals(tc, NULL, a->nexttype);
CuAssertPtrEquals(tc, a, a_add(&alist, a));
CuAssertPtrEquals(tc, 0, alist->nexttype);
CuAssertPtrEquals(tc, NULL, alist->nexttype);
CuAssertPtrNotNull(tc, a_add(&alist, a_new(&at_foo)));
CuAssertPtrEquals(tc, 0, alist->nexttype);
CuAssertPtrEquals(tc, NULL, alist->nexttype);
CuAssertPtrNotNull(tc, (a = a_add(&alist, a_new(&at_bar))));
CuAssertPtrEquals(tc, a, alist->nexttype);
CuAssertPtrEquals(tc, 0, a->nexttype);
CuAssertPtrEquals(tc, NULL, a->nexttype);
a_remove(&alist, alist);
CuAssertPtrEquals(tc, a, alist->nexttype);

8
src/kernel/build.test.c
View File

@ -202,8 +202,8 @@ static void test_build_building_no_materials(CuTest *tc) {
set_level(u, SK_BUILDING, 1);
u->orders = create_order(K_MAKE, u->faction->locale, 0);
CuAssertIntEquals(tc, ENOMATERIALS, build_building(u, btype, 0, 4, u->orders));
CuAssertPtrEquals(tc, 0, u->region->buildings);
CuAssertPtrEquals(tc, 0, u->building);
CuAssertPtrEquals(tc, NULL, u->region->buildings);
CuAssertPtrEquals(tc, NULL, u->building);
teardown_build(&bf);
}
@ -267,7 +267,7 @@ static void test_build_destroy_road(CuTest *tc)
CuAssertIntEquals(tc, 0, destroy_cmd(u, ord));
CuAssertIntEquals(tc, 100, rroad(r, D_EAST));
CuAssertPtrEquals(tc, 0, test_find_messagetype(f->msgs, "destroy_road"));
CuAssertPtrEquals(tc, NULL, test_find_messagetype(f->msgs, "destroy_road"));
set_level(u, SK_ROAD_BUILDING, 1);
CuAssertIntEquals(tc, 0, destroy_cmd(u, ord));
@ -324,7 +324,7 @@ static void test_build_destroy_road_guard(CuTest *tc)
CuAssertIntEquals(tc, 0, destroy_cmd(u, ord));
CuAssertIntEquals(tc, 100, rroad(r, D_EAST));
CuAssertPtrNotNull(tc, test_find_messagetype(f->msgs, "error70"));
CuAssertPtrEquals(tc, 0, test_find_messagetype(f->msgs, "destroy_road"));
CuAssertPtrEquals(tc, NULL, test_find_messagetype(f->msgs, "destroy_road"));
test_clear_messages(f);
setguard(ug, false);

4
src/kernel/command.test.c
View File

@ -37,8 +37,8 @@ static void test_command(CuTest * tc) {
st = stree_create();
CuAssertPtrNotNull(tc, st);
CuAssertPtrEquals(tc, loc, (struct locale *)st->lang);
CuAssertPtrEquals(tc, 0, st->root);
CuAssertPtrEquals(tc, 0, st->next);
CuAssertPtrEquals(tc, NULL, st->root);
CuAssertPtrEquals(tc, NULL, st->next);
stree_add(st, "two", parser_two);
stree_add(st, "six", parser_six);
CuAssertPtrNotNull(tc, st->root);

10
src/kernel/faction.test.c
View File

@ -57,7 +57,7 @@ static void test_remove_empty_factions_alliance(CuTest *tc) {
CuAssertPtrEquals(tc, f, alliance_get_leader(al));
CuAssertIntEquals(tc, 1, selist_length(al->members));
remove_empty_factions();
CuAssertPtrEquals(tc, 0, al->_leader);
CuAssertPtrEquals(tc, NULL, al->_leader);
CuAssertIntEquals(tc, 0, selist_length(al->members));
test_teardown();
}
@ -75,7 +75,7 @@ static void test_remove_empty_factions(CuTest *tc) {
CuAssertIntEquals(tc, false, f->_alive);
CuAssertPtrEquals(tc, fm, factions);
CuAssertPtrEquals(tc, NULL, fm->next);
CuAssertPtrEquals(tc, 0, findfaction(fno));
CuAssertPtrEquals(tc, NULL, findfaction(fno));
CuAssertPtrEquals(tc, fm, get_monsters());
test_teardown();
}
@ -99,7 +99,7 @@ static void test_remove_dead_factions(CuTest *tc) {
f->_alive = false;
fno = f->no;
remove_empty_factions();
CuAssertPtrEquals(tc, 0, findfaction(fno));
CuAssertPtrEquals(tc, NULL, findfaction(fno));
CuAssertPtrEquals(tc, fm, get_monsters());
test_teardown();
}
@ -162,7 +162,7 @@ static void test_set_origin(CuTest *tc) {
test_setup();
pl = create_new_plane(0, "", 0, 19, 0, 19, 0);
f = test_create_faction(NULL);
CuAssertPtrEquals(tc, 0, f->ursprung);
CuAssertPtrEquals(tc, NULL, f->ursprung);
faction_setorigin(f, 0, 1, 1);
CuAssertIntEquals(tc, 0, f->ursprung->id);
CuAssertIntEquals(tc, 1, f->ursprung->x);
@ -250,7 +250,7 @@ static void test_set_email(CuTest *tc) {
faction_setemail(f, "bugs@eressea.de");
CuAssertStrEquals(tc, "bugs@eressea.de", f->email);
faction_setemail(f, NULL);
CuAssertPtrEquals(tc, 0, f->email);
CuAssertPtrEquals(tc, NULL, f->email);
CuAssertStrEquals(tc, "", faction_getemail(f));
test_teardown();
}

12
src/kernel/group.test.c
View File

@ -35,7 +35,7 @@ static void test_group_readwrite_dead_faction(CuTest *tc) {
f = test_create_faction(NULL);
fno = f->no;
CuAssertPtrEquals(tc, f, factions);
CuAssertPtrEquals(tc, 0, f->next);
CuAssertPtrEquals(tc, NULL, f->next);
f2 = test_create_faction(NULL);
CuAssertPtrEquals(tc, f2, factions->next);
u = test_create_unit(f2, test_create_region(0, 0, NULL));
@ -58,14 +58,14 @@ static void test_group_readwrite_dead_faction(CuTest *tc) {
read_game(&data);
mstream_done(&data.strm);
gamedata_done(&data);
CuAssertPtrEquals(tc, 0, findfaction(fno));
CuAssertPtrEquals(tc, NULL, findfaction(fno));
f2 = factions;
CuAssertPtrNotNull(tc, f2);
u = f2->units;
CuAssertPtrNotNull(tc, u);
g = get_group(u);
CuAssertPtrNotNull(tc, g);
CuAssertPtrEquals(tc, 0, g->allies);
CuAssertPtrEquals(tc, NULL, g->allies);
test_teardown();
}
@ -106,11 +106,11 @@ static void test_group_readwrite(CuTest * tc)
CuAssertPtrNotNull(tc, f->groups->next);
CuAssertIntEquals(tc, 43, f->groups->next->gid);
CuAssertStrEquals(tc, "Egoisten", f->groups->next->name);
CuAssertPtrEquals(tc, 0, f->groups->allies);
CuAssertPtrEquals(tc, NULL, f->groups->allies);
g = f->groups->next;
CuAssertIntEquals(tc, 44, key_get(g->attribs, 44));
CuAssertPtrNotNull(tc, g->allies);
CuAssertPtrEquals(tc, 0, g->allies->next);
CuAssertPtrEquals(tc, NULL, g->allies->next);
CuAssertPtrEquals(tc, f, g->allies->faction);
CuAssertIntEquals(tc, HELP_GIVE, g->allies->status);
test_teardown();
@ -135,7 +135,7 @@ static void test_group(CuTest * tc)
CuAssertIntEquals(tc, 1, g->members);
set_group(u, 0);
CuAssertIntEquals(tc, 0, g->members);
CuAssertPtrEquals(tc, 0, get_group(u));
CuAssertPtrEquals(tc, NULL, get_group(u));
set_group(u, g);
CuAssertIntEquals(tc, 1, g->members);
CuAssertPtrEquals(tc, g, get_group(u));

14
src/kernel/item.test.c
View File

@ -61,7 +61,7 @@ static void test_uchange(CuTest * tc, unit * u, const resource_type * rtype) {
CuAssertIntEquals(tc, 0, rtype->uchange(u, rtype, -n));
CuAssertPtrNotNull(tc, sl);
CuAssertStrEquals(tc, "serious accounting error. number of items is %d.", sl->s);
CuAssertPtrEquals(tc, 0, sl->next);
CuAssertPtrEquals(tc, NULL, sl->next);
test_log_stop(log, sl);
}
@ -86,7 +86,7 @@ void test_resource_type(CuTest * tc)
test_setup();
CuAssertPtrEquals(tc, 0, rt_find("herpderp"));
CuAssertPtrEquals(tc, NULL, rt_find("herpderp"));
test_create_itemtype("herpderp");
test_create_itemtype("herpes");
@ -122,7 +122,7 @@ void test_findresourcetype(CuTest * tc)
locale_setstring(lang, "peasant", "Bauer");
init_resources();
CuAssertPtrNotNull(tc, rt_find("peasant"));
CuAssertPtrEquals(tc, 0, rt_find("log"));
CuAssertPtrEquals(tc, NULL, rt_find("log"));
itype = test_create_itemtype("log");
CuAssertPtrEquals(tc, (void*)itype->rtype, (void*)findresourcetype("Holz", lang));
@ -164,13 +164,13 @@ static void test_core_resources(CuTest *tc) {
CuAssertPtrNotNull(tc, rtype->itype);
CuAssertPtrNotNull(tc, rtype->uchange);
CuAssertPtrNotNull(tc, rtype = rt_find("peasant"));
CuAssertPtrEquals(tc, 0, rtype->itype);
CuAssertPtrEquals(tc, NULL, rtype->itype);
CuAssertPtrNotNull(tc, rtype = rt_find("permaura"));
CuAssertPtrEquals(tc, 0, rtype->itype);
CuAssertPtrEquals(tc, NULL, rtype->itype);
CuAssertPtrNotNull(tc, rtype = rt_find("hp"));
CuAssertPtrEquals(tc, 0, rtype->itype);
CuAssertPtrEquals(tc, NULL, rtype->itype);
CuAssertPtrNotNull(tc, rtype = rt_find("aura"));
CuAssertPtrEquals(tc, 0, rtype->itype);
CuAssertPtrEquals(tc, NULL, rtype->itype);
test_teardown();
}

4
src/kernel/messages.test.c
View File

@ -59,7 +59,7 @@ static void test_merge_split(CuTest *tc) {
add_message(&append, msg = msg_message(mtype->name, ""));
msg_release(msg);
CuAssertPtrEquals(tc, 0, mlist->begin->next);
CuAssertPtrEquals(tc, NULL, mlist->begin->next);
CuAssertPtrEquals(tc, &mlist->begin->next, mlist->end);
split = merge_messages(mlist, append);
CuAssertPtrNotNull(tc, split);
@ -68,7 +68,7 @@ static void test_merge_split(CuTest *tc) {
CuAssertPtrNotNull(tc, mlist->begin->next);
CuAssertPtrEquals(tc, append->begin, mlist->begin->next);
split_messages(mlist, split);
CuAssertPtrEquals(tc, 0, mlist->begin->next);
CuAssertPtrEquals(tc, NULL, mlist->begin->next);
free_messagelist(*split);
free_messagelist(mlist->begin);
free(mlist);

4
src/kernel/order.test.c
View File

@ -239,11 +239,11 @@ static void test_replace_order(CuTest *tc) {
orig = create_order(K_MAKE, lang, NULL);
repl = create_order(K_ALLY, lang, NULL);
replace_order(&orders, orig, repl);
CuAssertPtrEquals(tc, 0, orders);
CuAssertPtrEquals(tc, NULL, orders);
orders = orig;
replace_order(&orders, orig, repl);
CuAssertPtrNotNull(tc, orders);
CuAssertPtrEquals(tc, 0, orders->next);
CuAssertPtrEquals(tc, NULL, orders->next);
CuAssertIntEquals(tc, getkeyword(repl), getkeyword(orders));
free_order(orders);
free_order(repl);

10
src/kernel/plane.test.c
View File

@ -11,15 +11,15 @@ static void test_plane(CuTest *tc) {
test_setup();
r = test_create_region(0, 0, NULL);
CuAssertPtrEquals(tc, 0, findplane(0, 0));
CuAssertPtrEquals(tc, 0, getplane(r));
CuAssertPtrEquals(tc, NULL, findplane(0, 0));
CuAssertPtrEquals(tc, NULL, getplane(r));
CuAssertIntEquals(tc, 0, getplaneid(r));
CuAssertPtrEquals(tc, 0, getplanebyid(0));
CuAssertPtrEquals(tc, NULL, getplanebyid(0));
CuAssertIntEquals(tc, 0, plane_center_x(0));
CuAssertIntEquals(tc, 0, plane_center_y(0));
CuAssertIntEquals(tc, 0, plane_width(0));
CuAssertIntEquals(tc, 0, plane_height(0));
CuAssertPtrEquals(tc, 0, get_homeplane());
CuAssertPtrEquals(tc, NULL, get_homeplane());
pl = create_new_plane(1, "Hell", 4, 8, 40, 80, 15);
r = test_create_region(4, 40, 0);
@ -28,7 +28,7 @@ static void test_plane(CuTest *tc) {
CuAssertIntEquals(tc, 8, pl->maxx);
CuAssertIntEquals(tc, 40, pl->miny);
CuAssertIntEquals(tc, 80, pl->maxy);
CuAssertPtrEquals(tc, 0, pl->attribs);
CuAssertPtrEquals(tc, NULL, pl->attribs);
CuAssertStrEquals(tc, "Hell", pl->name);
CuAssertPtrEquals(tc, pl, findplane(4, 40));
CuAssertPtrEquals(tc, pl, getplane(r));

4
src/kernel/region.test.c
View File

@ -23,14 +23,14 @@ void test_terraform(CuTest *tc) {
t_plain = test_create_terrain("plain", LAND_REGION);
t_ocean = test_create_terrain("ocean", SEA_REGION);
r = test_create_region(0, 0, t_ocean);
CuAssertPtrEquals(tc, 0, r->land);
CuAssertPtrEquals(tc, NULL, r->land);
terraform_region(r, t_plain);
CuAssertPtrNotNull(tc, r->land);
CuAssertPtrNotNull(tc, r->land->demands);
CuAssertPtrEquals(tc, itype, (void *)r->land->demands->type->itype);
CuAssertIntEquals(tc, 0, r->land->demands->type->price);
terraform_region(r, t_ocean);
CuAssertPtrEquals(tc, 0, r->land);
CuAssertPtrEquals(tc, NULL, r->land);
test_teardown();
}

24
src/kernel/save.test.c
View File

@ -86,7 +86,7 @@ static void test_readwrite_unit(CuTest * tc)
CuAssertPtrEquals(tc, f, u->faction);
CuAssertStrEquals(tc, "Hodor", u->_name);
CuAssertTrue(tc, irace == u_irace(u));
CuAssertPtrEquals(tc, 0, u->region);
CuAssertPtrEquals(tc, NULL, u->region);
mstream_done(&data.strm);
gamedata_done(&data);
@ -115,7 +115,7 @@ static void test_readwrite_faction(CuTest * tc)
f = read_faction(&data);
CuAssertPtrNotNull(tc, f);
CuAssertStrEquals(tc, "Hodor", f->name);
CuAssertPtrEquals(tc, 0, f->units);
CuAssertPtrEquals(tc, NULL, f->units);
factions = f;
mstream_done(&data.strm);
@ -179,7 +179,7 @@ static void test_readwrite_building(CuTest * tc)
b = read_building(&data);
CuAssertPtrNotNull(tc, b);
CuAssertStrEquals(tc, "Hodor", b->name);
CuAssertPtrEquals(tc, 0, b->region);
CuAssertPtrEquals(tc, NULL, b->region);
b->region = r;
r->buildings = b;
@ -212,7 +212,7 @@ static void test_readwrite_ship(CuTest * tc)
sh = read_ship(&data);
CuAssertPtrNotNull(tc, sh);
CuAssertStrEquals(tc, "Hodor", sh->name);
CuAssertPtrEquals(tc, 0, sh->region);
CuAssertPtrEquals(tc, NULL, sh->region);
sh->region = r;
r->ships = sh;
@ -233,7 +233,7 @@ static void test_readwrite_attrib(CuTest *tc) {
gamedata_init(&data, &store, RELEASE_VERSION);
write_attribs(data.store, a, NULL);
a_removeall(&a, NULL);
CuAssertPtrEquals(tc, 0, a);
CuAssertPtrEquals(tc, NULL, a);
data.strm.api->rewind(data.strm.handle);
read_attribs(&data, &a, NULL);
@ -262,7 +262,7 @@ static void test_readwrite_dead_faction_group(CuTest *tc) {
f = test_create_faction(NULL);
fno = f->no;
CuAssertPtrEquals(tc, f, factions);
CuAssertPtrEquals(tc, 0, f->next);
CuAssertPtrEquals(tc, NULL, f->next);
f2 = test_create_faction(NULL);
CuAssertPtrEquals(tc, f2, factions->next);
u = test_create_unit(f2, test_create_region(0, 0, NULL));
@ -281,14 +281,14 @@ static void test_readwrite_dead_faction_group(CuTest *tc) {
f = f2 = NULL;
data.strm.api->rewind(data.strm.handle);
read_game(&data);
CuAssertPtrEquals(tc, 0, findfaction(fno));
CuAssertPtrEquals(tc, NULL, findfaction(fno));
f2 = factions;
CuAssertPtrNotNull(tc, f2);
u = f2->units;
CuAssertPtrNotNull(tc, u);
g = get_group(u);
CuAssertPtrNotNull(tc, g);
CuAssertPtrEquals(tc, 0, g->allies);
CuAssertPtrEquals(tc, NULL, g->allies);
mstream_done(&data.strm);
gamedata_done(&data);
test_teardown();
@ -319,10 +319,10 @@ static void test_readwrite_dead_faction_regionowner(CuTest *tc) {
mstream_done(&data.strm);
gamedata_done(&data);
f = factions;
CuAssertPtrEquals(tc, 0, f);
CuAssertPtrEquals(tc, NULL, f);
r = regions;
CuAssertPtrNotNull(tc, r);
CuAssertPtrEquals(tc, 0, region_get_owner(r));
CuAssertPtrEquals(tc, NULL, region_get_owner(r));
test_teardown();
}
@ -359,7 +359,7 @@ static void test_readwrite_dead_faction_changefaction(CuTest *tc) {
CuAssertPtrNotNull(tc, r);
u = r->units;
CuAssertPtrNotNull(tc, u);
CuAssertPtrEquals(tc, 0, a_find(u->attribs, &at_eventhandler));
CuAssertPtrEquals(tc, NULL, a_find(u->attribs, &at_eventhandler));
test_teardown();
}
@ -396,7 +396,7 @@ static void test_readwrite_dead_faction_createunit(CuTest *tc) {
CuAssertPtrNotNull(tc, r);
u = r->units;
CuAssertPtrNotNull(tc, u);
CuAssertPtrEquals(tc, 0, a_find(u->attribs, &at_eventhandler));
CuAssertPtrEquals(tc, NULL, a_find(u->attribs, &at_eventhandler));
test_teardown();
}

10
src/kernel/ship.test.c
View File

@ -278,7 +278,7 @@ static void test_shipowner_goes_to_same_faction_after_leave(CuTest * tc)
leave_ship(u3);
CuAssertPtrEquals(tc, u2, ship_owner(sh));
leave_ship(u2);
CuAssertPtrEquals(tc, 0, ship_owner(sh));
CuAssertPtrEquals(tc, NULL, ship_owner(sh));
test_teardown();
}
@ -311,7 +311,7 @@ static void test_shipowner_resets_when_empty(CuTest * tc)
u_set_ship(u, sh);
CuAssertPtrEquals(tc, u, ship_owner(sh));
u->number = 0;
CuAssertPtrEquals(tc, 0, ship_owner(sh));
CuAssertPtrEquals(tc, NULL, ship_owner(sh));
u->number = 1;
CuAssertPtrEquals(tc, u, ship_owner(sh));
test_teardown();
@ -353,7 +353,7 @@ void test_shipowner_goes_to_empty_unit_after_leave(CuTest * tc)
leave_ship(u1);
CuAssertPtrEquals(tc, u3, ship_owner(sh));
leave_ship(u3);
CuAssertPtrEquals(tc, 0, ship_owner(sh));
CuAssertPtrEquals(tc, NULL, ship_owner(sh));
u2->number = 1;
CuAssertPtrEquals(tc, u2, ship_owner(sh));
test_teardown();
@ -365,8 +365,8 @@ static void test_stype_defaults(CuTest *tc) {
stype = st_get_or_create("hodor");
CuAssertPtrNotNull(tc, stype);
CuAssertStrEquals(tc, "hodor", stype->_name);
CuAssertPtrEquals(tc, 0, stype->construction);
CuAssertPtrEquals(tc, 0, stype->coasts);
CuAssertPtrEquals(tc, NULL, stype->construction);
CuAssertPtrEquals(tc, NULL, stype->coasts);
CuAssertDblEquals(tc, 0.0, stype->damage, 0.0);
CuAssertDblEquals(tc, 1.0, stype->storm, 0.0);
CuAssertDblEquals(tc, 1.0, stype->tac_bonus, 0.01);

10
src/kernel/spell.test.c
View File

@ -17,8 +17,8 @@ static void test_create_a_spell(CuTest * tc)
spell * sp;
test_setup();
CuAssertPtrEquals(tc, 0, spells);
CuAssertPtrEquals(tc, 0, find_spell("testspell"));
CuAssertPtrEquals(tc, NULL, spells);
CuAssertPtrEquals(tc, NULL, find_spell("testspell"));
sp = create_spell("testspell");
CuAssertPtrEquals(tc, sp, find_spell("testspell"));
@ -37,13 +37,13 @@ static void test_create_duplicate_spell(CuTest * tc)
test_log_stderr(0); /* suppress the "duplicate spell" error message */
log = test_log_start(LOG_CPERROR, &sl);
CuAssertPtrEquals(tc, 0, find_spell("testspell"));
CuAssertPtrEquals(tc, NULL, find_spell("testspell"));
sp = create_spell("testspell");
CuAssertPtrEquals(tc, 0, create_spell("testspell"));
CuAssertPtrEquals(tc, NULL, create_spell("testspell"));
CuAssertPtrNotNull(tc, sl);
CuAssertStrEquals(tc, "create_spell: duplicate name '%s'", sl->s);
CuAssertPtrEquals(tc, 0, sl->next);
CuAssertPtrEquals(tc, NULL, sl->next);
CuAssertPtrEquals(tc, sp, find_spell("testspell"));
test_log_stop(log, sl);
test_log_stderr(1); /* or teardown complains that stderr logging is off */

2
src/kernel/spellbook.test.c
View File

@ -25,7 +25,7 @@ void test_named_spellbooks(CuTest * tc)
sb = create_spellbook(0);
CuAssertPtrNotNull(tc, sb);
CuAssertPtrEquals(tc, 0, sb->name);
CuAssertPtrEquals(tc, NULL, sb->name);
spellbook_clear(sb);
free(sb);

40
src/kernel/unit.test.c
View File

@ -42,7 +42,7 @@ static void test_remove_empty_units(CuTest *tc) {
CuAssertPtrNotNull(tc, findunit(uid));
u->number = 0;
remove_empty_units();
CuAssertPtrEquals(tc, 0, findunit(uid));
CuAssertPtrEquals(tc, NULL, findunit(uid));
test_teardown();
}
@ -61,9 +61,9 @@ static void test_remove_empty_units_in_region(CuTest *tc) {
CuAssertPtrNotNull(tc, findunit(uid));
u->number = 0;
remove_empty_units_in_region(u->region);
CuAssertPtrEquals(tc, 0, findunit(uid));
CuAssertPtrEquals(tc, 0, u->nextF);
CuAssertPtrEquals(tc, 0, u->region);
CuAssertPtrEquals(tc, NULL, findunit(uid));
CuAssertPtrEquals(tc, NULL, u->nextF);
CuAssertPtrEquals(tc, NULL, u->region);
test_teardown();
}
@ -78,7 +78,7 @@ static void test_remove_units_without_faction(CuTest *tc) {
uid = u->no;
u_setfaction(u, 0);
remove_empty_units_in_region(u->region);
CuAssertPtrEquals(tc, 0, findunit(uid));
CuAssertPtrEquals(tc, NULL, findunit(uid));
CuAssertIntEquals(tc, 0, u->number);
test_teardown();
}
@ -94,7 +94,7 @@ static void test_remove_units_with_dead_faction(CuTest *tc) {
uid = u->no;
u->faction->_alive = false;
remove_empty_units_in_region(u->region);
CuAssertPtrEquals(tc, 0, findunit(uid));
CuAssertPtrEquals(tc, NULL, findunit(uid));
CuAssertIntEquals(tc, 0, u->number);
test_teardown();
}
@ -308,16 +308,16 @@ static void test_inside_building(CuTest *tc) {
b->size = 1;
scale_number(u, 1);
CuAssertPtrEquals(tc, 0, inside_building(u));
CuAssertPtrEquals(tc, NULL, inside_building(u));
u->building = b;
CuAssertPtrEquals(tc, b, inside_building(u));
scale_number(u, 2);
CuAssertPtrEquals(tc, 0, inside_building(u));
CuAssertPtrEquals(tc, NULL, inside_building(u));
b->size = 2;
CuAssertPtrEquals(tc, b, inside_building(u));
u = test_create_unit(u->faction, u->region);
u->building = b;
CuAssertPtrEquals(tc, 0, inside_building(u));
CuAssertPtrEquals(tc, NULL, inside_building(u));
b->size = 3;
CuAssertPtrEquals(tc, b, inside_building(u));
test_teardown();
@ -397,7 +397,7 @@ static void test_unit_description(CuTest *tc) {
rc = test_create_race("hodor");
u = test_create_unit(test_create_faction(rc), test_create_region(0, 0, NULL));
CuAssertPtrEquals(tc, 0, u->display);
CuAssertPtrEquals(tc, NULL, u->display);
CuAssertStrEquals(tc, 0, u_description(u, lang));
u->display = str_strdup("Hodor");
CuAssertStrEquals(tc, "Hodor", u_description(u, NULL));
@ -428,37 +428,37 @@ static void test_remove_unit(CuTest *tc) {
CuAssertPtrEquals(tc, u1, f->units);
CuAssertPtrEquals(tc, u2, u1->nextF);
CuAssertPtrEquals(tc, u1, u2->prevF);
CuAssertPtrEquals(tc, 0, u2->nextF);
CuAssertPtrEquals(tc, NULL, u2->nextF);
uno = u1->no;
region_setresource(r, rtype, 0);
i_change(&u1->items, rtype->itype, 100);
remove_unit(&r->units, u1);
CuAssertIntEquals(tc, 0, u1->number);
CuAssertPtrEquals(tc, 0, u1->region);
CuAssertPtrEquals(tc, NULL, u1->region);
/* money is given to a survivor: */
CuAssertPtrEquals(tc, 0, u1->items);
CuAssertPtrEquals(tc, NULL, u1->items);
CuAssertIntEquals(tc, 0, region_getresource(r, rtype));
CuAssertIntEquals(tc, 100, i_get(u2->items, rtype->itype));
/* unit is removed from f->units: */
CuAssertPtrEquals(tc, 0, u1->nextF);
CuAssertPtrEquals(tc, NULL, u1->nextF);
CuAssertPtrEquals(tc, u2, f->units);
CuAssertPtrEquals(tc, 0, u2->nextF);
CuAssertPtrEquals(tc, 0, u2->prevF);
CuAssertPtrEquals(tc, NULL, u2->nextF);
CuAssertPtrEquals(tc, NULL, u2->prevF);
/* unit is no longer in r->units: */
CuAssertPtrEquals(tc, u2, r->units);
CuAssertPtrEquals(tc, 0, u2->next);
CuAssertPtrEquals(tc, NULL, u2->next);
/* unit is in deleted_units: */
CuAssertPtrEquals(tc, 0, findunit(uno));
CuAssertPtrEquals(tc, NULL, findunit(uno));
CuAssertPtrEquals(tc, f, dfindhash(uno));
remove_unit(&r->units, u2);
/* no survivor, give money to peasants: */
CuAssertIntEquals(tc, 100, region_getresource(r, rtype));
/* there are now no more units: */
CuAssertPtrEquals(tc, 0, r->units);
CuAssertPtrEquals(tc, 0, f->units);
CuAssertPtrEquals(tc, NULL, r->units);
CuAssertPtrEquals(tc, NULL, f->units);
test_teardown();
}

62
src/laws.test.c
View File

@ -123,8 +123,8 @@ static void test_enter_building(CuTest * tc)
rc->flags = RCF_SWIM;
u->building = 0;
CuAssertIntEquals(tc, 0, enter_building(u, NULL, b->no, false));
CuAssertPtrEquals(tc, 0, u->building);
CuAssertPtrEquals(tc, 0, u->faction->msgs);
CuAssertPtrEquals(tc, NULL, u->building);
CuAssertPtrEquals(tc, NULL, u->faction->msgs);
CuAssertIntEquals(tc, 0, enter_building(u, NULL, b->no, true));
CuAssertPtrNotNull(tc, u->faction->msgs);
@ -164,8 +164,8 @@ static void test_enter_ship(CuTest * tc)
rc->flags = RCF_SWIM;
u->ship = 0;
CuAssertIntEquals(tc, 0, enter_ship(u, NULL, sh->no, false));
CuAssertPtrEquals(tc, 0, u->ship);
CuAssertPtrEquals(tc, 0, u->faction->msgs);
CuAssertPtrEquals(tc, NULL, u->ship);
CuAssertPtrEquals(tc, NULL, u->faction->msgs);
CuAssertIntEquals(tc, 0, enter_ship(u, NULL, sh->no, true));
CuAssertPtrNotNull(tc, u->faction->msgs);
@ -1040,8 +1040,8 @@ static void test_long_order_normal(CuTest *tc) {
CuAssertIntEquals(tc, 0, fval(u, UFL_MOVED));
CuAssertIntEquals(tc, 0, fval(u, UFL_LONGACTION));
CuAssertPtrNotNull(tc, u->orders);
CuAssertPtrEquals(tc, 0, u->faction->msgs);
CuAssertPtrEquals(tc, 0, u->old_orders);
CuAssertPtrEquals(tc, NULL, u->faction->msgs);
CuAssertPtrEquals(tc, NULL, u->old_orders);
test_teardown();
}
@ -1051,9 +1051,9 @@ static void test_long_order_none(CuTest *tc) {
test_setup();
u = test_create_unit(test_create_faction(NULL), test_create_region(0, 0, NULL));
update_long_order(u);
CuAssertPtrEquals(tc, 0, u->thisorder);
CuAssertPtrEquals(tc, 0, u->orders);
CuAssertPtrEquals(tc, 0, u->faction->msgs);
CuAssertPtrEquals(tc, NULL, u->thisorder);
CuAssertPtrEquals(tc, NULL, u->orders);
CuAssertPtrEquals(tc, NULL, u->faction->msgs);
test_teardown();
}
@ -1065,9 +1065,9 @@ static void test_long_order_cast(CuTest *tc) {
unit_addorder(u, create_order(K_CAST, u->faction->locale, NULL));
unit_addorder(u, create_order(K_CAST, u->faction->locale, NULL));
update_long_order(u);
CuAssertPtrEquals(tc, 0, u->thisorder);
CuAssertPtrEquals(tc, NULL, u->thisorder);
CuAssertPtrNotNull(tc, u->orders);
CuAssertPtrEquals(tc, 0, u->faction->msgs);
CuAssertPtrEquals(tc, NULL, u->faction->msgs);
test_teardown();
}
@ -1080,9 +1080,9 @@ static void test_long_order_buy_sell(CuTest *tc) {
unit_addorder(u, create_order(K_SELL, u->faction->locale, NULL));
unit_addorder(u, create_order(K_SELL, u->faction->locale, NULL));
update_long_order(u);
CuAssertPtrEquals(tc, 0, u->thisorder);
CuAssertPtrEquals(tc, NULL, u->thisorder);
CuAssertPtrNotNull(tc, u->orders);
CuAssertPtrEquals(tc, 0, u->faction->msgs);
CuAssertPtrEquals(tc, NULL, u->faction->msgs);
test_teardown();
}
@ -1108,7 +1108,7 @@ static void test_long_order_multi_buy(CuTest *tc) {
unit_addorder(u, create_order(K_BUY, u->faction->locale, 0));
unit_addorder(u, create_order(K_BUY, u->faction->locale, 0));
update_long_order(u);
CuAssertPtrEquals(tc, 0, u->thisorder);
CuAssertPtrEquals(tc, NULL, u->thisorder);
CuAssertPtrNotNull(tc, u->orders);
CuAssertPtrNotNull(tc, test_find_messagetype(u->faction->msgs, "error52"));
test_teardown();
@ -1123,9 +1123,9 @@ static void test_long_order_multi_sell(CuTest *tc) {
unit_addorder(u, create_order(K_BUY, u->faction->locale, 0));
unit_addorder(u, create_order(K_SELL, u->faction->locale, 0));
update_long_order(u);
CuAssertPtrEquals(tc, 0, u->thisorder);
CuAssertPtrEquals(tc, NULL, u->thisorder);
CuAssertPtrNotNull(tc, u->orders);
CuAssertPtrEquals(tc, 0, u->faction->msgs);
CuAssertPtrEquals(tc, NULL, u->faction->msgs);
test_teardown();
}
@ -1137,7 +1137,7 @@ static void test_long_order_buy_cast(CuTest *tc) {
unit_addorder(u, create_order(K_BUY, u->faction->locale, 0));
unit_addorder(u, create_order(K_CAST, u->faction->locale, 0));
update_long_order(u);
CuAssertPtrEquals(tc, 0, u->thisorder);
CuAssertPtrEquals(tc, NULL, u->thisorder);
CuAssertPtrNotNull(tc, u->orders);
CuAssertPtrNotNull(tc, test_find_messagetype(u->faction->msgs, "error52"));
test_teardown();
@ -1155,7 +1155,7 @@ static void test_long_order_hungry(CuTest *tc) {
update_long_order(u);
CuAssertIntEquals(tc, K_WORK, getkeyword(u->thisorder));
CuAssertPtrNotNull(tc, u->orders);
CuAssertPtrEquals(tc, 0, u->faction->msgs);
CuAssertPtrEquals(tc, NULL, u->faction->msgs);
test_teardown();
}
@ -1167,7 +1167,7 @@ static void test_ally_cmd_errors(CuTest *tc) {
test_setup();
u = test_create_unit(test_create_faction(NULL), test_create_region(0, 0, NULL));
fid = u->faction->no + 1;
CuAssertPtrEquals(tc, 0, findfaction(fid));
CuAssertPtrEquals(tc, NULL, findfaction(fid));
ord = create_order(K_ALLY, u->faction->locale, itoa36(fid));
ally_cmd(u, ord);
@ -1264,25 +1264,25 @@ static void test_ally_cmd(CuTest *tc) {
ord = create_order(K_ALLY, f->locale, "%s", itoa36(f->no));
ally_cmd(u, ord);
CuAssertPtrEquals(tc, 0, u->faction->msgs);
CuAssertPtrEquals(tc, NULL, u->faction->msgs);
CuAssertIntEquals(tc, HELP_ALL, alliedfaction(0, u->faction, f, HELP_ALL));
free_order(ord);
ord = create_order(K_ALLY, f->locale, "%s %s", itoa36(f->no), LOC(f->locale, parameters[P_NOT]));
ally_cmd(u, ord);
CuAssertPtrEquals(tc, 0, u->faction->msgs);
CuAssertPtrEquals(tc, NULL, u->faction->msgs);
CuAssertIntEquals(tc, 0, alliedfaction(0, u->faction, f, HELP_ALL));
free_order(ord);
ord = create_order(K_ALLY, f->locale, "%s %s", itoa36(f->no), LOC(f->locale, parameters[P_GUARD]));
ally_cmd(u, ord);
CuAssertPtrEquals(tc, 0, u->faction->msgs);
CuAssertPtrEquals(tc, NULL, u->faction->msgs);
CuAssertIntEquals(tc, HELP_GUARD, alliedfaction(0, u->faction, f, HELP_ALL));
free_order(ord);
ord = create_order(K_ALLY, f->locale, "%s %s %s", itoa36(f->no), LOC(f->locale, parameters[P_GUARD]), LOC(f->locale, parameters[P_NOT]));
ally_cmd(u, ord);
CuAssertPtrEquals(tc, 0, u->faction->msgs);
CuAssertPtrEquals(tc, NULL, u->faction->msgs);
CuAssertIntEquals(tc, 0, alliedfaction(0, u->faction, f, HELP_ALL));
free_order(ord);
@ -1374,7 +1374,7 @@ static void test_mail_unit_no_msg(CuTest *tc) {
f = u->faction;
ord = create_order(K_MAIL, f->locale, "%s %s", LOC(f->locale, parameters[P_UNIT]), itoa36(u->no));
mail_cmd(u, ord);
CuAssertPtrEquals(tc, 0, test_find_messagetype(f->msgs, "unitmessage"));
CuAssertPtrEquals(tc, NULL, test_find_messagetype(f->msgs, "unitmessage"));
CuAssertPtrNotNull(tc, test_find_messagetype(f->msgs, "error30"));
free_order(ord);
test_teardown();
@ -1389,7 +1389,7 @@ static void test_mail_faction_no_msg(CuTest *tc) {
f = u->faction;
ord = create_order(K_MAIL, f->locale, "%s %s", LOC(f->locale, parameters[P_FACTION]), itoa36(f->no));
mail_cmd(u, ord);
CuAssertPtrEquals(tc, 0, test_find_messagetype(f->msgs, "regionmessage"));
CuAssertPtrEquals(tc, NULL, test_find_messagetype(f->msgs, "regionmessage"));
CuAssertPtrNotNull(tc, test_find_messagetype(f->msgs, "error30"));
free_order(ord);
test_teardown();
@ -1404,7 +1404,7 @@ static void test_mail_faction_no_target(CuTest *tc) {
f = u->faction;
ord = create_order(K_MAIL, f->locale, "%s %s", LOC(f->locale, parameters[P_FACTION]), itoa36(f->no+1));
mail_cmd(u, ord);
CuAssertPtrEquals(tc, 0, test_find_messagetype(f->msgs, "regionmessage"));
CuAssertPtrEquals(tc, NULL, test_find_messagetype(f->msgs, "regionmessage"));
CuAssertPtrNotNull(tc, test_find_messagetype(f->msgs, "error66"));
free_order(ord);
test_teardown();
@ -1419,7 +1419,7 @@ static void test_mail_region_no_msg(CuTest *tc) {
f = u->faction;
ord = create_order(K_MAIL, f->locale, LOC(f->locale, parameters[P_REGION]));
mail_cmd(u, ord);
CuAssertPtrEquals(tc, 0, test_find_messagetype(u->region->msgs, "mail_result"));
CuAssertPtrEquals(tc, NULL, test_find_messagetype(u->region->msgs, "mail_result"));
CuAssertPtrNotNull(tc, test_find_messagetype(f->msgs, "error30"));
free_order(ord);
test_teardown();
@ -1457,14 +1457,14 @@ static void test_show_without_item(CuTest *tc)
locale_setstring(loc, "iteminfo::testitem", "testdescription");
reshow_cmd(u, ord);
CuAssertPtrEquals(tc, 0, test_find_messagetype(f->msgs, "error21"));
CuAssertPtrEquals(tc, NULL, test_find_messagetype(f->msgs, "error21"));
CuAssertPtrNotNull(tc, test_find_messagetype(f->msgs, "error36"));
test_clear_messages(f);
i_add(&(u->items), i_new(itype, 1));
reshow_cmd(u, ord);
CuAssertPtrEquals(tc, 0, test_find_messagetype(f->msgs, "error21"));
CuAssertPtrEquals(tc, 0, test_find_messagetype(f->msgs, "error36"));
CuAssertPtrEquals(tc, NULL, test_find_messagetype(f->msgs, "error21"));
CuAssertPtrEquals(tc, NULL, test_find_messagetype(f->msgs, "error36"));
test_clear_messages(f);
free_order(ord);
@ -1609,7 +1609,7 @@ static void test_demon_hunger(CuTest * tc)
get_food(r);
CuAssertIntEquals(tc, 20, i_get(u->items, rtype->itype));
CuAssertPtrEquals(tc, 0, test_find_messagetype(f->msgs, "malnourish"));
CuAssertPtrEquals(tc, NULL, test_find_messagetype(f->msgs, "malnourish"));
config_set("hunger.demon.peasant_tolerance", "0");

14
src/magic.test.c
View File

@ -45,7 +45,7 @@ void test_updatespells(CuTest * tc)
CuAssertPtrNotNull(tc, book);
spellbook_add(book, sp, 1);
CuAssertPtrEquals(tc, 0, f->spellbook);
CuAssertPtrEquals(tc, NULL, f->spellbook);
pick_random_spells(f, 1, book, 1);
CuAssertPtrNotNull(tc, f->spellbook);
CuAssertIntEquals(tc, 1, selist_length(f->spellbook->spells));
@ -191,7 +191,7 @@ void test_getspell_unit(CuTest * tc)
sp = create_spell("testspell");
locale_setstring(lang, mkname("spell", sp->sname), "Herp-a-derp");
CuAssertPtrEquals(tc, 0, unit_getspell(u, "Herp-a-derp", lang));
CuAssertPtrEquals(tc, NULL, unit_getspell(u, "Herp-a-derp", lang));
unit_add_spell(u, 0, sp, 1);
CuAssertPtrNotNull(tc, unit_getspell(u, "Herp-a-derp", lang));
@ -220,7 +220,7 @@ void test_getspell_faction(CuTest * tc)
sp = create_spell("testspell");
locale_setstring(lang, mkname("spell", sp->sname), "Herp-a-derp");
CuAssertPtrEquals(tc, 0, unit_getspell(u, "Herp-a-derp", lang));
CuAssertPtrEquals(tc, NULL, unit_getspell(u, "Herp-a-derp", lang));
f->spellbook = create_spellbook(0);
spellbook_add(f->spellbook, sp, 1);
@ -250,7 +250,7 @@ void test_getspell_school(CuTest * tc)
sp = create_spell("testspell");
locale_setstring(lang, mkname("spell", sp->sname), "Herp-a-derp");
CuAssertPtrEquals(tc, 0, unit_getspell(u, "Herp-a-derp", lang));
CuAssertPtrEquals(tc, NULL, unit_getspell(u, "Herp-a-derp", lang));
book = faction_get_spellbook(f);
CuAssertPtrNotNull(tc, book);
@ -287,7 +287,7 @@ void test_set_pre_combatspell(CuTest * tc)
CuAssertIntEquals(tc, 1, get_combatspelllevel(u, index));
unset_combatspell(u, sp);
CuAssertIntEquals(tc, 0, get_combatspelllevel(u, index));
CuAssertPtrEquals(tc, 0, (spell *)get_combatspell(u, index));
CuAssertPtrEquals(tc, NULL, (spell *)get_combatspell(u, index));
test_teardown();
}
@ -319,7 +319,7 @@ void test_set_main_combatspell(CuTest * tc)
CuAssertIntEquals(tc, 1, get_combatspelllevel(u, index));
unset_combatspell(u, sp);
CuAssertIntEquals(tc, 0, get_combatspelllevel(u, index));
CuAssertPtrEquals(tc, 0, (spell *)get_combatspell(u, index));
CuAssertPtrEquals(tc, NULL, (spell *)get_combatspell(u, index));
test_teardown();
}
@ -351,7 +351,7 @@ void test_set_post_combatspell(CuTest * tc)
CuAssertIntEquals(tc, 1, get_combatspelllevel(u, index));
unset_combatspell(u, sp);
CuAssertIntEquals(tc, 0, get_combatspelllevel(u, index));
CuAssertPtrEquals(tc, 0, (spell *)get_combatspell(u, index));
CuAssertPtrEquals(tc, NULL, (spell *)get_combatspell(u, index));
test_teardown();
}

20
src/move.test.c
View File

@ -225,16 +225,16 @@ static void test_ship_trails(CuTest *tc) {
move_ship(sh, r1, r3, NULL);
CuAssertPtrEquals(tc, r3, sh->region);
CuAssertPtrEquals(tc, sh, r3->ships);
CuAssertPtrEquals(tc, 0, r1->ships);
CuAssertPtrEquals(tc, 0, a_find(r1->attribs, &at_shiptrail));
CuAssertPtrEquals(tc, 0, a_find(r3->attribs, &at_shiptrail));
CuAssertPtrEquals(tc, NULL, r1->ships);
CuAssertPtrEquals(tc, NULL, a_find(r1->attribs, &at_shiptrail));
CuAssertPtrEquals(tc, NULL, a_find(r3->attribs, &at_shiptrail));
add_regionlist(&route, r3);
add_regionlist(&route, r2);
move_ship(sh, r3, r1, route);
CuAssertPtrEquals(tc, r1, sh->region);
CuAssertPtrEquals(tc, sh, r1->ships);
CuAssertPtrEquals(tc, 0, r3->ships);
CuAssertPtrEquals(tc, 0, a_find(r1->attribs, &at_shiptrail));
CuAssertPtrEquals(tc, NULL, r3->ships);
CuAssertPtrEquals(tc, NULL, a_find(r1->attribs, &at_shiptrail));
CuAssertPtrNotNull(tc, a_find(r2->attribs, &at_shiptrail));
CuAssertPtrNotNull(tc, a_find(r3->attribs, &at_shiptrail));
free_regionlist(route);
@ -258,7 +258,7 @@ static void test_age_trails(CuTest *tc) {
a_age(&r1->attribs, r1);
CuAssertPtrNotNull(tc, r1->attribs);
a_age(&r1->attribs, r1);
CuAssertPtrEquals(tc, 0, r1->attribs);
CuAssertPtrEquals(tc, NULL, r1->attribs);
free_regionlist(route);
test_teardown();
}
@ -323,7 +323,7 @@ static void test_ship_empty(CuTest *tc) {
movement();
CuAssertPtrEquals(tc, fix.sh->region, findregion(0, 0));
CuAssertIntEquals(tc, 2, ship_damage_percent(fix.sh));
CuAssertPtrEquals(tc, 0, test_find_messagetype(fix.f->msgs, "ship_drift"));
CuAssertPtrEquals(tc, NULL, test_find_messagetype(fix.f->msgs, "ship_drift"));
test_teardown();
}
@ -340,7 +340,7 @@ static void test_no_drift_damage(CuTest *tc) {
movement();
CuAssertPtrEquals(tc, fix.sh->region, findregion(0, 0));
CuAssertIntEquals(tc, 0, ship_damage_percent(fix.sh));
CuAssertPtrEquals(tc, 0, test_find_messagetype(fix.f->msgs, "ship_drift"));
CuAssertPtrEquals(tc, NULL, test_find_messagetype(fix.f->msgs, "ship_drift"));
test_teardown();
}
@ -386,7 +386,7 @@ static void test_ship_no_real_overload(CuTest *tc) {
movement();
CuAssertPtrEquals(tc, fix.u->region, findregion(0, 0));
CuAssertIntEquals(tc, 82, ship_damage_percent(fix.sh));
CuAssertPtrEquals(tc, 0, test_find_messagetype(fix.f->msgs, "massive_overload"));
CuAssertPtrEquals(tc, NULL, test_find_messagetype(fix.f->msgs, "massive_overload"));
test_teardown();
}
@ -431,7 +431,7 @@ static void test_ship_ridiculous_overload_bad(CuTest *tc) {
movement();
CuAssertTrue(tc, ship_damage_percent(fix.sh) > 99);
CuAssertPtrNotNull(tc, test_find_messagetype(fix.f->msgs, "massive_overload"));
CuAssertPtrEquals(tc, 0, fix.sh->region);
CuAssertPtrEquals(tc, NULL, fix.sh->region);
CuAssertPtrNotNull(tc, test_find_messagetype(fix.f->msgs, "shipsink"));
test_teardown();
}

6
src/piracy.test.c
View File

@ -106,7 +106,7 @@ static void test_piracy_cmd(CuTest * tc) {
u->thisorder = create_order(K_PIRACY, f->locale, "%s", itoa36(u2->faction->no));
piracy_cmd(u);
CuAssertPtrEquals(tc, 0, u->thisorder);
CuAssertPtrEquals(tc, NULL, u->thisorder);
CuAssertTrue(tc, u->region != r);
CuAssertPtrEquals(tc, u2->region, u->region);
CuAssertPtrEquals(tc, u2->region, u->ship->region);
@ -211,7 +211,7 @@ static void test_piracy_cmd_land_to_land(CuTest * tc) {
u->thisorder = create_order(K_PIRACY, f->locale, "%s", itoa36(target));
piracy_cmd(u);
CuAssertPtrEquals(tc, 0, u->thisorder);
CuAssertPtrEquals(tc, NULL, u->thisorder);
CuAssertPtrEquals(tc, r, u->region);
test_teardown();
@ -226,7 +226,7 @@ static void test_piracy_cmd_swimmer(CuTest * tc) {
r = pirate->region;
piracy_cmd(pirate);
CuAssertPtrEquals(tc, 0, pirate->thisorder);
CuAssertPtrEquals(tc, NULL, pirate->thisorder);
CuAssertTrue(tc, pirate->region != r);
CuAssertPtrEquals(tc, victim->region, pirate->region);
CuAssertPtrNotNullMsg(tc, "successful PIRACY message", test_find_messagetype(pirate->faction->msgs, "piratesawvictim"));

8
src/prefix.test.c
View File

@ -11,17 +11,17 @@
static void test_add_prefix(CuTest *tc) {
test_setup();
CuAssertPtrEquals(tc, 0, race_prefixes);
CuAssertPtrEquals(tc, NULL, race_prefixes);
CuAssertIntEquals(tc, 0, add_raceprefix("sea"));
CuAssertPtrNotNull(tc, race_prefixes);
CuAssertStrEquals(tc, "sea", race_prefixes[0]);
CuAssertPtrEquals(tc, 0, race_prefixes[1]);
CuAssertPtrEquals(tc, NULL, race_prefixes[1]);
CuAssertIntEquals(tc, 0, add_raceprefix("moon"));
CuAssertStrEquals(tc, "sea", race_prefixes[0]);
CuAssertStrEquals(tc, "moon", race_prefixes[1]);
CuAssertPtrEquals(tc, 0, race_prefixes[2]);
CuAssertPtrEquals(tc, NULL, race_prefixes[2]);
free_prefixes();
CuAssertPtrEquals(tc, 0, race_prefixes);
CuAssertPtrEquals(tc, NULL, race_prefixes);
test_teardown();
}

30
src/reports.test.c
View File

@ -76,7 +76,7 @@ static void test_reorder_units(CuTest * tc)
CuAssertPtrEquals(tc, u2, u3->next);
CuAssertPtrEquals(tc, u1, u2->next);
CuAssertPtrEquals(tc, u0, u1->next);
CuAssertPtrEquals(tc, 0, u0->next);
CuAssertPtrEquals(tc, NULL, u0->next);
test_teardown();
}
@ -130,19 +130,19 @@ static void test_sparagraph(CuTest *tc) {
split_paragraph(&sp, "Hello World", 0, 16, 0);
CuAssertPtrNotNull(tc, sp);
CuAssertStrEquals(tc, "Hello World", sp->s);
CuAssertPtrEquals(tc, 0, sp->next);
CuAssertPtrEquals(tc, NULL, sp->next);
freestrlist(sp);
split_paragraph(&sp, "Hello World", 4, 16, 0);
CuAssertPtrNotNull(tc, sp);
CuAssertStrEquals(tc, " Hello World", sp->s);
CuAssertPtrEquals(tc, 0, sp->next);
CuAssertPtrEquals(tc, NULL, sp->next);
freestrlist(sp);
split_paragraph(&sp, "Hello World", 4, 16, '*');
CuAssertPtrNotNull(tc, sp);
CuAssertStrEquals(tc, " * Hello World", sp->s);
CuAssertPtrEquals(tc, 0, sp->next);
CuAssertPtrEquals(tc, NULL, sp->next);
freestrlist(sp);
split_paragraph(&sp, "12345678 90 12345678", 0, 8, '*');
@ -152,7 +152,7 @@ static void test_sparagraph(CuTest *tc) {
CuAssertStrEquals(tc, "90", sp->next->s);
CuAssertPtrNotNull(tc, sp->next->next);
CuAssertStrEquals(tc, "12345678", sp->next->next->s);
CuAssertPtrEquals(tc, 0, sp->next->next->next);
CuAssertPtrEquals(tc, NULL, sp->next->next->next);
freestrlist(sp);
}
@ -326,7 +326,7 @@ static void test_arg_resources(CuTest *tc) {
CuAssertPtrNotNull(tc, res = res->next);
CuAssertPtrEquals(tc, itype->rtype, (void *)res->type);
CuAssertIntEquals(tc, 5, res->number);
CuAssertPtrEquals(tc, 0, res->next);
CuAssertPtrEquals(tc, NULL, res->next);
atype->release(v2);
test_teardown();
}
@ -340,7 +340,7 @@ static void test_newbie_password_message(CuTest *tc) {
f->flags = 0;
prepare_report(&ctx, f);
CuAssertIntEquals(tc, 0, f->flags&FFL_PWMSG);
CuAssertPtrEquals(tc, 0, test_find_messagetype(f->msgs, "changepasswd"));
CuAssertPtrEquals(tc, NULL, test_find_messagetype(f->msgs, "changepasswd"));
f->age=2;
prepare_report(&ctx, f);
CuAssertIntEquals(tc, FFL_PWMSG, f->flags&FFL_PWMSG);
@ -511,7 +511,7 @@ void test_prepare_lighthouse_capacity(CuTest *tc) {
prepare_report(&ctx, u2->faction);
CuAssertPtrEquals(tc, r1, ctx.first);
CuAssertPtrEquals(tc, 0, ctx.last);
CuAssertPtrEquals(tc, NULL, ctx.last);
CuAssertIntEquals(tc, seen_unit, r1->seen.mode);
CuAssertIntEquals(tc, seen_neighbour, r2->seen.mode);
finish_reports(&ctx);
@ -520,7 +520,7 @@ void test_prepare_lighthouse_capacity(CuTest *tc) {
config_set_int("rules.lighthouse.unit_capacity", 1);
prepare_report(&ctx, u2->faction);
CuAssertPtrEquals(tc, r1, ctx.first);
CuAssertPtrEquals(tc, 0, ctx.last);
CuAssertPtrEquals(tc, NULL, ctx.last);
CuAssertIntEquals(tc, seen_unit, r1->seen.mode);
CuAssertIntEquals(tc, seen_lighthouse, r2->seen.mode);
finish_reports(&ctx);
@ -619,15 +619,15 @@ static void test_prepare_report(CuTest *tc) {
r = test_create_region(0, 0, NULL);
prepare_report(&ctx, f);
CuAssertPtrEquals(tc, 0, ctx.first);
CuAssertPtrEquals(tc, 0, ctx.last);
CuAssertPtrEquals(tc, NULL, ctx.first);
CuAssertPtrEquals(tc, NULL, ctx.last);
CuAssertIntEquals(tc, seen_none, r->seen.mode);
finish_reports(&ctx);
test_create_unit(f, r);
prepare_report(&ctx, f);
CuAssertPtrEquals(tc, r, ctx.first);
CuAssertPtrEquals(tc, 0, ctx.last);
CuAssertPtrEquals(tc, NULL, ctx.last);
CuAssertIntEquals(tc, seen_unit, r->seen.mode);
finish_reports(&ctx);
CuAssertIntEquals(tc, seen_none, r->seen.mode);
@ -655,7 +655,7 @@ static void test_seen_neighbours(CuTest *tc) {
test_create_unit(f, r1);
prepare_report(&ctx, f);
CuAssertPtrEquals(tc, r1, ctx.first);
CuAssertPtrEquals(tc, 0, ctx.last);
CuAssertPtrEquals(tc, NULL, ctx.last);
CuAssertIntEquals(tc, seen_unit, r1->seen.mode);
CuAssertIntEquals(tc, seen_neighbour, r2->seen.mode);
finish_reports(&ctx);
@ -682,7 +682,7 @@ static void test_seen_travelthru(CuTest *tc) {
CuAssertPtrEquals(tc, r3, f->last);
prepare_report(&ctx, f);
CuAssertPtrEquals(tc, r1, ctx.first);
CuAssertPtrEquals(tc, 0, ctx.last);
CuAssertPtrEquals(tc, NULL, ctx.last);
CuAssertIntEquals(tc, seen_unit, r1->seen.mode);
CuAssertIntEquals(tc, seen_travel, r2->seen.mode);
CuAssertIntEquals(tc, seen_neighbour, r3->seen.mode);
@ -760,7 +760,7 @@ static void test_report_far_vision(CuTest *tc) {
report_context ctx;
prepare_report(&ctx, f);
CuAssertPtrEquals(tc, r1, ctx.first);
CuAssertPtrEquals(tc, 0, ctx.last);
CuAssertPtrEquals(tc, NULL, ctx.last);
CuAssertIntEquals(tc, seen_unit, r1->seen.mode);
CuAssertIntEquals(tc, seen_spell, r2->seen.mode);
finish_reports(&ctx);

2
src/spy.test.c
View File

@ -272,7 +272,7 @@ static void test_sabotage_other_success(CuTest *tc) {
assert(ord);
set_level(u2, SK_SPY, 1);
CuAssertIntEquals(tc, 0, sabotage_cmd(u2, ord));
CuAssertPtrEquals(tc, 0, r->ships);
CuAssertPtrEquals(tc, NULL, r->ships);
free_order(ord);
test_teardown();
}

6
src/tests.test.c
View File

@ -23,13 +23,13 @@ static void test_resources(CuTest *tc) {
CuAssertPtrNotNull(tc, rt_find("permaura"));
CuAssertPtrEquals(tc, rt_find("permaura"), (void *)get_resourcetype(R_PERMAURA));
CuAssertPtrEquals(tc, 0, rt_find("stone"));
CuAssertPtrEquals(tc, NULL, rt_find("stone"));
rtype = rt_get_or_create("stone");
CuAssertPtrEquals(tc, (void *)rtype, (void *)rt_find("stone"));
CuAssertPtrEquals(tc, (void *)rtype, (void *)get_resourcetype(R_STONE));
free_resources();
CuAssertPtrEquals(tc, 0, rt_find("stone"));
CuAssertPtrEquals(tc, 0, rt_find("peasant"));
CuAssertPtrEquals(tc, NULL, rt_find("stone"));
CuAssertPtrEquals(tc, NULL, rt_find("peasant"));
rtype = rt_get_or_create("stone");
CuAssertPtrEquals(tc, (void *)rtype, (void *)get_resourcetype(R_STONE));
test_teardown();