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

static void *testf(void *dummy){	ATF_CHECK_EQ(var1, 1);	ATF_CHECK_EQ(var2, 0);	ATF_CHECK_EQ(var3, &optind);	ATF_CHECK_EQ(var4, &var4_helper);	testf_helper(2, 2);	ATF_CHECK_EQ(var1, 2);	ATF_CHECK_EQ(var2, 2);	testf_helper(3, 3);	ATF_CHECK_EQ(var1, 3);	ATF_CHECK_EQ(var2, 3);	ATF_CHECK_EQ(var3, &optind);	return NULL;}

/* reverse: walk database backwards */static void test_reverse(const atf_tc_t *tc) {	isc_result_t result;	dns_db_t *db = NULL;	dns_dbiterator_t *iter = NULL;	dns_dbnode_t *node = NULL;	dns_name_t *name;	dns_fixedname_t f;	int i = 0;	UNUSED(tc);	dns_fixedname_init(&f);	name = dns_fixedname_name(&f);	result = dns_test_begin(NULL, ISC_FALSE);	ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);	result = dns_test_loaddb(&db, dns_dbtype_cache, TEST_ORIGIN,				 atf_tc_get_md_var(tc, "X-filename"));	ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);	result = dns_db_createiterator(db, 0, &iter);	ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);	for (result = dns_dbiterator_last(iter);	     result == ISC_R_SUCCESS;	     result = dns_dbiterator_prev(iter)) {		result = dns_dbiterator_current(iter, &node, name);		if (result == DNS_R_NEWORIGIN)			result = ISC_R_SUCCESS;		ATF_CHECK_EQ(result, ISC_R_SUCCESS);		dns_db_detachnode(db, &node);		i++;	}	ATF_CHECK_EQ(i, 12);	dns_dbiterator_destroy(&iter);	dns_db_detach(&db);	dns_test_end();}

ATF_TC_BODY(emsgsize_nonblocking, tc){	int sv[2];	const size_t sndbufsize = 8192;	const size_t rcvbufsize = 8192;	const size_t pktsize = (sndbufsize + rcvbufsize) * 2;	char sndbuf[pktsize];	ssize_t ssize;	/* setup the socket pair */	do_socketpair_nonblocking(sv);	/* Setup the buffers */	ATF_REQUIRE_EQ(0, setsockopt(sv[0], SOL_SOCKET, SO_SNDBUF, &sndbufsize,	    sizeof(sndbufsize)));	ATF_REQUIRE_EQ(0, setsockopt(sv[1], SOL_SOCKET, SO_RCVBUF, &rcvbufsize,	    sizeof(rcvbufsize)));	ssize = send(sv[0], sndbuf, pktsize, MSG_EOR);	ATF_CHECK_EQ(EMSGSIZE, errno);	ATF_CHECK_EQ(-1, ssize);}

static voidwait_and_check_child(const pid_t pid, const char *fail_message){    int status;    (void)waitpid(pid, &status, 0);    if (WIFEXITED(status))        ATF_CHECK_EQ(EXIT_SUCCESS, WEXITSTATUS(status));    else        atf_tc_fail("%s; raw exit status was %d", fail_message, status);}

ATF_TC_BODY(wcsspn, tc){	ATF_CHECK_EQ(wcsspn(L"abcdefghijklmnop", L""), 0);	ATF_CHECK_EQ(wcsspn(L"abcdefghijklmnop", L"a"), 1);	ATF_CHECK_EQ(wcsspn(L"abcdefghijklmnop", L"b"), 0);	ATF_CHECK_EQ(wcsspn(L"abcdefghijklmnop", L"ab"), 2);	ATF_CHECK_EQ(wcsspn(L"abcdefghijklmnop", L"abc"), 3);	ATF_CHECK_EQ(wcsspn(L"abcdefghijklmnop", L"abce"), 3);	ATF_CHECK_EQ(wcsspn(L"abcdefghijklmnop", L"abcdefghijklmnop"), 16);}

ATF_TC_BODY(resize_buffers, tc){	int s;	int sndbuf = 12345;	int rcvbuf = 23456;	int xs, xr;	socklen_t sl = sizeof(xs);	s = socket(PF_LOCAL, SOCK_SEQPACKET, 0);	ATF_REQUIRE(s >= 0);	printf("                       Socket Buffer Sizes/n");	printf("                              | SNDBUF  | RCVBUF  |/n");	ATF_CHECK_EQ(0, getsockopt(s, SOL_SOCKET, SO_SNDBUF, &xs, &sl));	ATF_CHECK_EQ(0, getsockopt(s, SOL_SOCKET, SO_RCVBUF, &xr, &sl));	printf("Default                       | %7d | %7d |/n", xs, xr);	if (setsockopt(s, SOL_SOCKET, SO_SNDBUF, &sndbuf, sizeof(sndbuf)) != 0){		perror("setsockopt");		atf_tc_fail("setsockopt(SO_SNDBUF) failed");	}	ATF_CHECK_EQ(0, getsockopt(s, SOL_SOCKET, SO_SNDBUF, &xs, &sl));	ATF_CHECK_EQ(0, getsockopt(s, SOL_SOCKET, SO_RCVBUF, &xr, &sl));	printf("After changing SNDBUF         | %7d | %7d |/n", xs, xr);		if (setsockopt(s, SOL_SOCKET, SO_RCVBUF, &rcvbuf, sizeof(rcvbuf)) != 0){		perror("setsockopt");		atf_tc_fail("setsockopt(SO_RCVBUF) failed");	}	ATF_CHECK_EQ(0, getsockopt(s, SOL_SOCKET, SO_SNDBUF, &xs, &sl));	ATF_CHECK_EQ(0, getsockopt(s, SOL_SOCKET, SO_RCVBUF, &xr, &sl));	printf("After changing RCVBUF         | %7d | %7d |/n", xs, xr);}

/*  * Returns a pair of sockets made the hard way: bind, listen, connect & accept * @return	const char* The path to the socket */const char*mk_pair_of_sockets(int *sv){	struct sockaddr_un sun;	/* ATF's isolation mechanisms will guarantee uniqueness of this file */	const char *path = "sock";	int s, err, s2, s1;	s = socket(PF_LOCAL, SOCK_SEQPACKET, 0);	ATF_REQUIRE(s >= 0);	bzero(&sun, sizeof(sun));	sun.sun_family = AF_LOCAL;	sun.sun_len = sizeof(sun);	strlcpy(sun.sun_path, path, sizeof(sun.sun_path));	err = bind(s, (struct sockaddr *)&sun, sizeof(sun));	err = listen(s, -1);	ATF_CHECK_EQ(0, err);	ATF_CHECK_EQ(0, err);	/* Create the other socket */	s2 = socket(PF_LOCAL, SOCK_SEQPACKET, 0);	ATF_REQUIRE(s2 >= 0);	err = connect(s2, (struct sockaddr*)&sun, sizeof(sun));	if (err != 0) {		perror("connect");		atf_tc_fail("connect(2) failed");	}		/* Accept it */	s1 = accept(s, NULL, NULL);	if (s1 == -1) {		perror("accept");		atf_tc_fail("accept(2) failed");	}	sv[0] = s1;	sv[1] = s2;	return (path);}

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(pkg_current_state_local, tc){	struct pkg     *package;	package = gen_pkg(PKG_INSTALLED);	ATF_REQUIRE(package != NULL);	pkg_set(package, PKG_OLD_VERSION, "1.2.3");	ATF_CHECK_EQ(pkgutils_pkg_current_state(package),	    PK_INFO_ENUM_INSTALLED);	pkg_free(package);}

ATF_TC_BODY(totext, tc) {	isc_result_t result;	dns_rdataset_t rdataset;	dns_rdatalist_t rdatalist;	isc_buffer_t target;	unsigned char buf[BIGBUFLEN];	UNUSED(tc);	result = dns_test_begin(NULL, ISC_FALSE);	ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);	/* First, test with an empty rdataset */	rdatalist.rdclass = dns_rdataclass_in;	rdatalist.type = dns_rdatatype_none;	rdatalist.covers = dns_rdatatype_none;	rdatalist.ttl = 0;	ISC_LIST_INIT(rdatalist.rdata);	ISC_LINK_INIT(&rdatalist, link);	dns_rdataset_init(&rdataset);	result = dns_rdatalist_tordataset(&rdatalist, &rdataset);	ATF_CHECK_EQ(result, ISC_R_SUCCESS);	isc_buffer_init(&target, buf, BIGBUFLEN);	result = dns_master_rdatasettotext(dns_rootname,					   &rdataset, &dns_master_style_debug,					   &target);	ATF_CHECK_EQ(result, ISC_R_SUCCESS);	ATF_CHECK_EQ(isc_buffer_usedlength(&target), 0);	/*	 * XXX: We will also need to add tests for dumping various	 * rdata types, classes, etc, and comparing the results against	 * known-good output.	 */	dns_test_end();}

ATF_TC_BODY(wcspbrk, tc){	static const wchar_t s[] = L"abcdefghijklmnop";	ATF_CHECK_EQ(wcspbrk(s, L""), NULL);	ATF_CHECK_EQ(wcspbrk(s, L"qrst"), NULL);	ATF_CHECK_EQ(wcspbrk(s, L"a"), s);	ATF_CHECK_EQ(wcspbrk(s, L"b"), s + 1);	ATF_CHECK_EQ(wcspbrk(s, L"ab"), s);	ATF_CHECK_EQ(wcspbrk(s, L"cdef"), s + 2);	ATF_CHECK_EQ(wcspbrk(s, L"fedc"), s + 2);}

ATF_TC_BODY(t_crypto_nonce, tc){	unsigned char *x, *y;	/* Any better ideas how to test that? ... */	x = saslc__crypto_nonce(1024);	y = saslc__crypto_nonce(1024);	ATF_CHECK_EQ(((strncmp(x, y, 1024) == 0) ? 1 : 0), 0);	free(x);	free(y);}

ATF_TC_BODY(rbt_create, tc) {	isc_result_t result;	test_context_t *ctx;	isc_boolean_t tree_ok;	UNUSED(tc);	isc_mem_debugging = ISC_MEM_DEBUGRECORD;	result = dns_test_begin(NULL, ISC_TRUE);	ATF_CHECK_EQ(result, ISC_R_SUCCESS);	ctx = test_context_setup();	check_test_data(ctx->rbt);	tree_ok = dns__rbt_checkproperties(ctx->rbt);	ATF_CHECK_EQ(tree_ok, ISC_TRUE);	test_context_teardown(ctx);	dns_test_end();}

ATF_TC_BODY(check_sdp_get_str, tc){	uint8_t data[] = {		0x25, 0x04, 0x53, 0x54, // str8(4)	"STR8"		0x52, 0x38,		0x00,			// nil		0x26, 0x00, 0x05, 0x53,	// str16(5)	"STR16"		0x54, 0x52, 0x31, 0x36,		0x27, 0x00, 0x00, 0x00,	// str32(5)	"STR32"		0x05, 0x53, 0x54, 0x52,		0x33, 0x32,	};	sdp_data_t test = { data, data + sizeof(data) };	sdp_data_t nil;	char *str;	size_t len;	/*	 * sdp_get_str expects a STR type	 * advancing test if successful	 */	ATF_REQUIRE(sdp_get_str(&test, &str, &len));	ATF_CHECK(len == 4 && strncmp(str, "STR8", 4) == 0);	ATF_REQUIRE_EQ(sdp_get_str(&test, &str, &len), false);	/* not str */	ATF_REQUIRE(sdp_get_data(&test, &nil));			/* (skip) */	ATF_CHECK_EQ(sdp_data_type(&nil), SDP_DATA_NIL);	ATF_REQUIRE(sdp_get_str(&test, &str, &len));	ATF_CHECK(len == 5 && strncmp(str, "STR16", 5) == 0);	ATF_REQUIRE(sdp_get_str(&test, &str, &len));	ATF_CHECK(len == 5 && strncmp(str, "STR32", 5) == 0);	ATF_CHECK_EQ(test.next, test.end);}

/* Validates the integrity of an AVL tree. */static inline unsigned inttnode_assert(const posix_tnode *n){	unsigned int height_left, height_right;	int balance;	if (n == NULL)		return 0;	height_left = tnode_assert(n->llink);	height_right = tnode_assert(n->rlink);	balance = (int)height_left - (int)height_right;	ATF_CHECK(balance >= -1);	ATF_CHECK(balance <= 1);	ATF_CHECK_EQ(balance, n->balance);	return (height_left > height_right ? height_left : height_right) + 1;}

static voiditeration_test(const char* file, unsigned int expected) {	isc_result_t result;	dns_db_t *db = NULL;	unsigned int iterations;	result = dns_test_loaddb(&db, dns_dbtype_zone, "test", file);	ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);	result = dns_nsec3_maxiterations(db, NULL, mctx, &iterations);	ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);	ATF_CHECK_EQ(iterations, expected);	dns_db_detach(&db);}

static voidtest(int r){	int did = 0;	for (size_t i = 0; i < __arraycount(tst); i++) {		double d = strtod(tst[i].n, NULL);		int g = (int)rint(d);		int e = tst[i].v[r];		ATF_CHECK_EQ(g, e);		if (g != e) {			if (!did) {				fprintf(stderr, "Mode Value Result Expected/n");				did = 1;			}			fprintf(stderr, "%4.4s %-5.5s %6d %8d/n", rnd[r].n,			    tst[i].n, (int)rint(d), tst[i].v[r]);		}	}}

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