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
  28 struct torture_results *torture_results_init(TALLOC_CTX *mem_ctx, const struct torture_ui_ops *ui_ops)
  29 {
  30         struct torture_results *results = talloc_zero(mem_ctx, struct torture_results);
  31
  32         results->ui_ops = ui_ops;
  33         results->returncode = true;
  34
  35         if (ui_ops->init)
  36                 ui_ops->init(results);
  37
  38         return results;
  39 }
  40
  41 /**
  42  * Initialize a torture context
  43  */
  44 struct torture_context *torture_context_init(struct tevent_context *event_ctx,
  45                                                                                          struct torture_results *results)
  46 {
  47         struct torture_context *torture = talloc_zero(event_ctx,
  48                                                       struct torture_context);
  49
  50         if (torture == NULL)
  51                 return NULL;
  52
  53         torture->ev = event_ctx;
  54         torture->results = talloc_reference(torture, results);
  55
  56         return torture;
  57 }
  58
  59 /**
  60  * Create a sub torture context
  61  */
  62 struct torture_context *torture_context_child(struct torture_context *parent)
  63 {
  64         struct torture_context *subtorture = talloc_zero(parent, struct torture_context);
  65
  66         if (subtorture == NULL)
  67                 return NULL;
  68
  69         subtorture->ev = talloc_reference(subtorture, parent->ev);
  70         subtorture->lp_ctx = talloc_reference(subtorture, parent->lp_ctx);
  71         subtorture->outputdir = talloc_reference(subtorture, parent->outputdir);
  72         subtorture->results = talloc_reference(subtorture, parent->results);
  73
  74         return subtorture;
  75 }
  76
  77 /**
  78  create a temporary directory.
  79 */
  80 _PUBLIC_ NTSTATUS torture_temp_dir(struct torture_context *tctx,
  81                                    const char *prefix, 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 int torture_suite_children_count(const struct torture_suite *suite)
 249 {
 250         int ret = 0;
 251         struct torture_tcase *tcase;
 252         struct torture_test *test;
 253         struct torture_suite *tsuite;
 254         for (tcase = suite->testcases; tcase; tcase = tcase->next) {
 255                 for (test = tcase->tests; test; test = test->next) {
 256                         ret++;
 257                 }
 258         }
 259         for (tsuite = suite->children; tsuite; tsuite = tsuite->next) {
 260                 ret ++;
 261         }
 262         return ret;
 263 }
 264
 265 /**
 266  * Run a torture test suite.
 267  */
 268 bool torture_run_suite(struct torture_context *context,
 269                        struct torture_suite *suite)
 270 {
 271         return torture_run_suite_restricted(context, suite, NULL);
 272 }
 273
 274 bool torture_run_suite_restricted(struct torture_context *context,
 275                        struct torture_suite *suite, const char **restricted)
 276 {
 277         bool ret = true;
 278         struct torture_tcase *tcase;
 279         struct torture_suite *tsuite;
 280
 281         if (context->results->ui_ops->suite_start)
 282                 context->results->ui_ops->suite_start(context, suite);
 283
 284         /* FIXME: Adjust torture_suite_children_count if restricted != NULL */
 285         context->results->ui_ops->progress(context,
 286                 torture_suite_children_count(suite), TORTURE_PROGRESS_SET);
 287
 288         for (tcase = suite->testcases; tcase; tcase = tcase->next) {
 289                 ret &= torture_run_tcase_restricted(context, tcase, restricted);
 290         }
 291
 292         for (tsuite = suite->children; tsuite; tsuite = tsuite->next) {
 293                 context->results->ui_ops->progress(context, 0, TORTURE_PROGRESS_PUSH);
 294                 ret &= torture_run_suite_restricted(context, tsuite, restricted);
 295                 context->results->ui_ops->progress(context, 0, TORTURE_PROGRESS_POP);
 296         }
 297
 298         if (context->results->ui_ops->suite_finish)
 299                 context->results->ui_ops->suite_finish(context, suite);
 300
 301         return ret;
 302 }
 303
 304 void torture_ui_test_start(struct torture_context *context,
 305                            struct torture_tcase *tcase,
 306                            struct torture_test *test)
 307 {
 308         if (context->results->ui_ops->test_start)
 309                 context->results->ui_ops->test_start(context, tcase, test);
 310 }
 311
 312 void torture_ui_test_result(struct torture_context *context,
 313                             enum torture_result result,
 314                             const char *comment)
 315 {
 316         if (context->results->ui_ops->test_result)
 317                 context->results->ui_ops->test_result(context, result, comment);
 318
 319         if (result == TORTURE_ERROR || result == TORTURE_FAIL)
 320                 context->results->returncode = false;
 321 }
 322
 323 static bool test_needs_running(const char *name, const char **restricted)
 324 {
 325         int i;
 326         if (restricted == NULL)
 327                 return true;
 328         for (i = 0; restricted[i]; i++) {
 329                 if (!strcmp(name, restricted[i]))
 330                         return true;
 331         }
 332         return false;
 333 }
 334
 335 static bool internal_torture_run_test(struct torture_context *context,
 336                                           struct torture_tcase *tcase,
 337                                           struct torture_test *test,
 338                                           bool already_setup,
 339                                           const char **restricted)
 340 {
 341         bool success;
 342         char *old_testname = NULL;
 343         char *subunit_testname = NULL;
 344
 345         if (tcase == NULL || strcmp(test->name, tcase->name) != 0) {
 346                 subunit_testname = talloc_asprintf(context, "%s.%s", tcase->name, test->name);
 347         } else {
 348                 subunit_testname = talloc_strdup(context, test->name);
 349         }
 350
 351         if (!test_needs_running(subunit_testname, restricted))
 352                 return true;
 353
 354         context->active_tcase = tcase;
 355         context->active_test = test;
 356
 357         torture_ui_test_start(context, tcase, test);
 358
 359         context->last_reason = NULL;
 360         context->last_result = TORTURE_OK;
 361
 362         if (!already_setup && tcase->setup &&
 363                 !tcase->setup(context, &(tcase->data))) {
 364                 if (context->last_reason == NULL)
 365                         context->last_reason = talloc_strdup(context, "Setup failure");
 366                 context->last_result = TORTURE_ERROR;
 367                 success = false;
 368         } else if (test->dangerous &&
 369             !torture_setting_bool(context, "dangerous", false)) {
 370             context->last_result = TORTURE_SKIP;
 371             context->last_reason = talloc_asprintf(context,
 372                 "disabled %s - enable dangerous tests to use", test->name);
 373             success = true;
 374         } else {
 375             success = test->run(context, tcase, test);
 376
 377             if (!success && context->last_result == TORTURE_OK) {
 378                     if (context->last_reason == NULL)
 379                             context->last_reason = talloc_strdup(context, "Unknown error/failure");
 380                     context->last_result = TORTURE_ERROR;
 381             }
 382         }
 383
 384         if (!already_setup && tcase->teardown && !tcase->teardown(context, tcase->data)) {
 385                 if (context->last_reason == NULL)
 386                     context->last_reason = talloc_strdup(context, "Setup failure");
 387                 context->last_result = TORTURE_ERROR;
 388                 success = false;
 389         }
 390
 391         torture_ui_test_result(context, context->last_result,
 392                                context->last_reason);
 393
 394         talloc_free(context->last_reason);
 395
 396         context->active_test = NULL;
 397         context->active_tcase = NULL;
 398
 399         return success;
 400 }
 401
 402 bool torture_run_tcase(struct torture_context *context,
 403                        struct torture_tcase *tcase)
 404 {
 405         return torture_run_tcase_restricted(context, tcase, NULL);
 406 }
 407
 408 bool torture_run_tcase_restricted(struct torture_context *context,
 409                        struct torture_tcase *tcase, const char **restricted)
 410 {
 411         bool ret = true;
 412         struct torture_test *test;
 413         bool setup_succeeded = true;
 414         const char * setup_reason = "Setup failed";
 415
 416         context->active_tcase = tcase;
 417         if (context->results->ui_ops->tcase_start)
 418                 context->results->ui_ops->tcase_start(context, tcase);
 419
 420         if (tcase->fixture_persistent && tcase->setup) {
 421                 setup_succeeded = tcase->setup(context, &tcase->data);
 422         }
 423
 424         if (!setup_succeeded) {
 425                 /* Uh-oh. The setup failed, so we can't run any of the tests
 426                  * in this testcase. The subunit format doesn't specify what
 427                  * to do here, so we keep the failure reason, and manually
 428                  * use it to fail every test.
 429                  */
 430                 if (context->last_reason != NULL) {
 431                         setup_reason = talloc_asprintf(context,
 432                                 "Setup failed: %s", context->last_reason);
 433                 }
 434         }
 435
 436         for (test = tcase->tests; test; test = test->next) {
 437                 if (setup_succeeded) {
 438                         ret &= internal_torture_run_test(context, tcase, test,
 439                                         tcase->fixture_persistent, restricted);
 440                 } else {
 441                         context->active_tcase = tcase;
 442                         context->active_test = test;
 443                         torture_ui_test_start(context, tcase, test);
 444                         torture_ui_test_result(context, TORTURE_FAIL, setup_reason);
 445                 }
 446         }
 447
 448         if (setup_succeeded && tcase->fixture_persistent && tcase->teardown &&
 449                 !tcase->teardown(context, tcase->data)) {
 450                 ret = false;
 451         }
 452
 453         context->active_tcase = NULL;
 454         context->active_test = NULL;
 455
 456         if (context->results->ui_ops->tcase_finish)
 457                 context->results->ui_ops->tcase_finish(context, tcase);
 458
 459         return (!setup_succeeded) ? false : ret;
 460 }
 461
 462 bool torture_run_test(struct torture_context *context,
 463                                           struct torture_tcase *tcase,
 464                                           struct torture_test *test)
 465 {
 466         return internal_torture_run_test(context, tcase, test, false, NULL);
 467 }
 468
 469 bool torture_run_test_restricted(struct torture_context *context,
 470                                           struct torture_tcase *tcase,
 471                                           struct torture_test *test,
 472                                           const char **restricted)
 473 {
 474         return internal_torture_run_test(context, tcase, test, false, restricted);
 475 }
 476
 477 int torture_setting_int(struct torture_context *test, const char *name,
 478                                                         int default_value)
 479 {
 480         return lpcfg_parm_int(test->lp_ctx, NULL, "torture", name, default_value);
 481 }
 482
 483 unsigned long torture_setting_ulong(struct torture_context *test,
 484                                     const char *name,
 485                                     unsigned long default_value)
 486 {
 487         return lpcfg_parm_ulong(test->lp_ctx, NULL, "torture", name,
 488                              default_value);
 489 }
 490
 491 double torture_setting_double(struct torture_context *test, const char *name,
 492                                                         double default_value)
 493 {
 494         return lpcfg_parm_double(test->lp_ctx, NULL, "torture", name, default_value);
 495 }
 496
 497 bool torture_setting_bool(struct torture_context *test, const char *name,
 498                                                         bool default_value)
 499 {
 500         return lpcfg_parm_bool(test->lp_ctx, NULL, "torture", name, default_value);
 501 }
 502
 503 const char *torture_setting_string(struct torture_context *test,
 504                                    const char *name,
 505                                    const char *default_value)
 506 {
 507         const char *ret;
 508
 509         SMB_ASSERT(test != NULL);
 510         SMB_ASSERT(test->lp_ctx != NULL);
 511
 512         ret = lpcfg_parm_string(test->lp_ctx, NULL, "torture", name);
 513
 514         if (ret == NULL)
 515                 return default_value;
 516
 517         return ret;
 518 }
 519
 520 static bool wrap_test_with_simple_tcase_const (
 521                 struct torture_context *torture_ctx,
 522                 struct torture_tcase *tcase,
 523                 struct torture_test *test)
 524 {
 525         bool (*fn) (struct torture_context *, const void *tcase_data);
 526
 527         fn = test->fn;
 528
 529         return fn(torture_ctx, test->data);
 530 }
 531
 532 struct torture_tcase *torture_suite_add_simple_tcase_const(
 533                 struct torture_suite *suite, const char *name,
 534                 bool (*run) (struct torture_context *test, const void *),
 535                 const void *data)
 536 {
 537         struct torture_tcase *tcase;
 538         struct torture_test *test;
 539
 540         tcase = torture_suite_add_tcase(suite, name);
 541
 542         test = talloc(tcase, struct torture_test);
 543
 544         test->name = talloc_strdup(test, name);
 545         test->description = NULL;
 546         test->run = wrap_test_with_simple_tcase_const;
 547         test->fn = run;
 548         test->data = data;
 549         test->dangerous = false;
 550
 551         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
 552
 553         return tcase;
 554 }
 555
 556 static bool wrap_simple_test(struct torture_context *torture_ctx,
 557                              struct torture_tcase *tcase,
 558                              struct torture_test *test)
 559 {
 560         bool (*fn) (struct torture_context *);
 561
 562         fn = test->fn;
 563
 564         return fn(torture_ctx);
 565 }
 566
 567 struct torture_tcase *torture_suite_add_simple_test(
 568                                         struct torture_suite *suite,
 569                                         const char *name,
 570                                         bool (*run) (struct torture_context *test))
 571 {
 572         struct torture_test *test;
 573         struct torture_tcase *tcase;
 574
 575         tcase = torture_suite_add_tcase(suite, name);
 576
 577         test = talloc(tcase, struct torture_test);
 578
 579         test->name = talloc_strdup(test, name);
 580         test->description = NULL;
 581         test->run = wrap_simple_test;
 582         test->fn = run;
 583         test->dangerous = false;
 584
 585         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
 586
 587         return tcase;
 588 }
 589
 590 /**
 591  * Add a child testsuite to a testsuite.
 592  */
 593 bool torture_suite_add_suite(struct torture_suite *suite,
 594                              struct torture_suite *child)
 595 {
 596         if (child == NULL)
 597                 return false;
 598
 599         DLIST_ADD_END(suite->children, child, struct torture_suite *);
 600
 601         /* FIXME: Check for duplicates and return false if the
 602          * added suite already exists as a child */
 603
 604         return true;
 605 }
 606
 607 /**
 608  * Find the child testsuite with the specified name.
 609  */
 610 struct torture_suite *torture_find_suite(struct torture_suite *parent,
 611                                          const char *name)
 612 {
 613         struct torture_suite *child;
 614
 615         for (child = parent->children; child; child = child->next)
 616                 if (!strcmp(child->name, name))
 617                         return child;
 618
 619         return NULL;
 620 }
 621
 622 static bool wrap_test_with_simple_test_const(struct torture_context *torture_ctx,
 623                                        struct torture_tcase *tcase,
 624                                        struct torture_test *test)
 625 {
 626         bool (*fn) (struct torture_context *, const void *tcase_data);
 627
 628         fn = test->fn;
 629
 630         return fn(torture_ctx, tcase->data);
 631 }
 632
 633 struct torture_test *torture_tcase_add_simple_test_const(
 634                 struct torture_tcase *tcase,
 635                 const char *name,
 636                 bool (*run) (struct torture_context *test,
 637                         const void *tcase_data))
 638 {
 639         struct torture_test *test;
 640
 641         test = talloc(tcase, struct torture_test);
 642
 643         test->name = talloc_strdup(test, name);
 644         test->description = NULL;
 645         test->run = wrap_test_with_simple_test_const;
 646         test->fn = run;
 647         test->data = NULL;
 648         test->dangerous = false;
 649
 650         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
 651
 652         return test;
 653 }
 654
 655 static bool wrap_test_with_simple_test(struct torture_context *torture_ctx,
 656                                        struct torture_tcase *tcase,
 657                                        struct torture_test *test)
 658 {
 659         bool (*fn) (struct torture_context *, void *tcase_data);
 660
 661         fn = test->fn;
 662
 663         return fn(torture_ctx, tcase->data);
 664 }
 665
 666 struct torture_test *torture_tcase_add_simple_test(struct torture_tcase *tcase,
 667                 const char *name,
 668                 bool (*run) (struct torture_context *test, void *tcase_data))
 669 {
 670         struct torture_test *test;
 671
 672         test = talloc(tcase, struct torture_test);
 673
 674         test->name = talloc_strdup(test, name);
 675         test->description = NULL;
 676         test->run = wrap_test_with_simple_test;
 677         test->fn = run;
 678         test->data = NULL;
 679         test->dangerous = false;
 680
 681         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
 682
 683         return test;
 684 }
 685
 686 void torture_ui_report_time(struct torture_context *context)
 687 {
 688         if (context->results->ui_ops->report_time)
 689                 context->results->ui_ops->report_time(context);
 690 }