add pointer non null assertions

src/tests.c

@@ -16,6 +16,9 @@ static void test_wm_nodearray_push(void **state)
     TreeNode *node = wm_treenode_new(NODE_VERTICAL, NULL);
     TreeNode *node1 = wm_treenode_new(NODE_VERTICAL, node);
 
+    assert_non_null(node);
+    assert_non_null(node1);
+
     node1->id = 123;
 
     assert_null(node->parent);
@@ -35,6 +38,8 @@ static void test_wm_nodearray_push(void **state)
 static void test_wm_treenode_new(void **state)
 {
     TreeNode *node = wm_treenode_new(NODE_VERTICAL, NULL);
+
+    assert_non_null(node);
     assert_null(node->client);
     assert_non_null(node->children->nodes);
     assert_int_equal(node->children->size, 0);
@@ -47,6 +52,7 @@ static void test_wm_treenode_split_space(void **state)
 {
     /* vertical */
     TreeNode *parent = wm_treenode_new(NODE_VERTICAL, NULL);
+    assert_non_null(parent);
 
     parent->pos.x = 0;
     parent->pos.y = 0;
@@ -56,6 +62,9 @@ static void test_wm_treenode_split_space(void **state)
     TreeNode *child1 = wm_treenode_new(NODE_CLIENT, parent);
     TreeNode *child2 = wm_treenode_new(NODE_CLIENT, parent);
 
+    assert_non_null(child1);
+    assert_non_null(child2);
+
     wm_treenode_split_space(parent, &child1->pos, &child2->pos);
 
     assert_int_equal(child1->pos.x, 0);
@@ -76,6 +85,7 @@ static void test_wm_treenode_split_space(void **state)
 
     /* horizontal */
     parent = wm_treenode_new(NODE_HORIZONTAL, NULL);
+    assert_non_null(parent);
 
     parent->pos.x = 0;
     parent->pos.y = 0;
@@ -85,6 +95,9 @@ static void test_wm_treenode_split_space(void **state)
     child1 = wm_treenode_new(NODE_CLIENT, parent);
     child2 = wm_treenode_new(NODE_CLIENT, parent);
 
+    assert_non_null(child1);
+    assert_non_null(child2);
+
     wm_treenode_split_space(parent, &child1->pos, &child2->pos);
 
     assert_int_equal(child1->pos.x, 0);
@@ -111,6 +124,11 @@ static void test_wm_all_nodes_to_array(void **state)
     TreeNode *node2 = wm_treenode_new(NODE_CLIENT, NULL);
     TreeNode *node3 = wm_treenode_new(NODE_CLIENT, NULL);
 
+    assert_non_null(root);
+    assert_non_null(node1);
+    assert_non_null(node2);
+    assert_non_null(node3);
+
     const unsigned long ids[] = {1, 2, 3, 4};
 
     root->id = ids[0];
@@ -128,6 +146,7 @@ static void test_wm_all_nodes_to_array(void **state)
     assert_ptr_equal(root->children->nodes[2], node3);
 
     NodeArray *all_nodes = wm_all_nodes_to_array(root);
+    assert_non_null(all_nodes);
 
     assert_int_equal(all_nodes->size, 4);
     assert_in_set(((TreeNode*)all_nodes->nodes[0])->id, ids, 4);
@@ -148,6 +167,10 @@ static void test_wm_find_client_nodes(void **state)
     TreeNode *node1 = wm_treenode_new(NODE_CLIENT, NULL);
     TreeNode *node2 = wm_treenode_new(NODE_CLIENT, NULL);
 
+    assert_non_null(root);
+    assert_non_null(node1);
+    assert_non_null(node2);
+
     node1->client = (Client*)0x123;
     node2->client = (Client*)0x456;
 
@@ -164,6 +187,7 @@ static void test_wm_find_client_nodes(void **state)
     assert_ptr_equal(root->children->nodes[1], node2);
 
     NodeArray *client_nodes = wm_treenode_find_client_nodes(root);
+    assert_non_null(client_nodes);
 
     assert_int_equal(client_nodes->size, 2);
     assert_in_set((client_nodes->nodes[0])->id, ids, 2);
@@ -185,6 +209,14 @@ static void test_wm_treenode_remove_client1(void **state)
     TreeNode *client_node3 = wm_treenode_new(NODE_CLIENT, parent_node2);
     TreeNode *client_node4 = wm_treenode_new(NODE_CLIENT, parent_node2);
 
+    assert_non_null(root);
+    assert_non_null(parent_node1);
+    assert_non_null(parent_node2);
+    assert_non_null(client_node1);
+    assert_non_null(client_node2);
+    assert_non_null(client_node3);
+    assert_non_null(client_node4);
+
     wm_nodearray_push(root->children, parent_node1);
     wm_nodearray_push(root->children, parent_node2);
 
@@ -218,6 +250,7 @@ static void test_wm_treenode_remove_client1(void **state)
     wm_treenode_split_space(parent_node2, &client_node3->pos, &client_node4->pos);
 
     TreeNode *new_client_node = wm_treenode_remove_client(&(Wm) {0}, root, &client4);
+    assert_non_null(new_client_node);
 
     assert_ptr_equal(new_client_node, parent_node2);
     assert_int_equal(parent_node2->type, NODE_CLIENT);
@@ -239,6 +272,12 @@ static void test_wm_treenode_remove_client2(void **state)
     TreeNode *client_node2 = wm_treenode_new(NODE_CLIENT, parent_node1);
     TreeNode *client_node3 = wm_treenode_new(NODE_CLIENT, parent_node1);
 
+    assert_non_null(root);
+    assert_non_null(parent_node1);
+    assert_non_null(client_node1);
+    assert_non_null(client_node2);
+    assert_non_null(client_node3);
+
     TreeNode parent_node1_val = *parent_node1;
 
     wm_nodearray_push(root->children, parent_node1);
@@ -268,6 +307,7 @@ static void test_wm_treenode_remove_client2(void **state)
     wm_treenode_split_space(parent_node1, &client_node2->pos, &client_node3->pos);
 
     TreeNode *new_client_node = wm_treenode_remove_client(&(Wm) {0}, root, &client1);
+    assert_non_null(new_client_node);
 
     assert_ptr_equal(new_client_node, client_node2);
     assert_int_equal(root->id, parent_node1_val.id);
@@ -315,14 +355,32 @@ static void test_wm_treenode_lmd(void **state)
     TreeNode *node7 = node3->children->nodes[0];
     TreeNode *node8 = node3->children->nodes[1];
 
-    assert_int_equal(wm_treenode_lmd(node1)->id, node4->id);
+    TreeNode *lmd1 = wm_treenode_lmd(node1);
-    assert_int_equal(wm_treenode_lmd(node2)->id, node4->id);
+    TreeNode *lmd2 = wm_treenode_lmd(node2);
-    assert_int_equal(wm_treenode_lmd(node3)->id, node7->id);
+    TreeNode *lmd3 = wm_treenode_lmd(node3);
-    assert_int_equal(wm_treenode_lmd(node4)->id, node4->id);
+    TreeNode *lmd4 = wm_treenode_lmd(node4);
-    assert_int_equal(wm_treenode_lmd(node5)->id, node5->id);
+    TreeNode *lmd5 = wm_treenode_lmd(node5);
-    assert_int_equal(wm_treenode_lmd(node6)->id, node6->id);
+    TreeNode *lmd6 = wm_treenode_lmd(node6);
-    assert_int_equal(wm_treenode_lmd(node7)->id, node7->id);
+    TreeNode *lmd7 = wm_treenode_lmd(node7);
-    assert_int_equal(wm_treenode_lmd(node8)->id, node8->id);
+    TreeNode *lmd8 = wm_treenode_lmd(node8);
+
+    assert_non_null(lmd1);
+    assert_non_null(lmd2);
+    assert_non_null(lmd3);
+    assert_non_null(lmd4);
+    assert_non_null(lmd5);
+    assert_non_null(lmd6);
+    assert_non_null(lmd7);
+    assert_non_null(lmd8);
+
+    assert_ptr_equal(lmd1, node4);
+    assert_ptr_equal(lmd2, node4);
+    assert_ptr_equal(lmd3, node7);
+    assert_ptr_equal(lmd4, node4);
+    assert_ptr_equal(lmd5, node5);
+    assert_ptr_equal(lmd6, node6);
+    assert_ptr_equal(lmd7, node7);
+    assert_ptr_equal(lmd8, node8);
 }
 
 static void test_wm_is_treenode_keyroot(void **state)
@@ -396,6 +454,15 @@ static int test2_setup(void **state)
     TreeNode *node7 = wm_treenode_new(NODE_VERTICAL, node3);
     TreeNode *node8 = wm_treenode_new(NODE_VERTICAL, node3);
 
+    assert_non_null(node1);
+    assert_non_null(node2);
+    assert_non_null(node3);
+    assert_non_null(node4);
+    assert_non_null(node5);
+    assert_non_null(node6);
+    assert_non_null(node7);
+    assert_non_null(node8);
+
     wm_nodearray_push(node1->children, node2);
     wm_nodearray_push(node1->children, node3);
     wm_nodearray_push(node2->children, node4);