static int connected_handler(int fd, int events, void *arg)
{
int *counter = (int *)arg;
int i;
i = *counter;
if (events == IOBROKER_POLLIN) {
char buf[1024];
int len = read(fd, buf, sizeof(buf));
buf[len] = 0;
test(len == (int)strlen(msg[i]), "len match for message %d", i);
test(!memcmp(buf, msg[i], len), "data match for message %d", i);
}
i++;
if (i < 0 || i >= (int)ARRAY_SIZE(msg)) {
fprintf(stderr, "i = %d in connected_handler(). What's up with that?\n", i);
return 0;
}
if (!msg[i]) {
iobroker_close(iobs, fd);
return 0;
}
if (write(fd, msg[i], strlen(msg[i])) < 0)
t_fail("write returned failure: %s", strerror(errno));
*counter = i;
return 0;
}
int ok_str(const char *a, const char *b, const char *name)
{
if ((!a && !b) || (a && b && !strcmp(a, b))) {
t_pass("%s", name);
return TEST_PASS;
}
t_fail("%s", name);
t_diag("'%s' != '%s'", a, b);
return TEST_FAIL;
}
int ok_uint(unsigned int a, unsigned int b, const char *name)
{
if (a == b) {
t_pass("%s", name);
return TEST_PASS;
}
t_fail("%s", name);
t_diag("%u != %u. delta: %u", a, b, delta(a, b));
return TEST_FAIL;
}
int ok_int(int a, int b, const char *name)
{
if (a == b) {
t_pass("%s", name);
return TEST_PASS;
}
t_fail("%s", name);
t_diag("%d != %d. delta: %d", a, b, delta(a, b));
return TEST_FAIL;
}
int main(int argc, char **argv)
{
unsigned long k;
struct test_data *td;
t_set_colors(0);
t_start("fanout tests");
run_tests(10, 64);
run_tests(512, 64);
run_tests(64, 64);
run_tests(511, 17);
destroyed = 0;
fot = fanout_create(512);
ok_int(fanout_remove(fot, 12398) == NULL, 1,
"remove on empty table must yield NULL");
ok_int(fanout_get(fot, 123887987) == NULL, 1,
"get on empty table must yield NULL");
for (k = 0; k < 16385; k++) {
struct test_data *tdata = calloc(1, sizeof(*td));
tdata->key = k;
if (asprintf(&tdata->name, "%lu", k) < 0)
t_fail("asprintf returned failure: %s", strerror(errno));
else
fanout_add(fot, k, tdata);
}
td = fanout_get(fot, k - 1);
ok_int(td != NULL, 1, "get must get what add inserts");
ok_int(fanout_remove(fot, k + 1) == NULL, 1,
"remove on non-inserted key must yield NULL");
ok_int(fanout_get(fot, k + 1) == NULL, 1,
"get on non-inserted must yield NULL");
fanout_destroy(fot, pdest);
ok_int((int)destroyed, (int)k, "destroy counter while free()'ing");
return t_end();
}
static int listen_handler(int fd, int events, void *arg)
{
int sock;
struct sockaddr_in sain;
socklen_t addrlen;
if (!arg || arg != iobs) {
printf("Argument passing seems to fail spectacularly\n");
}
addrlen = sizeof(sain);
//printf("listen_handler(%d, %d, %p) called\n", fd, events, arg);
sock = accept(fd, (struct sockaddr *)&sain, &addrlen);
if (sock < 0) {
perror("accept");
return -1;
}
if (write(sock, msg[0], strlen(msg[0])) < 0)
t_fail("write returned failure: %s", strerror(errno));
iobroker_register(iobs, sock, iobs, echo_service);
ok_int(iobroker_is_registered(iobs, sock), 1, "is_registered must be true");
return 0;
}
static int echo_service(int fd, int events, void *arg)
{
char buf[1024];
int len;
len = read(fd, buf, sizeof(buf));
if (len < 0) {
perror("read");
iobroker_close(iobs, fd);
ok_int(iobroker_is_registered(iobs, fd), 0, "Closing must deregister");
return 0;
}
/* zero read means we're disconnected */
if (!len) {
iobroker_close(iobs, fd);
ok_int(iobroker_is_registered(iobs, fd), 0, "Closing must deregister");
return 0;
}
if (write(fd, buf, len) < 0)
t_fail("write returned failure: %s", strerror(errno));
return 0;
}
int main(int argc, char **argv)
{
int i, j;
struct kvvec *kvv, *kvv2, *kvv3;
struct kvvec_buf *kvvb, *kvvb2;
struct kvvec k = KVVEC_INITIALIZER;
t_set_colors(0);
t_start("key/value vector tests");
kvv = kvvec_create(1);
kvv2 = kvvec_create(1);
kvv3 = kvvec_create(1);
add_vars(kvv, test_data, 1239819);
add_vars(kvv, (const char **)argv + 1, argc - 1);
kvvec_sort(kvv);
kvvec_foreach(kvv, NULL, walker);
/* kvvec2buf -> buf2kvvec -> kvvec2buf -> buf2kvvec conversion */
kvvb = kvvec2buf(kvv, KVSEP, PAIRSEP, OVERALLOC);
kvv3 = buf2kvvec(kvvb->buf, kvvb->buflen, KVSEP, PAIRSEP, KVVEC_COPY);
kvvb2 = kvvec2buf(kvv3, KVSEP, PAIRSEP, OVERALLOC);
buf2kvvec_prealloc(kvv2, kvvb->buf, kvvb->buflen, KVSEP, PAIRSEP, KVVEC_ASSIGN);
kvvec_foreach(kvv2, kvv, walker);
kvvb = kvvec2buf(kvv, KVSEP, PAIRSEP, OVERALLOC);
test(kvv->kv_pairs == kvv2->kv_pairs, "pairs should be identical");
for (i = 0; i < kvv->kv_pairs; i++) {
struct key_value *kv1, *kv2;
kv1 = &kvv->kv[i];
if (i >= kvv2->kv_pairs) {
t_fail("missing var %d in kvv2", i);
printf("[%s=%s] (%d+%d)\n", kv1->key, kv1->value, kv1->key_len, kv1->value_len);
continue;
}
kv2 = &kvv2->kv[i];
if (!test(!kv_compare(kv1, kv2), "kv pair %d must match", i)) {
printf("%d failed: [%s=%s] (%d+%d) != [%s=%s (%d+%d)]\n",
i,
kv1->key, kv1->value, kv1->key_len, kv1->value_len,
kv2->key, kv2->value, kv2->key_len, kv2->value_len);
}
}
test(kvvb2->buflen == kvvb->buflen, "buflens must match");
test(kvvb2->bufsize == kvvb->bufsize, "bufsizes must match");
if (kvvb2->buflen == kvvb->buflen && kvvb2->bufsize == kvvb->bufsize &&
!memcmp(kvvb2->buf, kvvb->buf, kvvb->bufsize))
{
t_pass("kvvec -> buf -> kvvec conversion works flawlessly");
} else {
t_fail("kvvec -> buf -> kvvec conversion failed :'(");
}
free(kvvb->buf);
free(kvvb);
free(kvvb2->buf);
free(kvvb2);
kvvec_destroy(kvv, 1);
kvvec_destroy(kvv3, KVVEC_FREE_ALL);
for (j = 0; pair_term_missing[j]; j++) {
buf2kvvec_prealloc(&k, strdup(pair_term_missing[j]), strlen(pair_term_missing[j]), '=', ';', KVVEC_COPY);
for (i = 0; i < k.kv_pairs; i++) {
struct key_value *kv = &k.kv[i];
test(kv->key_len == kv->value_len, "%d.%d; key_len=%d; value_len=%d (%s = %s)",
j, i, kv->key_len, kv->value_len, kv->key, kv->value);
test(kv->value_len == strlen(kv->value),
"%d.%d; kv->value_len(%d) == strlen(%s)(%d)",
j, i, kv->value_len, kv->value, (int)strlen(kv->value));
}
}
t_end();
return 0;
}
int main(int argc, char **argv)
{
int ret, r2;
runcmd_init();
t_set_colors(0);
t_start("exec output comparison");
{
int i;
char *out = calloc(1, BUF_SIZE);
for (i = 0; cases[i].input != NULL; i++) {
int pfd[2] = { -1, -1}, pfderr[2] = { -1, -1};
int fd;
char *cmd;
memset(out, 0, BUF_SIZE);
if (asprintf(&cmd, "/bin/echo -n %s", cases[i].input) < 0) {
t_fail("asprintf returned failure: %s", strerror(errno));
continue;
}
fd = runcmd_open(cmd, pfd, pfderr, NULL);
if (read(pfd[0], out, BUF_SIZE) < 0) {
t_fail("read returned failure: %s", strerror(errno));
continue;
}
ok_str(cases[i].output, out, "Echoing a command should give expected output");
close(pfd[0]);
close(pfderr[0]);
close(fd);
}
}
ret = t_end();
t_reset();
t_start("anomaly detection");
{
int i;
for (i = 0; anomaly[i].cmd; i++) {
int out_argc;
char *out_argv[256];
int result = runcmd_cmd2strv(anomaly[i].cmd, &out_argc, out_argv);
ok_int(result, anomaly[i].ret, anomaly[i].cmd);
}
}
r2 = t_end();
ret = r2 ? r2 : ret;
t_reset();
t_start("argument splitting");
{
int i;
for (i = 0; parse_case[i].cmd; i++) {
int x, out_argc;
char *out_argv[256];
int result = runcmd_cmd2strv(parse_case[i].cmd, &out_argc, out_argv);
out_argv[out_argc] = NULL;
ok_int(result, 0, parse_case[i].cmd);
ok_int(out_argc, parse_case[i].argc_exp, parse_case[i].cmd);
for (x = 0; x < parse_case[x].argc_exp && out_argv[x]; x++) {
ok_str(parse_case[i].argv_exp[x], out_argv[x], "argv comparison test");
}
}
}
r2 = t_end();
return r2 ? r2 : ret;
}
int sighandler(int sig)
{
/* test failed */
t_fail("Caught signal %d", sig);
exit(t_end());
}