tsocket/bsd: more correctly check if the cached tevent_fd is still valid
[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         va_end(ap);
111                 
112         context->results->ui_ops->comment(context, tmp);
113         
114         talloc_free(tmp);
115 }
116
117 /**
118  * Print a warning about the current test
119  */
120 void torture_warning(struct torture_context *context, const char *comment, ...)
121 {
122         va_list ap;
123         char *tmp;
124
125         if (!context->results->ui_ops->warning)
126                 return;
127
128         va_start(ap, comment);
129         tmp = talloc_vasprintf(context, comment, ap);
130         va_end(ap);
131
132         context->results->ui_ops->warning(context, tmp);
133
134         talloc_free(tmp);
135 }
136
137 /**
138  * Store the result of a torture test.
139  */
140 void torture_result(struct torture_context *context, 
141                     enum torture_result result, const char *fmt, ...)
142 {
143         va_list ap;
144
145         va_start(ap, fmt);
146
147         if (context->last_reason) {
148                 torture_warning(context, "%s", context->last_reason);
149                 talloc_free(context->last_reason);
150         }
151
152         context->last_result = result;
153         context->last_reason = talloc_vasprintf(context, fmt, ap);
154         va_end(ap);
155 }
156
157 /**
158  * Create a new torture suite
159  */
160 struct torture_suite *torture_suite_create(TALLOC_CTX *ctx, const char *name)
161 {
162         struct torture_suite *suite = talloc_zero(ctx, struct torture_suite);
163
164         suite->name = talloc_strdup(suite, name);
165         suite->testcases = NULL;
166         suite->children = NULL;
167
168         return suite;
169 }
170
171 /**
172  * Set the setup() and teardown() functions for a testcase.
173  */
174 void torture_tcase_set_fixture(struct torture_tcase *tcase, 
175                 bool (*setup) (struct torture_context *, void **),
176                 bool (*teardown) (struct torture_context *, void *))
177 {
178         tcase->setup = setup;
179         tcase->teardown = teardown;
180 }
181
182 static bool wrap_test_with_testcase_const(struct torture_context *torture_ctx,
183                                     struct torture_tcase *tcase,
184                                     struct torture_test *test)
185 {
186         bool (*fn) (struct torture_context *,
187                     const void *tcase_data,
188                     const void *test_data);
189
190         fn = test->fn;
191
192         return fn(torture_ctx, tcase->data, test->data);
193 }
194
195 /**
196  * Add a test that uses const data to a testcase
197  */
198 struct torture_test *torture_tcase_add_test_const(struct torture_tcase *tcase,
199                 const char *name,
200                 bool (*run) (struct torture_context *, const void *tcase_data,
201                         const void *test_data),
202                 const void *data)
203 {
204         struct torture_test *test = talloc(tcase, struct torture_test);
205
206         test->name = talloc_strdup(test, name);
207         test->description = NULL;
208         test->run = wrap_test_with_testcase_const;
209         test->fn = run;
210         test->dangerous = false;
211         test->data = data;
212
213         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
214
215         return test;
216 }
217
218 /**
219  * Add a new testcase
220  */
221 bool torture_suite_init_tcase(struct torture_suite *suite, 
222                               struct torture_tcase *tcase, 
223                               const char *name)
224 {
225         tcase->name = talloc_strdup(tcase, name);
226         tcase->description = NULL;
227         tcase->setup = NULL;
228         tcase->teardown = NULL;
229         tcase->fixture_persistent = true;
230         tcase->tests = NULL;
231
232         DLIST_ADD_END(suite->testcases, tcase, struct torture_tcase *);
233
234         return true;
235 }
236
237
238 struct torture_tcase *torture_suite_add_tcase(struct torture_suite *suite, 
239                                                          const char *name)
240 {
241         struct torture_tcase *tcase = talloc(suite, struct torture_tcase);
242
243         if (!torture_suite_init_tcase(suite, tcase, name))
244                 return NULL;
245
246         return tcase;
247 }
248
249 /**
250  * Run a torture test suite.
251  */
252 bool torture_run_suite(struct torture_context *context, 
253                        struct torture_suite *suite)
254 {
255         bool ret = true;
256         struct torture_tcase *tcase;
257         struct torture_suite *tsuite;
258         char *old_testname;
259
260         context->level++;
261         if (context->results->ui_ops->suite_start)
262                 context->results->ui_ops->suite_start(context, suite);
263
264         old_testname = context->active_testname;
265         if (old_testname != NULL)
266                 context->active_testname = talloc_asprintf(context, "%s-%s", 
267                                                            old_testname, suite->name);
268         else
269                 context->active_testname = talloc_strdup(context, suite->name);
270
271         for (tcase = suite->testcases; tcase; tcase = tcase->next) {
272                 ret &= torture_run_tcase(context, tcase);
273         }
274
275         for (tsuite = suite->children; tsuite; tsuite = tsuite->next) {
276                 ret &= torture_run_suite(context, tsuite);
277         }
278
279         talloc_free(context->active_testname);
280         context->active_testname = old_testname;
281
282         if (context->results->ui_ops->suite_finish)
283                 context->results->ui_ops->suite_finish(context, suite);
284
285         context->level--;
286         
287         return ret;
288 }
289
290 void torture_ui_test_start(struct torture_context *context, 
291                            struct torture_tcase *tcase, 
292                            struct torture_test *test)
293 {
294         if (context->results->ui_ops->test_start)
295                 context->results->ui_ops->test_start(context, tcase, test);
296 }
297
298 void torture_ui_test_result(struct torture_context *context, 
299                             enum torture_result result,
300                             const char *comment)
301 {
302         if (context->results->ui_ops->test_result)
303                 context->results->ui_ops->test_result(context, result, comment);
304
305         if (result == TORTURE_ERROR || result == TORTURE_FAIL)
306                 context->results->returncode = false;
307 }
308
309 static bool internal_torture_run_test(struct torture_context *context, 
310                                           struct torture_tcase *tcase,
311                                           struct torture_test *test,
312                                           bool already_setup)
313 {
314         bool success;
315         char *old_testname = NULL;
316
317         if (tcase == NULL || strcmp(test->name, tcase->name) != 0) { 
318                 old_testname = context->active_testname;
319                 context->active_testname = talloc_asprintf(context, "%s-%s", old_testname, test->name);
320         }
321
322         context->active_tcase = tcase;
323         context->active_test = test;
324
325         torture_ui_test_start(context, tcase, test);
326
327         context->last_reason = NULL;
328         context->last_result = TORTURE_OK;
329
330         if (!already_setup && tcase->setup && 
331                 !tcase->setup(context, &(tcase->data))) {
332                 if (context->last_reason == NULL)
333                         context->last_reason = talloc_strdup(context, "Setup failure");
334                 context->last_result = TORTURE_ERROR;
335                 success = false;
336         } else if (test->dangerous && 
337             !torture_setting_bool(context, "dangerous", false)) {
338             context->last_result = TORTURE_SKIP;
339             context->last_reason = talloc_asprintf(context, 
340                 "disabled %s - enable dangerous tests to use", test->name);
341             success = true;
342         } else {
343             success = test->run(context, tcase, test);
344
345             if (!success && context->last_result == TORTURE_OK) {
346                     if (context->last_reason == NULL)
347                             context->last_reason = talloc_strdup(context, "Unknown error/failure");
348                     context->last_result = TORTURE_ERROR;
349             }
350         }
351
352         if (!already_setup && tcase->teardown && !tcase->teardown(context, tcase->data)) {
353                 if (context->last_reason == NULL)
354                     context->last_reason = talloc_strdup(context, "Setup failure");
355                 context->last_result = TORTURE_ERROR;
356                 success = false;
357         }
358
359         torture_ui_test_result(context, context->last_result, 
360                                context->last_reason);
361         
362         talloc_free(context->last_reason);
363
364         if (tcase == NULL || strcmp(test->name, tcase->name) != 0) { 
365                 talloc_free(context->active_testname);
366                 context->active_testname = old_testname;
367         }
368         context->active_test = NULL;
369         context->active_tcase = NULL;
370
371         return success;
372 }
373
374 bool torture_run_tcase(struct torture_context *context, 
375                        struct torture_tcase *tcase)
376 {
377         bool ret = true;
378         char *old_testname;
379         struct torture_test *test;
380
381         context->level++;
382
383         context->active_tcase = tcase;
384         if (context->results->ui_ops->tcase_start) 
385                 context->results->ui_ops->tcase_start(context, tcase);
386
387         if (tcase->fixture_persistent && tcase->setup 
388                 && !tcase->setup(context, &tcase->data)) {
389                 /* FIXME: Use torture ui ops for reporting this error */
390                 fprintf(stderr, "Setup failed: ");
391                 if (context->last_reason != NULL)
392                         fprintf(stderr, "%s", context->last_reason);
393                 fprintf(stderr, "\n");
394                 ret = false;
395                 goto done;
396         }
397
398         old_testname = context->active_testname;
399         context->active_testname = talloc_asprintf(context, "%s-%s", 
400                                                    old_testname, tcase->name);
401         for (test = tcase->tests; test; test = test->next) {
402                 ret &= internal_torture_run_test(context, tcase, test, 
403                                 tcase->fixture_persistent);
404         }
405         talloc_free(context->active_testname);
406         context->active_testname = old_testname;
407
408         if (tcase->fixture_persistent && tcase->teardown &&
409                 !tcase->teardown(context, tcase->data))
410                 ret = false;
411
412 done:
413         context->active_tcase = NULL;
414
415         if (context->results->ui_ops->tcase_finish)
416                 context->results->ui_ops->tcase_finish(context, tcase);
417
418         context->level--;
419
420         return ret;
421 }
422
423 bool torture_run_test(struct torture_context *context, 
424                                           struct torture_tcase *tcase,
425                                           struct torture_test *test)
426 {
427         return internal_torture_run_test(context, tcase, test, false);
428 }
429
430 int torture_setting_int(struct torture_context *test, const char *name, 
431                                                         int default_value)
432 {
433         return lp_parm_int(test->lp_ctx, NULL, "torture", name, 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 }