diff --git a/src/tests.c b/src/tests.c index 92df299..7c2c4af 100644 --- a/src/tests.c +++ b/src/tests.c @@ -5,6 +5,10 @@ #include #include +// store a copy of the nodes created in test2_setup, to check if any +// of the tests modified them +static PtrArray test_group2_nodes_copy = {0}; + static void test_wm_treenode_new(void **state) { TreeNode *node = wm_treenode_new(NODE_VERTICAL, NULL); @@ -108,14 +112,195 @@ static void test_wm_all_nodes_to_ptrarray(void **state) wm_ptrarray_free(&all_nodes); } +static void test_wm_postorder_traversal(void **state) +{ + TreeNode *node1 = (TreeNode*)*state; + + PtrArray postorder = wm_postorder_traversal(node1); + TreeNode **postorder_nodes = (TreeNode**)postorder.ptrs; + + 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); + + wm_ptrarray_free(&postorder); +} + +static void test_wm_treenode_lmd(void **state) +{ + TreeNode *node1 = (TreeNode*)*state; + TreeNode *node2 = node1->children.nodes[0]; + TreeNode *node3 = node1->children.nodes[1]; + TreeNode *node4 = node2->children.nodes[0]; + TreeNode *node5 = node2->children.nodes[1]; + TreeNode *node6 = node2->children.nodes[2]; + TreeNode *node7 = node3->children.nodes[0]; + TreeNode *node8 = node3->children.nodes[1]; + + assert_int_equal(wm_treenode_lmd(node1)->id, node4->id); + assert_int_equal(wm_treenode_lmd(node2)->id, node4->id); + assert_int_equal(wm_treenode_lmd(node3)->id, node7->id); + assert_int_equal(wm_treenode_lmd(node4)->id, node4->id); + assert_int_equal(wm_treenode_lmd(node5)->id, node5->id); + assert_int_equal(wm_treenode_lmd(node6)->id, node6->id); + assert_int_equal(wm_treenode_lmd(node7)->id, node7->id); + assert_int_equal(wm_treenode_lmd(node8)->id, node8->id); +} + +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; + + 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); + + wm_ptrarray_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; + + assert_int_equal(ret.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); + + wm_ptrarray_free(&ret); +} + +static int test2_setup(void **state) +{ + TreeNode *node1 = wm_treenode_new(NODE_VERTICAL, NULL); + TreeNode *node2 = wm_treenode_new(NODE_VERTICAL, node1); + TreeNode *node3 = wm_treenode_new(NODE_VERTICAL, node1); + TreeNode *node4 = wm_treenode_new(NODE_VERTICAL, node2); + TreeNode *node5 = wm_treenode_new(NODE_VERTICAL, node2); + TreeNode *node6 = wm_treenode_new(NODE_VERTICAL, node2); + TreeNode *node7 = wm_treenode_new(NODE_VERTICAL, node3); + TreeNode *node8 = wm_treenode_new(NODE_VERTICAL, node3); + + wm_nodearray_push(&node1->children, node2); + wm_nodearray_push(&node1->children, node3); + wm_nodearray_push(&node2->children, node4); + wm_nodearray_push(&node2->children, node5); + wm_nodearray_push(&node2->children, node6); + wm_nodearray_push(&node3->children, node7); + wm_nodearray_push(&node3->children, node8); + + node1->id = 1; + node2->id = 2; + node3->id = 3; + node4->id = 4; + node5->id = 5; + node6->id = 6; + node7->id = 7; + node8->id = 8; + + assert_null(node1->parent); + assert_ptr_equal(node2->parent, node1); + assert_ptr_equal(node3->parent, node1); + assert_ptr_equal(node4->parent, node2); + assert_ptr_equal(node5->parent, node2); + assert_ptr_equal(node6->parent, node2); + assert_ptr_equal(node7->parent, node3); + assert_ptr_equal(node8->parent, node3); + + assert_int_equal(node1->children.size, 2); + assert_int_equal(node2->children.size, 3); + assert_int_equal(node3->children.size, 2); + + assert_int_equal(node1->id, 1); + assert_int_equal(node1->children.nodes[0]->id, 2); + assert_int_equal(node1->children.nodes[1]->id, 3); + assert_int_equal(node2->children.nodes[0]->id, 4); + assert_int_equal(node2->children.nodes[1]->id, 5); + assert_int_equal(node2->children.nodes[2]->id, 6); + assert_int_equal(node3->children.nodes[0]->id, 7); + assert_int_equal(node3->children.nodes[1]->id, 8); + + *state = node1; + + PtrArray nodes = wm_all_nodes_to_ptrarray((TreeNode*)*state); + + PtrArray nodes_copy = wm_ptrarray_new(); + for (size_t i = 0; i < nodes.size; i++) { + TreeNode *node_copy = malloc(sizeof(TreeNode)); + *node_copy = *((TreeNode**)nodes.ptrs)[i]; + wm_ptrarray_push(&nodes_copy, node_copy); + } + + test_group2_nodes_copy = nodes_copy; + + wm_ptrarray_free(&nodes); + + return 0; +} + +static int test2_teardown(void **state) +{ + PtrArray nodes = wm_all_nodes_to_ptrarray((TreeNode*)*state); + + // check if any of the original nodes were modified + for (size_t i = 0; i < test_group2_nodes_copy.size; i++) { + TreeNode *node_copy = ((TreeNode**)test_group2_nodes_copy.ptrs)[i]; + assert_memory_equal(node_copy, nodes.ptrs[i], sizeof(TreeNode)); + } + + for (size_t i = 0; i < nodes.size; i++) { + wm_treenode_free(nodes.ptrs[i]); + free((TreeNode*)test_group2_nodes_copy.ptrs[i]); + } + + wm_ptrarray_free(&nodes); + wm_ptrarray_free(&test_group2_nodes_copy); + + return 0; +} + int main(void) { - const struct CMUnitTest tests[] = { + const struct CMUnitTest test_group1[] = { cmocka_unit_test(test_wm_treenode_new), cmocka_unit_test(test_wm_nodearray_push), cmocka_unit_test(test_wm_find_client_nodes_ptr), cmocka_unit_test(test_wm_all_nodes_to_ptrarray), }; - return cmocka_run_group_tests(tests, NULL, NULL); + const struct CMUnitTest test_group2[] = { + cmocka_unit_test(test_wm_postorder_traversal), + cmocka_unit_test(test_wm_treenode_lmd), + cmocka_unit_test(test_wm_is_treenode_keyroot), + cmocka_unit_test(test_wm_treenode_all_lmds), + }; + + cmocka_run_group_tests(test_group1, NULL, NULL); + cmocka_run_group_tests(test_group2, test2_setup, test2_teardown); }