source4/lib/torture/torture.c

   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 #include "includes.h"
  22 #include "torture/torture.h"
  23 #include "../lib/util/dlinklist.h"
  24 #include "param/param.h"
  25 #include "system/filesys.h"
  26
  27 /**
  28  * Initialize a torture context
  29  */
  30 struct torture_context *torture_context_init(struct event_context *event_ctx,
  31                                                                                          const struct torture_ui_ops *ui_ops)
  32 {
  33         struct torture_context *torture = talloc_zero(event_ctx,
  34                                                       struct torture_context);
  35         torture->ui_ops = ui_ops;
  36         torture->returncode = true;
  37         torture->ev = event_ctx;
  38
  39         if (ui_ops->init)
  40                 ui_ops->init(torture);
  41
  42         return torture;
  43 }
  44
  45 /**
  46  create a temporary directory.
  47 */
  48 _PUBLIC_ NTSTATUS torture_temp_dir(struct torture_context *tctx,
  49                                    const char *prefix,
  50                                    char **tempdir)
  51 {
  52         SMB_ASSERT(tctx->outputdir != NULL);
  53
  54         *tempdir = talloc_asprintf(tctx, "%s/%s.XXXXXX", tctx->outputdir,
  55                                    prefix);
  56         NT_STATUS_HAVE_NO_MEMORY(*tempdir);
  57
  58         if (mkdtemp(*tempdir) == NULL) {
  59                 return map_nt_error_from_unix(errno);
  60         }
  61
  62         return NT_STATUS_OK;
  63 }
  64
  65 /**
  66  * Comment on the status/progress of a test
  67  */
  68 void torture_comment(struct torture_context *context, const char *comment, ...)
  69 {
  70         va_list ap;
  71         char *tmp;
  72
  73         if (!context->ui_ops->comment)
  74                 return;
  75
  76         va_start(ap, comment);
  77         tmp = talloc_vasprintf(context, comment, ap);
  78
  79         context->ui_ops->comment(context, tmp);
  80
  81         talloc_free(tmp);
  82 }
  83
  84 /**
  85  * Print a warning about the current test
  86  */
  87 void torture_warning(struct torture_context *context, const char *comment, ...)
  88 {
  89         va_list ap;
  90         char *tmp;
  91
  92         if (!context->ui_ops->warning)
  93                 return;
  94
  95         va_start(ap, comment);
  96         tmp = talloc_vasprintf(context, comment, ap);
  97
  98         context->ui_ops->warning(context, tmp);
  99
 100         talloc_free(tmp);
 101 }
 102
 103 /**
 104  * Store the result of a torture test.
 105  */
 106 void torture_result(struct torture_context *context,
 107                     enum torture_result result, const char *fmt, ...)
 108 {
 109         va_list ap;
 110
 111         va_start(ap, fmt);
 112
 113         if (context->last_reason) {
 114                 torture_warning(context, "%s", context->last_reason);
 115                 talloc_free(context->last_reason);
 116         }
 117
 118         context->last_result = result;
 119         context->last_reason = talloc_vasprintf(context, fmt, ap);
 120         va_end(ap);
 121 }
 122
 123 /**
 124  * Create a new torture suite
 125  */
 126 struct torture_suite *torture_suite_create(TALLOC_CTX *ctx, const char *name)
 127 {
 128         struct torture_suite *suite = talloc_zero(ctx, struct torture_suite);
 129
 130         suite->name = talloc_strdup(suite, name);
 131         suite->testcases = NULL;
 132         suite->children = NULL;
 133
 134         return suite;
 135 }
 136
 137 /**
 138  * Set the setup() and teardown() functions for a testcase.
 139  */
 140 void torture_tcase_set_fixture(struct torture_tcase *tcase,
 141                 bool (*setup) (struct torture_context *, void **),
 142                 bool (*teardown) (struct torture_context *, void *))
 143 {
 144         tcase->setup = setup;
 145         tcase->teardown = teardown;
 146 }
 147
 148 static bool wrap_test_with_testcase_const(struct torture_context *torture_ctx,
 149                                     struct torture_tcase *tcase,
 150                                     struct torture_test *test)
 151 {
 152         bool (*fn) (struct torture_context *,
 153                     const void *tcase_data,
 154                     const void *test_data);
 155
 156         fn = test->fn;
 157
 158         return fn(torture_ctx, tcase->data, test->data);
 159 }
 160
 161 /**
 162  * Add a test that uses const data to a testcase
 163  */
 164 struct torture_test *torture_tcase_add_test_const(struct torture_tcase *tcase,
 165                 const char *name,
 166                 bool (*run) (struct torture_context *, const void *tcase_data,
 167                         const void *test_data),
 168                 const void *data)
 169 {
 170         struct torture_test *test = talloc(tcase, struct torture_test);
 171
 172         test->name = talloc_strdup(test, name);
 173         test->description = NULL;
 174         test->run = wrap_test_with_testcase_const;
 175         test->fn = run;
 176         test->dangerous = false;
 177         test->data = data;
 178
 179         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
 180
 181         return test;
 182 }
 183
 184 /**
 185  * Add a new testcase
 186  */
 187 bool torture_suite_init_tcase(struct torture_suite *suite,
 188                               struct torture_tcase *tcase,
 189                               const char *name)
 190 {
 191         tcase->name = talloc_strdup(tcase, name);
 192         tcase->description = NULL;
 193         tcase->setup = NULL;
 194         tcase->teardown = NULL;
 195         tcase->fixture_persistent = true;
 196         tcase->tests = NULL;
 197
 198         DLIST_ADD_END(suite->testcases, tcase, struct torture_tcase *);
 199
 200         return true;
 201 }
 202
 203
 204 struct torture_tcase *torture_suite_add_tcase(struct torture_suite *suite,
 205                                                          const char *name)
 206 {
 207         struct torture_tcase *tcase = talloc(suite, struct torture_tcase);
 208
 209         if (!torture_suite_init_tcase(suite, tcase, name))
 210                 return NULL;
 211
 212         return tcase;
 213 }
 214
 215 /**
 216  * Run a torture test suite.
 217  */
 218 bool torture_run_suite(struct torture_context *context,
 219                        struct torture_suite *suite)
 220 {
 221         bool ret = true;
 222         struct torture_tcase *tcase;
 223         struct torture_suite *tsuite;
 224         char *old_testname;
 225
 226         context->level++;
 227         if (context->ui_ops->suite_start)
 228                 context->ui_ops->suite_start(context, suite);
 229
 230         old_testname = context->active_testname;
 231         if (old_testname != NULL)
 232                 context->active_testname = talloc_asprintf(context, "%s-%s",
 233                                                            old_testname, suite->name);
 234         else
 235                 context->active_testname = talloc_strdup(context, suite->name);
 236
 237         for (tcase = suite->testcases; tcase; tcase = tcase->next) {
 238                 ret &= torture_run_tcase(context, tcase);
 239         }
 240
 241         for (tsuite = suite->children; tsuite; tsuite = tsuite->next) {
 242                 ret &= torture_run_suite(context, tsuite);
 243         }
 244
 245         talloc_free(context->active_testname);
 246         context->active_testname = old_testname;
 247
 248         if (context->ui_ops->suite_finish)
 249                 context->ui_ops->suite_finish(context, suite);
 250
 251         context->level--;
 252
 253         return ret;
 254 }
 255
 256 void torture_ui_test_start(struct torture_context *context,
 257                            struct torture_tcase *tcase,
 258                            struct torture_test *test)
 259 {
 260         if (context->ui_ops->test_start)
 261                 context->ui_ops->test_start(context, tcase, test);
 262 }
 263
 264 void torture_ui_test_result(struct torture_context *context,
 265                             enum torture_result result,
 266                             const char *comment)
 267 {
 268         if (context->ui_ops->test_result)
 269                 context->ui_ops->test_result(context, result, comment);
 270
 271         if (result == TORTURE_ERROR || result == TORTURE_FAIL)
 272                 context->returncode = false;
 273 }
 274
 275 static bool internal_torture_run_test(struct torture_context *context,
 276                                           struct torture_tcase *tcase,
 277                                           struct torture_test *test,
 278                                           bool already_setup)
 279 {
 280         bool success;
 281         char *old_testname;
 282
 283         if (tcase == NULL || strcmp(test->name, tcase->name) != 0) {
 284                 old_testname = context->active_testname;
 285                 context->active_testname = talloc_asprintf(context, "%s-%s", old_testname, test->name);
 286         }
 287
 288         context->active_tcase = tcase;
 289         context->active_test = test;
 290
 291         torture_ui_test_start(context, tcase, test);
 292
 293         context->last_reason = NULL;
 294         context->last_result = TORTURE_OK;
 295
 296         if (!already_setup && tcase->setup &&
 297                 !tcase->setup(context, &(tcase->data))) {
 298                 if (context->last_reason == NULL)
 299                         context->last_reason = talloc_strdup(context, "Setup failure");
 300                 context->last_result = TORTURE_ERROR;
 301                 success = false;
 302         } else if (test->dangerous &&
 303             !torture_setting_bool(context, "dangerous", false)) {
 304             context->last_result = TORTURE_SKIP;
 305             context->last_reason = talloc_asprintf(context,
 306                 "disabled %s - enable dangerous tests to use", test->name);
 307             success = true;
 308         } else {
 309             success = test->run(context, tcase, test);
 310
 311             if (!success && context->last_result == TORTURE_OK) {
 312                     if (context->last_reason == NULL)
 313                             context->last_reason = talloc_strdup(context, "Unknown error/failure");
 314                     context->last_result = TORTURE_ERROR;
 315             }
 316         }
 317
 318         if (!already_setup && tcase->teardown && !tcase->teardown(context, tcase->data)) {
 319                 if (context->last_reason == NULL)
 320                     context->last_reason = talloc_strdup(context, "Setup failure");
 321                 context->last_result = TORTURE_ERROR;
 322                 success = false;
 323         }
 324
 325         torture_ui_test_result(context, context->last_result,
 326                                context->last_reason);
 327
 328         talloc_free(context->last_reason);
 329
 330         if (tcase == NULL || strcmp(test->name, tcase->name) != 0) {
 331                 talloc_free(context->active_testname);
 332                 context->active_testname = old_testname;
 333         }
 334         context->active_test = NULL;
 335         context->active_tcase = NULL;
 336
 337         return success;
 338 }
 339
 340 bool torture_run_tcase(struct torture_context *context,
 341                        struct torture_tcase *tcase)
 342 {
 343         bool ret = true;
 344         char *old_testname;
 345         struct torture_test *test;
 346
 347         context->level++;
 348
 349         context->active_tcase = tcase;
 350         if (context->ui_ops->tcase_start)
 351                 context->ui_ops->tcase_start(context, tcase);
 352
 353         if (tcase->fixture_persistent && tcase->setup
 354                 && !tcase->setup(context, &tcase->data)) {
 355                 /* FIXME: Use torture ui ops for reporting this error */
 356                 fprintf(stderr, "Setup failed: ");
 357                 if (context->last_reason != NULL)
 358                         fprintf(stderr, "%s", context->last_reason);
 359                 fprintf(stderr, "\n");
 360                 ret = false;
 361                 goto done;
 362         }
 363
 364         old_testname = context->active_testname;
 365         context->active_testname = talloc_asprintf(context, "%s-%s",
 366                                                    old_testname, tcase->name);
 367         for (test = tcase->tests; test; test = test->next) {
 368                 ret &= internal_torture_run_test(context, tcase, test,
 369                                 tcase->fixture_persistent);
 370         }
 371         talloc_free(context->active_testname);
 372         context->active_testname = old_testname;
 373
 374         if (tcase->fixture_persistent && tcase->teardown &&
 375                 !tcase->teardown(context, tcase->data))
 376                 ret = false;
 377
 378 done:
 379         context->active_tcase = NULL;
 380
 381         if (context->ui_ops->tcase_finish)
 382                 context->ui_ops->tcase_finish(context, tcase);
 383
 384         context->level--;
 385
 386         return ret;
 387 }
 388
 389 bool torture_run_test(struct torture_context *context,
 390                                           struct torture_tcase *tcase,
 391                                           struct torture_test *test)
 392 {
 393         return internal_torture_run_test(context, tcase, test, false);
 394 }
 395
 396 int torture_setting_int(struct torture_context *test, const char *name,
 397                                                         int default_value)
 398 {
 399         return lp_parm_int(test->lp_ctx, NULL, "torture", name, default_value);
 400 }
 401
 402 double torture_setting_double(struct torture_context *test, const char *name,
 403                                                         double default_value)
 404 {
 405         return lp_parm_double(test->lp_ctx, NULL, "torture", name, default_value);
 406 }
 407
 408 bool torture_setting_bool(struct torture_context *test, const char *name,
 409                                                         bool default_value)
 410 {
 411         return lp_parm_bool(test->lp_ctx, NULL, "torture", name, default_value);
 412 }
 413
 414 const char *torture_setting_string(struct torture_context *test,
 415                                    const char *name,
 416                                    const char *default_value)
 417 {
 418         const char *ret;
 419
 420         SMB_ASSERT(test != NULL);
 421         SMB_ASSERT(test->lp_ctx != NULL);
 422
 423         ret = lp_parm_string(test->lp_ctx, NULL, "torture", name);
 424
 425         if (ret == NULL)
 426                 return default_value;
 427
 428         return ret;
 429 }
 430
 431 static bool wrap_test_with_simple_tcase_const (
 432                 struct torture_context *torture_ctx,
 433                 struct torture_tcase *tcase,
 434                 struct torture_test *test)
 435 {
 436         bool (*fn) (struct torture_context *, const void *tcase_data);
 437
 438         fn = test->fn;
 439
 440         return fn(torture_ctx, test->data);
 441 }
 442
 443 struct torture_tcase *torture_suite_add_simple_tcase_const(
 444                 struct torture_suite *suite, const char *name,
 445                 bool (*run) (struct torture_context *test, const void *),
 446                 const void *data)
 447 {
 448         struct torture_tcase *tcase;
 449         struct torture_test *test;
 450
 451         tcase = torture_suite_add_tcase(suite, name);
 452
 453         test = talloc(tcase, struct torture_test);
 454
 455         test->name = talloc_strdup(test, name);
 456         test->description = NULL;
 457         test->run = wrap_test_with_simple_tcase_const;
 458         test->fn = run;
 459         test->data = data;
 460         test->dangerous = false;
 461
 462         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
 463
 464         return tcase;
 465 }
 466
 467 static bool wrap_simple_test(struct torture_context *torture_ctx,
 468                              struct torture_tcase *tcase,
 469                              struct torture_test *test)
 470 {
 471         bool (*fn) (struct torture_context *);
 472
 473         fn = test->fn;
 474
 475         return fn(torture_ctx);
 476 }
 477
 478 struct torture_tcase *torture_suite_add_simple_test(
 479                                         struct torture_suite *suite,
 480                                         const char *name,
 481                                         bool (*run) (struct torture_context *test))
 482 {
 483         struct torture_test *test;
 484         struct torture_tcase *tcase;
 485
 486         tcase = torture_suite_add_tcase(suite, name);
 487
 488         test = talloc(tcase, struct torture_test);
 489
 490         test->name = talloc_strdup(test, name);
 491         test->description = NULL;
 492         test->run = wrap_simple_test;
 493         test->fn = run;
 494         test->dangerous = false;
 495
 496         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
 497
 498         return tcase;
 499 }
 500
 501 /**
 502  * Add a child testsuite to a testsuite.
 503  */
 504 bool torture_suite_add_suite(struct torture_suite *suite,
 505                              struct torture_suite *child)
 506 {
 507         if (child == NULL)
 508                 return false;
 509
 510         DLIST_ADD_END(suite->children, child, struct torture_suite *);
 511
 512         /* FIXME: Check for duplicates and return false if the
 513          * added suite already exists as a child */
 514
 515         return true;
 516 }
 517
 518 /**
 519  * Find the child testsuite with the specified name.
 520  */
 521 struct torture_suite *torture_find_suite(struct torture_suite *parent,
 522                                          const char *name)
 523 {
 524         struct torture_suite *child;
 525
 526         for (child = parent->children; child; child = child->next)
 527                 if (!strcmp(child->name, name))
 528                         return child;
 529
 530         return NULL;
 531 }
 532
 533 static bool wrap_test_with_simple_test_const(struct torture_context *torture_ctx,
 534                                        struct torture_tcase *tcase,
 535                                        struct torture_test *test)
 536 {
 537         bool (*fn) (struct torture_context *, const void *tcase_data);
 538
 539         fn = test->fn;
 540
 541         return fn(torture_ctx, tcase->data);
 542 }
 543
 544 struct torture_test *torture_tcase_add_simple_test_const(
 545                 struct torture_tcase *tcase,
 546                 const char *name,
 547                 bool (*run) (struct torture_context *test,
 548                         const void *tcase_data))
 549 {
 550         struct torture_test *test;
 551
 552         test = talloc(tcase, struct torture_test);
 553
 554         test->name = talloc_strdup(test, name);
 555         test->description = NULL;
 556         test->run = wrap_test_with_simple_test_const;
 557         test->fn = run;
 558         test->data = NULL;
 559         test->dangerous = false;
 560
 561         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
 562
 563         return test;
 564 }
 565
 566 static bool wrap_test_with_simple_test(struct torture_context *torture_ctx,
 567                                        struct torture_tcase *tcase,
 568                                        struct torture_test *test)
 569 {
 570         bool (*fn) (struct torture_context *, void *tcase_data);
 571
 572         fn = test->fn;
 573
 574         return fn(torture_ctx, tcase->data);
 575 }
 576
 577 struct torture_test *torture_tcase_add_simple_test(struct torture_tcase *tcase,
 578                 const char *name,
 579                 bool (*run) (struct torture_context *test, void *tcase_data))
 580 {
 581         struct torture_test *test;
 582
 583         test = talloc(tcase, struct torture_test);
 584
 585         test->name = talloc_strdup(test, name);
 586         test->description = NULL;
 587         test->run = wrap_test_with_simple_test;
 588         test->fn = run;
 589         test->data = NULL;
 590         test->dangerous = false;
 591
 592         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
 593
 594         return test;
 595 }