diff --git a/common/Makefile.am b/common/Makefile.am index e4d4f9c8..8bd27f7e 100644 --- a/common/Makefile.am +++ b/common/Makefile.am @@ -10,4 +10,8 @@ libdhcp_a_SOURCES = alloc.c bpf.c comapi.c conflex.c ctrace.c discover.c \ man_MANS = dhcp-eval.5 dhcp-options.5 EXTRA_DIST = $(man_MANS) -SUBDIRS = tests +SUBDIRS = . + +if HAVE_ATF + SUBDIRS += tests +endif diff --git a/common/tests/Makefile.am b/common/tests/Makefile.am index 70eb50ad..dd55e4fb 100644 --- a/common/tests/Makefile.am +++ b/common/tests/Makefile.am @@ -1,11 +1,16 @@ -AM_CPPFLAGS = -I../.. +SUBDIRS = . -check_PROGRAMS = test_alloc +AM_CPPFLAGS = $(ATF_CFLAGS) -I$(top_srcdir)/includes -TESTS = test_alloc +ATF_TESTS = alloc_unittest -test_alloc_SOURCES = test_alloc.c -test_alloc_LDADD = ../libdhcp.a ../../tests/libt_api.a \ +check_PROGRAMS = $(ATF_TESTS) + +alloc_unittest_SOURCES = test_alloc.c $(top_srcdir)/tests/t_api_dhcp.c +alloc_unittest_LDADD = $(ATF_LDFLAGS) +alloc_unittest_LDADD += ../libdhcp.a \ ../../omapip/libomapi.a ../../bind/lib/libdns.a \ ../../bind/lib/libisc.a +check: $(ATF_TESTS) + atf-run | atf-report diff --git a/common/tests/test_alloc.c b/common/tests/test_alloc.c index c0e1b9af..d941c8fb 100644 --- a/common/tests/test_alloc.c +++ b/common/tests/test_alloc.c @@ -1,5 +1,7 @@ /* - * We test the functions provided in alloc.c here. These are very + * Copyright (c) 2007,2009,2012 by Internet Systems Consortium, Inc. ("ISC") + * + * We test the functions provided in alloc.c here. These are very * basic functions, and it is very important that they work correctly. * * You can see two different styles of testing: @@ -16,482 +18,384 @@ * tests, and less duplicated and extra code. The advantage of having * a separate test is that each test is simpler. Plus if you need to * allow certain tests to fail for some reason (known bugs that are - * hard to fix for example), then + * hard to fix for example), then */ -/* TODO: dmalloc() test */ +/** @TODO: dmalloc() test */ #include "config.h" -#include "t_api.h" - +#include #include "dhcpd.h" -static void test_buffer_allocate(void); -static void test_buffer_reference(void); -static void test_buffer_dereference(void); -static void test_data_string_forget(void); -static void test_data_string_forget_nobuf(void); -static void test_data_string_copy(void); -static void test_data_string_copy_nobuf(void); +ATF_TC(buffer_allocate); -/* - * T_testlist is a list of tests that are invoked. - */ -testspec_t T_testlist[] = { - { test_buffer_allocate, - "buffer_allocate()" }, - { test_buffer_reference, - "buffer_reference()" }, - { test_buffer_dereference, - "buffer_dereference()" }, - { test_data_string_forget, - "data_string_forget()" }, - { test_data_string_forget_nobuf, - "data_string_forget(), no buffer" }, - { test_data_string_copy, - "data_string_copy()" }, - { test_data_string_copy_nobuf, - "data_string_copy(), no buffer" }, - { NULL, NULL } -}; - -static void -test_buffer_allocate(void) { - static const char *test_desc = - "buffer_allocate basic test"; - - struct buffer *buf; - - t_assert("buffer_allocate", 1, T_REQUIRED, "%s", test_desc); - - /* - * Check a 0-length buffer. - */ - buf = NULL; - if (!buffer_allocate(&buf, 0, MDL)) { - t_info("failed on 0-len buffer\n"); - t_result(T_FAIL); - return; - } - if (!buffer_dereference(&buf, MDL)) { - t_info("buffer_dereference() failed\n"); - t_result(T_FAIL); - return; - } - if (buf != NULL) { - t_info("buffer_dereference() did not NULL-out buffer\n"); - t_result(T_FAIL); - return; - } - - /* - * Check an actual buffer. - */ - buf = NULL; - if (!buffer_allocate(&buf, 100, MDL)) { - t_info("failed on allocate\n"); - t_result(T_FAIL); - return; - } - if (!buffer_dereference(&buf, MDL)) { - t_info("buffer_dereference() failed\n"); - t_result(T_FAIL); - return; - } - if (buf != NULL) { - t_info("buffer_dereference() did not NULL-out buffer\n"); - t_result(T_FAIL); - return; - } - - /* - * Okay, we're happy. - */ - t_result(T_PASS); +ATF_TC_HEAD(buffer_allocate, tc) { + atf_tc_set_md_var(tc, "descr", "buffer_allocate basic test"); } -static void -test_buffer_reference(void) { - static const char *test_desc = - "buffer_reference basic test"; - int result = T_PASS; +ATF_TC_BODY(buffer_allocate, tc) { + struct buffer *buf = 0; - struct buffer *a, *b; + /* + * Check a 0-length buffer. + */ + buf = NULL; + if (!buffer_allocate(&buf, 0, MDL)) { + atf_tc_fail("failed on 0-len buffer"); + } + if (!buffer_dereference(&buf, MDL)) { + atf_tc_fail("buffer_dereference() failed"); + } + if (buf != NULL) { + atf_tc_fail("buffer_dereference() did not NULL-out buffer"); + } - t_assert("buffer_reference", 1, T_REQUIRED, "%s", test_desc); + /* + * Check an actual buffer. + */ + buf = NULL; + if (!buffer_allocate(&buf, 100, MDL)) { + atf_tc_fail("failed on allocate 100 bytes\n"); + } + if (!buffer_dereference(&buf, MDL)) { + atf_tc_fail("buffer_dereference() failed"); + } + if (buf != NULL) { + atf_tc_fail("buffer_dereference() did not NULL-out buffer"); + } - /* - * Create a buffer. - */ - a = NULL; - if (!buffer_allocate(&a, 100, MDL)) { - t_info("failed on allocate\n"); - t_result(T_FAIL); - return; - } - - /* - * Confirm buffer_reference() doesn't work if we pass in NULL. - * - * TODO: we should confirm we get an error message here. - */ - if (buffer_reference(NULL, a, MDL)) { - t_info("succeeded on an error input\n"); - t_result(T_FAIL); - return; - } - - /* - * TODO: we should confirm we get an error message if we pass - * a non-NULL target. - */ - - /* - * Confirm we work under normal circumstances. - */ - b = NULL; - if (!buffer_reference(&b, a, MDL)) { - t_info("buffer_reference() failed\n"); - t_result(T_FAIL); - return; - } - - if (b != a) { - t_info("incorrect pointer\n"); - result = T_FAIL; - } - if (b->refcnt != 2) { - t_info("incorrect refcnt\n"); - result = T_FAIL; - } - - /* - * Clean up. - */ - if (!buffer_dereference(&b, MDL)) { - t_info("buffer_dereference() failed\n"); - t_result(T_FAIL); - return; - } - if (!buffer_dereference(&a, MDL)) { - t_info("buffer_dereference() failed\n"); - t_result(T_FAIL); - return; - } - - t_result(result); + /* + * Okay, we're happy. + */ + atf_tc_pass(); } -static void -test_buffer_dereference(void) { - static const char *test_desc = - "buffer_dereference basic test"; +ATF_TC(buffer_reference); - struct buffer *a, *b; - - t_assert("buffer_dereference", 1, T_REQUIRED, "%s", test_desc); - - /* - * Confirm buffer_dereference() doesn't work if we pass in NULL. - * - * TODO: we should confirm we get an error message here. - */ - if (buffer_dereference(NULL, MDL)) { - t_info("succeeded on an error input\n"); - t_result(T_FAIL); - return; - } - - /* - * Confirm buffer_dereference() doesn't work if we pass in - * a pointer to NULL. - * - * TODO: we should confirm we get an error message here. - */ - a = NULL; - if (buffer_dereference(&a, MDL)) { - t_info("succeeded on an error input\n"); - t_result(T_FAIL); - return; - } - - /* - * Confirm we work under normal circumstances. - */ - a = NULL; - if (!buffer_allocate(&a, 100, MDL)) { - t_info("failed on allocate\n"); - t_result(T_FAIL); - return; - } - if (!buffer_dereference(&a, MDL)) { - t_info("buffer_dereference() failed\n"); - t_result(T_FAIL); - return; - } - if (a != NULL) { - t_info("non-null buffer after buffer_dereference()\n"); - t_result(T_FAIL); - return; - } - - /* - * Confirm we get an error from negative refcnt. - * - * TODO: we should confirm we get an error message here. - */ - a = NULL; - if (!buffer_allocate(&a, 100, MDL)) { - t_info("failed on allocate\n"); - t_result(T_FAIL); - return; - } - b = NULL; - if (!buffer_reference(&b, a, MDL)) { - t_info("buffer_reference() failed\n"); - t_result(T_FAIL); - return; - } - a->refcnt = 0; /* purposely set to invalid value */ - if (buffer_dereference(&a, MDL)) { - t_info("buffer_dereference() succeeded on error input\n"); - t_result(T_FAIL); - return; - } - a->refcnt = 2; - if (!buffer_dereference(&b, MDL)) { - t_info("buffer_dereference() failed\n"); - t_result(T_FAIL); - return; - } - if (!buffer_dereference(&a, MDL)) { - t_info("buffer_dereference() failed\n"); - t_result(T_FAIL); - return; - } - - t_result(T_PASS); +ATF_TC_HEAD(buffer_reference, tc) { + atf_tc_set_md_var(tc, "descr", "buffer_reference basic test"); } -static void -test_data_string_forget(void) { - static const char *test_desc = - "data_string_forget basic test"; - int result = T_PASS; +ATF_TC_BODY(buffer_reference, tc) { - struct buffer *buf; - struct data_string a; - const char *str = "Lorem ipsum dolor sit amet turpis duis."; + struct buffer *a, *b; - t_assert("data_string_forget", 1, T_REQUIRED, "%s", test_desc); + /* + * Create a buffer. + */ + a = NULL; + if (!buffer_allocate(&a, 100, MDL)) { + atf_tc_fail("failed on allocate 100 bytes"); + } - /* - * Create the string we want to forget. - */ - memset(&a, 0, sizeof(a)); - a.len = strlen(str); - buf = NULL; - if (!buffer_allocate(&buf, a.len, MDL)) { - t_info("out of memory\n"); - t_result(T_FAIL); - return; - } - if (!buffer_reference(&a.buffer, buf, MDL)) { - t_info("buffer_reference() failed\n"); - t_result(T_FAIL); - return; - } - a.data = a.buffer->data; - memcpy(a.buffer->data, str, a.len); + /** + * Confirm buffer_reference() doesn't work if we pass in NULL. + * + * @TODO: we should confirm we get an error message here. + */ + if (buffer_reference(NULL, a, MDL)) { + atf_tc_fail("succeeded on an error input"); + } - /* - * Forget and confirm we've forgotten. - */ - data_string_forget(&a, MDL); + /** + * @TODO: we should confirm we get an error message if we pass + * a non-NULL target. + */ - if (a.len != 0) { - t_info("incorrect length\n"); - result = T_FAIL; - } - if (a.data != NULL) { - t_info("incorrect data\n"); - result = T_FAIL; - } - if (a.terminated) { - t_info("incorrect terminated\n"); - result = T_FAIL; - } - if (a.buffer != NULL) { - t_info("incorrect buffer\n"); - result = T_FAIL; - } - if (buf->refcnt != 1) { - t_info("too many references to buf\n"); - result = T_FAIL; - } + /* + * Confirm we work under normal circumstances. + */ + b = NULL; + if (!buffer_reference(&b, a, MDL)) { + atf_tc_fail("buffer_reference() failed"); + } - /* - * Clean up buffer. - */ - if (!buffer_dereference(&buf, MDL)) { - t_info("buffer_reference() failed\n"); - t_result(T_FAIL); - return; - } + if (b != a) { + atf_tc_fail("incorrect pointer returned"); + } + + if (b->refcnt != 2) { + atf_tc_fail("incorrect refcnt"); + } + + /* + * Clean up. + */ + if (!buffer_dereference(&b, MDL)) { + atf_tc_fail("buffer_dereference() failed"); + } + if (!buffer_dereference(&a, MDL)) { + atf_tc_fail("buffer_dereference() failed"); + } - t_result(result); } -static void -test_data_string_forget_nobuf(void) { - static const char *test_desc = - "data_string_forget test, data_string without buffer"; - int result = T_PASS; - struct data_string a; - const char *str = "Lorem ipsum dolor sit amet massa nunc."; +ATF_TC(buffer_dereference); - t_assert("data_string_forget, no buffer", 1, T_REQUIRED, "%s", test_desc); - - /* - * Create the string we want to forget. - */ - memset(&a, 0, sizeof(a)); - a.len = strlen(str); - a.data = (const unsigned char *)str; - a.terminated = 1; - - /* - * Forget and confirm we've forgotten. - */ - data_string_forget(&a, MDL); - - if (a.len != 0) { - t_info("incorrect length\n"); - result = T_FAIL; - } - if (a.data != NULL) { - t_info("incorrect data\n"); - result = T_FAIL; - } - if (a.terminated) { - t_info("incorrect terminated\n"); - result = T_FAIL; - } - if (a.buffer != NULL) { - t_info("incorrect buffer\n"); - result = T_FAIL; - } - - t_result(result); +ATF_TC_HEAD(buffer_dereference, tc) { + atf_tc_set_md_var(tc, "descr", "buffer_dereference basic test"); } -static void -test_data_string_copy(void) { - static const char *test_desc = - "data_string_copy basic test"; - int result = T_PASS; +ATF_TC_BODY(buffer_dereference, tc) { + struct buffer *a, *b; - struct data_string a, b; - const char *str = "Lorem ipsum dolor sit amet orci aliquam."; + /** + * Confirm buffer_dereference() doesn't work if we pass in NULL. + * + * TODO: we should confirm we get an error message here. + */ + if (buffer_dereference(NULL, MDL)) { + atf_tc_fail("succeeded on an error input"); + } - t_assert("data_string_copy", 1, T_REQUIRED, "%s", test_desc); + /** + * Confirm buffer_dereference() doesn't work if we pass in + * a pointer to NULL. + * + * @TODO: we should confirm we get an error message here. + */ + a = NULL; + if (buffer_dereference(&a, MDL)) { + atf_tc_fail("succeeded on an error input"); + } + /* + * Confirm we work under normal circumstances. + */ + a = NULL; + if (!buffer_allocate(&a, 100, MDL)) { + atf_tc_fail("failed on allocate"); + } + if (!buffer_dereference(&a, MDL)) { + atf_tc_fail("buffer_dereference() failed"); + } + if (a != NULL) { + atf_tc_fail("non-null buffer after buffer_dereference()"); + } - /* - * Create the string we want to copy. - */ - memset(&a, 0, sizeof(a)); - a.len = strlen(str); - if (!buffer_allocate(&a.buffer, a.len, MDL)) { - t_info("out of memory\n"); - t_result(T_FAIL); - return; - } - a.data = a.buffer->data; - memcpy(a.buffer->data, str, a.len); - - /* - * Copy the string, and confirm it works. - */ - memset(&b, 0, sizeof(b)); - data_string_copy(&b, &a, MDL); - - if (b.len != a.len) { - t_info("incorrect length\n"); - result = T_FAIL; - } - if (b.data != a.data) { - t_info("incorrect data\n"); - result = T_FAIL; - } - if (b.terminated != a.terminated) { - t_info("incorrect terminated\n"); - result = T_FAIL; - } - if (b.buffer != a.buffer) { - t_info("incorrect buffer\n"); - result = T_FAIL; - } - - /* - * Clean up. - */ - data_string_forget(&b, MDL); - data_string_forget(&a, MDL); - - t_result(result); + /** + * Confirm we get an error from negative refcnt. + * + * @TODO: we should confirm we get an error message here. + */ + a = NULL; + if (!buffer_allocate(&a, 100, MDL)) { + atf_tc_fail("failed on allocate"); + } + b = NULL; + if (!buffer_reference(&b, a, MDL)) { + atf_tc_fail("buffer_reference() failed"); + } + a->refcnt = 0; /* purposely set to invalid value */ + if (buffer_dereference(&a, MDL)) { + atf_tc_fail("buffer_dereference() succeeded on error input"); + } + a->refcnt = 2; + if (!buffer_dereference(&b, MDL)) { + atf_tc_fail("buffer_dereference() failed"); + } + if (!buffer_dereference(&a, MDL)) { + atf_tc_fail("buffer_dereference() failed"); + } } -static void -test_data_string_copy_nobuf(void) { - static const char *test_desc = - "data_string_copy test, data_string without buffer"; - int result = T_PASS; +ATF_TC(data_string_forget); - struct data_string a, b; - const char *str = "Lorem ipsum dolor sit amet cras amet."; - - t_assert("data_string_copy, no buffer", 1, T_REQUIRED, "%s", - test_desc); - - - /* - * Create the string we want to copy. - */ - memset(&a, 0, sizeof(a)); - a.len = strlen(str); - a.data = (const unsigned char *)str; - a.terminated = 1; - - /* - * Copy the string, and confirm it works. - */ - memset(&b, 0, sizeof(b)); - data_string_copy(&b, &a, MDL); - - if (b.len != a.len) { - t_info("incorrect length\n"); - result = T_FAIL; - } - if (b.data != a.data) { - t_info("incorrect data\n"); - result = T_FAIL; - } - if (b.terminated != a.terminated) { - t_info("incorrect terminated\n"); - result = T_FAIL; - } - if (b.buffer != a.buffer) { - t_info("incorrect buffer\n"); - result = T_FAIL; - } - - /* - * Clean up. - */ - data_string_forget(&b, MDL); - data_string_forget(&a, MDL); - - t_result(result); +ATF_TC_HEAD(data_string_forget, tc) { + atf_tc_set_md_var(tc, "descr", "data_string_forget basic test"); +} + +ATF_TC_BODY(data_string_forget, tc) { + struct buffer *buf; + struct data_string a; + const char *str = "Lorem ipsum dolor sit amet turpis duis."; + + /* + * Create the string we want to forget. + */ + memset(&a, 0, sizeof(a)); + a.len = strlen(str); + buf = NULL; + if (!buffer_allocate(&buf, a.len, MDL)) { + atf_tc_fail("out of memory"); + } + if (!buffer_reference(&a.buffer, buf, MDL)) { + atf_tc_fail("buffer_reference() failed"); + } + a.data = a.buffer->data; + memcpy(a.buffer->data, str, a.len); + + /* + * Forget and confirm we've forgotten. + */ + data_string_forget(&a, MDL); + + if (a.len != 0) { + atf_tc_fail("incorrect length"); + } + + if (a.data != NULL) { + atf_tc_fail("incorrect data"); + } + if (a.terminated) { + atf_tc_fail("incorrect terminated"); + } + if (a.buffer != NULL) { + atf_tc_fail("incorrect buffer"); + } + if (buf->refcnt != 1) { + atf_tc_fail("too many references to buf"); + } + + /* + * Clean up buffer. + */ + if (!buffer_dereference(&buf, MDL)) { + atf_tc_fail("buffer_reference() failed"); + } +} + +ATF_TC(data_string_forget_nobuf); + +ATF_TC_HEAD(data_string_forget_nobuf, tc) { + atf_tc_set_md_var(tc, "descr", "data_string_forget test, " + "data_string without buffer"); +} + +ATF_TC_BODY(data_string_forget_nobuf, tc) { + struct data_string a; + const char *str = "Lorem ipsum dolor sit amet massa nunc."; + + /* + * Create the string we want to forget. + */ + memset(&a, 0, sizeof(a)); + a.len = strlen(str); + a.data = (const unsigned char *)str; + a.terminated = 1; + + /* + * Forget and confirm we've forgotten. + */ + data_string_forget(&a, MDL); + + if (a.len != 0) { + atf_tc_fail("incorrect length"); + } + if (a.data != NULL) { + atf_tc_fail("incorrect data"); + } + if (a.terminated) { + atf_tc_fail("incorrect terminated"); + } + if (a.buffer != NULL) { + atf_tc_fail("incorrect buffer"); + } +} + +ATF_TC(data_string_copy); + +ATF_TC_HEAD(data_string_copy, tc) { + atf_tc_set_md_var(tc, "descr", "data_string_copy basic test"); +} + +ATF_TC_BODY(data_string_copy, tc) { + struct data_string a, b; + const char *str = "Lorem ipsum dolor sit amet orci aliquam."; + + /* + * Create the string we want to copy. + */ + memset(&a, 0, sizeof(a)); + a.len = strlen(str); + if (!buffer_allocate(&a.buffer, a.len, MDL)) { + atf_tc_fail("out of memory"); + } + a.data = a.buffer->data; + memcpy(a.buffer->data, str, a.len); + + /* + * Copy the string, and confirm it works. + */ + memset(&b, 0, sizeof(b)); + data_string_copy(&b, &a, MDL); + + if (b.len != a.len) { + atf_tc_fail("incorrect length"); + } + if (b.data != a.data) { + atf_tc_fail("incorrect data"); + } + if (b.terminated != a.terminated) { + atf_tc_fail("incorrect terminated"); + } + if (b.buffer != a.buffer) { + atf_tc_fail("incorrect buffer"); + } + + /* + * Clean up. + */ + data_string_forget(&b, MDL); + data_string_forget(&a, MDL); +} + +ATF_TC(data_string_copy_nobuf); + +ATF_TC_HEAD(data_string_copy_nobuf, tc) { + atf_tc_set_md_var(tc, "descr", "data_string_copy test, " + "data_string without buffer"); +} + +ATF_TC_BODY(data_string_copy_nobuf, tc) { + struct data_string a, b; + const char *str = "Lorem ipsum dolor sit amet cras amet."; + + /* + * Create the string we want to copy. + */ + memset(&a, 0, sizeof(a)); + a.len = strlen(str); + a.data = (const unsigned char *)str; + a.terminated = 1; + + /* + * Copy the string, and confirm it works. + */ + memset(&b, 0, sizeof(b)); + data_string_copy(&b, &a, MDL); + + if (b.len != a.len) { + atf_tc_fail("incorrect length"); + } + if (b.data != a.data) { + atf_tc_fail("incorrect data"); + } + if (b.terminated != a.terminated) { + atf_tc_fail("incorrect terminated"); + } + if (b.buffer != a.buffer) { + atf_tc_fail("incorrect buffer"); + } + + /* + * Clean up. + */ + data_string_forget(&b, MDL); + data_string_forget(&a, MDL); + +} + +ATF_TP_ADD_TCS(tp) +{ + ATF_TP_ADD_TC(tp, buffer_allocate); + ATF_TP_ADD_TC(tp, buffer_reference); + ATF_TP_ADD_TC(tp, buffer_dereference); + ATF_TP_ADD_TC(tp, data_string_forget); + ATF_TP_ADD_TC(tp, data_string_forget_nobuf); + ATF_TP_ADD_TC(tp, data_string_copy); + ATF_TP_ADD_TC(tp, data_string_copy_nobuf); + + return (atf_no_error()); } diff --git a/configure.ac b/configure.ac index 98a019dc..7185c443 100644 --- a/configure.ac +++ b/configure.ac @@ -651,7 +651,6 @@ Developer: ATF unittests : $enable_atf END -# TODO: Add unit tests # TODO: Add Perl system tests if test "$enable_atf" != "no" diff --git a/server/tests/Makefile.am b/server/tests/Makefile.am index 48ec3e4c..6d6561d4 100644 --- a/server/tests/Makefile.am +++ b/server/tests/Makefile.am @@ -1,6 +1,6 @@ SUBDIRS = . -AM_CPPFLAGS = $(ATF_CFLAGS) -DUNIT_TEST -I$((top_srcdir)/includes +AM_CPPFLAGS = $(ATF_CFLAGS) -DUNIT_TEST -I$(top_srcdir)/includes AM_CPPFLAGS += -I$(top_srcdir)/bind/include -I$(top_srcdir) AM_CPPFLAGS += -DLOCALSTATEDIR='"."' -Wno-unused-function -Wno-error=unused-variable @@ -42,4 +42,4 @@ legacy_unittests_LDADD = $(DHCPLIBS) $(ATF_LDFLAGS) endif -noinst_PROGRAMS = $(ATF_TESTS) $(TESTS) \ No newline at end of file +check_PROGRAMS = $(ATF_TESTS) $(TESTS) \ No newline at end of file diff --git a/server/tests/simple_unittest.c b/server/tests/simple_unittest.c index 18bcd9f3..825397ac 100644 --- a/server/tests/simple_unittest.c +++ b/server/tests/simple_unittest.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2012 Internet Systems Consortium, Inc. ("ISC") + * Copyright (C) 2012 Internet Systems Consortium, Inc. ("ISC") * * Permission to use, copy, modify, and/or distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -17,27 +17,61 @@ #include #include +/* That is an example ATF test case, tailored to ISC DHCP sources. + For detailed description with examples, see man 3 atf-c-api. */ + +/* this macro defines a name of a test case. Typical test case constists + of an initial test declaration (ATF_TC()) followed by 3 phases: + + - Initialization: ATF_TC_HEAD() + - Main body: ATF_TC_BODY() + - Cleanup: ATF_TC_CLEANUP() + + In many cases initialization or cleanup are not needed. Use + ATF_TC_WITHOUT_HEAD() or ATF_TC_WITH_CLEANUP() as needed. */ ATF_TC(simple_test_case); + + ATF_TC_HEAD(simple_test_case, tc) { atf_tc_set_md_var(tc, "descr", "This test case is a simple DHCP test."); } ATF_TC_BODY(simple_test_case, tc) { - //ATF_CHECK(returns_a_boolean()); /* Non-fatal test. */ - //ATF_REQUIRE(returns_a_boolean()); /* Fatal test. */ + int condition = 1; + int this_is_linux = 1; + /* Failing condition will fail the test, but the code + itself will continue */ + ATF_CHECK( 2 > 1 ); - //ATF_CHECK_EQ(4, 2 + 2); /* Non-fatal test. */ - //ATF_REQUIRE_EQ(4, 2 + 2); /* Fatal test. */ + /* assert style check. Test will abort if the condition is not met. */ + ATF_REQUIRE( 5 > 4 ); + + ATF_CHECK_EQ(4, 2 + 2); /* Non-fatal test. */ + ATF_REQUIRE_EQ(4, 2 + 2); /* Fatal test. */ + + /* tests can also explicitly report test result */ + if (!condition) { + atf_tc_fail("Condition not met!"); /* Explicit failure. */ + } + + if (!this_is_linux) { + atf_tc_skip("Skipping test. This Linux-only test."); + } + + if (condition && linux) { + /* no extra comments for pass needed. It just passed. */ + atf_tc_pass(); + } - //if (!condition) -// atf_tc_fail("Condition not met!"); /* Explicit failure. */ } +/* This macro defines main() method that will call specified + test cases. tp and simple_test_case names can be whatever you want + as long as it is a valid variable identifier. */ ATF_TP_ADD_TCS(tp) { ATF_TP_ADD_TC(tp, simple_test_case); return (atf_no_error()); } -