Refactor the dns_open_connection code so that duplicate code is removed and ensure...
[sfrench/samba-autobuild/.git] / lib / torture / torture.h
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 #ifndef __TORTURE_UI_H__
22 #define __TORTURE_UI_H__
23
24 struct torture_test;
25 struct torture_context;
26 struct torture_suite;
27 struct torture_tcase;
28 struct torture_results;
29
30 enum torture_result { 
31         TORTURE_OK=0, 
32         TORTURE_FAIL=1,
33         TORTURE_ERROR=2,
34         TORTURE_SKIP=3
35 };
36
37 enum torture_progress_whence {
38         TORTURE_PROGRESS_SET,
39         TORTURE_PROGRESS_CUR,
40         TORTURE_PROGRESS_POP,
41         TORTURE_PROGRESS_PUSH,
42 };
43
44 /* 
45  * These callbacks should be implemented by any backend that wishes 
46  * to listen to reports from the torture tests.
47  */
48 struct torture_ui_ops
49 {
50         void (*init) (struct torture_results *);
51         void (*comment) (struct torture_context *, const char *);
52         void (*warning) (struct torture_context *, const char *);
53         void (*suite_start) (struct torture_context *, struct torture_suite *);
54         void (*suite_finish) (struct torture_context *, struct torture_suite *);
55         void (*tcase_start) (struct torture_context *, struct torture_tcase *); 
56         void (*tcase_finish) (struct torture_context *, struct torture_tcase *);
57         void (*test_start) (struct torture_context *, 
58                                                 struct torture_tcase *,
59                                                 struct torture_test *);
60         void (*test_result) (struct torture_context *, 
61                                                  enum torture_result, const char *reason);
62         void (*progress) (struct torture_context *, int offset, enum torture_progress_whence whence);
63         void (*report_time) (struct torture_context *);
64 };
65
66 void torture_ui_test_start(struct torture_context *context,
67                                                            struct torture_tcase *tcase,
68                                                            struct torture_test *test);
69
70 void torture_ui_test_result(struct torture_context *context,
71                                                                 enum torture_result result,
72                                                                 const char *comment);
73
74 void torture_ui_report_time(struct torture_context *context);
75
76 /*
77  * Holds information about a specific run of the testsuite. 
78  * The data in this structure should be considered private to 
79  * the torture tests and should only be used directly by the torture 
80  * code and the ui backends.
81  *
82  * Torture tests should instead call the torture_*() macros and functions 
83  * specified below.
84  */
85
86 struct torture_context
87 {
88         struct torture_results *results;
89
90         struct torture_test *active_test;
91         struct torture_tcase *active_tcase;
92
93         enum torture_result last_result;
94         char *last_reason;
95
96         /** Directory used for temporary test data */
97         const char *outputdir;
98
99         /** Event context */
100         struct tevent_context *ev;
101
102         /** Loadparm context (will go away in favor of torture_setting_ at some point) */
103         struct loadparm_context *lp_ctx;
104 };
105
106 struct torture_results
107 {
108         const struct torture_ui_ops *ui_ops;
109         void *ui_data;
110
111         /** Whether tests should avoid writing output to stdout */
112         bool quiet;
113
114         bool returncode;
115 };
116
117 /* 
118  * Describes a particular torture test
119  */
120 struct torture_test {
121         /** Short unique name for the test. */
122         const char *name;
123
124         /** Long description for the test. */
125         const char *description;
126
127         /** Whether this is a dangerous test 
128          * (can corrupt the remote servers data or bring it down). */
129         bool dangerous;
130
131         /** Function to call to run this test */
132         bool (*run) (struct torture_context *torture_ctx, 
133                                  struct torture_tcase *tcase,
134                                  struct torture_test *test);
135
136         struct torture_test *prev, *next;
137
138         /** Pointer to the actual test function. This is run by the 
139           * run() function above. */
140         void *fn;
141
142         /** Use data for this test */
143         const void *data;
144 };
145
146 /* 
147  * Describes a particular test case.
148  */
149 struct torture_tcase {
150     const char *name;
151         const char *description;
152         bool (*setup) (struct torture_context *tcase, void **data);
153         bool (*teardown) (struct torture_context *tcase, void *data); 
154         bool fixture_persistent;
155         void *data;
156         struct torture_test *tests;
157         struct torture_tcase *prev, *next;
158 };
159
160 struct torture_suite
161 {
162         const char *name;
163         const char *description;
164         struct torture_tcase *testcases;
165         struct torture_suite *children;
166
167         /* Pointers to siblings of this torture suite */
168         struct torture_suite *prev, *next;
169 };
170
171 /** Create a new torture suite */
172 struct torture_suite *torture_suite_create(TALLOC_CTX *mem_ctx,
173                 const char *name);
174
175 /** Change the setup and teardown functions for a testcase */
176 void torture_tcase_set_fixture(struct torture_tcase *tcase,
177                 bool (*setup) (struct torture_context *, void **),
178                 bool (*teardown) (struct torture_context *, void *));
179
180 /* Add another test to run for a particular testcase */
181 struct torture_test *torture_tcase_add_test_const(struct torture_tcase *tcase,
182                 const char *name,
183                 bool (*run) (struct torture_context *test,
184                         const void *tcase_data, const void *test_data),
185                 const void *test_data);
186
187 /* Add a testcase to a testsuite */
188 struct torture_tcase *torture_suite_add_tcase(struct torture_suite *suite,
189                                                          const char *name);
190
191 /* Convenience wrapper that adds a testcase against only one
192  * test will be run */
193 struct torture_tcase *torture_suite_add_simple_tcase_const(
194                 struct torture_suite *suite,
195                 const char *name,
196                 bool (*run) (struct torture_context *test,
197                         const void *test_data),
198                 const void *data);
199
200 /* Convenience function that adds a test which only
201  * gets the test case data */
202 struct torture_test *torture_tcase_add_simple_test_const(
203                 struct torture_tcase *tcase,
204                 const char *name,
205                 bool (*run) (struct torture_context *test,
206                         const void *tcase_data));
207
208 /* Convenience wrapper that adds a test that doesn't need any
209  * testcase data */
210 struct torture_tcase *torture_suite_add_simple_test(
211                 struct torture_suite *suite,
212                 const char *name,
213                 bool (*run) (struct torture_context *test));
214
215 /* Add a child testsuite to an existing testsuite */
216 bool torture_suite_add_suite(struct torture_suite *suite,
217                 struct torture_suite *child);
218
219 /* Run the specified testsuite recursively */
220 bool torture_run_suite(struct torture_context *context,
221                                            struct torture_suite *suite);
222
223 /* Run the specified testsuite recursively, but only the specified 
224  * tests */
225 bool torture_run_suite_restricted(struct torture_context *context, 
226                        struct torture_suite *suite, const char **restricted);
227
228 /* Run the specified testcase */
229 bool torture_run_tcase(struct torture_context *context,
230                                            struct torture_tcase *tcase);
231
232 bool torture_run_tcase_restricted(struct torture_context *context, 
233                        struct torture_tcase *tcase, const char **restricted);
234
235 /* Run the specified test */
236 bool torture_run_test(struct torture_context *context,
237                                           struct torture_tcase *tcase,
238                                           struct torture_test *test);
239
240 bool torture_run_test_restricted(struct torture_context *context,
241                                           struct torture_tcase *tcase,
242                                           struct torture_test *test,
243                                           const char **restricted);
244
245 void torture_comment(struct torture_context *test, const char *comment, ...) PRINTF_ATTRIBUTE(2,3);
246 void torture_warning(struct torture_context *test, const char *comment, ...) PRINTF_ATTRIBUTE(2,3);
247 void torture_result(struct torture_context *test,
248                         enum torture_result, const char *reason, ...) PRINTF_ATTRIBUTE(3,4);
249
250 #define torture_assert(torture_ctx,expr,cmt) \
251         if (!(expr)) { \
252                 torture_result(torture_ctx, TORTURE_FAIL, __location__": Expression `%s' failed: %s", __STRING(expr), cmt); \
253                 return false; \
254         }
255
256 #define torture_assert_goto(torture_ctx,expr,ret,label,cmt) \
257         if (!(expr)) { \
258                 torture_result(torture_ctx, TORTURE_FAIL, __location__": Expression `%s' failed: %s", __STRING(expr), cmt); \
259                 ret = false; \
260                 goto label; \
261         }
262
263 #define torture_assert_werr_equal(torture_ctx, got, expected, cmt) \
264         do { WERROR __got = got, __expected = expected; \
265         if (!W_ERROR_EQUAL(__got, __expected)) { \
266                 torture_result(torture_ctx, TORTURE_FAIL, __location__": "#got" was %s, expected %s: %s", win_errstr(__got), win_errstr(__expected), cmt); \
267                 return false; \
268         } \
269         } while (0)
270
271 #define torture_assert_ntstatus_equal(torture_ctx,got,expected,cmt) \
272         do { NTSTATUS __got = got, __expected = expected; \
273         if (!NT_STATUS_EQUAL(__got, __expected)) { \
274                 torture_result(torture_ctx, TORTURE_FAIL, __location__": "#got" was %s, expected %s: %s", nt_errstr(__got), nt_errstr(__expected), cmt); \
275                 return false; \
276         }\
277         } while(0)
278
279 #define torture_assert_ntstatus_equal_goto(torture_ctx,got,expected,ret,label,cmt) \
280         do { NTSTATUS __got = got, __expected = expected; \
281         if (!NT_STATUS_EQUAL(__got, __expected)) { \
282                 torture_result(torture_ctx, TORTURE_FAIL, __location__": "#got" was %s, expected %s: %s", nt_errstr(__got), nt_errstr(__expected), cmt); \
283                 ret = false; \
284                 goto label; \
285         }\
286         } while(0)
287
288 #define torture_assert_ndr_err_equal(torture_ctx,got,expected,cmt) \
289         do { enum ndr_err_code __got = got, __expected = expected; \
290         if (__got != __expected) { \
291                 torture_result(torture_ctx, TORTURE_FAIL, __location__": "#got" was %d (%s), expected %d (%s): %s", __got, ndr_errstr(__got), __expected, __STRING(expected), cmt); \
292                 return false; \
293         }\
294         } while(0)
295
296 #define torture_assert_hresult_equal(torture_ctx, got, expected, cmt) \
297         do { HRESULT __got = got, __expected = expected; \
298         if (!HRES_IS_EQUAL(__got, __expected)) { \
299                 torture_result(torture_ctx, TORTURE_FAIL, __location__": "#got" was %s, expected %s: %s", hresult_errstr(__got), hresult_errstr(__expected), cmt); \
300                 return false; \
301         } \
302         } while (0)
303
304 #define torture_assert_casestr_equal(torture_ctx,got,expected,cmt) \
305         do { const char *__got = (got), *__expected = (expected); \
306         if (!strequal(__got, __expected)) { \
307                 torture_result(torture_ctx, TORTURE_FAIL, __location__": "#got" was %s, expected %s: %s", __got, __expected, cmt); \
308                 return false; \
309         } \
310         } while(0)
311
312 #define torture_assert_str_equal(torture_ctx,got,expected,cmt)\
313         do { const char *__got = (got), *__expected = (expected); \
314         if (strcmp_safe(__got, __expected) != 0) { \
315                 torture_result(torture_ctx, TORTURE_FAIL, \
316                                            __location__": "#got" was %s, expected %s: %s", \
317                                            __got, __expected, cmt); \
318                 return false; \
319         } \
320         } while(0)
321
322 #define torture_assert_strn_equal(torture_ctx,got,expected,len,cmt)\
323         do { const char *__got = (got), *__expected = (expected); \
324         if (strncmp(__got, __expected, len) != 0) { \
325                 torture_result(torture_ctx, TORTURE_FAIL, \
326                                            __location__": "#got" %s of len %d did not match "#expected" %s: %s", \
327                                            __got, (int)len, __expected, cmt); \
328                 return false; \
329         } \
330         } while(0)
331
332 #define torture_assert_str_equal_goto(torture_ctx,got,expected,ret,label,cmt)\
333         do { const char *__got = (got), *__expected = (expected); \
334         if (strcmp_safe(__got, __expected) != 0) { \
335                 torture_result(torture_ctx, TORTURE_FAIL, \
336                                            __location__": "#got" was %s, expected %s: %s", \
337                                            __got, __expected, cmt); \
338                 ret = false; \
339                 goto label; \
340         } \
341         } while(0)
342
343 #define torture_assert_mem_equal(torture_ctx,got,expected,len,cmt)\
344         do { const void *__got = (got), *__expected = (expected); \
345         if (memcmp(__got, __expected, len) != 0) { \
346                 torture_result(torture_ctx, TORTURE_FAIL, \
347                                __location__": "#got" of len %d did not match "#expected": %s", (int)len, cmt); \
348                 return false; \
349         } \
350         } while(0)
351
352 #define torture_assert_data_blob_equal(torture_ctx,got,expected,cmt)\
353         do { const DATA_BLOB __got = (got), __expected = (expected); \
354         if (__got.length != __expected.length) { \
355                 torture_result(torture_ctx, TORTURE_FAIL, \
356                                __location__": "#got".len %d did not match "#expected" len %d: %s", \
357                                (int)__got.length, (int)__expected.length, cmt); \
358                 return false; \
359         } \
360         if (memcmp(__got.data, __expected.data, __got.length) != 0) { \
361                 torture_result(torture_ctx, TORTURE_FAIL, \
362                                __location__": "#got" of len %d did not match "#expected": %s", (int)__got.length, cmt); \
363                 return false; \
364         } \
365         } while(0)
366
367 #define torture_assert_file_contains_text(torture_ctx,filename,expected,cmt)\
368         do { \
369         char *__got; \
370         const char *__expected = (expected); \
371         size_t __size; \
372         __got = file_load(filename, &__size, 0, torture_ctx); \
373         if (__got == NULL) { \
374                 torture_result(torture_ctx, TORTURE_FAIL, \
375                                __location__": unable to open %s: %s\n", \
376                                filename, cmt); \
377                 return false; \
378         } \
379         \
380         if (strcmp_safe(__got, __expected) != 0) { \
381                 torture_result(torture_ctx, TORTURE_FAIL, \
382                         __location__": %s contained:\n%sExpected: %s%s\n", \
383                         filename, __got, __expected, cmt); \
384                 talloc_free(__got); \
385                 return false; \
386         } \
387         talloc_free(__got); \
388         } while(0)
389
390 #define torture_assert_file_contains(torture_ctx,filename,expected,cmt)\
391         do { const char *__got, *__expected = (expected); \
392         size_t __size; \
393         __got = file_load(filename, *size, 0, torture_ctx); \
394         if (strcmp_safe(__got, __expected) != 0) { \
395                 torture_result(torture_ctx, TORTURE_FAIL, \
396                                            __location__": %s contained:\n%sExpected: %s%s\n", \
397                                            __got, __expected, cmt); \
398                 talloc_free(__got); \
399                 return false; \
400         } \
401         talloc_free(__got); \
402         } while(0)
403
404 #define torture_assert_int_equal(torture_ctx,got,expected,cmt)\
405         do { int __got = (got), __expected = (expected); \
406         if (__got != __expected) { \
407                 torture_result(torture_ctx, TORTURE_FAIL, \
408                         __location__": "#got" was %d (0x%X), expected %d (0x%X): %s", \
409                         __got, __got, __expected, __expected, cmt); \
410                 return false; \
411         } \
412         } while(0)
413
414 #define torture_assert_int_equal_goto(torture_ctx,got,expected,ret,label,cmt)\
415         do { int __got = (got), __expected = (expected); \
416         if (__got != __expected) { \
417                 torture_result(torture_ctx, TORTURE_FAIL, \
418                         __location__": "#got" was %d (0x%X), expected %d (0x%X): %s", \
419                         __got, __got, __expected, __expected, cmt); \
420                 ret = false; \
421                 goto label; \
422         } \
423         } while(0)
424
425 #define torture_assert_int_not_equal(torture_ctx,got,not_expected,cmt)\
426         do { int __got = (got), __not_expected = (not_expected); \
427         if (__got == __not_expected) { \
428                 torture_result(torture_ctx, TORTURE_FAIL, \
429                         __location__": "#got" was %d (0x%X), expected a different number: %s", \
430                         __got, __got, cmt); \
431                 return false; \
432         } \
433         } while(0)
434
435 #define torture_assert_int_not_equal_goto(torture_ctx,got,not_expected,ret,label,cmt)\
436         do { int __got = (got), __not_expected = (not_expected); \
437         if (__got == __not_expected) { \
438                 torture_result(torture_ctx, TORTURE_FAIL, \
439                         __location__": "#got" was %d (0x%X), expected a different number: %s", \
440                         __got, __got, cmt); \
441                 ret = false; \
442                 goto label; \
443         } \
444         } while(0)
445
446 #define torture_assert_u64_equal(torture_ctx,got,expected,cmt)\
447         do { uint64_t __got = (got), __expected = (expected); \
448         if (__got != __expected) { \
449                 torture_result(torture_ctx, TORTURE_FAIL, \
450                         __location__": "#got" was %llu (0x%llX), expected %llu (0x%llX): %s", \
451                         (unsigned long long)__got, (unsigned long long)__got, \
452                         (unsigned long long)__expected, (unsigned long long)__expected, \
453                         cmt); \
454                 return false; \
455         } \
456         } while(0)
457
458 #define torture_assert_u64_equal_goto(torture_ctx,got,expected,ret,label,cmt)\
459         do { uint64_t __got = (got), __expected = (expected); \
460         if (__got != __expected) { \
461                 torture_result(torture_ctx, TORTURE_FAIL, \
462                         __location__": "#got" was %llu (0x%llX), expected %llu (0x%llX): %s", \
463                         (unsigned long long)__got, (unsigned long long)__got, \
464                         (unsigned long long)__expected, (unsigned long long)__expected, \
465                         cmt); \
466                 ret = false; \
467                 goto label; \
468         } \
469         } while(0)
470
471 #define torture_assert_u64_not_equal(torture_ctx,got,not_expected,cmt)\
472         do { uint64_t __got = (got), __not_expected = (not_expected); \
473         if (__got == __not_expected) { \
474                 torture_result(torture_ctx, TORTURE_FAIL, \
475                         __location__": "#got" was %llu (0x%llX), expected a different number: %s", \
476                         (unsigned long long)__got, (unsigned long long)__got, \
477                         cmt); \
478                 return false; \
479         } \
480         } while(0)
481
482 #define torture_assert_u64_not_equal_goto(torture_ctx,got,not_expected,ret,label,cmt)\
483         do { uint64_t __got = (got), __not_expected = (not_expected); \
484         if (__got == __not_expected) { \
485                 torture_result(torture_ctx, TORTURE_FAIL, \
486                         __location__": "#got" was %llu (0x%llX), expected a different number: %s", \
487                         (unsigned long long)__got, (unsigned long long)__got, \
488                         cmt); \
489                 ret = false; \
490                 goto label; \
491         } \
492         } while(0)
493
494 #define torture_assert_errno_equal(torture_ctx,expected,cmt)\
495         do { int __expected = (expected); \
496         if (errno != __expected) { \
497                 torture_result(torture_ctx, TORTURE_FAIL, \
498                         __location__": errno was %d (%s), expected %d: %s: %s", \
499                                            errno, strerror(errno), __expected, \
500                                            strerror(__expected), cmt); \
501                 return false; \
502         } \
503         } while(0)
504
505 #define torture_assert_guid_equal(torture_ctx,got,expected,cmt)\
506         do { struct GUID __got = (got), __expected = (expected); \
507         if (!GUID_equal(&__got, &__expected)) { \
508                 torture_result(torture_ctx, TORTURE_FAIL, \
509                         __location__": "#got" was %s, expected %s: %s", \
510                         GUID_string(torture_ctx, &__got), GUID_string(torture_ctx, &__expected), cmt); \
511                 return false; \
512         } \
513         } while(0)
514
515 #define torture_assert_nttime_equal(torture_ctx,got,expected,cmt) \
516         do { NTTIME __got = got, __expected = expected; \
517         if (!nt_time_equal(&__got, &__expected)) { \
518                 torture_result(torture_ctx, TORTURE_FAIL, __location__": "#got" was %s, expected %s: %s", nt_time_string(tctx, __got), nt_time_string(tctx, __expected), cmt); \
519                 return false; \
520         }\
521         } while(0)
522
523 #define torture_assert_sid_equal(torture_ctx,got,expected,cmt)\
524         do { struct dom_sid *__got = (got), *__expected = (expected); \
525         if (!dom_sid_equal(__got, __expected)) { \
526                 torture_result(torture_ctx, TORTURE_FAIL, \
527                                            __location__": "#got" was %s, expected %s: %s", \
528                                            dom_sid_string(torture_ctx, __got), dom_sid_string(torture_ctx, __expected), cmt); \
529                 return false; \
530         } \
531         } while(0)
532
533 #define torture_assert_not_null(torture_ctx,got,cmt)\
534         do { void *__got = (got); \
535         if (__got == NULL) { \
536                 torture_result(torture_ctx, TORTURE_FAIL, \
537                         __location__": "#got" was NULL, expected != NULL: %s", \
538                         cmt); \
539                 return false; \
540         } \
541         } while(0)
542
543 #define torture_assert_not_null_goto(torture_ctx,got,ret,label,cmt)\
544         do { void *__got = (got); \
545         if (__got == NULL) { \
546                 torture_result(torture_ctx, TORTURE_FAIL, \
547                         __location__": "#got" was NULL, expected != NULL: %s", \
548                         cmt); \
549                 ret = false; \
550                 goto label; \
551         } \
552         } while(0)
553
554 #define torture_skip(torture_ctx,cmt) do {\
555                 torture_result(torture_ctx, TORTURE_SKIP, __location__": %s", cmt);\
556                 return true; \
557         } while(0)
558 #define torture_skip_goto(torture_ctx,label,cmt) do {\
559                 torture_result(torture_ctx, TORTURE_SKIP, __location__": %s", cmt);\
560                 goto label; \
561         } while(0)
562 #define torture_fail(torture_ctx,cmt) do {\
563                 torture_result(torture_ctx, TORTURE_FAIL, __location__": %s", cmt);\
564                 return false; \
565         } while (0)
566 #define torture_fail_goto(torture_ctx,label,cmt) do {\
567                 torture_result(torture_ctx, TORTURE_FAIL, __location__": %s", cmt);\
568                 goto label; \
569         } while (0)
570
571 #define torture_out stderr
572
573 /* Convenience macros */
574 #define torture_assert_ntstatus_ok(torture_ctx,expr,cmt) \
575                 torture_assert_ntstatus_equal(torture_ctx,expr,NT_STATUS_OK,cmt)
576
577 #define torture_assert_ntstatus_ok_goto(torture_ctx,expr,ret,label,cmt) \
578                 torture_assert_ntstatus_equal_goto(torture_ctx,expr,NT_STATUS_OK,ret,label,cmt)
579
580 #define torture_assert_werr_ok(torture_ctx,expr,cmt) \
581                 torture_assert_werr_equal(torture_ctx,expr,WERR_OK,cmt)
582
583 #define torture_assert_ndr_success(torture_ctx,expr,cmt) \
584                 torture_assert_ndr_err_equal(torture_ctx,expr,NDR_ERR_SUCCESS,cmt)
585
586 #define torture_assert_hresult_ok(torture_ctx,expr,cmt) \
587                 torture_assert_hresult_equal(torture_ctx,expr,HRES_ERROR(0), cmt)
588
589 /* Getting settings */
590 const char *torture_setting_string(struct torture_context *test, \
591                                                                    const char *name, 
592                                                                    const char *default_value);
593
594 int torture_setting_int(struct torture_context *test, 
595                                                 const char *name, 
596                                                 int default_value);
597
598 double torture_setting_double(struct torture_context *test, 
599                                                 const char *name, 
600                                                 double default_value);
601
602 bool torture_setting_bool(struct torture_context *test, 
603                                                   const char *name, 
604                                                   bool default_value);
605
606 struct torture_suite *torture_find_suite(struct torture_suite *parent, 
607                                                                                  const char *name);
608
609 unsigned long torture_setting_ulong(struct torture_context *test,
610                                     const char *name,
611                                     unsigned long default_value);
612
613 NTSTATUS torture_temp_dir(struct torture_context *tctx, 
614                                    const char *prefix, 
615                                    char **tempdir);
616 NTSTATUS torture_deltree_outputdir(struct torture_context *tctx);
617
618 struct torture_test *torture_tcase_add_simple_test(struct torture_tcase *tcase,
619                 const char *name,
620                 bool (*run) (struct torture_context *test, void *tcase_data));
621
622
623 bool torture_suite_init_tcase(struct torture_suite *suite, 
624                               struct torture_tcase *tcase, 
625                               const char *name);
626 int torture_suite_children_count(const struct torture_suite *suite);
627
628 struct torture_context *torture_context_init(struct tevent_context *event_ctx, struct torture_results *results);
629
630 struct torture_results *torture_results_init(TALLOC_CTX *mem_ctx, const struct torture_ui_ops *ui_ops);
631
632 struct torture_context *torture_context_child(struct torture_context *tctx);
633
634 extern const struct torture_ui_ops torture_subunit_ui_ops;
635 extern const struct torture_ui_ops torture_simple_ui_ops;
636
637 #endif /* __TORTURE_UI_H__ */