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(); }