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 (scheduler_cancel)

	AST_TEST_DEFINE (scheduler_cleanup)

	AST_TEST_DEFINE (scheduler_policy)

	AST_TEST_DEFINE (serialized_scheduler)

	AST_TEST_DEFINE (unserialized_scheduler)

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 = ASTERISK_GPL_KEY , .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.

◆ M2U

#define M2U ( x ) (long int)(x * 1000)

Definition at line 61 of file test_res_pjsip_scheduler.c.

◆ 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.

{ \
    ast_mutex_lock(&(x)->lock); \
    while (!(x)->done) { \
        ast_cond_wait(&(x)->cond, &(x)->lock); \
    } \
    (x)->done = 0; \
    ast_mutex_unlock(&(x)->lock); \
}

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 ( scheduler_cancel )

Definition at line 276 of file test_res_pjsip_scheduler.c.

{
    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;
}

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(), M2U, NULL, RAII_VAR, run_count, task(), test_destructor(), TEST_EXECUTE, and TEST_INIT.

◆ AST_TEST_DEFINE() [2/5]

AST_TEST_DEFINE ( scheduler_cleanup )

Definition at line 225 of file test_res_pjsip_scheduler.c.

{
    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;
}

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(), M2U, NULL, RAII_VAR, task(), test_destructor(), TEST_EXECUTE, and TEST_INIT.

◆ AST_TEST_DEFINE() [3/5]

AST_TEST_DEFINE ( scheduler_policy )

Definition at line 326 of file test_res_pjsip_scheduler.c.

{
    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;
}

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, done, M2U, NULL, RAII_VAR, run_count, task(), task_1(), TEST_EXECUTE, TEST_INIT, and waitfor.

◆ AST_TEST_DEFINE() [4/5]

AST_TEST_DEFINE ( serialized_scheduler )

Definition at line 173 of file test_res_pjsip_scheduler.c.

{
 
    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);
}

References AST_TEST_NOT_RUN, CATEGORY, scheduler(), TEST_EXECUTE, and TEST_INIT.

◆ AST_TEST_DEFINE() [5/5]

AST_TEST_DEFINE ( unserialized_scheduler )

Definition at line 190 of file test_res_pjsip_scheduler.c.

{
 
    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);
}

References AST_TEST_NOT_RUN, CATEGORY, scheduler(), TEST_EXECUTE, and TEST_INIT.

◆ data_cleanup()

static void data_cleanup ( void * data )

static

Definition at line 85 of file test_res_pjsip_scheduler.c.

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

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

Referenced by AST_TEST_DEFINE(), AST_TEST_DEFINE(), and scheduler().

◆ dummy_task()

static int dummy_task ( void * data )

static

Definition at line 210 of file test_res_pjsip_scheduler.c.

{
    int *sleep = data;
 
    usleep(M2U(*sleep));
    run_count++;
 
    return 0;
}

References M2U, and run_count.

Referenced by AST_TEST_DEFINE(), and AST_TEST_DEFINE().

◆ load_module()

static int load_module ( void )

static

Definition at line 406 of file test_res_pjsip_scheduler.c.

{
    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;
}

References AST_MODULE_LOAD_SUCCESS, and AST_TEST_REGISTER.

◆ scheduler()

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

static

Definition at line 102 of file test_res_pjsip_scheduler.c.

{
    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;
}

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(), and waitfor.

Referenced by AST_TEST_DEFINE(), and AST_TEST_DEFINE().

◆ task_1()

static int task_1 ( void * data )

static

Definition at line 63 of file test_res_pjsip_scheduler.c.

{
    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;
}

References ast_cond_signal, ast_mutex_lock, ast_mutex_unlock, ast_sip_thread_is_servant(), ast_tvnow(), and M2U.

Referenced by AST_TEST_DEFINE(), and scheduler().

◆ test_destructor()

static void test_destructor ( void * data )

static

Definition at line 220 of file test_res_pjsip_scheduler.c.

{
    destruct_count++;
}

References destruct_count.

Referenced by AST_TEST_DEFINE(), and AST_TEST_DEFINE().

◆ unload_module()

static int unload_module ( void )

static

Definition at line 416 of file test_res_pjsip_scheduler.c.

{
    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;
}