koma/wm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

rewrite NodeArray: use heap allocated struct pointer, remove unused ClientArray functions

Browse Source
This commit is contained in:
Akos Horvath
2023-12-29 19:08:58 +01:00
parent ff1c32bb33
commit 70d06f7888
5 changed files with 322 additions and 437 deletions
Download Patch File Download Diff File Expand all files Collapse all files

270
src/tests.c
View File

@ -7,18 +7,7 @@
// 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);
assert_null(node->client);
assert_non_null(node->children.nodes);
assert_int_equal(node->children.size, 0);
assert_int_equal(node->type, NODE_VERTICAL);
wm_treenode_free(node);
}
static NodeArray *test_group2_nodes_copy = NULL;
static void test_wm_nodearray_push(void **state)
{
@ -30,51 +19,90 @@ static void test_wm_nodearray_push(void **state)
assert_null(node->parent);
assert_ptr_equal(node1->parent, node);
wm_nodearray_push(&node->children, node1);
wm_nodearray_push(node->children, node1);
assert_int_equal(node->children.size, 1);
assert_ptr_equal(node->children.nodes[0], node1);
assert_int_equal(node->children->size, 1);
assert_ptr_equal(node->children->nodes[0], node1);
assert_int_equal(node1->id, 123);
assert_int_equal(node->children.nodes[0]->id, 123);
assert_int_equal(node->children->nodes[0]->id, 123);
wm_treenode_free(node);
wm_treenode_free(node1);
}
static void test_wm_find_client_nodes_ptr(void **state)
static void test_wm_treenode_new(void **state)
{
TreeNode *root = wm_treenode_new(NODE_VERTICAL, NULL);
TreeNode *node1 = wm_treenode_new(NODE_CLIENT, NULL);
TreeNode *node2 = wm_treenode_new(NODE_CLIENT, NULL);
TreeNode *node = wm_treenode_new(NODE_VERTICAL, NULL);
assert_null(node->client);
assert_non_null(node->children->nodes);
assert_int_equal(node->children->size, 0);
assert_int_equal(node->type, NODE_VERTICAL);
node1->client = (Client*)0x123;
node2->client = (Client*)0x456;
const unsigned long ids[] = {123, 456};
node1->id = ids[0];
node2->id = ids[1];
wm_nodearray_push(&root->children, node1);
wm_nodearray_push(&root->children, node2);
assert_int_equal(root->children.size, 2);
assert_ptr_equal(root->children.nodes[0], node1);
assert_ptr_equal(root->children.nodes[1], node2);
PtrArray client_ptrs = wm_treenode_find_client_nodes_ptr(root);
assert_int_equal(client_ptrs.size, 2);
assert_in_set(((TreeNode*)client_ptrs.ptrs[0])->id, ids, 2);
assert_in_set(((TreeNode*)client_ptrs.ptrs[1])->id, ids, 2);
wm_treenode_free(root);
wm_treenode_free(node1);
wm_treenode_free(node2);
wm_ptrarray_free(&client_ptrs);
wm_treenode_free(node);
}
static void test_wm_all_nodes_to_ptrarray(void **state)
static void test_wm_treenode_split_space(void **state)
{
/* vertical */
TreeNode *parent = wm_treenode_new(NODE_VERTICAL, NULL);
parent->pos.x = 0;
parent->pos.y = 0;
parent->pos.w = 200;
parent->pos.h = 200;
TreeNode *child1 = wm_treenode_new(NODE_CLIENT, parent);
TreeNode *child2 = wm_treenode_new(NODE_CLIENT, parent);
wm_treenode_split_space(parent, &child1->pos, &child2->pos);
assert_int_equal(child1->pos.x, 0);
assert_int_equal(child1->pos.y, 0);
assert_int_equal(child1->pos.w, 100);
assert_int_equal(child1->pos.h, 200);
assert_int_equal(child2->pos.x, 100);
assert_int_equal(child2->pos.y, 0);
assert_int_equal(child2->pos.w, 100);
assert_int_equal(child2->pos.h, 200);
wm_treenode_free(parent);
wm_treenode_free(child1);
wm_treenode_free(child2);
/* horizontal */
parent = wm_treenode_new(NODE_HORIZONTAL, NULL);
parent->pos.x = 0;
parent->pos.y = 0;
parent->pos.w = 200;
parent->pos.h = 200;
child1 = wm_treenode_new(NODE_CLIENT, parent);
child2 = wm_treenode_new(NODE_CLIENT, parent);
wm_treenode_split_space(parent, &child1->pos, &child2->pos);
assert_int_equal(child1->pos.x, 0);
assert_int_equal(child1->pos.y, 0);
assert_int_equal(child1->pos.w, 200);
assert_int_equal(child1->pos.h, 100);
assert_int_equal(child2->pos.x, 0);
assert_int_equal(child2->pos.y, 100);
assert_int_equal(child2->pos.w, 200);
assert_int_equal(child2->pos.h, 100);
wm_treenode_free(parent);
wm_treenode_free(child1);
wm_treenode_free(child2);
}
static void test_wm_all_nodes_to_array(void **state)
{
TreeNode *root = wm_treenode_new(NODE_VERTICAL, NULL);
TreeNode *node1 = wm_treenode_new(NODE_CLIENT, NULL);
@ -88,28 +116,61 @@ static void test_wm_all_nodes_to_ptrarray(void **state)
node2->id = ids[2];
node3->id = ids[3];
wm_nodearray_push(&root->children, node1);
wm_nodearray_push(&root->children, node2);
wm_nodearray_push(&root->children, node3);
wm_nodearray_push(root->children, node1);
wm_nodearray_push(root->children, node2);
wm_nodearray_push(root->children, node3);
assert_int_equal(root->children.size, 3);
assert_ptr_equal(root->children.nodes[0], node1);
assert_ptr_equal(root->children.nodes[1], node2);
assert_ptr_equal(root->children.nodes[2], node3);
assert_int_equal(root->children->size, 3);
assert_ptr_equal(root->children->nodes[0], node1);
assert_ptr_equal(root->children->nodes[1], node2);
assert_ptr_equal(root->children->nodes[2], node3);
PtrArray all_nodes = wm_all_nodes_to_ptrarray(root);
NodeArray *all_nodes = wm_all_nodes_to_array(root);
assert_int_equal(all_nodes.size, 4);
assert_in_set(((TreeNode*)all_nodes.ptrs[0])->id, ids, 4);
assert_in_set(((TreeNode*)all_nodes.ptrs[1])->id, ids, 4);
assert_in_set(((TreeNode*)all_nodes.ptrs[2])->id, ids, 4);
assert_in_set(((TreeNode*)all_nodes.ptrs[3])->id, ids, 4);
assert_int_equal(all_nodes->size, 4);
assert_in_set(((TreeNode*)all_nodes->nodes[0])->id, ids, 4);
assert_in_set(((TreeNode*)all_nodes->nodes[1])->id, ids, 4);
assert_in_set(((TreeNode*)all_nodes->nodes[2])->id, ids, 4);
assert_in_set(((TreeNode*)all_nodes->nodes[3])->id, ids, 4);
wm_treenode_free(root);
wm_treenode_free(node1);
wm_treenode_free(node2);
wm_treenode_free(node3);
wm_ptrarray_free(&all_nodes);
wm_nodearray_free(all_nodes);
}
static void test_wm_find_client_nodes(void **state)
{
TreeNode *root = wm_treenode_new(NODE_VERTICAL, NULL);
TreeNode *node1 = wm_treenode_new(NODE_CLIENT, NULL);
TreeNode *node2 = wm_treenode_new(NODE_CLIENT, NULL);
node1->client = (Client*)0x123;
node2->client = (Client*)0x456;
const unsigned long ids[] = {123, 456};
node1->id = ids[0];
node2->id = ids[1];
wm_nodearray_push(root->children, node1);
wm_nodearray_push(root->children, node2);
assert_int_equal(root->children->size, 2);
assert_ptr_equal(root->children->nodes[0], node1);
assert_ptr_equal(root->children->nodes[1], node2);
NodeArray *client_nodes = wm_treenode_find_client_nodes(root);
assert_int_equal(client_nodes->size, 2);
assert_in_set((client_nodes->nodes[0])->id, ids, 2);
assert_in_set((client_nodes->nodes[1])->id, ids, 2);
wm_treenode_free(root);
wm_treenode_free(node1);
wm_treenode_free(node2);
wm_nodearray_free(client_nodes);
}
static void test_wm_postorder_traversal(void **state)
@ -136,13 +197,13 @@ static void test_wm_postorder_traversal(void **state)
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];
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);
@ -225,13 +286,13 @@ static int test2_setup(void **state)
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);
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;
@ -251,54 +312,54 @@ static int test2_setup(void **state)
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->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);
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);
NodeArray *nodes = wm_all_nodes_to_array((TreeNode*)*state);
PtrArray nodes_copy = wm_ptrarray_new();
for (size_t i = 0; i < nodes.size; i++) {
test_group2_nodes_copy = wm_nodearray_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);
*node_copy = *(nodes->nodes)[i];
wm_nodearray_push(test_group2_nodes_copy, node_copy);
}
test_group2_nodes_copy = nodes_copy;
wm_ptrarray_free(&nodes);
wm_nodearray_free(nodes);
return 0;
}
static int test2_teardown(void **state)
{
PtrArray nodes = wm_all_nodes_to_ptrarray((TreeNode*)*state);
NodeArray *nodes = wm_all_nodes_to_array((TreeNode*)*state);
assert_non_null(test_group2_nodes_copy);
// 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 < test_group2_nodes_copy->size; i++) {
TreeNode *node_copy = ((TreeNode**)test_group2_nodes_copy->nodes)[i];
assert_memory_equal(node_copy, nodes->nodes[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]);
for (size_t i = 0; i < nodes->size; i++) {
wm_treenode_free(nodes->nodes[i]);
free((TreeNode*)test_group2_nodes_copy->nodes[i]);
}
wm_ptrarray_free(&nodes);
wm_ptrarray_free(&test_group2_nodes_copy);
wm_nodearray_free(nodes);
wm_nodearray_free(test_group2_nodes_copy);
return 0;
}
@ -306,10 +367,11 @@ static int test2_teardown(void **state)
int main(void)
{
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),
cmocka_unit_test(test_wm_treenode_new),
cmocka_unit_test(test_wm_treenode_split_space),
cmocka_unit_test(test_wm_all_nodes_to_array),
cmocka_unit_test(test_wm_find_client_nodes),
};
const struct CMUnitTest test_group2[] = {