test_scoped_lock.c File Reference

SCOPED_LOCK unit tests. More...

#include "asterisk.h"
#include "asterisk/test.h"
#include "asterisk/utils.h"
#include "asterisk/module.h"
#include "asterisk/astobj2.h"

Include dependency graph for test_scoped_lock.c:

Go to the source code of this file.

Data Structures
struct	test_struct

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
	AST_TEST_DEFINE (cleanup_order)
	AST_TEST_DEFINE (lock_test)
static int	load_module (void)
static void	lock_it (ast_mutex_t *lock)
static struct test_struct *	test_iterator_next (struct ao2_iterator *iter)
	wrapper for ao2_iterator_next
static void	test_lock (struct test_struct *test)
	lock callback function
static struct test_struct *	test_ref (struct test_struct *test)
	ref callback function
static void	test_unlock (struct test_struct *test)
	unlock callback function
static void	test_unref (struct test_struct *test)
	unref callback function
static int	unload_module (void)
static void	unlock_it (ast_mutex_t *lock)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "SCOPED_LOCK test module" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_DEFAULT, .support_level = AST_MODULE_SUPPORT_CORE, }
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct ast_test *	current_test
static int	indicator
static ast_mutex_t	the_lock = AST_MUTEX_INIT_VALUE

Detailed Description

SCOPED_LOCK unit tests.

Author

Mark Michelson mmich.nosp@m.elso.nosp@m.n@dig.nosp@m.ium..nosp@m.com

Definition in file test_scoped_lock.c.

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 283 of file test_scoped_lock.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 283 of file test_scoped_lock.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 283 of file test_scoped_lock.c.

AST_TEST_DEFINE() [1/2]

AST_TEST_DEFINE

(

cleanup_order

)

Definition at line 197 of file test_scoped_lock.c.

{
    enum ast_test_result_state res = AST_TEST_PASS;
    struct ao2_iterator iter;
    struct test_struct *object_iter;
    RAII_VAR(struct ao2_container*, container, NULL, ao2_cleanup);
    RAII_VAR(struct test_struct *, object, NULL, ao2_cleanup);
 
    switch(cmd) {
    case TEST_INIT:
        info->name = "cleanup_order_test";
        info->category = "/main/lock/";
        info->summary = "cleanup order test";
        info->description =
            "Tests that variables with cleanup attributes are cleaned up\n"
            "in the reverse order they are declared.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
    current_test = test;
 
    container = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, 13, NULL, NULL, NULL);
    object = ao2_alloc(sizeof(*object), NULL);
    if (!object || !container) {
        /* Allocation failure. We can't even pretend to do this test properly */
        return AST_TEST_FAIL;
    }
 
    {
        /* Purpose of this block is to make sure that the cleanup operations
         * run in the reverse order that they were created here.
         */
        RAII_VAR(struct test_struct *, object2, test_ref(object), test_unref);
        SCOPED_LOCK(lock, object, test_lock, test_unlock);
        if (!object->reffed || !object->locked) {
            ast_log(LOG_ERROR, "Test failed due to out of order initializations");
            res = AST_TEST_FAIL;
        }
    }
 
    if (object->reffed || object->locked) {
        ast_log(LOG_ERROR, "Test failed due to out of order cleanups\n");
        res = AST_TEST_FAIL;
    }
 
    /* Now link the object into the container for a little experiment ... */
    ao2_link(container, object);
 
    /* This loop is to ensure that unrefs in a for loop occur after the cleanup
     * operations of items inside the loop. If we hope to be able to mix scoped locks
     * and ao2 refs, this is the way to go about it.
     */
    for (iter = ao2_iterator_init(container, 0);
            (object_iter = test_iterator_next(&iter));
            test_unref(object_iter)) {
        SCOPED_LOCK(lock, object_iter, test_lock, test_unlock);
        if (!object->reffed || !object->locked) {
            ast_log(LOG_ERROR, "Test failed due to out of order initializations");
            res = AST_TEST_FAIL;
        }
    }
    ao2_iterator_destroy(&iter);
 
    if (object->reffed || object->locked) {
        ast_log(LOG_ERROR, "Test failed due to out of order cleanups\n");
        res = AST_TEST_FAIL;
    }
 
    return res;
}

References ao2_alloc, AO2_ALLOC_OPT_LOCK_MUTEX, ao2_cleanup, ao2_container_alloc_hash, ao2_iterator_destroy(), ao2_iterator_init(), ao2_link, ast_log, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, container, current_test, lock, LOG_ERROR, NULL, RAII_VAR, SCOPED_LOCK, TEST_EXECUTE, TEST_INIT, test_iterator_next(), test_lock(), test_ref(), test_unlock(), and test_unref().

AST_TEST_DEFINE() [2/2]

AST_TEST_DEFINE

(

lock_test

)

Definition at line 55 of file test_scoped_lock.c.

{
    enum ast_test_result_state res = AST_TEST_PASS;
    int i;
 
    switch(cmd) {
    case TEST_INIT:
        info->name = "lock_test";
        info->category = "/main/lock/";
        info->summary = "SCOPED_LOCK test";
        info->description =
            "Tests that scoped locks are scoped as they are expected to be";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    current_test = test;
    indicator = 0;
    {
        SCOPED_LOCK(lock, &the_lock, lock_it, unlock_it);
        if (indicator != 1) {
            ast_log(LOG_ERROR, "The lock was not acquired via RAII");
            res = AST_TEST_FAIL;
        }
    }
    if (indicator != 0) {
        ast_log(LOG_ERROR, "The lock was not released when the variable went out of scope");
        res = AST_TEST_FAIL;
    }
 
    for (i = 0; i < 10; ++i) {
        SCOPED_LOCK(lock, &the_lock, lock_it, unlock_it);
        if (indicator != 1) {
            ast_log(LOG_ERROR, "The lock was not acquired via RAII");
            res = AST_TEST_FAIL;
        }
    }
 
    if (indicator != 0) {
        ast_log(LOG_ERROR, "The lock was not released when the variable went out of scope");
        res = AST_TEST_FAIL;
    }
 
    return res;
}

References ast_log, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, current_test, indicator, lock, lock_it(), LOG_ERROR, SCOPED_LOCK, TEST_EXECUTE, TEST_INIT, the_lock, and unlock_it().

load_module()

static int load_module ( void  )

static

Definition at line 276 of file test_scoped_lock.c.

{
    AST_TEST_REGISTER(lock_test);
    AST_TEST_REGISTER(cleanup_order);
    return AST_MODULE_LOAD_SUCCESS;
}

References AST_MODULE_LOAD_SUCCESS, and AST_TEST_REGISTER.

lock_it()

static void lock_it ( ast_mutex_t *  lock )

static

Definition at line 43 of file test_scoped_lock.c.

{
    indicator = 1;
    ast_mutex_lock(lock);
}

References ast_mutex_lock, indicator, and lock.

Referenced by AST_TEST_DEFINE().

test_iterator_next()

static struct test_struct * test_iterator_next ( struct ao2_iterator *  iter )

static

wrapper for ao2_iterator_next

Grabs the next item in the container and replaces the ref acquired from ao2_iterator_next() with a call to test_ref().

Definition at line 179 of file test_scoped_lock.c.

{
    struct test_struct *test = ao2_iterator_next(iter);
 
    if (!test) {
        return NULL;
    }
 
    /* Remove ref from ao2_iterator_next() and replace it with
     * a test_ref() call. The order here is safe since we can guarantee
     * the container still has a ref to the test structure.
     */
    ao2_ref(test, -1);
    test_ref(test);
 
    return test;
}

References ao2_iterator_next, ao2_ref, NULL, and test_ref().

Referenced by AST_TEST_DEFINE().

test_lock()

static void test_lock ( struct test_struct *  test )

static

lock callback function

Locks the object passed in. Only sets the locked flag if the object is reffed. This allows us to check that locking is always occurring after reffing.

Definition at line 115 of file test_scoped_lock.c.

{
    ast_test_status_update(current_test, "Lock is occurring\n");
    ao2_lock(test);
    if (test->reffed) {
        test->locked = 1;
    }
}

References ao2_lock, ast_test_status_update, and current_test.

Referenced by AST_TEST_DEFINE().

test_ref()

static struct test_struct * test_ref ( struct test_struct *  test )

static

ref callback function

Refs the object passed in. Only sets the reffed flag if the object is not locked. This allows us to ensure that reffing always occurs before locking.

Definition at line 147 of file test_scoped_lock.c.

{
    ast_test_status_update(current_test, "Ref is occurring\n");
    ao2_ref(test, +1);
    if (!test->locked) {
        test->reffed = 1;
    }
    return test;
}

References ao2_ref, ast_test_status_update, and current_test.

Referenced by AST_TEST_DEFINE(), and test_iterator_next().

test_unlock()

static void test_unlock ( struct test_struct *  test )

static

unlock callback function

Unlocks the object passed in. Only clears the locked flag if the object is still reffed. This allows us to ensure that unlocking is always occurring before unreffing.

Definition at line 131 of file test_scoped_lock.c.

{
    ast_test_status_update(current_test, "Unlock is occurring\n");
    ao2_unlock(test);
    if (test->reffed) {
        test->locked = 0;
    }
}

References ao2_unlock, ast_test_status_update, and current_test.

Referenced by AST_TEST_DEFINE().

test_unref()

static void test_unref ( struct test_struct *  test )

static

unref callback function

Unrefs the object passed in. Only sets the unreffed flag if the object is not locked. This allows us to ensure that unreffing always occurs after unlocking.

Definition at line 164 of file test_scoped_lock.c.

{
    ast_test_status_update(current_test, "Unref is occurring\n");
    ao2_ref(test, -1);
    if (!test->locked) {
        test->reffed = 0;
    }
}

References ao2_ref, ast_test_status_update, and current_test.

Referenced by AST_TEST_DEFINE().

unload_module()

static int unload_module ( void  )

static

Definition at line 269 of file test_scoped_lock.c.

{
    AST_TEST_UNREGISTER(lock_test);
    AST_TEST_UNREGISTER(cleanup_order);
    return 0;
}

References AST_TEST_UNREGISTER.

unlock_it()

static void unlock_it ( ast_mutex_t *  lock )

static

Definition at line 49 of file test_scoped_lock.c.

{
    indicator = 0;
    ast_mutex_unlock(lock);
}

References ast_mutex_unlock, indicator, and lock.

Referenced by AST_TEST_DEFINE().

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "SCOPED_LOCK test module" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_DEFAULT, .support_level = AST_MODULE_SUPPORT_CORE, }

static

Definition at line 283 of file test_scoped_lock.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 283 of file test_scoped_lock.c.

current_test

struct ast_test* current_test

static

Definition at line 40 of file test_scoped_lock.c.

Referenced by AST_TEST_DEFINE(), AST_TEST_DEFINE(), test_lock(), test_ref(), test_unlock(), and test_unref().

indicator

int indicator

static

Definition at line 39 of file test_scoped_lock.c.

Referenced by acf_odbc_read(), AST_TEST_DEFINE(), cli_odbc_read(), hfp_parse_cind(), hfp_parse_cind_indicator(), hfp_parse_cind_test(), lock_it(), realtime_multi_odbc(), realtime_odbc(), and unlock_it().

the_lock

ast_mutex_t the_lock = AST_MUTEX_INIT_VALUE

static

Definition at line 41 of file test_scoped_lock.c.

Referenced by AST_TEST_DEFINE().