main/test.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 2009, Digium, Inc.
   5  *
   6  * David Vossel <dvossel@digium.com>
   7  *
   8  * See http://www.asterisk.org for more information about
   9  * the Asterisk project. Please do not directly contact
  10  * any of the maintainers of this project for assistance;
  11  * the project provides a web site, mailing lists and IRC
  12  * channels for your use.
  13  *
  14  * This program is free software, distributed under the terms of
  15  * the GNU General Public License Version 2. See the LICENSE file
  16  * at the top of the source tree.
  17  */
  18
  19 /*! \file
  20  *
  21  * \brief Unit Test Framework
  22  *
  23  * \author David Vossel <dvossel@digium.com>
  24  */
  25
  26 #include "asterisk.h"
  27
  28 ASTERISK_FILE_VERSION(__FILE__, "$Revision$");
  29
  30 #include "asterisk/_private.h"
  31
  32 #ifdef TEST_FRAMEWORK
  33 #include "asterisk/test.h"
  34 #include "asterisk/logger.h"
  35 #include "asterisk/linkedlists.h"
  36 #include "asterisk/utils.h"
  37 #include "asterisk/cli.h"
  38 #include "asterisk/term.h"
  39 #include "asterisk/version.h"
  40 #include "asterisk/paths.h"
  41 #include "asterisk/time.h"
  42
  43 /*! This array corresponds to the values defined in the ast_test_state enum */
  44 static const char * const test_result2str[] = {
  45         [AST_TEST_NOT_RUN] = "NOT RUN",
  46         [AST_TEST_PASS] = "PASS",
  47         [AST_TEST_FAIL] = "FAIL",
  48 };
  49
  50 /*! holds all the information pertaining to a single defined test */
  51 struct ast_test {
  52         struct ast_test_info info;        /*!< holds test callback information */
  53         struct ast_test_args args;        /*!< function callback arguments */
  54         enum ast_test_result_state state; /*!< current test state */
  55         unsigned int time;                /*!< time in ms test took */
  56         ast_test_cb_t *cb;                /*!< test callback function */
  57         AST_LIST_ENTRY(ast_test) entry;
  58 };
  59
  60 /*! global structure containing both total and last test execution results */
  61 static struct ast_test_execute_results {
  62         unsigned int total_tests;  /*!< total number of tests, regardless if they have been executed or not */
  63         unsigned int total_passed; /*!< total number of executed tests passed */
  64         unsigned int total_failed; /*!< total number of executed tests failed */
  65         unsigned int total_time;   /*!< total time of all executed tests */
  66         unsigned int last_passed;  /*!< number of passed tests during last execution */
  67         unsigned int last_failed;  /*!< number of failed tests during last execution */
  68         unsigned int last_time;    /*!< total time of the last test execution */
  69 } last_results;
  70
  71 enum test_mode {
  72         TEST_ALL = 0,
  73         TEST_CATEGORY = 1,
  74         TEST_NAME_CATEGORY = 2,
  75 };
  76
  77 /*! List of registered test definitions */
  78 static AST_LIST_HEAD_STATIC(tests, ast_test);
  79
  80 /*! static function prototypes */
  81 static struct ast_test *test_alloc(ast_test_cb_t *cb);
  82 static struct ast_test *test_free(struct ast_test *test);
  83 static int test_insert(struct ast_test *test);
  84 static struct ast_test *test_remove(ast_test_cb_t *cb);
  85 static int test_cat_cmp(const char *cat1, const char *cat2);
  86
  87 int ast_test_status_update(struct ast_test_status_args *args, const char *fmt, ...)
  88 {
  89         struct ast_str *buf = NULL;
  90         va_list ap;
  91
  92         /* it is not an error if no cli args exist. */
  93         if (!args->cli) {
  94                 return 0;
  95         }
  96
  97         if (!(buf = ast_str_create(128))) {
  98                 return -1;
  99         }
 100
 101         va_start(ap, fmt);
 102         ast_str_set_va(&buf, 0, fmt, ap);
 103         va_end(ap);
 104
 105         ast_cli(args->cli->fd, "%s", ast_str_buffer(buf));
 106
 107         ast_free(buf);
 108         return 0;
 109 }
 110
 111 int ast_test_register(ast_test_cb_t *cb)
 112 {
 113         struct ast_test *test;
 114
 115         /* verify data.*/
 116         if (!cb) {
 117                 ast_log(LOG_WARNING, "Attempted to register test without all required information\n");
 118                 return -1;
 119         }
 120
 121         /* create test object */
 122         if (!(test = test_alloc(cb))) {
 123                 return -1;
 124         }
 125
 126         /* insert into list */
 127         if (test_insert(test)) {
 128                 test_free(test);
 129                 return -1;
 130         }
 131
 132         return 0;
 133 }
 134
 135 int ast_test_unregister(ast_test_cb_t *cb)
 136 {
 137         struct ast_test *test;
 138
 139         /* find test and remove */
 140         if (!(test = test_remove(cb))) {
 141                 return -1; /* not found */
 142         }
 143
 144         /* free test object */
 145         test_free(test);
 146
 147         return 0;
 148 }
 149
 150 /*!
 151  * \internal
 152  * \brief executes a single test, storing the results in the test->result structure.
 153  *
 154  * \note The last_results structure which contains global statistics about test execution
 155  * must be updated when using this function. See use in test_execute_multiple().
 156  */
 157 static void test_execute(struct ast_test *test)
 158 {
 159         struct timeval begin;
 160
 161         /* clear any previous error results before starting */
 162         ast_str_reset(test->args.ast_test_error_str);
 163         /* get start time */
 164         begin = ast_tvnow();
 165         /* the callback gets the pointer to the pointer of the error buf */
 166         test->state = test->cb(&test->info, TEST_EXECUTE, &test->args);
 167         /* record the total time the test took */
 168         test->time = ast_tvdiff_ms(ast_tvnow(), begin);
 169         /* clear any status update args that may have been set */
 170         memset(&test->args.status_update, 0, sizeof(struct ast_test_status_args));
 171 }
 172
 173 static void test_xml_entry(struct ast_test *test, FILE *f)
 174 {
 175         if (!f || !test || test->state == AST_TEST_NOT_RUN) {
 176                 return;
 177         }
 178
 179         fprintf(f, "\t<testcase time=\"%d.%d\" name=\"%s%s\"%s>\n",
 180                         test->time / 1000, test->time % 1000,
 181                         test->info.category, test->info.name,
 182                         test->state == AST_TEST_PASS ? "/" : "");
 183
 184         if (test->state == AST_TEST_FAIL) {
 185                 fprintf(f, "\t\t<failure>%s</failure>\n",
 186                                 S_OR(ast_str_buffer(test->args.ast_test_error_str), "NA"));
 187                 fprintf(f, "\t</testcase>\n");
 188         }
 189
 190 }
 191
 192 static void test_txt_entry(struct ast_test *test, FILE *f)
 193 {
 194         if (!f || !test) {
 195                 return;
 196         }
 197
 198         fprintf(f, "\nName:              %s\n", test->info.name);
 199         fprintf(f,   "Category:          %s\n", test->info.category);
 200         fprintf(f,   "Summary:           %s\n", test->info.summary);
 201         fprintf(f,   "Description:       %s\n", test->info.description);
 202         fprintf(f,   "Result:            %s\n", test_result2str[test->state]);
 203         if (test->state == AST_TEST_FAIL) {
 204                 fprintf(f,   "Error Description: %s\n", S_OR(ast_str_buffer(test->args.ast_test_error_str), "NA"));
 205         }
 206         if (test->state != AST_TEST_NOT_RUN) {
 207                 fprintf(f,   "Time:              %d\n", test->time);
 208         }
 209 }
 210
 211 /*!
 212  * \internal
 213  * \brief Executes registered unit tests
 214  *
 215  * \param name of test to run (optional)
 216  * \param test category to run (optional)
 217  * \param cli args for cli test updates (optional)
 218  *
 219  * \return number of tests executed.
 220  *
 221  * \note This function has three modes of operation
 222  * -# When given a name and category, a matching individual test will execute if found.
 223  * -# When given only a category all matching tests within that category will execute.
 224  * -# If given no name or category all registered tests will execute.
 225  */
 226 static int test_execute_multiple(const char *name, const char *category, struct ast_cli_args *cli)
 227 {
 228         char result_buf[32] = { 0 };
 229         struct ast_test *test = NULL;
 230         enum test_mode mode = TEST_ALL; /* 3 modes, 0 = run all, 1 = only by category, 2 = only by name and category */
 231         int execute = 0;
 232         int res = 0;
 233
 234         if (!ast_strlen_zero(category)) {
 235                 if (!ast_strlen_zero(name)) {
 236                         mode = TEST_NAME_CATEGORY;
 237                 } else {
 238                         mode = TEST_CATEGORY;
 239                 }
 240         }
 241
 242         AST_LIST_LOCK(&tests);
 243         /* clear previous execution results */
 244         memset(&last_results, 0, sizeof(last_results));
 245         AST_LIST_TRAVERSE(&tests, test, entry) {
 246
 247                 execute = 0;
 248                 switch (mode) {
 249                 case TEST_CATEGORY:
 250                         if (!test_cat_cmp(test->info.category, category)) {
 251                                 execute = 1;
 252                         }
 253                         break;
 254                 case TEST_NAME_CATEGORY:
 255                         if (!(strcmp(test->info.category, category)) && !(strcmp(test->info.name, name))) {
 256                                 execute = 1;
 257                         }
 258                         break;
 259                 case TEST_ALL:
 260                         execute = 1;
 261                 }
 262
 263                 if (execute) {
 264                         if (cli) {
 265                                 ast_cli(cli->fd, "START  %s - %s \n", test->info.category, test->info.name);
 266                         }
 267
 268                         /* set the test status update argument. it is ok if cli is NULL */
 269                         test->args.status_update.cli = cli;
 270
 271                         /* execute the test and save results */
 272                         test_execute(test);
 273
 274                         /* update execution specific counts here */
 275                         last_results.last_time += test->time;
 276                         if (test->state == AST_TEST_PASS) {
 277                                 last_results.last_passed++;
 278                         } else {
 279                                 last_results.last_failed++;
 280                         }
 281
 282                         if (cli) {
 283                                 term_color(result_buf,
 284                                         test_result2str[test->state],
 285                                         (test->state == AST_TEST_FAIL) ? COLOR_RED : COLOR_GREEN,
 286                                         0,
 287                                         sizeof(result_buf));
 288                                 ast_cli(cli->fd, "END    %s - %s Time: %dms Result: %s %s\n",
 289                                         test->info.category,
 290                                         test->info.name,
 291                                         test->time,
 292                                         result_buf,
 293                                         ast_str_buffer(test->args.ast_test_error_str));
 294                         }
 295                 }
 296
 297                 /* update total counts as well during this iteration
 298                  * even if the current test did not execute this time */
 299                 last_results.total_time += test->time;
 300                 last_results.total_tests++;
 301                 if (test->state != AST_TEST_NOT_RUN) {
 302                         if (test->state == AST_TEST_PASS) {
 303                                 last_results.total_passed++;
 304                         } else {
 305                                 last_results.total_failed++;
 306                         }
 307                 }
 308         }
 309         res = last_results.last_passed + last_results.last_failed;
 310         AST_LIST_UNLOCK(&tests);
 311
 312         return res;
 313 }
 314
 315 /*!
 316  * \internal
 317  * \brief Generate test results.
 318  *
 319  * \param name of test result to generate (optional)
 320  * \param test category to generate (optional)
 321  * \param path to xml file to generate. (optional)
 322  * \param path to txt file to generate, (optional)
 323  *
 324  * \retval 0 success
 325  * \retval -1 failure
 326  *
 327  * \note This function has three modes of operation.
 328  * -# When given both a name and category, results will be generated for that single test.
 329  * -# When given only a category, results for every test within the category will be generated.
 330  * -# When given no name or category, results for every registered test will be generated.
 331  *
 332  * In order for the results to be generated, an xml and or txt file path must be provided.
 333  */
 334 static int test_generate_results(const char *name, const char *category, const char *xml_path, const char *txt_path)
 335 {
 336         enum test_mode mode = TEST_ALL;  /* 0 generate all, 1 generate by category only, 2 generate by name and category */
 337         FILE *f_xml = NULL, *f_txt = NULL;
 338         int res = 0;
 339         struct ast_test *test = NULL;
 340
 341         /* verify at least one output file was given */
 342         if (ast_strlen_zero(xml_path) && ast_strlen_zero(txt_path)) {
 343                 return -1;
 344         }
 345
 346         /* define what mode is to be used */
 347         if (!ast_strlen_zero(category)) {
 348                 if (!ast_strlen_zero(name)) {
 349                         mode = TEST_NAME_CATEGORY;
 350                 } else {
 351                         mode = TEST_CATEGORY;
 352                 }
 353         }
 354         /* open files for writing */
 355         if (!ast_strlen_zero(xml_path)) {
 356                 if (!(f_xml = fopen(xml_path, "w"))) {
 357                         ast_log(LOG_WARNING, "Could not open file %s for xml test results\n", xml_path);
 358                         res = -1;
 359                         goto done;
 360                 }
 361         }
 362         if (!ast_strlen_zero(txt_path)) {
 363                 if (!(f_txt = fopen(txt_path, "w"))) {
 364                         ast_log(LOG_WARNING, "Could not open file %s for text output of test results\n", txt_path);
 365                         res = -1;
 366                         goto done;
 367                 }
 368         }
 369
 370         AST_LIST_LOCK(&tests);
 371         /* xml header information */
 372         if (f_xml) {
 373                 /*
 374                  * http://confluence.atlassian.com/display/BAMBOO/JUnit+parsing+in+Bamboo
 375                  */
 376                 fprintf(f_xml, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
 377                 fprintf(f_xml, "<testsuite errors=\"0\" time=\"%d.%d\" tests=\"%d\" "
 378                                 "name=\"AsteriskUnitTests\">\n",
 379                                 last_results.total_time / 1000, last_results.total_time % 1000,
 380                                 last_results.total_tests);
 381                 fprintf(f_xml, "\t<properties>\n");
 382                 fprintf(f_xml, "\t\t<property name=\"version\" value=\"%s\"/>\n", ASTERISK_VERSION);
 383                 fprintf(f_xml, "\t</properties>\n");
 384         }
 385
 386         /* txt header information */
 387         if (f_txt) {
 388                 fprintf(f_txt, "Asterisk Version:         %s\n", ASTERISK_VERSION);
 389                 fprintf(f_txt, "Asterisk Version Number:  %d\n", ASTERISK_VERSION_NUM);
 390                 fprintf(f_txt, "Number of Tests:          %d\n", last_results.total_tests);
 391                 fprintf(f_txt, "Number of Tests Executed: %d\n", (last_results.total_passed + last_results.total_failed));
 392                 fprintf(f_txt, "Passed Tests:             %d\n", last_results.total_passed);
 393                 fprintf(f_txt, "Failed Tests:             %d\n", last_results.total_failed);
 394                 fprintf(f_txt, "Total Execution Time:     %d\n", last_results.total_time);
 395         }
 396
 397         /* export each individual test */
 398         AST_LIST_TRAVERSE(&tests, test, entry) {
 399                 switch (mode) {
 400                 case TEST_CATEGORY:
 401                         if (!test_cat_cmp(test->info.category, category)) {
 402                                 test_xml_entry(test, f_xml);
 403                                 test_txt_entry(test, f_txt);
 404                         }
 405                         break;
 406                 case TEST_NAME_CATEGORY:
 407                         if (!(strcmp(test->info.category, category)) && !(strcmp(test->info.name, name))) {
 408                                 test_xml_entry(test, f_xml);
 409                                 test_txt_entry(test, f_txt);
 410                         }
 411                         break;
 412                 case TEST_ALL:
 413                         test_xml_entry(test, f_xml);
 414                         test_txt_entry(test, f_txt);
 415                 }
 416         }
 417         AST_LIST_UNLOCK(&tests);
 418
 419 done:
 420         if (f_xml) {
 421                 fprintf(f_xml, "</testsuite>\n");
 422                 fclose(f_xml);
 423         }
 424         if (f_txt) {
 425                 fclose(f_txt);
 426         }
 427
 428         return res;
 429 }
 430
 431 /*!
 432  * \internal
 433  * \brief adds test to container sorted first by category then by name
 434  *
 435  * \return 0 on success, -1 on failure
 436  */
 437 static int test_insert(struct ast_test *test)
 438 {
 439         struct ast_test *cur = NULL;
 440         int res = 0;
 441         int i = 0;
 442         int inserted = 0;
 443
 444         /* This is a slow operation that may need to be optimized in the future
 445          * as the test framework expands.  At the moment we are doing string
 446          * comparisons on every item within the list to insert in sorted order. */
 447         AST_LIST_LOCK(&tests);
 448         AST_LIST_TRAVERSE_SAFE_BEGIN(&tests, cur, entry) {
 449                 if ((i = strcmp(test->info.category, cur->info.category)) < 0) {
 450                         AST_LIST_INSERT_BEFORE_CURRENT(test, entry);
 451                         inserted = 1;
 452                         break;
 453                 } else if (!i) {  /* same category, now insert by name within that category*/
 454                         if ((i = strcmp(test->info.name, cur->info.name)) < 0) {
 455                                 AST_LIST_INSERT_BEFORE_CURRENT(test, entry);
 456                                 inserted = 1;
 457                                 break;
 458                         } else if (!i) {
 459                                 /* Error, duplicate found */
 460                                 res = -1;
 461                                 break;
 462                         }
 463                 }
 464         }
 465         AST_LIST_TRAVERSE_SAFE_END;
 466
 467         if (!inserted && !res) {
 468                 AST_LIST_INSERT_TAIL(&tests, test, entry);
 469                 inserted = 1;
 470         }
 471
 472         AST_LIST_UNLOCK(&tests);
 473
 474         return res;
 475 }
 476
 477 /*!
 478  * \internal
 479  * \brief removes test from container
 480  *
 481  * \return ast_test removed from list on success, or NULL on failure
 482  */
 483 static struct ast_test *test_remove(ast_test_cb_t *cb)
 484 {
 485         struct ast_test *cur = NULL;
 486
 487         AST_LIST_LOCK(&tests);
 488         AST_LIST_TRAVERSE_SAFE_BEGIN(&tests, cur, entry) {
 489                 if (cur->cb == cb) {
 490                         AST_LIST_REMOVE_CURRENT(entry);
 491                         break;
 492                 }
 493         }
 494         AST_LIST_TRAVERSE_SAFE_END;
 495         AST_LIST_UNLOCK(&tests);
 496
 497         return cur;
 498 }
 499
 500 /*!
 501  * \brief compares two test categories to determine if cat1 resides in cat2
 502  * \internal
 503  *
 504  * \return 0 if true
 505  */
 506
 507 static int test_cat_cmp(const char *cat1, const char *cat2)
 508 {
 509         int len1 = 0;
 510         int len2 = 0;
 511
 512         if (!cat1 || !cat2) {
 513                 return -1;
 514         }
 515
 516         len1 = strlen(cat1);
 517         len2 = strlen(cat2);
 518
 519         if (len2 > len1) {
 520                 return -1;
 521         }
 522
 523         return strncmp(cat1, cat2, len2) ? 1 : 0;
 524 }
 525
 526 /*!
 527  * \brief frees a ast_test object and all it's data members
 528  * \internal
 529  */
 530 static struct ast_test *test_free(struct ast_test *test)
 531 {
 532         if (!test) {
 533                 return NULL;
 534         }
 535
 536         ast_free(test->args.ast_test_error_str);
 537         ast_free(test);
 538
 539         return NULL;
 540 }
 541
 542 /*!
 543  * \internal
 544  * \brief allocates an ast_test object.
 545  */
 546 static struct ast_test *test_alloc(ast_test_cb_t *cb)
 547 {
 548         struct ast_test *test;
 549
 550         if (!cb || !(test = ast_calloc(1, sizeof(*test)))) {
 551                 return NULL;
 552         }
 553
 554         test->cb = cb;
 555
 556         test->cb(&test->info, TEST_INIT, &test->args);
 557
 558         if (ast_strlen_zero(test->info.name) ||
 559                 ast_strlen_zero(test->info.category) ||
 560                 ast_strlen_zero(test->info.summary) ||
 561                 ast_strlen_zero(test->info.description) ||
 562                 !(test->args.ast_test_error_str = ast_str_create(128))) {
 563
 564                 return test_free(test);
 565         }
 566
 567         return test;
 568 }
 569
 570 /* CLI commands */
 571 static char *test_cli_show_registered(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 572 {
 573 #define FORMAT "%-30.30s %-25.25s %-40.40s %-13.13s\n"
 574         static const char * const option1[] = { "all", "category", NULL };
 575         static const char * const option2[] = { "name", NULL };
 576         struct ast_test *test = NULL;
 577         int count = 0;
 578         switch (cmd) {
 579         case CLI_INIT:
 580                 e->command = "test show registered";
 581
 582                 e->usage =
 583                         "Usage: 'test show registered' can be used in three ways.\n"
 584                         "       1. 'test show registered all' shows all registered tests\n"
 585                         "       2. 'test show registered category [test category]' shows all tests in the given\n"
 586                         "          category.\n"
 587                         "       3. 'test show registered category [test category] name [test name]' shows all\n"
 588                         "           tests in a given category matching a given name\n";
 589                 return NULL;
 590         case CLI_GENERATE:
 591                 if (a->pos == 3) {
 592                         return ast_cli_complete(a->word, option1, a->n);
 593                 }
 594                 if (a->pos == 5) {
 595                         return ast_cli_complete(a->word, option2, a->n);
 596                 }
 597                 return NULL;
 598         case CLI_HANDLER:
 599                 if ((a->argc < 4) || (a->argc == 6) || (a->argc > 7) ||
 600                         ((a->argc == 4) && strcmp(a->argv[3], "all")) ||
 601                         ((a->argc == 7) && strcmp(a->argv[5], "name"))) {
 602                         return CLI_SHOWUSAGE;
 603                 }
 604                 ast_cli(a->fd, FORMAT, "Name", "Category", "Summary", "Test Result");
 605                 AST_LIST_LOCK(&tests);
 606                 AST_LIST_TRAVERSE(&tests, test, entry) {
 607                         if ((a->argc == 4) ||
 608                                  ((a->argc == 5) && !test_cat_cmp(test->info.category, a->argv[4])) ||
 609                                  ((a->argc == 7) && !strcmp(test->info.category, a->argv[4]) && !strcmp(test->info.name, a->argv[6]))) {
 610
 611                                 ast_cli(a->fd, FORMAT, test->info.name, test->info.category, test->info.summary, test_result2str[test->state]);
 612                                 count ++;
 613                         }
 614                 }
 615                 AST_LIST_UNLOCK(&tests);
 616                 ast_cli(a->fd, "%d Registered Tests Matched\n", count);
 617         default:
 618                 return NULL;
 619         }
 620
 621         return CLI_SUCCESS;
 622 }
 623
 624 static char *test_cli_execute_registered(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 625 {
 626         static const char * const option1[] = { "all", "category", NULL };
 627         static const char * const option2[] = { "name", NULL };
 628         switch (cmd) {
 629         case CLI_INIT:
 630                 e->command = "test execute";
 631                 e->usage =
 632                         "Usage: test execute can be used in three ways.\n"
 633                         "       1. 'test execute all' runs all registered tests\n"
 634                         "       2. 'test execute category [test category]' runs all tests in the given\n"
 635                         "          category.\n"
 636                         "       3. 'test execute category [test category] name [test name]' runs all\n"
 637                         "           tests in a given category matching a given name\n";
 638                 return NULL;
 639         case CLI_GENERATE:
 640                 if (a->pos == 2) {
 641                         return ast_cli_complete(a->word, option1, a->n);
 642                 }
 643                 if (a->pos == 4) {
 644                         return ast_cli_complete(a->word, option2, a->n);
 645                 }
 646                 return NULL;
 647         case CLI_HANDLER:
 648
 649                 if (a->argc < 3|| a->argc > 6) {
 650                         return CLI_SHOWUSAGE;
 651                 }
 652
 653                 if ((a->argc == 3) && !strcmp(a->argv[2], "all")) { /* run all registered tests */
 654                         ast_cli(a->fd, "Running all available tests...\n\n");
 655                         test_execute_multiple(NULL, NULL, a);
 656                 } else if (a->argc == 4) { /* run only tests within a category */
 657                         ast_cli(a->fd, "Running all available tests matching category %s\n\n", a->argv[3]);
 658                         test_execute_multiple(NULL, a->argv[3], a);
 659                 } else if (a->argc == 6) { /* run only a single test matching the category and name */
 660                         ast_cli(a->fd, "Running all available tests matching category %s and name %s\n\n", a->argv[5], a->argv[3]);
 661                         test_execute_multiple(a->argv[5], a->argv[3], a);
 662                 } else {
 663                         return CLI_SHOWUSAGE;
 664                 }
 665
 666                 AST_LIST_LOCK(&tests);
 667                 if (!(last_results.last_passed + last_results.last_failed)) {
 668                         ast_cli(a->fd, "--- No Tests Found! ---\n");
 669                 }
 670                 ast_cli(a->fd, "\n%d Test(s) Executed  %d Passed  %d Failed\n",
 671                         (last_results.last_passed + last_results.last_failed),
 672                         last_results.last_passed,
 673                         last_results.last_failed);
 674                 AST_LIST_UNLOCK(&tests);
 675         default:
 676                 return NULL;
 677         }
 678
 679         return CLI_SUCCESS;
 680 }
 681
 682 static char *test_cli_show_results(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 683 {
 684 #define FORMAT_RES_ALL "%s%s %-30.30s %-25.25s %-40.40s\n"
 685         static const char * const option1[] = { "all", "failed", "passed", NULL };
 686         char result_buf[32] = { 0 };
 687         struct ast_test *test = NULL;
 688         int failed = 0;
 689         int passed = 0;
 690         int mode;  /* 0 for show all, 1 for show fail, 2 for show passed */
 691
 692         switch (cmd) {
 693         case CLI_INIT:
 694                 e->command = "test show results";
 695                 e->usage =
 696                         "Usage: test show results can be used in three ways\n"
 697                         "       1. 'test show results all' Displays results for all executed tests.\n"
 698                         "       2. 'test show results passed' Displays results for all passed tests.\n"
 699                         "       3. 'test show results failed' Displays results for all failed tests.\n";
 700                 return NULL;
 701         case CLI_GENERATE:
 702                 if (a->pos == 3) {
 703                         return ast_cli_complete(a->word, option1, a->n);
 704                 }
 705                 return NULL;
 706         case CLI_HANDLER:
 707
 708                 /* verify input */
 709                 if (a->argc != 4) {
 710                         return CLI_SHOWUSAGE;
 711                 } else if (!strcmp(a->argv[3], "passed")) {
 712                         mode = 2;
 713                 } else if (!strcmp(a->argv[3], "failed")) {
 714                         mode = 1;
 715                 } else if (!strcmp(a->argv[3], "all")) {
 716                         mode = 0;
 717                 } else {
 718                         return CLI_SHOWUSAGE;
 719                 }
 720
 721                 ast_cli(a->fd, FORMAT_RES_ALL, "Result", "", "Name", "Category", "Error Description");
 722                 AST_LIST_LOCK(&tests);
 723                 AST_LIST_TRAVERSE(&tests, test, entry) {
 724                         if (test->state == AST_TEST_NOT_RUN) {
 725                                 continue;
 726                         }
 727                         test->state == AST_TEST_FAIL ? failed++ : passed++;
 728                         if (!mode || ((mode == 1) && (test->state == AST_TEST_FAIL)) || ((mode == 2) && (test->state == AST_TEST_PASS))) {
 729                                 /* give our results pretty colors */
 730                                 term_color(result_buf, test_result2str[test->state],
 731                                         (test->state == AST_TEST_FAIL) ? COLOR_RED : COLOR_GREEN,
 732                                         0, sizeof(result_buf));
 733
 734                                 ast_cli(a->fd, FORMAT_RES_ALL,
 735                                         result_buf,
 736                                         "  ",
 737                                         test->info.name,
 738                                         test->info.category,
 739                                         (test->state == AST_TEST_FAIL) ? S_OR(ast_str_buffer(test->args.ast_test_error_str), "Not Avaliable") : "");
 740                         }
 741                 }
 742                 AST_LIST_UNLOCK(&tests);
 743
 744                 ast_cli(a->fd, "%d Test(s) Executed  %d Passed  %d Failed\n", (failed + passed), passed, failed);
 745         default:
 746                 return NULL;
 747         }
 748         return CLI_SUCCESS;
 749 }
 750
 751 static char *test_cli_generate_results(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 752 {
 753         static const char * const option[] = { "xml", "txt", NULL };
 754         const char *file = NULL;
 755         const char *type = "";
 756         int isxml = 0;
 757         int res = 0;
 758         struct ast_str *buf = NULL;
 759         struct timeval time = ast_tvnow();
 760
 761         switch (cmd) {
 762         case CLI_INIT:
 763                 e->command = "test generate results";
 764                 e->usage =
 765                         "Usage: 'test generate results'\n"
 766                         "       Generates test results in either xml or txt format. An optional \n"
 767                         "       file path may be provided to specify the location of the xml or\n"
 768                         "       txt file\n"
 769                         "       \nExample usage:\n"
 770                         "       'test generate results xml' this writes to a default file\n"
 771                         "       'test generate results xml /path/to/file.xml' writes to specified file\n";
 772                 return NULL;
 773         case CLI_GENERATE:
 774                 if (a->pos == 3) {
 775                         return ast_cli_complete(a->word, option, a->n);
 776                 }
 777                 return NULL;
 778         case CLI_HANDLER:
 779
 780                 /* verify input */
 781                 if (a->argc < 4 || a->argc > 5) {
 782                         return CLI_SHOWUSAGE;
 783                 } else if (!strcmp(a->argv[3], "xml")) {
 784                         type = "xml";
 785                         isxml = 1;
 786                 } else if (!strcmp(a->argv[3], "txt")) {
 787                         type = "txt";
 788                 } else {
 789                         return CLI_SHOWUSAGE;
 790                 }
 791
 792                 if (a->argc == 5) {
 793                         file = a->argv[4];
 794                 } else {
 795                         if (!(buf = ast_str_create(256))) {
 796                                 return NULL;
 797                         }
 798                         ast_str_set(&buf, 0, "%s/asterisk_test_results-%ld.%s", ast_config_AST_LOG_DIR, time.tv_sec, type);
 799
 800                         file = ast_str_buffer(buf);
 801                 }
 802
 803                 if (isxml) {
 804                         res = test_generate_results(NULL, NULL, file, NULL);
 805                 } else {
 806                         res = test_generate_results(NULL, NULL, NULL, file);
 807                 }
 808
 809                 if (!res) {
 810                         ast_cli(a->fd, "Results Generated Successfully: %s\n", S_OR(file, ""));
 811                 } else {
 812                         ast_cli(a->fd, "Results Could Not Be Generated: %s\n", S_OR(file, ""));
 813                 }
 814
 815                 ast_free(buf);
 816         default:
 817                 return NULL;
 818         }
 819
 820         return CLI_SUCCESS;
 821 }
 822
 823 static struct ast_cli_entry test_cli[] = {
 824         AST_CLI_DEFINE(test_cli_show_registered,           "show registered tests"),
 825         AST_CLI_DEFINE(test_cli_execute_registered,        "execute registered tests"),
 826         AST_CLI_DEFINE(test_cli_show_results,              "show last test results"),
 827         AST_CLI_DEFINE(test_cli_generate_results,          "generate test results to file"),
 828 };
 829 #endif /* TEST_FRAMEWORK */
 830
 831 int ast_test_init()
 832 {
 833 #ifdef TEST_FRAMEWORK
 834         /* Register cli commands */
 835         ast_cli_register_multiple(test_cli, ARRAY_LEN(test_cli));
 836 #endif
 837
 838         return 0;
 839 }