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 = 1;
  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         enum ast_test_result_state res = AST_TEST_PASS;
  59
  60         switch (cmd) {
  61         case TEST_INIT:
  62                 info->name = "default_taskprocessor";
  63                 info->category = "/main/taskprocessor/";
  64                 info->summary = "Test of default taskproccesor";
  65                 info->description =
  66                         "Ensures that queued tasks are executed.";
  67                 return AST_TEST_NOT_RUN;
  68         case TEST_EXECUTE:
  69                 break;
  70         }
  71
  72         tps = ast_taskprocessor_get("test", TPS_REF_DEFAULT);
  73
  74         if (!tps) {
  75                 ast_test_status_update(test, "Unable to create test taskprocessor\n");
  76                 return AST_TEST_FAIL;
  77         }
  78
  79         ast_cond_init(&task_data.cond, NULL);
  80         ast_mutex_init(&task_data.lock);
  81         task_data.task_complete = 0;
  82
  83         ast_taskprocessor_push(tps, task, &task_data);
  84         ast_mutex_lock(&task_data.lock);
  85         while (!task_data.task_complete) {
  86                 ast_cond_wait(&task_data.cond, &task_data.lock);
  87         }
  88
  89         if (!task_data.task_complete) {
  90                 ast_test_status_update(test, "Queued task did not execute!\n");
  91                 res = AST_TEST_FAIL;
  92                 goto test_end;
  93         }
  94
  95 test_end:
  96         tps = ast_taskprocessor_unreference(tps);
  97         ast_mutex_destroy(&task_data.lock);
  98         ast_cond_destroy(&task_data.cond);
  99         return res;
 100 }
 101
 102 struct test_listener_pvt {
 103         int num_pushed;
 104         int num_emptied;
 105 };
 106
 107 static void *test_alloc(struct ast_taskprocessor_listener *listener)
 108 {
 109         struct test_listener_pvt *pvt;
 110
 111         pvt = ast_calloc(1, sizeof(*pvt));
 112         return pvt;
 113 }
 114
 115 static void test_task_pushed(struct ast_taskprocessor_listener *listener, int was_empty)
 116 {
 117         struct test_listener_pvt *pvt = listener->private_data;
 118         ++pvt->num_pushed;
 119 }
 120
 121 static void test_emptied(struct ast_taskprocessor_listener *listener)
 122 {
 123         struct test_listener_pvt *pvt = listener->private_data;
 124         ++pvt->num_emptied;
 125 }
 126
 127 static void test_destroy(void *private_data)
 128 {
 129         struct test_listener_pvt *pvt = private_data;
 130         ast_free(pvt);
 131 }
 132
 133 static const struct ast_taskprocessor_listener_callbacks test_callbacks = {
 134         .alloc = test_alloc,
 135         .task_pushed = test_task_pushed,
 136         .emptied = test_emptied,
 137         .destroy = test_destroy,
 138 };
 139
 140 static int listener_test_task(void *ignore)
 141 {
 142         return 0;
 143 }
 144
 145 AST_TEST_DEFINE(taskprocessor_listener)
 146 {
 147         struct ast_taskprocessor *tps;
 148         struct ast_taskprocessor_listener *listener;
 149         struct test_listener_pvt *pvt;
 150         enum ast_test_result_state res = AST_TEST_PASS;
 151
 152         switch (cmd) {
 153         case TEST_INIT:
 154                 info->name = "taskprocessor_listener";
 155                 info->category = "/main/taskprocessor/";
 156                 info->summary = "Test of taskproccesor listeners";
 157                 info->description =
 158                         "Ensures that listener callbacks are called when expected.";
 159                 return AST_TEST_NOT_RUN;
 160         case TEST_EXECUTE:
 161                 break;
 162         }
 163
 164         listener = ast_taskprocessor_listener_alloc(&test_callbacks);
 165         if (!listener) {
 166                 ast_test_status_update(test, "Unable to allocate test taskprocessor listener\n");
 167                 return AST_TEST_FAIL;
 168         }
 169
 170         tps = ast_taskprocessor_create_with_listener("test_listener", listener);
 171         if (!tps) {
 172                 ast_test_status_update(test, "Unable to allocate test taskprocessor\n");
 173                 res = AST_TEST_FAIL;
 174                 goto test_exit;
 175         }
 176
 177         ast_taskprocessor_push(tps, listener_test_task, NULL);
 178         ast_taskprocessor_push(tps, listener_test_task, NULL);
 179
 180         ast_taskprocessor_execute(tps);
 181         ast_taskprocessor_execute(tps);
 182
 183         pvt = listener->private_data;
 184         if (pvt->num_pushed != 2) {
 185                 ast_test_status_update(test, "Unexpected number of tasks pushed. Expected %d but got %d\n",
 186                                 2, pvt->num_pushed);
 187                 res = AST_TEST_FAIL;
 188                 goto test_exit;
 189         }
 190
 191         if (pvt->num_emptied != 1) {
 192                 ast_test_status_update(test, "Unexpected number of empties. Expected %d but got %d\n",
 193                                 1, pvt->num_emptied);
 194                 res = AST_TEST_FAIL;
 195                 goto test_exit;
 196         }
 197
 198 test_exit:
 199         ao2_ref(listener, -1);
 200         ast_taskprocessor_unreference(tps);
 201         return res;
 202 }
 203
 204 static int unload_module(void)
 205 {
 206         ast_test_unregister(default_taskprocessor);
 207         ast_test_unregister(taskprocessor_listener);
 208         return 0;
 209 }
 210
 211 static int load_module(void)
 212 {
 213         ast_test_register(default_taskprocessor);
 214         ast_test_register(taskprocessor_listener);
 215         return AST_MODULE_LOAD_SUCCESS;
 216 }
 217
 218 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "taskprocessor test module");