diff --git a/lib/dns/tests/Kyuafile b/lib/dns/tests/Kyuafile
index 855d093ede..d18a48c24c 100644
--- a/lib/dns/tests/Kyuafile
+++ b/lib/dns/tests/Kyuafile
@@ -30,5 +30,5 @@ atf_test_program{name='time_test'}
 tap_test_program{name='tkey_test'}
 atf_test_program{name='tsig_test'}
 atf_test_program{name='update_test'}
-atf_test_program{name='zonemgr_test'}
+tap_test_program{name='zonemgr_test'}
 tap_test_program{name='zt_test'}
diff --git a/lib/dns/tests/Makefile.in b/lib/dns/tests/Makefile.in
index 067484fb3c..380bec3b9e 100644
--- a/lib/dns/tests/Makefile.in
+++ b/lib/dns/tests/Makefile.in
@@ -254,9 +254,9 @@ update_test@EXEEXT@: update_test.@O@ dnstest.@O@ ${ISCDEPLIBS} ${DNSDEPLIBS}
 				${ISCLIBS} ${LIBS}
 
 zonemgr_test@EXEEXT@: zonemgr_test.@O@ dnstest.@O@ ${ISCDEPLIBS} ${DNSDEPLIBS}
-	${LIBTOOL_MODE_LINK} ${PURIFY} ${CC} ${CFLAGS} ${LDFLAGS} -o $@ \
-			zonemgr_test.@O@ dnstest.@O@ ${DNSLIBS} \
-				${ISCLIBS} ${LIBS}
+	${LIBTOOL_MODE_LINK} ${PURIFY} ${CC} ${CFLAGS} ${CMOCKA_CFLAGS} \
+		${LDFLAGS} -o $@ zonemgr_test.@O@ dnstest.@O@ \
+		${DNSLIBS} ${ISCLIBS} ${LIBS} ${CMOCKA_LIBS}
 
 zt_test@EXEEXT@: zt_test.@O@ dnstest.@O@ ${ISCDEPLIBS} ${DNSDEPLIBS}
 	${LIBTOOL_MODE_LINK} ${PURIFY} ${CC} ${CFLAGS} ${CMOCKA_CFLAGS} \
diff --git a/lib/dns/tests/zonemgr_test.c b/lib/dns/tests/zonemgr_test.c
index 03079c6212..be856b2314 100644
--- a/lib/dns/tests/zonemgr_test.c
+++ b/lib/dns/tests/zonemgr_test.c
@@ -9,18 +9,25 @@
  * 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 <stdlib.h>
+#include <string.h>
 #include <unistd.h>
 
+#define UNIT_TESTING
+#include <cmocka.h>
+
 #include <isc/buffer.h>
 #include <isc/task.h>
 #include <isc/timer.h>
+#include <isc/util.h>
 
 #include <dns/name.h>
 #include <dns/view.h>
@@ -28,127 +35,121 @@
 
 #include "dnstest.h"
 
-/*
- * Individual unit tests
- */
-ATF_TC(zonemgr_create);
-ATF_TC_HEAD(zonemgr_create, tc) {
-	atf_tc_set_md_var(tc, "descr", "create zone manager");
+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);
 }
-ATF_TC_BODY(zonemgr_create, tc) {
+
+static int
+_teardown(void **state) {
+	UNUSED(state);
+
+	dns_test_end();
+
+	return (0);
+}
+
+/* create zone manager */
+static void
+zonemgr_create(void **state) {
 	dns_zonemgr_t *myzonemgr = NULL;
 	isc_result_t result;
 
-	UNUSED(tc);
-
-	result = dns_test_begin(NULL, true);
-	ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+	UNUSED(state);
 
 	result = dns_zonemgr_create(mctx, taskmgr, timermgr, socketmgr,
 				    &myzonemgr);
-	ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+	assert_int_equal(result, ISC_R_SUCCESS);
 
 	dns_zonemgr_shutdown(myzonemgr);
 	dns_zonemgr_detach(&myzonemgr);
-	ATF_REQUIRE_EQ(myzonemgr, NULL);
-
-	dns_test_end();
+	assert_null(myzonemgr);
 }
 
-
-ATF_TC(zonemgr_managezone);
-ATF_TC_HEAD(zonemgr_managezone, tc) {
-	atf_tc_set_md_var(tc, "descr", "manage and release a zone");
-}
-ATF_TC_BODY(zonemgr_managezone, tc) {
+/* manage and release a zone */
+static void
+zonemgr_managezone(void **state) {
 	dns_zonemgr_t *myzonemgr = NULL;
 	dns_zone_t *zone = NULL;
 	isc_result_t result;
 
-	UNUSED(tc);
-
-	result = dns_test_begin(NULL, true);
-	ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+	UNUSED(state);
 
 	result = dns_zonemgr_create(mctx, taskmgr, timermgr, socketmgr,
 				    &myzonemgr);
-	ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+	assert_int_equal(result, ISC_R_SUCCESS);
 
 	result = dns_test_makezone("foo", &zone, NULL, false);
-	ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+	assert_int_equal(result, ISC_R_SUCCESS);
 
 	/* This should not succeed until the dns_zonemgr_setsize() is run */
 	result = dns_zonemgr_managezone(myzonemgr, zone);
-	ATF_REQUIRE_EQ(result, ISC_R_FAILURE);
+	assert_int_equal(result, ISC_R_FAILURE);
 
-	ATF_REQUIRE_EQ(dns_zonemgr_getcount(myzonemgr, DNS_ZONESTATE_ANY), 0);
+	assert_int_equal(dns_zonemgr_getcount(myzonemgr, DNS_ZONESTATE_ANY), 0);
 
 	result = dns_zonemgr_setsize(myzonemgr, 1);
-	ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+	assert_int_equal(result, ISC_R_SUCCESS);
 
 	/* Now it should succeed */
 	result = dns_zonemgr_managezone(myzonemgr, zone);
-	ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+	assert_int_equal(result, ISC_R_SUCCESS);
 
-	ATF_REQUIRE_EQ(dns_zonemgr_getcount(myzonemgr, DNS_ZONESTATE_ANY), 1);
+	assert_int_equal(dns_zonemgr_getcount(myzonemgr, DNS_ZONESTATE_ANY), 1);
 
 	dns_zonemgr_releasezone(myzonemgr, zone);
 	dns_zone_detach(&zone);
 
-	ATF_REQUIRE_EQ(dns_zonemgr_getcount(myzonemgr, DNS_ZONESTATE_ANY), 0);
+	assert_int_equal(dns_zonemgr_getcount(myzonemgr, DNS_ZONESTATE_ANY), 0);
 
 	dns_zonemgr_shutdown(myzonemgr);
 	dns_zonemgr_detach(&myzonemgr);
-	ATF_REQUIRE_EQ(myzonemgr, NULL);
-
-	dns_test_end();
+	assert_null(myzonemgr);
 }
 
-ATF_TC(zonemgr_createzone);
-ATF_TC_HEAD(zonemgr_createzone, tc) {
-	atf_tc_set_md_var(tc, "descr", "create and release a zone");
-}
-ATF_TC_BODY(zonemgr_createzone, tc) {
+/* create and release a zone */
+static void
+zonemgr_createzone(void **state) {
 	dns_zonemgr_t *myzonemgr = NULL;
 	dns_zone_t *zone = NULL;
 	isc_result_t result;
 
-	UNUSED(tc);
-
-	result = dns_test_begin(NULL, true);
-	ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+	UNUSED(state);
 
 	result = dns_zonemgr_create(mctx, taskmgr, timermgr, socketmgr,
 				    &myzonemgr);
-	ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+	assert_int_equal(result, ISC_R_SUCCESS);
 
 	/* This should not succeed until the dns_zonemgr_setsize() is run */
 	result = dns_zonemgr_createzone(myzonemgr, &zone);
-	ATF_REQUIRE_EQ(result, ISC_R_FAILURE);
+	assert_int_equal(result, ISC_R_FAILURE);
 
 	result = dns_zonemgr_setsize(myzonemgr, 1);
-	ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+	assert_int_equal(result, ISC_R_SUCCESS);
 
 	/* Now it should succeed */
 	result = dns_zonemgr_createzone(myzonemgr, &zone);
-	ATF_CHECK_EQ(result, ISC_R_SUCCESS);
-	ATF_CHECK(zone != NULL);
+	assert_int_equal(result, ISC_R_SUCCESS);
+	assert_non_null(zone);
 
 	if (zone != NULL)
 		dns_zone_detach(&zone);
 
 	dns_zonemgr_shutdown(myzonemgr);
 	dns_zonemgr_detach(&myzonemgr);
-	ATF_REQUIRE_EQ(myzonemgr, NULL);
-
-	dns_test_end();
+	assert_null(myzonemgr);
 }
 
-ATF_TC(zonemgr_unreachable);
-ATF_TC_HEAD(zonemgr_unreachable, tc) {
-	atf_tc_set_md_var(tc, "descr", "manage and release a zone");
-}
-ATF_TC_BODY(zonemgr_unreachable, tc) {
+/* manage and release a zone */
+static void
+zonemgr_unreachable(void **state) {
 	dns_zonemgr_t *myzonemgr = NULL;
 	dns_zone_t *zone = NULL;
 	isc_sockaddr_t addr1, addr2;
@@ -156,80 +157,62 @@ ATF_TC_BODY(zonemgr_unreachable, tc) {
 	isc_result_t result;
 	isc_time_t now;
 
-	UNUSED(tc);
+	UNUSED(state);
 
 	TIME_NOW(&now);
 
-	result = dns_test_begin(NULL, true);
-
-	ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
-
 	result = dns_zonemgr_create(mctx, taskmgr, timermgr, socketmgr,
 				    &myzonemgr);
-	ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+	assert_int_equal(result, ISC_R_SUCCESS);
 
 	result = dns_test_makezone("foo", &zone, NULL, false);
-	ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+	assert_int_equal(result, ISC_R_SUCCESS);
 
 	result = dns_zonemgr_setsize(myzonemgr, 1);
-	ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+	assert_int_equal(result, ISC_R_SUCCESS);
 
 	result = dns_zonemgr_managezone(myzonemgr, zone);
-	ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
+	assert_int_equal(result, ISC_R_SUCCESS);
 
 	in.s_addr = inet_addr("10.53.0.1");
 	isc_sockaddr_fromin(&addr1, &in, 2112);
 	in.s_addr = inet_addr("10.53.0.2");
 	isc_sockaddr_fromin(&addr2, &in, 5150);
-	ATF_CHECK(! dns_zonemgr_unreachable(myzonemgr, &addr1, &addr2, &now));
+	assert_false(dns_zonemgr_unreachable(myzonemgr, &addr1, &addr2, &now));
 	/*
 	 * We require multiple unreachableadd calls to mark a server as
 	 * unreachable.
 	 */
 	dns_zonemgr_unreachableadd(myzonemgr, &addr1, &addr2, &now);
-	ATF_CHECK(! dns_zonemgr_unreachable(myzonemgr, &addr1, &addr2, &now));
+	assert_false(dns_zonemgr_unreachable(myzonemgr, &addr1, &addr2, &now));
 	dns_zonemgr_unreachableadd(myzonemgr, &addr1, &addr2, &now);
-	ATF_CHECK(dns_zonemgr_unreachable(myzonemgr, &addr1, &addr2, &now));
+	assert_true(dns_zonemgr_unreachable(myzonemgr, &addr1, &addr2, &now));
 
 	in.s_addr = inet_addr("10.53.0.3");
 	isc_sockaddr_fromin(&addr2, &in, 5150);
-	ATF_CHECK(! dns_zonemgr_unreachable(myzonemgr, &addr1, &addr2, &now));
+	assert_false(dns_zonemgr_unreachable(myzonemgr, &addr1, &addr2, &now));
 	/*
 	 * We require multiple unreachableadd calls to mark a server as
 	 * unreachable.
 	 */
 	dns_zonemgr_unreachableadd(myzonemgr, &addr1, &addr2, &now);
 	dns_zonemgr_unreachableadd(myzonemgr, &addr1, &addr2, &now);
-	ATF_CHECK(dns_zonemgr_unreachable(myzonemgr, &addr1, &addr2, &now));
+	assert_true(dns_zonemgr_unreachable(myzonemgr, &addr1, &addr2, &now));
 
 	dns_zonemgr_unreachabledel(myzonemgr, &addr1, &addr2);
-	ATF_CHECK(! dns_zonemgr_unreachable(myzonemgr, &addr1, &addr2, &now));
+	assert_false(dns_zonemgr_unreachable(myzonemgr, &addr1, &addr2, &now));
 
 	in.s_addr = inet_addr("10.53.0.2");
 	isc_sockaddr_fromin(&addr2, &in, 5150);
-	ATF_CHECK(dns_zonemgr_unreachable(myzonemgr, &addr1, &addr2, &now));
+	assert_true(dns_zonemgr_unreachable(myzonemgr, &addr1, &addr2, &now));
 	dns_zonemgr_unreachabledel(myzonemgr, &addr1, &addr2);
-	ATF_CHECK(! dns_zonemgr_unreachable(myzonemgr, &addr1, &addr2, &now));
+	assert_false(dns_zonemgr_unreachable(myzonemgr, &addr1, &addr2, &now));
 
 	dns_zonemgr_releasezone(myzonemgr, zone);
 	dns_zone_detach(&zone);
 	dns_zonemgr_shutdown(myzonemgr);
 	dns_zonemgr_detach(&myzonemgr);
-	ATF_REQUIRE_EQ(myzonemgr, NULL);
-
-	dns_test_end();
-}
-
-
-/*
- * Main
- */
-ATF_TP_ADD_TCS(tp) {
-	ATF_TP_ADD_TC(tp, zonemgr_create);
-	ATF_TP_ADD_TC(tp, zonemgr_managezone);
-	ATF_TP_ADD_TC(tp, zonemgr_createzone);
-	ATF_TP_ADD_TC(tp, zonemgr_unreachable);
-	return (atf_no_error());
+	assert_null(myzonemgr);
 }
 
 /*
@@ -251,3 +234,31 @@ ATF_TP_ADD_TCS(tp) {
  * 	- dns_zonemgr_setserialqueryrate
  * 	- dns_zonemgr_getserialqueryrate
  */
+
+int
+main(void) {
+	const struct CMUnitTest tests[] = {
+		cmocka_unit_test_setup_teardown(zonemgr_create,
+						_setup, _teardown),
+		cmocka_unit_test_setup_teardown(zonemgr_managezone,
+						_setup, _teardown),
+		cmocka_unit_test_setup_teardown(zonemgr_createzone,
+						_setup, _teardown),
+		cmocka_unit_test_setup_teardown(zonemgr_unreachable,
+						_setup, _teardown),
+	};
+
+	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