torture: Simplify torture suite running, call restricted test suite runner.
[samba.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->ev = talloc_reference(subtorture, parent->ev);
69         subtorture->lp_ctx = talloc_reference(subtorture, parent->lp_ctx);
70         subtorture->outputdir = talloc_reference(subtorture, parent->outputdir);
71         subtorture->results = talloc_reference(subtorture, parent->results);
72
73         return subtorture;
74 }       
75
76 /**
77  create a temporary directory.
78 */
79 _PUBLIC_ NTSTATUS torture_temp_dir(struct torture_context *tctx, 
80                                    const char *prefix, 
81                                    char **tempdir)
82 {
83         SMB_ASSERT(tctx->outputdir != NULL);
84
85         *tempdir = talloc_asprintf(tctx, "%s/%s.XXXXXX", tctx->outputdir, 
86                                    prefix);
87         NT_STATUS_HAVE_NO_MEMORY(*tempdir);
88
89         if (mkdtemp(*tempdir) == NULL) {
90                 return map_nt_error_from_unix(errno);
91         }
92
93         return NT_STATUS_OK;
94 }
95
96 /**
97  * Comment on the status/progress of a test
98  */
99 void torture_comment(struct torture_context *context, const char *comment, ...)
100 {
101         va_list ap;
102         char *tmp;
103
104         if (!context->results->ui_ops->comment)
105                 return;
106
107         va_start(ap, comment);
108         tmp = talloc_vasprintf(context, comment, ap);
109         va_end(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         va_end(ap);
130
131         context->results->ui_ops->warning(context, tmp);
132
133         talloc_free(tmp);
134 }
135
136 /**
137  * Store the result of a torture test.
138  */
139 void torture_result(struct torture_context *context, 
140                     enum torture_result result, const char *fmt, ...)
141 {
142         va_list ap;
143
144         va_start(ap, fmt);
145
146         if (context->last_reason) {
147                 torture_warning(context, "%s", context->last_reason);
148                 talloc_free(context->last_reason);
149         }
150
151         context->last_result = result;
152         context->last_reason = talloc_vasprintf(context, fmt, ap);
153         va_end(ap);
154 }
155
156 /**
157  * Create a new torture suite
158  */
159 struct torture_suite *torture_suite_create(TALLOC_CTX *ctx, const char *name)
160 {
161         struct torture_suite *suite = talloc_zero(ctx, struct torture_suite);
162
163         suite->name = talloc_strdup(suite, name);
164         suite->testcases = NULL;
165         suite->children = NULL;
166
167         return suite;
168 }
169
170 /**
171  * Set the setup() and teardown() functions for a testcase.
172  */
173 void torture_tcase_set_fixture(struct torture_tcase *tcase, 
174                 bool (*setup) (struct torture_context *, void **),
175                 bool (*teardown) (struct torture_context *, void *))
176 {
177         tcase->setup = setup;
178         tcase->teardown = teardown;
179 }
180
181 static bool wrap_test_with_testcase_const(struct torture_context *torture_ctx,
182                                     struct torture_tcase *tcase,
183                                     struct torture_test *test)
184 {
185         bool (*fn) (struct torture_context *,
186                     const void *tcase_data,
187                     const void *test_data);
188
189         fn = test->fn;
190
191         return fn(torture_ctx, tcase->data, test->data);
192 }
193
194 /**
195  * Add a test that uses const data to a testcase
196  */
197 struct torture_test *torture_tcase_add_test_const(struct torture_tcase *tcase,
198                 const char *name,
199                 bool (*run) (struct torture_context *, const void *tcase_data,
200                         const void *test_data),
201                 const void *data)
202 {
203         struct torture_test *test = talloc(tcase, struct torture_test);
204
205         test->name = talloc_strdup(test, name);
206         test->description = NULL;
207         test->run = wrap_test_with_testcase_const;
208         test->fn = run;
209         test->dangerous = false;
210         test->data = data;
211
212         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
213
214         return test;
215 }
216
217 /**
218  * Add a new testcase
219  */
220 bool torture_suite_init_tcase(struct torture_suite *suite, 
221                               struct torture_tcase *tcase, 
222                               const char *name)
223 {
224         tcase->name = talloc_strdup(tcase, name);
225         tcase->description = NULL;
226         tcase->setup = NULL;
227         tcase->teardown = NULL;
228         tcase->fixture_persistent = true;
229         tcase->tests = NULL;
230
231         DLIST_ADD_END(suite->testcases, tcase, struct torture_tcase *);
232
233         return true;
234 }
235
236
237 struct torture_tcase *torture_suite_add_tcase(struct torture_suite *suite, 
238                                                          const char *name)
239 {
240         struct torture_tcase *tcase = talloc(suite, struct torture_tcase);
241
242         if (!torture_suite_init_tcase(suite, tcase, name))
243                 return NULL;
244
245         return tcase;
246 }
247
248 int torture_suite_children_count(const struct torture_suite *suite)
249 {
250         int ret = 0;
251         struct torture_tcase *tcase;
252         struct torture_test *test;
253         struct torture_suite *tsuite;
254         for (tcase = suite->testcases; tcase; tcase = tcase->next) {
255                 for (test = tcase->tests; test; test = test->next) {
256                         ret++;
257                 }
258         }
259         for (tsuite = suite->children; tsuite; tsuite = tsuite->next) {
260                 ret ++;
261         }
262         return ret;
263 }
264
265 /**
266  * Run a torture test suite.
267  */
268 bool torture_run_suite(struct torture_context *context, 
269                        struct torture_suite *suite)
270 {
271         bool ret = true;
272         struct torture_tcase *tcase;
273         struct torture_suite *tsuite;
274         char *old_testname;
275
276         if (context->results->ui_ops->suite_start)
277                 context->results->ui_ops->suite_start(context, suite);
278
279         context->results->ui_ops->progress(context, 
280                 torture_suite_children_count(suite), TORTURE_PROGRESS_SET); 
281         old_testname = context->active_testname;
282         if (old_testname != NULL)
283                 context->active_testname = talloc_asprintf(context, "%s-%s", 
284                                                            old_testname, suite->name);
285         else
286                 context->active_testname = talloc_strdup(context, suite->name);
287
288         for (tcase = suite->testcases; tcase; tcase = tcase->next) {
289                 ret &= torture_run_tcase(context, tcase);
290         }
291
292         for (tsuite = suite->children; tsuite; tsuite = tsuite->next) {
293                 context->results->ui_ops->progress(context, 0, TORTURE_PROGRESS_PUSH);
294                 ret &= torture_run_suite(context, tsuite);
295                 context->results->ui_ops->progress(context, 0, TORTURE_PROGRESS_POP);
296         }
297
298         talloc_free(context->active_testname);
299         context->active_testname = old_testname;
300
301         if (context->results->ui_ops->suite_finish)
302                 context->results->ui_ops->suite_finish(context, suite);
303
304         return ret;
305 }
306
307 bool torture_run_suite_restricted(struct torture_context *context, 
308                        struct torture_suite *suite, char **restricted)
309 {
310         /* FIXME */
311         return false;
312 }
313
314 void torture_ui_test_start(struct torture_context *context, 
315                            struct torture_tcase *tcase, 
316                            struct torture_test *test)
317 {
318         if (context->results->ui_ops->test_start)
319                 context->results->ui_ops->test_start(context, tcase, test);
320 }
321
322 void torture_ui_test_result(struct torture_context *context, 
323                             enum torture_result result,
324                             const char *comment)
325 {
326         if (context->results->ui_ops->test_result)
327                 context->results->ui_ops->test_result(context, result, comment);
328
329         if (result == TORTURE_ERROR || result == TORTURE_FAIL)
330                 context->results->returncode = false;
331 }
332
333 static bool internal_torture_run_test(struct torture_context *context, 
334                                           struct torture_tcase *tcase,
335                                           struct torture_test *test,
336                                           bool already_setup)
337 {
338         bool success;
339         char *old_testname = NULL;
340
341         if (tcase == NULL || strcmp(test->name, tcase->name) != 0) { 
342                 old_testname = context->active_testname;
343                 context->active_testname = talloc_asprintf(context, "%s-%s", old_testname, test->name);
344         }
345
346         context->active_tcase = tcase;
347         context->active_test = test;
348
349         torture_ui_test_start(context, tcase, test);
350
351         context->last_reason = NULL;
352         context->last_result = TORTURE_OK;
353
354         if (!already_setup && tcase->setup && 
355                 !tcase->setup(context, &(tcase->data))) {
356                 if (context->last_reason == NULL)
357                         context->last_reason = talloc_strdup(context, "Setup failure");
358                 context->last_result = TORTURE_ERROR;
359                 success = false;
360         } else if (test->dangerous && 
361             !torture_setting_bool(context, "dangerous", false)) {
362             context->last_result = TORTURE_SKIP;
363             context->last_reason = talloc_asprintf(context, 
364                 "disabled %s - enable dangerous tests to use", test->name);
365             success = true;
366         } else {
367             success = test->run(context, tcase, test);
368
369             if (!success && context->last_result == TORTURE_OK) {
370                     if (context->last_reason == NULL)
371                             context->last_reason = talloc_strdup(context, "Unknown error/failure");
372                     context->last_result = TORTURE_ERROR;
373             }
374         }
375
376         if (!already_setup && tcase->teardown && !tcase->teardown(context, tcase->data)) {
377                 if (context->last_reason == NULL)
378                     context->last_reason = talloc_strdup(context, "Setup failure");
379                 context->last_result = TORTURE_ERROR;
380                 success = false;
381         }
382
383         torture_ui_test_result(context, context->last_result, 
384                                context->last_reason);
385         
386         talloc_free(context->last_reason);
387
388         if (tcase == NULL || strcmp(test->name, tcase->name) != 0) { 
389                 talloc_free(context->active_testname);
390                 context->active_testname = old_testname;
391         }
392         context->active_test = NULL;
393         context->active_tcase = NULL;
394
395         return success;
396 }
397
398 bool torture_run_tcase(struct torture_context *context, 
399                        struct torture_tcase *tcase)
400 {
401         bool ret = true;
402         char *old_testname;
403         struct torture_test *test;
404
405         context->active_tcase = tcase;
406         if (context->results->ui_ops->tcase_start) 
407                 context->results->ui_ops->tcase_start(context, tcase);
408
409         if (tcase->fixture_persistent && tcase->setup 
410                 && !tcase->setup(context, &tcase->data)) {
411                 /* FIXME: Use torture ui ops for reporting this error */
412                 fprintf(stderr, "Setup failed: ");
413                 if (context->last_reason != NULL)
414                         fprintf(stderr, "%s", context->last_reason);
415                 fprintf(stderr, "\n");
416                 ret = false;
417                 goto done;
418         }
419
420         old_testname = context->active_testname;
421         context->active_testname = talloc_asprintf(context, "%s-%s", 
422                                                    old_testname, tcase->name);
423         for (test = tcase->tests; test; test = test->next) {
424                 ret &= internal_torture_run_test(context, tcase, test, 
425                                 tcase->fixture_persistent);
426         }
427         talloc_free(context->active_testname);
428         context->active_testname = old_testname;
429
430         if (tcase->fixture_persistent && tcase->teardown &&
431                 !tcase->teardown(context, tcase->data))
432                 ret = false;
433
434 done:
435         context->active_tcase = NULL;
436
437         if (context->results->ui_ops->tcase_finish)
438                 context->results->ui_ops->tcase_finish(context, tcase);
439
440         return ret;
441 }
442
443 bool torture_run_test(struct torture_context *context, 
444                                           struct torture_tcase *tcase,
445                                           struct torture_test *test)
446 {
447         return internal_torture_run_test(context, tcase, test, false);
448 }
449
450 int torture_setting_int(struct torture_context *test, const char *name, 
451                                                         int default_value)
452 {
453         return lp_parm_int(test->lp_ctx, NULL, "torture", name, default_value);
454 }
455
456 unsigned long torture_setting_ulong(struct torture_context *test,
457                                     const char *name,
458                                     unsigned long default_value)
459 {
460         return lp_parm_ulong(test->lp_ctx, NULL, "torture", name,
461                              default_value);
462 }
463
464 double torture_setting_double(struct torture_context *test, const char *name, 
465                                                         double default_value)
466 {
467         return lp_parm_double(test->lp_ctx, NULL, "torture", name, default_value);
468 }
469
470 bool torture_setting_bool(struct torture_context *test, const char *name, 
471                                                         bool default_value)
472 {
473         return lp_parm_bool(test->lp_ctx, NULL, "torture", name, default_value);
474 }
475
476 const char *torture_setting_string(struct torture_context *test, 
477                                    const char *name, 
478                                    const char *default_value)
479 {
480         const char *ret;
481
482         SMB_ASSERT(test != NULL);
483         SMB_ASSERT(test->lp_ctx != NULL);
484         
485         ret = lp_parm_string(test->lp_ctx, NULL, "torture", name);
486
487         if (ret == NULL)
488                 return default_value;
489
490         return ret;
491 }
492
493 static bool wrap_test_with_simple_tcase_const (
494                 struct torture_context *torture_ctx,
495                 struct torture_tcase *tcase,
496                 struct torture_test *test)
497 {
498         bool (*fn) (struct torture_context *, const void *tcase_data);
499
500         fn = test->fn;
501
502         return fn(torture_ctx, test->data);
503 }
504
505 struct torture_tcase *torture_suite_add_simple_tcase_const(
506                 struct torture_suite *suite, const char *name,
507                 bool (*run) (struct torture_context *test, const void *),
508                 const void *data)
509 {
510         struct torture_tcase *tcase;
511         struct torture_test *test;
512
513         tcase = torture_suite_add_tcase(suite, name);
514
515         test = talloc(tcase, struct torture_test);
516
517         test->name = talloc_strdup(test, name);
518         test->description = NULL;
519         test->run = wrap_test_with_simple_tcase_const;
520         test->fn = run;
521         test->data = data;
522         test->dangerous = false;
523
524         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
525
526         return tcase;
527 }
528
529 static bool wrap_simple_test(struct torture_context *torture_ctx,
530                              struct torture_tcase *tcase,
531                              struct torture_test *test)
532 {
533         bool (*fn) (struct torture_context *);
534
535         fn = test->fn;
536
537         return fn(torture_ctx);
538 }
539
540 struct torture_tcase *torture_suite_add_simple_test(
541                                         struct torture_suite *suite, 
542                                         const char *name,
543                                         bool (*run) (struct torture_context *test))
544 {
545         struct torture_test *test; 
546         struct torture_tcase *tcase;
547         
548         tcase = torture_suite_add_tcase(suite, name);
549
550         test = talloc(tcase, struct torture_test);
551
552         test->name = talloc_strdup(test, name);
553         test->description = NULL;
554         test->run = wrap_simple_test;
555         test->fn = run;
556         test->dangerous = false;
557
558         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
559
560         return tcase;
561 }
562
563 /**
564  * Add a child testsuite to a testsuite.
565  */
566 bool torture_suite_add_suite(struct torture_suite *suite, 
567                              struct torture_suite *child)
568 {
569         if (child == NULL)
570                 return false;
571
572         DLIST_ADD_END(suite->children, child, struct torture_suite *);
573
574         /* FIXME: Check for duplicates and return false if the 
575          * added suite already exists as a child */
576
577         return true;
578 }
579
580 /**
581  * Find the child testsuite with the specified name.
582  */
583 struct torture_suite *torture_find_suite(struct torture_suite *parent, 
584                                          const char *name)
585 {
586         struct torture_suite *child;
587
588         for (child = parent->children; child; child = child->next) 
589                 if (!strcmp(child->name, name))
590                         return child;
591
592         return NULL;
593 }
594
595 static bool wrap_test_with_simple_test_const(struct torture_context *torture_ctx,
596                                        struct torture_tcase *tcase,
597                                        struct torture_test *test)
598 {
599         bool (*fn) (struct torture_context *, const void *tcase_data);
600
601         fn = test->fn;
602
603         return fn(torture_ctx, tcase->data);
604 }
605
606 struct torture_test *torture_tcase_add_simple_test_const(
607                 struct torture_tcase *tcase,
608                 const char *name,
609                 bool (*run) (struct torture_context *test,
610                         const void *tcase_data))
611 {
612         struct torture_test *test;
613
614         test = talloc(tcase, struct torture_test);
615
616         test->name = talloc_strdup(test, name);
617         test->description = NULL;
618         test->run = wrap_test_with_simple_test_const;
619         test->fn = run;
620         test->data = NULL;
621         test->dangerous = false;
622
623         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
624
625         return test;
626 }
627
628 static bool wrap_test_with_simple_test(struct torture_context *torture_ctx,
629                                        struct torture_tcase *tcase,
630                                        struct torture_test *test)
631 {
632         bool (*fn) (struct torture_context *, void *tcase_data);
633
634         fn = test->fn;
635
636         return fn(torture_ctx, tcase->data);
637 }
638
639 struct torture_test *torture_tcase_add_simple_test(struct torture_tcase *tcase,
640                 const char *name,
641                 bool (*run) (struct torture_context *test, void *tcase_data))
642 {
643         struct torture_test *test;
644
645         test = talloc(tcase, struct torture_test);
646
647         test->name = talloc_strdup(test, name);
648         test->description = NULL;
649         test->run = wrap_test_with_simple_test;
650         test->fn = run;
651         test->data = NULL;
652         test->dangerous = false;
653
654         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
655
656         return test;
657 }