convert zt_test

diff --git a/lib/dns/tests/Kyuafile b/lib/dns/tests/Kyuafile
index a4f0bb9afeaa243a8a696df29b695a3a5cce4ecc..855d093ede0ce82aab238b94ad8d3f0189155096 100644 (file)
--- a/lib/dns/tests/Kyuafile
+++ b/lib/dns/tests/Kyuafile
@@ -31,4 +31,4 @@ tap_test_program{name='tkey_test'}
 atf_test_program{name='tsig_test'}
 atf_test_program{name='update_test'}
 atf_test_program{name='zonemgr_test'}
-atf_test_program{name='zt_test'}
+tap_test_program{name='zt_test'}

diff --git a/lib/dns/tests/Makefile.in b/lib/dns/tests/Makefile.in
index 6f8c0bc02d0093c7bbda4abc4af875d9450175bf..067484fb3c225167d7b4fd375ef0b542f87515e2 100644 (file)
--- a/lib/dns/tests/Makefile.in
+++ b/lib/dns/tests/Makefile.in
@@ -258,11 +258,10 @@ zonemgr_test@EXEEXT@: zonemgr_test.@O@ dnstest.@O@ ${ISCDEPLIBS} ${DNSDEPLIBS}
                        zonemgr_test.@O@ dnstest.@O@ ${DNSLIBS} \
                                ${ISCLIBS} ${LIBS}
 
-zt_test@EXEEXT@: zt_test.@O@ dnstest.@O@ \
-               ${ISCDEPLIBS} ${DNSDEPLIBS}
-       ${LIBTOOL_MODE_LINK} ${PURIFY} ${CC} ${CFLAGS} ${LDFLAGS} -o $@ \
-                       zt_test.@O@ dnstest.@O@ ${DNSLIBS} \
-                               ${ISCLIBS} ${LIBS}
+zt_test@EXEEXT@: zt_test.@O@ dnstest.@O@ ${ISCDEPLIBS} ${DNSDEPLIBS}
+       ${LIBTOOL_MODE_LINK} ${PURIFY} ${CC} ${CFLAGS} ${CMOCKA_CFLAGS} \
+               ${LDFLAGS} -o $@ zt_test.@O@ dnstest.@O@ \
+               ${DNSLIBS} ${ISCLIBS} ${LIBS} ${CMOCKA_LIBS}
 
 unit::
        sh ${top_builddir}/unit/unittest.sh

diff --git a/lib/dns/tests/zt_test.c b/lib/dns/tests/zt_test.c
index 670688d0fe85ffae2df3d08d99a4da6da9617e56..b929e01bbc82e418436cbb99c9eb605721c13aeb 100644 (file)
--- a/lib/dns/tests/zt_test.c
+++ b/lib/dns/tests/zt_test.c
@@ -9,20 +9,28 @@
  * 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 <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
 #include <unistd.h>
 
+#define UNIT_TESTING
+#include <cmocka.h>
+
 #include <isc/app.h>
 #include <isc/buffer.h>
 #include <isc/print.h>
 #include <isc/task.h>
 #include <isc/timer.h>
+#include <isc/util.h>
 
 #include <dns/db.h>
 #include <dns/name.h>
@@ -38,9 +46,27 @@ struct args {
        bool arg3;
 };
 
-/*
- * Helper functions
- */
+static int
+_setup(void **state) {
+       isc_result_t result;
+
+       UNUSED(state);
+
+       result = dns_test_begin(NULL, true);
+       assert_int_equal(result, ISC_R_SUCCESS);
+
+       return (0);
+}
+
+static int
+_teardown(void **state) {
+       UNUSED(state);
+
+       dns_test_end();
+
+       return (0);
+}
+
 static isc_result_t
 count_zone(dns_zone_t *zone, void *uap) {
        int *nzones = (int *)uap;
@@ -94,56 +120,44 @@ start_zone_asyncload(isc_task_t *task, isc_event_t *event) {
        isc_event_free(&event);
 }
 
-/*
- * Individual unit tests
- */
-ATF_TC(apply);
-ATF_TC_HEAD(apply, tc) {
-       atf_tc_set_md_var(tc, "descr", "apply a function to a zone table");
-}
-ATF_TC_BODY(apply, tc) {
+/* apply a function to a zone table */
+static void
+apply(void **state) {
        isc_result_t result;
        dns_zone_t *zone = NULL;
        dns_view_t *view = NULL;
        int nzones = 0;
 
-       UNUSED(tc);
-
-       result = dns_test_begin(NULL, true);
-       ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+       UNUSED(state);
 
        result = dns_test_makezone("foo", &zone, NULL, true);
-       ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+       assert_int_equal(result, ISC_R_SUCCESS);
 
        view = dns_zone_getview(zone);
-       ATF_REQUIRE(view->zonetable != NULL);
+       assert_non_null(view->zonetable);
 
-       ATF_CHECK_EQ(0, nzones);
+       assert_int_equal(nzones, 0);
        result = dns_zt_apply(view->zonetable, false, NULL,
                              count_zone, &nzones);
-       ATF_CHECK_EQ(result, ISC_R_SUCCESS);
-       ATF_CHECK_EQ(1, nzones);
+       assert_int_equal(result, ISC_R_SUCCESS);
+       assert_int_equal(nzones, 1);
 
        /* These steps are necessary so the zone can be detached properly */
        result = dns_test_setupzonemgr();
-       ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+       assert_int_equal(result, ISC_R_SUCCESS);
        result = dns_test_managezone(zone);
-       ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+       assert_int_equal(result, ISC_R_SUCCESS);
        dns_test_releasezone(zone);
        dns_test_closezonemgr();
 
        /* The view was left attached in dns_test_makezone() */
        dns_view_detach(&view);
        dns_zone_detach(&zone);
-
-       dns_test_end();
 }
 
-ATF_TC(asyncload_zone);
-ATF_TC_HEAD(asyncload_zone, tc) {
-       atf_tc_set_md_var(tc, "descr", "asynchronous zone load");
-}
-ATF_TC_BODY(asyncload_zone, tc) {
+/* asynchronous zone load */
+static void
+asyncload_zone(void **state) {
        isc_result_t result;
        int n;
        dns_zone_t *zone = NULL;
@@ -155,28 +169,25 @@ ATF_TC_BODY(asyncload_zone, tc) {
        int i = 0;
        struct args args;
 
-       UNUSED(tc);
-
-       result = dns_test_begin(NULL, true);
-       ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+       UNUSED(state);
 
        result = dns_test_makezone("foo", &zone, NULL, true);
-       ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+       assert_int_equal(result, ISC_R_SUCCESS);
 
        result = dns_test_setupzonemgr();
-       ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+       assert_int_equal(result, ISC_R_SUCCESS);
        result = dns_test_managezone(zone);
-       ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+       assert_int_equal(result, ISC_R_SUCCESS);
 
        view = dns_zone_getview(zone);
-       ATF_REQUIRE(view->zonetable != NULL);
+       assert_non_null(view->zonetable);
 
-       ATF_CHECK(!dns__zone_loadpending(zone));
-       ATF_CHECK(!done);
+       assert_false(dns__zone_loadpending(zone));
+       assert_false(done);
        zonefile = fopen("./zone.data", "wb");
-       ATF_CHECK(zonefile != NULL);
+       assert_non_null(zonefile);
        origfile = fopen("./testdata/zt/zone1.db", "r+b");
-       ATF_CHECK(origfile != NULL);
+       assert_non_null(origfile);
        n = fread(buf, 1, 4096, origfile);
        fclose(origfile);
        fwrite(buf, 1, n, zonefile);
@@ -193,10 +204,10 @@ ATF_TC_BODY(asyncload_zone, tc) {
        isc_app_run();
        while (dns__zone_loadpending(zone) && i++ < 5000)
                dns_test_nap(1000);
-       ATF_CHECK(done);
+       assert_true(done);
        /* The zone should now be loaded; test it */
        result = dns_zone_getdb(zone, &db);
-       ATF_CHECK_EQ(result, ISC_R_SUCCESS);
+       assert_int_equal(result, ISC_R_SUCCESS);
        dns_db_detach(&db);
        /*
         * Add something to zone file, reload zone with newonly - it should
@@ -215,10 +226,10 @@ ATF_TC_BODY(asyncload_zone, tc) {
 
        while (dns__zone_loadpending(zone) && i++ < 5000)
                dns_test_nap(1000);
-       ATF_CHECK(done);
+       assert_true(done);
        /* The zone should now be loaded; test it */
        result = dns_zone_getdb(zone, &db);
-       ATF_CHECK_EQ(result, ISC_R_SUCCESS);
+       assert_int_equal(result, ISC_R_SUCCESS);
        dns_db_detach(&db);
 
        /* Now reload it without newonly - it should be reloaded */
@@ -231,12 +242,12 @@ ATF_TC_BODY(asyncload_zone, tc) {
 
        while (dns__zone_loadpending(zone) && i++ < 5000)
                dns_test_nap(1000);
-       ATF_CHECK(done);
+       assert_true(done);
        /* The zone should now be loaded; test it */
        result = dns_zone_getdb(zone, &db);
-       ATF_CHECK_EQ(result, ISC_R_SUCCESS);
+       assert_int_equal(result, ISC_R_SUCCESS);
 
-       ATF_CHECK(db != NULL);
+       assert_non_null(db);
        if (db != NULL)
                dns_db_detach(&db);
 
@@ -245,15 +256,11 @@ ATF_TC_BODY(asyncload_zone, tc) {
 
        dns_zone_detach(&zone);
        dns_view_detach(&view);
-
-       dns_test_end();
 }
 
-ATF_TC(asyncload_zt);
-ATF_TC_HEAD(asyncload_zt, tc) {
-       atf_tc_set_md_var(tc, "descr", "asynchronous zone table load");
-}
-ATF_TC_BODY(asyncload_zt, tc) {
+/* asynchronous zone table load */
+static void
+asyncload_zt(void **state) {
        isc_result_t result;
        dns_zone_t *zone1 = NULL, *zone2 = NULL, *zone3 = NULL;
        dns_view_t *view;
@@ -263,43 +270,40 @@ ATF_TC_BODY(asyncload_zt, tc) {
        int i = 0;
        struct args args;
 
-       UNUSED(tc);
-
-       result = dns_test_begin(NULL, true);
-       ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+       UNUSED(state);
 
        result = dns_test_makezone("foo", &zone1, NULL, true);
-       ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+       assert_int_equal(result, ISC_R_SUCCESS);
        dns_zone_setfile(zone1, "testdata/zt/zone1.db",
                         dns_masterformat_text, &dns_master_style_default);
        view = dns_zone_getview(zone1);
 
        result = dns_test_makezone("bar", &zone2, view, false);
-       ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+       assert_int_equal(result, ISC_R_SUCCESS);
        dns_zone_setfile(zone2, "testdata/zt/zone1.db",
                         dns_masterformat_text, &dns_master_style_default);
 
        /* This one will fail to load */
        result = dns_test_makezone("fake", &zone3, view, false);
-       ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+       assert_int_equal(result, ISC_R_SUCCESS);
        dns_zone_setfile(zone3, "testdata/zt/nonexistent.db",
                         dns_masterformat_text, &dns_master_style_default);
 
        zt = view->zonetable;
-       ATF_REQUIRE(zt != NULL);
+       assert_non_null(zt);
 
        result = dns_test_setupzonemgr();
-       ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+       assert_int_equal(result, ISC_R_SUCCESS);
        result = dns_test_managezone(zone1);
-       ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+       assert_int_equal(result, ISC_R_SUCCESS);
        result = dns_test_managezone(zone2);
-       ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+       assert_int_equal(result, ISC_R_SUCCESS);
        result = dns_test_managezone(zone3);
-       ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+       assert_int_equal(result, ISC_R_SUCCESS);
 
-       ATF_CHECK(!dns__zone_loadpending(zone1));
-       ATF_CHECK(!dns__zone_loadpending(zone2));
-       ATF_CHECK(!done);
+       assert_false(dns__zone_loadpending(zone1));
+       assert_false(dns__zone_loadpending(zone2));
+       assert_false(done);
 
        args.arg1 = zt;
        args.arg2 = &done;
@@ -308,18 +312,18 @@ ATF_TC_BODY(asyncload_zt, tc) {
        isc_app_run();
        while (!done && i++ < 5000)
                dns_test_nap(1000);
-       ATF_CHECK(done);
+       assert_true(done);
 
        /* Both zones should now be loaded; test them */
        result = dns_zone_getdb(zone1, &db);
-       ATF_CHECK_EQ(result, ISC_R_SUCCESS);
-       ATF_CHECK(db != NULL);
+       assert_int_equal(result, ISC_R_SUCCESS);
+       assert_non_null(db);
        if (db != NULL)
                dns_db_detach(&db);
 
        result = dns_zone_getdb(zone2, &db);
-       ATF_CHECK_EQ(result, ISC_R_SUCCESS);
-       ATF_CHECK(db != NULL);
+       assert_int_equal(result, ISC_R_SUCCESS);
+       assert_non_null(db);
        if (db != NULL)
                dns_db_detach(&db);
 
@@ -332,16 +336,29 @@ ATF_TC_BODY(asyncload_zt, tc) {
        dns_zone_detach(&zone2);
        dns_zone_detach(&zone3);
        dns_view_detach(&view);
+}
 
-       dns_test_end();
+int
+main(void) {
+       const struct CMUnitTest tests[] = {
+               cmocka_unit_test_setup_teardown(apply, _setup, _teardown),
+               cmocka_unit_test_setup_teardown(asyncload_zone,
+                                               _setup, _teardown),
+               cmocka_unit_test_setup_teardown(asyncload_zt,
+                                               _setup, _teardown),
+       };
+
+       return (cmocka_run_group_tests(tests, NULL, NULL));
 }
 
-/*
- * Main
- */
-ATF_TP_ADD_TCS(tp) {
-       ATF_TP_ADD_TC(tp, apply);
-       ATF_TP_ADD_TC(tp, asyncload_zone);
-       ATF_TP_ADD_TC(tp, asyncload_zt);
-       return (atf_no_error());
+#else /* HAVE_CMOCKA */
+
+#include <stdio.h>
+
+int
+main(void) {
+       printf("1..0 # Skipped: cmocka not available\n");
+       return (0);
 }
+
+#endif