contrib/ntp/lib/isc/tests/taskpool_test.c

   1 /*
   2  * Copyright (C) 2011, 2012  Internet Systems Consortium, Inc. ("ISC")
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
   9  * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  10  * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
  11  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  12  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  13  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  14  * PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 /* $Id$ */
  18
  19 /*! \file */
  20
  21 #include <config.h>
  22
  23 #include <atf-c.h>
  24
  25 #include <unistd.h>
  26
  27 #include <isc/task.h>
  28 #include <isc/taskpool.h>
  29
  30 #include "isctest.h"
  31
  32 /*
  33  * Individual unit tests
  34  */
  35
  36 /* Create a taskpool */
  37 ATF_TC(create_pool);
  38 ATF_TC_HEAD(create_pool, tc) {
  39         atf_tc_set_md_var(tc, "descr", "create a taskpool");
  40 }
  41 ATF_TC_BODY(create_pool, tc) {
  42         isc_result_t result;
  43         isc_taskpool_t *pool = NULL;
  44
  45         UNUSED(tc);
  46
  47         result = isc_test_begin(NULL, ISC_TRUE);
  48         ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
  49
  50         result = isc_taskpool_create(taskmgr, mctx, 8, 2, &pool);
  51         ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
  52         ATF_REQUIRE_EQ(isc_taskpool_size(pool), 8);
  53
  54         isc_taskpool_destroy(&pool);
  55         ATF_REQUIRE_EQ(pool, NULL);
  56
  57         isc_test_end();
  58 }
  59
  60 /* Resize a taskpool */
  61 ATF_TC(expand_pool);
  62 ATF_TC_HEAD(expand_pool, tc) {
  63         atf_tc_set_md_var(tc, "descr", "expand a taskpool");
  64 }
  65 ATF_TC_BODY(expand_pool, tc) {
  66         isc_result_t result;
  67         isc_taskpool_t *pool1 = NULL, *pool2 = NULL, *hold = NULL;
  68
  69         UNUSED(tc);
  70
  71         result = isc_test_begin(NULL, ISC_TRUE);
  72         ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
  73
  74         result = isc_taskpool_create(taskmgr, mctx, 10, 2, &pool1);
  75         ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
  76         ATF_REQUIRE_EQ(isc_taskpool_size(pool1), 10);
  77
  78         /* resizing to a smaller size should have no effect */
  79         hold = pool1;
  80         result = isc_taskpool_expand(&pool1, 5, &pool2);
  81         ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
  82         ATF_REQUIRE_EQ(isc_taskpool_size(pool2), 10);
  83         ATF_REQUIRE_EQ(pool2, hold);
  84         ATF_REQUIRE_EQ(pool1, NULL);
  85         pool1 = pool2;
  86         pool2 = NULL;
  87
  88         /* resizing to the same size should have no effect */
  89         hold = pool1;
  90         result = isc_taskpool_expand(&pool1, 10, &pool2);
  91         ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
  92         ATF_REQUIRE_EQ(isc_taskpool_size(pool2), 10);
  93         ATF_REQUIRE_EQ(pool2, hold);
  94         ATF_REQUIRE_EQ(pool1, NULL);
  95         pool1 = pool2;
  96         pool2 = NULL;
  97
  98         /* resizing to larger size should make a new pool */
  99         hold = pool1;
 100         result = isc_taskpool_expand(&pool1, 20, &pool2);
 101         ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
 102         ATF_REQUIRE_EQ(isc_taskpool_size(pool2), 20);
 103         ATF_REQUIRE(pool2 != hold);
 104         ATF_REQUIRE_EQ(pool1, NULL);
 105
 106         isc_taskpool_destroy(&pool2);
 107         ATF_REQUIRE_EQ(pool2, NULL);
 108
 109         isc_test_end();
 110 }
 111
 112 /* Get tasks */
 113 ATF_TC(get_tasks);
 114 ATF_TC_HEAD(get_tasks, tc) {
 115         atf_tc_set_md_var(tc, "descr", "create a taskpool");
 116 }
 117 ATF_TC_BODY(get_tasks, tc) {
 118         isc_result_t result;
 119         isc_taskpool_t *pool = NULL;
 120         isc_task_t *task1 = NULL, *task2 = NULL, *task3 = NULL;
 121
 122         UNUSED(tc);
 123
 124         result = isc_test_begin(NULL, ISC_TRUE);
 125         ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
 126
 127         result = isc_taskpool_create(taskmgr, mctx, 2, 2, &pool);
 128         ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
 129         ATF_REQUIRE_EQ(isc_taskpool_size(pool), 2);
 130
 131         /* two tasks in pool; make sure we can access them more than twice */
 132         isc_taskpool_gettask(pool, &task1);
 133         ATF_REQUIRE(ISCAPI_TASK_VALID(task1));
 134
 135         isc_taskpool_gettask(pool, &task2);
 136         ATF_REQUIRE(ISCAPI_TASK_VALID(task2));
 137
 138         isc_taskpool_gettask(pool, &task3);
 139         ATF_REQUIRE(ISCAPI_TASK_VALID(task3));
 140
 141         isc_task_destroy(&task1);
 142         isc_task_destroy(&task2);
 143         isc_task_destroy(&task3);
 144
 145         isc_taskpool_destroy(&pool);
 146         ATF_REQUIRE_EQ(pool, NULL);
 147
 148         isc_test_end();
 149 }
 150
 151 /* Get tasks */
 152 ATF_TC(set_privilege);
 153 ATF_TC_HEAD(set_privilege, tc) {
 154         atf_tc_set_md_var(tc, "descr", "create a taskpool");
 155 }
 156 ATF_TC_BODY(set_privilege, tc) {
 157         isc_result_t result;
 158         isc_taskpool_t *pool = NULL;
 159         isc_task_t *task1 = NULL, *task2 = NULL, *task3 = NULL;
 160
 161         UNUSED(tc);
 162
 163         result = isc_test_begin(NULL, ISC_TRUE);
 164         ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
 165
 166         result = isc_taskpool_create(taskmgr, mctx, 2, 2, &pool);
 167         ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
 168         ATF_REQUIRE_EQ(isc_taskpool_size(pool), 2);
 169
 170         isc_taskpool_setprivilege(pool, ISC_TRUE);
 171
 172         isc_taskpool_gettask(pool, &task1);
 173         isc_taskpool_gettask(pool, &task2);
 174         isc_taskpool_gettask(pool, &task3);
 175
 176         ATF_CHECK(ISCAPI_TASK_VALID(task1));
 177         ATF_CHECK(ISCAPI_TASK_VALID(task2));
 178         ATF_CHECK(ISCAPI_TASK_VALID(task3));
 179
 180         ATF_CHECK(isc_task_privilege(task1));
 181         ATF_CHECK(isc_task_privilege(task2));
 182         ATF_CHECK(isc_task_privilege(task3));
 183
 184         isc_taskpool_setprivilege(pool, ISC_FALSE);
 185
 186         ATF_CHECK(!isc_task_privilege(task1));
 187         ATF_CHECK(!isc_task_privilege(task2));
 188         ATF_CHECK(!isc_task_privilege(task3));
 189
 190         isc_task_destroy(&task1);
 191         isc_task_destroy(&task2);
 192         isc_task_destroy(&task3);
 193
 194         isc_taskpool_destroy(&pool);
 195         ATF_REQUIRE_EQ(pool, NULL);
 196
 197         isc_test_end();
 198 }
 199
 200 /*
 201  * Main
 202  */
 203 ATF_TP_ADD_TCS(tp) {
 204         ATF_TP_ADD_TC(tp, create_pool);
 205         ATF_TP_ADD_TC(tp, expand_pool);
 206         ATF_TP_ADD_TC(tp, get_tasks);
 207         ATF_TP_ADD_TC(tp, set_privilege);
 208
 209         return (atf_no_error());
 210 }
 211