talloc: use the system pytalloc-util for python3 as well
[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_krb5_error_equal(torture_ctx, got, expected, cmt) \
305         do { krb5_error_code __got = got, __expected = expected; \
306         if (__got != __expected) { \
307                 torture_result(torture_ctx, TORTURE_FAIL, __location__": "#got" was %d (%s), expected %d (%s): %s", __got, error_message(__got), __expected, error_message(__expected), cmt); \
308                 return false; \
309         } \
310         } while (0)
311
312 #define torture_assert_casestr_equal(torture_ctx,got,expected,cmt) \
313         do { const char *__got = (got), *__expected = (expected); \
314         if (!strequal(__got, __expected)) { \
315                 torture_result(torture_ctx, TORTURE_FAIL, __location__": "#got" was %s, expected %s: %s", __got, __expected, cmt); \
316                 return false; \
317         } \
318         } while(0)
319
320 #define torture_assert_str_equal(torture_ctx,got,expected,cmt)\
321         do { const char *__got = (got), *__expected = (expected); \
322         if (strcmp_safe(__got, __expected) != 0) { \
323                 torture_result(torture_ctx, TORTURE_FAIL, \
324                                            __location__": "#got" was %s, expected %s: %s", \
325                                            __got, __expected, cmt); \
326                 return false; \
327         } \
328         } while(0)
329
330 #define torture_assert_strn_equal(torture_ctx,got,expected,len,cmt)\
331         do { const char *__got = (got), *__expected = (expected); \
332         if (strncmp(__got, __expected, len) != 0) { \
333                 torture_result(torture_ctx, TORTURE_FAIL, \
334                                            __location__": "#got" %s of len %d did not match "#expected" %s: %s", \
335                                            __got, (int)len, __expected, cmt); \
336                 return false; \
337         } \
338         } while(0)
339
340 #define torture_assert_str_equal_goto(torture_ctx,got,expected,ret,label,cmt)\
341         do { const char *__got = (got), *__expected = (expected); \
342         if (strcmp_safe(__got, __expected) != 0) { \
343                 torture_result(torture_ctx, TORTURE_FAIL, \
344                                            __location__": "#got" was %s, expected %s: %s", \
345                                            __got, __expected, cmt); \
346                 ret = false; \
347                 goto label; \
348         } \
349         } while(0)
350
351 #define torture_assert_mem_equal(torture_ctx,got,expected,len,cmt)\
352         do { const void *__got = (got), *__expected = (expected); \
353         if (memcmp(__got, __expected, len) != 0) { \
354                 torture_result(torture_ctx, TORTURE_FAIL, \
355                                __location__": "#got" of len %d did not match "#expected": %s", (int)len, cmt); \
356                 return false; \
357         } \
358         } while(0)
359
360 #define torture_assert_mem_equal_goto(torture_ctx,got,expected,len,ret,label,cmt) \
361         do { const void *__got = (got), *__expected = (expected); \
362         if (memcmp(__got, __expected, len) != 0) { \
363                 torture_result(torture_ctx, TORTURE_FAIL, \
364                                __location__": "#got" of len %d did not match "#expected": %s", (int)len, cmt); \
365                 ret = false; \
366                 goto label; \
367         } \
368         } while(0)
369
370 static inline void torture_dump_data_str_cb(const char *buf, void *private_data)
371 {
372         char **dump = (char **)private_data;
373         *dump = talloc_strdup_append_buffer(*dump, buf);
374 }
375
376 #define torture_assert_data_blob_equal(torture_ctx,got,expected,cmt)\
377         do { const DATA_BLOB __got = (got), __expected = (expected); \
378         if (__got.length != __expected.length) { \
379                 torture_result(torture_ctx, TORTURE_FAIL, \
380                                __location__": "#got".len %d did not match "#expected" len %d: %s", \
381                                (int)__got.length, (int)__expected.length, cmt); \
382                 return false; \
383         } \
384         if (memcmp(__got.data, __expected.data, __got.length) != 0) { \
385                 char *__dump = NULL; \
386                 uint8_t __byte_a = 0x00;\
387                 uint8_t __byte_b = 0x00;\
388                 int __i;\
389                 for (__i=0; __i < __expected.length; __i++) {\
390                         __byte_a = __expected.data[__i];\
391                         if (__i == __got.length) {\
392                                 __byte_b = 0x00;\
393                                 break;\
394                         }\
395                         __byte_b = __got.data[__i];\
396                         if (__byte_a != __byte_b) {\
397                                 break;\
398                         }\
399                 }\
400                 torture_warning(torture_ctx, "blobs differ at byte 0x%02X (%u)", __i, __i);\
401                 torture_warning(torture_ctx, "expected byte[0x%02X] = 0x%02X got byte[0x%02X] = 0x%02X",\
402                                 __i, __byte_a, __i, __byte_b);\
403                 __dump = talloc_strdup(torture_ctx, ""); \
404                 dump_data_cb(__got.data, __got.length, true, \
405                              torture_dump_data_str_cb, &__dump); \
406                 torture_warning(torture_ctx, "got[0x%02X]: \n%s", \
407                                 (int)__got.length, __dump); \
408                 TALLOC_FREE(__dump); \
409                 __dump = talloc_strdup(torture_ctx, ""); \
410                 dump_data_cb(__expected.data, __expected.length, true, \
411                              torture_dump_data_str_cb, &__dump); \
412                 torture_warning(torture_ctx, "expected[0x%02X]: \n%s", \
413                                 (int)__expected.length, __dump); \
414                 TALLOC_FREE(__dump); \
415                 torture_result(torture_ctx, TORTURE_FAIL, \
416                                __location__": "#got" of len %d did not match "#expected": %s", (int)__got.length, cmt); \
417                 return false; \
418         } \
419         } while(0)
420
421 #define torture_assert_file_contains_text(torture_ctx,filename,expected,cmt)\
422         do { \
423         char *__got; \
424         const char *__expected = (expected); \
425         size_t __size; \
426         __got = file_load(filename, &__size, 0, torture_ctx); \
427         if (__got == NULL) { \
428                 torture_result(torture_ctx, TORTURE_FAIL, \
429                                __location__": unable to open %s: %s\n", \
430                                filename, cmt); \
431                 return false; \
432         } \
433         \
434         if (strcmp_safe(__got, __expected) != 0) { \
435                 torture_result(torture_ctx, TORTURE_FAIL, \
436                         __location__": %s contained:\n%sExpected: %s%s\n", \
437                         filename, __got, __expected, cmt); \
438                 talloc_free(__got); \
439                 return false; \
440         } \
441         talloc_free(__got); \
442         } while(0)
443
444 #define torture_assert_file_contains(torture_ctx,filename,expected,cmt)\
445         do { const char *__got, *__expected = (expected); \
446         size_t __size; \
447         __got = file_load(filename, *size, 0, torture_ctx); \
448         if (strcmp_safe(__got, __expected) != 0) { \
449                 torture_result(torture_ctx, TORTURE_FAIL, \
450                                            __location__": %s contained:\n%sExpected: %s%s\n", \
451                                            __got, __expected, cmt); \
452                 talloc_free(__got); \
453                 return false; \
454         } \
455         talloc_free(__got); \
456         } while(0)
457
458 #define torture_assert_int_equal(torture_ctx,got,expected,cmt)\
459         do { int __got = (got), __expected = (expected); \
460         if (__got != __expected) { \
461                 torture_result(torture_ctx, TORTURE_FAIL, \
462                         __location__": "#got" was %d (0x%X), expected %d (0x%X): %s", \
463                         __got, __got, __expected, __expected, cmt); \
464                 return false; \
465         } \
466         } while(0)
467
468 #define torture_assert_int_equal_goto(torture_ctx,got,expected,ret,label,cmt)\
469         do { int __got = (got), __expected = (expected); \
470         if (__got != __expected) { \
471                 torture_result(torture_ctx, TORTURE_FAIL, \
472                         __location__": "#got" was %d (0x%X), expected %d (0x%X): %s", \
473                         __got, __got, __expected, __expected, cmt); \
474                 ret = false; \
475                 goto label; \
476         } \
477         } while(0)
478
479 #define torture_assert_int_not_equal(torture_ctx,got,not_expected,cmt)\
480         do { int __got = (got), __not_expected = (not_expected); \
481         if (__got == __not_expected) { \
482                 torture_result(torture_ctx, TORTURE_FAIL, \
483                         __location__": "#got" was %d (0x%X), expected a different number: %s", \
484                         __got, __got, cmt); \
485                 return false; \
486         } \
487         } while(0)
488
489 #define torture_assert_int_not_equal_goto(torture_ctx,got,not_expected,ret,label,cmt)\
490         do { int __got = (got), __not_expected = (not_expected); \
491         if (__got == __not_expected) { \
492                 torture_result(torture_ctx, TORTURE_FAIL, \
493                         __location__": "#got" was %d (0x%X), expected a different number: %s", \
494                         __got, __got, cmt); \
495                 ret = false; \
496                 goto label; \
497         } \
498         } while(0)
499
500 #define torture_assert_u64_equal(torture_ctx,got,expected,cmt)\
501         do { uint64_t __got = (got), __expected = (expected); \
502         if (__got != __expected) { \
503                 torture_result(torture_ctx, TORTURE_FAIL, \
504                         __location__": "#got" was %llu (0x%llX), expected %llu (0x%llX): %s", \
505                         (unsigned long long)__got, (unsigned long long)__got, \
506                         (unsigned long long)__expected, (unsigned long long)__expected, \
507                         cmt); \
508                 return false; \
509         } \
510         } while(0)
511
512 #define torture_assert_u64_equal_goto(torture_ctx,got,expected,ret,label,cmt)\
513         do { uint64_t __got = (got), __expected = (expected); \
514         if (__got != __expected) { \
515                 torture_result(torture_ctx, TORTURE_FAIL, \
516                         __location__": "#got" was %llu (0x%llX), expected %llu (0x%llX): %s", \
517                         (unsigned long long)__got, (unsigned long long)__got, \
518                         (unsigned long long)__expected, (unsigned long long)__expected, \
519                         cmt); \
520                 ret = false; \
521                 goto label; \
522         } \
523         } while(0)
524
525 #define torture_assert_u64_not_equal(torture_ctx,got,not_expected,cmt)\
526         do { uint64_t __got = (got), __not_expected = (not_expected); \
527         if (__got == __not_expected) { \
528                 torture_result(torture_ctx, TORTURE_FAIL, \
529                         __location__": "#got" was %llu (0x%llX), expected a different number: %s", \
530                         (unsigned long long)__got, (unsigned long long)__got, \
531                         cmt); \
532                 return false; \
533         } \
534         } while(0)
535
536 #define torture_assert_u64_not_equal_goto(torture_ctx,got,not_expected,ret,label,cmt)\
537         do { uint64_t __got = (got), __not_expected = (not_expected); \
538         if (__got == __not_expected) { \
539                 torture_result(torture_ctx, TORTURE_FAIL, \
540                         __location__": "#got" was %llu (0x%llX), expected a different number: %s", \
541                         (unsigned long long)__got, (unsigned long long)__got, \
542                         cmt); \
543                 ret = false; \
544                 goto label; \
545         } \
546         } while(0)
547
548 #define torture_assert_errno_equal(torture_ctx,expected,cmt)\
549         do { int __expected = (expected); \
550         if (errno != __expected) { \
551                 torture_result(torture_ctx, TORTURE_FAIL, \
552                         __location__": errno was %d (%s), expected %d: %s: %s", \
553                                            errno, strerror(errno), __expected, \
554                                            strerror(__expected), cmt); \
555                 return false; \
556         } \
557         } while(0)
558
559 #define torture_assert_guid_equal(torture_ctx,got,expected,cmt)\
560         do {const struct GUID __got = (got), __expected = (expected); \
561         if (!GUID_equal(&__got, &__expected)) { \
562                 torture_result(torture_ctx, TORTURE_FAIL, \
563                         __location__": "#got" was %s, expected %s: %s", \
564                         GUID_string(torture_ctx, &__got), GUID_string(torture_ctx, &__expected), cmt); \
565                 return false; \
566         } \
567         } while(0)
568
569 #define torture_assert_nttime_equal(torture_ctx,got,expected,cmt) \
570         do { NTTIME __got = got, __expected = expected; \
571         if (!nt_time_equal(&__got, &__expected)) { \
572                 torture_result(torture_ctx, TORTURE_FAIL, __location__": "#got" was %s, expected %s: %s", nt_time_string(tctx, __got), nt_time_string(tctx, __expected), cmt); \
573                 return false; \
574         }\
575         } while(0)
576
577 #define torture_assert_sid_equal(torture_ctx,got,expected,cmt)\
578         do {const struct dom_sid *__got = (got), *__expected = (expected); \
579         if (!dom_sid_equal(__got, __expected)) { \
580                 torture_result(torture_ctx, TORTURE_FAIL, \
581                                            __location__": "#got" was %s, expected %s: %s", \
582                                            dom_sid_string(torture_ctx, __got), dom_sid_string(torture_ctx, __expected), cmt); \
583                 return false; \
584         } \
585         } while(0)
586
587 #define torture_assert_not_null(torture_ctx,got,cmt)\
588         do {const void *__got = (got); \
589         if (__got == NULL) { \
590                 torture_result(torture_ctx, TORTURE_FAIL, \
591                         __location__": "#got" was NULL, expected != NULL: %s", \
592                         cmt); \
593                 return false; \
594         } \
595         } while(0)
596
597 #define torture_assert_not_null_goto(torture_ctx,got,ret,label,cmt)\
598         do {const void *__got = (got); \
599         if (__got == NULL) { \
600                 torture_result(torture_ctx, TORTURE_FAIL, \
601                         __location__": "#got" was NULL, expected != NULL: %s", \
602                         cmt); \
603                 ret = false; \
604                 goto label; \
605         } \
606         } while(0)
607
608 #define torture_skip(torture_ctx,cmt) do {\
609                 torture_result(torture_ctx, TORTURE_SKIP, __location__": %s", cmt);\
610                 return true; \
611         } while(0)
612 #define torture_skip_goto(torture_ctx,label,cmt) do {\
613                 torture_result(torture_ctx, TORTURE_SKIP, __location__": %s", cmt);\
614                 goto label; \
615         } while(0)
616 #define torture_fail(torture_ctx,cmt) do {\
617                 torture_result(torture_ctx, TORTURE_FAIL, __location__": %s", cmt);\
618                 return false; \
619         } while (0)
620 #define torture_fail_goto(torture_ctx,label,cmt) do {\
621                 torture_result(torture_ctx, TORTURE_FAIL, __location__": %s", cmt);\
622                 goto label; \
623         } while (0)
624
625 #define torture_out stderr
626
627 /* Convenience macros */
628 #define torture_assert_ntstatus_ok(torture_ctx,expr,cmt) \
629                 torture_assert_ntstatus_equal(torture_ctx,expr,NT_STATUS_OK,cmt)
630
631 #define torture_assert_ntstatus_ok_goto(torture_ctx,expr,ret,label,cmt) \
632                 torture_assert_ntstatus_equal_goto(torture_ctx,expr,NT_STATUS_OK,ret,label,cmt)
633
634 #define torture_assert_werr_ok(torture_ctx,expr,cmt) \
635                 torture_assert_werr_equal(torture_ctx,expr,WERR_OK,cmt)
636
637 #define torture_assert_ndr_success(torture_ctx,expr,cmt) \
638                 torture_assert_ndr_err_equal(torture_ctx,expr,NDR_ERR_SUCCESS,cmt)
639
640 #define torture_assert_hresult_ok(torture_ctx,expr,cmt) \
641                 torture_assert_hresult_equal(torture_ctx,expr,HRES_ERROR(0), cmt)
642
643 /* Getting settings */
644 const char *torture_setting_string(struct torture_context *test, \
645                                                                    const char *name, 
646                                                                    const char *default_value);
647
648 int torture_setting_int(struct torture_context *test, 
649                                                 const char *name, 
650                                                 int default_value);
651
652 double torture_setting_double(struct torture_context *test, 
653                                                 const char *name, 
654                                                 double default_value);
655
656 bool torture_setting_bool(struct torture_context *test, 
657                                                   const char *name, 
658                                                   bool default_value);
659
660 struct torture_suite *torture_find_suite(struct torture_suite *parent, 
661                                                                                  const char *name);
662
663 unsigned long torture_setting_ulong(struct torture_context *test,
664                                     const char *name,
665                                     unsigned long default_value);
666
667 NTSTATUS torture_temp_dir(struct torture_context *tctx, 
668                                    const char *prefix, 
669                                    char **tempdir);
670 NTSTATUS torture_deltree_outputdir(struct torture_context *tctx);
671
672 struct torture_test *torture_tcase_add_simple_test(struct torture_tcase *tcase,
673                 const char *name,
674                 bool (*run) (struct torture_context *test, void *tcase_data));
675
676
677 bool torture_suite_init_tcase(struct torture_suite *suite, 
678                               struct torture_tcase *tcase, 
679                               const char *name);
680 int torture_suite_children_count(const struct torture_suite *suite);
681
682 struct torture_context *torture_context_init(struct tevent_context *event_ctx, struct torture_results *results);
683
684 struct torture_results *torture_results_init(TALLOC_CTX *mem_ctx, const struct torture_ui_ops *ui_ops);
685
686 struct torture_context *torture_context_child(struct torture_context *tctx);
687
688 extern const struct torture_ui_ops torture_subunit_ui_ops;
689 extern const struct torture_ui_ops torture_simple_ui_ops;
690
691 #endif /* __TORTURE_UI_H__ */