Mercurial > hg > ucx / file revision

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2023 Mike Becker, Olaf Wintermann All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include "cx/tree.h"

#include "cx/test.h"

typedef struct tree_node {
    struct tree_node *parent;
    struct tree_node *next;
    struct tree_node *prev;
    struct tree_node *children;
    int data;
} tree_node;

#define tree_node_layout \
    offsetof(tree_node, parent), offsetof(tree_node, children), \
    offsetof(tree_node, prev), offsetof(tree_node, next)

#define tree_child_list offsetof(tree_node, children),offsetof(tree_node, next)

CX_TEST(test_tree_link_new_child) {
    tree_node parent = {0};
    tree_node child = {0};

    CX_TEST_DO {
        cx_tree_link(&parent, &child, tree_node_layout);
        CX_TEST_ASSERT(parent.next == NULL);
        CX_TEST_ASSERT(parent.prev == NULL);
        CX_TEST_ASSERT(parent.parent == NULL);
        CX_TEST_ASSERT(parent.children == &child);
        CX_TEST_ASSERT(child.parent == &parent);
        CX_TEST_ASSERT(child.next == NULL);
        CX_TEST_ASSERT(child.prev == NULL);
        CX_TEST_ASSERT(child.children == NULL);
    }
}

CX_TEST(test_tree_link_add_child) {
    tree_node parent = {0};
    tree_node child1 = {0};
    tree_node child2 = {0};
    tree_node child3 = {0};

    CX_TEST_DO {
        cx_tree_link(&parent, &child1, tree_node_layout);
        cx_tree_link(&parent, &child2, tree_node_layout);
        cx_tree_link(&parent, &child3, tree_node_layout);
        CX_TEST_ASSERT(parent.next == NULL);
        CX_TEST_ASSERT(parent.prev == NULL);
        CX_TEST_ASSERT(parent.parent == NULL);
        CX_TEST_ASSERT(parent.children == &child3);

        CX_TEST_ASSERT(child1.parent == &parent);
        CX_TEST_ASSERT(child2.parent == &parent);
        CX_TEST_ASSERT(child3.parent == &parent);
        CX_TEST_ASSERT(child1.children == NULL);
        CX_TEST_ASSERT(child2.children == NULL);
        CX_TEST_ASSERT(child3.children == NULL);

        CX_TEST_ASSERT(child3.prev == NULL);
        CX_TEST_ASSERT(child3.next == &child2);
        CX_TEST_ASSERT(child2.prev == &child3);
        CX_TEST_ASSERT(child2.next == &child1);
        CX_TEST_ASSERT(child1.prev == &child2);
        CX_TEST_ASSERT(child1.next == NULL);
    }
}

CX_TEST(test_tree_link_move_to_other_parent) {
    tree_node parent = {0};
    tree_node child1 = {0};
    tree_node child2 = {0};
    tree_node child3 = {0};
    cx_tree_link(&parent, &child1, tree_node_layout);
    cx_tree_link(&parent, &child2, tree_node_layout);
    cx_tree_link(&parent, &child3, tree_node_layout);

    CX_TEST_DO {
        cx_tree_link(&child3, &child2, tree_node_layout);

        CX_TEST_ASSERT(parent.next == NULL);
        CX_TEST_ASSERT(parent.prev == NULL);
        CX_TEST_ASSERT(parent.parent == NULL);
        CX_TEST_ASSERT(parent.children == &child3);

        CX_TEST_ASSERT(child1.parent == &parent);
        CX_TEST_ASSERT(child2.parent == &child3);
        CX_TEST_ASSERT(child3.parent == &parent);
        CX_TEST_ASSERT(child1.children == NULL);
        CX_TEST_ASSERT(child2.children == NULL);
        CX_TEST_ASSERT(child3.children == &child2);

        CX_TEST_ASSERT(child3.prev == NULL);
        CX_TEST_ASSERT(child3.next == &child1);
        CX_TEST_ASSERT(child1.prev == &child3);
        CX_TEST_ASSERT(child1.next == NULL);

        CX_TEST_ASSERT(child2.prev == NULL);
        CX_TEST_ASSERT(child2.next == NULL);
    }
}

CX_TEST(test_tree_unlink) {
    tree_node parent = {0};
    tree_node child1 = {0};
    tree_node child2 = {0};
    tree_node child3 = {0};
    cx_tree_link(&parent, &child1, tree_node_layout);
    cx_tree_link(&parent, &child3, tree_node_layout);
    cx_tree_link(&child3, &child2, tree_node_layout);

    CX_TEST_DO {
        cx_tree_unlink(&child3, tree_node_layout);

        CX_TEST_ASSERT(parent.next == NULL);
        CX_TEST_ASSERT(parent.prev == NULL);
        CX_TEST_ASSERT(parent.parent == NULL);
        CX_TEST_ASSERT(parent.children == &child1);

        CX_TEST_ASSERT(child1.parent == &parent);
        CX_TEST_ASSERT(child1.children == NULL);
        CX_TEST_ASSERT(child1.prev == NULL);
        CX_TEST_ASSERT(child1.next == NULL);

        // child 3 is unlinked
        CX_TEST_ASSERT(child3.parent == NULL);
        CX_TEST_ASSERT(child3.prev == NULL);
        CX_TEST_ASSERT(child3.next == NULL);

        // child 2 is still child of the unlinked child 3
        CX_TEST_ASSERT(child3.children == &child2);
        CX_TEST_ASSERT(child2.parent == &child3);
        CX_TEST_ASSERT(child2.children == NULL);
        CX_TEST_ASSERT(child2.prev == NULL);
        CX_TEST_ASSERT(child2.next == NULL);
    }
}

static int test_tree_search_function(void const *n, void const *d) {
    tree_node const *node = n;
    int data = *((int const*)d);

    if (data < node->data) return -1;
    else if (data == node->data) return 0;
    else return data - node->data;
}

CX_TEST(test_tree_search) {
    tree_node root = {0};
    tree_node a = {0};
    tree_node b = {0};
    tree_node c = {0};
    tree_node aa = {0};
    tree_node ab = {0};
    tree_node ba = {0};
    tree_node ca = {0};
    tree_node cb = {0};
    tree_node cc = {0};
    tree_node cba = {0};

    int testdata[] = {0, 10, 14, 18, 20, 25, 30, 32, 34, 36, 40};
    tree_node* testnodes[] = {&root, &a, &aa, &ab, &b, &ba, &c, &ca, &cb, &cba, &cc};

    for (unsigned i = 0 ; i <= 10 ; i++) {
        testnodes[i]->data = testdata[i];
    }

    cx_tree_link(&root, &a, tree_node_layout);
    cx_tree_link(&root, &b, tree_node_layout);
    cx_tree_link(&root, &c, tree_node_layout);

    cx_tree_link(&a, &aa, tree_node_layout);
    cx_tree_link(&a, &ab, tree_node_layout);

    cx_tree_link(&b, &ba, tree_node_layout);

    cx_tree_link(&c, &ca, tree_node_layout);
    cx_tree_link(&c, &cb, tree_node_layout);
    cx_tree_link(&c, &cc, tree_node_layout);

    cx_tree_link(&cb, &cba, tree_node_layout);

    int s;
    int r;
    tree_node *n;
    CX_TEST_DO {
        for (unsigned i = 0 ; i <= 10 ; i++) {
            s = testdata[i];
            r = cx_tree_search(&root, &s, test_tree_search_function,
                               (void **) &n, tree_child_list);
            CX_TEST_ASSERT(r == 0);
            CX_TEST_ASSERT(n == testnodes[i]);
        }

        s = -5;
        r = cx_tree_search(&root, &s, test_tree_search_function,
                           (void **) &n, tree_child_list);
        CX_TEST_ASSERT(r < 0);
        CX_TEST_ASSERT(n == NULL);

        s = 26;
        r = cx_tree_search(&root, &s, test_tree_search_function,
                           (void **) &n, tree_child_list);
        CX_TEST_ASSERT(r > 0);
        CX_TEST_ASSERT(n == &ba);

        s = 35;
        r = cx_tree_search(&root, &s, test_tree_search_function,
                           (void **) &n, tree_child_list);
        CX_TEST_ASSERT(r > 0);
        CX_TEST_ASSERT(n == &cb);

        s = 38;
        r = cx_tree_search(&root, &s, test_tree_search_function,
                           (void **) &n, tree_child_list);
        CX_TEST_ASSERT(r > 0);
        CX_TEST_ASSERT(n == &cba);

        s = 42;
        r = cx_tree_search(&root, &s, test_tree_search_function,
                           (void **) &n, tree_child_list);
        CX_TEST_ASSERT(r > 0);
        CX_TEST_ASSERT(n == &cc);
    }
}

CX_TEST(test_tree_iterator_create) {
    tree_node root;
    CX_TEST_DO {
        CxTreeIterator iter = cx_tree_iterator(&root, false, tree_child_list);
        CX_TEST_ASSERT(!iter.visit_on_exit);
        CX_TEST_ASSERT(!iter.exiting);
        CX_TEST_ASSERT(iter.counter == 1);
        CX_TEST_ASSERT(iter.node == &root);
        CX_TEST_ASSERT(!iter.base.mutating);
        CX_TEST_ASSERT(!iter.base.remove);
        CX_TEST_ASSERT(iter.stack != NULL);
        CX_TEST_ASSERT(iter.stack_capacity > 0);
        CX_TEST_ASSERT(iter.stack_size == 1);
        CX_TEST_ASSERT(iter.depth == 1);
        CX_TEST_ASSERT(iter.loc_next == offsetof(tree_node, next));
        CX_TEST_ASSERT(iter.loc_children == offsetof(tree_node, children));
    }
}

CxTestSuite *cx_test_suite_tree_low_level(void) {
    CxTestSuite *suite = cx_test_suite_new("tree (low level)");

    cx_test_register(suite, test_tree_link_new_child);
    cx_test_register(suite, test_tree_link_add_child);
    cx_test_register(suite, test_tree_link_move_to_other_parent);
    cx_test_register(suite, test_tree_unlink);
    cx_test_register(suite, test_tree_search);
    cx_test_register(suite, test_tree_iterator_create);

    return suite;
}