* information regarding copyright ownership.
*/
-/* ! \file */
-
#include <config.h>
-#include <atf-c.h>
+#if HAVE_CMOCKA
+
+#include <stdarg.h>
+#include <stddef.h>
+#include <setjmp.h>
+#include <ctype.h>
#include <fcntl.h>
#include <inttypes.h>
#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
#include <unistd.h>
-#include <isc/mem.h>
-#include <isc/random.h>
-#include <isc/string.h>
-
-#include <dns/rbt.h>
-#include <dns/fixedname.h>
-#include <dns/name.h>
-#include <dns/result.h>
-#include <dns/compress.h>
-#include "dnstest.h"
+#define UNIT_TESTING
+#include <cmocka.h>
#include <isc/app.h>
#include <isc/buffer.h>
#include <isc/file.h>
#include <isc/hash.h>
#include <isc/mem.h>
+#include <isc/mem.h>
#include <isc/os.h>
-#include <isc/string.h>
+#include <isc/print.h>
+#include <isc/random.h>
#include <isc/socket.h>
#include <isc/stdio.h>
+#include <isc/string.h>
+#include <isc/string.h>
#include <isc/task.h>
#include <isc/thread.h>
+#include <isc/time.h>
#include <isc/timer.h>
#include <isc/util.h>
-#include <isc/print.h>
-#include <isc/time.h>
+#include <isc/util.h>
+#include <dns/compress.h>
+#include <dns/fixedname.h>
#include <dns/log.h>
#include <dns/name.h>
+#include <dns/name.h>
+#include <dns/rbt.h>
#include <dns/result.h>
#include <dst/dst.h>
-#include <ctype.h>
-#include <stdlib.h>
-#include <time.h>
+#include "dnstest.h"
typedef struct {
dns_rbt_t *rbt;
static const size_t ordered_names_count = (sizeof(ordered_names) /
sizeof(*ordered_names));
+static int
+_setup(void **state) {
+ isc_result_t result;
+
+ UNUSED(state);
+
+ result = dns_test_begin(NULL, false);
+ assert_int_equal(result, ISC_R_SUCCESS);
+
+ return (0);
+}
+
+static int
+_teardown(void **state) {
+ UNUSED(state);
+
+ dns_test_end();
+
+ return (0);
+}
static void
delete_data(void *data, void *arg) {
UNUSED(arg);
size_t i;
ctx = isc_mem_get(mctx, sizeof(*ctx));
- ATF_REQUIRE(ctx != NULL);
+ assert_non_null(ctx);
ctx->rbt = NULL;
result = dns_rbt_create(mctx, delete_data, NULL, &ctx->rbt);
- ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
ctx->rbt_distances = NULL;
result = dns_rbt_create(mctx, delete_data, NULL, &ctx->rbt_distances);
- ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
for (i = 0; i < domain_names_count; i++) {
size_t *n;
name = dns_fixedname_name(&fname);
n = isc_mem_get(mctx, sizeof(size_t));
- ATF_REQUIRE(n != NULL);
+ assert_non_null(n);
*n = i + 1;
result = dns_rbt_addname(ctx->rbt, name, n);
- ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
n = isc_mem_get(mctx, sizeof(size_t));
- ATF_REQUIRE(n != NULL);
+ assert_non_null(n);
*n = node_distances[i];
result = dns_rbt_addname(ctx->rbt_distances, name, n);
- ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
}
return (ctx);
n = NULL;
result = dns_rbt_findname(rbt, name, 0, foundname,
(void *) &n);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
- ATF_CHECK_EQ(*n, i + 1);
+ assert_int_equal(result, ISC_R_SUCCESS);
+ assert_int_equal(*n, i + 1);
}
}
-ATF_TC(rbt_create);
-ATF_TC_HEAD(rbt_create, tc) {
- atf_tc_set_md_var(tc, "descr", "Test the creation of an rbt");
-}
-ATF_TC_BODY(rbt_create, tc) {
- isc_result_t result;
+/* Test the creation of an rbt */
+static void
+rbt_create(void **state) {
test_context_t *ctx;
bool tree_ok;
- UNUSED(tc);
+ UNUSED(state);
isc_mem_debugging = ISC_MEM_DEBUGRECORD;
- result = dns_test_begin(NULL, true);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
-
ctx = test_context_setup();
check_test_data(ctx->rbt);
tree_ok = dns__rbt_checkproperties(ctx->rbt);
- ATF_CHECK_EQ(tree_ok, true);
+ assert_true(tree_ok);
test_context_teardown(ctx);
-
- dns_test_end();
}
-ATF_TC(rbt_nodecount);
-ATF_TC_HEAD(rbt_nodecount, tc) {
- atf_tc_set_md_var(tc, "descr", "Test dns_rbt_nodecount() on a tree");
-}
-ATF_TC_BODY(rbt_nodecount, tc) {
- isc_result_t result;
+/* Test dns_rbt_nodecount() on a tree */
+static void
+rbt_nodecount(void **state) {
test_context_t *ctx;
- UNUSED(tc);
+ UNUSED(state);
isc_mem_debugging = ISC_MEM_DEBUGRECORD;
- result = dns_test_begin(NULL, true);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
-
ctx = test_context_setup();
- ATF_CHECK_EQ(15, dns_rbt_nodecount(ctx->rbt));
+ assert_int_equal(15, dns_rbt_nodecount(ctx->rbt));
test_context_teardown(ctx);
-
- dns_test_end();
}
-ATF_TC(rbtnode_get_distance);
-ATF_TC_HEAD(rbtnode_get_distance, tc) {
- atf_tc_set_md_var(tc, "descr",
- "Test dns_rbtnode_get_distance() on a tree");
-}
-ATF_TC_BODY(rbtnode_get_distance, tc) {
+/* Test dns_rbtnode_get_distance() on a tree */
+static void
+rbtnode_get_distance(void **state) {
isc_result_t result;
test_context_t *ctx;
const char *name_str = "a";
dns_rbtnode_t *node = NULL;
dns_rbtnodechain_t chain;
- UNUSED(tc);
+ UNUSED(state);
isc_mem_debugging = ISC_MEM_DEBUGRECORD;
- result = dns_test_begin(NULL, true);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
-
ctx = test_context_setup();
dns_test_namefromstring(name_str, &fname);
result = dns_rbt_findnode(ctx->rbt_distances, name, NULL,
&node, &chain, 0, NULL, NULL);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
while (node != NULL) {
const size_t *distance = (const size_t *) node->data;
if (distance != NULL)
- ATF_CHECK_EQ(*distance,
- dns__rbtnode_getdistance(node));
+ assert_int_equal(*distance,
+ dns__rbtnode_getdistance(node));
result = dns_rbtnodechain_next(&chain, NULL, NULL);
if (result == ISC_R_NOMORE)
break;
dns_rbtnodechain_current(&chain, NULL, NULL, &node);
}
- ATF_CHECK_EQ(result, ISC_R_NOMORE);
+ assert_int_equal(result, ISC_R_NOMORE);
dns_rbtnodechain_invalidate(&chain);
test_context_teardown(ctx);
-
- dns_test_end();
}
-ATF_TC(rbt_check_distance_random);
-ATF_TC_HEAD(rbt_check_distance_random, tc) {
- atf_tc_set_md_var(tc, "descr",
- "Test tree balance, inserting names in random order");
-}
-ATF_TC_BODY(rbt_check_distance_random, tc) {
- /* This test checks an important performance-related property of
- * the red-black tree, which is important for us: the longest
- * path from a sub-tree's root to a node is no more than
- * 2log(n). This check verifies that the tree is balanced.
- */
+/*
+ * Test tree balance, inserting names in random order.
+ *
+ * This test checks an important performance-related property of
+ * the red-black tree, which is important for us: the longest
+ * path from a sub-tree's root to a node is no more than
+ * 2log(n). This check verifies that the tree is balanced.
+ */
+static void
+rbt_check_distance_random(void **state) {
dns_rbt_t *mytree = NULL;
const unsigned int log_num_nodes = 16;
-
- int i;
isc_result_t result;
bool tree_ok;
+ int i;
- UNUSED(tc);
+ UNUSED(state);
isc_mem_debugging = ISC_MEM_DEBUGRECORD;
- result = dns_test_begin(NULL, true);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
-
result = dns_rbt_create(mctx, delete_data, NULL, &mytree);
- ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
/* Names are inserted in random order. */
char namebuf[34];
n = isc_mem_get(mctx, sizeof(size_t));
- ATF_REQUIRE(n != NULL);
+ assert_non_null(n);
*n = i + 1;
while (1) {
}
/* 1 (root . node) + (1 << log_num_nodes) */
- ATF_CHECK_EQ(1U + (1U << log_num_nodes), dns_rbt_nodecount(mytree));
+ assert_int_equal(1U + (1U << log_num_nodes),
+ dns_rbt_nodecount(mytree));
/* The distance from each node to its sub-tree root must be less
* than 2 * log(n).
*/
- ATF_CHECK((2U * log_num_nodes) >= dns__rbt_getheight(mytree));
+ assert_true((2U * log_num_nodes) >= dns__rbt_getheight(mytree));
/* Also check RB tree properties */
tree_ok = dns__rbt_checkproperties(mytree);
- ATF_CHECK_EQ(tree_ok, true);
+ assert_true(tree_ok);
dns_rbt_destroy(&mytree);
-
- dns_test_end();
}
-ATF_TC(rbt_check_distance_ordered);
-ATF_TC_HEAD(rbt_check_distance_ordered, tc) {
- atf_tc_set_md_var(tc, "descr",
- "Test tree balance, inserting names in sorted order");
-}
-ATF_TC_BODY(rbt_check_distance_ordered, tc) {
- /* This test checks an important performance-related property of
- * the red-black tree, which is important for us: the longest
- * path from a sub-tree's root to a node is no more than
- * 2log(n). This check verifies that the tree is balanced.
- */
+/*
+ * Test tree balance, inserting names in sorted order.
+ *
+ * This test checks an important performance-related property of
+ * the red-black tree, which is important for us: the longest
+ * path from a sub-tree's root to a node is no more than
+ * 2log(n). This check verifies that the tree is balanced.
+ */
+static void
+rbt_check_distance_ordered(void **state) {
dns_rbt_t *mytree = NULL;
const unsigned int log_num_nodes = 16;
-
- int i;
isc_result_t result;
bool tree_ok;
+ int i;
- UNUSED(tc);
+ UNUSED(state);
isc_mem_debugging = ISC_MEM_DEBUGRECORD;
- result = dns_test_begin(NULL, true);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
-
result = dns_rbt_create(mctx, delete_data, NULL, &mytree);
- ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
/* Names are inserted in sorted order. */
dns_name_t *name;
n = isc_mem_get(mctx, sizeof(size_t));
- ATF_REQUIRE(n != NULL);
+ assert_non_null(n);
*n = i + 1;
snprintf(namebuf, sizeof(namebuf), "name%08x.", i);
name = dns_fixedname_name(&fname);
result = dns_rbt_addname(mytree, name, n);
- ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
}
/* 1 (root . node) + (1 << log_num_nodes) */
- ATF_CHECK_EQ(1U + (1U << log_num_nodes), dns_rbt_nodecount(mytree));
+ assert_int_equal(1U + (1U << log_num_nodes),
+ dns_rbt_nodecount(mytree));
/* The distance from each node to its sub-tree root must be less
* than 2 * log(n).
*/
- ATF_CHECK((2U * log_num_nodes) >= dns__rbt_getheight(mytree));
+ assert_true((2U * log_num_nodes) >= dns__rbt_getheight(mytree));
/* Also check RB tree properties */
tree_ok = dns__rbt_checkproperties(mytree);
- ATF_CHECK_EQ(tree_ok, true);
+ assert_true(tree_ok);
dns_rbt_destroy(&mytree);
-
- dns_test_end();
}
static isc_result_t
dns_rbt_namefromnode(node, &name);
result = dns_name_tostring(&name, &nodestr, mctx);
- ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
is_equal = strcmp(labelstr, nodestr) == 0 ? true : false;
return (is_equal);
}
-ATF_TC(rbt_insert);
-ATF_TC_HEAD(rbt_insert, tc) {
- atf_tc_set_md_var(tc, "descr", "Test insertion into a tree");
-}
-ATF_TC_BODY(rbt_insert, tc) {
+/* Test insertion into a tree */
+static void
+rbt_insert(void **state) {
isc_result_t result;
test_context_t *ctx;
dns_rbtnode_t *node;
- UNUSED(tc);
+ UNUSED(state);
isc_mem_debugging = ISC_MEM_DEBUGRECORD;
- result = dns_test_begin(NULL, true);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
-
ctx = test_context_setup();
/* Check node count before beginning. */
- ATF_CHECK_EQ(15, dns_rbt_nodecount(ctx->rbt));
+ assert_int_equal(15, dns_rbt_nodecount(ctx->rbt));
/* Try to insert a node that already exists. */
node = NULL;
result = insert_helper(ctx->rbt, "d.e.f", &node);
- ATF_CHECK_EQ(result, ISC_R_EXISTS);
+ assert_int_equal(result, ISC_R_EXISTS);
/* Node count must not have changed. */
- ATF_CHECK_EQ(15, dns_rbt_nodecount(ctx->rbt));
+ assert_int_equal(15, dns_rbt_nodecount(ctx->rbt));
/* Try to insert a node that doesn't exist. */
node = NULL;
result = insert_helper(ctx->rbt, "0", &node);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
- ATF_CHECK_EQ(compare_labelsequences(node, "0"), true);
+ assert_int_equal(result, ISC_R_SUCCESS);
+ assert_true(compare_labelsequences(node, "0"));
/* Node count must have increased. */
- ATF_CHECK_EQ(16, dns_rbt_nodecount(ctx->rbt));
+ assert_int_equal(16, dns_rbt_nodecount(ctx->rbt));
/* Another. */
node = NULL;
result = insert_helper(ctx->rbt, "example.com", &node);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
- ATF_REQUIRE(node != NULL);
- ATF_CHECK_EQ(node->data, NULL);
+ assert_int_equal(result, ISC_R_SUCCESS);
+ assert_non_null(node);
+ assert_null(node->data);
/* Node count must have increased. */
- ATF_CHECK_EQ(17, dns_rbt_nodecount(ctx->rbt));
+ assert_int_equal(17, dns_rbt_nodecount(ctx->rbt));
/* Re-adding it should return EXISTS */
node = NULL;
result = insert_helper(ctx->rbt, "example.com", &node);
- ATF_CHECK_EQ(result, ISC_R_EXISTS);
+ assert_int_equal(result, ISC_R_EXISTS);
/* Node count must not have changed. */
- ATF_CHECK_EQ(17, dns_rbt_nodecount(ctx->rbt));
+ assert_int_equal(17, dns_rbt_nodecount(ctx->rbt));
/* Fission the node d.e.f */
node = NULL;
result = insert_helper(ctx->rbt, "k.e.f", &node);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
- ATF_CHECK_EQ(compare_labelsequences(node, "k"), true);
+ assert_int_equal(result, ISC_R_SUCCESS);
+ assert_true(compare_labelsequences(node, "k"));
/* Node count must have incremented twice ("d.e.f" fissioned to
* "d" and "e.f", and the newly added "k").
*/
- ATF_CHECK_EQ(19, dns_rbt_nodecount(ctx->rbt));
+ assert_int_equal(19, dns_rbt_nodecount(ctx->rbt));
/* Fission the node "g.h" */
node = NULL;
result = insert_helper(ctx->rbt, "h", &node);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
- ATF_CHECK_EQ(compare_labelsequences(node, "h"), true);
+ assert_int_equal(result, ISC_R_SUCCESS);
+ assert_true(compare_labelsequences(node, "h"));
/* Node count must have incremented ("g.h" fissioned to "g" and
* "h").
*/
- ATF_CHECK_EQ(20, dns_rbt_nodecount(ctx->rbt));
+ assert_int_equal(20, dns_rbt_nodecount(ctx->rbt));
/* Add child domains */
node = NULL;
result = insert_helper(ctx->rbt, "m.p.w.y.d.e.f", &node);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
- ATF_CHECK_EQ(compare_labelsequences(node, "m"), true);
- ATF_CHECK_EQ(21, dns_rbt_nodecount(ctx->rbt));
+ assert_int_equal(result, ISC_R_SUCCESS);
+ assert_true(compare_labelsequences(node, "m"));
+ assert_int_equal(21, dns_rbt_nodecount(ctx->rbt));
node = NULL;
result = insert_helper(ctx->rbt, "n.p.w.y.d.e.f", &node);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
- ATF_CHECK_EQ(compare_labelsequences(node, "n"), true);
- ATF_CHECK_EQ(22, dns_rbt_nodecount(ctx->rbt));
+ assert_int_equal(result, ISC_R_SUCCESS);
+ assert_true(compare_labelsequences(node, "n"));
+ assert_int_equal(22, dns_rbt_nodecount(ctx->rbt));
node = NULL;
result = insert_helper(ctx->rbt, "l.a", &node);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
- ATF_CHECK_EQ(compare_labelsequences(node, "l"), true);
- ATF_CHECK_EQ(23, dns_rbt_nodecount(ctx->rbt));
+ assert_int_equal(result, ISC_R_SUCCESS);
+ assert_true(compare_labelsequences(node, "l"));
+ assert_int_equal(23, dns_rbt_nodecount(ctx->rbt));
node = NULL;
result = insert_helper(ctx->rbt, "r.d.e.f", &node);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
node = NULL;
result = insert_helper(ctx->rbt, "s.d.e.f", &node);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
- ATF_CHECK_EQ(25, dns_rbt_nodecount(ctx->rbt));
+ assert_int_equal(result, ISC_R_SUCCESS);
+ assert_int_equal(25, dns_rbt_nodecount(ctx->rbt));
node = NULL;
result = insert_helper(ctx->rbt, "h.w.y.d.e.f", &node);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
/* Add more nodes one by one to cover left and right rotation
* functions.
*/
node = NULL;
result = insert_helper(ctx->rbt, "f", &node);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
node = NULL;
result = insert_helper(ctx->rbt, "m", &node);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
node = NULL;
result = insert_helper(ctx->rbt, "nm", &node);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
node = NULL;
result = insert_helper(ctx->rbt, "om", &node);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
node = NULL;
result = insert_helper(ctx->rbt, "k", &node);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
node = NULL;
result = insert_helper(ctx->rbt, "l", &node);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
node = NULL;
result = insert_helper(ctx->rbt, "fe", &node);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
node = NULL;
result = insert_helper(ctx->rbt, "ge", &node);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
node = NULL;
result = insert_helper(ctx->rbt, "i", &node);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
node = NULL;
result = insert_helper(ctx->rbt, "ae", &node);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
node = NULL;
result = insert_helper(ctx->rbt, "n", &node);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
test_context_teardown(ctx);
-
- dns_test_end();
}
-ATF_TC(rbt_remove);
-ATF_TC_HEAD(rbt_remove, tc) {
- atf_tc_set_md_var(tc, "descr", "Test removal from a tree");
-}
-ATF_TC_BODY(rbt_remove, tc) {
- /*
- * This testcase checks that after node removal, the
- * binary-search tree is valid and all nodes that are supposed
- * to exist are present in the correct order. It mainly tests
- * DomainTree as a BST, and not particularly as a red-black
- * tree. This test checks node deletion when upper nodes have
- * data.
- */
- isc_result_t result;
- size_t j;
+/*
+ * Test removal from a tree
+ *
+ * This testcase checks that after node removal, the binary-search tree is
+ * valid and all nodes that are supposed to exist are present in the
+ * correct order. It mainly tests DomainTree as a BST, and not particularly
+ * as a red-black tree. This test checks node deletion when upper nodes
+ * have data.
+ */
+static void
+rbt_remove(void **state) {
+ isc_result_t result; size_t j;
- UNUSED(tc);
+ UNUSED(state);
isc_mem_debugging = ISC_MEM_DEBUGRECORD;
- result = dns_test_begin(NULL, true);
- ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
-
/*
* Delete single nodes and check if the rest of the nodes exist.
*/
/* Create a tree. */
result = dns_rbt_create(mctx, delete_data, NULL, &mytree);
- ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
/* Insert test data into the tree. */
for (i = 0; i < domain_names_count; i++) {
node = NULL;
result = insert_helper(mytree, domain_names[i], &node);
- ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
}
/* Check that all names exist in order. */
&node, NULL,
DNS_RBTFIND_EMPTYDATA,
NULL, NULL);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
/* Add node data */
- ATF_REQUIRE(node != NULL);
- ATF_REQUIRE_EQ(node->data, NULL);
+ assert_non_null(node);
+ assert_null(node->data);
n = isc_mem_get(mctx, sizeof(size_t));
- ATF_REQUIRE(n != NULL);
+ assert_non_null(n);
*n = i;
node->data = n;
name = dns_fixedname_name(&fname);
result = dns_rbt_deletename(mytree, name, false);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
}
/* Check RB tree properties. */
tree_ok = dns__rbt_checkproperties(mytree);
- ATF_CHECK_EQ(tree_ok, true);
+ assert_true(tree_ok);
dns_rbtnodechain_init(&chain, mctx);
&node, NULL,
0,
NULL, NULL);
- ATF_CHECK_EQ(result, ISC_R_NOTFOUND);
+ assert_int_equal(result, ISC_R_NOTFOUND);
dns_test_namefromstring(ordered_names[1], &fname);
name = dns_fixedname_name(&fname);
&node, &chain,
0,
NULL, NULL);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
start_node = 1;
} else {
/* Start from node 0. */
&node, &chain,
0,
NULL, NULL);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
start_node = 0;
}
continue;
}
- ATF_REQUIRE(node != NULL);
+ assert_non_null(node);
n = (size_t *) node->data;
if (n != NULL) {
/* printf("n=%zu, i=%zu\n", *n, i); */
- ATF_CHECK_EQ(*n, i);
+ assert_int_equal(*n, i);
}
result = dns_rbtnodechain_next(&chain, NULL, NULL);
}
/* We should have reached the end of the tree. */
- ATF_REQUIRE_EQ(node, NULL);
+ assert_null(node);
dns_rbt_destroy(&mytree);
}
-
- dns_test_end();
}
static void
char namebuf[34];
n = isc_mem_get(mctx, sizeof(size_t));
- ATF_REQUIRE(n != NULL);
+ assert_non_null(n);
*n = i; /* Unused value */
node->data = n;
names[*names_count] = isc_mem_strdup(mctx,
namebuf);
- ATF_REQUIRE(names[*names_count] != NULL);
+ assert_non_null(names[*names_count]);
*names_count += 1;
break;
}
name = dns_fixedname_name(&fname);
result = dns_rbt_deletename(mytree, name, false);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
isc_mem_free(mctx, names[node]);
if (*names_count > 0) {
}
static void
-check_tree(dns_rbt_t *mytree, char **names, size_t names_count,
- unsigned int line)
-{
+check_tree(dns_rbt_t *mytree, char **names, size_t names_count) {
bool tree_ok;
UNUSED(names);
- ATF_CHECK_EQ_MSG(names_count + 1, dns_rbt_nodecount(mytree),
- "line:%u: %lu != %u", line,
- (unsigned long)(names_count + 1),
- dns_rbt_nodecount(mytree));
+ assert_int_equal(names_count + 1, dns_rbt_nodecount(mytree));
/*
* The distance from each node to its sub-tree root must be less
* than 2 * log_2(1024).
*/
- ATF_CHECK((2 * 10) >= dns__rbt_getheight(mytree));
+ assert_true((2 * 10) >= dns__rbt_getheight(mytree));
/* Also check RB tree properties */
tree_ok = dns__rbt_checkproperties(mytree);
- ATF_CHECK_EQ(tree_ok, true);
+ assert_true(tree_ok);
}
-ATF_TC(rbt_insert_and_remove);
-ATF_TC_HEAD(rbt_insert_and_remove, tc) {
- atf_tc_set_md_var(tc, "descr",
- "Test insert and remove in a loop");
-}
-ATF_TC_BODY(rbt_insert_and_remove, tc) {
- /*
- * What is the best way to test our red-black tree code? It is
- * not a good method to test every case handled in the actual
- * code itself. This is because our approach itself may be
- * incorrect.
- *
- * We test our code at the interface level here by exercising the
- * tree randomly multiple times, checking that red-black tree
- * properties are valid, and all the nodes that are supposed to be
- * in the tree exist and are in order.
- *
- * NOTE: These tests are run within a single tree level in the
- * forest. The number of nodes in the tree level doesn't grow
- * over 1024.
- */
+/*
+ * Test insert and remove in a loop.
+ *
+ * What is the best way to test our red-black tree code? It is
+ * not a good method to test every case handled in the actual
+ * code itself. This is because our approach itself may be
+ * incorrect.
+ *
+ * We test our code at the interface level here by exercising the
+ * tree randomly multiple times, checking that red-black tree
+ * properties are valid, and all the nodes that are supposed to be
+ * in the tree exist and are in order.
+ *
+ * NOTE: These tests are run within a single tree level in the
+ * forest. The number of nodes in the tree level doesn't grow
+ * over 1024.
+ */
+static void
+rbt_insert_and_remove(void **state) {
isc_result_t result;
dns_rbt_t *mytree = NULL;
size_t *n;
- /*
- * We use an array for storing names instead of a set
- * structure. It's slow, but works and is good enough for tests.
- */
char *names[1024];
size_t names_count;
int i;
- UNUSED(tc);
+ UNUSED(state);
isc_mem_debugging = ISC_MEM_DEBUGRECORD;
- result = dns_test_begin(NULL, true);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
-
result = dns_rbt_create(mctx, delete_data, NULL, &mytree);
- ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
n = isc_mem_get(mctx, sizeof(size_t));
- ATF_REQUIRE(n != NULL);
+ assert_non_null(n);
result = dns_rbt_addname(mytree, dns_rootname, n);
- ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
memset(names, 0, sizeof(names));
names_count = 0;
}
insert_nodes(mytree, names, &names_count, num_names);
- check_tree(mytree, names, names_count, __LINE__);
+ check_tree(mytree, names, names_count);
if (names_count > 0) {
num_names = isc_random_uniform(names_count);
}
remove_nodes(mytree, names, &names_count, num_names);
- check_tree(mytree, names, names_count, __LINE__);
+ check_tree(mytree, names, names_count);
}
/* Remove the rest of the nodes */
remove_nodes(mytree, names, &names_count, names_count);
- check_tree(mytree, names, names_count, __LINE__);
+ check_tree(mytree, names, names_count);
for (i = 0; i < 1024; i++) {
if (names[i] != NULL) {
}
result = dns_rbt_deletename(mytree, dns_rootname, false);
- ATF_CHECK_EQ_MSG(result, ISC_R_SUCCESS,
- "result: %s", isc_result_totext(result));
- ATF_CHECK_EQ_MSG(dns_rbt_nodecount(mytree), 0,
- "%u != 0", dns_rbt_nodecount(mytree));
+ assert_int_equal(result, ISC_R_SUCCESS);
+ assert_int_equal(dns_rbt_nodecount(mytree), 0);
dns_rbt_destroy(&mytree);
-
- dns_test_end();
}
-ATF_TC(rbt_findname);
-ATF_TC_HEAD(rbt_findname, tc) {
- atf_tc_set_md_var(tc, "descr", "findname return values");
-}
-ATF_TC_BODY(rbt_findname, tc) {
+/* Test findname return values */
+static void
+rbt_findname(void **state) {
isc_result_t result;
test_context_t *ctx = NULL;
dns_fixedname_t fname, found;
dns_name_t *name = NULL, *foundname = NULL;
size_t *n = NULL;
- UNUSED(tc);
+ UNUSED(state);
isc_mem_debugging = ISC_MEM_DEBUGRECORD;
- result = dns_test_begin(NULL, true);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
-
ctx = test_context_setup();
/* Try to find a name that exists. */
result = dns_rbt_findname(ctx->rbt, name,
DNS_RBTFIND_EMPTYDATA,
foundname, (void *) &n);
- ATF_CHECK(dns_name_equal(foundname, name));
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
+ assert_true(dns_name_equal(foundname, name));
+ assert_int_equal(result, ISC_R_SUCCESS);
/* Now without EMPTYDATA */
result = dns_rbt_findname(ctx->rbt, name, 0,
foundname, (void *) &n);
- ATF_CHECK_EQ(result, ISC_R_NOTFOUND);
+ assert_int_equal(result, ISC_R_NOTFOUND);
/* Now one that partially matches */
dns_test_namefromstring("d.e.f.g.h.i.j", &fname);
result = dns_rbt_findname(ctx->rbt, name,
DNS_RBTFIND_EMPTYDATA,
foundname, (void *) &n);
- ATF_CHECK_EQ(result, DNS_R_PARTIALMATCH);
+ assert_int_equal(result, DNS_R_PARTIALMATCH);
/* Now one that doesn't match */
dns_test_namefromstring("1.2", &fname);
result = dns_rbt_findname(ctx->rbt, name,
DNS_RBTFIND_EMPTYDATA,
foundname, (void *) &n);
- ATF_CHECK_EQ(result, DNS_R_PARTIALMATCH);
- ATF_CHECK(dns_name_equal(foundname, dns_rootname));
+ assert_int_equal(result, DNS_R_PARTIALMATCH);
+ assert_true(dns_name_equal(foundname, dns_rootname));
test_context_teardown(ctx);
-
- dns_test_end();
}
-ATF_TC(rbt_addname);
-ATF_TC_HEAD(rbt_addname, tc) {
- atf_tc_set_md_var(tc, "descr", "addname return values");
-}
-ATF_TC_BODY(rbt_addname, tc) {
+/* Test addname return values */
+static void
+rbt_addname(void **state) {
isc_result_t result;
test_context_t *ctx = NULL;
dns_fixedname_t fname;
dns_name_t *name = NULL;
size_t *n;
- UNUSED(tc);
+ UNUSED(state);
isc_mem_debugging = ISC_MEM_DEBUGRECORD;
- result = dns_test_begin(NULL, true);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
-
ctx = test_context_setup();
n = isc_mem_get(mctx, sizeof(size_t));
- ATF_REQUIRE(n != NULL);
+ assert_non_null(n);
*n = 1;
dns_test_namefromstring("d.e.f.g.h.i.j.k", &fname);
/* Add a name that doesn't exist */
result = dns_rbt_addname(ctx->rbt, name, n);
- ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
/* Now add again, should get ISC_R_EXISTS */
n = isc_mem_get(mctx, sizeof(size_t));
- ATF_REQUIRE(n != NULL);
+ assert_non_null(n);
*n = 2;
result = dns_rbt_addname(ctx->rbt, name, n);
- ATF_REQUIRE_EQ(result, ISC_R_EXISTS);
+ assert_int_equal(result, ISC_R_EXISTS);
isc_mem_put(mctx, n, sizeof(size_t));
test_context_teardown(ctx);
-
- dns_test_end();
}
-ATF_TC(rbt_deletename);
-ATF_TC_HEAD(rbt_deletename, tc) {
- atf_tc_set_md_var(tc, "descr", "deletename return values");
-}
-ATF_TC_BODY(rbt_deletename, tc) {
+/* Test deletename return values */
+static void
+rbt_deletename(void **state) {
isc_result_t result;
test_context_t *ctx = NULL;
dns_fixedname_t fname;
dns_name_t *name = NULL;
- UNUSED(tc);
+ UNUSED(state);
isc_mem_debugging = ISC_MEM_DEBUGRECORD;
- result = dns_test_begin(NULL, true);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
-
ctx = test_context_setup();
/* Delete a name that doesn't exist */
dns_test_namefromstring("z.x.y.w", &fname);
name = dns_fixedname_name(&fname);
result = dns_rbt_deletename(ctx->rbt, name, false);
- ATF_REQUIRE_EQ(result, ISC_R_NOTFOUND);
+ assert_int_equal(result, ISC_R_NOTFOUND);
/* Now one that does */
dns_test_namefromstring("d.e.f", &fname);
name = dns_fixedname_name(&fname);
result = dns_rbt_deletename(ctx->rbt, name, false);
- ATF_REQUIRE_EQ(result, ISC_R_NOTFOUND);
+ assert_int_equal(result, ISC_R_NOTFOUND);
test_context_teardown(ctx);
-
- dns_test_end();
}
-ATF_TC(rbt_nodechain);
-ATF_TC_HEAD(rbt_nodechain, tc) {
- atf_tc_set_md_var(tc, "descr", "nodechain");
-}
-ATF_TC_BODY(rbt_nodechain, tc) {
+/* Test nodechain */
+static void
+rbt_nodechain(void **state) {
isc_result_t result;
test_context_t *ctx;
dns_fixedname_t fname, found, expect;
dns_rbtnode_t *node = NULL;
dns_rbtnodechain_t chain;
- UNUSED(tc);
+ UNUSED(state);
isc_mem_debugging = ISC_MEM_DEBUGRECORD;
- result = dns_test_begin(NULL, true);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
-
ctx = test_context_setup();
dns_rbtnodechain_init(&chain, mctx);
result = dns_rbt_findnode(ctx->rbt, name, NULL,
&node, &chain, 0, NULL, NULL);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
foundname = dns_fixedname_initname(&found);
UNUSED(expected);
result = dns_rbtnodechain_first(&chain, ctx->rbt, foundname, NULL);
- ATF_CHECK_EQ(result, DNS_R_NEWORIGIN);
- ATF_CHECK_EQ(dns_name_countlabels(foundname), 0);
+ assert_int_equal(result, DNS_R_NEWORIGIN);
+ assert_int_equal(dns_name_countlabels(foundname), 0);
result = dns_rbtnodechain_prev(&chain, NULL, NULL);
- ATF_CHECK_EQ(result, ISC_R_NOMORE);
+ assert_int_equal(result, ISC_R_NOMORE);
result = dns_rbtnodechain_next(&chain, NULL, NULL);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
result = dns_rbtnodechain_next(&chain, NULL, NULL);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
result = dns_rbtnodechain_last(&chain, ctx->rbt, NULL, NULL);
- ATF_CHECK_EQ(result, DNS_R_NEWORIGIN);
+ assert_int_equal(result, DNS_R_NEWORIGIN);
result = dns_rbtnodechain_next(&chain, NULL, NULL);
- ATF_CHECK_EQ(result, ISC_R_NOMORE);
+ assert_int_equal(result, ISC_R_NOMORE);
result = dns_rbtnodechain_last(&chain, ctx->rbt, NULL, NULL);
- ATF_CHECK_EQ(result, DNS_R_NEWORIGIN);
+ assert_int_equal(result, DNS_R_NEWORIGIN);
result = dns_rbtnodechain_prev(&chain, NULL, NULL);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
dns_rbtnodechain_invalidate(&chain);
test_context_teardown(ctx);
-
- dns_test_end();
}
#ifdef DNS_BENCHMARK_TESTS
* RBT, but we don't require it as part of the unit test runs.
*/
-ATF_TC(benchmark);
-ATF_TC_HEAD(benchmark, tc) {
- atf_tc_set_md_var(tc, "descr", "Benchmark RBT implementation");
-}
-
static dns_fixedname_t *fnames;
static dns_name_t **names;
static int *values;
&node, NULL,
DNS_RBTFIND_EMPTYDATA,
NULL, NULL);
- ATF_CHECK_EQ(result, ISC_R_SUCCESS);
- ATF_REQUIRE(node != NULL);
- ATF_CHECK_EQ(values[i], (intptr_t) node->data);
+ assert_int_equal(result, ISC_R_SUCCESS);
+ assert_non_null(node);
+ assert_int_equal(values[i], (intptr_t) node->data);
}
}
return (NULL);
}
-ATF_TC_BODY(benchmark, tc) {
+/* Benchmark RBT implementation */
+static void
+benchmark(void **state) {
isc_result_t result;
char namestr[sizeof("name18446744073709551616.example.org.")];
unsigned int r;
unsigned int nthreads;
isc_thread_t threads[32];
- UNUSED(tc);
+ UNUSED(state);
srandom(time(NULL));
debug_mem_record = false;
- result = dns_test_begin(NULL, true);
- ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
-
fnames = (dns_fixedname_t *) malloc(4000000 * sizeof(dns_fixedname_t));
names = (dns_name_t **) malloc(4000000 * sizeof(dns_name_t *));
values = (int *) malloc(4000000 * sizeof(int));
/* Create a tree. */
mytree = NULL;
result = dns_rbt_create(mctx, NULL, NULL, &mytree);
- ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
/* Insert test data into the tree. */
for (i = 0; i < maxvalue; i++) {
snprintf(namestr, sizeof(namestr), "name%u.example.org.", i);
node = NULL;
result = insert_helper(mytree, namestr, &node);
- ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
node->data = (void *) (intptr_t) i;
}
result = isc_time_now(&ts1);
- ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
nthreads = ISC_MIN(isc_os_ncpus(), 32);
nthreads = ISC_MAX(nthreads, 1);
for (i = 0; i < nthreads; i++) {
result = isc_thread_create(find_thread, mytree, &threads[i]);
- ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
}
for (i = 0; i < nthreads; i++) {
result = isc_thread_join(threads[i], NULL);
- ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
}
result = isc_time_now(&ts2);
- ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+ assert_int_equal(result, ISC_R_SUCCESS);
t = isc_time_microdiff(&ts2, &ts1);
free(fnames);
dns_rbt_destroy(&mytree);
-
- dns_test_end();
}
-
#endif /* DNS_BENCHMARK_TESTS */
-/*
- * Main
- */
-ATF_TP_ADD_TCS(tp) {
- ATF_TP_ADD_TC(tp, rbt_create);
- ATF_TP_ADD_TC(tp, rbt_nodecount);
- ATF_TP_ADD_TC(tp, rbtnode_get_distance);
- ATF_TP_ADD_TC(tp, rbt_check_distance_random);
- ATF_TP_ADD_TC(tp, rbt_check_distance_ordered);
- ATF_TP_ADD_TC(tp, rbt_insert);
- ATF_TP_ADD_TC(tp, rbt_remove);
- ATF_TP_ADD_TC(tp, rbt_insert_and_remove);
- ATF_TP_ADD_TC(tp, rbt_findname);
- ATF_TP_ADD_TC(tp, rbt_addname);
- ATF_TP_ADD_TC(tp, rbt_deletename);
- ATF_TP_ADD_TC(tp, rbt_nodechain);
+int
+main(void) {
+ const struct CMUnitTest tests[] = {
+ cmocka_unit_test_setup_teardown(rbt_create, _setup, _teardown),
+ cmocka_unit_test_setup_teardown(rbt_nodecount,
+ _setup, _teardown),
+ cmocka_unit_test_setup_teardown(rbtnode_get_distance,
+ _setup, _teardown),
+ cmocka_unit_test_setup_teardown(rbt_check_distance_random,
+ _setup, _teardown),
+ cmocka_unit_test_setup_teardown(rbt_check_distance_ordered,
+ _setup, _teardown),
+ cmocka_unit_test_setup_teardown(rbt_insert, _setup, _teardown),
+ cmocka_unit_test_setup_teardown(rbt_remove, _setup, _teardown),
+ cmocka_unit_test_setup_teardown(rbt_insert_and_remove,
+ _setup, _teardown),
+ cmocka_unit_test_setup_teardown(rbt_findname,
+ _setup, _teardown),
+ cmocka_unit_test_setup_teardown(rbt_addname, _setup, _teardown),
+ cmocka_unit_test_setup_teardown(rbt_deletename,
+ _setup, _teardown),
+ cmocka_unit_test_setup_teardown(rbt_nodechain,
+ _setup, _teardown),
#ifdef DNS_BENCHMARK_TESTS
- ATF_TP_ADD_TC(tp, benchmark);
+ cmocka_unit_test_setup_teardown(benchmark, _setup, _teardown),
#endif /* DNS_BENCHMARK_TESTS */
+ };
- return (atf_no_error());
+ return (cmocka_run_group_tests(tests, NULL, NULL));
}
+
+#else /* HAVE_CMOCKA */
+
+#include <stdio.h>
+
+int
+main(void) {
+ printf("1..0 # Skipped: cmocka not available\n");
+ return (0);
+}
+
+#endif
projects / thirdparty / bind9.git / commitdiff
