/**
* @brief Verify that an unclean rd_kafka_destroy() does not hang.
*/
static void do_test_unclean_destroy (rd_kafka_type_t cltype, int with_mainq) {
rd_kafka_t *rk;
char errstr[512];
rd_kafka_conf_t *conf;
rd_kafka_queue_t *q;
rd_kafka_event_t *rkev;
rd_kafka_DeleteTopic_t *topic;
test_timing_t t_destroy;
test_conf_init(&conf, NULL, 0);
/* Remove brokers, if any, since this is a local test and we
* rely on the controller not being found. */
test_conf_set(conf, "bootstrap.servers", "");
test_conf_set(conf, "socket.timeout.ms", "60000");
rk = rd_kafka_new(cltype, conf, errstr, sizeof(errstr));
TEST_ASSERT(rk, "kafka_new(%d): %s", cltype, errstr);
TEST_SAY(_C_MAG "[ Test unclean destroy for %s using %s]\n", rd_kafka_name(rk),
with_mainq ? "mainq" : "tempq");
if (with_mainq)
q = rd_kafka_queue_get_main(rk);
else
q = rd_kafka_queue_new(rk);
topic = rd_kafka_DeleteTopic_new("test");
rd_kafka_DeleteTopics(rk, &topic, 1, NULL, q);
rd_kafka_DeleteTopic_destroy(topic);
/* We're not expecting a result yet since DeleteTopics will attempt
* to look up the controller for socket.timeout.ms (1 minute). */
rkev = rd_kafka_queue_poll(q, 100);
TEST_ASSERT(!rkev, "Did not expect result: %s", rd_kafka_event_name(rkev));
rd_kafka_queue_destroy(q);
TEST_SAY("Giving rd_kafka_destroy() 5s to finish, "
"despite Admin API request being processed\n");
test_timeout_set(5);
TIMING_START(&t_destroy, "rd_kafka_destroy()");
rd_kafka_destroy(rk);
TIMING_STOP(&t_destroy);
/* Restore timeout */
test_timeout_set(60);
}
/**
* @brief Verify that an unclean rd_kafka_destroy() does not hang.
*/
static void do_test_unclean_destroy (rd_kafka_type_t cltype, int with_mainq) {
rd_kafka_t *rk;
char errstr[512];
rd_kafka_conf_t *conf;
rd_kafka_queue_t *q;
rd_kafka_NewTopic_t *topic;
test_timing_t t_destroy;
test_conf_init(&conf, NULL, 0);
rk = rd_kafka_new(cltype, conf, errstr, sizeof(errstr));
TEST_ASSERT(rk, "kafka_new(%d): %s", cltype, errstr);
TEST_SAY(_C_MAG "[ Test unclean destroy for %s using %s]\n", rd_kafka_name(rk),
with_mainq ? "mainq" : "tempq");
if (with_mainq)
q = rd_kafka_queue_get_main(rk);
else
q = rd_kafka_queue_new(rk);
topic = rd_kafka_NewTopic_new(test_mk_topic_name(__FUNCTION__, 1),
3, 1, NULL, 0);
rd_kafka_CreateTopics(rk, &topic, 1, NULL, q);
rd_kafka_NewTopic_destroy(topic);
rd_kafka_queue_destroy(q);
TEST_SAY("Giving rd_kafka_destroy() 5s to finish, "
"despite Admin API request being processed\n");
test_timeout_set(5);
TIMING_START(&t_destroy, "rd_kafka_destroy()");
rd_kafka_destroy(rk);
TIMING_STOP(&t_destroy);
/* Restore timeout */
test_timeout_set(60);;
}
/**
* Creates and sets up kafka configuration objects.
* Will read "test.conf" file if it exists.
*/
void test_conf_init (rd_kafka_conf_t **conf, rd_kafka_topic_conf_t **topic_conf,
int timeout) {
char buf[512];
const char *test_conf =
#ifndef _MSC_VER
getenv("RDKAFKA_TEST_CONF") ? getenv("RDKAFKA_TEST_CONF") :
#endif
"test.conf";
if (conf) {
#ifndef _MSC_VER
char *tmp;
#endif
*conf = rd_kafka_conf_new();
rd_kafka_conf_set_error_cb(*conf, test_error_cb);
rd_kafka_conf_set_stats_cb(*conf, test_stats_cb);
#ifndef _MSC_VER
if ((tmp = getenv("TEST_DEBUG")) && *tmp)
test_conf_set(*conf, "debug", tmp);
#endif
#ifdef SIGIO
/* Quick termination */
rd_snprintf(buf, sizeof(buf), "%i", SIGIO);
rd_kafka_conf_set(*conf, "internal.termination.signal",
buf, NULL, 0);
signal(SIGIO, SIG_IGN);
#endif
}
if (topic_conf)
*topic_conf = rd_kafka_topic_conf_new();
/* Open and read optional local test configuration file, if any. */
test_read_conf_file(test_conf,
conf ? *conf : NULL,
topic_conf ? *topic_conf : NULL, &timeout);
if (timeout)
test_timeout_set(timeout);
}
int main(int argc, char **argv) {
const char *tests_to_run = NULL; /* all */
int test_flags = 0;
int i, r;
test_timing_t t_all;
mtx_init(&test_mtx, mtx_plain);
test_init();
#ifndef _MSC_VER
tests_to_run = getenv("TESTS");
#endif
for (i = 1 ; i < argc ; i++) {
if (!strncmp(argv[i], "-p", 2) && strlen(argv[i]) > 2)
test_concurrent_max = strtod(argv[i]+2, NULL);
else if (!strcmp(argv[i], "-l"))
test_flags |= TEST_F_LOCAL;
else if (!strcmp(argv[i], "-a"))
test_assert_on_fail = 1;
else if (*argv[i] != '-')
tests_to_run = argv[i];
else {
printf("Unknown option: %s\n"
"\n"
"Usage: %s [options] [<test-match-substr>]\n"
"Options:\n"
" -p<N> Run N tests in parallel\n"
" -l Only run local tests (no broker needed)\n"
" -a Assert on failures\n"
"\n",
argv[0], argv[i]);
exit(1);
}
}
test_curr = &tests[0];
test_curr->state = TEST_PASSED;
test_curr->start = test_clock();
TEST_SAY("Tests to run: %s\n", tests_to_run ? tests_to_run : "all");
TEST_SAY("Test filter: %s\n",
(test_flags & TEST_F_LOCAL) ?
"local tests only" : "no filter");
TEST_SAY("Action on test failure: %s\n",
test_assert_on_fail ? "assert crash" : "continue other tests");
test_timeout_set(20);
TIMING_START(&t_all, "ALL-TESTS");
run_tests(tests_to_run, test_flags, argc, argv);
TEST_LOCK();
while (tests_running_cnt > 0) {
struct test *test;
TEST_SAY("%d test(s) running:", tests_running_cnt);
for (test = tests ; test->name ; test++)
if (test->state == TEST_RUNNING)
TEST_SAY0(" %s", test->name);
TEST_SAY0("\n");
TEST_UNLOCK();
rd_sleep(1);
TEST_LOCK();
}
TIMING_STOP(&t_all);
test_curr = &tests[0];
test_curr->duration = test_clock() - test_curr->start;
TEST_UNLOCK();
/* Wait for everything to be cleaned up since broker destroys are
* handled in its own thread. */
test_wait_exit(10);
r = test_summary(1/*lock*/) ? 1 : 0;
/* If we havent failed at this point then
* there were no threads leaked */
if (r == 0)
TEST_SAY("\n============== ALL TESTS PASSED ==============\n");
return r;
}
