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