talloc: use the system pytalloc-util for python3 as well
[sfrench/samba-autobuild/.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 #include "system/dir.h"
27
28
29 struct torture_results *torture_results_init(TALLOC_CTX *mem_ctx, const struct torture_ui_ops *ui_ops)
30 {
31         struct torture_results *results = talloc_zero(mem_ctx, struct torture_results);
32
33         results->ui_ops = ui_ops;
34         results->returncode = true;
35
36         if (ui_ops->init)
37                 ui_ops->init(results);
38
39         return results;
40 }
41
42 /**
43  * Initialize a torture context
44  */
45 struct torture_context *torture_context_init(struct tevent_context *event_ctx, 
46                                                                                          struct torture_results *results)
47 {
48         struct torture_context *torture = talloc_zero(event_ctx, 
49                                                       struct torture_context);
50
51         if (torture == NULL)
52                 return NULL;
53
54         torture->ev = event_ctx;
55         torture->results = talloc_reference(torture, results);
56
57         return torture;
58 }
59
60 /**
61  * Create a sub torture context
62  */
63 struct torture_context *torture_context_child(struct torture_context *parent)
64 {
65         struct torture_context *subtorture = talloc_zero(parent, struct torture_context);
66
67         if (subtorture == NULL)
68                 return NULL;
69
70         subtorture->ev = talloc_reference(subtorture, parent->ev);
71         subtorture->lp_ctx = talloc_reference(subtorture, parent->lp_ctx);
72         subtorture->outputdir = talloc_reference(subtorture, parent->outputdir);
73         subtorture->results = talloc_reference(subtorture, parent->results);
74
75         return subtorture;
76 }
77
78 /**
79  create a temporary directory under the output dir
80 */
81 _PUBLIC_ NTSTATUS torture_temp_dir(struct torture_context *tctx,
82                                    const char *prefix, 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_common(errno);
92         }
93
94         return NT_STATUS_OK;
95 }
96
97 static int local_deltree(const char *path)
98 {
99         int ret = 0;
100         struct dirent *dirent;
101         DIR *dir = opendir(path);
102         if (!dir) {
103                 char *error = talloc_asprintf(NULL, "Could not open directory %s", path);
104                 perror(error);
105                 talloc_free(error);
106                 return -1;
107         }
108         while ((dirent = readdir(dir))) {
109                 char *name;
110                 if ((strcmp(dirent->d_name, ".") == 0) || (strcmp(dirent->d_name, "..") == 0)) {
111                         continue;
112                 }
113                 name = talloc_asprintf(NULL, "%s/%s", path,
114                                        dirent->d_name);
115                 if (name == NULL) {
116                         closedir(dir);
117                         return -1;
118                 }
119                 DEBUG(0, ("About to remove %s\n", name));
120                 ret = remove(name);
121                 if (ret == 0) {
122                         talloc_free(name);
123                         continue;
124                 }
125
126                 if (errno == ENOTEMPTY) {
127                         ret = local_deltree(name);
128                         if (ret == 0) {
129                                 ret = remove(name);
130                         }
131                 }
132                 talloc_free(name);
133                 if (ret != 0) {
134                         char *error = talloc_asprintf(NULL, "Could not remove %s", path);
135                         perror(error);
136                         talloc_free(error);
137                         break;
138                 }
139         }
140         closedir(dir);
141         rmdir(path);
142         return ret;
143 }
144
145 _PUBLIC_ NTSTATUS torture_deltree_outputdir(struct torture_context *tctx)
146 {
147         if (tctx->outputdir == NULL) {
148                 return NT_STATUS_OK;
149         }
150         if ((strcmp(tctx->outputdir, "/") == 0)
151             || (strcmp(tctx->outputdir, "") == 0)) {
152                 return NT_STATUS_INVALID_PARAMETER;
153         }
154
155         if (local_deltree(tctx->outputdir) == -1) {
156                 if (errno != 0) {
157                         return map_nt_error_from_unix_common(errno);
158                 }
159                 return NT_STATUS_UNSUCCESSFUL;
160         }
161         return NT_STATUS_OK;
162 }
163
164 /**
165  * Comment on the status/progress of a test
166  */
167 void torture_comment(struct torture_context *context, const char *comment, ...)
168 {
169         va_list ap;
170         char *tmp;
171
172         if (!context->results->ui_ops->comment)
173                 return;
174
175         va_start(ap, comment);
176         tmp = talloc_vasprintf(context, comment, ap);
177         va_end(ap);
178
179         context->results->ui_ops->comment(context, tmp);
180
181         talloc_free(tmp);
182 }
183
184 /**
185  * Print a warning about the current test
186  */
187 void torture_warning(struct torture_context *context, const char *comment, ...)
188 {
189         va_list ap;
190         char *tmp;
191
192         if (!context->results->ui_ops->warning)
193                 return;
194
195         va_start(ap, comment);
196         tmp = talloc_vasprintf(context, comment, ap);
197         va_end(ap);
198
199         context->results->ui_ops->warning(context, tmp);
200
201         talloc_free(tmp);
202 }
203
204 /**
205  * Store the result of a torture test.
206  */
207 void torture_result(struct torture_context *context, 
208                     enum torture_result result, const char *fmt, ...)
209 {
210         va_list ap;
211
212         va_start(ap, fmt);
213
214         if (context->last_reason) {
215                 torture_warning(context, "%s", context->last_reason);
216                 talloc_free(context->last_reason);
217         }
218
219         context->last_result = result;
220         context->last_reason = talloc_vasprintf(context, fmt, ap);
221         va_end(ap);
222 }
223
224 /**
225  * Create a new torture suite
226  */
227 struct torture_suite *torture_suite_create(TALLOC_CTX *ctx, const char *name)
228 {
229         struct torture_suite *suite = talloc_zero(ctx, struct torture_suite);
230
231         suite->name = talloc_strdup(suite, name);
232         suite->testcases = NULL;
233         suite->children = NULL;
234
235         return suite;
236 }
237
238 /**
239  * Set the setup() and teardown() functions for a testcase.
240  */
241 void torture_tcase_set_fixture(struct torture_tcase *tcase, 
242                 bool (*setup) (struct torture_context *, void **),
243                 bool (*teardown) (struct torture_context *, void *))
244 {
245         tcase->setup = setup;
246         tcase->teardown = teardown;
247 }
248
249 static bool wrap_test_with_testcase_const(struct torture_context *torture_ctx,
250                                     struct torture_tcase *tcase,
251                                     struct torture_test *test)
252 {
253         bool (*fn) (struct torture_context *,
254                     const void *tcase_data,
255                     const void *test_data);
256
257         fn = test->fn;
258
259         return fn(torture_ctx, tcase->data, test->data);
260 }
261
262 /**
263  * Add a test that uses const data to a testcase
264  */
265 struct torture_test *torture_tcase_add_test_const(struct torture_tcase *tcase,
266                 const char *name,
267                 bool (*run) (struct torture_context *, const void *tcase_data,
268                         const void *test_data),
269                 const void *data)
270 {
271         struct torture_test *test = talloc(tcase, struct torture_test);
272
273         test->name = talloc_strdup(test, name);
274         test->description = NULL;
275         test->run = wrap_test_with_testcase_const;
276         test->fn = run;
277         test->dangerous = false;
278         test->data = data;
279
280         DLIST_ADD_END(tcase->tests, test);
281
282         return test;
283 }
284
285 /**
286  * Add a new testcase
287  */
288 bool torture_suite_init_tcase(struct torture_suite *suite, 
289                               struct torture_tcase *tcase, 
290                               const char *name)
291 {
292         tcase->name = talloc_strdup(tcase, name);
293         tcase->description = NULL;
294         tcase->setup = NULL;
295         tcase->teardown = NULL;
296         tcase->fixture_persistent = true;
297         tcase->tests = NULL;
298
299         DLIST_ADD_END(suite->testcases, tcase);
300
301         return true;
302 }
303
304
305 struct torture_tcase *torture_suite_add_tcase(struct torture_suite *suite, 
306                                                          const char *name)
307 {
308         struct torture_tcase *tcase = talloc(suite, struct torture_tcase);
309
310         if (!torture_suite_init_tcase(suite, tcase, name))
311                 return NULL;
312
313         return tcase;
314 }
315
316 int torture_suite_children_count(const struct torture_suite *suite)
317 {
318         int ret = 0;
319         struct torture_tcase *tcase;
320         struct torture_test *test;
321         struct torture_suite *tsuite;
322         for (tcase = suite->testcases; tcase; tcase = tcase->next) {
323                 for (test = tcase->tests; test; test = test->next) {
324                         ret++;
325                 }
326         }
327         for (tsuite = suite->children; tsuite; tsuite = tsuite->next) {
328                 ret ++;
329         }
330         return ret;
331 }
332
333 /**
334  * Run a torture test suite.
335  */
336 bool torture_run_suite(struct torture_context *context, 
337                        struct torture_suite *suite)
338 {
339         return torture_run_suite_restricted(context, suite, NULL);
340 }
341
342 bool torture_run_suite_restricted(struct torture_context *context, 
343                        struct torture_suite *suite, const char **restricted)
344 {
345         bool ret = true;
346         struct torture_tcase *tcase;
347         struct torture_suite *tsuite;
348
349         if (context->results->ui_ops->suite_start)
350                 context->results->ui_ops->suite_start(context, suite);
351
352         /* FIXME: Adjust torture_suite_children_count if restricted != NULL */
353         context->results->ui_ops->progress(context,
354                 torture_suite_children_count(suite), TORTURE_PROGRESS_SET);
355
356         for (tcase = suite->testcases; tcase; tcase = tcase->next) {
357                 ret &= torture_run_tcase_restricted(context, tcase, restricted);
358         }
359
360         for (tsuite = suite->children; tsuite; tsuite = tsuite->next) {
361                 context->results->ui_ops->progress(context, 0, TORTURE_PROGRESS_PUSH);
362                 ret &= torture_run_suite_restricted(context, tsuite, restricted);
363                 context->results->ui_ops->progress(context, 0, TORTURE_PROGRESS_POP);
364         }
365
366         if (context->results->ui_ops->suite_finish)
367                 context->results->ui_ops->suite_finish(context, suite);
368
369         return ret;
370 }
371
372 void torture_ui_test_start(struct torture_context *context, 
373                            struct torture_tcase *tcase, 
374                            struct torture_test *test)
375 {
376         if (context->results->ui_ops->test_start)
377                 context->results->ui_ops->test_start(context, tcase, test);
378 }
379
380 void torture_ui_test_result(struct torture_context *context, 
381                             enum torture_result result,
382                             const char *comment)
383 {
384         if (context->results->ui_ops->test_result)
385                 context->results->ui_ops->test_result(context, result, comment);
386
387         if (result == TORTURE_ERROR || result == TORTURE_FAIL)
388                 context->results->returncode = false;
389 }
390
391 static bool test_needs_running(const char *name, const char **restricted)
392 {
393         int i;
394         if (restricted == NULL)
395                 return true;
396         for (i = 0; restricted[i]; i++) {
397                 if (!strcmp(name, restricted[i]))
398                         return true;
399         }
400         return false;
401 }
402
403 static bool internal_torture_run_test(struct torture_context *context,
404                                           struct torture_tcase *tcase,
405                                           struct torture_test *test,
406                                           bool already_setup,
407                                           const char **restricted)
408 {
409         bool success;
410         char *subunit_testname = NULL;
411
412         if (tcase == NULL || strcmp(test->name, tcase->name) != 0) {
413                 subunit_testname = talloc_asprintf(context, "%s.%s", tcase->name, test->name);
414         } else {
415                 subunit_testname = talloc_strdup(context, test->name);
416         }
417
418         if (!test_needs_running(subunit_testname, restricted))
419                 return true;
420
421         context->active_tcase = tcase;
422         context->active_test = test;
423
424         torture_ui_test_start(context, tcase, test);
425
426         context->last_reason = NULL;
427         context->last_result = TORTURE_OK;
428
429         if (!already_setup && tcase->setup &&
430             !tcase->setup(context, &(tcase->data))) {
431                 if (context->last_reason == NULL)
432                         context->last_reason = talloc_strdup(context, "Setup failure");
433                 context->last_result = TORTURE_ERROR;
434                 success = false;
435         } else if (test->dangerous &&
436                    !torture_setting_bool(context, "dangerous", false)) {
437                 context->last_result = TORTURE_SKIP;
438                 context->last_reason = talloc_asprintf(context,
439                 "disabled %s - enable dangerous tests to use", test->name);
440                 success = true;
441         } else {
442                 success = test->run(context, tcase, test);
443
444                 if (!success && context->last_result == TORTURE_OK) {
445                         if (context->last_reason == NULL)
446                                 context->last_reason = talloc_strdup(context,
447                                         "Unknown error/failure. Missing torture_fail() or torture_assert_*() call?");
448                         context->last_result = TORTURE_ERROR;
449                 }
450         }
451
452         if (!already_setup && tcase->teardown && !tcase->teardown(context, tcase->data)) {
453                 if (context->last_reason == NULL)
454                         context->last_reason = talloc_strdup(context, "Setup failure");
455                 context->last_result = TORTURE_ERROR;
456                 success = false;
457         }
458
459         torture_ui_test_result(context, context->last_result,
460                                context->last_reason);
461
462         talloc_free(context->last_reason);
463         context->last_reason = NULL;
464
465         context->active_test = NULL;
466         context->active_tcase = NULL;
467
468         return success;
469 }
470
471 bool torture_run_tcase(struct torture_context *context,
472                        struct torture_tcase *tcase)
473 {
474         return torture_run_tcase_restricted(context, tcase, NULL);
475 }
476
477 bool torture_run_tcase_restricted(struct torture_context *context,
478                        struct torture_tcase *tcase, const char **restricted)
479 {
480         bool ret = true;
481         struct torture_test *test;
482         bool setup_succeeded = true;
483         const char * setup_reason = "Setup failed";
484
485         context->active_tcase = tcase;
486         if (context->results->ui_ops->tcase_start) 
487                 context->results->ui_ops->tcase_start(context, tcase);
488
489         if (tcase->fixture_persistent && tcase->setup) {
490                 setup_succeeded = tcase->setup(context, &tcase->data);
491         }
492
493         if (!setup_succeeded) {
494                 /* Uh-oh. The setup failed, so we can't run any of the tests
495                  * in this testcase. The subunit format doesn't specify what
496                  * to do here, so we keep the failure reason, and manually
497                  * use it to fail every test.
498                  */
499                 if (context->last_reason != NULL) {
500                         setup_reason = talloc_asprintf(context,
501                                 "Setup failed: %s", context->last_reason);
502                 }
503         }
504
505         for (test = tcase->tests; test; test = test->next) {
506                 if (setup_succeeded) {
507                         ret &= internal_torture_run_test(context, tcase, test,
508                                         tcase->fixture_persistent, restricted);
509                 } else {
510                         context->active_tcase = tcase;
511                         context->active_test = test;
512                         torture_ui_test_start(context, tcase, test);
513                         torture_ui_test_result(context, TORTURE_FAIL, setup_reason);
514                 }
515         }
516
517         if (setup_succeeded && tcase->fixture_persistent && tcase->teardown &&
518                 !tcase->teardown(context, tcase->data)) {
519                 ret = false;
520         }
521
522         context->active_tcase = NULL;
523         context->active_test = NULL;
524
525         if (context->results->ui_ops->tcase_finish)
526                 context->results->ui_ops->tcase_finish(context, tcase);
527
528         return (!setup_succeeded) ? false : ret;
529 }
530
531 bool torture_run_test(struct torture_context *context, 
532                                           struct torture_tcase *tcase,
533                                           struct torture_test *test)
534 {
535         return internal_torture_run_test(context, tcase, test, false, NULL);
536 }
537
538 bool torture_run_test_restricted(struct torture_context *context, 
539                                           struct torture_tcase *tcase,
540                                           struct torture_test *test,
541                                           const char **restricted)
542 {
543         return internal_torture_run_test(context, tcase, test, false, restricted);
544 }
545
546 int torture_setting_int(struct torture_context *test, const char *name, 
547                                                         int default_value)
548 {
549         return lpcfg_parm_int(test->lp_ctx, NULL, "torture", name, default_value);
550 }
551
552 unsigned long torture_setting_ulong(struct torture_context *test,
553                                     const char *name,
554                                     unsigned long default_value)
555 {
556         return lpcfg_parm_ulong(test->lp_ctx, NULL, "torture", name,
557                              default_value);
558 }
559
560 double torture_setting_double(struct torture_context *test, const char *name, 
561                                                         double default_value)
562 {
563         return lpcfg_parm_double(test->lp_ctx, NULL, "torture", name, default_value);
564 }
565
566 bool torture_setting_bool(struct torture_context *test, const char *name, 
567                                                         bool default_value)
568 {
569         return lpcfg_parm_bool(test->lp_ctx, NULL, "torture", name, default_value);
570 }
571
572 const char *torture_setting_string(struct torture_context *test, 
573                                    const char *name, 
574                                    const char *default_value)
575 {
576         const char *ret;
577
578         SMB_ASSERT(test != NULL);
579         SMB_ASSERT(test->lp_ctx != NULL);
580         
581         ret = lpcfg_parm_string(test->lp_ctx, NULL, "torture", name);
582
583         if (ret == NULL)
584                 return default_value;
585
586         return ret;
587 }
588
589 static bool wrap_test_with_simple_tcase_const (
590                 struct torture_context *torture_ctx,
591                 struct torture_tcase *tcase,
592                 struct torture_test *test)
593 {
594         bool (*fn) (struct torture_context *, const void *tcase_data);
595
596         fn = test->fn;
597
598         return fn(torture_ctx, test->data);
599 }
600
601 struct torture_tcase *torture_suite_add_simple_tcase_const(
602                 struct torture_suite *suite, const char *name,
603                 bool (*run) (struct torture_context *test, const void *),
604                 const void *data)
605 {
606         struct torture_tcase *tcase;
607         struct torture_test *test;
608
609         tcase = torture_suite_add_tcase(suite, name);
610
611         test = talloc(tcase, struct torture_test);
612
613         test->name = talloc_strdup(test, name);
614         test->description = NULL;
615         test->run = wrap_test_with_simple_tcase_const;
616         test->fn = run;
617         test->data = data;
618         test->dangerous = false;
619
620         DLIST_ADD_END(tcase->tests, test);
621
622         return tcase;
623 }
624
625 static bool wrap_simple_test(struct torture_context *torture_ctx,
626                              struct torture_tcase *tcase,
627                              struct torture_test *test)
628 {
629         bool (*fn) (struct torture_context *);
630
631         fn = test->fn;
632
633         return fn(torture_ctx);
634 }
635
636 struct torture_tcase *torture_suite_add_simple_test(
637                                         struct torture_suite *suite, 
638                                         const char *name,
639                                         bool (*run) (struct torture_context *test))
640 {
641         struct torture_test *test; 
642         struct torture_tcase *tcase;
643         
644         tcase = torture_suite_add_tcase(suite, name);
645
646         test = talloc(tcase, struct torture_test);
647
648         test->name = talloc_strdup(test, name);
649         test->description = NULL;
650         test->run = wrap_simple_test;
651         test->fn = run;
652         test->dangerous = false;
653
654         DLIST_ADD_END(tcase->tests, test);
655
656         return tcase;
657 }
658
659 /**
660  * Add a child testsuite to a testsuite.
661  */
662 bool torture_suite_add_suite(struct torture_suite *suite, 
663                              struct torture_suite *child)
664 {
665         if (child == NULL)
666                 return false;
667
668         DLIST_ADD_END(suite->children, child);
669
670         /* FIXME: Check for duplicates and return false if the 
671          * added suite already exists as a child */
672
673         return true;
674 }
675
676 /**
677  * Find the child testsuite with the specified name.
678  */
679 struct torture_suite *torture_find_suite(struct torture_suite *parent, 
680                                          const char *name)
681 {
682         struct torture_suite *child;
683
684         for (child = parent->children; child; child = child->next) 
685                 if (!strcmp(child->name, name))
686                         return child;
687
688         return NULL;
689 }
690
691 static bool wrap_test_with_simple_test_const(struct torture_context *torture_ctx,
692                                        struct torture_tcase *tcase,
693                                        struct torture_test *test)
694 {
695         bool (*fn) (struct torture_context *, const void *tcase_data);
696
697         fn = test->fn;
698
699         return fn(torture_ctx, tcase->data);
700 }
701
702 struct torture_test *torture_tcase_add_simple_test_const(
703                 struct torture_tcase *tcase,
704                 const char *name,
705                 bool (*run) (struct torture_context *test,
706                         const void *tcase_data))
707 {
708         struct torture_test *test;
709
710         test = talloc(tcase, struct torture_test);
711
712         test->name = talloc_strdup(test, name);
713         test->description = NULL;
714         test->run = wrap_test_with_simple_test_const;
715         test->fn = run;
716         test->data = NULL;
717         test->dangerous = false;
718
719         DLIST_ADD_END(tcase->tests, test);
720
721         return test;
722 }
723
724 static bool wrap_test_with_simple_test(struct torture_context *torture_ctx,
725                                        struct torture_tcase *tcase,
726                                        struct torture_test *test)
727 {
728         bool (*fn) (struct torture_context *, void *tcase_data);
729
730         fn = test->fn;
731
732         return fn(torture_ctx, tcase->data);
733 }
734
735 struct torture_test *torture_tcase_add_simple_test(struct torture_tcase *tcase,
736                 const char *name,
737                 bool (*run) (struct torture_context *test, void *tcase_data))
738 {
739         struct torture_test *test;
740
741         test = talloc(tcase, struct torture_test);
742
743         test->name = talloc_strdup(test, name);
744         test->description = NULL;
745         test->run = wrap_test_with_simple_test;
746         test->fn = run;
747         test->data = NULL;
748         test->dangerous = false;
749
750         DLIST_ADD_END(tcase->tests, test);
751
752         return test;
753 }
754
755 void torture_ui_report_time(struct torture_context *context)
756 {
757         if (context->results->ui_ops->report_time)
758                 context->results->ui_ops->report_time(context);
759 }