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