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