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