Tab completion for test categories and names for "test show registered" and "test...
[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         return ret;
583 }
584
585 static char *complete_test_name(const char *line, const char *word, int pos, int state, const char *category)
586 {
587         int which = 0;
588         int wordlen = strlen(word);
589         char *ret = NULL;
590         struct ast_test *test;
591
592         AST_LIST_LOCK(&tests);
593         AST_LIST_TRAVERSE(&tests, test, entry) {
594                 if (!test_cat_cmp(category, test->info.category) && (!strncasecmp(word, test->info.name, wordlen) && ++which > state)) {
595                         ret = ast_strdup(test->info.name);
596                         break;
597                 }
598         }
599         return ret;
600 }
601
602 /* CLI commands */
603 static char *test_cli_show_registered(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
604 {
605 #define FORMAT "%-25.25s %-30.30s %-40.40s %-13.13s\n"
606         static const char * const option1[] = { "all", "category", NULL };
607         static const char * const option2[] = { "name", NULL };
608         struct ast_test *test = NULL;
609         int count = 0;
610         switch (cmd) {
611         case CLI_INIT:
612                 e->command = "test show registered";
613
614                 e->usage =
615                         "Usage: 'test show registered' can be used in three ways.\n"
616                         "       1. 'test show registered all' shows all registered tests\n"
617                         "       2. 'test show registered category [test category]' shows all tests in the given\n"
618                         "          category.\n"
619                         "       3. 'test show registered category [test category] name [test name]' shows all\n"
620                         "           tests in a given category matching a given name\n";
621                 return NULL;
622         case CLI_GENERATE:
623                 if (a->pos == 3) {
624                         return ast_cli_complete(a->word, option1, a->n);
625                 }
626                 if (a->pos == 4) {
627                         return complete_test_category(a->line, a->word, a->pos, a->n);
628                 }
629                 if (a->pos == 5) {
630                         return ast_cli_complete(a->word, option2, a->n);
631                 }
632                 if (a->pos == 6) {
633                         return complete_test_name(a->line, a->word, a->pos, a->n, a->argv[3]);
634                 }
635                 return NULL;
636         case CLI_HANDLER:
637                 if ((a->argc < 4) || (a->argc == 6) || (a->argc > 7) ||
638                         ((a->argc == 4) && strcmp(a->argv[3], "all")) ||
639                         ((a->argc == 7) && strcmp(a->argv[5], "name"))) {
640                         return CLI_SHOWUSAGE;
641                 }
642                 ast_cli(a->fd, FORMAT, "Category", "Name", "Summary", "Test Result");
643                 ast_cli(a->fd, FORMAT, "--------", "----", "-------", "-----------");
644                 AST_LIST_LOCK(&tests);
645                 AST_LIST_TRAVERSE(&tests, test, entry) {
646                         if ((a->argc == 4) ||
647                                  ((a->argc == 5) && !test_cat_cmp(test->info.category, a->argv[4])) ||
648                                  ((a->argc == 7) && !strcmp(test->info.category, a->argv[4]) && !strcmp(test->info.name, a->argv[6]))) {
649
650                                 ast_cli(a->fd, FORMAT, test->info.category, test->info.name,
651                                                 test->info.summary, test_result2str[test->state]);
652                                 count++;
653                         }
654                 }
655                 AST_LIST_UNLOCK(&tests);
656                 ast_cli(a->fd, FORMAT, "--------", "----", "-------", "-----------");
657                 ast_cli(a->fd, "\n%d Registered Tests Matched\n", count);
658         default:
659                 return NULL;
660         }
661
662         return CLI_SUCCESS;
663 }
664
665 static char *test_cli_execute_registered(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
666 {
667         static const char * const option1[] = { "all", "category", NULL };
668         static const char * const option2[] = { "name", NULL };
669
670         switch (cmd) {
671         case CLI_INIT:
672                 e->command = "test execute";
673                 e->usage =
674                         "Usage: test execute can be used in three ways.\n"
675                         "       1. 'test execute all' runs all registered tests\n"
676                         "       2. 'test execute category [test category]' runs all tests in the given\n"
677                         "          category.\n"
678                         "       3. 'test execute category [test category] name [test name]' runs all\n"
679                         "           tests in a given category matching a given name\n";
680                 return NULL;
681         case CLI_GENERATE:
682                 if (a->pos == 2) {
683                         return ast_cli_complete(a->word, option1, a->n);
684                 }
685                 if (a->pos == 3) {
686                         return complete_test_category(a->line, a->word, a->pos, a->n);
687                 }
688                 if (a->pos == 4) {
689                         return ast_cli_complete(a->word, option2, a->n);
690                 }
691                 if (a->pos == 5) {
692                         return complete_test_name(a->line, a->word, a->pos, a->n, a->argv[3]);
693                 }
694                 return NULL;
695         case CLI_HANDLER:
696
697                 if (a->argc < 3|| a->argc > 6) {
698                         return CLI_SHOWUSAGE;
699                 }
700
701                 if ((a->argc == 3) && !strcmp(a->argv[2], "all")) { /* run all registered tests */
702                         ast_cli(a->fd, "Running all available tests...\n\n");
703                         test_execute_multiple(NULL, NULL, a);
704                 } else if (a->argc == 4) { /* run only tests within a category */
705                         ast_cli(a->fd, "Running all available tests matching category %s\n\n", a->argv[3]);
706                         test_execute_multiple(NULL, a->argv[3], a);
707                 } else if (a->argc == 6) { /* run only a single test matching the category and name */
708                         ast_cli(a->fd, "Running all available tests matching category %s and name %s\n\n", a->argv[5], a->argv[3]);
709                         test_execute_multiple(a->argv[5], a->argv[3], a);
710                 } else {
711                         return CLI_SHOWUSAGE;
712                 }
713
714                 AST_LIST_LOCK(&tests);
715                 if (!(last_results.last_passed + last_results.last_failed)) {
716                         ast_cli(a->fd, "--- No Tests Found! ---\n");
717                 }
718                 ast_cli(a->fd, "\n%d Test(s) Executed  %d Passed  %d Failed\n",
719                         (last_results.last_passed + last_results.last_failed),
720                         last_results.last_passed,
721                         last_results.last_failed);
722                 AST_LIST_UNLOCK(&tests);
723         default:
724                 return NULL;
725         }
726
727         return CLI_SUCCESS;
728 }
729
730 static char *test_cli_show_results(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
731 {
732 #define FORMAT_RES_ALL "%s%s %-30.30s %-25.25s\n"
733         static const char * const option1[] = { "all", "failed", "passed", NULL };
734         char result_buf[32] = { 0 };
735         struct ast_test *test = NULL;
736         int failed = 0;
737         int passed = 0;
738         int mode;  /* 0 for show all, 1 for show fail, 2 for show passed */
739
740         switch (cmd) {
741         case CLI_INIT:
742                 e->command = "test show results";
743                 e->usage =
744                         "Usage: test show results can be used in three ways\n"
745                         "       1. 'test show results all' Displays results for all executed tests.\n"
746                         "       2. 'test show results passed' Displays results for all passed tests.\n"
747                         "       3. 'test show results failed' Displays results for all failed tests.\n";
748                 return NULL;
749         case CLI_GENERATE:
750                 if (a->pos == 3) {
751                         return ast_cli_complete(a->word, option1, a->n);
752                 }
753                 return NULL;
754         case CLI_HANDLER:
755
756                 /* verify input */
757                 if (a->argc != 4) {
758                         return CLI_SHOWUSAGE;
759                 } else if (!strcmp(a->argv[3], "passed")) {
760                         mode = 2;
761                 } else if (!strcmp(a->argv[3], "failed")) {
762                         mode = 1;
763                 } else if (!strcmp(a->argv[3], "all")) {
764                         mode = 0;
765                 } else {
766                         return CLI_SHOWUSAGE;
767                 }
768
769                 ast_cli(a->fd, FORMAT_RES_ALL, "Result", "", "Name", "Category");
770                 AST_LIST_LOCK(&tests);
771                 AST_LIST_TRAVERSE(&tests, test, entry) {
772                         if (test->state == AST_TEST_NOT_RUN) {
773                                 continue;
774                         }
775                         test->state == AST_TEST_FAIL ? failed++ : passed++;
776                         if (!mode || ((mode == 1) && (test->state == AST_TEST_FAIL)) || ((mode == 2) && (test->state == AST_TEST_PASS))) {
777                                 /* give our results pretty colors */
778                                 term_color(result_buf, test_result2str[test->state],
779                                         (test->state == AST_TEST_FAIL) ? COLOR_RED : COLOR_GREEN,
780                                         0, sizeof(result_buf));
781
782                                 ast_cli(a->fd, FORMAT_RES_ALL,
783                                         result_buf,
784                                         "  ",
785                                         test->info.name,
786                                         test->info.category);
787                         }
788                 }
789                 AST_LIST_UNLOCK(&tests);
790
791                 ast_cli(a->fd, "%d Test(s) Executed  %d Passed  %d Failed\n", (failed + passed), passed, failed);
792         default:
793                 return NULL;
794         }
795         return CLI_SUCCESS;
796 }
797
798 static char *test_cli_generate_results(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
799 {
800         static const char * const option[] = { "xml", "txt", NULL };
801         const char *file = NULL;
802         const char *type = "";
803         int isxml = 0;
804         int res = 0;
805         struct ast_str *buf = NULL;
806         struct timeval time = ast_tvnow();
807
808         switch (cmd) {
809         case CLI_INIT:
810                 e->command = "test generate results";
811                 e->usage =
812                         "Usage: 'test generate results'\n"
813                         "       Generates test results in either xml or txt format. An optional \n"
814                         "       file path may be provided to specify the location of the xml or\n"
815                         "       txt file\n"
816                         "       \nExample usage:\n"
817                         "       'test generate results xml' this writes to a default file\n"
818                         "       'test generate results xml /path/to/file.xml' writes to specified file\n";
819                 return NULL;
820         case CLI_GENERATE:
821                 if (a->pos == 3) {
822                         return ast_cli_complete(a->word, option, a->n);
823                 }
824                 return NULL;
825         case CLI_HANDLER:
826
827                 /* verify input */
828                 if (a->argc < 4 || a->argc > 5) {
829                         return CLI_SHOWUSAGE;
830                 } else if (!strcmp(a->argv[3], "xml")) {
831                         type = "xml";
832                         isxml = 1;
833                 } else if (!strcmp(a->argv[3], "txt")) {
834                         type = "txt";
835                 } else {
836                         return CLI_SHOWUSAGE;
837                 }
838
839                 if (a->argc == 5) {
840                         file = a->argv[4];
841                 } else {
842                         if (!(buf = ast_str_create(256))) {
843                                 return NULL;
844                         }
845                         ast_str_set(&buf, 0, "%s/asterisk_test_results-%ld.%s", ast_config_AST_LOG_DIR, time.tv_sec, type);
846
847                         file = ast_str_buffer(buf);
848                 }
849
850                 if (isxml) {
851                         res = test_generate_results(NULL, NULL, file, NULL);
852                 } else {
853                         res = test_generate_results(NULL, NULL, NULL, file);
854                 }
855
856                 if (!res) {
857                         ast_cli(a->fd, "Results Generated Successfully: %s\n", S_OR(file, ""));
858                 } else {
859                         ast_cli(a->fd, "Results Could Not Be Generated: %s\n", S_OR(file, ""));
860                 }
861
862                 ast_free(buf);
863         default:
864                 return NULL;
865         }
866
867         return CLI_SUCCESS;
868 }
869
870 static struct ast_cli_entry test_cli[] = {
871         AST_CLI_DEFINE(test_cli_show_registered,           "show registered tests"),
872         AST_CLI_DEFINE(test_cli_execute_registered,        "execute registered tests"),
873         AST_CLI_DEFINE(test_cli_show_results,              "show last test results"),
874         AST_CLI_DEFINE(test_cli_generate_results,          "generate test results to file"),
875 };
876 #endif /* TEST_FRAMEWORK */
877
878 int ast_test_init()
879 {
880 #ifdef TEST_FRAMEWORK
881         /* Register cli commands */
882         ast_cli_register_multiple(test_cli, ARRAY_LEN(test_cli));
883 #endif
884
885         return 0;
886 }