Add initial simple threadpool test.
[asterisk/asterisk.git] / tests / test_threadpool.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2012, Digium, Inc.
5  *
6  * Mark Michelson <mmichelson@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*!
20  * \file
21  * \brief threadpool unit tests
22  *
23  * \author Mark Michelson <mmichelson@digium.com>
24  *
25  */
26
27 /*** MODULEINFO
28         <depend>TEST_FRAMEWORK</depend>
29         <support_level>core</support_level>
30  ***/
31
32 #include "asterisk.h"
33
34 #include "asterisk/test.h"
35 #include "asterisk/threadpool.h"
36 #include "asterisk/module.h"
37 #include "asterisk/lock.h"
38 #include "asterisk/astobj2.h"
39
40 struct test_listener_data {
41         int num_active;
42         int num_idle;
43         int task_pushed;
44         int num_tasks;
45         int empty_notice;
46         int was_empty;
47         ast_mutex_t lock;
48         ast_cond_t cond;
49 };
50
51 static void *test_alloc(struct ast_threadpool_listener *listener)
52 {
53         struct test_listener_data *tld = ast_calloc(1, sizeof(*tld));
54         if (!tld) {
55                 return NULL;
56         }
57         ast_mutex_init(&tld->lock);
58         ast_cond_init(&tld->cond, NULL);
59         return tld;
60 }
61
62 static void test_state_changed(struct ast_threadpool *pool,
63                 struct ast_threadpool_listener *listener,
64                 int active_threads,
65                 int idle_threads)
66 {
67         struct test_listener_data *tld = listener->private_data;
68         SCOPED_MUTEX(lock, &tld->lock);
69         tld->num_active = active_threads;
70         tld->num_idle = idle_threads;
71         ast_cond_signal(&tld->cond);
72 }
73
74 static void test_task_pushed(struct ast_threadpool *pool,
75                 struct ast_threadpool_listener *listener,
76                 int was_empty)
77 {
78         struct test_listener_data *tld = listener->private_data;
79         SCOPED_MUTEX(lock, &tld->lock);
80         tld->task_pushed = 1;
81         ++tld->num_tasks;
82         tld->was_empty = was_empty;
83         ast_cond_signal(&tld->cond);
84 }
85
86 static void test_emptied(struct ast_threadpool *pool,
87                 struct ast_threadpool_listener *listener)
88 {
89         struct test_listener_data *tld = listener->private_data;
90         SCOPED_MUTEX(lock, &tld->lock);
91         tld->empty_notice = 1;
92         ast_cond_signal(&tld->cond);
93 }
94
95 static void test_destroy(void *private_data)
96 {
97         struct test_listener_data *tld = private_data;
98         ast_cond_destroy(&tld->cond);
99         ast_mutex_destroy(&tld->lock);
100         ast_free(tld);
101 }
102
103 static const struct ast_threadpool_listener_callbacks test_callbacks = {
104         .alloc = test_alloc,
105         .state_changed = test_state_changed,
106         .task_pushed = test_task_pushed,
107         .emptied = test_emptied,
108         .destroy = test_destroy,
109 };
110
111 struct simple_task_data {
112         int task_executed;
113         ast_mutex_t lock;
114         ast_cond_t cond;
115 };
116
117 static struct simple_task_data *simple_task_data_alloc(void)
118 {
119         struct simple_task_data *std = ast_calloc(1, sizeof(*std));
120
121         if (!std) {
122                 return NULL;
123         }
124         ast_mutex_init(&std->lock);
125         ast_cond_init(&std->cond, NULL);
126         return std;
127 }
128
129 static int simple_task(void *data)
130 {
131         struct simple_task_data *std = data;
132         SCOPED_MUTEX(lock, &std->lock);
133         std->task_executed = 1;
134         ast_cond_signal(&std->cond);
135         return 0;
136 }
137
138 static void wait_for_task_pushed(struct ast_threadpool_listener *listener)
139 {
140         struct test_listener_data *tld = listener->private_data;
141         struct timeval start = ast_tvnow();
142         struct timespec end = {
143                 .tv_sec = start.tv_sec + 5,
144                 .tv_nsec = start.tv_usec * 1000
145         };
146         SCOPED_MUTEX(lock, &tld->lock);
147
148         while (!tld->task_pushed) {
149                 ast_cond_timedwait(&tld->cond, lock, &end);
150         }
151 }
152
153 static enum ast_test_result_state listener_check(
154                 struct ast_test *test,
155                 struct ast_threadpool_listener *listener,
156                 int task_pushed,
157                 int was_empty,
158                 int num_tasks,
159                 int num_active,
160                 int num_idle,
161                 int empty_notice)
162 {
163         struct test_listener_data *tld = listener->private_data;
164         enum ast_test_result_state res = AST_TEST_PASS;
165
166         if (tld->task_pushed != task_pushed) {
167                 ast_test_status_update(test, "Expected task %sto be pushed, but it was%s\n",
168                                 task_pushed ? "" : "not ", tld->task_pushed ? "" : " not");
169                 res = AST_TEST_FAIL;
170         }
171         if (tld->was_empty != was_empty) {
172                 ast_test_status_update(test, "Expected %sto be empty, but it was%s\n",
173                                 was_empty ? "" : "not ", tld->task_pushed ? "" : " not");
174                 res = AST_TEST_FAIL;
175         }
176         if (tld->num_tasks!= num_tasks) {
177                 ast_test_status_update(test, "Expected %d tasks to be pushed, but got %d\n",
178                                 num_tasks, tld->num_tasks);
179                 res = AST_TEST_FAIL;
180         }
181         if (tld->num_active != num_active) {
182                 ast_test_status_update(test, "Expected %d active threads, but got %d\n",
183                                 num_active, tld->num_active);
184                 res = AST_TEST_FAIL;
185         }
186         if (tld->num_idle != num_idle) {
187                 ast_test_status_update(test, "Expected %d idle threads, but got %d\n",
188                                 num_idle, tld->num_idle);
189                 res = AST_TEST_FAIL;
190         }
191         if (tld->empty_notice != empty_notice) {
192                 ast_test_status_update(test, "Expected %s empty notice, but got %s\n",
193                                 was_empty ? "an" : "no", tld->task_pushed ? "one" : "none");
194                 res = AST_TEST_FAIL;
195         }
196
197         return res;
198 }
199
200 AST_TEST_DEFINE(threadpool_push)
201 {
202         struct ast_threadpool *pool = NULL;
203         struct ast_threadpool_listener *listener = NULL;
204         struct simple_task_data *std = NULL;
205         enum ast_test_result_state res = AST_TEST_FAIL;
206
207         switch (cmd) {
208         case TEST_INIT:
209                 info->name = "threadpool_push";
210                 info->category = "/main/threadpool_push/";
211                 info->summary = "Test task";
212                 info->description =
213                         "Basic threadpool test";
214                 return AST_TEST_NOT_RUN;
215         case TEST_EXECUTE:
216                 break;
217         }
218
219         listener = ast_threadpool_listener_alloc(&test_callbacks);
220         if (!listener) {
221                 return AST_TEST_FAIL;
222         }
223
224         pool = ast_threadpool_create(listener, 0);
225         if (!pool) {
226                 goto end;
227         }
228
229         std = simple_task_data_alloc();
230         if (!std) {
231                 goto end;
232         }
233
234         ast_threadpool_push(pool, simple_task, std);
235
236         wait_for_task_pushed(listener);
237
238         res = listener_check(test, listener, 1, 1, 1, 0, 0, 0);
239
240 end:
241         if (pool) {
242                 ast_threadpool_shutdown(pool);
243         }
244         ao2_cleanup(listener);
245         ast_free(std);
246         return res;
247 }
248
249 static int unload_module(void)
250 {
251         ast_test_unregister(threadpool_push);
252         return 0;
253 }
254
255 static int load_module(void)
256 {
257         ast_test_register(threadpool_push);
258         return AST_MODULE_LOAD_SUCCESS;
259 }
260
261 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "threadpool test module");