ATF_TC_BODY(get_tasks, tc) { isc_result_t result; isc_taskpool_t *pool = NULL; isc_task_t *task1 = NULL, *task2 = NULL, *task3 = NULL; UNUSED(tc); result = isc_test_begin(NULL, ISC_TRUE); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); result = isc_taskpool_create(taskmgr, mctx, 2, 2, &pool); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); ATF_REQUIRE_EQ(isc_taskpool_size(pool), 2); /* two tasks in pool; make sure we can access them more than twice */ isc_taskpool_gettask(pool, &task1); ATF_REQUIRE(ISCAPI_TASK_VALID(task1)); isc_taskpool_gettask(pool, &task2); ATF_REQUIRE(ISCAPI_TASK_VALID(task2)); isc_taskpool_gettask(pool, &task3); ATF_REQUIRE(ISCAPI_TASK_VALID(task3)); isc_task_destroy(&task1); isc_task_destroy(&task2); isc_task_destroy(&task3); isc_taskpool_destroy(&pool); ATF_REQUIRE_EQ(pool, NULL); isc_test_end(); }
ATF_TC_BODY(isc_counter, tc) { isc_result_t result; isc_counter_t *counter = NULL; int i; result = isc_test_begin(NULL, ISC_TRUE); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); result = isc_counter_create(mctx, 0, &counter); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); for (i = 0; i < 10; i++) { result = isc_counter_increment(counter); ATF_CHECK_EQ(result, ISC_R_SUCCESS); } ATF_CHECK_EQ(isc_counter_used(counter), 10); isc_counter_setlimit(counter, 15); for (i = 0; i < 10; i++) { result = isc_counter_increment(counter); if (result != ISC_R_SUCCESS) break; } ATF_CHECK_EQ(isc_counter_used(counter), 15); isc_counter_detach(&counter); isc_test_end(); }
ATF_TC_BODY(isc_mem_inuse, tc) { isc_result_t result; isc_mem_t *mctx2 = NULL; size_t before, during, after; ssize_t diff; void *ptr; result = isc_test_begin(NULL, ISC_TRUE); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); mctx2 = NULL; result = isc_mem_createx2(0, 0, default_memalloc, default_memfree, NULL, &mctx2, 0); if (result != ISC_R_SUCCESS) goto out; before = isc_mem_inuse(mctx2); ptr = isc_mem_allocate(mctx2, 1024000); during = isc_mem_inuse(mctx2); isc_mem_free(mctx2, ptr); after = isc_mem_inuse(mctx2); diff = after - before; printf("inuse_before=%lu, inuse_during=%lu, inuse_after=%lu\n", (unsigned long)before, (unsigned long)during, (unsigned long)after); ATF_REQUIRE_EQ(diff, 0); out: if (mctx2 != NULL) isc_mem_destroy(&mctx2); isc_test_end(); }
ATF_TC_BODY(sockaddr_hash, tc) { isc_result_t result; isc_sockaddr_t addr; struct in_addr in; struct in6_addr in6; unsigned int h1, h2, h3, h4; int ret; UNUSED(tc); result = isc_test_begin(NULL, ISC_TRUE); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); in.s_addr = inet_addr("127.0.0.1"); isc_sockaddr_fromin(&addr, &in, 1); h1 = isc_sockaddr_hash(&addr, ISC_TRUE); h2 = isc_sockaddr_hash(&addr, ISC_FALSE); ATF_CHECK(h1 != h2); ret = inet_pton(AF_INET6, "::ffff:127.0.0.1", &in6); ATF_CHECK(ret == 1); isc_sockaddr_fromin6(&addr, &in6, 1); h3 = isc_sockaddr_hash(&addr, ISC_TRUE); h4 = isc_sockaddr_hash(&addr, ISC_FALSE); ATF_CHECK(h1 == h3); ATF_CHECK(h2 == h4); isc_test_end(); }
ATF_TC_BODY(all_events, tc) { isc_result_t result; isc_task_t *task = NULL; isc_event_t *event; int a = 0, b = 0; int i = 0; UNUSED(tc); counter = 1; result = isc_mutex_init(&set_lock); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); result = isc_test_begin(NULL, ISC_TRUE); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); result = isc_task_create(taskmgr, 0, &task); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); /* First event */ event = isc_event_allocate(mctx, task, ISC_TASKEVENT_TEST, set, &a, sizeof (isc_event_t)); ATF_REQUIRE(event != NULL); ATF_CHECK_EQ(a, 0); isc_task_send(task, &event); event = isc_event_allocate(mctx, task, ISC_TASKEVENT_TEST, set, &b, sizeof (isc_event_t)); ATF_REQUIRE(event != NULL); ATF_CHECK_EQ(b, 0); isc_task_send(task, &event); while ((a == 0 || b == 0) && i++ < 5000) { #ifndef ISC_PLATFORM_USETHREADS while (isc__taskmgr_ready(taskmgr)) isc__taskmgr_dispatch(taskmgr); #endif isc_test_nap(1000); } ATF_CHECK(a != 0); ATF_CHECK(b != 0); isc_task_destroy(&task); ATF_REQUIRE_EQ(task, NULL); isc_test_end(); }
ATF_TC_BODY(create_task, tc) { isc_result_t result; isc_task_t *task = NULL; UNUSED(tc); result = isc_test_begin(NULL, ISC_TRUE); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); result = isc_task_create(taskmgr, 0, &task); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); isc_task_destroy(&task); ATF_REQUIRE_EQ(task, NULL); isc_test_end(); }
ATF_TC_BODY(expand_pool, tc) { isc_result_t result; isc_pool_t *pool1 = NULL, *pool2 = NULL, *hold = NULL; UNUSED(tc); result = isc_test_begin(NULL, ISC_TRUE); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); result = isc_pool_create(mctx, 10, poolfree, poolinit, taskmgr, &pool1); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); ATF_REQUIRE_EQ(isc_pool_count(pool1), 10); /* resizing to a smaller size should have no effect */ hold = pool1; result = isc_pool_expand(&pool1, 5, &pool2); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); ATF_REQUIRE_EQ(isc_pool_count(pool2), 10); ATF_REQUIRE_EQ(pool2, hold); ATF_REQUIRE_EQ(pool1, NULL); pool1 = pool2; pool2 = NULL; /* resizing to the same size should have no effect */ hold = pool1; result = isc_pool_expand(&pool1, 10, &pool2); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); ATF_REQUIRE_EQ(isc_pool_count(pool2), 10); ATF_REQUIRE_EQ(pool2, hold); ATF_REQUIRE_EQ(pool1, NULL); pool1 = pool2; pool2 = NULL; /* resizing to larger size should make a new pool */ hold = pool1; result = isc_pool_expand(&pool1, 20, &pool2); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); ATF_REQUIRE_EQ(isc_pool_count(pool2), 20); ATF_REQUIRE(pool2 != hold); ATF_REQUIRE_EQ(pool1, NULL); isc_pool_destroy(&pool2); ATF_REQUIRE_EQ(pool2, NULL); isc_test_end(); }
isc_result_t isc_test_begin(FILE *logfile, isc_boolean_t start_managers) { isc_result_t result; isc_mem_debugging |= ISC_MEM_DEBUGRECORD; CHECK(isc_mem_create(0, 0, &mctx)); CHECK(isc_entropy_create(mctx, &ectx)); CHECK(isc_hash_create(mctx, ectx, 255)); hash_active = ISC_TRUE; if (logfile != NULL) { isc_logdestination_t destination; isc_logconfig_t *logconfig = NULL; CHECK(isc_log_create(mctx, &lctx, &logconfig)); isc_log_registercategories(lctx, categories); isc_log_setcontext(lctx); destination.file.stream = logfile; destination.file.name = NULL; destination.file.versions = ISC_LOG_ROLLNEVER; destination.file.maximum_size = 0; CHECK(isc_log_createchannel(logconfig, "stderr", ISC_LOG_TOFILEDESC, ISC_LOG_DYNAMIC, &destination, 0)); CHECK(isc_log_usechannel(logconfig, "stderr", NULL, NULL)); } #ifdef ISC_PLATFORM_USETHREADS ncpus = isc_os_ncpus(); #else ncpus = 1; #endif if (start_managers) CHECK(create_managers()); return (ISC_R_SUCCESS); cleanup: isc_test_end(); return (result); }
ATF_TC_BODY(create_pool, tc) { isc_result_t result; isc_pool_t *pool = NULL; UNUSED(tc); result = isc_test_begin(NULL, ISC_TRUE); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); result = isc_pool_create(mctx, 8, poolfree, poolinit, taskmgr, &pool); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); ATF_REQUIRE_EQ(isc_pool_count(pool), 8); isc_pool_destroy(&pool); ATF_REQUIRE_EQ(pool, NULL); isc_test_end(); }
ATF_TC_BODY(set_privilege, tc) { isc_result_t result; isc_taskpool_t *pool = NULL; isc_task_t *task1 = NULL, *task2 = NULL, *task3 = NULL; UNUSED(tc); result = isc_test_begin(NULL, ISC_TRUE); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); result = isc_taskpool_create(taskmgr, mctx, 2, 2, &pool); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); ATF_REQUIRE_EQ(isc_taskpool_size(pool), 2); isc_taskpool_setprivilege(pool, ISC_TRUE); isc_taskpool_gettask(pool, &task1); isc_taskpool_gettask(pool, &task2); isc_taskpool_gettask(pool, &task3); ATF_CHECK(ISCAPI_TASK_VALID(task1)); ATF_CHECK(ISCAPI_TASK_VALID(task2)); ATF_CHECK(ISCAPI_TASK_VALID(task3)); ATF_CHECK(isc_task_privilege(task1)); ATF_CHECK(isc_task_privilege(task2)); ATF_CHECK(isc_task_privilege(task3)); isc_taskpool_setprivilege(pool, ISC_FALSE); ATF_CHECK(!isc_task_privilege(task1)); ATF_CHECK(!isc_task_privilege(task2)); ATF_CHECK(!isc_task_privilege(task3)); isc_task_destroy(&task1); isc_task_destroy(&task2); isc_task_destroy(&task3); isc_taskpool_destroy(&pool); ATF_REQUIRE_EQ(pool, NULL); isc_test_end(); }
ATF_TC_BODY(parse_overflow, tc) { isc_result_t result; isc_uint32_t output; UNUSED(tc); result = isc_test_begin(NULL, ISC_TRUE); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); result = isc_parse_uint32(&output, "1234567890", 10); ATF_CHECK_EQ(ISC_R_SUCCESS, result); ATF_CHECK_EQ(1234567890, output); result = isc_parse_uint32(&output, "123456789012345", 10); ATF_CHECK_EQ(ISC_R_RANGE, result); result = isc_parse_uint32(&output, "12345678901234567890", 10); ATF_CHECK_EQ(ISC_R_RANGE, result); isc_test_end(); }
ATF_TC_BODY(get_objects, tc) { isc_result_t result; isc_pool_t *pool = NULL; void *item; isc_task_t *task1 = NULL, *task2 = NULL, *task3 = NULL; UNUSED(tc); result = isc_test_begin(NULL, ISC_TRUE); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); result = isc_pool_create(mctx, 2, poolfree, poolinit, taskmgr, &pool); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); ATF_REQUIRE_EQ(isc_pool_count(pool), 2); item = isc_pool_get(pool); ATF_REQUIRE(item != NULL); isc_task_attach((isc_task_t *) item, &task1); item = isc_pool_get(pool); ATF_REQUIRE(item != NULL); isc_task_attach((isc_task_t *) item, &task2); item = isc_pool_get(pool); ATF_REQUIRE(item != NULL); isc_task_attach((isc_task_t *) item, &task3); isc_task_detach(&task1); isc_task_detach(&task2); isc_task_detach(&task3); isc_pool_destroy(&pool); ATF_REQUIRE_EQ(pool, NULL); isc_test_end(); }
ATF_TC_BODY(symtab_grow, tc) { isc_result_t result; isc_symtab_t *st = NULL; isc_symvalue_t value; isc_symexists_t policy = isc_symexists_reject; int i; UNUSED(tc); result = isc_test_begin(NULL, ISC_TRUE); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); result = isc_symtab_create(mctx, 3, undefine, NULL, ISC_FALSE, &st); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); ATF_REQUIRE(st != NULL); /* Nothing should be in the table yet */ /* * Put 1024 entries in the table (this should necessate * regrowing the hash table several times */ for (i = 0; i < 1024; i++) { char str[16], *key; snprintf(str, sizeof(str), "%04x", i); key = isc_mem_strdup(mctx, str); ATF_REQUIRE(key != NULL); value.as_pointer = isc_mem_strdup(mctx, str); ATF_REQUIRE(value.as_pointer != NULL); result = isc_symtab_define(st, key, 1, value, policy); ATF_CHECK_EQ(result, ISC_R_SUCCESS); if (result != ISC_R_SUCCESS) undefine(key, 1, value, NULL); } /* * Try to put them in again; this should fail */ for (i = 0; i < 1024; i++) { char str[16], *key; snprintf(str, sizeof(str), "%04x", i); key = isc_mem_strdup(mctx, str); ATF_REQUIRE(key != NULL); value.as_pointer = isc_mem_strdup(mctx, str); ATF_REQUIRE(value.as_pointer != NULL); result = isc_symtab_define(st, key, 1, value, policy); ATF_CHECK_EQ(result, ISC_R_EXISTS); undefine(key, 1, value, NULL); } /* * Retrieve them; this should succeed */ for (i = 0; i < 1024; i++) { char str[16]; snprintf(str, sizeof(str), "%04x", i); result = isc_symtab_lookup(st, str, 0, &value); ATF_CHECK_EQ(result, ISC_R_SUCCESS); ATF_CHECK_STREQ(str, value.as_pointer); } /* * Undefine them */ for (i = 0; i < 1024; i++) { char str[16]; snprintf(str, sizeof(str), "%04x", i); result = isc_symtab_undefine(st, str, 1); ATF_CHECK_EQ(result, ISC_R_SUCCESS); } /* * Retrieve them again; this should fail */ for (i = 0; i < 1024; i++) { char str[16]; snprintf(str, sizeof(str), "%04x", i); result = isc_symtab_lookup(st, str, 0, &value); ATF_CHECK_EQ(result, ISC_R_NOTFOUND); } isc_symtab_destroy(&st); isc_test_end(); }
ATF_TC_BODY(isc_mem_total, tc) { isc_result_t result; isc_mem_t *mctx2 = NULL; size_t before, after; ssize_t diff; int i; result = isc_test_begin(NULL, ISC_TRUE); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); /* Local alloc, free */ mctx2 = NULL; result = isc_mem_createx2(0, 0, default_memalloc, default_memfree, NULL, &mctx2, 0); if (result != ISC_R_SUCCESS) goto out; before = isc_mem_total(mctx2); for (i = 0; i < 100000; i++) { void *ptr; ptr = isc_mem_allocate(mctx2, 2048); isc_mem_free(mctx2, ptr); } after = isc_mem_total(mctx2); diff = after - before; printf("total_before=%lu, total_after=%lu, total_diff=%lu\n", (unsigned long)before, (unsigned long)after, (unsigned long)diff); /* 2048 +8 bytes extra for size_info */ ATF_CHECK_EQ(diff, (2048 + 8) * 100000); /* ISC_MEMFLAG_INTERNAL */ before = isc_mem_total(mctx); for (i = 0; i < 100000; i++) { void *ptr; ptr = isc_mem_allocate(mctx, 2048); isc_mem_free(mctx, ptr); } after = isc_mem_total(mctx); diff = after - before; printf("total_before=%lu, total_after=%lu, total_diff=%lu\n", (unsigned long)before, (unsigned long)after, (unsigned long)diff); /* 2048 +8 bytes extra for size_info */ ATF_CHECK_EQ(diff, (2048 + 8) * 100000); out: if (mctx2 != NULL) isc_mem_destroy(&mctx2); isc_test_end(); }
ATF_TC_BODY(privilege_drop, tc) { isc_result_t result; isc_task_t *task1 = NULL, *task2 = NULL; isc_event_t *event; int a = -1, b = -1, c = -1, d = -1, e = -1; /* non valid states */ int i = 0; UNUSED(tc); counter = 1; result = isc_mutex_init(&set_lock); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); result = isc_test_begin(NULL, ISC_TRUE); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); #ifdef ISC_PLATFORM_USETHREADS /* * Pause the task manager so we can fill up the work queue * without things happening while we do it. */ isc__taskmgr_pause(taskmgr); #endif result = isc_task_create(taskmgr, 0, &task1); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); isc_task_setname(task1, "privileged", NULL); ATF_CHECK(!isc_task_privilege(task1)); isc_task_setprivilege(task1, ISC_TRUE); ATF_CHECK(isc_task_privilege(task1)); result = isc_task_create(taskmgr, 0, &task2); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); isc_task_setname(task2, "normal", NULL); ATF_CHECK(!isc_task_privilege(task2)); /* First event: privileged */ event = isc_event_allocate(mctx, task1, ISC_TASKEVENT_TEST, set_and_drop, &a, sizeof (isc_event_t)); ATF_REQUIRE(event != NULL); ATF_CHECK_EQ(a, -1); isc_task_send(task1, &event); /* Second event: not privileged */ event = isc_event_allocate(mctx, task2, ISC_TASKEVENT_TEST, set_and_drop, &b, sizeof (isc_event_t)); ATF_REQUIRE(event != NULL); ATF_CHECK_EQ(b, -1); isc_task_send(task2, &event); /* Third event: privileged */ event = isc_event_allocate(mctx, task1, ISC_TASKEVENT_TEST, set_and_drop, &c, sizeof (isc_event_t)); ATF_REQUIRE(event != NULL); ATF_CHECK_EQ(c, -1); isc_task_send(task1, &event); /* Fourth event: privileged */ event = isc_event_allocate(mctx, task1, ISC_TASKEVENT_TEST, set_and_drop, &d, sizeof (isc_event_t)); ATF_REQUIRE(event != NULL); ATF_CHECK_EQ(d, -1); isc_task_send(task1, &event); /* Fifth event: not privileged */ event = isc_event_allocate(mctx, task2, ISC_TASKEVENT_TEST, set_and_drop, &e, sizeof (isc_event_t)); ATF_REQUIRE(event != NULL); ATF_CHECK_EQ(e, -1); isc_task_send(task2, &event); ATF_CHECK_EQ(isc_taskmgr_mode(taskmgr), isc_taskmgrmode_normal); isc_taskmgr_setmode(taskmgr, isc_taskmgrmode_privileged); ATF_CHECK_EQ(isc_taskmgr_mode(taskmgr), isc_taskmgrmode_privileged); #ifdef ISC_PLATFORM_USETHREADS isc__taskmgr_resume(taskmgr); #endif /* We're waiting for all variables to be set. */ while ((a == -1 || b == -1 || c == -1 || d == -1 || e == -1) && i++ < 5000) { #ifndef ISC_PLATFORM_USETHREADS while (isc__taskmgr_ready(taskmgr)) isc__taskmgr_dispatch(taskmgr); #endif isc_test_nap(1000); } /* * We can't guarantee what order the events fire, but * we do know *exactly one* of the privileged tasks will * have run in privileged mode... */ ATF_CHECK(a == isc_taskmgrmode_privileged || c == isc_taskmgrmode_privileged || d == isc_taskmgrmode_privileged); ATF_CHECK(a + c + d == isc_taskmgrmode_privileged); /* ...and neither of the non-privileged tasks did... */ ATF_CHECK(b == isc_taskmgrmode_normal || e == isc_taskmgrmode_normal); /* ...but all five of them did run. */ ATF_CHECK_EQ(counter, 6); ATF_CHECK_EQ(isc_taskmgr_mode(taskmgr), isc_taskmgrmode_normal); isc_task_destroy(&task1); ATF_REQUIRE_EQ(task1, NULL); isc_task_destroy(&task2); ATF_REQUIRE_EQ(task2, NULL); isc_test_end(); }
ATF_TC_BODY(privileged_events, tc) { isc_result_t result; isc_task_t *task1 = NULL, *task2 = NULL; isc_event_t *event; int a = 0, b = 0, c = 0, d = 0, e = 0; int i = 0; UNUSED(tc); counter = 1; result = isc_mutex_init(&set_lock); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); result = isc_test_begin(NULL, ISC_TRUE); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); #ifdef ISC_PLATFORM_USETHREADS /* * Pause the task manager so we can fill up the work queue * without things happening while we do it. */ isc__taskmgr_pause(taskmgr); #endif result = isc_task_create(taskmgr, 0, &task1); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); isc_task_setname(task1, "privileged", NULL); ATF_CHECK(!isc_task_privilege(task1)); isc_task_setprivilege(task1, ISC_TRUE); ATF_CHECK(isc_task_privilege(task1)); result = isc_task_create(taskmgr, 0, &task2); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); isc_task_setname(task2, "normal", NULL); ATF_CHECK(!isc_task_privilege(task2)); /* First event: privileged */ event = isc_event_allocate(mctx, task1, ISC_TASKEVENT_TEST, set, &a, sizeof (isc_event_t)); ATF_REQUIRE(event != NULL); ATF_CHECK_EQ(a, 0); isc_task_send(task1, &event); /* Second event: not privileged */ event = isc_event_allocate(mctx, task2, ISC_TASKEVENT_TEST, set, &b, sizeof (isc_event_t)); ATF_REQUIRE(event != NULL); ATF_CHECK_EQ(b, 0); isc_task_send(task2, &event); /* Third event: privileged */ event = isc_event_allocate(mctx, task1, ISC_TASKEVENT_TEST, set, &c, sizeof (isc_event_t)); ATF_REQUIRE(event != NULL); ATF_CHECK_EQ(c, 0); isc_task_send(task1, &event); /* Fourth event: privileged */ event = isc_event_allocate(mctx, task1, ISC_TASKEVENT_TEST, set, &d, sizeof (isc_event_t)); ATF_REQUIRE(event != NULL); ATF_CHECK_EQ(d, 0); isc_task_send(task1, &event); /* Fifth event: not privileged */ event = isc_event_allocate(mctx, task2, ISC_TASKEVENT_TEST, set, &e, sizeof (isc_event_t)); ATF_REQUIRE(event != NULL); ATF_CHECK_EQ(e, 0); isc_task_send(task2, &event); ATF_CHECK_EQ(isc_taskmgr_mode(taskmgr), isc_taskmgrmode_normal); isc_taskmgr_setmode(taskmgr, isc_taskmgrmode_privileged); ATF_CHECK_EQ(isc_taskmgr_mode(taskmgr), isc_taskmgrmode_privileged); #ifdef ISC_PLATFORM_USETHREADS isc__taskmgr_resume(taskmgr); #endif /* We're waiting for *all* variables to be set */ while ((a == 0 || b == 0 || c == 0 || d == 0 || e == 0) && i++ < 5000) { #ifndef ISC_PLATFORM_USETHREADS while (isc__taskmgr_ready(taskmgr)) isc__taskmgr_dispatch(taskmgr); #endif isc_test_nap(1000); } /* * We can't guarantee what order the events fire, but * we do know the privileged tasks that set a, c, and d * would have fired first. */ ATF_CHECK(a <= 3); ATF_CHECK(c <= 3); ATF_CHECK(d <= 3); /* ...and the non-privileged tasks that set b and e, last */ ATF_CHECK(b >= 4); ATF_CHECK(e >= 4); ATF_CHECK_EQ(counter, 6); isc_task_setprivilege(task1, ISC_FALSE); ATF_CHECK(!isc_task_privilege(task1)); ATF_CHECK_EQ(isc_taskmgr_mode(taskmgr), isc_taskmgrmode_normal); isc_task_destroy(&task1); ATF_REQUIRE_EQ(task1, NULL); isc_task_destroy(&task2); ATF_REQUIRE_EQ(task2, NULL); isc_test_end(); }
ATF_TC_BODY(queue_valid, tc) { isc_result_t result; item_queue_t queue; item_t one, two, three, four, five; item_t *p; UNUSED(tc); ISC_QUEUE_INIT(queue, qlink); item_init(&one, 1); item_init(&two, 2); item_init(&three, 3); item_init(&four, 4); item_init(&five, 5); result = isc_test_begin(NULL, ISC_TRUE); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); ATF_CHECK(ISC_QUEUE_EMPTY(queue)); ISC_QUEUE_POP(queue, qlink, p); ATF_CHECK(p == NULL); ATF_CHECK(! ISC_QLINK_LINKED(&one, qlink)); ISC_QUEUE_PUSH(queue, &one, qlink); ATF_CHECK(ISC_QLINK_LINKED(&one, qlink)); ATF_CHECK(! ISC_QUEUE_EMPTY(queue)); ISC_QUEUE_POP(queue, qlink, p); ATF_REQUIRE(p != NULL); ATF_CHECK_EQ(p->value, 1); ATF_CHECK(ISC_QUEUE_EMPTY(queue)); ATF_CHECK(! ISC_QLINK_LINKED(p, qlink)); ISC_QUEUE_PUSH(queue, p, qlink); ATF_CHECK(! ISC_QUEUE_EMPTY(queue)); ATF_CHECK(ISC_QLINK_LINKED(p, qlink)); ATF_CHECK(! ISC_QLINK_LINKED(&two, qlink)); ISC_QUEUE_PUSH(queue, &two, qlink); ATF_CHECK(ISC_QLINK_LINKED(&two, qlink)); ATF_CHECK(! ISC_QLINK_LINKED(&three, qlink)); ISC_QUEUE_PUSH(queue, &three, qlink); ATF_CHECK(ISC_QLINK_LINKED(&three, qlink)); ATF_CHECK(! ISC_QLINK_LINKED(&four, qlink)); ISC_QUEUE_PUSH(queue, &four, qlink); ATF_CHECK(ISC_QLINK_LINKED(&four, qlink)); ATF_CHECK(! ISC_QLINK_LINKED(&five, qlink)); ISC_QUEUE_PUSH(queue, &five, qlink); ATF_CHECK(ISC_QLINK_LINKED(&five, qlink)); ISC_QUEUE_POP(queue, qlink, p); ATF_REQUIRE(p != NULL); ATF_CHECK_EQ(p->value, 1); ISC_QUEUE_POP(queue, qlink, p); ATF_REQUIRE(p != NULL); ATF_CHECK_EQ(p->value, 2); ISC_QUEUE_POP(queue, qlink, p); ATF_REQUIRE(p != NULL); ATF_CHECK_EQ(p->value, 3); ISC_QUEUE_POP(queue, qlink, p); ATF_REQUIRE(p != NULL); ATF_CHECK_EQ(p->value, 4); ISC_QUEUE_POP(queue, qlink, p); ATF_REQUIRE(p != NULL); ATF_CHECK_EQ(p->value, 5); ATF_CHECK(ISC_QUEUE_EMPTY(queue)); ISC_QUEUE_DESTROY(queue); isc_test_end(); }
ATF_TC_BODY(udp_sendto, tc) { isc_result_t result; isc_sockaddr_t addr1, addr2; struct in_addr in; isc_socket_t *s1 = NULL, *s2 = NULL; isc_task_t *task = NULL; char sendbuf[BUFSIZ], recvbuf[BUFSIZ]; completion_t completion; isc_region_t r; UNUSED(tc); result = isc_test_begin(NULL, ISC_TRUE); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); /* * Create two sockets: 127.0.0.1/5444 and 127.0.0.1/5445, talking to * each other. */ in.s_addr = inet_addr("127.0.0.1"); isc_sockaddr_fromin(&addr1, &in, 5444); isc_sockaddr_fromin(&addr2, &in, 5445); result = isc_socket_create(socketmgr, PF_INET, isc_sockettype_udp, &s1); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); result = isc_socket_bind(s1, &addr1, ISC_SOCKET_REUSEADDRESS); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); result = isc_socket_create(socketmgr, PF_INET, isc_sockettype_udp, &s2); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); result = isc_socket_bind(s2, &addr2, ISC_SOCKET_REUSEADDRESS); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); result = isc_task_create(taskmgr, 0, &task); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); strcpy(sendbuf, "Hello"); r.base = (void *) sendbuf; r.length = strlen(sendbuf) + 1; completion_init(&completion); result = isc_socket_sendto(s1, &r, task, event_done, &completion, &addr2, NULL); ATF_CHECK_EQ(result, ISC_R_SUCCESS); waitfor(&completion); ATF_CHECK(completion.done); ATF_CHECK_EQ(completion.result, ISC_R_SUCCESS); r.base = (void *) recvbuf; r.length = BUFSIZ; completion_init(&completion); result = isc_socket_recv(s2, &r, 1, task, event_done, &completion); ATF_CHECK_EQ(result, ISC_R_SUCCESS); waitfor(&completion); ATF_CHECK(completion.done); ATF_CHECK_EQ(completion.result, ISC_R_SUCCESS); ATF_CHECK_STREQ(recvbuf, "Hello"); isc_task_detach(&task); isc_socket_detach(&s1); isc_socket_detach(&s2); isc_test_end(); }