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);
ATF_TC_HEAD(create_pool,tc)40 ATF_TC_HEAD(create_pool, tc) {
41 atf_tc_set_md_var(tc, "descr", "create a taskpool");
42 }
ATF_TC_BODY(create_pool,tc)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);
ATF_TC_HEAD(expand_pool,tc)64 ATF_TC_HEAD(expand_pool, tc) {
65 atf_tc_set_md_var(tc, "descr", "expand a taskpool");
66 }
ATF_TC_BODY(expand_pool,tc)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);
ATF_TC_HEAD(get_tasks,tc)116 ATF_TC_HEAD(get_tasks, tc) {
117 atf_tc_set_md_var(tc, "descr", "create a taskpool");
118 }
ATF_TC_BODY(get_tasks,tc)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);
ATF_TC_HEAD(set_privilege,tc)155 ATF_TC_HEAD(set_privilege, tc) {
156 atf_tc_set_md_var(tc, "descr", "create a taskpool");
157 }
ATF_TC_BODY(set_privilege,tc)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 */
ATF_TP_ADD_TCS(tp)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