torture: minor fixes to torture macro text output.
[ira/wip.git] / lib / torture / torture.c
1 /* 
2    Unix SMB/CIFS implementation.
3    SMB torture UI functions
4
5    Copyright (C) Jelmer Vernooij 2006-2008
6    
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11    
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16    
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "source4/include/includes.h"
22 #include "../torture/torture.h"
23 #include "../lib/util/dlinklist.h"
24 #include "param/param.h"
25 #include "system/filesys.h"
26
27 struct torture_results *torture_results_init(TALLOC_CTX *mem_ctx, const struct torture_ui_ops *ui_ops)
28 {
29         struct torture_results *results = talloc_zero(mem_ctx, struct torture_results);
30
31         results->ui_ops = ui_ops;
32         results->returncode = true;
33
34         if (ui_ops->init)
35                 ui_ops->init(results);
36
37         return results;
38 }
39
40 /**
41  * Initialize a torture context
42  */
43 struct torture_context *torture_context_init(struct tevent_context *event_ctx, 
44                                                                                          struct torture_results *results)
45 {
46         struct torture_context *torture = talloc_zero(event_ctx, 
47                                                       struct torture_context);
48
49         if (torture == NULL)
50                 return NULL;
51
52         torture->ev = event_ctx;
53         torture->results = talloc_reference(torture, results);
54
55         return torture;
56 }
57
58 /**
59  * Create a sub torture context
60  */
61 struct torture_context *torture_context_child(struct torture_context *parent)
62 {
63         struct torture_context *subtorture = talloc_zero(parent, struct torture_context);
64
65         if (subtorture == NULL)
66                 return NULL;
67
68         subtorture->level = parent->level+1;
69         subtorture->ev = talloc_reference(subtorture, parent->ev);
70         subtorture->lp_ctx = talloc_reference(subtorture, parent->lp_ctx);
71         subtorture->outputdir = talloc_reference(subtorture, parent->outputdir);
72         subtorture->results = talloc_reference(subtorture, parent->results);
73
74         return subtorture;
75 }       
76
77 /**
78  create a temporary directory.
79 */
80 _PUBLIC_ NTSTATUS torture_temp_dir(struct torture_context *tctx, 
81                                    const char *prefix, 
82                                    char **tempdir)
83 {
84         SMB_ASSERT(tctx->outputdir != NULL);
85
86         *tempdir = talloc_asprintf(tctx, "%s/%s.XXXXXX", tctx->outputdir, 
87                                    prefix);
88         NT_STATUS_HAVE_NO_MEMORY(*tempdir);
89
90         if (mkdtemp(*tempdir) == NULL) {
91                 return map_nt_error_from_unix(errno);
92         }
93
94         return NT_STATUS_OK;
95 }
96
97 /**
98  * Comment on the status/progress of a test
99  */
100 void torture_comment(struct torture_context *context, const char *comment, ...)
101 {
102         va_list ap;
103         char *tmp;
104
105         if (!context->results->ui_ops->comment)
106                 return;
107
108         va_start(ap, comment);
109         tmp = talloc_vasprintf(context, comment, ap);
110                 
111         context->results->ui_ops->comment(context, tmp);
112         
113         talloc_free(tmp);
114 }
115
116 /**
117  * Print a warning about the current test
118  */
119 void torture_warning(struct torture_context *context, const char *comment, ...)
120 {
121         va_list ap;
122         char *tmp;
123
124         if (!context->results->ui_ops->warning)
125                 return;
126
127         va_start(ap, comment);
128         tmp = talloc_vasprintf(context, comment, ap);
129
130         context->results->ui_ops->warning(context, tmp);
131
132         talloc_free(tmp);
133 }
134
135 /**
136  * Store the result of a torture test.
137  */
138 void torture_result(struct torture_context *context, 
139                     enum torture_result result, const char *fmt, ...)
140 {
141         va_list ap;
142
143         va_start(ap, fmt);
144
145         if (context->last_reason) {
146                 torture_warning(context, "%s", context->last_reason);
147                 talloc_free(context->last_reason);
148         }
149
150         context->last_result = result;
151         context->last_reason = talloc_vasprintf(context, fmt, ap);
152         va_end(ap);
153 }
154
155 /**
156  * Create a new torture suite
157  */
158 struct torture_suite *torture_suite_create(TALLOC_CTX *ctx, const char *name)
159 {
160         struct torture_suite *suite = talloc_zero(ctx, struct torture_suite);
161
162         suite->name = talloc_strdup(suite, name);
163         suite->testcases = NULL;
164         suite->children = NULL;
165
166         return suite;
167 }
168
169 /**
170  * Set the setup() and teardown() functions for a testcase.
171  */
172 void torture_tcase_set_fixture(struct torture_tcase *tcase, 
173                 bool (*setup) (struct torture_context *, void **),
174                 bool (*teardown) (struct torture_context *, void *))
175 {
176         tcase->setup = setup;
177         tcase->teardown = teardown;
178 }
179
180 static bool wrap_test_with_testcase_const(struct torture_context *torture_ctx,
181                                     struct torture_tcase *tcase,
182                                     struct torture_test *test)
183 {
184         bool (*fn) (struct torture_context *,
185                     const void *tcase_data,
186                     const void *test_data);
187
188         fn = test->fn;
189
190         return fn(torture_ctx, tcase->data, test->data);
191 }
192
193 /**
194  * Add a test that uses const data to a testcase
195  */
196 struct torture_test *torture_tcase_add_test_const(struct torture_tcase *tcase,
197                 const char *name,
198                 bool (*run) (struct torture_context *, const void *tcase_data,
199                         const void *test_data),
200                 const void *data)
201 {
202         struct torture_test *test = talloc(tcase, struct torture_test);
203
204         test->name = talloc_strdup(test, name);
205         test->description = NULL;
206         test->run = wrap_test_with_testcase_const;
207         test->fn = run;
208         test->dangerous = false;
209         test->data = data;
210
211         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
212
213         return test;
214 }
215
216 /**
217  * Add a new testcase
218  */
219 bool torture_suite_init_tcase(struct torture_suite *suite, 
220                               struct torture_tcase *tcase, 
221                               const char *name)
222 {
223         tcase->name = talloc_strdup(tcase, name);
224         tcase->description = NULL;
225         tcase->setup = NULL;
226         tcase->teardown = NULL;
227         tcase->fixture_persistent = true;
228         tcase->tests = NULL;
229
230         DLIST_ADD_END(suite->testcases, tcase, struct torture_tcase *);
231
232         return true;
233 }
234
235
236 struct torture_tcase *torture_suite_add_tcase(struct torture_suite *suite, 
237                                                          const char *name)
238 {
239         struct torture_tcase *tcase = talloc(suite, struct torture_tcase);
240
241         if (!torture_suite_init_tcase(suite, tcase, name))
242                 return NULL;
243
244         return tcase;
245 }
246
247 /**
248  * Run a torture test suite.
249  */
250 bool torture_run_suite(struct torture_context *context, 
251                        struct torture_suite *suite)
252 {
253         bool ret = true;
254         struct torture_tcase *tcase;
255         struct torture_suite *tsuite;
256         char *old_testname;
257
258         context->level++;
259         if (context->results->ui_ops->suite_start)
260                 context->results->ui_ops->suite_start(context, suite);
261
262         old_testname = context->active_testname;
263         if (old_testname != NULL)
264                 context->active_testname = talloc_asprintf(context, "%s-%s", 
265                                                            old_testname, suite->name);
266         else
267                 context->active_testname = talloc_strdup(context, suite->name);
268
269         for (tcase = suite->testcases; tcase; tcase = tcase->next) {
270                 ret &= torture_run_tcase(context, tcase);
271         }
272
273         for (tsuite = suite->children; tsuite; tsuite = tsuite->next) {
274                 ret &= torture_run_suite(context, tsuite);
275         }
276
277         talloc_free(context->active_testname);
278         context->active_testname = old_testname;
279
280         if (context->results->ui_ops->suite_finish)
281                 context->results->ui_ops->suite_finish(context, suite);
282
283         context->level--;
284         
285         return ret;
286 }
287
288 void torture_ui_test_start(struct torture_context *context, 
289                            struct torture_tcase *tcase, 
290                            struct torture_test *test)
291 {
292         if (context->results->ui_ops->test_start)
293                 context->results->ui_ops->test_start(context, tcase, test);
294 }
295
296 void torture_ui_test_result(struct torture_context *context, 
297                             enum torture_result result,
298                             const char *comment)
299 {
300         if (context->results->ui_ops->test_result)
301                 context->results->ui_ops->test_result(context, result, comment);
302
303         if (result == TORTURE_ERROR || result == TORTURE_FAIL)
304                 context->results->returncode = false;
305 }
306
307 static bool internal_torture_run_test(struct torture_context *context, 
308                                           struct torture_tcase *tcase,
309                                           struct torture_test *test,
310                                           bool already_setup)
311 {
312         bool success;
313         char *old_testname = NULL;
314
315         if (tcase == NULL || strcmp(test->name, tcase->name) != 0) { 
316                 old_testname = context->active_testname;
317                 context->active_testname = talloc_asprintf(context, "%s-%s", old_testname, test->name);
318         }
319
320         context->active_tcase = tcase;
321         context->active_test = test;
322
323         torture_ui_test_start(context, tcase, test);
324
325         context->last_reason = NULL;
326         context->last_result = TORTURE_OK;
327
328         if (!already_setup && tcase->setup && 
329                 !tcase->setup(context, &(tcase->data))) {
330                 if (context->last_reason == NULL)
331                         context->last_reason = talloc_strdup(context, "Setup failure");
332                 context->last_result = TORTURE_ERROR;
333                 success = false;
334         } else if (test->dangerous && 
335             !torture_setting_bool(context, "dangerous", false)) {
336             context->last_result = TORTURE_SKIP;
337             context->last_reason = talloc_asprintf(context, 
338                 "disabled %s - enable dangerous tests to use", test->name);
339             success = true;
340         } else {
341             success = test->run(context, tcase, test);
342
343             if (!success && context->last_result == TORTURE_OK) {
344                     if (context->last_reason == NULL)
345                             context->last_reason = talloc_strdup(context, "Unknown error/failure");
346                     context->last_result = TORTURE_ERROR;
347             }
348         }
349
350         if (!already_setup && tcase->teardown && !tcase->teardown(context, tcase->data)) {
351                 if (context->last_reason == NULL)
352                     context->last_reason = talloc_strdup(context, "Setup failure");
353                 context->last_result = TORTURE_ERROR;
354                 success = false;
355         }
356
357         torture_ui_test_result(context, context->last_result, 
358                                context->last_reason);
359         
360         talloc_free(context->last_reason);
361
362         if (tcase == NULL || strcmp(test->name, tcase->name) != 0) { 
363                 talloc_free(context->active_testname);
364                 context->active_testname = old_testname;
365         }
366         context->active_test = NULL;
367         context->active_tcase = NULL;
368
369         return success;
370 }
371
372 bool torture_run_tcase(struct torture_context *context, 
373                        struct torture_tcase *tcase)
374 {
375         bool ret = true;
376         char *old_testname;
377         struct torture_test *test;
378
379         context->level++;
380
381         context->active_tcase = tcase;
382         if (context->results->ui_ops->tcase_start) 
383                 context->results->ui_ops->tcase_start(context, tcase);
384
385         if (tcase->fixture_persistent && tcase->setup 
386                 && !tcase->setup(context, &tcase->data)) {
387                 /* FIXME: Use torture ui ops for reporting this error */
388                 fprintf(stderr, "Setup failed: ");
389                 if (context->last_reason != NULL)
390                         fprintf(stderr, "%s", context->last_reason);
391                 fprintf(stderr, "\n");
392                 ret = false;
393                 goto done;
394         }
395
396         old_testname = context->active_testname;
397         context->active_testname = talloc_asprintf(context, "%s-%s", 
398                                                    old_testname, tcase->name);
399         for (test = tcase->tests; test; test = test->next) {
400                 ret &= internal_torture_run_test(context, tcase, test, 
401                                 tcase->fixture_persistent);
402         }
403         talloc_free(context->active_testname);
404         context->active_testname = old_testname;
405
406         if (tcase->fixture_persistent && tcase->teardown &&
407                 !tcase->teardown(context, tcase->data))
408                 ret = false;
409
410 done:
411         context->active_tcase = NULL;
412
413         if (context->results->ui_ops->tcase_finish)
414                 context->results->ui_ops->tcase_finish(context, tcase);
415
416         context->level--;
417
418         return ret;
419 }
420
421 bool torture_run_test(struct torture_context *context, 
422                                           struct torture_tcase *tcase,
423                                           struct torture_test *test)
424 {
425         return internal_torture_run_test(context, tcase, test, false);
426 }
427
428 int torture_setting_int(struct torture_context *test, const char *name, 
429                                                         int default_value)
430 {
431         return lp_parm_int(test->lp_ctx, NULL, "torture", name, default_value);
432 }
433
434 double torture_setting_double(struct torture_context *test, const char *name, 
435                                                         double default_value)
436 {
437         return lp_parm_double(test->lp_ctx, NULL, "torture", name, default_value);
438 }
439
440 bool torture_setting_bool(struct torture_context *test, const char *name, 
441                                                         bool default_value)
442 {
443         return lp_parm_bool(test->lp_ctx, NULL, "torture", name, default_value);
444 }
445
446 const char *torture_setting_string(struct torture_context *test, 
447                                    const char *name, 
448                                    const char *default_value)
449 {
450         const char *ret;
451
452         SMB_ASSERT(test != NULL);
453         SMB_ASSERT(test->lp_ctx != NULL);
454         
455         ret = lp_parm_string(test->lp_ctx, NULL, "torture", name);
456
457         if (ret == NULL)
458                 return default_value;
459
460         return ret;
461 }
462
463 static bool wrap_test_with_simple_tcase_const (
464                 struct torture_context *torture_ctx,
465                 struct torture_tcase *tcase,
466                 struct torture_test *test)
467 {
468         bool (*fn) (struct torture_context *, const void *tcase_data);
469
470         fn = test->fn;
471
472         return fn(torture_ctx, test->data);
473 }
474
475 struct torture_tcase *torture_suite_add_simple_tcase_const(
476                 struct torture_suite *suite, const char *name,
477                 bool (*run) (struct torture_context *test, const void *),
478                 const void *data)
479 {
480         struct torture_tcase *tcase;
481         struct torture_test *test;
482
483         tcase = torture_suite_add_tcase(suite, name);
484
485         test = talloc(tcase, struct torture_test);
486
487         test->name = talloc_strdup(test, name);
488         test->description = NULL;
489         test->run = wrap_test_with_simple_tcase_const;
490         test->fn = run;
491         test->data = data;
492         test->dangerous = false;
493
494         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
495
496         return tcase;
497 }
498
499 static bool wrap_simple_test(struct torture_context *torture_ctx,
500                              struct torture_tcase *tcase,
501                              struct torture_test *test)
502 {
503         bool (*fn) (struct torture_context *);
504
505         fn = test->fn;
506
507         return fn(torture_ctx);
508 }
509
510 struct torture_tcase *torture_suite_add_simple_test(
511                                         struct torture_suite *suite, 
512                                         const char *name,
513                                         bool (*run) (struct torture_context *test))
514 {
515         struct torture_test *test; 
516         struct torture_tcase *tcase;
517         
518         tcase = torture_suite_add_tcase(suite, name);
519
520         test = talloc(tcase, struct torture_test);
521
522         test->name = talloc_strdup(test, name);
523         test->description = NULL;
524         test->run = wrap_simple_test;
525         test->fn = run;
526         test->dangerous = false;
527
528         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
529
530         return tcase;
531 }
532
533 /**
534  * Add a child testsuite to a testsuite.
535  */
536 bool torture_suite_add_suite(struct torture_suite *suite, 
537                              struct torture_suite *child)
538 {
539         if (child == NULL)
540                 return false;
541
542         DLIST_ADD_END(suite->children, child, struct torture_suite *);
543
544         /* FIXME: Check for duplicates and return false if the 
545          * added suite already exists as a child */
546
547         return true;
548 }
549
550 /**
551  * Find the child testsuite with the specified name.
552  */
553 struct torture_suite *torture_find_suite(struct torture_suite *parent, 
554                                          const char *name)
555 {
556         struct torture_suite *child;
557
558         for (child = parent->children; child; child = child->next) 
559                 if (!strcmp(child->name, name))
560                         return child;
561
562         return NULL;
563 }
564
565 static bool wrap_test_with_simple_test_const(struct torture_context *torture_ctx,
566                                        struct torture_tcase *tcase,
567                                        struct torture_test *test)
568 {
569         bool (*fn) (struct torture_context *, const void *tcase_data);
570
571         fn = test->fn;
572
573         return fn(torture_ctx, tcase->data);
574 }
575
576 struct torture_test *torture_tcase_add_simple_test_const(
577                 struct torture_tcase *tcase,
578                 const char *name,
579                 bool (*run) (struct torture_context *test,
580                         const void *tcase_data))
581 {
582         struct torture_test *test;
583
584         test = talloc(tcase, struct torture_test);
585
586         test->name = talloc_strdup(test, name);
587         test->description = NULL;
588         test->run = wrap_test_with_simple_test_const;
589         test->fn = run;
590         test->data = NULL;
591         test->dangerous = false;
592
593         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
594
595         return test;
596 }
597
598 static bool wrap_test_with_simple_test(struct torture_context *torture_ctx,
599                                        struct torture_tcase *tcase,
600                                        struct torture_test *test)
601 {
602         bool (*fn) (struct torture_context *, void *tcase_data);
603
604         fn = test->fn;
605
606         return fn(torture_ctx, tcase->data);
607 }
608
609 struct torture_test *torture_tcase_add_simple_test(struct torture_tcase *tcase,
610                 const char *name,
611                 bool (*run) (struct torture_context *test, void *tcase_data))
612 {
613         struct torture_test *test;
614
615         test = talloc(tcase, struct torture_test);
616
617         test->name = talloc_strdup(test, name);
618         test->description = NULL;
619         test->run = wrap_test_with_simple_test;
620         test->fn = run;
621         test->data = NULL;
622         test->dangerous = false;
623
624         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
625
626         return test;
627 }