modify 'test show registered' cli output format
[asterisk/asterisk.git] / 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 "%-20.20s %-20.20s %-30.30s %-10.10s\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 %-20.20s %-20.20s %-30.30s\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 }