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 void
wait_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(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(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(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(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 (stream_init_redirect_path, tc)
{
atf_process_stream_t sb;
atf_fs_path_t path;
RE (atf_fs_path_init_fmt (&path, "foo"));
RE (atf_process_stream_init_redirect_path (&sb, &path));
ATF_CHECK_EQ (atf_process_stream_type (&sb), atf_process_stream_type_redirect_path);
atf_process_stream_fini (&sb);
atf_fs_path_fini (&path);
}
ATF_TC_BODY(mkstemp_err, tc)
{
int fd;
atf_error_t err;
atf_fs_path_t p;
ATF_REQUIRE(mkdir("dir", 0555) != -1);
RE(atf_fs_path_init_fmt(&p, "dir/testfile.XXXXXX"));
fd = 1234;
err = atf_fs_mkstemp(&p, &fd);
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/testfile.XXXXXX") == 0);
ATF_CHECK_EQ(fd, 1234);
atf_fs_path_fini(&p);
}
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);
}
ATF_TC_BODY(check_sdp_get_url, tc)
{
uint8_t data[] = {
0x45, 0x04, 0x55, 0x52, // url8(4) "URL8"
0x4c, 0x38,
0x00, // nil
0x46, 0x00, 0x05, 0x55, // url16(5) "URL16"
0x52, 0x4c, 0x31, 0x36,
0x47, 0x00, 0x00, 0x00, // url32(5) "URL32"
0x05, 0x55, 0x52, 0x4c,
0x33, 0x32,
};
sdp_data_t test = { data, data + sizeof(data) };
sdp_data_t nil;
char *url;
size_t len;
/*
* sdp_get_url expects a URL type
* advancing test if successful
*/
ATF_REQUIRE(sdp_get_url(&test, &url, &len));
ATF_CHECK(len == 4 && strncmp(url, "URL8", 4) == 0);
ATF_REQUIRE_EQ(sdp_get_url(&test, &url, &len), false); /* not url */
ATF_REQUIRE(sdp_get_data(&test, &nil)); /* (skip) */
ATF_CHECK_EQ(sdp_data_type(&nil), SDP_DATA_NIL);
ATF_REQUIRE(sdp_get_url(&test, &url, &len));
ATF_CHECK(len == 5 && strncmp(url, "URL16", 5) == 0);
ATF_REQUIRE(sdp_get_url(&test, &url, &len));
ATF_CHECK(len == 5 && strncmp(url, "URL32", 5) == 0);
ATF_CHECK_EQ(test.next, test.end);
}
ATF_TC_BODY(pkg_current_state_remote, tc)
{
struct pkg *package;
package = gen_pkg(PKG_REMOTE);
ATF_REQUIRE(package != NULL);
/* Old version newer -> available */
pkg_set(package, PKG_OLD_VERSION, "1.2.3");
ATF_CHECK_EQ(pkgutils_pkg_current_state(package),
PK_INFO_ENUM_AVAILABLE);
/* Old version the same -> installed */
pkg_set(package, PKG_OLD_VERSION, "1.1.4");
ATF_CHECK_EQ(pkgutils_pkg_current_state(package),
PK_INFO_ENUM_INSTALLED);
/* Old version older -> available */
pkg_set(package, PKG_OLD_VERSION, "1.0.0");
ATF_CHECK_EQ(pkgutils_pkg_current_state(package),
PK_INFO_ENUM_AVAILABLE);
pkg_free(package);
}
ATF_TC_BODY(pkg_install_state, tc)
{
struct pkg *package;
package = gen_pkg(PKG_REMOTE);
ATF_REQUIRE(package != NULL);
/* Old version newer -> downgrading */
pkg_set(package, PKG_OLD_VERSION, "1.2.3");
ATF_CHECK_EQ(pkgutils_pkg_install_state(package),
PK_INFO_ENUM_DOWNGRADING);
/* Old version the same -> reinstalling */
pkg_set(package, PKG_OLD_VERSION, "1.1.4");
ATF_CHECK_EQ(pkgutils_pkg_install_state(package),
PK_INFO_ENUM_REINSTALLING);
/* Old version older -> updating */
pkg_set(package, PKG_OLD_VERSION, "1.0.0");
ATF_CHECK_EQ(pkgutils_pkg_install_state(package),
PK_INFO_ENUM_UPDATING);
pkg_free(package);
}
/* Validates the integrity of an AVL tree. */
static inline unsigned int
tnode_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 void
iteration_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);
}
ATF_TC_BODY(check_sdp_get_data, tc)
{
uint8_t data[] = {
0x09, 0x00, 0x00, // uint16 0x0000
0x35, 0x05, // seq8(5)
0x19, 0x00, 0x00, // uuid16 0x0000
0x08, 0x00, // uint8 0x00
0x36, 0x00, 0x01, // seq16(1)
0x19, // uint16 /* invalid */
0x25, 0x04, 0x54, 0x45, // str8(4) "TEST"
0x53, 0x54,
};
sdp_data_t test = { data, data + sizeof(data) };
sdp_data_t value, seq;
/*
* sdp_get_data constructs a new sdp_data_t containing
* the next data element, advancing test if successful
*/
ATF_REQUIRE(sdp_get_data(&test, &value));
ATF_CHECK_EQ(sdp_data_type(&value), SDP_DATA_UINT16);
ATF_CHECK_EQ(sdp_data_size(&value), 3);
ATF_REQUIRE(sdp_get_data(&test, &value));
ATF_CHECK_EQ(sdp_data_type(&value), SDP_DATA_SEQ8);
ATF_CHECK_EQ(sdp_data_size(&value), 7);
ATF_REQUIRE(sdp_get_data(&test, &value));
ATF_CHECK_EQ(sdp_data_type(&value), SDP_DATA_SEQ16);
ATF_CHECK_EQ(sdp_data_size(&value), 4);
ATF_REQUIRE_EQ(sdp_get_seq(&value, &seq), true);
ATF_REQUIRE_EQ(sdp_get_data(&seq, &value), false); /* invalid */
ATF_REQUIRE(sdp_get_data(&test, &value));
ATF_CHECK_EQ(sdp_data_type(&value), SDP_DATA_STR8);
ATF_CHECK_EQ(sdp_data_size(&value), 6);
ATF_CHECK_EQ(test.next, test.end);
}
ATF_TC_BODY(bind, tc)
{
struct sockaddr_un sun;
/* ATF's isolation mechanisms will guarantee uniqueness of this file */
const char *path = "sock";
int s, r;
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));
r = bind(s, (struct sockaddr *)&sun, sizeof(sun));
ATF_CHECK_EQ(0, r);
}
ATF_TC_BODY(sendto_recvfrom, tc)
{
const char* path;
struct sockaddr_storage from;
int s;
int sv[2];
const int bufsize = 64;
const char *data = "data";
char recv_buf[bufsize];
size_t datalen;
ssize_t ssize, rsize;
socklen_t fromlen;
/* setup the socket pair */
path = mk_pair_of_sockets(sv);
/* send and receive a small packet */
datalen = strlen(data) + 1; /* +1 for the null */
ssize = sendto(sv[0], data, datalen, MSG_EOR, NULL, 0);
if (ssize < 0) {
perror("send");
atf_tc_fail("send returned < 0");
}
ATF_CHECK_EQ_MSG(datalen, ssize, "expected %zd=send(...) but got %zd",
datalen, ssize);
fromlen = sizeof(from);
rsize = recvfrom(sv[1], recv_buf, bufsize, MSG_WAITALL,
(struct sockaddr*)&from, &fromlen);
if (ssize < 0) {
perror("recvfrom");
atf_tc_fail("recvfrom returned < 0");
}
ATF_CHECK_EQ(datalen, rsize);
/*
* FreeBSD does not currently provide the source address for SEQ_PACKET
* AF_UNIX sockets, and POSIX does not require it, so these two checks
* are disabled. If FreeBSD gains that feature in the future, then
* these checks may be reenabled
*/
/* ATF_CHECK_EQ(PF_LOCAL, from.ss_family); */
/* ATF_CHECK_STREQ(path, ((struct sockaddr_un*)&from)->sun_path); */
}
ATF_TC_BODY(check_sdp_get_attr, tc)
{
uint8_t data[] = {
0x09, 0x00, 0x00, // uint16 0x0000
0x35, 0x05, // seq8(5)
0x19, 0x00, 0x00, // uuid16 0x0000
0x08, 0x00, // uint8 0x00
0x08, 0x00, // uint8 0x00
0x09, 0x00, 0x01, // uint16 0x0001
0x19, 0x12, 0x34, // uuid16 0x1234
};
sdp_data_t test = { data, data + sizeof(data) };
sdp_data_t value;
uint16_t attr;
/*
* sdp_get_attr expects a UINT16 followed by any data item
* and advances test if successful
*/
ATF_REQUIRE(sdp_get_attr(&test, &attr, &value));
ATF_CHECK_EQ(attr, 0x0000);
ATF_CHECK_EQ(sdp_data_type(&value), SDP_DATA_SEQ8);
ATF_CHECK_EQ(sdp_data_size(&value), 7);
ATF_REQUIRE_EQ(sdp_get_attr(&test, &attr, &value), false);
ATF_REQUIRE(sdp_get_data(&test, &value));
ATF_CHECK_EQ(sdp_data_type(&value), SDP_DATA_UINT8);
ATF_CHECK_EQ(sdp_data_size(&value), 2);
ATF_REQUIRE(sdp_get_attr(&test, &attr, &value));
ATF_CHECK_EQ(attr, 0x0001);
ATF_CHECK_EQ(sdp_data_type(&value), SDP_DATA_UUID16);
ATF_CHECK_EQ(sdp_data_size(&value), 3);
ATF_CHECK_EQ(test.next, test.end);
}
static void
test(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 (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(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);
}
