static void check_line(int fd, const char *exp) { char *line = atf_utils_readline(fd); ATF_CHECK(line != NULL); ATF_CHECK_STREQ_MSG(exp, line, "read: '%s', expected: '%s'", line, exp); free(line); }
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(msgrcv_basic, tc) { struct msg msg1 = { MSG_MTYPE_1, { 'a', 'b', 'c' } }; struct msg msg2 = { MSG_MTYPE_1, { 'x', 'y', 'z' } }; int id; id = msgget(MSG_KEY, IPC_CREAT | 0600); ATF_REQUIRE(id != -1); (void)msgsnd(id, &msg1, sizeof(struct msg), IPC_NOWAIT); (void)msgrcv(id, &msg2, sizeof(struct msg), MSG_MTYPE_1, IPC_NOWAIT); ATF_CHECK(msg1.buf[0] == msg2.buf[0]); ATF_CHECK(msg1.buf[1] == msg2.buf[1]); ATF_CHECK(msg1.buf[2] == msg2.buf[2]); ATF_REQUIRE(msgctl(id, IPC_RMID, 0) == 0); }
ATF_TC_BODY(isc_errno_toresult, tc) { isc_result_t result, expect; size_t i; for (i = 0; i < sizeof(testpair)/sizeof(testpair[0]); i++) { result = isc_errno_toresult(testpair[i].err); expect = testpair[i].result; ATF_CHECK(result == expect); } }
ATF_TC_BODY(cam_open_device_negative_test_O_RDONLY, tc) { const char *cam_test_device; cam_test_device = get_cam_test_device(tc); cam_clear_error(); ATF_CHECK(cam_open_device(cam_test_device, O_RDONLY) == NULL); ATF_REQUIRE(cam_has_error()); }
ATF_TC_BODY(listen_unbound, tc) { int s, r; s = socket(PF_LOCAL, SOCK_SEQPACKET, 0); ATF_REQUIRE(s > 0); r = listen(s, -1); /* expect listen to fail since we haven't called bind(2) */ ATF_CHECK(r != 0); }
ATF_TC_BODY(exec_umask, tc) { atf_check_result_t result; atf_fs_path_t process_helpers; const char *argv[3]; get_process_helpers_path(tc, false, &process_helpers); argv[0] = atf_fs_path_cstring(&process_helpers); argv[1] = "exit-success"; argv[2] = NULL; umask(0222); atf_error_t err = atf_check_exec_array(argv, &result); ATF_CHECK(atf_is_error(err)); ATF_CHECK(atf_error_is(err, "invalid_umask")); atf_error_free(err); atf_fs_path_fini(&process_helpers); }
ATF_TC_BODY(exec_cleanup, tc) { atf_fs_path_t out, err; atf_check_result_t result; bool exists; do_exec(tc, "exit-success", &result); RE(atf_fs_path_init_fmt(&out, "%s", atf_check_result_stdout(&result))); RE(atf_fs_path_init_fmt(&err, "%s", atf_check_result_stderr(&result))); RE(atf_fs_exists(&out, &exists)); ATF_CHECK(exists); RE(atf_fs_exists(&err, &exists)); ATF_CHECK(exists); atf_check_result_fini(&result); RE(atf_fs_exists(&out, &exists)); ATF_CHECK(!exists); RE(atf_fs_exists(&err, &exists)); ATF_CHECK(!exists); atf_fs_path_fini(&err); atf_fs_path_fini(&out); }
ATF_TC_BODY(dispatchset_get, tc) { isc_result_t result; dns_dispatch_t *d1, *d2, *d3, *d4, *d5; UNUSED(tc); result = dns_test_begin(NULL, ISC_TRUE); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); result = make_dispatchset(1); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); d1 = dns_dispatchset_get(dset); d2 = dns_dispatchset_get(dset); d3 = dns_dispatchset_get(dset); d4 = dns_dispatchset_get(dset); d5 = dns_dispatchset_get(dset); ATF_CHECK_EQ(d1, d2); ATF_CHECK_EQ(d2, d3); ATF_CHECK_EQ(d3, d4); ATF_CHECK_EQ(d4, d5); teardown(); result = make_dispatchset(4); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); d1 = dns_dispatchset_get(dset); d2 = dns_dispatchset_get(dset); d3 = dns_dispatchset_get(dset); d4 = dns_dispatchset_get(dset); d5 = dns_dispatchset_get(dset); ATF_CHECK_EQ(d1, d5); ATF_CHECK(d1 != d2); ATF_CHECK(d2 != d3); ATF_CHECK(d3 != d4); ATF_CHECK(d4 != d5); teardown(); dns_test_end(); }
ATF_TC_BODY(memrchr_simple, tc) { char buf[] = "abcdabcd"; ATF_CHECK(memrchr(buf, 'a', 0) == NULL); ATF_CHECK(memrchr(buf, 'g', 0) == NULL); ATF_CHECK(memrchr(buf, 'x', 8) == NULL); ATF_CHECK(memrchr("\0", 'x', 0) == NULL); ATF_CHECK(memrchr("\0", 'x', 1) == NULL); ATF_CHECK(memrchr(buf, 'a', 8) == buf + 4); ATF_CHECK(memrchr(buf, 'b', 8) == buf + 5); ATF_CHECK(memrchr(buf, 'c', 8) == buf + 6); ATF_CHECK(memrchr(buf, 'd', 8) == buf + 7); }
ATF_TC_BODY(uid_hash_rt29851, tc) { unsigned char clientid1[] = { 0x0 }; unsigned char clientid2[] = { 0x0 }; unsigned char clientid3[] = { 0x0 }; int clientid1_len = 1; int clientid2_len = 1; int clientid3_len = 0; struct lease *lease1 = 0, *lease2 = 0, *lease3 = 0; dhcp_db_objects_setup (); dhcp_common_objects_setup (); ATF_CHECK(lease_id_new_hash(&lease_uid_hash, LEASE_HASH_SIZE, MDL)); ATF_CHECK(lease_allocate (&lease1, MDL) == ISC_R_SUCCESS); ATF_CHECK(lease_allocate (&lease2, MDL) == ISC_R_SUCCESS); ATF_CHECK(lease_allocate (&lease3, MDL) == ISC_R_SUCCESS); lease1->uid = clientid1; lease2->uid = clientid2; lease3->uid = clientid3; lease1->uid_len = clientid1_len; lease2->uid_len = clientid2_len; lease3->uid_len = clientid3_len; uid_hash_add(lease1); /* uid_hash_delete(lease2); // not necessary for actual issue repro */ uid_hash_add(lease3); /* lease2->uid_len = 0; // not necessary for actual issue repro */ /* uid_hash_delete(lease2); // not necessary for actual issue repro */ /* uid_hash_delete(lease3); // not necessary for actual issue repro */ uid_hash_delete(lease1); /* lease2->uid_len = 1; // not necessary for actual issue repro */ uid_hash_add(lease1); uid_hash_delete(lease2); }
ATF_TC_BODY(strtod_gherman_bug, tc) { const char *str = "1.8254370818746402660437411213933955878019332885742187"; errno = 0; volatile double d = strtod(str, NULL); ATF_CHECK(d == 0x1.d34fd8378ea83p+0); }
ATF_TC_BODY(strncat_simple, tc) { char buf[100] = "abcdefg"; ATF_CHECK(strncat(buf, "xxx", 0) == buf); ATF_CHECK(strcmp(buf, "abcdefg") == 0); ATF_CHECK(strncat(buf, "xxx", 1) == buf); ATF_CHECK(strcmp(buf, "abcdefgx") == 0); ATF_CHECK(strncat(buf, "xxx", 2) == buf); ATF_CHECK(strcmp(buf, "abcdefgxxx") == 0); ATF_CHECK(strncat(buf, "\0", 1) == buf); ATF_CHECK(strcmp(buf, "abcdefgxxx") == 0); }
static void read_directory(const atf_tc_t *tc, const char *mp) { char buf[1024]; int fd, res; ssize_t size; FSTEST_ENTER(); fd = rump_sys_open(".", O_DIRECTORY | O_RDONLY, 0777); ATF_REQUIRE(fd != -1); size = rump_sys_pread(fd, buf, sizeof(buf), 0); ATF_CHECK(size != -1 || errno == EISDIR); size = rump_sys_read(fd, buf, sizeof(buf)); ATF_CHECK(size != -1 || errno == EISDIR); res = rump_sys_close(fd); ATF_REQUIRE(res != -1); FSTEST_EXIT(); }
ATF_TC_BODY (status_coredump, tc) { struct rlimit rl; rl.rlim_cur = RLIM_INFINITY; rl.rlim_max = RLIM_INFINITY; if (setrlimit (RLIMIT_CORE, &rl) == -1) atf_tc_skip ("Cannot unlimit the core file size; check limits " "manually"); const int rawstatus = fork_and_wait_child (child_sigquit); atf_process_status_t s; RE (atf_process_status_init (&s, rawstatus)); ATF_CHECK (!atf_process_status_exited (&s)); ATF_CHECK (atf_process_status_signaled (&s)); ATF_CHECK_EQ (atf_process_status_termsig (&s), SIGQUIT); ATF_CHECK (atf_process_status_coredump (&s)); atf_process_status_fini (&s); }
ATF_TC_BODY(setrlimit_stack, tc) { struct rlimit res; /* Ensure soft limit is not bigger than hard limit */ res.rlim_cur = res.rlim_max = 4192256; ATF_REQUIRE(setrlimit(RLIMIT_STACK, &res) == 0); ATF_REQUIRE(getrlimit(RLIMIT_STACK, &res) == 0); ATF_CHECK(res.rlim_cur <= res.rlim_max); }
ATF_TC_BODY(types_unsigned, tc) { fsblkcnt_t fb; fsfilcnt_t ff; size_t size; rlim_t lim; ino_t ino; fb = 0; ff = 0; ino = 0; lim = 0; size = 0; ATF_CHECK((fb - 1) > 0); ATF_CHECK((ff - 1) > 0); ATF_CHECK((ino - 1) > 0); ATF_CHECK((lim - 1) > 0); ATF_CHECK((size - 1) > 0); }
ATF_TC_BODY(mkdtemp_err, tc) { atf_error_t err; atf_fs_path_t p; ATF_REQUIRE(mkdir("dir", 0555) != -1); RE(atf_fs_path_init_fmt(&p, "dir/testdir.XXXXXX")); err = atf_fs_mkdtemp(&p); ATF_REQUIRE(atf_is_error(err)); ATF_REQUIRE(atf_error_is(err, "libc")); ATF_CHECK_EQ(atf_libc_error_code(err), EACCES); atf_error_free(err); ATF_CHECK(!exists(&p)); ATF_CHECK(strcmp(atf_fs_path_cstring(&p), "dir/testdir.XXXXXX") == 0); atf_fs_path_fini(&p); }
ATF_TC_BODY (exec_list, tc) { atf_fs_path_t process_helpers; atf_list_t argv; atf_process_status_t status; RE (atf_list_init (&argv)); get_process_helpers_path (tc, true, &process_helpers); atf_list_append (&argv, strdup (atf_fs_path_cstring (&process_helpers)), true); atf_list_append (&argv, strdup ("echo"), true); atf_list_append (&argv, strdup ("test-message"), true); { atf_fs_path_t outpath; atf_process_stream_t outsb; RE (atf_fs_path_init_fmt (&outpath, "stdout")); RE (atf_process_stream_init_redirect_path (&outsb, &outpath)); RE (atf_process_exec_list (&status, &process_helpers, &argv, &outsb, NULL)); atf_process_stream_fini (&outsb); atf_fs_path_fini (&outpath); } atf_list_fini (&argv); ATF_CHECK (atf_process_status_exited (&status)); ATF_CHECK_EQ (atf_process_status_exitstatus (&status), EXIT_SUCCESS); { int fd = open ("stdout", O_RDONLY); ATF_CHECK (fd != -1); check_line (fd, "test-message"); close (fd); } atf_process_status_fini (&status); atf_fs_path_fini (&process_helpers); }
static void capture_stream_fini (void *v) { struct capture_stream *s = v; switch (s->m_base.m_type) { case stdout_type: ATF_CHECK (grep_string (&s->m_msg, "stdout: msg")); ATF_CHECK (!grep_string (&s->m_msg, "stderr: msg")); break; case stderr_type: ATF_CHECK (!grep_string (&s->m_msg, "stdout: msg")); ATF_CHECK (grep_string (&s->m_msg, "stderr: msg")); break; default: UNREACHABLE; } atf_dynstr_fini (&s->m_msg); atf_process_stream_fini (&s->m_base.m_sb); }
ATF_TC_BODY (status_signaled, tc) { { const int rawstatus = fork_and_wait_child (child_sigkill); atf_process_status_t s; RE (atf_process_status_init (&s, rawstatus)); ATF_CHECK (!atf_process_status_exited (&s)); ATF_CHECK (atf_process_status_signaled (&s)); ATF_CHECK_EQ (atf_process_status_termsig (&s), SIGKILL); ATF_CHECK (!atf_process_status_coredump (&s)); atf_process_status_fini (&s); } { const int rawstatus = fork_and_wait_child (child_sigterm); atf_process_status_t s; RE (atf_process_status_init (&s, rawstatus)); ATF_CHECK (!atf_process_status_exited (&s)); ATF_CHECK (atf_process_status_signaled (&s)); ATF_CHECK_EQ (atf_process_status_termsig (&s), SIGTERM); ATF_CHECK (!atf_process_status_coredump (&s)); atf_process_status_fini (&s); } }
ATF_TC_BODY (fork_cookie, tc) { atf_process_stream_t outsb, errsb; RE (atf_process_stream_init_inherit (&outsb)); RE (atf_process_stream_init_inherit (&errsb)); { atf_process_child_t child; atf_process_status_t status; RE (atf_process_fork (&child, child_cookie, &outsb, &errsb, NULL)); RE (atf_process_child_wait (&child, &status)); ATF_CHECK (atf_process_status_exited (&status)); ATF_CHECK_EQ (atf_process_status_exitstatus (&status), exit_v_null); atf_process_status_fini (&status); } { atf_process_child_t child; atf_process_status_t status; int dummy_int; RE (atf_process_fork (&child, child_cookie, &outsb, &errsb, &dummy_int)); RE (atf_process_child_wait (&child, &status)); ATF_CHECK (atf_process_status_exited (&status)); ATF_CHECK_EQ (atf_process_status_exitstatus (&status), exit_v_notnull); atf_process_status_fini (&status); } atf_process_stream_fini (&errsb); atf_process_stream_fini (&outsb); }
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(wcscasecmp_same_len_buffers, tc) { ATF_REQUIRE(setlocale(LC_CTYPE, "C") != NULL); ATF_CHECK(wcscasecmp(L"abc", L"xyz") < 0); ATF_CHECK(wcscasecmp(L"ABC", L"xyz") < 0); ATF_CHECK(wcscasecmp(L"abc", L"XYZ") < 0); ATF_CHECK(wcscasecmp(L"ABC", L"XYZ") < 0); ATF_CHECK(wcscasecmp(L"xyz", L"abc") > 0); ATF_CHECK(wcscasecmp(L"XYZ", L"abc") > 0); ATF_CHECK(wcscasecmp(L"xyz", L"ABC") > 0); ATF_CHECK(wcscasecmp(L"XYZ", L"ABC") > 0); }
ATF_TC_BODY(isc_file_sanitize, tc) { isc_result_t result; char buf[1024]; ATF_CHECK(chdir(TESTS) != -1); result = isc_file_sanitize("testdata/file", NAME, "test", buf, 1024); ATF_CHECK_EQ(result, ISC_R_SUCCESS); ATF_CHECK(strcmp(buf, F(NAME)) == 0); touch(F(TRUNC_SHA)); result = isc_file_sanitize("testdata/file", NAME, "test", buf, 1024); ATF_CHECK_EQ(result, ISC_R_SUCCESS); ATF_CHECK(strcmp(buf, F(TRUNC_SHA)) == 0); touch(F(SHA)); result = isc_file_sanitize("testdata/file", NAME, "test", buf, 1024); ATF_CHECK_EQ(result, ISC_R_SUCCESS); ATF_CHECK(strcmp(buf, F(SHA)) == 0); result = isc_file_sanitize("testdata/file", BAD1, "test", buf, 1024); ATF_CHECK_EQ(result, ISC_R_SUCCESS); ATF_CHECK(strcmp(buf, F(BADHASH1)) == 0); result = isc_file_sanitize("testdata/file", BAD2, "test", buf, 1024); ATF_CHECK_EQ(result, ISC_R_SUCCESS); ATF_CHECK(strcmp(buf, F(BADHASH2)) == 0); unlink(F(TRUNC_SHA)); unlink(F(SHA)); }
ATF_TC_BODY(ldexp_nan, tc) { const double x = 0.0L / 0.0L; double y; size_t i; ATF_REQUIRE(isnan(x) != 0); for (i = 0; i < __arraycount(exps); i++) { y = ldexp(x, exps[i]); ATF_CHECK(isnan(y) != 0); } }
ATF_TC_BODY(shutdown_send_sigpipe, tc) { int s; const char *data = "data"; ssize_t ssize; s = socket(PF_LOCAL, SOCK_SEQPACKET, 0); ATF_CHECK(s >= 0); ATF_CHECK_EQ(0, shutdown(s, SHUT_RDWR)); ATF_REQUIRE(SIG_ERR != signal(SIGPIPE, shutdown_send_sigpipe_handler)); ssize = send(s, data, sizeof(data), MSG_EOR); ATF_CHECK_EQ(1, got_sigpipe); }
ATF_TC_BODY(ldexpf_nan, tc) { const float x = 0.0L / 0.0L; float y; size_t i; ATF_REQUIRE(isnan(x) != 0); for (i = 0; i < __arraycount(exps); i++) { y = ldexpf(x, exps[i]); ATF_CHECK(isnan(y) != 0); } }
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); }
ATF_TC_BODY(grep_string, tc) { const char *str = "a string - aaaabbbb"; ATF_CHECK(atf_utils_grep_string("a string", str)); ATF_CHECK(atf_utils_grep_string("^a string", str)); ATF_CHECK(atf_utils_grep_string("aaaabbbb$", str)); ATF_CHECK(atf_utils_grep_string("a%s*bb", str, "a.")); ATF_CHECK(!atf_utils_grep_string("foo", str)); ATF_CHECK(!atf_utils_grep_string("bar", str)); ATF_CHECK(!atf_utils_grep_string("aaaaa", str)); }