test_logger.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 2009, Digium, Inc.
 *
 * Kevin P. Fleming <[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 Test module for the logging subsystem
 *
 * \author\verbatim Kevin P. Fleming <[email protected]> \endverbatim
 *
 * \ingroup tests
 */

/*** MODULEINFO
   <depend>TEST_FRAMEWORK</depend>
   <support_level>core</support_level>
 ***/

#include "asterisk.h"

#include "asterisk/file.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/module.h"
#include "asterisk/lock.h"
#include "asterisk/app.h"
#include "asterisk/cli.h"

struct test {
   const char *name;
   unsigned int x_success;
   unsigned int x_failure;
   unsigned int u_success;
   unsigned int u_failure;
};

static void output_tests(struct test *tests, size_t num_tests, int fd)
{
   unsigned int x;

   for (x = 0; x < num_tests; x++) {
      ast_cli(fd, "Test %u: %s\n", x + 1, tests[x].name);
      ast_cli(fd, "\tExpected Successes: %u\n", tests[x].x_success);
      ast_cli(fd, "\tExpected Failures: %u\n", tests[x].x_failure);
      ast_cli(fd, "\tUnexpected Successes: %u\n", tests[x].u_success);
      ast_cli(fd, "\tUnexpected Failures: %u\n", tests[x].u_failure);
      ast_cli(fd, "Test %u Result: %s\n", x + 1, (tests[x].u_success + tests[x].u_failure) ? "FAIL" : "PASS");
   }
}

static char *handle_cli_dynamic_level_test(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
{
   unsigned int level;
   unsigned int x;
   unsigned int test;
   struct test tests[] = {
      { .name = "Simple register/message/unregister",
      },
      { .name = "Register multiple levels",
      },
   };

   switch (cmd) {
   case CLI_INIT:
      e->command = "logger test dynamic";
      e->usage = ""
         "Usage: logger test dynamic\n"
         "";
      return NULL;
   case CLI_GENERATE:
      return NULL;
   }

   for (test = 0; test < ARRAY_LEN(tests); test++) {
      ast_cli(a->fd, "Test %u: %s.\n", test + 1, tests[test].name);
      switch (test) {
      case 0:
         if ((level = ast_logger_register_level("test")) != -1) {
            ast_cli(a->fd, "Test: got level %u\n", level);
            ast_log_dynamic_level(level, "Logger Dynamic Test: Test 1\n");
            ast_logger_unregister_level("test");
            tests[test].x_success++;
         } else {
            ast_cli(a->fd, "Test: Failed, could not register level 'test'.\n");
            tests[test].u_failure++;
         }
         break;
      case 1:
      {
         char level_name[18][8];

         for (x = 0; x < ARRAY_LEN(level_name); x++) {
            sprintf(level_name[x], "level%02u", x);
            if ((level = ast_logger_register_level(level_name[x])) == -1) {
               if (x < 16) {
                  tests[test].u_failure++;
               } else {
                  tests[test].x_failure++;
               }
               level_name[x][0] = '\0';
            } else {
               ast_cli(a->fd, "Test: registered '%s', got level %u\n", level_name[x], level);
               if (x < 16) {
                  tests[test].x_success++;
               } else {
                  tests[test].u_success++;
               }
            }
         }

         for (x = 0; x < ARRAY_LEN(level_name); x++) {
            if (!ast_strlen_zero(level_name[x])) {
               ast_logger_unregister_level(level_name[x]);
            }
         }
      }
      }
   }

   output_tests(tests, ARRAY_LEN(tests), a->fd);

   return CLI_SUCCESS;
}

static char *handle_cli_performance_test(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
{
   unsigned int level;
   unsigned int test;
   struct test tests[] = {
      { .name = "Log 10,000 messages",
      },
   };

   switch (cmd) {
   case CLI_INIT:
      e->command = "logger test performance";
      e->usage = ""
         "Usage: logger test performance\n"
         "";
      return NULL;
   case CLI_GENERATE:
      return NULL;
   }

   for (test = 0; test < ARRAY_LEN(tests); test++) {
      ast_cli(a->fd, "Test %u: %s.\n", test + 1, tests[test].name);
      switch (test) {
      case 0:
         if ((level = ast_logger_register_level("perftest")) != -1) {
            unsigned int x;
            struct timeval start, end;
            int elapsed;

            ast_cli(a->fd, "Test: got level %u\n", level);
            start = ast_tvnow();
            for (x = 0; x < 10000; x++) {
               ast_log_dynamic_level(level, "Performance test log message\n");
            }
            end = ast_tvnow();
            elapsed = ast_tvdiff_ms(end, start);
            ast_cli(a->fd, "Test: 10,000 messages in %f seconds.\n", (float) elapsed / 1000);
            ast_logger_unregister_level("perftest");
            tests[test].x_success++;
         } else {
            ast_cli(a->fd, "Test: Failed, could not register level 'perftest'.\n");
            tests[test].u_failure++;
         }
         break;
      }
   }

   output_tests(tests, ARRAY_LEN(tests), a->fd);

   return CLI_SUCCESS;
}

static char *handle_cli_queue_test(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
{
   int level;
   int current_queue_limit;
   unsigned int x;
   struct timeval start, end;
   int elapsed;
   char tmppath[] = "/tmp/asterisk_logger_queue.XXXXXX";
   int fd;

   switch (cmd) {
   case CLI_INIT:
      e->command = "logger test queue";
      e->usage = ""
         "Usage: logger test queue\n"
         "";
      return NULL;
   case CLI_GENERATE:
      return NULL;
   }

   fd = mkstemp(tmppath);
   if (fd < 0) {
      ast_cli(a->fd, "Test: Failed, could not create temporary log file '%s'.\n", tmppath);
      return CLI_SUCCESS;
   }

   level = ast_logger_register_level("queuetest");
   if (level < 0) {
      ast_cli(a->fd, "Test: Failed, could not register level 'queuetest'.\n");
      return CLI_SUCCESS;
   }
   ast_cli(a->fd, "Test: got level %d for 'queuetest'.\n", level);

   if (ast_logger_create_channel(tmppath, "queuetest") != AST_LOGGER_SUCCESS) {
      ast_cli(a->fd, "Test: Unable to create logger channel '%s'\n", tmppath);
      goto error;
   }

   current_queue_limit = ast_logger_get_queue_limit();
   ast_cli(a->fd, "Test: Current queue limit: %d.  Setting to 100 for test.\n", current_queue_limit);
   ast_logger_set_queue_limit(100);

   ast_cli(a->fd, "Test: You should see SOME 'exceeded' and 'resumed' messages after the test "
      "is completed.  How many is dependent on system resources.\n");

   start = ast_tvnow();
   for (x = 0; x < 10000; x++) {
      ast_log_dynamic_level(level, "Performance test log message %2d\n", x);
   }
   end = ast_tvnow();
   elapsed = ast_tvdiff_ms(end, start);
   ast_cli(a->fd, "Test: 10,000 messages in %f seconds.\n", (float) elapsed / 1000);
   ast_cli(a->fd, "Test: Completed.  Resetting queue limit to %d.\n", current_queue_limit);
   ast_logger_set_queue_limit(current_queue_limit);

error:

   ast_logger_remove_channel(tmppath);
   ast_logger_unregister_level("queuetest");
   close(fd);
   unlink(tmppath);

   return CLI_SUCCESS;
}

static struct ast_cli_entry cli_logger[] = {
   AST_CLI_DEFINE(handle_cli_dynamic_level_test, "Test the dynamic logger level implementation"),
   AST_CLI_DEFINE(handle_cli_performance_test, "Test the logger performance"),
   AST_CLI_DEFINE(handle_cli_queue_test, "Test the logger queue"),
};

static int unload_module(void)
{
   ast_cli_unregister_multiple(cli_logger, ARRAY_LEN(cli_logger));
   return 0;
}

static int load_module(void)
{
   ast_cli_register_multiple(cli_logger, ARRAY_LEN(cli_logger));
   return AST_MODULE_LOAD_SUCCESS;
}

AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Logger Test Module");