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) {