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