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