Modify test results XML format to match the JUnit 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 corrisponds 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, reguardless 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                 fprintf(f_xml, "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n");
374                 fprintf(f_xml, "<testsuite errors=\"0\" time=\"%d.%d\" tests=\"%d\" "
375                                 "name=\"AsteriskUnitTests\">\n",
376                                 last_results.total_time / 1000, last_results.total_time % 1000,
377                                 last_results.total_tests);
378                 fprintf(f_xml, "\t<properties>\n");
379                 fprintf(f_xml, "\t\t<property name=\"version\" value=\"%s\"/>\n", ASTERISK_VERSION);
380                 fprintf(f_xml, "\t</properties>\n");
381         }
382
383         /* txt header information */
384         if (f_txt) {
385                 fprintf(f_txt, "Asterisk Version:         %s\n", ASTERISK_VERSION);
386                 fprintf(f_txt, "Asterisk Version Number:  %d\n", ASTERISK_VERSION_NUM);
387                 fprintf(f_txt, "Number of Tests:          %d\n", last_results.total_tests);
388                 fprintf(f_txt, "Number of Tests Executed: %d\n", (last_results.total_passed + last_results.total_failed));
389                 fprintf(f_txt, "Passed Tests:             %d\n", last_results.total_passed);
390                 fprintf(f_txt, "Failed Tests:             %d\n", last_results.total_failed);
391                 fprintf(f_txt, "Total Execution Time:     %d\n", last_results.total_time);
392         }
393
394         /* export each individual test */
395         AST_LIST_TRAVERSE(&tests, test, entry) {
396                 switch (mode) {
397                 case TEST_CATEGORY:
398                         if (!test_cat_cmp(test->info.category, category)) {
399                                 test_xml_entry(test, f_xml);
400                                 test_txt_entry(test, f_txt);
401                         }
402                         break;
403                 case TEST_NAME_CATEGORY:
404                         if (!(strcmp(test->info.category, category)) && !(strcmp(test->info.name, name))) {
405                                 test_xml_entry(test, f_xml);
406                                 test_txt_entry(test, f_txt);
407                         }
408                         break;
409                 case TEST_ALL:
410                         test_xml_entry(test, f_xml);
411                         test_txt_entry(test, f_txt);
412                 }
413         }
414         AST_LIST_UNLOCK(&tests);
415
416 done:
417         if (f_xml) {
418                 fprintf(f_xml, "</testsuite>\n");
419                 fclose(f_xml);
420         }
421         if (f_txt) {
422                 fclose(f_txt);
423         }
424
425         return res;
426 }
427
428 /*!
429  * \internal
430  * \brief adds test to container sorted first by category then by name
431  *
432  * \return 0 on success, -1 on failure
433  */
434 static int test_insert(struct ast_test *test)
435 {
436         struct ast_test *cur = NULL;
437         int res = 0;
438         int i = 0;
439         int inserted = 0;
440
441         /* This is a slow operation that may need to be optimized in the future
442          * as the test framework expands.  At the moment we are doing string
443          * comparisons on every item within the list to insert in sorted order. */
444         AST_LIST_LOCK(&tests);
445         AST_LIST_TRAVERSE_SAFE_BEGIN(&tests, cur, entry) {
446                 if ((i = strcmp(test->info.category, cur->info.category)) < 0) {
447                         AST_LIST_INSERT_BEFORE_CURRENT(test, entry);
448                         inserted = 1;
449                         break;
450                 } else if (!i) {  /* same category, now insert by name within that category*/
451                         if ((i = strcmp(test->info.name, cur->info.name)) < 0) {
452                                 AST_LIST_INSERT_BEFORE_CURRENT(test, entry);
453                                 inserted = 1;
454                                 break;
455                         } else if (!i) {
456                                 /* Error, duplicate found */
457                                 res = -1;
458                                 break;
459                         }
460                 }
461         }
462         AST_LIST_TRAVERSE_SAFE_END;
463
464         if (!inserted && !res) {
465                 AST_LIST_INSERT_TAIL(&tests, test, entry);
466                 inserted = 1;
467         }
468
469         AST_LIST_UNLOCK(&tests);
470
471         return res;
472 }
473
474 /*!
475  * \internal
476  * \brief removes test from container
477  *
478  * \return ast_test removed from list on success, or NULL on failure
479  */
480 static struct ast_test *test_remove(ast_test_cb_t *cb)
481 {
482         struct ast_test *cur = NULL;
483
484         AST_LIST_LOCK(&tests);
485         AST_LIST_TRAVERSE_SAFE_BEGIN(&tests, cur, entry) {
486                 if (cur->cb == cb) {
487                         AST_LIST_REMOVE_CURRENT(entry);
488                         break;
489                 }
490         }
491         AST_LIST_TRAVERSE_SAFE_END;
492         AST_LIST_UNLOCK(&tests);
493
494         return cur;
495 }
496
497 /*!
498  * \brief compares two test categories to determine if cat1 resides in cat2
499  * \internal
500  *
501  * \return 0 if true
502  */
503
504 static int test_cat_cmp(const char *cat1, const char *cat2)
505 {
506         int len1 = 0;
507         int len2 = 0;
508
509         if (!cat1 || !cat2) {
510                 return -1;
511         }
512
513         len1 = strlen(cat1);
514         len2 = strlen(cat2);
515
516         if (len2 > len1) {
517                 return -1;
518         }
519
520         return strncmp(cat1, cat2, len2) ? 1 : 0;
521 }
522
523 /*!
524  * \brief frees a ast_test object and all it's data members
525  * \internal
526  */
527 static struct ast_test *test_free(struct ast_test *test)
528 {
529         if (!test) {
530                 return NULL;
531         }
532
533         ast_free(test->args.ast_test_error_str);
534         ast_free(test);
535
536         return NULL;
537 }
538
539 /*!
540  * \internal
541  * \brief allocates an ast_test object.
542  */
543 static struct ast_test *test_alloc(ast_test_cb_t *cb)
544 {
545         struct ast_test *test;
546
547         if (!cb || !(test = ast_calloc(1, sizeof(*test)))) {
548                 return NULL;
549         }
550
551         test->cb = cb;
552
553         test->cb(&test->info, TEST_INIT, &test->args);
554
555         if (ast_strlen_zero(test->info.name) ||
556                 ast_strlen_zero(test->info.category) ||
557                 ast_strlen_zero(test->info.summary) ||
558                 ast_strlen_zero(test->info.description) ||
559                 !(test->args.ast_test_error_str = ast_str_create(128))) {
560
561                 return test_free(test);
562         }
563
564         return test;
565 }
566
567 /* CLI commands */
568 static char *test_cli_show_registered(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
569 {
570 #define FORMAT "%-15s %-20s %-30s %-10s\n"
571         static const char * const option1[] = { "all", "category", NULL };
572         static const char * const option2[] = { "name", NULL };
573         struct ast_test *test = NULL;
574         int count = 0;
575         switch (cmd) {
576         case CLI_INIT:
577                 e->command = "test show registered";
578
579                 e->usage =
580                         "Usage: 'test show registered' can be used in three ways.\n"
581                         "       1. 'test show registered all' shows all registered tests\n"
582                         "       2. 'test show registered category [test category]' shows all tests in the given\n"
583                         "          category.\n"
584                         "       3. 'test show registered category [test category] name [test name]' shows all\n"
585                         "           tests in a given category matching a given name\n";
586                 return NULL;
587         case CLI_GENERATE:
588                 if (a->pos == 3) {
589                         return ast_cli_complete(a->word, option1, a->n);
590                 }
591                 if (a->pos == 5) {
592                         return ast_cli_complete(a->word, option2, a->n);
593                 }
594                 return NULL;
595         case CLI_HANDLER:
596                 if ((a->argc < 4) || (a->argc == 6) || (a->argc > 7) ||
597                         ((a->argc == 4) && strcmp(a->argv[3], "all")) ||
598                         ((a->argc == 7) && strcmp(a->argv[5], "name"))) {
599                         return CLI_SHOWUSAGE;
600                 }
601                 ast_cli(a->fd, FORMAT, "Name", "Category", "Summary", "Test Result");
602                 AST_LIST_LOCK(&tests);
603                 AST_LIST_TRAVERSE(&tests, test, entry) {
604                         if ((a->argc == 4) ||
605                                  ((a->argc == 5) && !test_cat_cmp(test->info.category, a->argv[4])) ||
606                                  ((a->argc == 7) && !strcmp(test->info.category, a->argv[4]) && !strcmp(test->info.name, a->argv[6]))) {
607
608                                 ast_cli(a->fd, FORMAT, test->info.name, test->info.category, test->info.summary, test_result2str[test->state]);
609                                 count ++;
610                         }
611                 }
612                 AST_LIST_UNLOCK(&tests);
613                 ast_cli(a->fd, "%d Registered Tests Matched\n", count);
614         default:
615                 return NULL;
616         }
617
618         return CLI_SUCCESS;
619 }
620
621 static char *test_cli_execute_registered(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
622 {
623         static const char * const option1[] = { "all", "category", NULL };
624         static const char * const option2[] = { "name", NULL };
625         switch (cmd) {
626         case CLI_INIT:
627                 e->command = "test execute";
628                 e->usage =
629                         "Usage: test execute can be used in three ways.\n"
630                         "       1. 'test execute all' runs all registered tests\n"
631                         "       2. 'test execute category [test category]' runs all tests in the given\n"
632                         "          category.\n"
633                         "       3. 'test execute category [test category] name [test name]' runs all\n"
634                         "           tests in a given category matching a given name\n";
635                 return NULL;
636         case CLI_GENERATE:
637                 if (a->pos == 2) {
638                         return ast_cli_complete(a->word, option1, a->n);
639                 }
640                 if (a->pos == 4) {
641                         return ast_cli_complete(a->word, option2, a->n);
642                 }
643                 return NULL;
644         case CLI_HANDLER:
645
646                 if (a->argc < 3|| a->argc > 6) {
647                         return CLI_SHOWUSAGE;
648                 }
649
650                 if ((a->argc == 3) && !strcmp(a->argv[2], "all")) { /* run all registered tests */
651                         ast_cli(a->fd, "Running all available tests...\n\n");
652                         test_execute_multiple(NULL, NULL, a);
653                 } else if (a->argc == 4) { /* run only tests within a category */
654                         ast_cli(a->fd, "Running all available tests matching category %s\n\n", a->argv[3]);
655                         test_execute_multiple(NULL, a->argv[3], a);
656                 } else if (a->argc == 6) { /* run only a single test matching the category and name */
657                         ast_cli(a->fd, "Running all available tests matching category %s and name %s\n\n", a->argv[5], a->argv[3]);
658                         test_execute_multiple(a->argv[5], a->argv[3], a);
659                 } else {
660                         return CLI_SHOWUSAGE;
661                 }
662
663                 AST_LIST_LOCK(&tests);
664                 if (!(last_results.last_passed + last_results.last_failed)) {
665                         ast_cli(a->fd, "--- No Tests Found! ---\n");
666                 }
667                 ast_cli(a->fd, "\n%d Test(s) Executed  %d Passed  %d Failed\n",
668                         (last_results.last_passed + last_results.last_failed),
669                         last_results.last_passed,
670                         last_results.last_failed);
671                 AST_LIST_UNLOCK(&tests);
672         default:
673                 return NULL;
674         }
675
676         return CLI_SUCCESS;
677 }
678
679 static char *test_cli_show_results(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
680 {
681 #define FORMAT_RES_ALL "%s%s %-15s %-20s %-30s\n"
682         static const char * const option1[] = { "all", "failed", "passed", NULL };
683         char result_buf[32] = { 0 };
684         struct ast_test *test = NULL;
685         int failed = 0;
686         int passed = 0;
687         int mode;  /* 0 for show all, 1 for show fail, 2 for show passed */
688
689         switch (cmd) {
690         case CLI_INIT:
691                 e->command = "test show results";
692                 e->usage =
693                         "Usage: test show results can be used in three ways\n"
694                         "       1. 'test show results all' Displays results for all executed tests.\n"
695                         "       2. 'test show results passed' Displays results for all passed tests.\n"
696                         "       3. 'test show results failed' Displays results for all failed tests.\n";
697                 return NULL;
698         case CLI_GENERATE:
699                 if (a->pos == 3) {
700                         return ast_cli_complete(a->word, option1, a->n);
701                 }
702                 return NULL;
703         case CLI_HANDLER:
704
705                 /* verify input */
706                 if (a->argc != 4) {
707                         return CLI_SHOWUSAGE;
708                 } else if (!strcmp(a->argv[3], "passed")) {
709                         mode = 2;
710                 } else if (!strcmp(a->argv[3], "failed")) {
711                         mode = 1;
712                 } else if (!strcmp(a->argv[3], "all")) {
713                         mode = 0;
714                 } else {
715                         return CLI_SHOWUSAGE;
716                 }
717
718                 ast_cli(a->fd, FORMAT_RES_ALL, "Result", "", "Name", "Category", "Error Description");
719                 AST_LIST_LOCK(&tests);
720                 AST_LIST_TRAVERSE(&tests, test, entry) {
721                         if (test->state == AST_TEST_NOT_RUN) {
722                                 continue;
723                         }
724                         test->state == AST_TEST_FAIL ? failed++ : passed++;
725                         if (!mode || ((mode == 1) && (test->state == AST_TEST_FAIL)) || ((mode == 2) && (test->state == AST_TEST_PASS))) {
726                                 /* give our results pretty colors */
727                                 term_color(result_buf, test_result2str[test->state],
728                                         (test->state == AST_TEST_FAIL) ? COLOR_RED : COLOR_GREEN,
729                                         0, sizeof(result_buf));
730
731                                 ast_cli(a->fd, FORMAT_RES_ALL,
732                                         result_buf,
733                                         "  ",
734                                         test->info.name,
735                                         test->info.category,
736                                         (test->state == AST_TEST_FAIL) ? S_OR(ast_str_buffer(test->args.ast_test_error_str), "Not Avaliable") : "");
737                         }
738                 }
739                 AST_LIST_UNLOCK(&tests);
740
741                 ast_cli(a->fd, "%d Test(s) Executed  %d Passed  %d Failed\n", (failed + passed), passed, failed);
742         default:
743                 return NULL;
744         }
745         return CLI_SUCCESS;
746 }
747
748 static char *test_cli_generate_results(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
749 {
750         static const char * const option[] = { "xml", "txt", NULL };
751         const char *file = NULL;
752         const char *type = "";
753         int isxml = 0;
754         int res = 0;
755         struct ast_str *buf = NULL;
756         struct timeval time = ast_tvnow();
757
758         switch (cmd) {
759         case CLI_INIT:
760                 e->command = "test generate results";
761                 e->usage =
762                         "Usage: 'test generate results'\n"
763                         "       Generates test results in either xml or txt format. An optional \n"
764                         "       file path may be provided to specify the location of the xml or\n"
765                         "       txt file\n"
766                         "       \nExample usage:\n"
767                         "       'test generate results xml' this writes to a default file\n"
768                         "       'test generate results xml /path/to/file.xml' writes to specified file\n";
769                 return NULL;
770         case CLI_GENERATE:
771                 if (a->pos == 3) {
772                         return ast_cli_complete(a->word, option, a->n);
773                 }
774                 return NULL;
775         case CLI_HANDLER:
776
777                 /* verify input */
778                 if (a->argc < 4 || a->argc > 5) {
779                         return CLI_SHOWUSAGE;
780                 } else if (!strcmp(a->argv[3], "xml")) {
781                         type = "xml";
782                         isxml = 1;
783                 } else if (!strcmp(a->argv[3], "txt")) {
784                         type = "txt";
785                 } else {
786                         return CLI_SHOWUSAGE;
787                 }
788
789                 if (a->argc == 5) {
790                         file = a->argv[4];
791                 } else {
792                         if (!(buf = ast_str_create(256))) {
793                                 return NULL;
794                         }
795                         ast_str_set(&buf, 0, "%s/asterisk_test_results-%ld.%s", ast_config_AST_LOG_DIR, time.tv_sec, type);
796
797                         file = ast_str_buffer(buf);
798                 }
799
800                 if (isxml) {
801                         res = test_generate_results(NULL, NULL, file, NULL);
802                 } else {
803                         res = test_generate_results(NULL, NULL, NULL, file);
804                 }
805
806                 if (!res) {
807                         ast_cli(a->fd, "Results Generated Successfully: %s\n", S_OR(file, ""));
808                 } else {
809                         ast_cli(a->fd, "Results Could Not Be Generated: %s\n", S_OR(file, ""));
810                 }
811
812                 ast_free(buf);
813         default:
814                 return NULL;
815         }
816
817         return CLI_SUCCESS;
818 }
819
820 static struct ast_cli_entry test_cli[] = {
821         AST_CLI_DEFINE(test_cli_show_registered,           "show registered tests"),
822         AST_CLI_DEFINE(test_cli_execute_registered,        "execute registered tests"),
823         AST_CLI_DEFINE(test_cli_show_results,              "show last test results"),
824         AST_CLI_DEFINE(test_cli_generate_results,          "generate test results to file"),
825 };
826 #endif /* TEST_FRAMEWORK */
827
828 int ast_test_init()
829 {
830 #ifdef TEST_FRAMEWORK
831         /* Register cli commands */
832         ast_cli_register_multiple(test_cli, ARRAY_LEN(test_cli));
833
834         /* in the future this function could be used to register functions not
835          * defined within a module */
836 #endif
837
838         return 0;
839 }