ATF_TC_BODY(loadraw, tc) {
isc_result_t result;
UNUSED(tc);
result = dns_test_begin(NULL, ISC_FALSE);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
/* Raw format version 0 */
result = test_master("testdata/master/master12.data",
dns_masterformat_raw, NULL, NULL);
ATF_CHECK_STREQ(isc_result_totext(result), "success");
ATF_CHECK(headerset);
ATF_CHECK_EQ(header.flags, 0);
/* Raw format version 1, no source serial */
result = test_master("testdata/master/master13.data",
dns_masterformat_raw, NULL, NULL);
ATF_CHECK_STREQ(isc_result_totext(result), "success");
ATF_CHECK(headerset);
ATF_CHECK_EQ(header.flags, 0);
/* Raw format version 1, source serial == 2011120101 */
result = test_master("testdata/master/master14.data",
dns_masterformat_raw, NULL, NULL);
ATF_CHECK_STREQ(isc_result_totext(result), "success");
ATF_CHECK(headerset);
ATF_CHECK((header.flags & DNS_MASTERRAW_SOURCESERIALSET) != 0);
ATF_CHECK_EQ(header.sourceserial, 2011120101);
dns_test_end();
}
ATF_TC_BODY(setenv_basic, tc)
{
const size_t numvars = 8192;
size_t i, offset;
char name[1024];
char value[1024];
offset = lrand48();
for (i = 0; i < numvars; i++) {
(void)snprintf(name, sizeof(name), "var%zu",
(i * 7 + offset) % numvars);
(void)snprintf(value, sizeof(value), "value%ld", lrand48());
ATF_CHECK(setenv(name, value, 1) != -1);
ATF_CHECK(setenv(name, "foo", 0) != -1);
ATF_CHECK_STREQ(getenv(name), value);
}
offset = lrand48();
for (i = 0; i < numvars; i++) {
(void)snprintf(name, sizeof(name), "var%zu",
(i * 11 + offset) % numvars);
ATF_CHECK(unsetenv(name) != -1);
ATF_CHECK(getenv(name) == NULL);
ATF_CHECK(unsetenv(name) != -1);
}
ATF_CHECK_ERRNO(EINVAL, setenv(NULL, "val", 1) == -1);
ATF_CHECK_ERRNO(EINVAL, setenv("", "val", 1) == -1);
ATF_CHECK_ERRNO(EINVAL, setenv("v=r", "val", 1) == -1);
ATF_CHECK_ERRNO(EINVAL, setenv("var", NULL, 1) == -1);
ATF_CHECK(setenv("var", "=val", 1) == 0);
ATF_CHECK_STREQ(getenv("var"), "=val");
}
ATF_TC_BODY(t_saslc__error, tc)
{
saslc_t *ctx;
ATF_REQUIRE(ctx = saslc_alloc());
ATF_REQUIRE_EQ(saslc_init(ctx, NULL, NULL), 0);
saslc__error_set(ERR(ctx), ERROR_GENERAL, "test");
ATF_CHECK_EQ(saslc__error_get_errno(ERR(ctx)), ERROR_GENERAL);
ATF_CHECK_STREQ(saslc_strerror(ctx), "test");
saslc__error_set_errno(ERR(ctx), ERROR_NOMEM);
ATF_CHECK_STREQ(saslc_strerror(ctx), "no memory available");
ATF_REQUIRE_EQ(saslc_end(ctx), 0);
}
ATF_TC_BODY(getenv_basic, tc)
{
ATF_CHECK(setenv("EVIL", "very=bad", 1) != -1);
ATF_CHECK_STREQ(getenv("EVIL"), "very=bad");
ATF_CHECK(getenv("EVIL=very") == NULL);
ATF_CHECK(unsetenv("EVIL") != -1);
}
ATF_TC_BODY(master_includelist, tc) {
isc_result_t result;
char *filename = NULL;
UNUSED(tc);
result = dns_test_begin(NULL, ISC_FALSE);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
result = setup_master(NULL, NULL);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
result = dns_master_loadfile4("testdata/master/master8.data",
&dns_origin, &dns_origin,
dns_rdataclass_in, 0, ISC_TRUE,
&callbacks, include_callback,
&filename, mctx, dns_masterformat_text);
ATF_CHECK_EQ(result, DNS_R_SEENINCLUDE);
ATF_CHECK(filename != NULL);
if (filename != NULL) {
ATF_CHECK_STREQ(filename, "testdata/master/master7.data");
isc_mem_free(mctx, filename);
}
dns_test_end();
}
/*
* Load test data into the RBT.
*/
static void
add_test_data(isc_mem_t *mymctx, dns_rbt_t *rbt) {
char buffer[1024];
isc_buffer_t b;
isc_result_t result;
dns_fixedname_t fname;
dns_name_t *name;
dns_compress_t cctx;
rbt_testdata_t *testdatap = testdata;
dns_compress_init(&cctx, -1, mymctx);
while (testdatap->name != NULL && testdatap->data.data != NULL) {
memmove(buffer, testdatap->name, testdatap->name_len);
isc_buffer_init(&b, buffer, testdatap->name_len);
isc_buffer_add(&b, testdatap->name_len);
dns_fixedname_init(&fname);
name = dns_fixedname_name(&fname);
result = dns_name_fromtext(name, &b, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS) {
testdatap++;
continue;
}
if (name != NULL) {
result = dns_rbt_addname(rbt, name, &testdatap->data);
ATF_CHECK_STREQ(dns_result_totext(result), "success");
}
testdatap++;
}
dns_compress_invalidate(&cctx);
}
ATF_TC_BODY(isc_net_ntop, tc) {
char buf[sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255")];
int r;
size_t i;
unsigned char abuf[16];
struct {
int family;
const char * address;
} testdata[] = {
{ AF_INET, "0.0.0.0" },
{ AF_INET, "0.1.0.0" },
{ AF_INET, "0.0.2.0" },
{ AF_INET, "0.0.0.3" },
{ AF_INET, "255.255.255.255" },
{ AF_INET6, "::" },
{ AF_INET6, "::1.2.3.4" },
{ AF_INET6, "::ffff:1.2.3.4" },
{ AF_INET6, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff" }
};
for (i = 0; i < sizeof(testdata)/sizeof(testdata[0]); i++) {
r = inet_pton(testdata[i].family, testdata[i].address, abuf);
ATF_REQUIRE_EQ_MSG(r, 1, "%s", testdata[i].address);
isc_net_ntop(testdata[i].family, abuf, buf, sizeof(buf));
ATF_CHECK_STREQ(buf, testdata[i].address);
}
}
ATF_TC_BODY(md5, tc)
{
const char want[] = "$1$deadbeef$0Huu6KHrKLVWfqa4WljDE0";
char *pw;
pw = crypt(LEET, want);
ATF_CHECK_STREQ(pw, want);
}
ATF_TC_BODY(putenv_basic, tc)
{
char string[1024];
snprintf(string, sizeof(string), "crap=true");
ATF_CHECK(putenv(string) != -1);
ATF_CHECK_STREQ(getenv("crap"), "true");
string[1] = 'l';
ATF_CHECK_STREQ(getenv("clap"), "true");
ATF_CHECK(getenv("crap") == NULL);
string[1] = 'r';
ATF_CHECK(unsetenv("crap") != -1);
ATF_CHECK(getenv("crap") == NULL);
ATF_CHECK_ERRNO(EINVAL, putenv(NULL) == -1);
ATF_CHECK_ERRNO(EINVAL, putenv(__UNCONST("val")) == -1);
ATF_CHECK_ERRNO(EINVAL, putenv(__UNCONST("=val")) == -1);
}
ATF_TC_BODY(isc_aes128, tc) {
UNUSED(tc);
aes_testcase_t testcases[] = {
/* Test 1 (KAT ECBVarTxt128 #3) */
{
"00000000000000000000000000000000",
"F0000000000000000000000000000000",
"96D9FD5CC4F07441727DF0F33E401A36"
},
/* Test 2 (KAT ECBVarTxt128 #123) */
{
"00000000000000000000000000000000",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0",
"F9B0FDA0C4A898F5B9E6F661C4CE4D07"
},
/* Test 3 (KAT ECBVarKey128 #3) */
{
"F0000000000000000000000000000000",
"00000000000000000000000000000000",
"970014D634E2B7650777E8E84D03CCD8"
},
/* Test 4 (KAT ECBVarKey128 #123) */
{
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0",
"00000000000000000000000000000000",
"41C78C135ED9E98C096640647265DA1E"
},
/* Test 5 (KAT ECBGFSbox128 #3) */
{
"00000000000000000000000000000000",
"6A118A874519E64E9963798A503F1D35",
"DC43BE40BE0E53712F7E2BF5CA707209"
},
/* Test 6 (KAT ECBKeySbox128 #3) */
{
"B6364AC4E1DE1E285EAF144A2415F7A0",
"00000000000000000000000000000000",
"5D9B05578FC944B3CF1CCF0E746CD581"
},
{ NULL, NULL, NULL }
};
aes_testcase_t *testcase = testcases;
while (testcase->key != NULL) {
len = fromhexstr(testcase->key, key);
ATF_CHECK_EQ(len, ISC_AES128_KEYLENGTH);
len = fromhexstr(testcase->input, plaintext);
ATF_CHECK_EQ(len, ISC_AES_BLOCK_LENGTH);
isc_aes128_crypt(key, plaintext, ciphertext);
ATF_CHECK(tohexstr(ciphertext, str) == ISC_R_SUCCESS);
ATF_CHECK_STREQ(str, testcase->result);
testcase++;
}
}
ATF_TC_BODY(isc_aes192, tc) {
UNUSED(tc);
aes_testcase_t testcases[] = {
/* Test 1 (KAT ECBVarTxt192 #3) */
{
"000000000000000000000000000000000000000000000000",
"F0000000000000000000000000000000",
"2A560364CE529EFC21788779568D5555"
},
/* Test 2 (KAT ECBVarTxt192 #123) */
{
"000000000000000000000000000000000000000000000000",
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0",
"2AABB999F43693175AF65C6C612C46FB"
},
/* Test 3 (KAT ECBVarKey192 #3) */
{
"F00000000000000000000000000000000000000000000000",
"00000000000000000000000000000000",
"180B09F267C45145DB2F826C2582D35C"
},
/* Test 4 (KAT ECBVarKey192 #187) */
{
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0",
"00000000000000000000000000000000",
"EACF1E6C4224EFB38900B185AB1DFD42"
},
/* Test 5 (KAT ECBGFSbox192 #3) */
{
"000000000000000000000000000000000000000000000000",
"51719783D3185A535BD75ADC65071CE1",
"4F354592FF7C8847D2D0870CA9481B7C"
},
/* Test 6 (KAT ECBKeySbox192 #3) */
{
"CD62376D5EBB414917F0C78F05266433DC9192A1EC943300",
"00000000000000000000000000000000",
"7F6C25FF41858561BB62F36492E93C29"
},
{ NULL, NULL, NULL }
};
aes_testcase_t *testcase = testcases;
while (testcase->key != NULL) {
len = fromhexstr(testcase->key, key);
ATF_CHECK_EQ(len, ISC_AES192_KEYLENGTH);
len = fromhexstr(testcase->input, plaintext);
ATF_CHECK_EQ(len, ISC_AES_BLOCK_LENGTH);
isc_aes192_crypt(key, plaintext, ciphertext);
ATF_CHECK(tohexstr(ciphertext, str) == ISC_R_SUCCESS);
ATF_CHECK_STREQ(str, testcase->result);
testcase++;
}
}
ATF_TC_BODY(setenv_basic, tc)
{
const size_t numvars = 8192;
size_t i, offset;
char name[1024];
char value[1024];
offset = lrand48();
for (i = 0; i < numvars; i++) {
(void)snprintf(name, sizeof(name), "var%zu",
(i * 7 + offset) % numvars);
(void)snprintf(value, sizeof(value), "value%ld", lrand48());
ATF_CHECK(setenv(name, value, 1) != -1);
ATF_CHECK(setenv(name, "foo", 0) != -1);
ATF_CHECK_STREQ(getenv(name), value);
}
offset = lrand48();
for (i = 0; i < numvars; i++) {
(void)snprintf(name, sizeof(name), "var%zu",
(i * 11 + offset) % numvars);
ATF_CHECK(unsetenv(name) != -1);
ATF_CHECK(getenv(name) == NULL);
ATF_CHECK(unsetenv(name) != -1);
}
ATF_CHECK_ERRNO(EINVAL, setenv(NULL, "val", 1) == -1);
ATF_CHECK_ERRNO(EINVAL, setenv("", "val", 1) == -1);
ATF_CHECK_ERRNO(EINVAL, setenv("v=r", "val", 1) == -1);
#ifdef __FreeBSD__
/*
Both FreeBSD and OS/X does not validate the second
argument to setenv(3)
*/
atf_tc_expect_signal(SIGSEGV, "FreeBSD does not validate the second "
"argument to setenv(3); see bin/189805");
#endif
ATF_CHECK_ERRNO(EINVAL, setenv("var", NULL, 1) == -1);
ATF_CHECK(setenv("var", "=val", 1) == 0);
ATF_CHECK_STREQ(getenv("var"), "=val");
}
ATF_TC_BODY(setenv_mixed, tc)
{
char string[32];
(void)strcpy(string, "mixedcrap=putenv");
ATF_CHECK(setenv("mixedcrap", "setenv", 1) != -1);
ATF_CHECK_STREQ(getenv("mixedcrap"), "setenv");
ATF_CHECK(putenv(string) != -1);
ATF_CHECK_STREQ(getenv("mixedcrap"), "putenv");
ATF_CHECK(unsetenv("mixedcrap") != -1);
ATF_CHECK(getenv("mixedcrap") == NULL);
ATF_CHECK(putenv(string) != -1);
ATF_CHECK_STREQ(getenv("mixedcrap"), "putenv");
ATF_CHECK(setenv("mixedcrap", "setenv", 1) != -1);
ATF_CHECK_STREQ(getenv("mixedcrap"), "setenv");
ATF_CHECK(unsetenv("mixedcrap") != -1);
ATF_CHECK(getenv("mixedcrap") == NULL);
}
ATF_TC_BODY(t_parser_test2, tc)
{
saslc_t *ctx;
saslc_sess_t *sess;
const char *val;
ATF_REQUIRE(ctx = saslc_alloc());
ATF_CHECK_EQ(saslc_init(ctx, "test2", NULL), 0);
ATF_REQUIRE((sess = saslc_sess_init(ctx, "ANONYMOUS", NULL)));
ATF_REQUIRE(val = saslc_sess_getprop(sess, "TEST"));
ATF_CHECK_STREQ(val, "one");
ATF_REQUIRE(val = saslc_sess_getprop(sess, "TEST2"));
ATF_CHECK_STREQ(val, "one two");
ATF_REQUIRE(val = saslc_sess_getprop(sess, "TEST3"));
ATF_CHECK_STREQ(val, "one two three");
ATF_REQUIRE(val = saslc_sess_getprop(sess, "ID"));
ATF_CHECK_STREQ(val, "6669");
saslc_sess_end(sess);
ATF_REQUIRE_EQ(saslc_end(ctx), 0);
}
ATF_TC_BODY(repo_of_package_valid_remote, tc)
{
struct pkg *pkg;
pkg = gen_pkg(PKG_REMOTE);
ATF_REQUIRE(pkg != NULL);
ATF_CHECK_STREQ(repo_of_package(pkg), "packagesite");
pkg_free(pkg);
}
ATF_TC_BODY(repo_of_package_valid_installed, tc)
{
struct pkg *pkg;
pkg = gen_pkg(PKG_INSTALLED);
ATF_REQUIRE(pkg != NULL);
ATF_CHECK_STREQ(repo_of_package(pkg), "installed");
pkg_free(pkg);
}
ATF_TC_BODY(repo_of_package_valid_local, tc)
{
struct pkg *pkg;
pkg = gen_pkg(PKG_FILE);
ATF_REQUIRE(pkg != NULL);
ATF_CHECK_STREQ(repo_of_package(pkg), "local");
pkg_free(pkg);
}
ATF_TC_BODY(t_saslc__dict_get, tc)
{
saslc__dict_t *dict;
ATF_REQUIRE(dict = saslc__dict_create());
ATF_CHECK_EQ(saslc__dict_get(dict, "BAR"), NULL);
ATF_REQUIRE_EQ(saslc__dict_insert(dict, "foo1", "bar1"), DICT_OK);
ATF_REQUIRE_EQ(saslc__dict_insert(dict, "foo2", "bar2"), DICT_OK);
ATF_REQUIRE_EQ(saslc__dict_insert(dict, "foo3", "bar3"), DICT_OK);
ATF_CHECK_STREQ(saslc__dict_get(dict, "foo1"), "bar1");
ATF_CHECK_STREQ(saslc__dict_get(dict, "foo2"), "bar2");
ATF_CHECK_STREQ(saslc__dict_get(dict, "foo3"), "bar3");
ATF_CHECK_EQ(saslc__dict_get(dict, "foo4"), NULL);
ATF_REQUIRE_EQ(saslc__dict_remove(dict, "foo2"), DICT_OK);
ATF_CHECK_STREQ(saslc__dict_get(dict, "foo1"), "bar1");
ATF_CHECK_EQ(saslc__dict_get(dict, "foo2"), NULL);
ATF_CHECK_STREQ(saslc__dict_get(dict, "foo3"), "bar3");
ATF_REQUIRE_EQ(saslc__dict_remove(dict, "foo1"), DICT_OK);
ATF_REQUIRE_EQ(saslc__dict_remove(dict, "foo3"), DICT_OK);
ATF_CHECK_EQ(saslc__dict_get(dict, "foo2"), NULL);
saslc__dict_destroy(dict);
}
ATF_TC_BODY(pkg_to_id_valid_remote, tc)
{
struct pkg *pkg;
gchar *package_id;
pkg = gen_pkg(PKG_REMOTE);
ATF_REQUIRE(pkg != NULL);
package_id = pkgutils_pkg_to_id(pkg);
ATF_CHECK_STREQ(package_id, "pkg;1.1.4;freebsd:10:x86:32;packagesite");
pkg_free(pkg);
g_free(package_id);
}
ATF_TC_BODY(pkg_to_id_valid_installed, tc)
{
struct pkg *pkg;
gchar *package_id;
pkg = gen_pkg(PKG_INSTALLED);
ATF_REQUIRE(pkg != NULL);
package_id = pkgutils_pkg_to_id(pkg);
ATF_CHECK_STREQ(package_id, "pkg;1.1.4;freebsd:10:x86:32;installed");
pkg_free(pkg);
g_free(package_id);
}
ATF_TC_BODY(snprintf__two_formatters, tc)
{
char buffer[128];
/* This first require-style check invokes the function we are
* interested in testing. This will cause the test to fail if
* the condition provided to ATF_REQUIRE is not met. */
ATF_REQUIRE(snprintf(buffer, sizeof(buffer), "%s, %s!",
"Hello", "tests") > 0);
/* This second check-style check compares that the result of the
* snprintf call we performed above is correct. We use a check
* instead of a require. */
ATF_CHECK_STREQ("Hello, tests!", buffer);
}
static
void
compare_one(const char *var, const char *expvalue)
{
const struct varnames *v;
printf("Checking that %s is set to %s\n", var, expvalue);
for (v = all_vars; v->lc != NULL; v++) {
if (strcmp(v->lc, var) == 0)
ATF_CHECK_STREQ(atf_config_get(v->lc), test_value);
else
ATF_CHECK(strcmp(atf_config_get(v->lc), test_value) != 0);
}
}
ATF_TC_BODY(t_sha512, tc)
{
size_t i, j, len;
SHA512_CTX ctx;
unsigned char buf[512];
unsigned char digest[8 + SHA512_DIGEST_LENGTH];
char output[SHA512_DIGEST_STRING_LENGTH];
for (i = 0; i < sizeof(test512) / sizeof(test512[0]); ++i) {
len = strlen(test512[i].vector);
for (j = 0; j < 8; ++j) {
SHA512_Init(&ctx);
memcpy(buf + j, test512[i].vector, len);
SHA512_Update(&ctx, buf + j, len);
SHA512_Final(digest + j, &ctx);
digest2string(digest + j, output, SHA512_DIGEST_LENGTH);
ATF_CHECK_STREQ(test512[i].hash, output);
}
}
}
static
void
check_split(const char *str, const char *delim, const char *words[])
{
atf_list_t list;
const char **word;
size_t i;
printf("Splitting '%s' with delimiter '%s'\n", str, delim);
CE(atf_text_split(str, delim, &list));
printf("Expecting %zd words\n", array_size(words));
ATF_CHECK_EQ(atf_list_size(&list), array_size(words));
for (word = words, i = 0; *word != NULL; word++, i++) {
printf("Word at position %zd should be '%s'\n", i, words[i]);
ATF_CHECK_STREQ((const char *)atf_list_index_c(&list, i), words[i]);
}
atf_list_fini(&list);
}
ATF_TC_BODY(clearenv_basic, tc)
{
char name[1024], value[1024];
for (size_t i = 0; i < 1024; i++) {
snprintf(name, sizeof(name), "crap%zu", i);
snprintf(value, sizeof(value), "%zu", i);
ATF_CHECK(setenv(name, value, 1) != -1);
}
*environ = NULL;
for (size_t i = 0; i < 1; i++) {
snprintf(name, sizeof(name), "crap%zu", i);
snprintf(value, sizeof(value), "%zu", i);
ATF_CHECK(setenv(name, value, 1) != -1);
}
ATF_CHECK_STREQ(getenv("crap0"), "0");
ATF_CHECK(getenv("crap1") == NULL);
ATF_CHECK(getenv("crap2") == NULL);
}
/*
* Walk the tree and ensure that all the test nodes are present.
*/
static void
check_test_data(dns_rbt_t *rbt) {
char buffer[1024];
char *arg;
dns_fixedname_t fname;
dns_fixedname_t fixed;
dns_name_t *name;
isc_buffer_t b;
data_holder_t *data;
isc_result_t result;
dns_name_t *foundname;
rbt_testdata_t *testdatap = testdata;
dns_fixedname_init(&fixed);
foundname = dns_fixedname_name(&fixed);
while (testdatap->name != NULL && testdatap->data.data != NULL) {
memmove(buffer, testdatap->name, testdatap->name_len + 1);
arg = buffer;
isc_buffer_init(&b, arg, testdatap->name_len);
isc_buffer_add(&b, testdatap->name_len);
dns_fixedname_init(&fname);
name = dns_fixedname_name(&fname);
result = dns_name_fromtext(name, &b, dns_rootname, 0, NULL);
if (result != ISC_R_SUCCESS) {
testdatap++;
continue;
}
data = NULL;
result = dns_rbt_findname(rbt, name, 0, foundname,
(void *) &data);
ATF_CHECK_STREQ(dns_result_totext(result), "success");
testdatap++;
}
}
ATF_TC_BODY(t_sess, tc)
{
saslc_t *ctx;
saslc_sess_t *sess;
ATF_REQUIRE(ctx = saslc_alloc());
ATF_REQUIRE_EQ(saslc_init(ctx, NULL, NULL), 0);
ATF_CHECK(sess = saslc_sess_init(ctx, "PLAIN", NULL));
if (sess != NULL)
saslc_sess_end(sess);
ATF_CHECK_EQ(sess = saslc_sess_init(ctx, "", NULL), NULL);
ATF_CHECK(sess = saslc_sess_init(ctx, "NOTEXISTS,LOGIN", NULL));
if (sess != NULL)
saslc_sess_end(sess);
ATF_CHECK(sess = saslc_sess_init(ctx, "LOGIN,NOTEXISTS", NULL));
if (sess != NULL)
saslc_sess_end(sess);
ATF_REQUIRE(sess = saslc_sess_init(ctx, "LOGiN", NULL));
ATF_CHECK_STREQ(saslc_sess_getmech(sess), "LOGIN");
ATF_REQUIRE_EQ(saslc_end(ctx), -1);
saslc_sess_end(sess);
ATF_REQUIRE_EQ(saslc_end(ctx), 0);
}
static void
run(const char *p, int flags, const char **res, size_t len)
{
glob_t gl;
size_t i;
memset(&gl, 0, sizeof(gl));
gl.gl_opendir = gl_opendir;
gl.gl_readdir = gl_readdir;
gl.gl_closedir = gl_closedir;
gl.gl_stat = gl_stat;
gl.gl_lstat = gl_lstat;
RZ(glob(p, GLOB_ALTDIRFUNC | flags, NULL, &gl));
for (i = 0; i < gl.gl_pathc; i++)
DPRINTF(("%s\n", gl.gl_pathv[i]));
ATF_CHECK(len == gl.gl_pathc);
for (i = 0; i < gl.gl_pathc; i++)
ATF_CHECK_STREQ(gl.gl_pathv[i], res[i]);
globfree(&gl);
}
ATF_TC_BODY(symtab_grow, tc) {
isc_result_t result;
isc_symtab_t *st = NULL;
isc_symvalue_t value;
isc_symexists_t policy = isc_symexists_reject;
int i;
UNUSED(tc);
result = isc_test_begin(NULL, ISC_TRUE);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
result = isc_symtab_create(mctx, 3, undefine, NULL, ISC_FALSE, &st);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
ATF_REQUIRE(st != NULL);
/* Nothing should be in the table yet */
/*
* Put 1024 entries in the table (this should necessate
* regrowing the hash table several times
*/
for (i = 0; i < 1024; i++) {
char str[16], *key;
snprintf(str, sizeof(str), "%04x", i);
key = isc_mem_strdup(mctx, str);
ATF_REQUIRE(key != NULL);
value.as_pointer = isc_mem_strdup(mctx, str);
ATF_REQUIRE(value.as_pointer != NULL);
result = isc_symtab_define(st, key, 1, value, policy);
ATF_CHECK_EQ(result, ISC_R_SUCCESS);
if (result != ISC_R_SUCCESS)
undefine(key, 1, value, NULL);
}
/*
* Try to put them in again; this should fail
*/
for (i = 0; i < 1024; i++) {
char str[16], *key;
snprintf(str, sizeof(str), "%04x", i);
key = isc_mem_strdup(mctx, str);
ATF_REQUIRE(key != NULL);
value.as_pointer = isc_mem_strdup(mctx, str);
ATF_REQUIRE(value.as_pointer != NULL);
result = isc_symtab_define(st, key, 1, value, policy);
ATF_CHECK_EQ(result, ISC_R_EXISTS);
undefine(key, 1, value, NULL);
}
/*
* Retrieve them; this should succeed
*/
for (i = 0; i < 1024; i++) {
char str[16];
snprintf(str, sizeof(str), "%04x", i);
result = isc_symtab_lookup(st, str, 0, &value);
ATF_CHECK_EQ(result, ISC_R_SUCCESS);
ATF_CHECK_STREQ(str, value.as_pointer);
}
/*
* Undefine them
*/
for (i = 0; i < 1024; i++) {
char str[16];
snprintf(str, sizeof(str), "%04x", i);
result = isc_symtab_undefine(st, str, 1);
ATF_CHECK_EQ(result, ISC_R_SUCCESS);
}
/*
* Retrieve them again; this should fail
*/
for (i = 0; i < 1024; i++) {
char str[16];
snprintf(str, sizeof(str), "%04x", i);
result = isc_symtab_lookup(st, str, 0, &value);
ATF_CHECK_EQ(result, ISC_R_NOTFOUND);
}
isc_symtab_destroy(&st);
isc_test_end();
}
ATF_TC_BODY(serialize, tc) {
dns_rbt_t *rbt = NULL;
isc_result_t result;
FILE *rbtfile = NULL;
dns_rbt_t *rbt_deserialized = NULL;
off_t offset;
int fd;
off_t filesize = 0;
char *base;
UNUSED(tc);
isc_mem_debugging = ISC_MEM_DEBUGRECORD;
result = dns_test_begin(NULL, ISC_TRUE);
ATF_CHECK_STREQ(dns_result_totext(result), "success");
result = dns_rbt_create(mctx, delete_data, NULL, &rbt);
ATF_CHECK_STREQ(dns_result_totext(result), "success");
add_test_data(mctx, rbt);
dns_rbt_printtext(rbt, data_printer, stdout);
/*
* Serialize the tree.
*/
printf("serialization begins.\n");
rbtfile = fopen("./zone.bin", "w+b");
ATF_REQUIRE(rbtfile != NULL);
result = dns_rbt_serialize_tree(rbtfile, rbt, write_data, NULL,
&offset);
ATF_REQUIRE(result == ISC_R_SUCCESS);
dns_rbt_destroy(&rbt);
/*
* Deserialize the tree
*/
printf("deserialization begins.\n");
/*
* Map in the whole file in one go
*/
fd = open("zone.bin", O_RDWR);
isc_file_getsizefd(fd, &filesize);
base = mmap(NULL, filesize,
PROT_READ|PROT_WRITE,
MAP_FILE|MAP_PRIVATE, fd, 0);
ATF_REQUIRE(base != NULL && base != MAP_FAILED);
close(fd);
result = dns_rbt_deserialize_tree(base, filesize, 0, mctx,
delete_data, NULL, fix_data, NULL,
NULL, &rbt_deserialized);
/* Test to make sure we have a valid tree */
ATF_REQUIRE(result == ISC_R_SUCCESS);
if (rbt_deserialized == NULL)
atf_tc_fail("deserialized rbt is null!"); /* Abort execution. */
check_test_data(rbt_deserialized);
dns_rbt_printtext(rbt_deserialized, data_printer, stdout);
dns_rbt_destroy(&rbt_deserialized);
munmap(base, filesize);
unlink("zone.bin");
dns_test_end();
}
