test_res_pjsip_scheduler.c File Reference

res_pjsip scheduler tests More...

#include "asterisk.h"
#include <pjsip.h>
#include "asterisk/test.h"
#include "asterisk/module.h"
#include "asterisk/taskprocessor.h"
#include "asterisk/res_pjsip.h"
#include "asterisk/utils.h"

Include dependency graph for test_res_pjsip_scheduler.c:

Go to the source code of this file.

Data Structures
struct	test_data
	Sorcery object created based on backend data. More...

Macros
#define	CATEGORY   "/res/res_pjsip/scheduler/"
#define	M2U(x)   (long int)(x * 1000)
#define	S2U(x)   (long int)(x * 1000 * 1000)
#define	waitfor(x)

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
	AST_TEST_DEFINE (serialized_scheduler)
	AST_TEST_DEFINE (unserialized_scheduler)
	AST_TEST_DEFINE (scheduler_cleanup)
	AST_TEST_DEFINE (scheduler_cancel)
	AST_TEST_DEFINE (scheduler_policy)
static void	data_cleanup (void *data)
static int	dummy_task (void *data)
static int	load_module (void)
static int	scheduler (struct ast_test *test, int serialized)
static int	task_1 (void *data)
static void	test_destructor (void *data)
static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "res_pjsip scheduler test module" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .requires = "res_pjsip", }
static const struct ast_module_info *	ast_module_info = &__mod_info
static int	destruct_count
static int	run_count

Detailed Description

res_pjsip scheduler tests

Author

George Joseph georg.nosp@m.e.jo.nosp@m.seph@.nosp@m.fair.nosp@m.view5.nosp@m..com

Definition in file test_res_pjsip_scheduler.c.

Macro Definition Documentation

CATEGORY

#define CATEGORY   "/res/res_pjsip/scheduler/"

Definition at line 43 of file test_res_pjsip_scheduler.c.

Referenced by AST_TEST_DEFINE().

M2U

#define M2U

(

x

)

(long int)(x * 1000)

Definition at line 61 of file test_res_pjsip_scheduler.c.

Referenced by AST_TEST_DEFINE(), dummy_task(), and task_1().

S2U

#define S2U

(

x

)

(long int)(x * 1000 * 1000)

Definition at line 60 of file test_res_pjsip_scheduler.c.

waitfor

#define waitfor

(

x

)

Definition at line 92 of file test_res_pjsip_scheduler.c.

Referenced by AST_TEST_DEFINE(), and scheduler().

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 431 of file test_res_pjsip_scheduler.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 431 of file test_res_pjsip_scheduler.c.

AST_MODULE_SELF_SYM()

struct ast_module* AST_MODULE_SELF_SYM

(

void

)

Definition at line 431 of file test_res_pjsip_scheduler.c.

AST_TEST_DEFINE() [1/5]

AST_TEST_DEFINE

(

serialized_scheduler

)

Definition at line 173 of file test_res_pjsip_scheduler.c.

References AST_TEST_NOT_RUN, CATEGORY, sip_to_pjsip::info(), scheduler(), TEST_EXECUTE, and TEST_INIT.

{

   switch (cmd) {
   case TEST_INIT:
      info->name = __func__;
      info->category = CATEGORY;
      info->summary = "Test res_pjsip serialized scheduler";
      info->description = "Test res_pjsip serialized scheduler";
      return AST_TEST_NOT_RUN;
   case TEST_EXECUTE:
      break;
   }

   return scheduler(test, 1);
}

AST_TEST_DEFINE() [2/5]

AST_TEST_DEFINE

(

unserialized_scheduler

)

Definition at line 190 of file test_res_pjsip_scheduler.c.

References AST_TEST_NOT_RUN, CATEGORY, sip_to_pjsip::info(), scheduler(), TEST_EXECUTE, and TEST_INIT.

{

   switch (cmd) {
   case TEST_INIT:
      info->name = __func__;
      info->category = CATEGORY;
      info->summary = "Test res_pjsip unserialized scheduler";
      info->description = "Test res_pjsip unserialized scheduler";
      return AST_TEST_NOT_RUN;
   case TEST_EXECUTE:
      break;
   }

   return scheduler(test, 0);
}

AST_TEST_DEFINE() [3/5]

AST_TEST_DEFINE

(

scheduler_cleanup

)

Definition at line 225 of file test_res_pjsip_scheduler.c.

References ao2_alloc, ao2_cleanup, ao2_ref, ast_sip_sched_is_task_running(), AST_SIP_SCHED_TASK_DATA_AO2, AST_SIP_SCHED_TASK_DATA_FREE, ast_sip_sched_task_get_next_run(), ast_sip_schedule_task(), AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, CATEGORY, destruct_count, dummy_task(), error(), sip_to_pjsip::info(), test_data::interval, M2U, NULL, RAII_VAR, test_data::sleep, task(), test_destructor(), TEST_EXECUTE, and TEST_INIT.

{
   RAII_VAR(int *, sleep, NULL, ao2_cleanup);
   RAII_VAR(struct ast_sip_sched_task *, task, NULL, ao2_cleanup);
   int interval;
   int when;

   switch (cmd) {
   case TEST_INIT:
      info->name = __func__;
      info->category = CATEGORY;
      info->summary = "Test res_pjsip scheduler cleanup";
      info->description = "Test res_pjsip scheduler cleanup";
      return AST_TEST_NOT_RUN;
   case TEST_EXECUTE:
      break;
   }

   destruct_count = 0;
   interval = 1000;

   sleep = ao2_alloc(sizeof(*sleep), test_destructor);
   ast_test_validate(test, sleep != NULL);
   *sleep = 500;

   ast_test_status_update(test, "This test will take about %3.1f seconds\n",
      ((interval * 1.1) + *sleep) / 1000.0);

   task = ast_sip_schedule_task(NULL, interval, dummy_task, "dummy", sleep,
      AST_SIP_SCHED_TASK_DATA_AO2 | AST_SIP_SCHED_TASK_DATA_FREE);
   ast_test_validate(test, task != NULL);
   usleep(M2U(interval * 0.5));
   when = ast_sip_sched_task_get_next_run(task);
   ast_test_validate(test, (when > (interval * 0.4) && when < (interval * 0.6)));
   usleep(M2U(interval * 0.6));
   ast_test_validate(test, ast_sip_sched_is_task_running(task));

   usleep(M2U(*sleep));

   ast_test_validate(test, (ast_sip_sched_is_task_running(task) == 0));
   when = ast_sip_sched_task_get_next_run(task);
   ast_test_validate(test, (when < 0), res, error);
   ast_test_validate(test, (ao2_ref(task, 0) == 1));
   ao2_ref(task, -1);
   task = NULL;
   ast_test_validate(test, (destruct_count == 1));
   sleep = NULL;

   return AST_TEST_PASS;
}

AST_TEST_DEFINE() [4/5]

AST_TEST_DEFINE

(

scheduler_cancel

)

Definition at line 276 of file test_res_pjsip_scheduler.c.

References ao2_alloc, ao2_cleanup, ao2_ref, ast_sip_sched_is_task_running_by_name(), ast_sip_sched_task_cancel_by_name(), AST_SIP_SCHED_TASK_DATA_NO_CLEANUP, ast_sip_sched_task_get_next_run(), ast_sip_sched_task_get_next_run_by_name(), ast_sip_schedule_task(), AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, CATEGORY, destruct_count, dummy_task(), sip_to_pjsip::info(), test_data::interval, M2U, NULL, RAII_VAR, run_count, test_data::sleep, task(), test_destructor(), TEST_EXECUTE, and TEST_INIT.

{
   RAII_VAR(int *, sleep, NULL, ao2_cleanup);
   RAII_VAR(struct ast_sip_sched_task *, task, NULL, ao2_cleanup);
   int interval;
   int when;

   switch (cmd) {
   case TEST_INIT:
      info->name = __func__;
      info->category = CATEGORY;
      info->summary = "Test res_pjsip scheduler cancel task";
      info->description = "Test res_pjsip scheduler cancel task";
      return AST_TEST_NOT_RUN;
   case TEST_EXECUTE:
      break;
   }

   destruct_count = 0;
   interval = 1000;

   sleep = ao2_alloc(sizeof(*sleep), test_destructor);
   ast_test_validate(test, sleep != NULL);
   *sleep = 500;

   ast_test_status_update(test, "This test will take about %3.1f seconds\n",
      (interval + *sleep) / 1000.0);

   task = ast_sip_schedule_task(NULL, interval, dummy_task, "dummy", sleep, AST_SIP_SCHED_TASK_DATA_NO_CLEANUP);
   ast_test_validate(test, task != NULL);

   usleep(M2U(interval * 0.5));
   when = ast_sip_sched_task_get_next_run_by_name("dummy");
   ast_test_validate(test, (when > (interval * 0.4) && when < (interval * 0.6)));
   ast_test_validate(test, !ast_sip_sched_is_task_running_by_name("dummy"));
   ast_test_validate(test, ao2_ref(task, 0) == 2);

   ast_sip_sched_task_cancel_by_name("dummy");

   when = ast_sip_sched_task_get_next_run(task);
   ast_test_validate(test, when < 0);

   usleep(M2U(interval));
   ast_test_validate(test, run_count == 0);
   ast_test_validate(test, destruct_count == 0);
   ast_test_validate(test, ao2_ref(task, 0) == 1);

   return AST_TEST_PASS;
}

AST_TEST_DEFINE() [5/5]

AST_TEST_DEFINE

(

scheduler_policy

)

Definition at line 326 of file test_res_pjsip_scheduler.c.

References ao2_alloc, ao2_cleanup, ast_cond_init, ast_mutex_init, ast_mutex_lock, ast_mutex_unlock, ast_sip_sched_task_cancel(), AST_SIP_SCHED_TASK_DATA_NO_CLEANUP, AST_SIP_SCHED_TASK_PERIODIC, ast_sip_schedule_task(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, ast_tvdiff_ms(), ast_tvnow(), CATEGORY, data_cleanup(), destruct_count, test_data::done, sip_to_pjsip::info(), test_data::interval, M2U, NULL, RAII_VAR, run_count, task(), task_1(), test_data::test, TEST_EXECUTE, TEST_INIT, and waitfor.

{
   RAII_VAR(struct test_data *, test_data1, ao2_alloc(sizeof(*test_data1), data_cleanup), ao2_cleanup);
   RAII_VAR(struct ast_sip_sched_task *, task, NULL, ao2_cleanup);
   int when;

   switch (cmd) {
   case TEST_INIT:
      info->name = __func__;
      info->category = CATEGORY;
      info->summary = "Test res_pjsip scheduler cancel task";
      info->description = "Test res_pjsip scheduler cancel task";
      return AST_TEST_NOT_RUN;
   case TEST_EXECUTE:
      break;
   }

   ast_test_validate(test, test_data1 != NULL);

   destruct_count = 0;
   run_count = 0;
   test_data1->test = test;
   test_data1->test_start = ast_tvnow();
   test_data1->interval = 1000;
   test_data1->sleep = 500;
   test_data1->no_clear_done = 1;
   ast_mutex_init(&test_data1->lock);
   ast_cond_init(&test_data1->cond, NULL);

   ast_test_status_update(test, "This test will take about %3.1f seconds\n",
      ((test_data1->interval * 4) + test_data1->sleep) / 1000.0);

   task = ast_sip_schedule_task(NULL, test_data1->interval, task_1, "test_1", test_data1,
      AST_SIP_SCHED_TASK_DATA_NO_CLEANUP | AST_SIP_SCHED_TASK_PERIODIC);
   ast_test_validate(test, task != NULL);

   waitfor(test_data1);
   when = ast_tvdiff_ms(test_data1->task_start, test_data1->test_start);
   ast_test_validate(test, when > test_data1->interval * 0.9 && when < test_data1->interval * 1.1);

   waitfor(test_data1);
   when = ast_tvdiff_ms(test_data1->task_start, test_data1->test_start);
   ast_test_validate(test, when > test_data1->interval * 2 * 0.9 && when < test_data1->interval * 2 * 1.1);

   waitfor(test_data1);
   when = ast_tvdiff_ms(test_data1->task_start, test_data1->test_start);
   ast_test_validate(test, when > test_data1->interval * 3 * 0.9 && when < test_data1->interval * 3 * 1.1);

   ast_sip_sched_task_cancel(task);

   /* Wait a full interval in case a 4th call to test_1 happened before the cancel */
   usleep(M2U(test_data1->interval));

   ast_mutex_lock(&test_data1->lock);
   if (test_data1->done) {
      int done = test_data1->done;

      test_data1->done = 0;
      ast_mutex_unlock(&test_data1->lock);

      ast_test_validate(test, done == 1);

      /* Wait two full intervals to be certain no further calls to test_1. */
      usleep(M2U(test_data1->interval * 2));

      ast_mutex_lock(&test_data1->lock);
      if (test_data1->done != 0) {
         ast_mutex_unlock(&test_data1->lock);
         /* The cancelation failed so we need to prevent cleanup of
          * test_data1 to prevent a crash from write-after-free. */
         test_data1 = NULL;
         ast_test_status_update(test, "Failed to cancel task");
         return AST_TEST_FAIL;
      }
   }
   ast_mutex_unlock(&test_data1->lock);

   return AST_TEST_PASS;
}

data_cleanup()

static void data_cleanup ( void *  data )

static

Definition at line 85 of file test_res_pjsip_scheduler.c.

References ast_cond_destroy, ast_mutex_destroy, test_data::cond, and test_data::lock.

Referenced by AST_TEST_DEFINE(), and scheduler().

{
   struct test_data *test_data = data;
   ast_mutex_destroy(&test_data->lock);
   ast_cond_destroy(&test_data->cond);
}

dummy_task()

static int dummy_task ( void *  data )

static

Definition at line 210 of file test_res_pjsip_scheduler.c.

References M2U, run_count, and test_data::sleep.

Referenced by AST_TEST_DEFINE().

{
   int *sleep = data;

   usleep(M2U(*sleep));
   run_count++;

   return 0;
}

load_module()

static int load_module ( void  )

static

Definition at line 406 of file test_res_pjsip_scheduler.c.

References AST_MODULE_LOAD_SUCCESS, and AST_TEST_REGISTER.

Referenced by unload_module().

{
   AST_TEST_REGISTER(serialized_scheduler);
   AST_TEST_REGISTER(unserialized_scheduler);
   AST_TEST_REGISTER(scheduler_cleanup);
   AST_TEST_REGISTER(scheduler_cancel);
   AST_TEST_REGISTER(scheduler_policy);
   return AST_MODULE_LOAD_SUCCESS;
}

scheduler()

static int scheduler ( struct ast_test *  test, int  serialized  )

static

Definition at line 102 of file test_res_pjsip_scheduler.c.

References ao2_alloc, ao2_cleanup, ast_cond_init, ast_mutex_init, ast_sip_create_serializer(), ast_sip_sched_task_cancel(), AST_SIP_SCHED_TASK_FIXED, ast_sip_sched_task_get_times(), ast_sip_schedule_task(), ast_taskprocessor_unreference(), AST_TEST_PASS, ast_test_status_update, ast_tvdiff_ms(), ast_tvnow(), data_cleanup(), MAX, NULL, RAII_VAR, task_1(), test_data::test, and waitfor.

Referenced by AST_TEST_DEFINE().

{
   RAII_VAR(struct ast_taskprocessor *, tp1, NULL, ast_taskprocessor_unreference);
   RAII_VAR(struct test_data *, test_data1, ao2_alloc(sizeof(*test_data1), data_cleanup), ao2_cleanup);
   RAII_VAR(struct test_data *, test_data2, ao2_alloc(sizeof(*test_data2), data_cleanup), ao2_cleanup);
   RAII_VAR(struct ast_sip_sched_task *, task1, NULL, ao2_cleanup);
   RAII_VAR(struct ast_sip_sched_task *, task2, NULL, ao2_cleanup);
   int duration;
   int delay;
   struct timeval task1_start;

   ast_test_validate(test, test_data1 != NULL);
   ast_test_validate(test, test_data2 != NULL);

   test_data1->test = test;
   test_data1->test_start = ast_tvnow();
   test_data1->interval = 2000;
   test_data1->sleep = 1000;
   ast_mutex_init(&test_data1->lock);
   ast_cond_init(&test_data1->cond, NULL);

   test_data2->test = test;
   test_data2->test_start = ast_tvnow();
   test_data2->interval = 2000;
   test_data2->sleep = 1000;
   ast_mutex_init(&test_data2->lock);
   ast_cond_init(&test_data2->cond, NULL);

   if (serialized) {
      ast_test_status_update(test, "This test will take about %3.1f seconds\n",
         (test_data1->interval + test_data1->sleep + (MAX(test_data1->interval - test_data2->interval, 0)) + test_data2->sleep) / 1000.0);
      tp1 = ast_sip_create_serializer("test-scheduler-serializer");
      ast_test_validate(test, (tp1 != NULL));
   } else {
      ast_test_status_update(test, "This test will take about %3.1f seconds\n",
         ((MAX(test_data1->interval, test_data2->interval) + MAX(test_data1->sleep, test_data2->sleep)) / 1000.0));
   }

   task1 = ast_sip_schedule_task(tp1, test_data1->interval, task_1, NULL, test_data1, AST_SIP_SCHED_TASK_FIXED);
   ast_test_validate(test, task1 != NULL);

   task2 = ast_sip_schedule_task(tp1, test_data2->interval, task_1, NULL, test_data2, AST_SIP_SCHED_TASK_FIXED);
   ast_test_validate(test, task2 != NULL);

   waitfor(test_data1);
   ast_sip_sched_task_cancel(task1);
   ast_test_validate(test, test_data1->is_servant);

   duration = ast_tvdiff_ms(test_data1->task_end, test_data1->test_start);
   ast_test_validate(test, (duration > ((test_data1->interval + test_data1->sleep) * 0.9))
      && (duration < ((test_data1->interval + test_data1->sleep) * 1.1)));

   ast_sip_sched_task_get_times(task1, NULL, &task1_start, NULL);
   delay = ast_tvdiff_ms(task1_start, test_data1->test_start);
   ast_test_validate(test, (delay > (test_data1->interval * 0.9)
      && (delay < (test_data1->interval * 1.1))));

   waitfor(test_data2);
   ast_sip_sched_task_cancel(task2);
   ast_test_validate(test, test_data2->is_servant);

   if (serialized) {
      ast_test_validate(test, test_data1->tid == test_data2->tid);
      ast_test_validate(test, ast_tvdiff_ms(test_data2->task_start, test_data1->task_end) >= 0);
   } else {
      ast_test_validate(test, test_data1->tid != test_data2->tid);
   }

   return AST_TEST_PASS;
}

task_1()

static int task_1 ( void *  data )

static

Definition at line 63 of file test_res_pjsip_scheduler.c.

References ast_cond_signal, ast_mutex_lock, ast_mutex_unlock, ast_sip_thread_is_servant(), ast_tvnow(), test_data::cond, test_data::done, test_data::interval, test_data::is_servant, test_data::lock, M2U, test_data::no_clear_done, test_data::sleep, test_data::task_end, test_data::task_start, and test_data::tid.

Referenced by AST_TEST_DEFINE(), and scheduler().

{
   struct test_data *test = data;

   if (!test->no_clear_done) {
      test->done = 0;
   }
   test->task_start = ast_tvnow();
   test->tid = pthread_self();
   test->is_servant = ast_sip_thread_is_servant();
   usleep(M2U(test->sleep));
   test->task_end = ast_tvnow();

   ast_mutex_lock(&test->lock);
   test->done++;
   ast_mutex_unlock(&test->lock);
   ast_cond_signal(&test->cond);

   return test->interval;
}

test_destructor()

static void test_destructor ( void *  data )

static

Definition at line 220 of file test_res_pjsip_scheduler.c.

References destruct_count.

Referenced by AST_TEST_DEFINE().

{
   destruct_count++;
}

unload_module()

static int unload_module ( void  )

static

Definition at line 416 of file test_res_pjsip_scheduler.c.

References AST_MODFLAG_DEFAULT, AST_MODULE_INFO(), AST_MODULE_SUPPORT_CORE, AST_TEST_UNREGISTER, ASTERISK_GPL_KEY, and load_module().

{
   AST_TEST_UNREGISTER(scheduler_cancel);
   AST_TEST_UNREGISTER(scheduler_cleanup);
   AST_TEST_UNREGISTER(unserialized_scheduler);
   AST_TEST_UNREGISTER(serialized_scheduler);
   AST_TEST_UNREGISTER(scheduler_policy);
   return 0;
}

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "res_pjsip scheduler test module" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .requires = "res_pjsip", }

static

Definition at line 431 of file test_res_pjsip_scheduler.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 431 of file test_res_pjsip_scheduler.c.

destruct_count

int destruct_count

static

Definition at line 208 of file test_res_pjsip_scheduler.c.

Referenced by AST_TEST_DEFINE(), and test_destructor().

run_count

int run_count

static

Definition at line 207 of file test_res_pjsip_scheduler.c.

Referenced by AST_TEST_DEFINE(), and dummy_task().