Mercurial > hg > ucx / changeset

     1.1 --- a/tests/test_list.cpp	Mon Jan 01 16:42:37 2024 +0100
     1.2 +++ b/tests/test_list.cpp	Mon Jan 01 16:43:18 2024 +0100
     1.3 @@ -39,8 +39,8 @@
     1.4  #include <algorithm>
     1.5  
     1.6  struct node {
     1.7 -    node *next = nullptr;
     1.8 -    node *prev = nullptr;
     1.9 +    node *next = NULL;
    1.10 +    node *prev = NULL;
    1.11      int data = 0;
    1.12  };
    1.13  
    1.14 @@ -49,11 +49,11 @@
    1.15  const ptrdiff_t loc_data = offsetof(struct node, data);
    1.16  
    1.17  struct node_test_data {
    1.18 -    node *begin = nullptr;
    1.19 +    node *begin = NULL;
    1.20  
    1.21      explicit node_test_data(node *begin) : begin(begin) {
    1.22          auto n = begin;
    1.23 -        while (n != nullptr) {
    1.24 +        while (n != NULL) {
    1.25              nodes.push_back(n);
    1.26              n = n->next;
    1.27          }
    1.28 @@ -72,7 +72,7 @@
    1.29  };
    1.30  
    1.31  static node_test_data create_nodes_test_data(size_t len) {
    1.32 -    if (len == 0) return node_test_data{nullptr};
    1.33 +    if (len == 0) return node_test_data{NULL};
    1.34      auto begin = new node;
    1.35      auto prev = begin;
    1.36      for (size_t i = 1; i < len; i++) {
    1.37 @@ -88,7 +88,7 @@
    1.38          InputIter begin,
    1.39          InputIter end
    1.40  ) {
    1.41 -    if (begin == end) return node_test_data{nullptr};
    1.42 +    if (begin == end) return node_test_data{NULL};
    1.43      node *first = new node;
    1.44      first->data = *begin;
    1.45      node *prev = first;
    1.46 @@ -119,26 +119,26 @@
    1.47      node a, b, c;
    1.48  
    1.49      cx_linked_list_link(&a, &b, loc_prev, loc_next);
    1.50 -    EXPECT_EQ(a.prev, nullptr);
    1.51 -    EXPECT_EQ(a.next, &b);
    1.52 -    EXPECT_EQ(b.prev, &a);
    1.53 -    EXPECT_EQ(b.next, nullptr);
    1.54 +    CX_TEST_ASSERT(a.prev == NULL);
    1.55 +    CX_TEST_ASSERT(a.next == &b);
    1.56 +    CX_TEST_ASSERT(b.prev == &a);
    1.57 +    CX_TEST_ASSERT(b.next == NULL);
    1.58  
    1.59      cx_linked_list_unlink(&a, &b, loc_prev, loc_next);
    1.60 -    EXPECT_EQ(a.prev, nullptr);
    1.61 -    EXPECT_EQ(a.next, nullptr);
    1.62 -    EXPECT_EQ(b.prev, nullptr);
    1.63 -    EXPECT_EQ(b.next, nullptr);
    1.64 +    CX_TEST_ASSERT(a.prev == NULL);
    1.65 +    CX_TEST_ASSERT(a.next == NULL);
    1.66 +    CX_TEST_ASSERT(b.prev == NULL);
    1.67 +    CX_TEST_ASSERT(b.next == NULL);
    1.68  
    1.69      cx_linked_list_link(&b, &c, loc_prev, loc_next);
    1.70      cx_linked_list_link(&a, &b, loc_prev, loc_next);
    1.71      cx_linked_list_unlink(&b, &c, loc_prev, loc_next);
    1.72 -    EXPECT_EQ(a.prev, nullptr);
    1.73 -    EXPECT_EQ(a.next, &b);
    1.74 -    EXPECT_EQ(b.prev, &a);
    1.75 -    EXPECT_EQ(b.next, nullptr);
    1.76 -    EXPECT_EQ(c.prev, nullptr);
    1.77 -    EXPECT_EQ(c.next, nullptr);
    1.78 +    CX_TEST_ASSERT(a.prev == NULL);
    1.79 +    CX_TEST_ASSERT(a.next == &b);
    1.80 +    CX_TEST_ASSERT(b.prev == &a);
    1.81 +    CX_TEST_ASSERT(b.next == NULL);
    1.82 +    CX_TEST_ASSERT(c.prev == NULL);
    1.83 +    CX_TEST_ASSERT(c.next == NULL);
    1.84  }
    1.85  
    1.86  TEST(LinkedList_LowLevel, cx_linked_list_at) {
    1.87 @@ -151,13 +151,13 @@
    1.88      EXPECT_EQ(cx_linked_list_at(&a, 0, loc_next, 1), &b);
    1.89      EXPECT_EQ(cx_linked_list_at(&a, 0, loc_next, 2), &c);
    1.90      EXPECT_EQ(cx_linked_list_at(&a, 0, loc_next, 3), &d);
    1.91 -    EXPECT_EQ(cx_linked_list_at(&a, 0, loc_next, 4), nullptr);
    1.92 +    EXPECT_EQ(cx_linked_list_at(&a, 0, loc_next, 4), NULL);
    1.93  
    1.94      EXPECT_EQ(cx_linked_list_at(&b, 1, loc_prev, 0), &a);
    1.95      EXPECT_EQ(cx_linked_list_at(&b, 1, loc_next, 1), &b);
    1.96      EXPECT_EQ(cx_linked_list_at(&b, 1, loc_next, 2), &c);
    1.97      EXPECT_EQ(cx_linked_list_at(&b, 1, loc_next, 3), &d);
    1.98 -    EXPECT_EQ(cx_linked_list_at(&b, 1, loc_next, 4), nullptr);
    1.99 +    EXPECT_EQ(cx_linked_list_at(&b, 1, loc_next, 4), NULL);
   1.100  
   1.101      EXPECT_EQ(cx_linked_list_at(&d, 3, loc_prev, 0), &a);
   1.102      EXPECT_EQ(cx_linked_list_at(&d, 3, loc_prev, 1), &b);
   1.103 @@ -199,68 +199,68 @@
   1.104      // test with begin, end / prev, next
   1.105      {
   1.106          node nodes[4];
   1.107 -        void *begin = nullptr, *end = nullptr;
   1.108 +        void *begin = NULL, *end = NULL;
   1.109  
   1.110          cx_linked_list_add(&begin, &end, loc_prev, loc_next, &nodes[0]);
   1.111 -        EXPECT_EQ(begin, &nodes[0]);
   1.112 -        EXPECT_EQ(end, &nodes[0]);
   1.113 -        EXPECT_EQ(nodes[0].prev, nullptr);
   1.114 -        EXPECT_EQ(nodes[0].next, nullptr);
   1.115 +        CX_TEST_ASSERT(begin == &nodes[0]);
   1.116 +        CX_TEST_ASSERT(end == &nodes[0]);
   1.117 +        CX_TEST_ASSERT(nodes[0].prev == NULL);
   1.118 +        CX_TEST_ASSERT(nodes[0].next == NULL);
   1.119  
   1.120          cx_linked_list_add(&begin, &end, loc_prev, loc_next, &nodes[1]);
   1.121 -        EXPECT_EQ(begin, &nodes[0]);
   1.122 -        EXPECT_EQ(end, &nodes[1]);
   1.123 -        EXPECT_EQ(nodes[0].next, &nodes[1]);
   1.124 -        EXPECT_EQ(nodes[1].prev, &nodes[0]);
   1.125 +        CX_TEST_ASSERT(begin == &nodes[0]);
   1.126 +        CX_TEST_ASSERT(end == &nodes[1]);
   1.127 +        CX_TEST_ASSERT(nodes[0].next == &nodes[1]);
   1.128 +        CX_TEST_ASSERT(nodes[1].prev == &nodes[0]);
   1.129      }
   1.130  
   1.131      // test with begin only / prev, next
   1.132      {
   1.133          node nodes[4];
   1.134 -        void *begin = nullptr;
   1.135 +        void *begin = NULL;
   1.136  
   1.137 -        cx_linked_list_add(&begin, nullptr, loc_prev, loc_next, &nodes[0]);
   1.138 -        EXPECT_EQ(begin, &nodes[0]);
   1.139 -        cx_linked_list_add(&begin, nullptr, loc_prev, loc_next, &nodes[1]);
   1.140 -        EXPECT_EQ(begin, &nodes[0]);
   1.141 -        EXPECT_EQ(nodes[0].next, &nodes[1]);
   1.142 -        EXPECT_EQ(nodes[1].prev, &nodes[0]);
   1.143 +        cx_linked_list_add(&begin, NULL, loc_prev, loc_next, &nodes[0]);
   1.144 +        CX_TEST_ASSERT(begin == &nodes[0]);
   1.145 +        cx_linked_list_add(&begin, NULL, loc_prev, loc_next, &nodes[1]);
   1.146 +        CX_TEST_ASSERT(begin == &nodes[0]);
   1.147 +        CX_TEST_ASSERT(nodes[0].next == &nodes[1]);
   1.148 +        CX_TEST_ASSERT(nodes[1].prev == &nodes[0]);
   1.149  
   1.150 -        cx_linked_list_add(&begin, nullptr, loc_prev, loc_next, &nodes[2]);
   1.151 -        EXPECT_EQ(nodes[1].next, &nodes[2]);
   1.152 -        EXPECT_EQ(nodes[2].prev, &nodes[1]);
   1.153 +        cx_linked_list_add(&begin, NULL, loc_prev, loc_next, &nodes[2]);
   1.154 +        CX_TEST_ASSERT(nodes[1].next == &nodes[2]);
   1.155 +        CX_TEST_ASSERT(nodes[2].prev == &nodes[1]);
   1.156      }
   1.157  
   1.158      // test with end only / prev, next
   1.159      {
   1.160          node nodes[4];
   1.161 -        void *end = nullptr;
   1.162 +        void *end = NULL;
   1.163  
   1.164 -        cx_linked_list_add(nullptr, &end, loc_prev, loc_next, &nodes[0]);
   1.165 -        EXPECT_EQ(end, &nodes[0]);
   1.166 -        cx_linked_list_add(nullptr, &end, loc_prev, loc_next, &nodes[1]);
   1.167 -        EXPECT_EQ(end, &nodes[1]);
   1.168 -        EXPECT_EQ(nodes[0].next, &nodes[1]);
   1.169 -        EXPECT_EQ(nodes[1].prev, &nodes[0]);
   1.170 +        cx_linked_list_add(NULL, &end, loc_prev, loc_next, &nodes[0]);
   1.171 +        CX_TEST_ASSERT(end == &nodes[0]);
   1.172 +        cx_linked_list_add(NULL, &end, loc_prev, loc_next, &nodes[1]);
   1.173 +        CX_TEST_ASSERT(end == &nodes[1]);
   1.174 +        CX_TEST_ASSERT(nodes[0].next == &nodes[1]);
   1.175 +        CX_TEST_ASSERT(nodes[1].prev == &nodes[0]);
   1.176  
   1.177 -        cx_linked_list_add(nullptr, &end, loc_prev, loc_next, &nodes[2]);
   1.178 -        EXPECT_EQ(end, &nodes[2]);
   1.179 -        EXPECT_EQ(nodes[1].next, &nodes[2]);
   1.180 -        EXPECT_EQ(nodes[2].prev, &nodes[1]);
   1.181 +        cx_linked_list_add(NULL, &end, loc_prev, loc_next, &nodes[2]);
   1.182 +        CX_TEST_ASSERT(end == &nodes[2]);
   1.183 +        CX_TEST_ASSERT(nodes[1].next == &nodes[2]);
   1.184 +        CX_TEST_ASSERT(nodes[2].prev == &nodes[1]);
   1.185      }
   1.186  
   1.187      // test with begin, end / next
   1.188      {
   1.189          node nodes[4];
   1.190 -        void *begin = nullptr, *end = nullptr;
   1.191 +        void *begin = NULL, *end = NULL;
   1.192  
   1.193          cx_linked_list_add(&begin, &end, -1, loc_next, &nodes[0]);
   1.194 -        EXPECT_EQ(begin, &nodes[0]);
   1.195 -        EXPECT_EQ(end, &nodes[0]);
   1.196 +        CX_TEST_ASSERT(begin == &nodes[0]);
   1.197 +        CX_TEST_ASSERT(end == &nodes[0]);
   1.198          cx_linked_list_add(&begin, &end, -1, loc_next, &nodes[1]);
   1.199 -        EXPECT_EQ(end, &nodes[1]);
   1.200 -        EXPECT_EQ(nodes[0].next, &nodes[1]);
   1.201 -        EXPECT_EQ(nodes[1].prev, nullptr);
   1.202 +        CX_TEST_ASSERT(end == &nodes[1]);
   1.203 +        CX_TEST_ASSERT(nodes[0].next == &nodes[1]);
   1.204 +        CX_TEST_ASSERT(nodes[1].prev == NULL);
   1.205      }
   1.206  }
   1.207  
   1.208 @@ -268,73 +268,73 @@
   1.209      // test with begin, end / prev, next
   1.210      {
   1.211          node nodes[4];
   1.212 -        void *begin = nullptr, *end = nullptr;
   1.213 +        void *begin = NULL, *end = NULL;
   1.214  
   1.215          cx_linked_list_prepend(&begin, &end, loc_prev, loc_next, &nodes[0]);
   1.216 -        EXPECT_EQ(begin, &nodes[0]);
   1.217 -        EXPECT_EQ(end, &nodes[0]);
   1.218 -        EXPECT_EQ(nodes[0].prev, nullptr);
   1.219 -        EXPECT_EQ(nodes[0].next, nullptr);
   1.220 +        CX_TEST_ASSERT(begin == &nodes[0]);
   1.221 +        CX_TEST_ASSERT(end == &nodes[0]);
   1.222 +        CX_TEST_ASSERT(nodes[0].prev == NULL);
   1.223 +        CX_TEST_ASSERT(nodes[0].next == NULL);
   1.224  
   1.225          cx_linked_list_prepend(&begin, &end, loc_prev, loc_next, &nodes[1]);
   1.226 -        EXPECT_EQ(begin, &nodes[1]);
   1.227 -        EXPECT_EQ(end, &nodes[0]);
   1.228 -        EXPECT_EQ(nodes[1].next, &nodes[0]);
   1.229 -        EXPECT_EQ(nodes[0].prev, &nodes[1]);
   1.230 +        CX_TEST_ASSERT(begin == &nodes[1]);
   1.231 +        CX_TEST_ASSERT(end == &nodes[0]);
   1.232 +        CX_TEST_ASSERT(nodes[1].next == &nodes[0]);
   1.233 +        CX_TEST_ASSERT(nodes[0].prev == &nodes[1]);
   1.234      }
   1.235  
   1.236      // test with begin only / prev, next
   1.237      {
   1.238          node nodes[4];
   1.239 -        void *begin = nullptr;
   1.240 +        void *begin = NULL;
   1.241  
   1.242 -        cx_linked_list_prepend(&begin, nullptr, loc_prev, loc_next, &nodes[0]);
   1.243 -        EXPECT_EQ(begin, &nodes[0]);
   1.244 -        cx_linked_list_prepend(&begin, nullptr, loc_prev, loc_next, &nodes[1]);
   1.245 -        EXPECT_EQ(begin, &nodes[1]);
   1.246 -        EXPECT_EQ(nodes[1].next, &nodes[0]);
   1.247 -        EXPECT_EQ(nodes[0].prev, &nodes[1]);
   1.248 +        cx_linked_list_prepend(&begin, NULL, loc_prev, loc_next, &nodes[0]);
   1.249 +        CX_TEST_ASSERT(begin == &nodes[0]);
   1.250 +        cx_linked_list_prepend(&begin, NULL, loc_prev, loc_next, &nodes[1]);
   1.251 +        CX_TEST_ASSERT(begin == &nodes[1]);
   1.252 +        CX_TEST_ASSERT(nodes[1].next == &nodes[0]);
   1.253 +        CX_TEST_ASSERT(nodes[0].prev == &nodes[1]);
   1.254  
   1.255 -        cx_linked_list_prepend(&begin, nullptr, loc_prev, loc_next, &nodes[2]);
   1.256 -        EXPECT_EQ(begin, &nodes[2]);
   1.257 -        EXPECT_EQ(nodes[2].next, &nodes[1]);
   1.258 -        EXPECT_EQ(nodes[1].prev, &nodes[2]);
   1.259 +        cx_linked_list_prepend(&begin, NULL, loc_prev, loc_next, &nodes[2]);
   1.260 +        CX_TEST_ASSERT(begin == &nodes[2]);
   1.261 +        CX_TEST_ASSERT(nodes[2].next == &nodes[1]);
   1.262 +        CX_TEST_ASSERT(nodes[1].prev == &nodes[2]);
   1.263      }
   1.264  
   1.265      // test with end only / prev, next
   1.266      {
   1.267          node nodes[4];
   1.268 -        void *end = nullptr;
   1.269 +        void *end = NULL;
   1.270  
   1.271 -        cx_linked_list_prepend(nullptr, &end, loc_prev, loc_next, &nodes[0]);
   1.272 -        EXPECT_EQ(end, &nodes[0]);
   1.273 -        cx_linked_list_prepend(nullptr, &end, loc_prev, loc_next, &nodes[1]);
   1.274 -        EXPECT_EQ(end, &nodes[0]);
   1.275 -        EXPECT_EQ(nodes[1].next, &nodes[0]);
   1.276 -        EXPECT_EQ(nodes[0].prev, &nodes[1]);
   1.277 +        cx_linked_list_prepend(NULL, &end, loc_prev, loc_next, &nodes[0]);
   1.278 +        CX_TEST_ASSERT(end == &nodes[0]);
   1.279 +        cx_linked_list_prepend(NULL, &end, loc_prev, loc_next, &nodes[1]);
   1.280 +        CX_TEST_ASSERT(end == &nodes[0]);
   1.281 +        CX_TEST_ASSERT(nodes[1].next == &nodes[0]);
   1.282 +        CX_TEST_ASSERT(nodes[0].prev == &nodes[1]);
   1.283  
   1.284 -        cx_linked_list_prepend(nullptr, &end, loc_prev, loc_next, &nodes[2]);
   1.285 -        EXPECT_EQ(end, &nodes[0]);
   1.286 -        EXPECT_EQ(nodes[2].next, &nodes[1]);
   1.287 -        EXPECT_EQ(nodes[1].prev, &nodes[2]);
   1.288 +        cx_linked_list_prepend(NULL, &end, loc_prev, loc_next, &nodes[2]);
   1.289 +        CX_TEST_ASSERT(end == &nodes[0]);
   1.290 +        CX_TEST_ASSERT(nodes[2].next == &nodes[1]);
   1.291 +        CX_TEST_ASSERT(nodes[1].prev == &nodes[2]);
   1.292      }
   1.293  
   1.294      // test with begin, end / next
   1.295      {
   1.296          node nodes[4];
   1.297 -        void *begin = nullptr, *end = nullptr;
   1.298 +        void *begin = NULL, *end = NULL;
   1.299  
   1.300          cx_linked_list_prepend(&begin, &end, -1, loc_next, &nodes[0]);
   1.301 -        EXPECT_EQ(begin, &nodes[0]);
   1.302 -        EXPECT_EQ(end, &nodes[0]);
   1.303 +        CX_TEST_ASSERT(begin == &nodes[0]);
   1.304 +        CX_TEST_ASSERT(end == &nodes[0]);
   1.305          cx_linked_list_prepend(&begin, &end, -1, loc_next, &nodes[1]);
   1.306          cx_linked_list_prepend(&begin, &end, -1, loc_next, &nodes[2]);
   1.307 -        EXPECT_EQ(begin, &nodes[2]);
   1.308 -        EXPECT_EQ(end, &nodes[0]);
   1.309 -        EXPECT_EQ(nodes[1].next, &nodes[0]);
   1.310 -        EXPECT_EQ(nodes[2].next, &nodes[1]);
   1.311 -        EXPECT_EQ(nodes[1].prev, nullptr);
   1.312 -        EXPECT_EQ(nodes[0].prev, nullptr);
   1.313 +        CX_TEST_ASSERT(begin == &nodes[2]);
   1.314 +        CX_TEST_ASSERT(end == &nodes[0]);
   1.315 +        CX_TEST_ASSERT(nodes[1].next == &nodes[0]);
   1.316 +        CX_TEST_ASSERT(nodes[2].next == &nodes[1]);
   1.317 +        CX_TEST_ASSERT(nodes[1].prev == NULL);
   1.318 +        CX_TEST_ASSERT(nodes[0].prev == NULL);
   1.319      }
   1.320  }
   1.321  
   1.322 @@ -348,12 +348,12 @@
   1.323          cx_linked_list_link(&nodes[1], &nodes[2], loc_prev, loc_next);
   1.324  
   1.325          cx_linked_list_insert(&begin, &end, loc_prev, loc_next, &nodes[1], &nodes[3]);
   1.326 -        EXPECT_EQ(begin, &nodes[0]);
   1.327 -        EXPECT_EQ(end, &nodes[2]);
   1.328 -        EXPECT_EQ(nodes[1].next, &nodes[3]);
   1.329 -        EXPECT_EQ(nodes[2].prev, &nodes[3]);
   1.330 -        EXPECT_EQ(nodes[3].prev, &nodes[1]);
   1.331 -        EXPECT_EQ(nodes[3].next, &nodes[2]);
   1.332 +        CX_TEST_ASSERT(begin == &nodes[0]);
   1.333 +        CX_TEST_ASSERT(end == &nodes[2]);
   1.334 +        CX_TEST_ASSERT(nodes[1].next == &nodes[3]);
   1.335 +        CX_TEST_ASSERT(nodes[2].prev == &nodes[3]);
   1.336 +        CX_TEST_ASSERT(nodes[3].prev == &nodes[1]);
   1.337 +        CX_TEST_ASSERT(nodes[3].next == &nodes[2]);
   1.338      }
   1.339  
   1.340      // insert end
   1.341 @@ -365,11 +365,11 @@
   1.342          cx_linked_list_link(&nodes[1], &nodes[2], loc_prev, loc_next);
   1.343  
   1.344          cx_linked_list_insert(&begin, &end, loc_prev, loc_next, &nodes[2], &nodes[3]);
   1.345 -        EXPECT_EQ(begin, &nodes[0]);
   1.346 -        EXPECT_EQ(end, &nodes[3]);
   1.347 -        EXPECT_EQ(nodes[2].next, &nodes[3]);
   1.348 -        EXPECT_EQ(nodes[3].prev, &nodes[2]);
   1.349 -        EXPECT_EQ(nodes[3].next, nullptr);
   1.350 +        CX_TEST_ASSERT(begin == &nodes[0]);
   1.351 +        CX_TEST_ASSERT(end == &nodes[3]);
   1.352 +        CX_TEST_ASSERT(nodes[2].next == &nodes[3]);
   1.353 +        CX_TEST_ASSERT(nodes[3].prev == &nodes[2]);
   1.354 +        CX_TEST_ASSERT(nodes[3].next == NULL);
   1.355      }
   1.356  
   1.357      // insert begin
   1.358 @@ -380,12 +380,12 @@
   1.359          cx_linked_list_link(&nodes[0], &nodes[1], loc_prev, loc_next);
   1.360          cx_linked_list_link(&nodes[1], &nodes[2], loc_prev, loc_next);
   1.361  
   1.362 -        cx_linked_list_insert(&begin, &end, loc_prev, loc_next, nullptr, &nodes[3]);
   1.363 -        EXPECT_EQ(begin, &nodes[3]);
   1.364 -        EXPECT_EQ(end, &nodes[2]);
   1.365 -        EXPECT_EQ(nodes[0].prev, &nodes[3]);
   1.366 -        EXPECT_EQ(nodes[3].prev, nullptr);
   1.367 -        EXPECT_EQ(nodes[3].next, &nodes[0]);
   1.368 +        cx_linked_list_insert(&begin, &end, loc_prev, loc_next, NULL, &nodes[3]);
   1.369 +        CX_TEST_ASSERT(begin == &nodes[3]);
   1.370 +        CX_TEST_ASSERT(end == &nodes[2]);
   1.371 +        CX_TEST_ASSERT(nodes[0].prev == &nodes[3]);
   1.372 +        CX_TEST_ASSERT(nodes[3].prev == NULL);
   1.373 +        CX_TEST_ASSERT(nodes[3].next == &nodes[0]);
   1.374      }
   1.375  }
   1.376  
   1.377 @@ -399,13 +399,13 @@
   1.378          cx_linked_list_link(&nodes[1], &nodes[2], loc_prev, loc_next);
   1.379          cx_linked_list_link(&nodes[3], &nodes[4], loc_prev, loc_next);
   1.380  
   1.381 -        cx_linked_list_insert_chain(&begin, &end, loc_prev, loc_next, &nodes[1], &nodes[3], nullptr);
   1.382 -        EXPECT_EQ(begin, &nodes[0]);
   1.383 -        EXPECT_EQ(end, &nodes[2]);
   1.384 -        EXPECT_EQ(nodes[1].next, &nodes[3]);
   1.385 -        EXPECT_EQ(nodes[2].prev, &nodes[4]);
   1.386 -        EXPECT_EQ(nodes[3].prev, &nodes[1]);
   1.387 -        EXPECT_EQ(nodes[4].next, &nodes[2]);
   1.388 +        cx_linked_list_insert_chain(&begin, &end, loc_prev, loc_next, &nodes[1], &nodes[3], NULL);
   1.389 +        CX_TEST_ASSERT(begin == &nodes[0]);
   1.390 +        CX_TEST_ASSERT(end == &nodes[2]);
   1.391 +        CX_TEST_ASSERT(nodes[1].next == &nodes[3]);
   1.392 +        CX_TEST_ASSERT(nodes[2].prev == &nodes[4]);
   1.393 +        CX_TEST_ASSERT(nodes[3].prev == &nodes[1]);
   1.394 +        CX_TEST_ASSERT(nodes[4].next == &nodes[2]);
   1.395      }
   1.396  
   1.397      // insert end
   1.398 @@ -417,12 +417,12 @@
   1.399          cx_linked_list_link(&nodes[1], &nodes[2], loc_prev, loc_next);
   1.400          cx_linked_list_link(&nodes[3], &nodes[4], loc_prev, loc_next);
   1.401  
   1.402 -        cx_linked_list_insert_chain(&begin, &end, loc_prev, loc_next, &nodes[2], &nodes[3], nullptr);
   1.403 -        EXPECT_EQ(begin, &nodes[0]);
   1.404 -        EXPECT_EQ(end, &nodes[4]);
   1.405 -        EXPECT_EQ(nodes[2].next, &nodes[3]);
   1.406 -        EXPECT_EQ(nodes[3].prev, &nodes[2]);
   1.407 -        EXPECT_EQ(nodes[4].next, nullptr);
   1.408 +        cx_linked_list_insert_chain(&begin, &end, loc_prev, loc_next, &nodes[2], &nodes[3], NULL);
   1.409 +        CX_TEST_ASSERT(begin == &nodes[0]);
   1.410 +        CX_TEST_ASSERT(end == &nodes[4]);
   1.411 +        CX_TEST_ASSERT(nodes[2].next == &nodes[3]);
   1.412 +        CX_TEST_ASSERT(nodes[3].prev == &nodes[2]);
   1.413 +        CX_TEST_ASSERT(nodes[4].next == NULL);
   1.414      }
   1.415  
   1.416      // insert begin
   1.417 @@ -434,12 +434,12 @@
   1.418          cx_linked_list_link(&nodes[1], &nodes[2], loc_prev, loc_next);
   1.419          cx_linked_list_link(&nodes[3], &nodes[4], loc_prev, loc_next);
   1.420  
   1.421 -        cx_linked_list_insert_chain(&begin, &end, loc_prev, loc_next, nullptr, &nodes[3], nullptr);
   1.422 -        EXPECT_EQ(begin, &nodes[3]);
   1.423 -        EXPECT_EQ(end, &nodes[2]);
   1.424 -        EXPECT_EQ(nodes[0].prev, &nodes[4]);
   1.425 -        EXPECT_EQ(nodes[3].prev, nullptr);
   1.426 -        EXPECT_EQ(nodes[4].next, &nodes[0]);
   1.427 +        cx_linked_list_insert_chain(&begin, &end, loc_prev, loc_next, NULL, &nodes[3], NULL);
   1.428 +        CX_TEST_ASSERT(begin == &nodes[3]);
   1.429 +        CX_TEST_ASSERT(end == &nodes[2]);
   1.430 +        CX_TEST_ASSERT(nodes[0].prev == &nodes[4]);
   1.431 +        CX_TEST_ASSERT(nodes[3].prev == NULL);
   1.432 +        CX_TEST_ASSERT(nodes[4].next == &nodes[0]);
   1.433      }
   1.434  }
   1.435  
   1.436 @@ -463,7 +463,7 @@
   1.437  TEST(LinkedList_LowLevel, cx_linked_list_prev) {
   1.438      auto testdata = create_nodes_test_data(3);
   1.439      auto begin = testdata.begin;
   1.440 -    EXPECT_EQ(cx_linked_list_prev(begin, loc_next, begin), nullptr);
   1.441 +    EXPECT_EQ(cx_linked_list_prev(begin, loc_next, begin), NULL);
   1.442      EXPECT_EQ(cx_linked_list_prev(begin, loc_next, begin->next), begin);
   1.443      EXPECT_EQ(cx_linked_list_prev(begin, loc_next, begin->next->next), begin->next);
   1.444  }
   1.445 @@ -477,26 +477,26 @@
   1.446      auto end = reinterpret_cast<void *>(third);
   1.447  
   1.448      cx_linked_list_remove(&begin, &end, loc_prev, loc_next, second);
   1.449 -    EXPECT_EQ(begin, first);
   1.450 -    EXPECT_EQ(end, third);
   1.451 -    EXPECT_EQ(first->prev, nullptr);
   1.452 -    EXPECT_EQ(first->next, third);
   1.453 -    EXPECT_EQ(third->prev, first);
   1.454 -    EXPECT_EQ(third->next, nullptr);
   1.455 +    CX_TEST_ASSERT(begin == first);
   1.456 +    CX_TEST_ASSERT(end == third);
   1.457 +    CX_TEST_ASSERT(first->prev == NULL);
   1.458 +    CX_TEST_ASSERT(first->next == third);
   1.459 +    CX_TEST_ASSERT(third->prev == first);
   1.460 +    CX_TEST_ASSERT(third->next == NULL);
   1.461  
   1.462      cx_linked_list_remove(&begin, &end, loc_prev, loc_next, third);
   1.463 -    EXPECT_EQ(begin, first);
   1.464 -    EXPECT_EQ(end, first);
   1.465 -    EXPECT_EQ(first->prev, nullptr);
   1.466 -    EXPECT_EQ(first->next, nullptr);
   1.467 +    CX_TEST_ASSERT(begin == first);
   1.468 +    CX_TEST_ASSERT(end == first);
   1.469 +    CX_TEST_ASSERT(first->prev == NULL);
   1.470 +    CX_TEST_ASSERT(first->next == NULL);
   1.471  
   1.472      cx_linked_list_remove(&begin, &end, loc_prev, loc_next, first);
   1.473 -    EXPECT_EQ(begin, nullptr);
   1.474 -    EXPECT_EQ(end, nullptr);
   1.475 +    CX_TEST_ASSERT(begin == NULL);
   1.476 +    CX_TEST_ASSERT(end == NULL);
   1.477  }
   1.478  
   1.479  TEST(LinkedList_LowLevel, cx_linked_list_size) {
   1.480 -    EXPECT_EQ(cx_linked_list_size(nullptr, loc_next), 0);
   1.481 +    EXPECT_EQ(cx_linked_list_size(NULL, loc_next), 0);
   1.482  
   1.483      {
   1.484          auto testdata = create_nodes_test_data(5);
   1.485 @@ -510,9 +510,9 @@
   1.486  }
   1.487  
   1.488  TEST(LinkedList_LowLevel, cx_linked_list_sort_empty) {
   1.489 -    void *begin = nullptr;
   1.490 +    void *begin = NULL;
   1.491      EXPECT_NO_FATAL_FAILURE(
   1.492 -        cx_linked_list_sort(&begin, nullptr, loc_prev, loc_next, loc_data, cx_cmp_int);
   1.493 +        cx_linked_list_sort(&begin, NULL, loc_prev, loc_next, loc_data, cx_cmp_int);
   1.494      );
   1.495  }
   1.496  
   1.497 @@ -528,18 +528,18 @@
   1.498      cx_linked_list_sort(&begin, &end, loc_prev, loc_next, loc_data, cx_cmp_int);
   1.499  
   1.500      node *check = reinterpret_cast<node *>(begin);
   1.501 -    node *check_last = nullptr;
   1.502 +    node *check_last = NULL;
   1.503      cx_for_n (i, sorted.size()) {
   1.504 -        EXPECT_EQ(check->data, sorted[i]);
   1.505 -        EXPECT_EQ(check->prev, check_last);
   1.506 +        CX_TEST_ASSERT(check->data == sorted[i]);
   1.507 +        CX_TEST_ASSERT(check->prev == check_last);
   1.508          if (i < sorted.size() - 1) {
   1.509 -            ASSERT_NE(check->next, nullptr);
   1.510 +            ASSERT_NE(check->next, NULL);
   1.511          }
   1.512          check_last = check;
   1.513          check = check->next;
   1.514      }
   1.515 -    EXPECT_EQ(check, nullptr);
   1.516 -    EXPECT_EQ(end, check_last);
   1.517 +    CX_TEST_ASSERT(check == NULL);
   1.518 +    CX_TEST_ASSERT(end == check_last);
   1.519  }
   1.520  
   1.521  TEST(LinkedList_LowLevel, cx_linked_list_reverse) {
   1.522 @@ -551,8 +551,8 @@
   1.523      auto orig_begin = begin, orig_end = end;
   1.524  
   1.525      cx_linked_list_reverse(&begin, &end, loc_prev, loc_next);
   1.526 -    EXPECT_EQ(end, orig_begin);
   1.527 -    EXPECT_EQ(begin, orig_end);
   1.528 +    CX_TEST_ASSERT(end == orig_begin);
   1.529 +    CX_TEST_ASSERT(begin == orig_end);
   1.530      EXPECT_EQ(cx_linked_list_compare(begin, expected.begin, loc_next, loc_data, cx_cmp_int), 0);
   1.531  }
   1.532  
   1.533 @@ -563,14 +563,14 @@
   1.534  
   1.535      void TearDown() override {
   1.536          for (auto &&l: lists) cxListDestroy(l);
   1.537 -        EXPECT_TRUE(testingAllocator.verify());
   1.538 +        CX_TEST_ASSERT(testingAllocator.verify());
   1.539      }
   1.540  
   1.541      static constexpr size_t testdata_len = 250;
   1.542      int_test_data<testdata_len> testdata;
   1.543  
   1.544      auto autofree(CxList *list) const -> CxList * {
   1.545 -        if (list != nullptr) lists.insert(list);
   1.546 +        if (list != NULL) lists.insert(list);
   1.547          return list;
   1.548      }
   1.549  
   1.550 @@ -606,7 +606,7 @@
   1.551      ) {
   1.552          auto len = testdata_len;
   1.553          cx_for_n (i, len) EXPECT_EQ(cxListAdd(list, &testdata.data[i]), 0);
   1.554 -        EXPECT_EQ(cxListSize(list), len);
   1.555 +        CX_TEST_ASSERT(cxListSize(list) == len);
   1.556          cx_for_n (i, len) EXPECT_EQ(*(int *) cxListAt(list, i), testdata.data[i]);
   1.557          cx_for_n (i, len) ++testdata.data[i];
   1.558          if (as_pointer) {
   1.559 @@ -629,7 +629,7 @@
   1.560          EXPECT_EQ(cxListSize(list), 3);
   1.561          EXPECT_EQ(cxListInsert(list, 3, &d), 0);
   1.562  
   1.563 -        ASSERT_EQ(cxListSize(list), 4);
   1.564 +        CX_TEST_ASSERT(cxListSize(list) == 4);
   1.565  
   1.566          EXPECT_EQ(*(int *) cxListAt(list, 0), 47);
   1.567          EXPECT_EQ(*(int *) cxListAt(list, 1), 13);
   1.568 @@ -657,7 +657,7 @@
   1.569          } else {
   1.570              inserted = cxListInsertArray(list, 0, a, 5);
   1.571          }
   1.572 -        EXPECT_EQ(inserted, 5);
   1.573 +        CX_TEST_ASSERT(inserted == 5);
   1.574          EXPECT_EQ(*(int *) cxListAt(list, 0), 5);
   1.575          EXPECT_EQ(*(int *) cxListAt(list, 1), 47);
   1.576          EXPECT_EQ(*(int *) cxListAt(list, 2), 11);
   1.577 @@ -668,7 +668,7 @@
   1.578          } else {
   1.579              inserted = cxListInsertArray(list, 3, b, 5);
   1.580          }
   1.581 -        EXPECT_EQ(inserted, 5);
   1.582 +        CX_TEST_ASSERT(inserted == 5);
   1.583          EXPECT_EQ(*(int *) cxListAt(list, 0), 5);
   1.584          EXPECT_EQ(*(int *) cxListAt(list, 1), 47);
   1.585          EXPECT_EQ(*(int *) cxListAt(list, 2), 11);
   1.586 @@ -794,7 +794,7 @@
   1.587      }
   1.588  
   1.589      static void verifySwap(CxList *list) {
   1.590 -        ASSERT_EQ(cxListSize(list), 0);
   1.591 +        CX_TEST_ASSERT(cxListSize(list) == 0);
   1.592  
   1.593          int original[16] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
   1.594          int swapped[16] = {8, 4, 14, 3, 1, 5, 9, 12, 0, 6, 11, 10, 7, 15, 2, 13};
   1.595 @@ -825,11 +825,11 @@
   1.596          EXPECT_EQ(0, result);
   1.597  
   1.598          result = cxListSwap(list, 5, 16);
   1.599 -        EXPECT_NE(0, result);
   1.600 +        CX_TEST_ASSERT(0 != result);
   1.601          result = cxListSwap(list, 16, 6);
   1.602 -        EXPECT_NE(0, result);
   1.603 +        CX_TEST_ASSERT(0 != result);
   1.604          result = cxListSwap(list, 16, 17);
   1.605 -        EXPECT_NE(0, result);
   1.606 +        CX_TEST_ASSERT(0 != result);
   1.607  
   1.608          auto iter = cxListIterator(list);
   1.609          cx_foreach(int*, e, iter) {
   1.610 @@ -847,7 +847,7 @@
   1.611          cx_for_n (i, len) {
   1.612              EXPECT_EQ(*(int *) cxListAt(list, i), testdata.data[i]);
   1.613          }
   1.614 -        EXPECT_EQ(cxListAt(list, cxListSize(list)), nullptr);
   1.615 +        EXPECT_EQ(cxListAt(list, cxListSize(list)), NULL);
   1.616      }
   1.617  
   1.618      void verifyFind(CxList *list) const {
   1.619 @@ -872,49 +872,49 @@
   1.620          std::array<int, testdata_len> expected{};
   1.621          std::partial_sort_copy(testdata.data.begin(), testdata.data.end(), expected.begin(), expected.end());
   1.622          cxListSort(list);
   1.623 -        cx_for_n (i, testdata_len) ASSERT_EQ(*(int *) cxListAt(list, i), expected[i]);
   1.624 +        cx_for_n (i, testdata_len) CX_TEST_ASSERT(*(int *) cxListAt(list, i) == expected[i]);
   1.625      }
   1.626  
   1.627      void verifyIterator(CxList *list) const {
   1.628          auto iter = cxListIterator(list);
   1.629          size_t i = 0;
   1.630          cx_foreach(int*, x, iter) {
   1.631 -            ASSERT_EQ(i, iter.index);
   1.632 +            CX_TEST_ASSERT(i == iter.index);
   1.633              EXPECT_EQ(*x, testdata.data[iter.index]);
   1.634              i++;
   1.635          }
   1.636 -        ASSERT_EQ(i, cxListSize(list));
   1.637 +        CX_TEST_ASSERT(i == cxListSize(list));
   1.638          iter = cxListBackwardsIterator(list);
   1.639          cx_foreach(int*, x, iter) {
   1.640 -            ASSERT_EQ(i - 1, iter.index);
   1.641 +            CX_TEST_ASSERT(i - 1 == iter.index);
   1.642              EXPECT_EQ(*x, testdata.data[iter.index]);
   1.643              i--;
   1.644          }
   1.645 -        ASSERT_EQ(i, 0);
   1.646 +        CX_TEST_ASSERT(i == 0);
   1.647          auto len = testdata_len;
   1.648          i = len / 2;
   1.649          auto mut_iter = cxListMutIteratorAt(list, i);
   1.650          size_t j = 0;
   1.651          cx_foreach(int*, x, mut_iter) {
   1.652 -            ASSERT_EQ(mut_iter.index, len / 2 + j / 2);
   1.653 -            ASSERT_EQ(*x, testdata.data[i]);
   1.654 +            CX_TEST_ASSERT(mut_iter.index == len / 2 + j / 2);
   1.655 +            CX_TEST_ASSERT(*x == testdata.data[i]);
   1.656              if (i % 2 == 1) cxIteratorFlagRemoval(mut_iter);
   1.657              i++;
   1.658              j++;
   1.659          }
   1.660 -        ASSERT_EQ(i, len);
   1.661 +        CX_TEST_ASSERT(i == len);
   1.662          i = len / 2;
   1.663          j = 0;
   1.664          mut_iter = cxListMutBackwardsIteratorAt(list, i - 1);
   1.665          cx_foreach(int*, x, mut_iter) {
   1.666 -            ASSERT_EQ(mut_iter.index, len / 2 - 1 - j);
   1.667 -            ASSERT_EQ(*x, testdata.data[i - 1]);
   1.668 +            CX_TEST_ASSERT(mut_iter.index == len / 2 - 1 - j);
   1.669 +            CX_TEST_ASSERT(*x == testdata.data[i - 1]);
   1.670              if (i % 2 == 0) cxIteratorFlagRemoval(mut_iter);
   1.671              i--;
   1.672              j++;
   1.673          }
   1.674 -        ASSERT_EQ(i, 0);
   1.675 -        ASSERT_EQ(cxListSize(list), len / 2);
   1.676 +        CX_TEST_ASSERT(i == 0);
   1.677 +        CX_TEST_ASSERT(cxListSize(list) == len / 2);
   1.678          cx_for_n(j, len / 2) ASSERT_EQ(*(int *) cxListAt(list, j), testdata.data[j * 2]);
   1.679      }
   1.680  
   1.681 @@ -922,30 +922,30 @@
   1.682          int newdata[] = {10, 20, 30, 40, 50};
   1.683  
   1.684          auto iter = cxListMutIteratorAt(list, 2);
   1.685 -        EXPECT_TRUE(cxIteratorValid(iter));
   1.686 +        CX_TEST_ASSERT(cxIteratorValid(iter));
   1.687          EXPECT_EQ(iter.index, 2);
   1.688          EXPECT_EQ(*(int *) cxIteratorCurrent(iter), 2);
   1.689          cxListInsertAfter(&iter, &newdata[0]);
   1.690 -        EXPECT_TRUE(cxIteratorValid(iter));
   1.691 +        CX_TEST_ASSERT(cxIteratorValid(iter));
   1.692          EXPECT_EQ(iter.index, 2);
   1.693          EXPECT_EQ(*(int *) cxIteratorCurrent(iter), 2);
   1.694          cxListInsertBefore(&iter, &newdata[1]);
   1.695 -        EXPECT_TRUE(cxIteratorValid(iter));
   1.696 +        CX_TEST_ASSERT(cxIteratorValid(iter));
   1.697          EXPECT_EQ(iter.index, 3);
   1.698          EXPECT_EQ(*(int *) cxIteratorCurrent(iter), 2);
   1.699  
   1.700          iter = cxListMutIterator(list);
   1.701          cxListInsertBefore(&iter, &newdata[2]);
   1.702 -        EXPECT_TRUE(cxIteratorValid(iter));
   1.703 +        CX_TEST_ASSERT(cxIteratorValid(iter));
   1.704          EXPECT_EQ(iter.index, 1);
   1.705          EXPECT_EQ(*(int *) cxIteratorCurrent(iter), 0);
   1.706          iter = cxListMutIteratorAt(list, cxListSize(list));
   1.707          cxListInsertBefore(&iter, &newdata[3]);
   1.708 -        EXPECT_FALSE(cxIteratorValid(iter));
   1.709 +        CX_TEST_ASSERT(!cxIteratorValid(iter));
   1.710          EXPECT_EQ(iter.index, 9);
   1.711          iter = cxListMutIteratorAt(list, cxListSize(list));
   1.712          cxListInsertAfter(&iter, &newdata[4]);
   1.713 -        EXPECT_FALSE(cxIteratorValid(iter));
   1.714 +        CX_TEST_ASSERT(!cxIteratorValid(iter));
   1.715          EXPECT_EQ(iter.index, 10);
   1.716  
   1.717          int expdata[] = {30, 0, 1, 20, 2, 10, 3, 4, 40, 50};
   1.718 @@ -970,12 +970,12 @@
   1.719          EXPECT_GT(cxListCompare(left, right), 0);
   1.720          EXPECT_LT(cxListCompare(right, left), 0);
   1.721          cxListAdd(right, &x);
   1.722 -        ASSERT_EQ(cxListSize(left), cxListSize(right));
   1.723 +        CX_TEST_ASSERT(cxListSize(left) == cxListSize(right));
   1.724          EXPECT_EQ(cxListCompare(left, right), 0);
   1.725          int a = 5, b = 10;
   1.726          cxListInsert(left, 15, &a);
   1.727          cxListInsert(right, 15, &b);
   1.728 -        ASSERT_EQ(cxListSize(left), cxListSize(right));
   1.729 +        CX_TEST_ASSERT(cxListSize(left) == cxListSize(right));
   1.730          EXPECT_LT(cxListCompare(left, right), 0);
   1.731          EXPECT_GT(cxListCompare(right, left), 0);
   1.732          *(int *) cxListAt(left, 15) = 10;
   1.733 @@ -1000,90 +1000,90 @@
   1.734  
   1.735  TEST_F(PointerLinkedList, cxListStorePointers) {
   1.736      auto list = autofree(cxLinkedListCreate(&testingAllocator, cx_cmp_int, 47));
   1.737 -    EXPECT_FALSE(cxListIsStoringPointers(list));
   1.738 +    CX_TEST_ASSERT(!cxListIsStoringPointers(list));
   1.739      cxListStorePointers(list);
   1.740      EXPECT_EQ(list->item_size, sizeof(void *));
   1.741 -    EXPECT_NE(list->cl, nullptr);
   1.742 -    EXPECT_NE(list->climpl, nullptr);
   1.743 -    EXPECT_TRUE(cxListIsStoringPointers(list));
   1.744 +    CX_TEST_ASSERT(list->cl != NULL);
   1.745 +    CX_TEST_ASSERT(list->climpl != NULL);
   1.746 +    CX_TEST_ASSERT(cxListIsStoringPointers(list));
   1.747      cxListStoreObjects(list);
   1.748 -    EXPECT_NE(list->cl, nullptr);
   1.749 -    EXPECT_EQ(list->climpl, nullptr);
   1.750 -    EXPECT_FALSE(cxListIsStoringPointers(list));
   1.751 +    CX_TEST_ASSERT(list->cl != NULL);
   1.752 +    EXPECT_EQ(list->climpl, NULL);
   1.753 +    CX_TEST_ASSERT(!cxListIsStoringPointers(list));
   1.754  }
   1.755  
   1.756  TEST_F(LinkedList, cxLinkedListCreate) {
   1.757      CxList *list = autofree(cxLinkedListCreate(&testingAllocator, cx_cmp_int, sizeof(int)));
   1.758 -    ASSERT_NE(list, nullptr);
   1.759 +    ASSERT_NE(list, NULL);
   1.760      EXPECT_EQ(list->item_size, sizeof(int));
   1.761 -    EXPECT_EQ(list->simple_destructor, nullptr);
   1.762 -    EXPECT_EQ(list->advanced_destructor, nullptr);
   1.763 -    EXPECT_EQ(list->destructor_data, nullptr);
   1.764 +    EXPECT_EQ(list->simple_destructor, NULL);
   1.765 +    EXPECT_EQ(list->advanced_destructor, NULL);
   1.766 +    EXPECT_EQ(list->destructor_data, NULL);
   1.767      EXPECT_EQ(cxListSize(list), 0);
   1.768      EXPECT_EQ(list->allocator, &testingAllocator);
   1.769      EXPECT_EQ(list->cmpfunc, cx_cmp_int);
   1.770 -    EXPECT_FALSE(cxListIsStoringPointers(list));
   1.771 +    CX_TEST_ASSERT(!cxListIsStoringPointers(list));
   1.772  }
   1.773  
   1.774  TEST_F(LinkedList, cxLinkedListCreateSimple) {
   1.775      CxList *list = autofree(cxLinkedListCreateSimple(sizeof(int)));
   1.776 -    ASSERT_NE(list, nullptr);
   1.777 +    ASSERT_NE(list, NULL);
   1.778      EXPECT_EQ(list->item_size, sizeof(int));
   1.779 -    EXPECT_EQ(list->cmpfunc, nullptr);
   1.780 +    EXPECT_EQ(list->cmpfunc, NULL);
   1.781      EXPECT_EQ(list->allocator, cxDefaultAllocator);
   1.782 -    EXPECT_EQ(list->simple_destructor, nullptr);
   1.783 -    EXPECT_EQ(list->advanced_destructor, nullptr);
   1.784 -    EXPECT_EQ(list->destructor_data, nullptr);
   1.785 +    EXPECT_EQ(list->simple_destructor, NULL);
   1.786 +    EXPECT_EQ(list->advanced_destructor, NULL);
   1.787 +    EXPECT_EQ(list->destructor_data, NULL);
   1.788      EXPECT_EQ(cxListSize(list), 0);
   1.789 -    EXPECT_FALSE(cxListIsStoringPointers(list));
   1.790 +    CX_TEST_ASSERT(!cxListIsStoringPointers(list));
   1.791  }
   1.792  
   1.793  TEST_F(PointerLinkedList, cxLinkedListCreateSimpleForPointers) {
   1.794      CxList *list = autofree(cxLinkedListCreateSimple(CX_STORE_POINTERS));
   1.795 -    ASSERT_NE(list, nullptr);
   1.796 +    ASSERT_NE(list, NULL);
   1.797      EXPECT_EQ(list->item_size, sizeof(void *));
   1.798      EXPECT_EQ(list->cmpfunc, cx_cmp_ptr);
   1.799      EXPECT_EQ(list->allocator, cxDefaultAllocator);
   1.800 -    EXPECT_EQ(list->simple_destructor, nullptr);
   1.801 -    EXPECT_EQ(list->advanced_destructor, nullptr);
   1.802 -    EXPECT_EQ(list->destructor_data, nullptr);
   1.803 +    EXPECT_EQ(list->simple_destructor, NULL);
   1.804 +    EXPECT_EQ(list->advanced_destructor, NULL);
   1.805 +    EXPECT_EQ(list->destructor_data, NULL);
   1.806      EXPECT_EQ(cxListSize(list), 0);
   1.807 -    EXPECT_TRUE(cxListIsStoringPointers(list));
   1.808 +    CX_TEST_ASSERT(cxListIsStoringPointers(list));
   1.809  }
   1.810  
   1.811  TEST_F(ArrayList, cxArrayListCreate) {
   1.812      CxList *list = autofree(cxArrayListCreate(&testingAllocator, cx_cmp_int, sizeof(int), 8));
   1.813 -    ASSERT_NE(list, nullptr);
   1.814 +    ASSERT_NE(list, NULL);
   1.815      EXPECT_EQ(list->item_size, sizeof(int));
   1.816 -    EXPECT_EQ(list->simple_destructor, nullptr);
   1.817 -    EXPECT_EQ(list->advanced_destructor, nullptr);
   1.818 -    EXPECT_EQ(list->destructor_data, nullptr);
   1.819 +    EXPECT_EQ(list->simple_destructor, NULL);
   1.820 +    EXPECT_EQ(list->advanced_destructor, NULL);
   1.821 +    EXPECT_EQ(list->destructor_data, NULL);
   1.822      EXPECT_EQ(cxListSize(list), 0);
   1.823      EXPECT_EQ(list->allocator, &testingAllocator);
   1.824      EXPECT_EQ(list->cmpfunc, cx_cmp_int);
   1.825 -    EXPECT_FALSE(cxListIsStoringPointers(list));
   1.826 +    CX_TEST_ASSERT(!cxListIsStoringPointers(list));
   1.827  }
   1.828  
   1.829  TEST_F(ArrayList, cxArrayListCreateSimple) {
   1.830      CxList *list = autofree(cxArrayListCreateSimple(sizeof(int), 8));
   1.831 -    ASSERT_NE(list, nullptr);
   1.832 -    EXPECT_EQ(list->cmpfunc, nullptr);
   1.833 +    ASSERT_NE(list, NULL);
   1.834 +    EXPECT_EQ(list->cmpfunc, NULL);
   1.835      EXPECT_EQ(list->allocator, cxDefaultAllocator);
   1.836      EXPECT_EQ(list->item_size, sizeof(int));
   1.837 -    EXPECT_EQ(list->simple_destructor, nullptr);
   1.838 -    EXPECT_EQ(list->advanced_destructor, nullptr);
   1.839 -    EXPECT_EQ(list->destructor_data, nullptr);
   1.840 +    EXPECT_EQ(list->simple_destructor, NULL);
   1.841 +    EXPECT_EQ(list->advanced_destructor, NULL);
   1.842 +    EXPECT_EQ(list->destructor_data, NULL);
   1.843      EXPECT_EQ(cxListSize(list), 0);
   1.844 -    EXPECT_FALSE(cxListIsStoringPointers(list));
   1.845 +    CX_TEST_ASSERT(!cxListIsStoringPointers(list));
   1.846  }
   1.847  
   1.848  TEST_F(PointerArrayList, cxArrayListCreateSimpleForPointers) {
   1.849      CxList *list = autofree(cxArrayListCreateSimple(CX_STORE_POINTERS, 8));
   1.850 -    ASSERT_NE(list, nullptr);
   1.851 +    ASSERT_NE(list, NULL);
   1.852      EXPECT_EQ(list->cmpfunc, cx_cmp_ptr);
   1.853      EXPECT_EQ(list->allocator, cxDefaultAllocator);
   1.854      EXPECT_EQ(list->item_size, sizeof(void *));
   1.855 -    EXPECT_TRUE(cxListIsStoringPointers(list));
   1.856 +    CX_TEST_ASSERT(cxListIsStoringPointers(list));
   1.857  }
   1.858  
   1.859  TEST_F(LinkedList, cxListAdd) {
   1.860 @@ -1456,11 +1456,11 @@
   1.861      void *item = cxMalloc(&testingAllocator, sizeof(int));
   1.862      auto list = cxLinkedListCreate(cxDefaultAllocator, cx_cmp_int, CX_STORE_POINTERS);
   1.863      cxListAdd(list, item);
   1.864 -    ASSERT_FALSE(testingAllocator.verify());
   1.865 +    CX_TEST_ASSERT(!testingAllocator.verify());
   1.866      cxListDestroy(list);
   1.867 -    EXPECT_FALSE(testingAllocator.verify());
   1.868 +    CX_TEST_ASSERT(!testingAllocator.verify());
   1.869      cxFree(&testingAllocator, item);
   1.870 -    EXPECT_TRUE(testingAllocator.verify());
   1.871 +    CX_TEST_ASSERT(testingAllocator.verify());
   1.872  }
   1.873  
   1.874  TEST_F(PointerLinkedList, DestroySimpleDestructor) {
   1.875 @@ -1478,20 +1478,20 @@
   1.876      list->destructor_data = &testingAllocator;
   1.877      list->advanced_destructor = (cx_destructor_func2) cxFree;
   1.878      cxListAdd(list, item);
   1.879 -    ASSERT_FALSE(testingAllocator.verify());
   1.880 +    CX_TEST_ASSERT(!testingAllocator.verify());
   1.881      cxListDestroy(list);
   1.882 -    EXPECT_TRUE(testingAllocator.verify());
   1.883 +    CX_TEST_ASSERT(testingAllocator.verify());
   1.884  }
   1.885  
   1.886  TEST_F(PointerArrayList, DestroyNoDestructor) {
   1.887      void *item = cxMalloc(&testingAllocator, sizeof(int));
   1.888      auto list = cxArrayListCreate(cxDefaultAllocator, cx_cmp_int, CX_STORE_POINTERS, 4);
   1.889      cxListAdd(list, item);
   1.890 -    ASSERT_FALSE(testingAllocator.verify());
   1.891 +    CX_TEST_ASSERT(!testingAllocator.verify());
   1.892      cxListDestroy(list);
   1.893 -    EXPECT_FALSE(testingAllocator.verify());
   1.894 +    CX_TEST_ASSERT(!testingAllocator.verify());
   1.895      cxFree(&testingAllocator, item);
   1.896 -    EXPECT_TRUE(testingAllocator.verify());
   1.897 +    CX_TEST_ASSERT(testingAllocator.verify());
   1.898  }
   1.899  
   1.900  TEST_F(PointerArrayList, DestroySimpleDestructor) {
   1.901 @@ -1509,9 +1509,9 @@
   1.902      list->destructor_data = &testingAllocator;
   1.903      list->advanced_destructor = (cx_destructor_func2) cxFree;
   1.904      cxListAdd(list, item);
   1.905 -    ASSERT_FALSE(testingAllocator.verify());
   1.906 +    CX_TEST_ASSERT(!testingAllocator.verify());
   1.907      cxListDestroy(list);
   1.908 -    EXPECT_TRUE(testingAllocator.verify());
   1.909 +    CX_TEST_ASSERT(testingAllocator.verify());
   1.910  }
   1.911  
   1.912  TEST(EmptyList, Size) {
   1.913 @@ -1529,10 +1529,10 @@
   1.914      auto it3 = cxListMutIterator(list);
   1.915      auto it4 = cxListMutBackwardsIterator(list);
   1.916  
   1.917 -    EXPECT_FALSE(cxIteratorValid(it1));
   1.918 -    EXPECT_FALSE(cxIteratorValid(it2));
   1.919 -    EXPECT_FALSE(cxIteratorValid(it3));
   1.920 -    EXPECT_FALSE(cxIteratorValid(it4));
   1.921 +    CX_TEST_ASSERT(!cxIteratorValid(it1));
   1.922 +    CX_TEST_ASSERT(!cxIteratorValid(it2));
   1.923 +    CX_TEST_ASSERT(!cxIteratorValid(it3));
   1.924 +    CX_TEST_ASSERT(!cxIteratorValid(it4));
   1.925  
   1.926      int c = 0;
   1.927      cx_foreach(void*, data, it1) c++;
   1.928 @@ -1553,8 +1553,8 @@
   1.929  TEST(EmptyList, At) {
   1.930      auto list = cxEmptyList;
   1.931  
   1.932 -    EXPECT_EQ(cxListAt(list, 0), nullptr);
   1.933 -    EXPECT_EQ(cxListAt(list, 1), nullptr);
   1.934 +    EXPECT_EQ(cxListAt(list, 0), NULL);
   1.935 +    EXPECT_EQ(cxListAt(list, 1), NULL);
   1.936  }
   1.937  
   1.938  TEST(EmptyList, Find) {