diff --git a/src/tests.c b/src/tests.c
index be6d22f..a700d13 100644
--- a/src/tests.c
+++ b/src/tests.c
@@ -287,21 +287,21 @@ static void test_wm_postorder_traversal(void **state)
 {
     TreeNode *node1 = (TreeNode*)*state;
 
-    PtrArray postorder = wm_postorder_traversal(node1);
-    TreeNode **postorder_nodes = (TreeNode**)postorder.ptrs;
+    NodeArray *postorder = wm_postorder_traversal(node1);
 
-    assert_int_equal(postorder.size, 8);
+    assert_non_null(postorder);
+    assert_int_equal(postorder->size, 8);
 
-    assert_int_equal(postorder_nodes[0]->id, 4);
-    assert_int_equal(postorder_nodes[1]->id, 5);
-    assert_int_equal(postorder_nodes[2]->id, 6);
-    assert_int_equal(postorder_nodes[3]->id, 2);
-    assert_int_equal(postorder_nodes[4]->id, 7);
-    assert_int_equal(postorder_nodes[5]->id, 8);
-    assert_int_equal(postorder_nodes[6]->id, 3);
-    assert_int_equal(postorder_nodes[7]->id, 1);
+    assert_int_equal(postorder->nodes[0]->id, 4);
+    assert_int_equal(postorder->nodes[1]->id, 5);
+    assert_int_equal(postorder->nodes[2]->id, 6);
+    assert_int_equal(postorder->nodes[3]->id, 2);
+    assert_int_equal(postorder->nodes[4]->id, 7);
+    assert_int_equal(postorder->nodes[5]->id, 8);
+    assert_int_equal(postorder->nodes[6]->id, 3);
+    assert_int_equal(postorder->nodes[7]->id, 1);
 
-    wm_ptrarray_free(&postorder);
+    wm_nodearray_free(postorder);
 }
 
 static void test_wm_treenode_lmd(void **state)
@@ -329,60 +329,60 @@ static void test_wm_is_treenode_keyroot(void **state)
 {
     TreeNode *node1 = (TreeNode*)*state;
 
-    PtrArray postorder = wm_postorder_traversal(node1);
-    TreeNode **postorder_nodes = (TreeNode**)postorder.ptrs;
+    NodeArray *postorder = wm_postorder_traversal(node1);
 
-    assert_int_equal(postorder.size, 8);
+    assert_non_null(postorder);
+    assert_int_equal(postorder->size, 8);
 
-    assert_int_equal(wm_is_treenode_keyroot(postorder_nodes[0]), false);
-    assert_int_equal(wm_is_treenode_keyroot(postorder_nodes[1]), true);
-    assert_int_equal(wm_is_treenode_keyroot(postorder_nodes[2]), true);
-    assert_int_equal(wm_is_treenode_keyroot(postorder_nodes[3]), false);
-    assert_int_equal(wm_is_treenode_keyroot(postorder_nodes[4]), false);
-    assert_int_equal(wm_is_treenode_keyroot(postorder_nodes[5]), true);
-    assert_int_equal(wm_is_treenode_keyroot(postorder_nodes[6]), true);
-    assert_int_equal(wm_is_treenode_keyroot(postorder_nodes[7]), true);
+    assert_int_equal(wm_is_treenode_keyroot(postorder->nodes[0]), false);
+    assert_int_equal(wm_is_treenode_keyroot(postorder->nodes[1]), true);
+    assert_int_equal(wm_is_treenode_keyroot(postorder->nodes[2]), true);
+    assert_int_equal(wm_is_treenode_keyroot(postorder->nodes[3]), false);
+    assert_int_equal(wm_is_treenode_keyroot(postorder->nodes[4]), false);
+    assert_int_equal(wm_is_treenode_keyroot(postorder->nodes[5]), true);
+    assert_int_equal(wm_is_treenode_keyroot(postorder->nodes[6]), true);
+    assert_int_equal(wm_is_treenode_keyroot(postorder->nodes[7]), true);
 
-    wm_ptrarray_free(&postorder);
+    wm_nodearray_free(postorder);
 }
 
 static void test_wm_treenode_all_lmds(void **state)
 {
     TreeNode *node1 = (TreeNode*)*state;
 
-    PtrArray ret = wm_treenode_all_lmds(node1);
-    TreeNode **lmds = (TreeNode**)ret.ptrs;
+    NodeArray *lmds = wm_treenode_all_lmds(node1);
 
-    assert_int_equal(ret.size, 8);
+    assert_non_null(lmds);
+    assert_int_equal(lmds->size, 8);
 
-    assert_int_equal(lmds[0]->id, 4);
-    assert_int_equal(lmds[1]->id, 5);
-    assert_int_equal(lmds[2]->id, 6);
-    assert_int_equal(lmds[3]->id, 4);
-    assert_int_equal(lmds[4]->id, 7);
-    assert_int_equal(lmds[5]->id, 8);
-    assert_int_equal(lmds[6]->id, 7);
-    assert_int_equal(lmds[7]->id, 4);
+    assert_int_equal(lmds->nodes[0]->id, 4);
+    assert_int_equal(lmds->nodes[1]->id, 5);
+    assert_int_equal(lmds->nodes[2]->id, 6);
+    assert_int_equal(lmds->nodes[3]->id, 4);
+    assert_int_equal(lmds->nodes[4]->id, 7);
+    assert_int_equal(lmds->nodes[5]->id, 8);
+    assert_int_equal(lmds->nodes[6]->id, 7);
+    assert_int_equal(lmds->nodes[7]->id, 4);
 
-    wm_ptrarray_free(&ret);
+    wm_nodearray_free(lmds);
 }
 
 static void test_wm_treenode_all_keyroots(void **state)
 {
     TreeNode *node1 = (TreeNode*)*state;
 
-    PtrArray keyroots = wm_treenode_all_keyroots(node1);
-    TreeNode **keyroot_nodes = (TreeNode**)keyroots.ptrs;
+    NodeArray *keyroots = wm_treenode_all_keyroots(node1);
 
-    assert_int_equal(keyroots.size, 5);
+    assert_non_null(keyroots);
+    assert_int_equal(keyroots->size, 5);
 
-    assert_int_equal(keyroot_nodes[0]->id, 5);
-    assert_int_equal(keyroot_nodes[1]->id, 6);
-    assert_int_equal(keyroot_nodes[2]->id, 8);
-    assert_int_equal(keyroot_nodes[3]->id, 3);
-    assert_int_equal(keyroot_nodes[4]->id, 1);
+    assert_int_equal(keyroots->nodes[0]->id, 5);
+    assert_int_equal(keyroots->nodes[1]->id, 6);
+    assert_int_equal(keyroots->nodes[2]->id, 8);
+    assert_int_equal(keyroots->nodes[3]->id, 3);
+    assert_int_equal(keyroots->nodes[4]->id, 1);
 
-    wm_ptrarray_free(&keyroots);
+    wm_nodearray_free(keyroots);
 }
 
 static int test2_setup(void **state)
@@ -438,10 +438,12 @@ static int test2_setup(void **state)
     *state = node1;
 
     NodeArray *nodes = wm_all_nodes_to_array((TreeNode*)*state);
+    assert_non_null(nodes);
 
     test_group2_nodes_copy = wm_nodearray_new();
     for (size_t i = 0; i < nodes->size; i++) {
         TreeNode *node_copy = malloc(sizeof(TreeNode));
+        assert_non_null(node_copy);
         *node_copy = *(nodes->nodes)[i];
         wm_nodearray_push(test_group2_nodes_copy, node_copy);
     }
diff --git a/src/util.c b/src/util.c
index 58d4ced..f371952 100644
--- a/src/util.c
+++ b/src/util.c
@@ -230,24 +230,24 @@ TreeNode* wm_treenode_lmd(TreeNode *node)
     return wm_treenode_lmd(node->children->nodes[0]);
 }
 
-PtrArray wm_treenode_all_lmds(TreeNode *node)
+NodeArray* wm_treenode_all_lmds(TreeNode *node)
 {
     assert(node);
 
-    PtrArray postorder = wm_postorder_traversal(node);
-    PtrArray ret = wm_ptrarray_new();
+    NodeArray *postorder = wm_postorder_traversal(node);
+    NodeArray *ret = wm_nodearray_new();
 
-    for (size_t i = 0; i < postorder.size; i++) {
-        TreeNode *lmd = wm_treenode_lmd(postorder.ptrs[i]);
+    for (size_t i = 0; i < postorder->size; i++) {
+        TreeNode *lmd = wm_treenode_lmd(postorder->nodes[i]);
 
-        wm_ptrarray_push(&ret, (void*)lmd);
+        wm_nodearray_push(ret, lmd);
     }
 
-    wm_ptrarray_free(&postorder);
+    wm_nodearray_free(postorder);
     return ret;
 }
 
-PtrArray wm_postorder_traversal(TreeNode *tree)
+NodeArray* wm_postorder_traversal(TreeNode *tree)
 {
     assert(tree);
 
@@ -260,15 +260,15 @@ PtrArray wm_postorder_traversal(TreeNode *tree)
 
     int root_index = 0;
 
-    PtrArray stack = wm_ptrarray_new();
-    PtrArray ret = wm_ptrarray_new();
+    NodeArray* stack = wm_nodearray_new();
+    NodeArray* ret = wm_nodearray_new();
 
-    while (root != NULL || stack.size > 0) {
+    while (root != NULL || stack->size > 0) {
         if (root != NULL) {
             NodeWithIndex *n = malloc(sizeof(NodeWithIndex));
             n->node = root;
             n->index = root_index;
-            wm_ptrarray_push(&stack, n);
+            wm_nodearray_push(stack, (void*)n);
             root_index = 0;
 
             if (root->children->size >= 1)
@@ -279,28 +279,28 @@ PtrArray wm_postorder_traversal(TreeNode *tree)
         }
 
         NodeWithIndex *nptr;
-        wm_ptrarray_pop(&stack, (void**)&nptr);
+        wm_nodearray_pop(stack, (TreeNode**)(void**)&nptr);
         NodeWithIndex n = *nptr;
         free(nptr);
-        wm_ptrarray_push(&ret, n.node);
+        wm_nodearray_push(ret, n.node);
 
-        while (stack.size > 0 && n.index == ((NodeWithIndex**)stack.ptrs)
-               [stack.size-1]->node->children->size - 1) {
-            wm_ptrarray_pop(&stack, (void**)&nptr);
+        while (stack->size > 0 && n.index == ((NodeWithIndex**)stack->nodes)
+               [stack->size-1]->node->children->size - 1) {
+            wm_nodearray_pop(stack, (TreeNode**)(void**)&nptr);
             n = *nptr;
             free(nptr);
 
-            wm_ptrarray_push(&ret, n.node);
+            wm_nodearray_push(ret, n.node);
         }
 
-        if (stack.size > 0) {
-            root = ((NodeWithIndex**)stack.ptrs)[stack.size-1]->node
+        if (stack->size > 0) {
+            root = ((NodeWithIndex**)stack->nodes)[stack->size-1]->node
                    ->children->nodes[n.index + 1];
             root_index = n.index + 1;
         }
     }
 
-    wm_ptrarray_free(&stack);
+    wm_nodearray_free(stack);
 
     return ret;
 }
@@ -313,20 +313,20 @@ bool wm_is_treenode_keyroot(TreeNode *node)
     return wm_treenode_lmd(node) != wm_treenode_lmd(node->parent);
 }
 
-PtrArray wm_treenode_all_keyroots(TreeNode *node)
+NodeArray* wm_treenode_all_keyroots(TreeNode *node)
 {
     assert(node);
 
-    PtrArray ret = wm_ptrarray_new();
-    PtrArray postorder = wm_postorder_traversal(node);
+    NodeArray* ret = wm_nodearray_new();
+    NodeArray* postorder = wm_postorder_traversal(node);
 
-    for (size_t i = 0; i < postorder.size; i++) {
-        TreeNode *node = ((TreeNode**)postorder.ptrs)[i];
+    for (size_t i = 0; i < postorder->size; i++) {
+        TreeNode *node = postorder->nodes[i];
         if (wm_is_treenode_keyroot(node))
-            wm_ptrarray_push(&ret, node);
+            wm_nodearray_push(ret, node);
     }
 
-    wm_ptrarray_free(&postorder);
+    wm_nodearray_free(postorder);
     return ret;
 }
 
diff --git a/src/util.h b/src/util.h
index cc8651b..4516f52 100644
--- a/src/util.h
+++ b/src/util.h
@@ -96,9 +96,9 @@ NodeArray* wm_all_nodes_to_array(TreeNode *root);
 void wm_log_state(Wm *wm, const char *prefixstr, const char* logfile);
 
 TreeNode* wm_treenode_lmd(TreeNode *node);
-PtrArray wm_treenode_all_lmds(TreeNode *node);
-PtrArray wm_postorder_traversal(TreeNode *tree);
+NodeArray* wm_treenode_all_lmds(TreeNode *node);
+NodeArray* wm_postorder_traversal(TreeNode *tree);
 bool wm_is_treenode_keyroot(TreeNode *node);
-PtrArray wm_treenode_all_keyroots(TreeNode *node);
+NodeArray* wm_treenode_all_keyroots(TreeNode *node);
 
 #endif