diff --git a/clibs b/clibs
index d86c85254..12139c7ce 160000
--- a/clibs
+++ b/clibs
@@ -1 +1 @@
-Subproject commit d86c8525489d7f11b7ba13e101bb59ecf160b871
+Subproject commit 12139c7ce25e6731393f863e248ab16aa0578a3a
diff --git a/src/alchemy.test.c b/src/alchemy.test.c
index 7510933fe..32e0c84a5 100644
--- a/src/alchemy.test.c
+++ b/src/alchemy.test.c
@@ -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();
diff --git a/src/automate.c b/src/automate.c
index 24c34e903..c2b07fbd0 100644
--- a/src/automate.c
+++ b/src/automate.c
@@ -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)));
             }
         }
     }
diff --git a/src/battle.test.c b/src/battle.test.c
index 53c47f0e5..92a26e692 100644
--- a/src/battle.test.c
+++ b/src/battle.test.c
@@ -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();
 }
diff --git a/src/economy.test.c b/src/economy.test.c
index 0b213ba7e..5425ca56f 100644
--- a/src/economy.test.c
+++ b/src/economy.test.c
@@ -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);
 
diff --git a/src/give.test.c b/src/give.test.c
index 06c0ecf96..806901c46 100644
--- a/src/give.test.c
+++ b/src/give.test.c
@@ -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();
 }
 
diff --git a/src/guard.test.c b/src/guard.test.c
index 6264aad21..1c4da2d1f 100644
--- a/src/guard.test.c
+++ b/src/guard.test.c
@@ -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();
diff --git a/src/json.test.c b/src/json.test.c
index 48a5e4be6..30d4e072e 100644
--- a/src/json.test.c
+++ b/src/json.test.c
@@ -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();
 }
diff --git a/src/kernel/alliance.test.c b/src/kernel/alliance.test.c
index 00fe1f4d9..284d57d27 100644
--- a/src/kernel/alliance.test.c
+++ b/src/kernel/alliance.test.c
@@ -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();
 }
 
diff --git a/src/kernel/ally.test.c b/src/kernel/ally.test.c
index 66542a298..99d220151 100644
--- a/src/kernel/ally.test.c
+++ b/src/kernel/ally.test.c
@@ -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);
 }
diff --git a/src/kernel/attrib.test.c b/src/kernel/attrib.test.c
index 918b768fd..de024c46d 100644
--- a/src/kernel/attrib.test.c
+++ b/src/kernel/attrib.test.c
@@ -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);
diff --git a/src/kernel/build.test.c b/src/kernel/build.test.c
index 2607b2dfb..ae3e47d0d 100644
--- a/src/kernel/build.test.c
+++ b/src/kernel/build.test.c
@@ -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);
diff --git a/src/kernel/command.test.c b/src/kernel/command.test.c
index d173474f2..4c7bbb362 100644
--- a/src/kernel/command.test.c
+++ b/src/kernel/command.test.c
@@ -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);
diff --git a/src/kernel/faction.test.c b/src/kernel/faction.test.c
index 9cd5d9de8..d2931c669 100644
--- a/src/kernel/faction.test.c
+++ b/src/kernel/faction.test.c
@@ -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();
 }
diff --git a/src/kernel/group.test.c b/src/kernel/group.test.c
index 1c6d6339e..877728780 100644
--- a/src/kernel/group.test.c
+++ b/src/kernel/group.test.c
@@ -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));
diff --git a/src/kernel/item.test.c b/src/kernel/item.test.c
index f04a22572..f820f8592 100644
--- a/src/kernel/item.test.c
+++ b/src/kernel/item.test.c
@@ -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();
 }
 
diff --git a/src/kernel/messages.test.c b/src/kernel/messages.test.c
index 3c9c684c6..e852bbc61 100644
--- a/src/kernel/messages.test.c
+++ b/src/kernel/messages.test.c
@@ -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);
diff --git a/src/kernel/order.test.c b/src/kernel/order.test.c
index d1dd6a371..14cdeb157 100644
--- a/src/kernel/order.test.c
+++ b/src/kernel/order.test.c
@@ -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);
diff --git a/src/kernel/plane.test.c b/src/kernel/plane.test.c
index 8338cc31f..6eb2ff631 100644
--- a/src/kernel/plane.test.c
+++ b/src/kernel/plane.test.c
@@ -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));
diff --git a/src/kernel/region.test.c b/src/kernel/region.test.c
index d54049b8e..4078b7cbd 100644
--- a/src/kernel/region.test.c
+++ b/src/kernel/region.test.c
@@ -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();
 }
 
diff --git a/src/kernel/save.test.c b/src/kernel/save.test.c
index 8e738863f..4844d1189 100644
--- a/src/kernel/save.test.c
+++ b/src/kernel/save.test.c
@@ -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();
 }
 
diff --git a/src/kernel/ship.test.c b/src/kernel/ship.test.c
index c50fdfa8d..180b558a2 100644
--- a/src/kernel/ship.test.c
+++ b/src/kernel/ship.test.c
@@ -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);
diff --git a/src/kernel/spell.test.c b/src/kernel/spell.test.c
index 622780e20..d7dfbad7e 100644
--- a/src/kernel/spell.test.c
+++ b/src/kernel/spell.test.c
@@ -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 */
diff --git a/src/kernel/spellbook.test.c b/src/kernel/spellbook.test.c
index 22ea7c491..d83409797 100644
--- a/src/kernel/spellbook.test.c
+++ b/src/kernel/spellbook.test.c
@@ -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);
 
diff --git a/src/kernel/unit.test.c b/src/kernel/unit.test.c
index 29596f866..085e0177a 100644
--- a/src/kernel/unit.test.c
+++ b/src/kernel/unit.test.c
@@ -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();
 }
 
diff --git a/src/laws.test.c b/src/laws.test.c
index e7951a7ce..fb8929996 100644
--- a/src/laws.test.c
+++ b/src/laws.test.c
@@ -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");
 
diff --git a/src/magic.test.c b/src/magic.test.c
index 1b64cdf53..9ca9c013e 100644
--- a/src/magic.test.c
+++ b/src/magic.test.c
@@ -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();
 }
 
diff --git a/src/move.test.c b/src/move.test.c
index e782bb748..a4a65fead 100644
--- a/src/move.test.c
+++ b/src/move.test.c
@@ -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();
 }
diff --git a/src/piracy.test.c b/src/piracy.test.c
index 096e267b7..7aa57bc2d 100644
--- a/src/piracy.test.c
+++ b/src/piracy.test.c
@@ -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"));
diff --git a/src/prefix.test.c b/src/prefix.test.c
index f131813d7..e95f0c281 100644
--- a/src/prefix.test.c
+++ b/src/prefix.test.c
@@ -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();
 }
 
diff --git a/src/reports.test.c b/src/reports.test.c
index 0f5ca6b1f..d402b2b6a 100644
--- a/src/reports.test.c
+++ b/src/reports.test.c
@@ -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);
diff --git a/src/spy.test.c b/src/spy.test.c
index d1f616fab..e5a7ec628 100644
--- a/src/spy.test.c
+++ b/src/spy.test.c
@@ -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();
 }
diff --git a/src/tests.test.c b/src/tests.test.c
index 067772262..885d834e8 100644
--- a/src/tests.test.c
+++ b/src/tests.test.c
@@ -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();