From: Evan Hunt Date: Thu, 25 Oct 2018 05:12:06 +0000 (-0700) Subject: convert rbt_test X-Git-Tag: v9.13.4~21^2~23 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=55465517c70c1c1ea8bd29e0aaee08e7ba7493d2;p=thirdparty%2Fbind9.git convert rbt_test --- diff --git a/lib/dns/tests/Kyuafile b/lib/dns/tests/Kyuafile index dc1b395919a..214cf34f278 100644 --- a/lib/dns/tests/Kyuafile +++ b/lib/dns/tests/Kyuafile @@ -18,7 +18,7 @@ tap_test_program{name='nsec3_test'} tap_test_program{name='peer_test'} atf_test_program{name='private_test'} atf_test_program{name='rbt_serialize_test', is_exclusive=true} -atf_test_program{name='rbt_test'} +tap_test_program{name='rbt_test'} atf_test_program{name='rdata_test'} tap_test_program{name='rdataset_test'} tap_test_program{name='rdatasetstats_test'} diff --git a/lib/dns/tests/Makefile.in b/lib/dns/tests/Makefile.in index e220d96da34..38b5204daca 100644 --- a/lib/dns/tests/Makefile.in +++ b/lib/dns/tests/Makefile.in @@ -191,9 +191,9 @@ rbt_serialize_test@EXEEXT@: rbt_serialize_test.@O@ dnstest.@O@ ${ISCDEPLIBS} ${D ${ISCLIBS} ${LIBS} rbt_test@EXEEXT@: rbt_test.@O@ dnstest.@O@ ${ISCDEPLIBS} ${DNSDEPLIBS} - ${LIBTOOL_MODE_LINK} ${PURIFY} ${CC} ${CFLAGS} ${LDFLAGS} -o $@ \ - rbt_test.@O@ dnstest.@O@ ${DNSLIBS} \ - ${ISCLIBS} ${LIBS} + ${LIBTOOL_MODE_LINK} ${PURIFY} ${CC} ${CFLAGS} ${CMOCKA_CFLAGS} \ + ${LDFLAGS} -o $@ rbt_test.@O@ dnstest.@O@ \ + ${DNSLIBS} ${ISCLIBS} ${LIBS} ${CMOCKA_LIBS} rdata_test@EXEEXT@: rdata_test.@O@ dnstest.@O@ ${ISCDEPLIBS} ${DNSDEPLIBS} ${LIBTOOL_MODE_LINK} ${PURIFY} ${CC} ${CFLAGS} ${LDFLAGS} -o $@ \ diff --git a/lib/dns/tests/rbt_test.c b/lib/dns/tests/rbt_test.c index 5881c40976f..85a993367e8 100644 --- a/lib/dns/tests/rbt_test.c +++ b/lib/dns/tests/rbt_test.c @@ -9,53 +9,57 @@ * information regarding copyright ownership. */ -/* ! \file */ - #include -#include +#if HAVE_CMOCKA + +#include +#include +#include +#include #include #include #include +#include +#include +#include #include -#include -#include -#include - -#include -#include -#include -#include -#include -#include "dnstest.h" +#define UNIT_TESTING +#include #include #include #include #include #include +#include #include -#include +#include +#include #include #include +#include +#include #include #include +#include #include #include -#include -#include +#include +#include +#include #include #include +#include +#include #include #include -#include -#include -#include +#include "dnstest.h" typedef struct { dns_rbt_t *rbt; @@ -128,6 +132,26 @@ static const char * const ordered_names[] = { 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); @@ -142,15 +166,15 @@ test_context_setup(void) { 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; @@ -162,16 +186,16 @@ test_context_setup(void) { 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); @@ -208,69 +232,50 @@ check_test_data(dns_rbt_t *rbt) { 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"; @@ -279,13 +284,10 @@ ATF_TC_BODY(rbtnode_get_distance, tc) { 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); @@ -295,55 +297,48 @@ ATF_TC_BODY(rbtnode_get_distance, tc) { 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. */ @@ -360,7 +355,7 @@ ATF_TC_BODY(rbt_check_distance_random, tc) { char namebuf[34]; n = isc_mem_get(mctx, sizeof(size_t)); - ATF_REQUIRE(n != NULL); + assert_non_null(n); *n = i + 1; while (1) { @@ -385,49 +380,43 @@ ATF_TC_BODY(rbt_check_distance_random, tc) { } /* 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. */ @@ -446,7 +435,7 @@ ATF_TC_BODY(rbt_check_distance_ordered, tc) { 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); @@ -454,24 +443,23 @@ ATF_TC_BODY(rbt_check_distance_ordered, tc) { 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 @@ -496,7 +484,7 @@ compare_labelsequences(dns_rbtnode_t *node, const char *labelstr) { 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; @@ -505,191 +493,178 @@ compare_labelsequences(dns_rbtnode_t *node, const char *labelstr) { 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. */ @@ -704,13 +679,13 @@ ATF_TC_BODY(rbt_remove, tc) { /* 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. */ @@ -726,14 +701,14 @@ ATF_TC_BODY(rbt_remove, tc) { &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; @@ -749,12 +724,12 @@ ATF_TC_BODY(rbt_remove, tc) { 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); @@ -774,7 +749,7 @@ ATF_TC_BODY(rbt_remove, tc) { &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); @@ -783,7 +758,7 @@ ATF_TC_BODY(rbt_remove, tc) { &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. */ @@ -797,7 +772,7 @@ ATF_TC_BODY(rbt_remove, tc) { &node, &chain, 0, NULL, NULL); - ATF_CHECK_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); start_node = 0; } @@ -846,12 +821,12 @@ ATF_TC_BODY(rbt_remove, tc) { 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); @@ -864,12 +839,10 @@ ATF_TC_BODY(rbt_remove, tc) { } /* 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 @@ -884,7 +857,7 @@ insert_nodes(dns_rbt_t *mytree, char **names, char namebuf[34]; n = isc_mem_get(mctx, sizeof(size_t)); - ATF_REQUIRE(n != NULL); + assert_non_null(n); *n = i; /* Unused value */ @@ -910,7 +883,7 @@ insert_nodes(dns_rbt_t *mytree, char **names, 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; } @@ -938,7 +911,7 @@ remove_nodes(dns_rbt_t *mytree, char **names, 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) { @@ -950,75 +923,61 @@ remove_nodes(dns_rbt_t *mytree, char **names, } 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; @@ -1035,7 +994,7 @@ ATF_TC_BODY(rbt_insert_and_remove, tc) { } 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); @@ -1045,12 +1004,12 @@ ATF_TC_BODY(rbt_insert_and_remove, tc) { } 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) { @@ -1059,34 +1018,25 @@ ATF_TC_BODY(rbt_insert_and_remove, tc) { } 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. */ @@ -1098,13 +1048,13 @@ ATF_TC_BODY(rbt_findname, tc) { 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); @@ -1112,7 +1062,7 @@ ATF_TC_BODY(rbt_findname, tc) { 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); @@ -1120,36 +1070,29 @@ ATF_TC_BODY(rbt_findname, tc) { 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); @@ -1157,62 +1100,51 @@ ATF_TC_BODY(rbt_addname, tc) { /* 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; @@ -1220,13 +1152,10 @@ ATF_TC_BODY(rbt_nodechain, tc) { 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); @@ -1236,7 +1165,7 @@ ATF_TC_BODY(rbt_nodechain, tc) { 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); @@ -1245,35 +1174,33 @@ ATF_TC_BODY(rbt_nodechain, tc) { 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 @@ -1283,11 +1210,6 @@ ATF_TC_BODY(rbt_nodechain, tc) { * 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; @@ -1312,16 +1234,18 @@ find_thread(void *arg) { &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; @@ -1334,15 +1258,12 @@ ATF_TC_BODY(benchmark, tc) { 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)); @@ -1358,34 +1279,34 @@ ATF_TC_BODY(benchmark, tc) { /* 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); @@ -1398,31 +1319,48 @@ ATF_TC_BODY(benchmark, tc) { 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 + +int +main(void) { + printf("1..0 # Skipped: cmocka not available\n"); + return (0); +} + +#endif