test_scoped_lock.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 2012, Digium, Inc.
 *
 * Mark Michelson <mmichelson@digium.com>
 *
 * See http://www.asterisk.org for more information about
 * the Asterisk project. Please do not directly contact
 * any of the maintainers of this project for assistance;
 * the project provides a web site, mailing lists and IRC
 * channels for your use.
 *
 * This program is free software, distributed under the terms of
 * the GNU General Public License Version 2. See the LICENSE file
 * at the top of the source tree.
 */
 
/*!
 * \file
 * \brief SCOPED_LOCK unit tests
 *
 * \author Mark Michelson <mmichelson@digium.com>
 *
 */
 
/*** MODULEINFO
    <depend>TEST_FRAMEWORK</depend>
    <support_level>core</support_level>
 ***/
 
#include "asterisk.h"
 
#include "asterisk/test.h"
#include "asterisk/utils.h"
#include "asterisk/module.h"
#include "asterisk/astobj2.h"
 
static int indicator;
static struct ast_test *current_test;
AST_MUTEX_DEFINE_STATIC(the_lock);
 
static void lock_it(ast_mutex_t *lock)
{
    indicator = 1;
    ast_mutex_lock(lock);
}
 
static void unlock_it(ast_mutex_t *lock)
{
    indicator = 0;
    ast_mutex_unlock(lock);
}
 
AST_TEST_DEFINE(lock_test)
{
    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;
}
 
struct test_struct
{
    int locked;
    int reffed;
};
 
/*!
 * \brief 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.
 */
static void test_lock(struct test_struct *test)
{
    ast_test_status_update(current_test, "Lock is occurring\n");
    ao2_lock(test);
    if (test->reffed) {
        test->locked = 1;
    }
}
 
/*!
 * \brief 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.
 */
static void test_unlock(struct test_struct *test)
{
    ast_test_status_update(current_test, "Unlock is occurring\n");
    ao2_unlock(test);
    if (test->reffed) {
        test->locked = 0;
    }
}
 
/*!
 * \brief 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.
 */
static struct test_struct *test_ref(struct test_struct *test)
{
    ast_test_status_update(current_test, "Ref is occurring\n");
    ao2_ref(test, +1);
    if (!test->locked) {
        test->reffed = 1;
    }
    return test;
}
 
/*!
 * \brief 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.
 */
static void test_unref(struct test_struct *test)
{
    ast_test_status_update(current_test, "Unref is occurring\n");
    ao2_ref(test, -1);
    if (!test->locked) {
        test->reffed = 0;
    }
}
 
/*!
 * \brief 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().
 */
static struct test_struct *test_iterator_next(struct ao2_iterator *iter)
{
    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;
}
 
AST_TEST_DEFINE(cleanup_order)
{
    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;
}
 
static int unload_module(void)
{
    AST_TEST_UNREGISTER(lock_test);
    AST_TEST_UNREGISTER(cleanup_order);
    return 0;
}
 
static int load_module(void)
{
    AST_TEST_REGISTER(lock_test);
    AST_TEST_REGISTER(cleanup_order);
    return AST_MODULE_LOAD_SUCCESS;
}
 
AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "SCOPED_LOCK test module");