自学教程：C++ ATF_CHECK函数代码示例

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

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