mir/bind
2
0
Fork 0
mirror of https://gitlab.isc.org/isc-projects/bind9 synced 2025-08-29 05:28:00 +00:00
Code Issues Releases Wiki Activity

convert zonemgr_test

Browse Source
This commit is contained in:
Evan Hunt 2018-10-25 20:30:51 -07:00
parent 0a4f6122de
commit 01a193ff6c
3 changed files with 109 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/dns/tests/Kyuafile
View File

@ -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'}

6
lib/dns/tests/Makefile.in
View File

@ -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} \

199
lib/dns/tests/zonemgr_test.c
View File

@ -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