tests/test_taskprocessor.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 taskprocessor 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/taskprocessor.h"
  36 #include "asterisk/module.h"
  37 #include "asterisk/astobj2.h"
  38
  39 struct task_data {
  40         ast_cond_t cond;
  41         ast_mutex_t lock;
  42         int task_complete;
  43 };
  44
  45 static int task(void *data)
  46 {
  47         struct task_data *task_data = data;
  48         SCOPED_MUTEX(lock, &task_data->lock);
  49         ++task_data->task_complete;
  50         ast_cond_signal(&task_data->cond);
  51         return 0;
  52 }
  53
  54 AST_TEST_DEFINE(default_taskprocessor)
  55 {
  56         struct ast_taskprocessor *tps;
  57         struct task_data task_data;
  58         struct timeval start;
  59         struct timespec ts;
  60         enum ast_test_result_state res = AST_TEST_PASS;
  61         int timedwait_res;
  62
  63         switch (cmd) {
  64         case TEST_INIT:
  65                 info->name = "default_taskprocessor";
  66                 info->category = "/main/taskprocessor/";
  67                 info->summary = "Test of default taskproccesor";
  68                 info->description =
  69                         "Ensures that queued tasks are executed.";
  70                 return AST_TEST_NOT_RUN;
  71         case TEST_EXECUTE:
  72                 break;
  73         }
  74
  75         tps = ast_taskprocessor_get("test", TPS_REF_DEFAULT);
  76
  77         if (!tps) {
  78                 ast_test_status_update(test, "Unable to create test taskprocessor\n");
  79                 return AST_TEST_FAIL;
  80         }
  81
  82         start = ast_tvnow();
  83
  84         ts.tv_sec = start.tv_sec + 30;
  85         ts.tv_nsec = start.tv_usec * 1000;
  86
  87         ast_cond_init(&task_data.cond, NULL);
  88         ast_mutex_init(&task_data.lock);
  89         task_data.task_complete = 0;
  90
  91         ast_taskprocessor_push(tps, task, &task_data);
  92         ast_mutex_lock(&task_data.lock);
  93         while (!task_data.task_complete) {
  94                 timedwait_res = ast_cond_timedwait(&task_data.cond, &task_data.lock, &ts);
  95                 if (timedwait_res == ETIMEDOUT) {
  96                         break;
  97                 }
  98         }
  99
 100         if (!task_data.task_complete) {
 101                 ast_test_status_update(test, "Queued task did not execute!\n");
 102                 res = AST_TEST_FAIL;
 103                 goto test_end;
 104         }
 105
 106 test_end:
 107         tps = ast_taskprocessor_unreference(tps);
 108         ast_mutex_destroy(&task_data.lock);
 109         ast_cond_destroy(&task_data.cond);
 110         return res;
 111 }
 112
 113 struct test_listener_pvt {
 114         int num_pushed;
 115         int num_emptied;
 116         int num_was_empty;
 117         int shutdown;
 118 };
 119
 120 static void *test_alloc(struct ast_taskprocessor_listener *listener)
 121 {
 122         struct test_listener_pvt *pvt;
 123
 124         pvt = ast_calloc(1, sizeof(*pvt));
 125         return pvt;
 126 }
 127
 128 static void test_task_pushed(struct ast_taskprocessor_listener *listener, int was_empty)
 129 {
 130         struct test_listener_pvt *pvt = listener->private_data;
 131         ++pvt->num_pushed;
 132         if (was_empty) {
 133                 ++pvt->num_was_empty;
 134         }
 135 }
 136
 137 static void test_emptied(struct ast_taskprocessor_listener *listener)
 138 {
 139         struct test_listener_pvt *pvt = listener->private_data;
 140         ++pvt->num_emptied;
 141 }
 142
 143 static void test_shutdown(struct ast_taskprocessor_listener *listener)
 144 {
 145         struct test_listener_pvt *pvt = listener->private_data;
 146         pvt->shutdown = 1;
 147 }
 148
 149 static void test_destroy(void *private_data)
 150 {
 151         struct test_listener_pvt *pvt = private_data;
 152         ast_free(pvt);
 153 }
 154
 155 static const struct ast_taskprocessor_listener_callbacks test_callbacks = {
 156         .alloc = test_alloc,
 157         .task_pushed = test_task_pushed,
 158         .emptied = test_emptied,
 159         .shutdown = test_shutdown,
 160         .destroy = test_destroy,
 161 };
 162
 163 static int listener_test_task(void *ignore)
 164 {
 165         return 0;
 166 }
 167
 168 static int check_stats(struct ast_test *test, const struct test_listener_pvt *pvt, int num_pushed, int num_emptied, int num_was_empty)
 169 {
 170         if (pvt->num_pushed != num_pushed) {
 171                 ast_test_status_update(test, "Unexpected number of tasks pushed. Expected %d but got %d\n",
 172                                 num_pushed, pvt->num_pushed);
 173                 return -1;
 174         }
 175
 176         if (pvt->num_emptied != num_emptied) {
 177                 ast_test_status_update(test, "Unexpected number of empties. Expected %d but got %d\n",
 178                                 num_emptied, pvt->num_emptied);
 179                 return -1;
 180         }
 181
 182         if (pvt->num_was_empty != num_was_empty) {
 183                 ast_test_status_update(test, "Unexpected number of empties. Expected %d but got %d\n",
 184                                 num_was_empty, pvt->num_emptied);
 185                 return -1;
 186         }
 187
 188         return 0;
 189 }
 190
 191 AST_TEST_DEFINE(taskprocessor_listener)
 192 {
 193         struct ast_taskprocessor *tps;
 194         struct ast_taskprocessor_listener *listener;
 195         struct test_listener_pvt *pvt;
 196         enum ast_test_result_state res = AST_TEST_PASS;
 197
 198         switch (cmd) {
 199         case TEST_INIT:
 200                 info->name = "taskprocessor_listener";
 201                 info->category = "/main/taskprocessor/";
 202                 info->summary = "Test of taskproccesor listeners";
 203                 info->description =
 204                         "Ensures that listener callbacks are called when expected.";
 205                 return AST_TEST_NOT_RUN;
 206         case TEST_EXECUTE:
 207                 break;
 208         }
 209
 210         listener = ast_taskprocessor_listener_alloc(&test_callbacks);
 211         if (!listener) {
 212                 ast_test_status_update(test, "Unable to allocate test taskprocessor listener\n");
 213                 return AST_TEST_FAIL;
 214         }
 215
 216         tps = ast_taskprocessor_create_with_listener("test_listener", listener);
 217         if (!tps) {
 218                 ast_test_status_update(test, "Unable to allocate test taskprocessor\n");
 219                 res = AST_TEST_FAIL;
 220                 goto test_exit;
 221         }
 222
 223         pvt = listener->private_data;
 224
 225         ast_taskprocessor_push(tps, listener_test_task, NULL);
 226
 227         if (check_stats(test, pvt, 1, 0, 1) < 0) {
 228                 res = AST_TEST_FAIL;
 229                 goto test_exit;
 230         }
 231
 232         ast_taskprocessor_push(tps, listener_test_task, NULL);
 233
 234         if (check_stats(test, pvt, 2, 0, 1) < 0) {
 235                 res = AST_TEST_FAIL;
 236                 goto test_exit;
 237         }
 238
 239         ast_taskprocessor_execute(tps);
 240
 241         if (check_stats(test, pvt, 2, 0, 1) < 0) {
 242                 res = AST_TEST_FAIL;
 243                 goto test_exit;
 244         }
 245
 246         ast_taskprocessor_execute(tps);
 247
 248         if (check_stats(test, pvt, 2, 1, 1) < 0) {
 249                 res = AST_TEST_FAIL;
 250                 goto test_exit;
 251         }
 252
 253         tps = ast_taskprocessor_unreference(tps);
 254
 255         if (!pvt->shutdown) {
 256                 res = AST_TEST_FAIL;
 257                 goto test_exit;
 258         }
 259
 260 test_exit:
 261         ao2_ref(listener, -1);
 262         /* This is safe even if tps is NULL */
 263         ast_taskprocessor_unreference(tps);
 264         return res;
 265 }
 266
 267 static int unload_module(void)
 268 {
 269         ast_test_unregister(default_taskprocessor);
 270         ast_test_unregister(taskprocessor_listener);
 271         return 0;
 272 }
 273
 274 static int load_module(void)
 275 {
 276         ast_test_register(default_taskprocessor);
 277         ast_test_register(taskprocessor_listener);
 278         return AST_MODULE_LOAD_SUCCESS;
 279 }
 280
 281 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "taskprocessor test module");