Mercurial > hg > ucx / file revision

 /*

  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

  *

  * Copyright 2021 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 "test_config.h"

 #include <stddef.h>

 typedef struct TestNode TestNode;

 struct TestNode {

     TestNode *parent;

     TestNode *prev;

     TestNode *next;

     TestNode *children_begin;

     TestNode *children_end;

 };

 void test_cx_tree_add_node(void) {

     // prepare test tree

     TestNode root;

     memset(&root, 0, sizeof(TestNode));

     TestNode a;

     memset(&a, 0, sizeof(TestNode));

     root.children_begin = &a;

     root.children_end = &a;

     a.parent = &root;

     // new test nodes

     TestNode b;

     memset(&b, 0, sizeof(TestNode));

     TestNode c;

     memset(&c, 0, sizeof(TestNode));

     // test

     int ret = cx_tree_add_node(&a, offsetof(TestNode, parent), offsetof(TestNode, prev), offsetof(TestNode, next), &b);

     CU_ASSERT_EQUAL(ret, 0)

     CU_ASSERT_PTR_EQUAL(b.parent, &root)

     CU_ASSERT_PTR_EQUAL(b.prev, &a)

     CU_ASSERT_PTR_NULL(b.next)

     CU_ASSERT_PTR_EQUAL(a.next, &b)

     ret = cx_tree_add_node(&a, -1, -1, offsetof(TestNode, next), &c);

     CU_ASSERT_EQUAL(ret, 0)

     CU_ASSERT_PTR_NULL(c.parent)

     CU_ASSERT_PTR_NULL(c.prev)

     CU_ASSERT_PTR_NULL(c.next)

     CU_ASSERT_PTR_EQUAL(b.next, &c)

 }

 void test_cx_tree_add_child_node(void) {

     // prepare test tree

     TestNode root;

     memset(&root, 0, sizeof(TestNode));

     TestNode a;

     memset(&a, 0, sizeof(TestNode));

     TestNode b;

     memset(&b, 0, sizeof(TestNode));

     TestNode c;

     memset(&c, 0, sizeof(TestNode));

     TestNode a1;

     memset(&a1, 0, sizeof(TestNode));

     int ret;

     // test

     ret = cx_tree_add_child_node(

             &root,

             offsetof(TestNode, parent),

             offsetof(TestNode, prev),

             offsetof(TestNode, next),

             (void**)&root.children_begin,

             (void**)&root.children_end,

             &a);

     CU_ASSERT_EQUAL(ret, 0)

     CU_ASSERT_PTR_EQUAL(root.children_begin, &a)

     CU_ASSERT_PTR_EQUAL(root.children_end, &a)

     CU_ASSERT_PTR_EQUAL(a.parent, &root)

     CU_ASSERT_PTR_NULL(a.prev)

     CU_ASSERT_PTR_NULL(a.next)

     ret = cx_tree_add_child_node(

             &root,

             offsetof(TestNode, parent),

             offsetof(TestNode, prev),

             offsetof(TestNode, next),

             (void**)&root.children_begin,

             (void**)&root.children_end,

             &b);

     CU_ASSERT_EQUAL(ret, 0)

     CU_ASSERT_PTR_NOT_NULL(root.children_begin)

     CU_ASSERT_PTR_EQUAL(root.children_begin->next, &b)

     CU_ASSERT_PTR_EQUAL(root.children_end, &b)

     CU_ASSERT_PTR_EQUAL(b.parent, &root)

     CU_ASSERT_PTR_EQUAL(b.prev, &a)

     ret = cx_tree_add_child_node(

             &root,

             -1,

             -1,

             offsetof(TestNode, next),

             (void**)&root.children_begin,

             NULL,

             &c);

     CU_ASSERT_EQUAL(ret, 0)

     CU_ASSERT_PTR_EQUAL(root.children_end, &b) // children_end unchanged

     CU_ASSERT_PTR_EQUAL(b.next, &c)

     CU_ASSERT_PTR_NULL(c.prev)

     CU_ASSERT_PTR_NULL(c.next)

     CU_ASSERT_PTR_NULL(c.parent)

     ret = cx_tree_add_child_node(

             &a,

             offsetof(TestNode, parent),

             offsetof(TestNode, prev),

             offsetof(TestNode, next),

             (void**)&a.children_begin,

             (void**)&a.children_end,

             &a1);

     CU_ASSERT_EQUAL(ret, 0);

     CU_ASSERT_PTR_EQUAL(a.children_begin, &a1);

     CU_ASSERT_PTR_EQUAL(a1.parent, &a);

     CU_ASSERT_PTR_NOT_NULL(root.children_begin)

     CU_ASSERT_PTR_EQUAL(root.children_begin->children_begin, &a1)

 }

 int main() {

     CU_pSuite suite = NULL;

     if (CUE_SUCCESS != CU_initialize_registry()) {

         return CU_get_error();

     }

     suite = CU_add_suite("tree suite", NULL, NULL);

     CU_add_test(suite, "ll add tree node", test_cx_tree_add_node);

     CU_add_test(suite, "ll add tree child node", test_cx_tree_add_child_node);

     CU_basic_set_mode(UCX_CU_BRM);

     int exitcode;

     if (CU_basic_run_tests()) {

         exitcode = CU_get_error();

     } else {

         exitcode = CU_get_number_of_failures() == 0 ? 0 : 1;

     }

     CU_cleanup_registry();

     return exitcode;

 }