diff -r 37c5d2fdb36b -r 68ad5750ba6b test/test_list.c
--- a/test/test_list.c	Tue Sep 28 18:49:12 2021 +0200
+++ b/test/test_list.c	Sun Oct 03 10:43:31 2021 +0200
@@ -80,96 +80,96 @@
     d.prev = &c;
     d.next = NULL;
 
-    CU_ASSERT_PTR_EQUAL(&a, cx_linked_list_at(&a, 0, loc_next, 0));
-    CU_ASSERT_PTR_EQUAL(&b, cx_linked_list_at(&a, 0, loc_next, 1));
-    CU_ASSERT_PTR_EQUAL(&c, cx_linked_list_at(&a, 0, loc_next, 2));
-    CU_ASSERT_PTR_EQUAL(&d, cx_linked_list_at(&a, 0, loc_next, 3));
-    CU_ASSERT_PTR_NULL(cx_linked_list_at(&a, 0, loc_next, 4));
+    CU_ASSERT_PTR_EQUAL(cx_linked_list_at(&a, 0, loc_next, 0), &a)
+    CU_ASSERT_PTR_EQUAL(cx_linked_list_at(&a, 0, loc_next, 1), &b)
+    CU_ASSERT_PTR_EQUAL(cx_linked_list_at(&a, 0, loc_next, 2), &c)
+    CU_ASSERT_PTR_EQUAL(cx_linked_list_at(&a, 0, loc_next, 3), &d)
+    CU_ASSERT_PTR_NULL(cx_linked_list_at(&a, 0, loc_next, 4))
 
-    CU_ASSERT_PTR_EQUAL(&a, cx_linked_list_at(&b, 1, loc_prev, 0));
-    CU_ASSERT_PTR_EQUAL(&b, cx_linked_list_at(&b, 1, loc_next, 1));
-    CU_ASSERT_PTR_EQUAL(&c, cx_linked_list_at(&b, 1, loc_next, 2));
-    CU_ASSERT_PTR_EQUAL(&d, cx_linked_list_at(&b, 1, loc_next, 3));
-    CU_ASSERT_PTR_NULL(cx_linked_list_at(&b, 1, loc_next, 4));
+    CU_ASSERT_PTR_EQUAL(cx_linked_list_at(&b, 1, loc_prev, 0), &a)
+    CU_ASSERT_PTR_EQUAL(cx_linked_list_at(&b, 1, loc_next, 1), &b)
+    CU_ASSERT_PTR_EQUAL(cx_linked_list_at(&b, 1, loc_next, 2), &c)
+    CU_ASSERT_PTR_EQUAL(cx_linked_list_at(&b, 1, loc_next, 3), &d)
+    CU_ASSERT_PTR_NULL(cx_linked_list_at(&b, 1, loc_next, 4))
 
-    CU_ASSERT_PTR_EQUAL(&a, cx_linked_list_at(&d, 3, loc_prev, 0));
-    CU_ASSERT_PTR_EQUAL(&b, cx_linked_list_at(&d, 3, loc_prev, 1));
+    CU_ASSERT_PTR_EQUAL(cx_linked_list_at(&d, 3, loc_prev, 0), &a)
+    CU_ASSERT_PTR_EQUAL(cx_linked_list_at(&d, 3, loc_prev, 1), &b)
 }
 
 void test_linked_list_add(void) {
     struct node {
         void *prev;
         void *next;
-        int value;
     };
-    
+
     struct node nodes[4];
-    
+
     // test with begin, end / prev, next
-    memset(nodes, 0, 4*sizeof(struct node));
+    memset(nodes, 0, 4 * sizeof(struct node));
     void *begin = NULL;
     void *end = NULL;
-    
+
     ptrdiff_t loc_prev = offsetof(struct node, prev);
     ptrdiff_t loc_next = offsetof(struct node, next);
-    
+
     int ret;
     ret = cx_linked_list_add(&begin, &end, loc_prev, loc_next, &nodes[0]);
-    CU_ASSERT_EQUAL(ret, 0);
-    CU_ASSERT_PTR_EQUAL(begin, &nodes[0]);
-    CU_ASSERT_PTR_EQUAL(end, &nodes[0]);
-    CU_ASSERT_PTR_EQUAL(nodes[0].prev, NULL);
-    CU_ASSERT_PTR_EQUAL(nodes[0].next, NULL);
-    
+    CU_ASSERT_EQUAL(ret, 0)
+    CU_ASSERT_PTR_EQUAL(begin, &nodes[0])
+    CU_ASSERT_PTR_EQUAL(end, &nodes[0])
+    CU_ASSERT_PTR_EQUAL(nodes[0].prev, NULL)
+    CU_ASSERT_PTR_EQUAL(nodes[0].next, NULL)
+
     ret = cx_linked_list_add(&begin, &end, loc_prev, loc_next, &nodes[1]);
-    CU_ASSERT_EQUAL(ret, 0);
-    CU_ASSERT_PTR_EQUAL(begin, &nodes[0]);
-    CU_ASSERT_PTR_EQUAL(end, &nodes[1]);
-    CU_ASSERT_PTR_EQUAL(nodes[0].next, &nodes[1]);
-    CU_ASSERT_PTR_EQUAL(nodes[1].prev, &nodes[0]);
-    
+    CU_ASSERT_EQUAL(ret, 0)
+    CU_ASSERT_PTR_EQUAL(begin, &nodes[0])
+    CU_ASSERT_PTR_EQUAL(end, &nodes[1])
+    CU_ASSERT_PTR_EQUAL(nodes[0].next, &nodes[1])
+    CU_ASSERT_PTR_EQUAL(nodes[1].prev, &nodes[0])
+
     // test with begin only / prev, next
-    memset(nodes, 0, 4*sizeof(struct node));
+    memset(nodes, 0, 4 * sizeof(struct node));
     begin = NULL;
     end = NULL;
-    
+
     ret = cx_linked_list_add(&begin, NULL, loc_prev, loc_next, &nodes[0]);
-    CU_ASSERT_EQUAL(ret, 0);
-    CU_ASSERT_PTR_EQUAL(begin, &nodes[0]);
+    CU_ASSERT_EQUAL(ret, 0)
+    CU_ASSERT_PTR_EQUAL(begin, &nodes[0])
     ret = cx_linked_list_add(&begin, NULL, loc_prev, loc_next, &nodes[1]);
-    CU_ASSERT_EQUAL(ret, 0);
-    CU_ASSERT_PTR_EQUAL(begin, &nodes[0]);
-    CU_ASSERT_PTR_EQUAL(nodes[0].next, &nodes[1]);
-    CU_ASSERT_PTR_EQUAL(nodes[1].prev, &nodes[0]);
-    
+    CU_ASSERT_EQUAL(ret, 0)
+    CU_ASSERT_PTR_EQUAL(begin, &nodes[0])
+    CU_ASSERT_PTR_EQUAL(nodes[0].next, &nodes[1])
+    CU_ASSERT_PTR_EQUAL(nodes[1].prev, &nodes[0])
+
     ret = cx_linked_list_add(&begin, NULL, loc_prev, loc_next, &nodes[2]);
-    CU_ASSERT_PTR_EQUAL(nodes[1].next, &nodes[2]);
-    CU_ASSERT_PTR_EQUAL(nodes[2].prev, &nodes[1]);
-    
+    CU_ASSERT_PTR_EQUAL(nodes[1].next, &nodes[2])
+    CU_ASSERT_PTR_EQUAL(nodes[2].prev, &nodes[1])
+
     // test with begin, end / next
-    memset(nodes, 0, 4*sizeof(struct node));
+    memset(nodes, 0, 4 * sizeof(struct node));
     begin = NULL;
     end = NULL;
-    
+
     ret = cx_linked_list_add(&begin, &end, -1, loc_next, &nodes[0]);
-    CU_ASSERT_EQUAL(ret, 0);
-    CU_ASSERT_PTR_EQUAL(begin, &nodes[0]);
-    CU_ASSERT_PTR_EQUAL(end, &nodes[0]);
+    CU_ASSERT_EQUAL(ret, 0)
+    CU_ASSERT_PTR_EQUAL(begin, &nodes[0])
+    CU_ASSERT_PTR_EQUAL(end, &nodes[0])
     ret = cx_linked_list_add(&begin, &end, -1, loc_next, &nodes[1]);
-    CU_ASSERT_PTR_EQUAL(end, &nodes[1]);
-    CU_ASSERT_PTR_EQUAL(nodes[0].next, &nodes[1]);
-    CU_ASSERT_PTR_EQUAL(nodes[1].prev, NULL);
+    CU_ASSERT_EQUAL(ret, 0)
+    CU_ASSERT_PTR_EQUAL(end, &nodes[1])
+    CU_ASSERT_PTR_EQUAL(nodes[0].next, &nodes[1])
+    CU_ASSERT_PTR_NULL(nodes[1].prev)
 }
 
 int main() {
     CU_pSuite suite = NULL;
-    
+
     if (CUE_SUCCESS != CU_initialize_registry()) {
         return CU_get_error();
     }
 
     suite = CU_add_suite("linked list suite", NULL, NULL);
-    
+
     CU_add_test(suite, "linked list: create and destroy", test_linked_list_create);
     CU_add_test(suite, "linked list: get node at index", test_linked_list_at);
     CU_add_test(suite, "linked list: add", test_linked_list_add);