source/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 2 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, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23 #include "torture/ui.h"
  24 #include "torture/torture.h"
  25 #include "lib/util/dlinklist.h"
  26
  27 void torture_comment(struct torture_context *context,
  28                                                  const char *comment, ...)
  29 {
  30         va_list ap;
  31         char *tmp;
  32
  33         if (!context->ui_ops->comment)
  34                 return;
  35
  36         va_start(ap, comment);
  37         tmp = talloc_vasprintf(context, comment, ap);
  38
  39         context->ui_ops->comment(context, tmp);
  40
  41         talloc_free(tmp);
  42 }
  43
  44 void _torture_fail_ext(struct torture_context *context,
  45                                           const char *fmt, ...)
  46 {
  47         va_list ap;
  48
  49         va_start(ap, fmt);
  50         context->last_reason = talloc_vasprintf(context, fmt, ap);
  51         /* make sure the reason for the failure is displayed */
  52         if (context->ui_ops->comment)
  53                 context->ui_ops->comment(context, context->last_reason);
  54         va_end(ap);
  55         context->last_result = TORTURE_FAIL;
  56 }
  57
  58 void _torture_skip_ext(struct torture_context *context,
  59                                           const char *fmt, ...)
  60 {
  61         va_list ap;
  62         context->skipped++;
  63
  64         va_start(ap, fmt);
  65         context->last_result = TORTURE_SKIP;
  66         context->last_reason = talloc_vasprintf(context, fmt, ap);
  67         va_end(ap);
  68 }
  69
  70 struct torture_suite *torture_suite_create(TALLOC_CTX *ctx, const char *name)
  71 {
  72         struct torture_suite *suite = talloc_zero(ctx, struct torture_suite);
  73
  74         suite->name = talloc_strdup(suite, name);
  75         suite->testcases = NULL;
  76         suite->children = NULL;
  77
  78         return suite;
  79 }
  80
  81 void torture_tcase_set_fixture(struct torture_tcase *tcase,
  82                 BOOL (*setup) (struct torture_context *, void **),
  83                 BOOL (*teardown) (struct torture_context *, void *))
  84 {
  85         tcase->setup = setup;
  86         tcase->teardown = teardown;
  87 }
  88
  89 static bool wrap_test_with_testcase(struct torture_context *torture_ctx,
  90                                                                         struct torture_tcase *tcase,
  91                                                                         struct torture_test *test)
  92 {
  93         bool (*fn) (struct torture_context *,
  94                                  const void *tcase_data,
  95                                  const void *test_data);
  96
  97         fn = test->fn;
  98
  99         return fn(torture_ctx, tcase->data, test->data);
 100 }
 101
 102 struct torture_test *torture_tcase_add_test(struct torture_tcase *tcase,
 103                                                 const char *name,
 104                                                 bool (*run) (struct torture_context *,
 105                                                                          const void *tcase_data,
 106                                                                          const void *test_data),
 107                                                 const void *data)
 108 {
 109         struct torture_test *test = talloc(tcase, struct torture_test);
 110
 111         test->name = talloc_strdup(test, name);
 112         test->description = NULL;
 113         test->run = wrap_test_with_testcase;
 114         test->fn = run;
 115         test->dangerous = False;
 116         test->data = data;
 117
 118         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
 119
 120         return test;
 121 }
 122
 123 struct torture_tcase *torture_suite_add_tcase(struct torture_suite *suite,
 124                                                          const char *name)
 125 {
 126         struct torture_tcase *tcase = talloc(suite, struct torture_tcase);
 127
 128         tcase->name = talloc_strdup(tcase, name);
 129         tcase->description = NULL;
 130         tcase->setup = NULL;
 131         tcase->teardown = NULL;
 132         tcase->fixture_persistent = True;
 133         tcase->tests = NULL;
 134
 135         DLIST_ADD_END(suite->testcases, tcase, struct torture_tcase *);
 136
 137         return tcase;
 138 }
 139
 140 BOOL torture_run_suite(struct torture_context *context,
 141                                            struct torture_suite *suite)
 142 {
 143         BOOL ret = True;
 144         struct torture_tcase *tcase;
 145         struct torture_suite *tsuite;
 146
 147         context->level++;
 148         if (context->ui_ops->suite_start)
 149                 context->ui_ops->suite_start(context, suite);
 150
 151         if (suite->path)
 152                 torture_subunit_run_suite(context, suite);
 153
 154         for (tcase = suite->testcases; tcase; tcase = tcase->next) {
 155                 ret &= torture_run_tcase(context, tcase);
 156         }
 157
 158         for (tsuite = suite->children; tsuite; tsuite = tsuite->next) {
 159                 ret &= torture_run_suite(context, tsuite);
 160         }
 161
 162         if (context->ui_ops->suite_finish)
 163                 context->ui_ops->suite_finish(context, suite);
 164
 165         context->level--;
 166
 167         return ret;
 168 }
 169
 170 void torture_ui_test_start(struct torture_context *context,
 171                                                            struct torture_tcase *tcase,
 172                                                            struct torture_test *test)
 173 {
 174         if (context->ui_ops->test_start)
 175                 context->ui_ops->test_start(context, tcase, test);
 176 }
 177
 178 void torture_ui_test_result(struct torture_context *context,
 179                                                                 enum torture_result result,
 180                                                                 const char *comment)
 181 {
 182         if (context->ui_ops->test_result)
 183                 context->ui_ops->test_result(context, result, comment);
 184
 185
 186         switch (result) {
 187                 case TORTURE_SKIP: context->success++; break;
 188                 case TORTURE_FAIL: context->failed++; break;
 189                 case TORTURE_TODO: context->todo++; break;
 190                 case TORTURE_OK: context->success++; break;
 191         }
 192 }
 193
 194 static BOOL internal_torture_run_test(struct torture_context *context,
 195                                           struct torture_tcase *tcase,
 196                                           struct torture_test *test,
 197                                           BOOL already_setup)
 198 {
 199         BOOL ret;
 200
 201         if (test->dangerous && !torture_setting_bool(context, "dangerous", False)) {
 202                 _torture_skip_ext(context,
 203                                 "disabled %s - enable dangerous tests to use", test->name);
 204                 return True;
 205         }
 206
 207         if (!already_setup && tcase->setup &&
 208                 !tcase->setup(context, &(tcase->data)))
 209                 return False;
 210
 211         context->active_tcase = tcase;
 212         context->active_test = test;
 213
 214         torture_ui_test_start(context, tcase, test);
 215
 216         context->last_reason = NULL;
 217         context->last_result = TORTURE_OK;
 218
 219         ret = test->run(context, tcase, test);
 220         if (!ret) {
 221                 if (context->last_reason == NULL)
 222                         context->last_reason = talloc_strdup(context, "...");
 223                 context->last_result = TORTURE_FAIL;
 224         }
 225
 226         torture_ui_test_result(context, context->last_result, context->last_reason);
 227
 228         talloc_free(context->last_reason);
 229
 230         context->active_test = NULL;
 231         context->active_tcase = NULL;
 232
 233         if (!already_setup && tcase->teardown && !tcase->teardown(context, tcase->data))
 234                 return False;
 235
 236         return ret;
 237 }
 238
 239 BOOL torture_run_tcase(struct torture_context *context,
 240                                            struct torture_tcase *tcase)
 241 {
 242         BOOL ret = True;
 243         struct torture_test *test;
 244
 245         context->level++;
 246
 247         context->active_tcase = tcase;
 248         if (context->ui_ops->tcase_start)
 249                 context->ui_ops->tcase_start(context, tcase);
 250
 251         if (tcase->fixture_persistent && tcase->setup
 252                 && !tcase->setup(context, &tcase->data)) {
 253                 ret = False;
 254                 goto done;
 255         }
 256
 257         for (test = tcase->tests; test; test = test->next) {
 258                 ret &= internal_torture_run_test(context, tcase, test,
 259                                 tcase->fixture_persistent);
 260         }
 261
 262         if (tcase->fixture_persistent && tcase->teardown &&
 263                 !tcase->teardown(context, tcase->data))
 264                 ret = False;
 265
 266 done:
 267         context->active_tcase = NULL;
 268
 269         if (context->ui_ops->tcase_finish)
 270                 context->ui_ops->tcase_finish(context, tcase);
 271
 272         context->level--;
 273
 274         return ret;
 275 }
 276
 277 BOOL torture_run_test(struct torture_context *context,
 278                                           struct torture_tcase *tcase,
 279                                           struct torture_test *test)
 280 {
 281         return internal_torture_run_test(context, tcase, test, False);
 282 }
 283
 284 int torture_setting_int(struct torture_context *test, const char *name,
 285                                                         int default_value)
 286 {
 287         return lp_parm_int(-1, "torture", name, default_value);
 288 }
 289
 290 bool torture_setting_bool(struct torture_context *test, const char *name,
 291                                                         bool default_value)
 292 {
 293         return lp_parm_bool(-1, "torture", name, default_value);
 294 }
 295
 296 const char *torture_setting_string(struct torture_context *test, const char *name,
 297                                                         const char *default_value)
 298 {
 299         const char *ret = lp_parm_string(-1, "torture", name);
 300
 301         if (ret == NULL)
 302                 return default_value;
 303
 304         return ret;
 305 }
 306
 307 static bool wrap_test_with_simple_tcase(struct torture_context *torture_ctx,
 308                                                                         struct torture_tcase *tcase,
 309                                                                         struct torture_test *test)
 310 {
 311         bool (*fn) (struct torture_context *, const void *tcase_data);
 312
 313         fn = test->fn;
 314
 315         return fn(torture_ctx, test->data);
 316 }
 317
 318 struct torture_tcase *torture_suite_add_simple_tcase(
 319                                         struct torture_suite *suite,
 320                                         const char *name,
 321                                         bool (*run) (struct torture_context *test, const void *),
 322                                         const void *data)
 323 {
 324         struct torture_tcase *tcase;
 325         struct torture_test *test;
 326
 327         tcase = torture_suite_add_tcase(suite, name);
 328
 329         test = talloc(tcase, struct torture_test);
 330
 331         test->name = talloc_strdup(test, name);
 332         test->description = NULL;
 333         test->run = wrap_test_with_simple_tcase;
 334         test->fn = run;
 335         test->data = data;
 336         test->dangerous = False;
 337
 338         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
 339
 340         return tcase;
 341 }
 342
 343 static bool wrap_simple_test(struct torture_context *torture_ctx,
 344                                                                         struct torture_tcase *tcase,
 345                                                                         struct torture_test *test)
 346 {
 347         bool (*fn) (struct torture_context *);
 348
 349         fn = test->fn;
 350
 351         return fn(torture_ctx);
 352 }
 353
 354 struct torture_tcase *torture_suite_add_simple_test(
 355                                         struct torture_suite *suite,
 356                                         const char *name,
 357                                         bool (*run) (struct torture_context *test))
 358 {
 359         struct torture_test *test;
 360         struct torture_tcase *tcase;
 361
 362         tcase = torture_suite_add_tcase(suite, name);
 363
 364         test = talloc(tcase, struct torture_test);
 365
 366         test->name = talloc_strdup(test, name);
 367         test->description = NULL;
 368         test->run = wrap_simple_test;
 369         test->fn = run;
 370         test->dangerous = false;
 371
 372         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
 373
 374         return tcase;
 375 }
 376
 377 BOOL torture_teardown_free(struct torture_context *torture, void *data)
 378 {
 379         return talloc_free(data);
 380 }
 381
 382
 383 bool torture_suite_add_suite(struct torture_suite *suite,
 384                                                          struct torture_suite *child)
 385 {
 386         if (child == NULL)
 387                 return false;
 388
 389         DLIST_ADD_END(suite->children, child, struct torture_suite *);
 390
 391         /* FIXME: Check for duplicates and return false if the
 392          * added suite already exists as a child */
 393
 394         return true;
 395 }
 396
 397
 398 struct torture_suite *torture_find_suite(struct torture_suite *parent,
 399                                                                                  const char *name)
 400 {
 401         struct torture_suite *child;
 402
 403         for (child = parent->children; child; child = child->next)
 404                 if (!strcmp(child->name, name))
 405                         return child;
 406
 407         return NULL;
 408 }