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