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 /*
  31  * Arranged in precedence order. TORTURE_ERROR has the highest priority;
  32  * TORTURE_OK the lowest.
  33  */
  34 enum torture_result {
  35         TORTURE_OK=0,
  36         TORTURE_SKIP=1,
  37         TORTURE_FAIL=2,
  38         TORTURE_ERROR=3
  39 };
  40
  41 enum torture_progress_whence {
  42         TORTURE_PROGRESS_SET,
  43         TORTURE_PROGRESS_CUR,
  44         TORTURE_PROGRESS_POP,
  45         TORTURE_PROGRESS_PUSH,
  46 };
  47
  48 /*
  49  * These callbacks should be implemented by any backend that wishes
  50  * to listen to reports from the torture tests.
  51  */
  52 struct torture_ui_ops
  53 {
  54         void (*init) (struct torture_results *);
  55         void (*comment) (struct torture_context *, const char *);
  56         void (*warning) (struct torture_context *, const char *);
  57         void (*suite_start) (struct torture_context *, struct torture_suite *);
  58         void (*suite_finish) (struct torture_context *, struct torture_suite *);
  59         void (*tcase_start) (struct torture_context *, struct torture_tcase *);
  60         void (*tcase_finish) (struct torture_context *, struct torture_tcase *);
  61         void (*test_start) (struct torture_context *,
  62                                                 struct torture_tcase *,
  63                                                 struct torture_test *);
  64         void (*test_result) (struct torture_context *,
  65                                                  enum torture_result, const char *reason);
  66         void (*progress) (struct torture_context *, int offset, enum torture_progress_whence whence);
  67         void (*report_time) (struct torture_context *);
  68 };
  69
  70 void torture_ui_test_start(struct torture_context *context,
  71                                                            struct torture_tcase *tcase,
  72                                                            struct torture_test *test);
  73
  74 void torture_ui_test_result(struct torture_context *context,
  75                                                                 enum torture_result result,
  76                                                                 const char *comment);
  77
  78 void torture_ui_report_time(struct torture_context *context);
  79
  80 /*
  81  * Holds information about a specific run of the testsuite.
  82  * The data in this structure should be considered private to
  83  * the torture tests and should only be used directly by the torture
  84  * code and the ui backends.
  85  *
  86  * Torture tests should instead call the torture_*() macros and functions
  87  * specified below.
  88  */
  89
  90 struct torture_subunit_prefix {
  91         const struct torture_subunit_prefix *parent;
  92         char subunit_prefix[256];
  93 };
  94
  95 struct torture_context
  96 {
  97         struct torture_results *results;
  98
  99         struct torture_test *active_test;
 100         struct torture_tcase *active_tcase;
 101         struct torture_subunit_prefix _initial_prefix;
 102         const struct torture_subunit_prefix *active_prefix;
 103
 104         enum torture_result last_result;
 105         char *last_reason;
 106
 107         /** Directory used for temporary test data */
 108         const char *outputdir;
 109
 110         /** Event context */
 111         struct tevent_context *ev;
 112
 113         /** Loadparm context (will go away in favor of torture_setting_ at some point) */
 114         struct loadparm_context *lp_ctx;
 115
 116         int conn_index;
 117 };
 118
 119 struct torture_results
 120 {
 121         const struct torture_ui_ops *ui_ops;
 122         void *ui_data;
 123
 124         /** Whether tests should avoid writing output to stdout */
 125         bool quiet;
 126
 127         bool returncode;
 128 };
 129
 130 /*
 131  * Describes a particular torture test
 132  */
 133 struct torture_test {
 134         /** Short unique name for the test. */
 135         const char *name;
 136
 137         /** Long description for the test. */
 138         const char *description;
 139
 140         /** Whether this is a dangerous test
 141          * (can corrupt the remote servers data or bring it down). */
 142         bool dangerous;
 143
 144         /** Function to call to run this test */
 145         bool (*run) (struct torture_context *torture_ctx,
 146                                  struct torture_tcase *tcase,
 147                                  struct torture_test *test);
 148
 149         struct torture_test *prev, *next;
 150
 151         /** Pointer to the actual test function. This is run by the
 152           * run() function above. */
 153         void *fn;
 154
 155         /** Use data for this test */
 156         const void *data;
 157
 158         struct torture_tcase *tcase;
 159 };
 160
 161 /*
 162  * Describes a particular test case.
 163  */
 164 struct torture_tcase {
 165     const char *name;
 166         const char *description;
 167         bool (*setup) (struct torture_context *tcase, void **data);
 168         bool (*teardown) (struct torture_context *tcase, void *data);
 169         bool fixture_persistent;
 170         void *data;
 171         struct torture_test *tests;
 172         struct torture_tcase *prev, *next;
 173         const struct torture_suite *suite;
 174 };
 175
 176 struct torture_suite
 177 {
 178         const char *name;
 179         const char *description;
 180         struct torture_tcase *testcases;
 181         struct torture_suite *children;
 182         const struct torture_suite *parent;
 183
 184         /* Pointers to siblings of this torture suite */
 185         struct torture_suite *prev, *next;
 186 };
 187
 188 /** Create a new torture suite */
 189 struct torture_suite *torture_suite_create(TALLOC_CTX *mem_ctx,
 190                 const char *name);
 191
 192 /** Change the setup and teardown functions for a testcase */
 193 void torture_tcase_set_fixture(struct torture_tcase *tcase,
 194                 bool (*setup) (struct torture_context *, void **),
 195                 bool (*teardown) (struct torture_context *, void *));
 196
 197 /* Add another test to run for a particular testcase */
 198 struct torture_test *torture_tcase_add_test_const(struct torture_tcase *tcase,
 199                 const char *name,
 200                 bool (*run) (struct torture_context *test,
 201                         const void *tcase_data, const void *test_data),
 202                 const void *test_data);
 203
 204 /* Add a testcase to a testsuite */
 205 struct torture_tcase *torture_suite_add_tcase(struct torture_suite *suite,
 206                                                          const char *name);
 207
 208 /* Convenience wrapper that adds a testcase against only one
 209  * test will be run */
 210 struct torture_tcase *torture_suite_add_simple_tcase_const(
 211                 struct torture_suite *suite,
 212                 const char *name,
 213                 bool (*run) (struct torture_context *test,
 214                         const void *test_data),
 215                 const void *data);
 216
 217 /* Convenience function that adds a test which only
 218  * gets the test case data */
 219 struct torture_test *torture_tcase_add_simple_test_const(
 220                 struct torture_tcase *tcase,
 221                 const char *name,
 222                 bool (*run) (struct torture_context *test,
 223                         const void *tcase_data));
 224
 225 /* Convenience wrapper that adds a test that doesn't need any
 226  * testcase data */
 227 struct torture_tcase *torture_suite_add_simple_test(
 228                 struct torture_suite *suite,
 229                 const char *name,
 230                 bool (*run) (struct torture_context *test));
 231
 232 /* Add a child testsuite to an existing testsuite */
 233 bool torture_suite_add_suite(struct torture_suite *suite,
 234                 struct torture_suite *child);
 235
 236 char *torture_subunit_test_name(struct torture_context *ctx,
 237                                 struct torture_tcase *tcase,
 238                                 struct torture_test *test);
 239 void torture_subunit_prefix_reset(struct torture_context *ctx,
 240                                   const char *name);
 241
 242 /* Run the specified testsuite recursively */
 243 bool torture_run_suite(struct torture_context *context,
 244                                            struct torture_suite *suite);
 245
 246 /* Run the specified testsuite recursively, but only the specified
 247  * tests */
 248 bool torture_run_suite_restricted(struct torture_context *context,
 249                        struct torture_suite *suite, const char **restricted);
 250
 251 /* Run the specified testcase */
 252 bool torture_run_tcase(struct torture_context *context,
 253                                            struct torture_tcase *tcase);
 254
 255 bool torture_run_tcase_restricted(struct torture_context *context,
 256                        struct torture_tcase *tcase, const char **restricted);
 257
 258 /* Run the specified test */
 259 bool torture_run_test(struct torture_context *context,
 260                                           struct torture_tcase *tcase,
 261                                           struct torture_test *test);
 262
 263 bool torture_run_test_restricted(struct torture_context *context,
 264                                           struct torture_tcase *tcase,
 265                                           struct torture_test *test,
 266                                           const char **restricted);
 267
 268 void torture_comment(struct torture_context *test, const char *comment, ...) PRINTF_ATTRIBUTE(2,3);
 269 void torture_warning(struct torture_context *test, const char *comment, ...) PRINTF_ATTRIBUTE(2,3);
 270 void torture_result(struct torture_context *test,
 271                         enum torture_result, const char *reason, ...) PRINTF_ATTRIBUTE(3,4);
 272
 273 #define torture_assert(torture_ctx,expr,cmt) do { \
 274         if (!(expr)) { \
 275                 torture_result(torture_ctx, TORTURE_FAIL, __location__": Expression `%s' failed: %s", __STRING(expr), cmt); \
 276                 return false; \
 277         } \
 278 } while(0)
 279
 280 #define torture_assertf(torture_ctx, expr, format, ...) do {            \
 281         if (!(expr)) {                                                  \
 282                 char *_msg = talloc_asprintf(torture_ctx,               \
 283                                              format,                    \
 284                                              __VA_ARGS__);              \
 285                 torture_result(torture_ctx,                             \
 286                                TORTURE_FAIL,                            \
 287                                __location__": Expression `%s' failed: %s", \
 288                                __STRING(expr), _msg);                   \
 289                 talloc_free(_msg);                                      \
 290                 return false;                                           \
 291         }                                                               \
 292 } while(0)
 293
 294 #define torture_assert_goto(torture_ctx,expr,ret,label,cmt) do { \
 295         if (!(expr)) { \
 296                 torture_result(torture_ctx, TORTURE_FAIL, __location__": Expression `%s' failed: %s", __STRING(expr), cmt); \
 297                 ret = false; \
 298                 goto label; \
 299         } \
 300 } while(0)
 301
 302 #define torture_assert_werr_equal(torture_ctx, got, expected, cmt) \
 303         do { WERROR __got = got, __expected = expected; \
 304         if (!W_ERROR_EQUAL(__got, __expected)) { \
 305                 torture_result(torture_ctx, TORTURE_FAIL, __location__": "#got" was %s, expected %s: %s", win_errstr(__got), win_errstr(__expected), cmt); \
 306                 return false; \
 307         } \
 308         } while (0)
 309
 310 #define torture_assert_werr_equal_goto(torture_ctx, got, expected, ret, label, cmt) \
 311         do { WERROR __got = got, __expected = expected; \
 312         if (!W_ERROR_EQUAL(__got, __expected)) { \
 313                 torture_result(torture_ctx, TORTURE_FAIL, __location__": "#got" was %s, expected %s: %s", win_errstr(__got), win_errstr(__expected), cmt); \
 314                 ret = false; \
 315                 goto label; \
 316         } \
 317         } while (0)
 318
 319 #define torture_assert_ntstatus_equal(torture_ctx,got,expected,cmt) \
 320         do { NTSTATUS __got = got, __expected = expected; \
 321         if (!NT_STATUS_EQUAL(__got, __expected)) { \
 322                 torture_result(torture_ctx, TORTURE_FAIL, __location__": "#got" was %s, expected %s: %s", nt_errstr(__got), nt_errstr(__expected), cmt); \
 323                 return false; \
 324         }\
 325         } while(0)
 326
 327 #define torture_assert_ntstatus_equal_goto(torture_ctx,got,expected,ret,label,cmt) \
 328         do { NTSTATUS __got = got, __expected = expected; \
 329         if (!NT_STATUS_EQUAL(__got, __expected)) { \
 330                 torture_result(torture_ctx, TORTURE_FAIL, __location__": "#got" was %s, expected %s: %s", nt_errstr(__got), nt_errstr(__expected), cmt); \
 331                 ret = false; \
 332                 goto label; \
 333         }\
 334         } while(0)
 335
 336 #define torture_assert_ndr_err_equal(torture_ctx,got,expected,cmt) \
 337         do { enum ndr_err_code __got = got, __expected = expected; \
 338         if (__got != __expected) { \
 339                 torture_result(torture_ctx, TORTURE_FAIL, __location__": "#got" was %d (%s), expected %d (%s): %s", __got, ndr_errstr(__got), __expected, __STRING(expected), cmt); \
 340                 return false; \
 341         }\
 342         } while(0)
 343
 344 #define torture_assert_ndr_err_equal_goto(torture_ctx,got,expected,ret,label,cmt) \
 345         do { enum ndr_err_code __got = got, __expected = expected; \
 346         if (__got != __expected) { \
 347                 torture_result(torture_ctx, TORTURE_FAIL, __location__": "#got" was %d (%s), expected %d (%s): %s", __got, ndr_errstr(__got), __expected, __STRING(expected), cmt); \
 348                 ret = false; \
 349                 goto label; \
 350         }\
 351         } while(0)
 352
 353 #define torture_assert_hresult_equal(torture_ctx, got, expected, cmt) \
 354         do { HRESULT __got = got, __expected = expected; \
 355         if (!HRES_IS_EQUAL(__got, __expected)) { \
 356                 torture_result(torture_ctx, TORTURE_FAIL, __location__": "#got" was %s, expected %s: %s", hresult_errstr(__got), hresult_errstr(__expected), cmt); \
 357                 return false; \
 358         } \
 359         } while (0)
 360
 361 #define torture_assert_krb5_error_equal(torture_ctx, got, expected, cmt) \
 362         do { krb5_error_code __got = got, __expected = expected; \
 363         if (__got != __expected) { \
 364                 torture_result(torture_ctx, TORTURE_FAIL, __location__": "#got" was %d (%s), expected %d (%s): %s", __got, error_message(__got), __expected, error_message(__expected), cmt); \
 365                 return false; \
 366         } \
 367         } while (0)
 368
 369 #define torture_assert_casestr_equal(torture_ctx,got,expected,cmt) \
 370         do { const char *__got = (got), *__expected = (expected); \
 371         if (!strequal(__got, __expected)) { \
 372                 torture_result(torture_ctx, TORTURE_FAIL, \
 373                                __location__": "#got" was %s, expected %s: %s", \
 374                                __got, __expected == NULL ? "null" : __expected, cmt); \
 375                 return false; \
 376         } \
 377         } while(0)
 378
 379 #define torture_assert_str_equal(torture_ctx,got,expected,cmt)\
 380         do { const char *__got = (got), *__expected = (expected); \
 381         if (strcmp_safe(__got, __expected) != 0) { \
 382                 torture_result(torture_ctx, TORTURE_FAIL, \
 383                                __location__": "#got" was %s, expected %s: %s", \
 384                                __got, __expected == NULL ? "NULL" : __expected, cmt); \
 385                 return false; \
 386         } \
 387         } while(0)
 388
 389 #define torture_assert_strn_equal(torture_ctx,got,expected,len,cmt)\
 390         do { const char *__got = (got), *__expected = (expected); \
 391         if (strncmp(__got, __expected, len) != 0) { \
 392                 torture_result(torture_ctx, TORTURE_FAIL, \
 393                                            __location__": "#got" %s of len %d did not match "#expected" %s: %s", \
 394                                            __got, (int)len, __expected, cmt); \
 395                 return false; \
 396         } \
 397         } while(0)
 398
 399 #define torture_assert_str_equal_goto(torture_ctx,got,expected,ret,label,cmt)\
 400         do { const char *__got = (got), *__expected = (expected); \
 401         if (strcmp_safe(__got, __expected) != 0) { \
 402                 torture_result(torture_ctx, TORTURE_FAIL, \
 403                                            __location__": "#got" was %s, expected %s: %s", \
 404                                            __got, __expected, cmt); \
 405                 ret = false; \
 406                 goto label; \
 407         } \
 408         } while(0)
 409
 410 #define torture_assert_mem_equal(torture_ctx,got,expected,len,cmt)\
 411         do { const void *__got = (got), *__expected = (expected); \
 412         if (memcmp(__got, __expected, len) != 0) { \
 413                 torture_result(torture_ctx, TORTURE_FAIL, \
 414                                __location__": "#got" of len %d did not match "#expected": %s", (int)len, cmt); \
 415                 return false; \
 416         } \
 417         } while(0)
 418
 419 #define torture_assert_mem_equal_goto(torture_ctx,got,expected,len,ret,label,cmt) \
 420         do { const void *__got = (got), *__expected = (expected); \
 421         if (memcmp(__got, __expected, len) != 0) { \
 422                 torture_result(torture_ctx, TORTURE_FAIL, \
 423                                __location__": "#got" of len %d did not match "#expected": %s", (int)len, cmt); \
 424                 ret = false; \
 425                 goto label; \
 426         } \
 427         } while(0)
 428
 429 #define torture_assert_mem_not_equal_goto(torture_ctx,got,expected,len,ret,label,cmt) \
 430         do { const void *__got = (got), *__expected = (expected); \
 431         if (memcmp(__got, __expected, len) == 0) { \
 432                 torture_result(torture_ctx, TORTURE_FAIL, \
 433                                __location__": "#got" of len %d unexpectedly matches "#expected": %s", (int)len, cmt); \
 434                 ret = false; \
 435                 goto label; \
 436         } \
 437         } while(0)
 438
 439 static inline void torture_dump_data_str_cb(const char *buf, void *private_data)
 440 {
 441         char **dump = (char **)private_data;
 442         *dump = talloc_strdup_append_buffer(*dump, buf);
 443 }
 444
 445 #define torture_assert_data_blob_equal(torture_ctx,got,expected,cmt)\
 446         do { const DATA_BLOB __got = (got), __expected = (expected); \
 447         if (__got.length != __expected.length) { \
 448                 torture_result(torture_ctx, TORTURE_FAIL, \
 449                                __location__": "#got".len %d did not match "#expected" len %d: %s", \
 450                                (int)__got.length, (int)__expected.length, cmt); \
 451                 return false; \
 452         } \
 453         if (memcmp(__got.data, __expected.data, __got.length) != 0) { \
 454                 char *__dump = NULL; \
 455                 uint8_t __byte_a = 0x00;\
 456                 uint8_t __byte_b = 0x00;\
 457                 size_t __i;\
 458                 for (__i=0; __i < __expected.length; __i++) {\
 459                         __byte_a = __expected.data[__i];\
 460                         if (__i == __got.length) {\
 461                                 __byte_b = 0x00;\
 462                                 break;\
 463                         }\
 464                         __byte_b = __got.data[__i];\
 465                         if (__byte_a != __byte_b) {\
 466                                 break;\
 467                         }\
 468                 }\
 469                 torture_warning(torture_ctx, "blobs differ at byte 0x%02X (%zu)", (unsigned int)__i, __i);\
 470                 torture_warning(torture_ctx, "expected byte[0x%02X] = 0x%02X got byte[0x%02X] = 0x%02X",\
 471                                 (unsigned int)__i, __byte_a, (unsigned int)__i, __byte_b);\
 472                 __dump = talloc_strdup(torture_ctx, ""); \
 473                 dump_data_cb(__got.data, __got.length, true, \
 474                              torture_dump_data_str_cb, &__dump); \
 475                 torture_warning(torture_ctx, "got[0x%02X]: \n%s", \
 476                                 (unsigned int)__got.length, __dump); \
 477                 TALLOC_FREE(__dump); \
 478                 __dump = talloc_strdup(torture_ctx, ""); \
 479                 dump_data_cb(__expected.data, __expected.length, true, \
 480                              torture_dump_data_str_cb, &__dump); \
 481                 torture_warning(torture_ctx, "expected[0x%02X]: \n%s", \
 482                                 (int)__expected.length, __dump); \
 483                 TALLOC_FREE(__dump); \
 484                 torture_result(torture_ctx, TORTURE_FAIL, \
 485                                __location__": "#got" of len %d did not match "#expected": %s", (int)__got.length, cmt); \
 486                 return false; \
 487         } \
 488         } while(0)
 489
 490 #define torture_assert_file_contains_text(torture_ctx,filename,expected,cmt)\
 491         do { \
 492         char *__got; \
 493         const char *__expected = (expected); \
 494         size_t __size; \
 495         __got = file_load(filename, &__size, 0, torture_ctx); \
 496         if (__got == NULL) { \
 497                 torture_result(torture_ctx, TORTURE_FAIL, \
 498                                __location__": unable to open %s: %s\n", \
 499                                filename, cmt); \
 500                 return false; \
 501         } \
 502         \
 503         if (strcmp_safe(__got, __expected) != 0) { \
 504                 torture_result(torture_ctx, TORTURE_FAIL, \
 505                         __location__": %s contained:\n%sExpected: %s%s\n", \
 506                         filename, __got, __expected, cmt); \
 507                 talloc_free(__got); \
 508                 return false; \
 509         } \
 510         talloc_free(__got); \
 511         } while(0)
 512
 513 #define torture_assert_file_contains(torture_ctx,filename,expected,cmt)\
 514         do { const char *__got, *__expected = (expected); \
 515         size_t __size; \
 516         __got = file_load(filename, *size, 0, torture_ctx); \
 517         if (strcmp_safe(__got, __expected) != 0) { \
 518                 torture_result(torture_ctx, TORTURE_FAIL, \
 519                                            __location__": %s contained:\n%sExpected: %s%s\n", \
 520                                            __got, __expected, cmt); \
 521                 talloc_free(__got); \
 522                 return false; \
 523         } \
 524         talloc_free(__got); \
 525         } while(0)
 526
 527 #define torture_assert_int_equal(torture_ctx,got,expected,cmt)\
 528         do { int __got = (got), __expected = (expected); \
 529         if (__got != __expected) { \
 530                 torture_result(torture_ctx, TORTURE_FAIL, \
 531                         __location__": "#got" was %d (0x%X), expected %d (0x%X): %s", \
 532                         __got, __got, __expected, __expected, cmt); \
 533                 return false; \
 534         } \
 535         } while(0)
 536
 537 #define torture_assert_int_less(torture_ctx,got,limit,cmt)\
 538         do { int __got = (got), __limit = (limit); \
 539         if (__got >= __limit) { \
 540                 torture_result(torture_ctx, TORTURE_FAIL, \
 541                         __location__": "#got" was %d (0x%X), expected < %d (0x%X): %s", \
 542                         __got, __got, __limit, __limit, cmt); \
 543                 return false; \
 544         } \
 545         } while(0)
 546
 547 #define torture_assert_int_greater(torture_ctx,got,limit,cmt)\
 548         do { int __got = (got), __limit = (limit); \
 549         if (__got <= __limit) { \
 550                 torture_result(torture_ctx, TORTURE_FAIL, \
 551                         __location__": "#got" was %d (0x%X), expected > %d (0x%X): %s", \
 552                         __got, __got, __limit, __limit, cmt); \
 553                 return false; \
 554         } \
 555         } while(0)
 556
 557 #define torture_assert_int_equal_goto(torture_ctx,got,expected,ret,label,cmt)\
 558         do { int __got = (got), __expected = (expected); \
 559         if (__got != __expected) { \
 560                 torture_result(torture_ctx, TORTURE_FAIL, \
 561                         __location__": "#got" was %d (0x%X), expected %d (0x%X): %s", \
 562                         __got, __got, __expected, __expected, cmt); \
 563                 ret = false; \
 564                 goto label; \
 565         } \
 566         } while(0)
 567
 568 #define torture_assert_int_not_equal(torture_ctx,got,not_expected,cmt)\
 569         do { int __got = (got), __not_expected = (not_expected); \
 570         if (__got == __not_expected) { \
 571                 torture_result(torture_ctx, TORTURE_FAIL, \
 572                         __location__": "#got" was %d (0x%X), expected a different number: %s", \
 573                         __got, __got, cmt); \
 574                 return false; \
 575         } \
 576         } while(0)
 577
 578 #define torture_assert_int_not_equal_goto(torture_ctx,got,not_expected,ret,label,cmt)\
 579         do { int __got = (got), __not_expected = (not_expected); \
 580         if (__got == __not_expected) { \
 581                 torture_result(torture_ctx, TORTURE_FAIL, \
 582                         __location__": "#got" was %d (0x%X), expected a different number: %s", \
 583                         __got, __got, cmt); \
 584                 ret = false; \
 585                 goto label; \
 586         } \
 587         } while(0)
 588
 589 #define torture_assert_u32_equal(torture_ctx,got,expected,cmt)\
 590         do { uint32_t __got = (got), __expected = (expected); \
 591         if (__got != __expected) { \
 592                 torture_result(torture_ctx, TORTURE_FAIL, \
 593                         __location__": "#got" was %"PRIu32" (0x%"PRIX32"), expected %"PRIu32" (0x%"PRIX32"): %s", \
 594                         __got, __got, \
 595                         __expected, __expected, \
 596                         cmt); \
 597                 return false; \
 598         } \
 599         } while(0)
 600
 601 #define torture_assert_u32_equal_goto(torture_ctx,got,expected,ret,label,cmt)\
 602         do { uint32_t __got = (got), __expected = (expected); \
 603         if (__got != __expected) { \
 604                 torture_result(torture_ctx, TORTURE_FAIL, \
 605                         __location__": "#got" was %"PRIu32" (0x%"PRIX32"), expected %"PRIu32" (0x%"PRIX32"): %s", \
 606                         __got, __got, \
 607                         __expected, __expected, \
 608                         cmt); \
 609                 ret = false; \
 610                 goto label; \
 611         } \
 612         } while(0)
 613
 614 #define torture_assert_u32_not_equal(torture_ctx,got,not_expected,cmt)\
 615         do { uint32_t __got = (got), __not_expected = (not_expected); \
 616         if (__got == __not_expected) { \
 617                 torture_result(torture_ctx, TORTURE_FAIL, \
 618                         __location__": "#got" was %"PRIu32" (0x%"PRIX32"), expected a different number: %s", \
 619                         __got, __got, \
 620                         cmt); \
 621                 return false; \
 622         } \
 623         } while(0)
 624
 625 #define torture_assert_u32_not_equal_goto(torture_ctx,got,not_expected,ret,label,cmt)\
 626         do { uint32_t __got = (got), __not_expected = (not_expected); \
 627         if (__got == __not_expected) { \
 628                 torture_result(torture_ctx, TORTURE_FAIL, \
 629                         __location__": "#got" was %"PRIu32" (0x%"PRIX32"), expected a different number: %s", \
 630                         __got, __got, \
 631                         cmt); \
 632                 ret = false; \
 633                 goto label; \
 634         } \
 635         } while(0)
 636
 637 #define torture_assert_u64_equal(torture_ctx,got,expected,cmt)\
 638         do { uint64_t __got = (got), __expected = (expected); \
 639         if (__got != __expected) { \
 640                 torture_result(torture_ctx, TORTURE_FAIL, \
 641                         __location__": "#got" was %"PRIu64" (0x%"PRIX64"), expected %"PRIu64" (0x%"PRIX64"): %s", \
 642                         __got, __got, \
 643                         __expected, __expected, \
 644                         cmt); \
 645                 return false; \
 646         } \
 647         } while(0)
 648
 649 #define torture_assert_u64_equal_goto(torture_ctx,got,expected,ret,label,cmt)\
 650         do { uint64_t __got = (got), __expected = (expected); \
 651         if (__got != __expected) { \
 652                 torture_result(torture_ctx, TORTURE_FAIL, \
 653                         __location__": "#got" was %"PRIu64" (0x%"PRIX64"), expected %"PRIu64" (0x%"PRIX64"): %s", \
 654                         __got, __got, \
 655                         __expected, __expected, \
 656                         cmt); \
 657                 ret = false; \
 658                 goto label; \
 659         } \
 660         } while(0)
 661
 662 #define torture_assert_u64_not_equal(torture_ctx,got,not_expected,cmt)\
 663         do { uint64_t __got = (got), __not_expected = (not_expected); \
 664         if (__got == __not_expected) { \
 665                 torture_result(torture_ctx, TORTURE_FAIL, \
 666                         __location__": "#got" was %"PRIu64" (0x%"PRIX64"), expected a different number: %s", \
 667                         __got, __got, \
 668                         cmt); \
 669                 return false; \
 670         } \
 671         } while(0)
 672
 673 #define torture_assert_u64_not_equal_goto(torture_ctx,got,not_expected,ret,label,cmt)\
 674         do { uint64_t __got = (got), __not_expected = (not_expected); \
 675         if (__got == __not_expected) { \
 676                 torture_result(torture_ctx, TORTURE_FAIL, \
 677                         __location__": "#got" was %"PRIu64" (0x%"PRIX64"), expected a different number: %s", \
 678                         __got, __got, \
 679                         cmt); \
 680                 ret = false; \
 681                 goto label; \
 682         } \
 683         } while(0)
 684
 685 #define torture_assert_size_equal(torture_ctx,got,expected,cmt)\
 686         do { size_t __got = (got), __expected = (expected); \
 687         if (__got != __expected) { \
 688                 torture_result(torture_ctx, TORTURE_FAIL, \
 689                         __location__": "#got" was %zu (0x%zX), expected %zu (0x%zX): %s", \
 690                         __got, __got, \
 691                         __expected, __expected, \
 692                         cmt); \
 693                 return false; \
 694         } \
 695         } while(0)
 696
 697 #define torture_assert_size_equal_goto(torture_ctx,got,expected,ret,label,cmt)\
 698         do { size_t __got = (got), __expected = (expected); \
 699         if (__got != __expected) { \
 700                 torture_result(torture_ctx, TORTURE_FAIL, \
 701                         __location__": "#got" was %zu (0x%zX), expected %zu (0x%zX): %s", \
 702                         __got, __got, \
 703                         __expected, __expected, \
 704                         cmt); \
 705                 ret = false; \
 706                 goto label; \
 707         } \
 708         } while(0)
 709
 710 #define torture_assert_size_not_equal(torture_ctx,got,not_expected,cmt)\
 711         do { size_t __got = (got), __not_expected = (not_expected); \
 712         if (__got == __not_expected) { \
 713                 torture_result(torture_ctx, TORTURE_FAIL, \
 714                         __location__": "#got" was %zu (0x%zX), expected a different number: %s", \
 715                         __got, __got, \
 716                         cmt); \
 717                 return false; \
 718         } \
 719         } while(0)
 720
 721 #define torture_assert_size_not_equal_goto(torture_ctx,got,not_expected,ret,label,cmt)\
 722         do { size_t __got = (got), __not_expected = (not_expected); \
 723         if (__got == __not_expected) { \
 724                 torture_result(torture_ctx, TORTURE_FAIL, \
 725                         __location__": "#got" was %zu (0x%zX), expected a different number: %s", \
 726                         __got, __got, \
 727                         cmt); \
 728                 ret = false; \
 729                 goto label; \
 730         } \
 731         } while(0)
 732
 733 #define torture_assert_errno_equal(torture_ctx,expected,cmt)\
 734         do { int __expected = (expected); \
 735         if (errno != __expected) { \
 736                 torture_result(torture_ctx, TORTURE_FAIL, \
 737                         __location__": errno was %d (%s), expected %d: %s: %s", \
 738                                            errno, strerror(errno), __expected, \
 739                                            strerror(__expected), cmt); \
 740                 return false; \
 741         } \
 742         } while(0)
 743
 744 #define torture_assert_errno_equal_goto(torture_ctx,expected,ret,label,cmt)\
 745         do { int __expected = (expected); \
 746         if (errno != __expected) { \
 747                 torture_result(torture_ctx, TORTURE_FAIL, \
 748                         __location__": errno was %d (%s), expected %d: %s: %s", \
 749                                            errno, strerror(errno), __expected, \
 750                                            strerror(__expected), cmt); \
 751                 ret = false; \
 752                 goto label; \
 753         } \
 754         } while(0)
 755
 756 #define torture_assert_guid_equal(torture_ctx,got,expected,cmt)\
 757         do {const struct GUID __got = (got), __expected = (expected); \
 758         if (!GUID_equal(&__got, &__expected)) { \
 759                 torture_result(torture_ctx, TORTURE_FAIL, \
 760                         __location__": "#got" was %s, expected %s: %s", \
 761                         GUID_string(torture_ctx, &__got), GUID_string(torture_ctx, &__expected), cmt); \
 762                 return false; \
 763         } \
 764         } while(0)
 765
 766 #define torture_assert_nttime_equal(torture_ctx,got,expected,cmt) \
 767         do { NTTIME __got = got, __expected = expected; \
 768         if (!nt_time_equal(&__got, &__expected)) { \
 769                 torture_result(torture_ctx, TORTURE_FAIL, __location__": "#got" was %s, expected %s: %s", nt_time_string(torture_ctx, __got), nt_time_string(torture_ctx, __expected), cmt); \
 770                 return false; \
 771         }\
 772         } while(0)
 773
 774 #define torture_assert_sid_equal(torture_ctx,got,expected,cmt)\
 775         do {const struct dom_sid *__got = (got), *__expected = (expected); \
 776         if (!dom_sid_equal(__got, __expected)) { \
 777                 torture_result(torture_ctx, TORTURE_FAIL, \
 778                                            __location__": "#got" was %s, expected %s: %s", \
 779                                            dom_sid_string(torture_ctx, __got), dom_sid_string(torture_ctx, __expected), cmt); \
 780                 return false; \
 781         } \
 782         } while(0)
 783
 784 #define torture_assert_not_null(torture_ctx,got,cmt)\
 785         do {const void *__got = (got); \
 786         if (__got == NULL) { \
 787                 torture_result(torture_ctx, TORTURE_FAIL, \
 788                         __location__": "#got" was NULL, expected != NULL: %s", \
 789                         cmt); \
 790                 return false; \
 791         } \
 792         } while(0)
 793
 794 #define torture_assert_not_null_goto(torture_ctx,got,ret,label,cmt)\
 795         do {const void *__got = (got); \
 796         if (__got == NULL) { \
 797                 torture_result(torture_ctx, TORTURE_FAIL, \
 798                         __location__": "#got" was NULL, expected != NULL: %s", \
 799                         cmt); \
 800                 ret = false; \
 801                 goto label; \
 802         } \
 803         } while(0)
 804
 805 #define torture_skip(torture_ctx,cmt) do {\
 806                 torture_result(torture_ctx, TORTURE_SKIP, __location__": %s", cmt);\
 807                 return true; \
 808         } while(0)
 809 #define torture_skip_goto(torture_ctx,label,cmt) do {\
 810                 torture_result(torture_ctx, TORTURE_SKIP, __location__": %s", cmt);\
 811                 goto label; \
 812         } while(0)
 813 #define torture_fail(torture_ctx,cmt) do {\
 814                 torture_result(torture_ctx, TORTURE_FAIL, __location__": %s", cmt);\
 815                 return false; \
 816         } while (0)
 817 #define torture_fail_goto(torture_ctx,label,cmt) do {\
 818                 torture_result(torture_ctx, TORTURE_FAIL, __location__": %s", cmt);\
 819                 goto label; \
 820         } while (0)
 821
 822 #define torture_out stderr
 823
 824 /* Convenience macros */
 825 #define torture_assert_ntstatus_ok(torture_ctx,expr,cmt) \
 826                 torture_assert_ntstatus_equal(torture_ctx,expr,NT_STATUS_OK,cmt)
 827
 828 #define torture_assert_ntstatus_ok_goto(torture_ctx,expr,ret,label,cmt) \
 829                 torture_assert_ntstatus_equal_goto(torture_ctx,expr,NT_STATUS_OK,ret,label,cmt)
 830
 831 #define torture_assert_werr_ok(torture_ctx,expr,cmt) \
 832                 torture_assert_werr_equal(torture_ctx,expr,WERR_OK,cmt)
 833
 834 #define torture_assert_werr_ok_goto(torture_ctx,expr,ret,label,cmt) \
 835                 torture_assert_werr_equal_goto(torture_ctx,expr,WERR_OK,ret,label,cmt)
 836
 837 #define torture_assert_ndr_success(torture_ctx,expr,cmt) \
 838                 torture_assert_ndr_err_equal(torture_ctx,expr,NDR_ERR_SUCCESS,cmt)
 839
 840 #define torture_assert_ndr_success_goto(torture_ctx,expr,ret,label,cmt) \
 841                 torture_assert_ndr_err_equal_goto(torture_ctx,expr,NDR_ERR_SUCCESS,ret,label,cmt)
 842
 843 #define torture_assert_hresult_ok(torture_ctx,expr,cmt) \
 844                 torture_assert_hresult_equal(torture_ctx,expr,HRES_ERROR(0), cmt)
 845
 846 /* Getting settings */
 847 const char *torture_setting_string(struct torture_context *test, \
 848                                                                    const char *name,
 849                                                                    const char *default_value);
 850
 851 int torture_setting_int(struct torture_context *test,
 852                                                 const char *name,
 853                                                 int default_value);
 854
 855 double torture_setting_double(struct torture_context *test,
 856                                                 const char *name,
 857                                                 double default_value);
 858
 859 bool torture_setting_bool(struct torture_context *test,
 860                                                   const char *name,
 861                                                   bool default_value);
 862
 863 struct torture_suite *torture_find_suite(struct torture_suite *parent,
 864                                                                                  const char *name);
 865
 866 unsigned long torture_setting_ulong(struct torture_context *test,
 867                                     const char *name,
 868                                     unsigned long default_value);
 869
 870 NTSTATUS torture_temp_dir(struct torture_context *tctx,
 871                                    const char *prefix,
 872                                    char **tempdir);
 873 NTSTATUS torture_deltree_outputdir(struct torture_context *tctx);
 874
 875 struct torture_test *torture_tcase_add_simple_test(struct torture_tcase *tcase,
 876                 const char *name,
 877                 bool (*run) (struct torture_context *test, void *tcase_data));
 878
 879
 880 bool torture_suite_init_tcase(struct torture_suite *suite,
 881                               struct torture_tcase *tcase,
 882                               const char *name);
 883 int torture_suite_children_count(const struct torture_suite *suite);
 884
 885 struct torture_context *torture_context_init(struct tevent_context *event_ctx, struct torture_results *results);
 886
 887 struct torture_results *torture_results_init(TALLOC_CTX *mem_ctx, const struct torture_ui_ops *ui_ops);
 888
 889 struct torture_context *torture_context_child(struct torture_context *tctx);
 890
 891 extern const struct torture_ui_ops torture_subunit_ui_ops;
 892 extern const struct torture_ui_ops torture_simple_ui_ops;
 893
 894 #endif /* __TORTURE_UI_H__ */