Commit db81cc0c authored by Tomek Mrugalski's avatar Tomek Mrugalski 🛰

[25901_atf] Existing alloc tests in common converted to ATF

parent c08a7075
......@@ -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
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
/*
* 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 <atf-c.h>
#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;
struct buffer *a, *b;
t_assert("buffer_reference", 1, T_REQUIRED, "%s", test_desc);
/*
* 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);
ATF_TC_BODY(buffer_allocate, tc) {
struct buffer *buf = 0;
/*
* 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");
}
/*
* 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");
}
/*
* Okay, we're happy.
*/
atf_tc_pass();
}
static void
test_buffer_dereference(void) {
static const char *test_desc =
"buffer_dereference basic test";
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(buffer_reference);
ATF_TC_HEAD(buffer_reference, tc) {
atf_tc_set_md_var(tc, "descr", "buffer_reference basic test");
}
ATF_TC_BODY(buffer_reference, tc) {
struct buffer *a, *b;
/*
* Create a buffer.
*/
a = NULL;
if (!buffer_allocate(&a, 100, MDL)) {
atf_tc_fail("failed on allocate 100 bytes");
}
/**
* 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");
}
/**
* @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)) {
atf_tc_fail("buffer_reference() failed");
}
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");
}
}
static void
test_data_string_forget(void) {
static const char *test_desc =
"data_string_forget basic test";
int result = T_PASS;
struct buffer *buf;
struct data_string a;
const char *str = "Lorem ipsum dolor sit amet turpis duis.";
t_assert("data_string_forget", 1, T_REQUIRED, "%s", test_desc);
/*
* 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);
/*
* 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;
}
if (buf->refcnt != 1) {
t_info("too many references to buf\n");
result = T_FAIL;
}
/*
* Clean up buffer.
*/
if (!buffer_dereference(&buf, MDL)) {
t_info("buffer_reference() failed\n");
t_result(T_FAIL);
return;
}
t_result(result);
ATF_TC(buffer_dereference);
ATF_TC_HEAD(buffer_dereference, tc) {
atf_tc_set_md_var(tc, "descr", "buffer_dereference basic test");
}
ATF_TC_BODY(buffer_dereference, tc) {
struct buffer *a, *b;
/**
* 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");
}
/**
* 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()");
}
/**
* 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");
}
}
ATF_TC(data_string_forget);
ATF_TC_HEAD(data_string_forget, tc) {
atf_tc_set_md_var(tc, "descr", "data_string_forget basic test");
}
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.";
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_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");
}
}
static void
test_data_string_copy(void) {
static const char *test_desc =
"data_string_copy basic test";
int result = T_PASS;
struct data_string a, b;
const char *str = "Lorem ipsum dolor sit amet orci aliquam.";
t_assert("data_string_copy", 1, T_REQUIRED, "%s", test_desc);
/*
* Create the string we want to copy.
*/
memset(&a, 0, sizeof(a));
a.len = strlen(str);