diff -r 1e3cb39815f8 -r 28bc3e10ac28 test/test_list.c
--- a/test/test_list.c	Tue Oct 05 12:25:23 2021 +0200
+++ b/test/test_list.c	Tue Oct 05 13:03:45 2021 +0200
@@ -158,19 +158,7 @@
     CU_ASSERT_EQUAL(list->itemsize, sizeof(int))
     CU_ASSERT_PTR_EQUAL(list->cmpfunc, cmp_int)
 
-    // assume this structure for a linked list
-    struct ll_check {
-        cx_list_s base;
-        void *begin;
-        void *end;
-    };
-
-    struct ll_check *actual = (struct ll_check *) list;
-    CU_ASSERT_PTR_NULL(actual->begin)
-    CU_ASSERT_PTR_NULL(actual->end)
-
     cxLinkedListDestroy(list);
-
     CU_ASSERT_TRUE(cxTestingAllocatorVerify())
 }
 
@@ -190,9 +178,9 @@
     CU_ASSERT_EQUAL(list->size, 3)
     CU_ASSERT_TRUE(list->capacity >= list->size)
 
-    CU_ASSERT_EQUAL(*(int*)cxListAt(list, 0), 5)
-    CU_ASSERT_EQUAL(*(int*)cxListAt(list, 1), 47)
-    CU_ASSERT_EQUAL(*(int*)cxListAt(list, 2), 13)
+    CU_ASSERT_EQUAL(*(int *) cxListAt(list, 0), 5)
+    CU_ASSERT_EQUAL(*(int *) cxListAt(list, 1), 47)
+    CU_ASSERT_EQUAL(*(int *) cxListAt(list, 2), 13)
 
     cxLinkedListDestroy(list);
     CU_ASSERT_TRUE(cxTestingAllocatorVerify())
@@ -208,11 +196,11 @@
 
     data = 5;
     CU_ASSERT_EQUAL(cxListAdd(list, &data), 0)
-    CU_ASSERT_EQUAL(*(int*)cxListLast(list), 5)
+    CU_ASSERT_EQUAL(*(int *) cxListLast(list), 5)
 
     data = 47;
     CU_ASSERT_EQUAL(cxListAdd(list, &data), 0)
-    CU_ASSERT_EQUAL(*(int*)cxListLast(list), 47)
+    CU_ASSERT_EQUAL(*(int *) cxListLast(list), 47)
 
     cxLinkedListDestroy(list);
     CU_ASSERT_TRUE(cxTestingAllocatorVerify())
@@ -241,10 +229,10 @@
     CU_ASSERT_EQUAL(list->size, 4)
     CU_ASSERT_TRUE(list->capacity >= list->size)
 
-    CU_ASSERT_EQUAL(*(int*)cxListAt(list, 0), 47)
-    CU_ASSERT_EQUAL(*(int*)cxListAt(list, 1), 13)
-    CU_ASSERT_EQUAL(*(int*)cxListAt(list, 2), 5)
-    CU_ASSERT_EQUAL(*(int*)cxListAt(list, 3), 42)
+    CU_ASSERT_EQUAL(*(int *) cxListAt(list, 0), 47)
+    CU_ASSERT_EQUAL(*(int *) cxListAt(list, 1), 13)
+    CU_ASSERT_EQUAL(*(int *) cxListAt(list, 2), 5)
+    CU_ASSERT_EQUAL(*(int *) cxListAt(list, 3), 42)
 
     cxLinkedListDestroy(list);
     CU_ASSERT_TRUE(cxTestingAllocatorVerify())
@@ -273,20 +261,20 @@
     CU_ASSERT_EQUAL(cxListRemove(list, 2), 0)
     CU_ASSERT_EQUAL(list->size, 3)
     CU_ASSERT_TRUE(list->capacity >= list->size)
-    CU_ASSERT_EQUAL(*(int*)cxListAt(list, 0), 5)
-    CU_ASSERT_EQUAL(*(int*)cxListAt(list, 1), 47)
-    CU_ASSERT_EQUAL(*(int*)cxListAt(list, 2), 13)
+    CU_ASSERT_EQUAL(*(int *) cxListAt(list, 0), 5)
+    CU_ASSERT_EQUAL(*(int *) cxListAt(list, 1), 47)
+    CU_ASSERT_EQUAL(*(int *) cxListAt(list, 2), 13)
 
     CU_ASSERT_EQUAL(cxListRemove(list, 0), 0)
     CU_ASSERT_EQUAL(list->size, 2)
     CU_ASSERT_TRUE(list->capacity >= list->size)
-    CU_ASSERT_EQUAL(*(int*)cxListAt(list, 0), 47)
-    CU_ASSERT_EQUAL(*(int*)cxListAt(list, 1), 13)
+    CU_ASSERT_EQUAL(*(int *) cxListAt(list, 0), 47)
+    CU_ASSERT_EQUAL(*(int *) cxListAt(list, 1), 13)
 
     CU_ASSERT_EQUAL(cxListRemove(list, 1), 0)
     CU_ASSERT_EQUAL(list->size, 1)
     CU_ASSERT_TRUE(list->capacity >= list->size)
-    CU_ASSERT_EQUAL(*(int*)cxListAt(list, 0), 47)
+    CU_ASSERT_EQUAL(*(int *) cxListAt(list, 0), 47)
 
     CU_ASSERT_EQUAL(cxListRemove(list, 0), 0)
     CU_ASSERT_EQUAL(list->size, 0)
@@ -329,6 +317,171 @@
     CU_ASSERT_TRUE(cxTestingAllocatorVerify())
 }
 
+void test_hl_ptr_linked_list_create(void) {
+    cxTestingAllocatorReset();
+
+    CxList list = cxPointerLinkedListCreate(cxTestingAllocator, (CxListComparator) cmp_int);
+
+    CU_ASSERT_EQUAL(list->size, 0)
+    CU_ASSERT_EQUAL(list->capacity, (size_t) -1)
+    CU_ASSERT_PTR_EQUAL(list->allocator, cxTestingAllocator)
+    CU_ASSERT_EQUAL(list->itemsize, sizeof(void *))
+    CU_ASSERT_PTR_EQUAL(list->cmpfunc, cmp_int)
+
+    cxLinkedListDestroy(list);
+    CU_ASSERT_TRUE(cxTestingAllocatorVerify())
+}
+
+void test_hl_ptr_linked_list_add(void) {
+    cxTestingAllocatorReset();
+
+    CxList list = cxPointerLinkedListCreate(cxTestingAllocator, (CxListComparator) cmp_int);
+
+    int a = 5, b = 47, c = 13;
+
+    CU_ASSERT_EQUAL(cxListAdd(list, &a), 0)
+    CU_ASSERT_EQUAL(cxListAdd(list, &b), 0)
+    CU_ASSERT_EQUAL(cxListAdd(list, &c), 0)
+
+    CU_ASSERT_EQUAL(list->size, 3)
+    CU_ASSERT_TRUE(list->capacity >= list->size)
+
+    CU_ASSERT_EQUAL(*(int *) cxListAt(list, 0), 5)
+    CU_ASSERT_EQUAL(*(int *) cxListAt(list, 1), 47)
+    CU_ASSERT_EQUAL(*(int *) cxListAt(list, 2), 13)
+
+    a = 9;
+    b = 10;
+    c = 11;
+
+    CU_ASSERT_EQUAL(*(int *) cxListAt(list, 0), 9)
+    CU_ASSERT_EQUAL(*(int *) cxListAt(list, 1), 10)
+    CU_ASSERT_EQUAL(*(int *) cxListAt(list, 2), 11)
+
+    cxLinkedListDestroy(list);
+    CU_ASSERT_TRUE(cxTestingAllocatorVerify())
+}
+
+void test_hl_ptr_linked_list_last(void) {
+    cxTestingAllocatorReset();
+
+    CxList list = cxPointerLinkedListCreate(cxTestingAllocator, (CxListComparator) cmp_int);
+    CU_ASSERT_PTR_NULL(cxListLast(list))
+
+    int a = 5, b = 47;
+
+    CU_ASSERT_EQUAL(cxListAdd(list, &a), 0)
+    CU_ASSERT_EQUAL(*(int *) cxListLast(list), 5)
+    CU_ASSERT_EQUAL(cxListAdd(list, &b), 0)
+    CU_ASSERT_EQUAL(*(int *) cxListLast(list), 47)
+
+    cxLinkedListDestroy(list);
+    CU_ASSERT_TRUE(cxTestingAllocatorVerify())
+}
+
+void test_hl_ptr_linked_list_insert(void) {
+    cxTestingAllocatorReset();
+
+    CxList list = cxPointerLinkedListCreate(cxTestingAllocator, (CxListComparator) cmp_int);
+
+    int a = 5, b = 47, c = 13, d = 42;
+
+    CU_ASSERT_NOT_EQUAL(cxListInsert(list, 1, &a), 0)
+    CU_ASSERT_EQUAL(list->size, 0)
+    CU_ASSERT_EQUAL(cxListInsert(list, 0, &a), 0)
+    CU_ASSERT_EQUAL(list->size, 1)
+    CU_ASSERT_EQUAL(cxListInsert(list, 0, &b), 0)
+    CU_ASSERT_EQUAL(list->size, 2)
+    CU_ASSERT_EQUAL(cxListInsert(list, 1, &c), 0)
+    CU_ASSERT_EQUAL(list->size, 3)
+    CU_ASSERT_EQUAL(cxListInsert(list, 3, &d), 0)
+
+    CU_ASSERT_EQUAL(list->size, 4)
+    CU_ASSERT_TRUE(list->capacity >= list->size)
+
+    CU_ASSERT_EQUAL(*(int *) cxListAt(list, 0), 47)
+    CU_ASSERT_EQUAL(*(int *) cxListAt(list, 1), 13)
+    CU_ASSERT_EQUAL(*(int *) cxListAt(list, 2), 5)
+    CU_ASSERT_EQUAL(*(int *) cxListAt(list, 3), 42)
+
+    cxLinkedListDestroy(list);
+    CU_ASSERT_TRUE(cxTestingAllocatorVerify())
+}
+
+void test_hl_ptr_linked_list_remove(void) {
+    cxTestingAllocatorReset();
+
+    int a = 5, b = 47, c = 42, d = 13;
+    CxList list = cxPointerLinkedListCreate(cxTestingAllocator, (CxListComparator) cmp_int);
+
+    cxListAdd(list, &a);
+    cxListAdd(list, &b);
+    cxListAdd(list, &c);
+    cxListAdd(list, &d);
+
+    CU_ASSERT_EQUAL(list->size, 4)
+    CU_ASSERT_TRUE(list->capacity >= list->size)
+
+    CU_ASSERT_NOT_EQUAL(cxListRemove(list, 4), 0)
+
+    CU_ASSERT_EQUAL(cxListRemove(list, 2), 0)
+    CU_ASSERT_EQUAL(list->size, 3)
+    CU_ASSERT_TRUE(list->capacity >= list->size)
+    CU_ASSERT_EQUAL(*(int *) cxListAt(list, 0), 5)
+    CU_ASSERT_EQUAL(*(int *) cxListAt(list, 1), 47)
+    CU_ASSERT_EQUAL(*(int *) cxListAt(list, 2), 13)
+
+    CU_ASSERT_EQUAL(cxListRemove(list, 0), 0)
+    CU_ASSERT_EQUAL(list->size, 2)
+    CU_ASSERT_TRUE(list->capacity >= list->size)
+    CU_ASSERT_EQUAL(*(int *) cxListAt(list, 0), 47)
+    CU_ASSERT_EQUAL(*(int *) cxListAt(list, 1), 13)
+
+    CU_ASSERT_EQUAL(cxListRemove(list, 1), 0)
+    CU_ASSERT_EQUAL(list->size, 1)
+    CU_ASSERT_TRUE(list->capacity >= list->size)
+    CU_ASSERT_EQUAL(*(int *) cxListAt(list, 0), 47)
+
+    CU_ASSERT_EQUAL(cxListRemove(list, 0), 0)
+    CU_ASSERT_EQUAL(list->size, 0)
+    CU_ASSERT_TRUE(list->capacity >= list->size)
+
+    CU_ASSERT_NOT_EQUAL(cxListRemove(list, 0), 0)
+
+    cxLinkedListDestroy(list);
+    CU_ASSERT_TRUE(cxTestingAllocatorVerify())
+}
+
+void test_hl_ptr_linked_list_find(void) {
+    cxTestingAllocatorReset();
+
+    int a = 5, b = 47, c = 13, criteria;
+    CxList list = cxPointerLinkedListCreate(cxTestingAllocator, (CxListComparator) cmp_int);
+
+    cxListAdd(list, &a);
+    cxListAdd(list, &b);
+    cxListAdd(list, &c);
+
+    CU_ASSERT_EQUAL(list->size, 3)
+    CU_ASSERT_TRUE(list->capacity >= list->size)
+
+    criteria = 5;
+    CU_ASSERT_EQUAL(cxListFind(list, &criteria), 0)
+    criteria = 47;
+    CU_ASSERT_EQUAL(cxListFind(list, &criteria), 1)
+    criteria = 13;
+    CU_ASSERT_EQUAL(cxListFind(list, &criteria), 2)
+    criteria = 9000;
+    CU_ASSERT_EQUAL(cxListFind(list, &criteria), 3)
+    criteria = -5;
+    CU_ASSERT_EQUAL(cxListFind(list, &criteria), 3)
+    b = -5;
+    CU_ASSERT_EQUAL(cxListFind(list, &criteria), 1)
+
+    cxLinkedListDestroy(list);
+    CU_ASSERT_TRUE(cxTestingAllocatorVerify())
+}
+
 int main() {
     CU_pSuite suite = NULL;
 
@@ -351,6 +504,15 @@
     cu_add_test(suite, test_hl_linked_list_remove);
     cu_add_test(suite, test_hl_linked_list_find);
 
+    suite = CU_add_suite("high level pointer linked list", NULL, NULL);
+
+    cu_add_test(suite, test_hl_ptr_linked_list_create);
+    cu_add_test(suite, test_hl_ptr_linked_list_add);
+    cu_add_test(suite, test_hl_ptr_linked_list_last);
+    cu_add_test(suite, test_hl_ptr_linked_list_insert);
+    cu_add_test(suite, test_hl_ptr_linked_list_remove);
+    cu_add_test(suite, test_hl_ptr_linked_list_find);
+
     CU_basic_set_mode(UCX_CU_BRM);
 
     int exitcode;