From 20cef35ece4e144d033eba59fb2102d3f046f558 Mon Sep 17 00:00:00 2001 From: Evan Hunt Date: Wed, 24 Oct 2018 08:48:41 -0700 Subject: [PATCH] convert timer_test --- lib/isc/tests/Kyuafile | 2 +- lib/isc/tests/Makefile.in | 5 +- lib/isc/tests/timer_test.c | 315 ++++++++++++++++++++----------------- 3 files changed, 176 insertions(+), 146 deletions(-) diff --git a/lib/isc/tests/Kyuafile b/lib/isc/tests/Kyuafile index 718e6ac659..954f280797 100644 --- a/lib/isc/tests/Kyuafile +++ b/lib/isc/tests/Kyuafile @@ -27,4 +27,4 @@ tap_test_program{name='symtab_test'} tap_test_program{name='task_test'} tap_test_program{name='taskpool_test'} tap_test_program{name='time_test'} -atf_test_program{name='timer_test'} +tap_test_program{name='timer_test'} diff --git a/lib/isc/tests/Makefile.in b/lib/isc/tests/Makefile.in index ac532b1895..97b4ab43d6 100644 --- a/lib/isc/tests/Makefile.in +++ b/lib/isc/tests/Makefile.in @@ -187,8 +187,9 @@ time_test@EXEEXT@: time_test.@O@ ${ISCDEPLIBS} ${ISCLIBS} ${LIBS} ${CMOCKA_LIBS} timer_test@EXEEXT@: timer_test.@O@ isctest.@O@ ${ISCDEPLIBS} - ${LIBTOOL_MODE_LINK} ${PURIFY} ${CC} ${CFLAGS} ${LDFLAGS} -o $@ \ - timer_test.@O@ isctest.@O@ ${ISCLIBS} ${LIBS} + ${LIBTOOL_MODE_LINK} ${PURIFY} ${CC} ${CFLAGS} ${CMOCKA_CFLAGS} \ + ${LDFLAGS} -o $@ timer_test.@O@ isctest.@O@ \ + ${ISCLIBS} ${LIBS} ${CMOCKA_LIBS} unit:: sh ${top_builddir}/unit/unittest.sh diff --git a/lib/isc/tests/timer_test.c b/lib/isc/tests/timer_test.c index 473cb7fc50..c958b6a9cd 100644 --- a/lib/isc/tests/timer_test.c +++ b/lib/isc/tests/timer_test.c @@ -9,15 +9,23 @@ * information regarding copyright ownership. */ -/*! \file */ - #include -#include +#if HAVE_CMOCKA +#include +#include +#include + +#include +#include #include +#define UNIT_TESTING +#include + #include +#include #include #include #include @@ -25,25 +33,46 @@ #include #include #include -#include #include "isctest.h" -/* - * Helper functions - */ +/* Set to true for verbose output */ +static bool verbose = false; + #define FUDGE_SECONDS 0 /* in absence of clock_getres() */ #define FUDGE_NANOSECONDS 500000000 /* in absence of clock_getres() */ -static isc_timer_t *timer = NULL; -static isc_condition_t cv; -static isc_mutex_t mx; -static isc_time_t endtime; -static isc_time_t lasttime; -static int seconds; -static int nanoseconds; -static int eventcnt; -static int nevents; +static isc_timer_t *timer = NULL; +static isc_condition_t cv; +static isc_mutex_t mx; +static isc_time_t endtime; +static isc_time_t lasttime; +static int seconds; +static int nanoseconds; +static int eventcnt; +static int nevents; + +static int +_setup(void **state) { + isc_result_t result; + + UNUSED(state); + + /* Timer tests require two worker threads */ + result = isc_test_begin(NULL, true, 2); + assert_int_equal(result, ISC_R_SUCCESS); + + return (0); +} + +static int +_teardown(void **state) { + UNUSED(state); + + isc_test_end(); + + return (0); +} static void shutdown(isc_task_t *task, isc_event_t *event) { @@ -55,13 +84,13 @@ shutdown(isc_task_t *task, isc_event_t *event) { * Signal shutdown processing complete. */ result = isc_mutex_lock(&mx); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); result = isc_condition_signal(&cv); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); result = isc_mutex_unlock(&mx); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); isc_event_free(&event); } @@ -77,33 +106,33 @@ setup_test(isc_timertype_t timertype, isc_time_t *expires, eventcnt = 0; result = isc_mutex_init(&mx); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); result = isc_condition_init(&cv); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); LOCK(&mx); result = isc_task_create(taskmgr, 0, &task); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); result = isc_task_onshutdown(task, shutdown, NULL); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); result = isc_time_now(&lasttime); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); result = isc_timer_create(timermgr, timertype, expires, interval, task, action, (void *)timertype, &timer); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); /* * Wait for shutdown processing to complete. */ while (eventcnt != nevents) { result = isc_condition_wait(&cv, &mx); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); } UNLOCK(&mx); @@ -125,7 +154,9 @@ ticktock(isc_task_t *task, isc_event_t *event) { ++eventcnt; - printf("tick %d\n", eventcnt); + if (verbose) { + print_message("# tick %d\n", eventcnt); + } expected_event_type = ISC_TIMEREVENT_LIFE; if ((isc_timertype_t) event->ev_arg == isc_timertype_ticker) { @@ -133,31 +164,31 @@ ticktock(isc_task_t *task, isc_event_t *event) { } if (event->ev_type != expected_event_type) { - printf("expected event type %u, got %u\n", - expected_event_type, event->ev_type); + print_error("# expected event type %u, got %u\n", + expected_event_type, event->ev_type); } result = isc_time_now(&now); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); isc_interval_set(&interval, seconds, nanoseconds); result = isc_time_add(&lasttime, &interval, &base); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); isc_interval_set(&interval, FUDGE_SECONDS, FUDGE_NANOSECONDS); result = isc_time_add(&base, &interval, &ulim); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); result = isc_time_subtract(&base, &interval, &llim); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); - ATF_CHECK(isc_time_compare(&llim, &now) <= 0); - ATF_CHECK(isc_time_compare(&ulim, &now) >= 0); + assert_true(isc_time_compare(&llim, &now) <= 0); + assert_true(isc_time_compare(&ulim, &now) >= 0); lasttime = now; if (eventcnt == nevents) { result = isc_time_now(&endtime); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); isc_timer_detach(&timer); isc_task_shutdown(task); } @@ -169,62 +200,46 @@ ticktock(isc_task_t *task, isc_event_t *event) { * Individual unit tests */ -ATF_TC(ticker); -ATF_TC_HEAD(ticker, tc) { - atf_tc_set_md_var(tc, "descr", "timer type ticker"); -} -ATF_TC_BODY(ticker, tc) { - isc_result_t result; +/* timer type ticker */ +static void +ticker(void **state) { isc_time_t expires; isc_interval_t interval; - UNUSED(tc); + UNUSED(state); nevents = 12; seconds = 0; nanoseconds = 500000000; - result = isc_test_begin(NULL, true, 2); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); - isc_interval_set(&interval, seconds, nanoseconds); isc_time_settoepoch(&expires); setup_test(isc_timertype_ticker, &expires, &interval, ticktock); - - isc_test_end(); } -ATF_TC(once_life); -ATF_TC_HEAD(once_life, tc) { - atf_tc_set_md_var(tc, "descr", "timer type once reaches lifetime"); -} -ATF_TC_BODY(once_life, tc) { +/* timer type once reaches lifetime */ +static void +once_life(void **state) { isc_result_t result; isc_time_t expires; isc_interval_t interval; - UNUSED(tc); + UNUSED(state); nevents = 1; seconds = 1; nanoseconds = 100000000; - result = isc_test_begin(NULL, true, 2); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); - isc_interval_set(&interval, seconds, nanoseconds); result = isc_time_nowplusinterval(&expires, &interval); - ATF_CHECK_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); isc_interval_set(&interval, 0, 0); setup_test(isc_timertype_once, &expires, &interval, ticktock); - - isc_test_end(); } - static void test_idle(isc_task_t *task, isc_event_t *event) { isc_result_t result; @@ -236,62 +251,58 @@ test_idle(isc_task_t *task, isc_event_t *event) { ++eventcnt; - printf("tick %d\n", eventcnt); + if (verbose) { + print_message("# tick %d\n", eventcnt); + } result = isc_time_now(&now); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); isc_interval_set(&interval, seconds, nanoseconds); result = isc_time_add(&lasttime, &interval, &base); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); isc_interval_set(&interval, FUDGE_SECONDS, FUDGE_NANOSECONDS); result = isc_time_add(&base, &interval, &ulim); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); result = isc_time_subtract(&base, &interval, &llim); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); - ATF_CHECK(isc_time_compare(&llim, &now) <= 0); - ATF_CHECK(isc_time_compare(&ulim, &now) >= 0); + assert_true(isc_time_compare(&llim, &now) <= 0); + assert_true(isc_time_compare(&ulim, &now) >= 0); lasttime = now; - ATF_CHECK_EQ(event->ev_type, ISC_TIMEREVENT_IDLE); + assert_int_equal(event->ev_type, ISC_TIMEREVENT_IDLE); isc_timer_detach(&timer); isc_task_shutdown(task); isc_event_free(&event); } -ATF_TC(once_idle); -ATF_TC_HEAD(once_idle, tc) { - atf_tc_set_md_var(tc, "descr", "timer type once idles out"); -} -ATF_TC_BODY(once_idle, tc) { +/* timer type once idles out */ +static void +once_idle(void **state) { isc_result_t result; isc_time_t expires; isc_interval_t interval; - UNUSED(tc); + UNUSED(state); nevents = 1; seconds = 1; nanoseconds = 200000000; - result = isc_test_begin(NULL, true, 2); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); - isc_interval_set(&interval, seconds + 1, nanoseconds); result = isc_time_nowplusinterval(&expires, &interval); - ATF_CHECK_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); isc_interval_set(&interval, seconds, nanoseconds); setup_test(isc_timertype_once, &expires, &interval, test_idle); - - isc_test_end(); } +/* timer reset */ static void test_reset(isc_task_t *task, isc_event_t *event) { isc_result_t result; @@ -304,46 +315,48 @@ test_reset(isc_task_t *task, isc_event_t *event) { ++eventcnt; - printf("tick %d\n", eventcnt); + if (verbose) { + print_message("# tick %d\n", eventcnt); + } /* * Check expired time. */ result = isc_time_now(&now); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); isc_interval_set(&interval, seconds, nanoseconds); result = isc_time_add(&lasttime, &interval, &base); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); isc_interval_set(&interval, FUDGE_SECONDS, FUDGE_NANOSECONDS); result = isc_time_add(&base, &interval, &ulim); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); result = isc_time_subtract(&base, &interval, &llim); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); - ATF_CHECK(isc_time_compare(&llim, &now) <= 0); - ATF_CHECK(isc_time_compare(&ulim, &now) >= 0); + assert_true(isc_time_compare(&llim, &now) <= 0); + assert_true(isc_time_compare(&ulim, &now) >= 0); lasttime = now; if (eventcnt < 3) { - ATF_CHECK_EQ(event->ev_type, ISC_TIMEREVENT_TICK); + assert_int_equal(event->ev_type, ISC_TIMEREVENT_TICK); if (eventcnt == 2) { isc_interval_set(&interval, seconds, nanoseconds); result = isc_time_nowplusinterval(&expires, &interval); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); isc_interval_set(&interval, 0, 0); result = isc_timer_reset(timer, isc_timertype_once, &expires, &interval, false); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); } } else { - ATF_CHECK_EQ(event->ev_type, ISC_TIMEREVENT_LIFE); + assert_int_equal(event->ev_type, ISC_TIMEREVENT_LIFE); isc_timer_detach(&timer); isc_task_shutdown(task); @@ -352,19 +365,12 @@ test_reset(isc_task_t *task, isc_event_t *event) { isc_event_free(&event); } -ATF_TC(reset); -ATF_TC_HEAD(reset, tc) { - atf_tc_set_md_var(tc, "descr", "timer reset"); -} -ATF_TC_BODY(reset, tc) { - isc_result_t result; +static void +reset(void **state) { isc_time_t expires; isc_interval_t interval; - UNUSED(tc); - - result = isc_test_begin(NULL, true, 2); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + UNUSED(state); nevents = 3; seconds = 0; @@ -374,8 +380,6 @@ ATF_TC_BODY(reset, tc) { isc_time_settoepoch(&expires); setup_test(isc_timertype_ticker, &expires, &interval, test_reset); - - isc_test_end(); } static int startflag; @@ -394,7 +398,9 @@ static void start_event(isc_task_t *task, isc_event_t *event) { UNUSED(task); - printf("start_event\n"); + if (verbose) { + print_message("# start_event\n"); + } LOCK(&mx); while (! startflag) { @@ -414,7 +420,9 @@ tick_event(isc_task_t *task, isc_event_t *event) { UNUSED(task); ++eventcnt; - printf("tick_event %d\n", eventcnt); + if (verbose) { + print_message("# tick_event %d\n", eventcnt); + } /* * On the first tick, purge all remaining tick events @@ -425,7 +433,7 @@ tick_event(isc_task_t *task, isc_event_t *event) { isc_interval_set(&interval, seconds, 0); result = isc_timer_reset(tickertimer, isc_timertype_ticker, &expires, &interval, true); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); isc_task_shutdown(task); } @@ -437,7 +445,9 @@ static void once_event(isc_task_t *task, isc_event_t *event) { isc_result_t result; - printf("once_event\n"); + if (verbose) { + print_message("# once_event\n"); + } /* * Allow task1 to start processing events. @@ -446,7 +456,7 @@ once_event(isc_task_t *task, isc_event_t *event) { startflag = 1; result = isc_condition_broadcast(&cv); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); UNLOCK(&mx); isc_event_free(&event); @@ -460,7 +470,9 @@ shutdown_purge(isc_task_t *task, isc_event_t *event) { UNUSED(task); UNUSED(event); - printf("shutdown_event\n"); + if (verbose) { + print_message("# shutdown_event\n"); + } /* * Signal shutdown processing complete. @@ -469,26 +481,21 @@ shutdown_purge(isc_task_t *task, isc_event_t *event) { shutdownflag = 1; result = isc_condition_signal(&cv); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); UNLOCK(&mx); isc_event_free(&event); } -ATF_TC(purge); -ATF_TC_HEAD(purge, tc) { - atf_tc_set_md_var(tc, "descr", "timer events purged"); -} -ATF_TC_BODY(purge, tc) { +/* timer events purged */ +static void +purge(void **state) { isc_result_t result; isc_event_t *event = NULL; isc_time_t expires; isc_interval_t interval; - UNUSED(tc); - - result = isc_test_begin(NULL, true, 2); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + UNUSED(state); startflag = 0; shutdownflag = 0; @@ -497,25 +504,25 @@ ATF_TC_BODY(purge, tc) { nanoseconds = 0; result = isc_mutex_init(&mx); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); result = isc_condition_init(&cv); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); result = isc_task_create(taskmgr, 0, &task1); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); result = isc_task_onshutdown(task1, shutdown_purge, NULL); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); result = isc_task_create(taskmgr, 0, &task2); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); LOCK(&mx); event = isc_event_allocate(mctx, (void *)1 , (isc_eventtype_t)1, start_event, NULL, sizeof(*event)); - ATF_REQUIRE(event != NULL); + assert_non_null(event); isc_task_send(task1, &event); isc_time_settoepoch(&expires); @@ -525,49 +532,71 @@ ATF_TC_BODY(purge, tc) { result = isc_timer_create(timermgr, isc_timertype_ticker, &expires, &interval, task1, tick_event, NULL, &tickertimer); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); oncetimer = NULL; isc_interval_set(&interval, (seconds * 2) + 1, 0); result = isc_time_nowplusinterval(&expires, &interval); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); isc_interval_set(&interval, 0, 0); result = isc_timer_create(timermgr, isc_timertype_once, &expires, &interval, task2, once_event, NULL, &oncetimer); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); /* * Wait for shutdown processing to complete. */ while (! shutdownflag) { result = isc_condition_wait(&cv, &mx); - ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); + assert_int_equal(result, ISC_R_SUCCESS); } UNLOCK(&mx); - ATF_CHECK_EQ(eventcnt, 1); + assert_int_equal(eventcnt, 1); isc_timer_detach(&tickertimer); isc_timer_detach(&oncetimer); isc_task_destroy(&task1); isc_task_destroy(&task2); DESTROYLOCK(&mx); - - isc_test_end(); } -/* - * Main - */ -ATF_TP_ADD_TCS(tp) { - ATF_TP_ADD_TC(tp, ticker); - ATF_TP_ADD_TC(tp, once_life); - ATF_TP_ADD_TC(tp, once_idle); - ATF_TP_ADD_TC(tp, reset); - ATF_TP_ADD_TC(tp, purge); - return (atf_no_error()); +int +main(int argc, char **argv) { + const struct CMUnitTest tests[] = { + cmocka_unit_test_setup_teardown(ticker, _setup, _teardown), + cmocka_unit_test_setup_teardown(once_life, _setup, _teardown), + cmocka_unit_test_setup_teardown(once_idle, _setup, _teardown), + cmocka_unit_test_setup_teardown(reset, _setup, _teardown), + cmocka_unit_test_setup_teardown(purge, _setup, _teardown), + }; + int c; + + while ((c = isc_commandline_parse(argc, argv, "v")) != -1) { + switch (c) { + case 'v': + verbose = true; + break; + default: + break; + } + } + + 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