talloc: Documented talloc with doxygen.
[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->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 /**
249  * Run a torture test suite.
250  */
251 bool torture_run_suite(struct torture_context *context, 
252                        struct torture_suite *suite)
253 {
254         bool ret = true;
255         struct torture_tcase *tcase;
256         struct torture_suite *tsuite;
257         char *old_testname;
258
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         return ret;
284 }
285
286 void torture_ui_test_start(struct torture_context *context, 
287                            struct torture_tcase *tcase, 
288                            struct torture_test *test)
289 {
290         if (context->results->ui_ops->test_start)
291                 context->results->ui_ops->test_start(context, tcase, test);
292 }
293
294 void torture_ui_test_result(struct torture_context *context, 
295                             enum torture_result result,
296                             const char *comment)
297 {
298         if (context->results->ui_ops->test_result)
299                 context->results->ui_ops->test_result(context, result, comment);
300
301         if (result == TORTURE_ERROR || result == TORTURE_FAIL)
302                 context->results->returncode = false;
303 }
304
305 static bool internal_torture_run_test(struct torture_context *context, 
306                                           struct torture_tcase *tcase,
307                                           struct torture_test *test,
308                                           bool already_setup)
309 {
310         bool success;
311         char *old_testname = NULL;
312
313         if (tcase == NULL || strcmp(test->name, tcase->name) != 0) { 
314                 old_testname = context->active_testname;
315                 context->active_testname = talloc_asprintf(context, "%s-%s", old_testname, test->name);
316         }
317
318         context->active_tcase = tcase;
319         context->active_test = test;
320
321         torture_ui_test_start(context, tcase, test);
322
323         context->last_reason = NULL;
324         context->last_result = TORTURE_OK;
325
326         if (!already_setup && tcase->setup && 
327                 !tcase->setup(context, &(tcase->data))) {
328                 if (context->last_reason == NULL)
329                         context->last_reason = talloc_strdup(context, "Setup failure");
330                 context->last_result = TORTURE_ERROR;
331                 success = false;
332         } else if (test->dangerous && 
333             !torture_setting_bool(context, "dangerous", false)) {
334             context->last_result = TORTURE_SKIP;
335             context->last_reason = talloc_asprintf(context, 
336                 "disabled %s - enable dangerous tests to use", test->name);
337             success = true;
338         } else {
339             success = test->run(context, tcase, test);
340
341             if (!success && context->last_result == TORTURE_OK) {
342                     if (context->last_reason == NULL)
343                             context->last_reason = talloc_strdup(context, "Unknown error/failure");
344                     context->last_result = TORTURE_ERROR;
345             }
346         }
347
348         if (!already_setup && tcase->teardown && !tcase->teardown(context, tcase->data)) {
349                 if (context->last_reason == NULL)
350                     context->last_reason = talloc_strdup(context, "Setup failure");
351                 context->last_result = TORTURE_ERROR;
352                 success = false;
353         }
354
355         torture_ui_test_result(context, context->last_result, 
356                                context->last_reason);
357         
358         talloc_free(context->last_reason);
359
360         if (tcase == NULL || strcmp(test->name, tcase->name) != 0) { 
361                 talloc_free(context->active_testname);
362                 context->active_testname = old_testname;
363         }
364         context->active_test = NULL;
365         context->active_tcase = NULL;
366
367         return success;
368 }
369
370 bool torture_run_tcase(struct torture_context *context, 
371                        struct torture_tcase *tcase)
372 {
373         bool ret = true;
374         char *old_testname;
375         struct torture_test *test;
376
377         context->active_tcase = tcase;
378         if (context->results->ui_ops->tcase_start) 
379                 context->results->ui_ops->tcase_start(context, tcase);
380
381         if (tcase->fixture_persistent && tcase->setup 
382                 && !tcase->setup(context, &tcase->data)) {
383                 /* FIXME: Use torture ui ops for reporting this error */
384                 fprintf(stderr, "Setup failed: ");
385                 if (context->last_reason != NULL)
386                         fprintf(stderr, "%s", context->last_reason);
387                 fprintf(stderr, "\n");
388                 ret = false;
389                 goto done;
390         }
391
392         old_testname = context->active_testname;
393         context->active_testname = talloc_asprintf(context, "%s-%s", 
394                                                    old_testname, tcase->name);
395         for (test = tcase->tests; test; test = test->next) {
396                 ret &= internal_torture_run_test(context, tcase, test, 
397                                 tcase->fixture_persistent);
398         }
399         talloc_free(context->active_testname);
400         context->active_testname = old_testname;
401
402         if (tcase->fixture_persistent && tcase->teardown &&
403                 !tcase->teardown(context, tcase->data))
404                 ret = false;
405
406 done:
407         context->active_tcase = NULL;
408
409         if (context->results->ui_ops->tcase_finish)
410                 context->results->ui_ops->tcase_finish(context, tcase);
411
412         return ret;
413 }
414
415 bool torture_run_test(struct torture_context *context, 
416                                           struct torture_tcase *tcase,
417                                           struct torture_test *test)
418 {
419         return internal_torture_run_test(context, tcase, test, false);
420 }
421
422 int torture_setting_int(struct torture_context *test, const char *name, 
423                                                         int default_value)
424 {
425         return lp_parm_int(test->lp_ctx, NULL, "torture", name, default_value);
426 }
427
428 unsigned long torture_setting_ulong(struct torture_context *test,
429                                     const char *name,
430                                     unsigned long default_value)
431 {
432         return lp_parm_ulong(test->lp_ctx, NULL, "torture", name,
433                              default_value);
434 }
435
436 double torture_setting_double(struct torture_context *test, const char *name, 
437                                                         double default_value)
438 {
439         return lp_parm_double(test->lp_ctx, NULL, "torture", name, default_value);
440 }
441
442 bool torture_setting_bool(struct torture_context *test, const char *name, 
443                                                         bool default_value)
444 {
445         return lp_parm_bool(test->lp_ctx, NULL, "torture", name, default_value);
446 }
447
448 const char *torture_setting_string(struct torture_context *test, 
449                                    const char *name, 
450                                    const char *default_value)
451 {
452         const char *ret;
453
454         SMB_ASSERT(test != NULL);
455         SMB_ASSERT(test->lp_ctx != NULL);
456         
457         ret = lp_parm_string(test->lp_ctx, NULL, "torture", name);
458
459         if (ret == NULL)
460                 return default_value;
461
462         return ret;
463 }
464
465 static bool wrap_test_with_simple_tcase_const (
466                 struct torture_context *torture_ctx,
467                 struct torture_tcase *tcase,
468                 struct torture_test *test)
469 {
470         bool (*fn) (struct torture_context *, const void *tcase_data);
471
472         fn = test->fn;
473
474         return fn(torture_ctx, test->data);
475 }
476
477 struct torture_tcase *torture_suite_add_simple_tcase_const(
478                 struct torture_suite *suite, const char *name,
479                 bool (*run) (struct torture_context *test, const void *),
480                 const void *data)
481 {
482         struct torture_tcase *tcase;
483         struct torture_test *test;
484
485         tcase = torture_suite_add_tcase(suite, name);
486
487         test = talloc(tcase, struct torture_test);
488
489         test->name = talloc_strdup(test, name);
490         test->description = NULL;
491         test->run = wrap_test_with_simple_tcase_const;
492         test->fn = run;
493         test->data = data;
494         test->dangerous = false;
495
496         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
497
498         return tcase;
499 }
500
501 static bool wrap_simple_test(struct torture_context *torture_ctx,
502                              struct torture_tcase *tcase,
503                              struct torture_test *test)
504 {
505         bool (*fn) (struct torture_context *);
506
507         fn = test->fn;
508
509         return fn(torture_ctx);
510 }
511
512 struct torture_tcase *torture_suite_add_simple_test(
513                                         struct torture_suite *suite, 
514                                         const char *name,
515                                         bool (*run) (struct torture_context *test))
516 {
517         struct torture_test *test; 
518         struct torture_tcase *tcase;
519         
520         tcase = torture_suite_add_tcase(suite, name);
521
522         test = talloc(tcase, struct torture_test);
523
524         test->name = talloc_strdup(test, name);
525         test->description = NULL;
526         test->run = wrap_simple_test;
527         test->fn = run;
528         test->dangerous = false;
529
530         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
531
532         return tcase;
533 }
534
535 /**
536  * Add a child testsuite to a testsuite.
537  */
538 bool torture_suite_add_suite(struct torture_suite *suite, 
539                              struct torture_suite *child)
540 {
541         if (child == NULL)
542                 return false;
543
544         DLIST_ADD_END(suite->children, child, struct torture_suite *);
545
546         /* FIXME: Check for duplicates and return false if the 
547          * added suite already exists as a child */
548
549         return true;
550 }
551
552 /**
553  * Find the child testsuite with the specified name.
554  */
555 struct torture_suite *torture_find_suite(struct torture_suite *parent, 
556                                          const char *name)
557 {
558         struct torture_suite *child;
559
560         for (child = parent->children; child; child = child->next) 
561                 if (!strcmp(child->name, name))
562                         return child;
563
564         return NULL;
565 }
566
567 static bool wrap_test_with_simple_test_const(struct torture_context *torture_ctx,
568                                        struct torture_tcase *tcase,
569                                        struct torture_test *test)
570 {
571         bool (*fn) (struct torture_context *, const void *tcase_data);
572
573         fn = test->fn;
574
575         return fn(torture_ctx, tcase->data);
576 }
577
578 struct torture_test *torture_tcase_add_simple_test_const(
579                 struct torture_tcase *tcase,
580                 const char *name,
581                 bool (*run) (struct torture_context *test,
582                         const void *tcase_data))
583 {
584         struct torture_test *test;
585
586         test = talloc(tcase, struct torture_test);
587
588         test->name = talloc_strdup(test, name);
589         test->description = NULL;
590         test->run = wrap_test_with_simple_test_const;
591         test->fn = run;
592         test->data = NULL;
593         test->dangerous = false;
594
595         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
596
597         return test;
598 }
599
600 static bool wrap_test_with_simple_test(struct torture_context *torture_ctx,
601                                        struct torture_tcase *tcase,
602                                        struct torture_test *test)
603 {
604         bool (*fn) (struct torture_context *, void *tcase_data);
605
606         fn = test->fn;
607
608         return fn(torture_ctx, tcase->data);
609 }
610
611 struct torture_test *torture_tcase_add_simple_test(struct torture_tcase *tcase,
612                 const char *name,
613                 bool (*run) (struct torture_context *test, void *tcase_data))
614 {
615         struct torture_test *test;
616
617         test = talloc(tcase, struct torture_test);
618
619         test->name = talloc_strdup(test, name);
620         test->description = NULL;
621         test->run = wrap_test_with_simple_test;
622         test->fn = run;
623         test->data = NULL;
624         test->dangerous = false;
625
626         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
627
628         return test;
629 }