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