test_scoped_lock.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 2012, Digium, Inc.
 *
 * Mark Michelson <[email protected]>
 *
 * 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 <[email protected]>
 *
 */

/*** 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");