lib/torture/torture.c

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