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 #include "system/dir.h"
  27
  28
  29 struct torture_results *torture_results_init(TALLOC_CTX *mem_ctx, const struct torture_ui_ops *ui_ops)
  30 {
  31         struct torture_results *results = talloc_zero(mem_ctx, struct torture_results);
  32
  33         results->ui_ops = ui_ops;
  34         results->returncode = true;
  35
  36         if (ui_ops->init)
  37                 ui_ops->init(results);
  38
  39         return results;
  40 }
  41
  42 /**
  43  * Initialize a torture context
  44  */
  45 struct torture_context *torture_context_init(struct tevent_context *event_ctx,
  46                                                                                          struct torture_results *results)
  47 {
  48         struct torture_context *torture = talloc_zero(event_ctx,
  49                                                       struct torture_context);
  50
  51         if (torture == NULL)
  52                 return NULL;
  53
  54         torture->ev = event_ctx;
  55         torture->results = talloc_reference(torture, results);
  56
  57         return torture;
  58 }
  59
  60 /**
  61  * Create a sub torture context
  62  */
  63 struct torture_context *torture_context_child(struct torture_context *parent)
  64 {
  65         struct torture_context *subtorture = talloc_zero(parent, struct torture_context);
  66
  67         if (subtorture == NULL)
  68                 return NULL;
  69
  70         subtorture->ev = talloc_reference(subtorture, parent->ev);
  71         subtorture->lp_ctx = talloc_reference(subtorture, parent->lp_ctx);
  72         subtorture->outputdir = talloc_reference(subtorture, parent->outputdir);
  73         subtorture->results = talloc_reference(subtorture, parent->results);
  74
  75         return subtorture;
  76 }
  77
  78 /**
  79  create a temporary directory under the output dir
  80 */
  81 _PUBLIC_ NTSTATUS torture_temp_dir(struct torture_context *tctx,
  82                                    const char *prefix, 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 static int local_deltree(const char *path)
  98 {
  99         int ret = 0;
 100         struct dirent *dirent;
 101         DIR *dir = opendir(path);
 102         if (!dir) {
 103                 char *error = talloc_asprintf(NULL, "Could not open directory %s", path);
 104                 perror(error);
 105                 talloc_free(error);
 106                 return -1;
 107         }
 108         while ((dirent = readdir(dir))) {
 109                 char *name;
 110                 if ((strcmp(dirent->d_name, ".") == 0) || (strcmp(dirent->d_name, "..") == 0)) {
 111                         continue;
 112                 }
 113                 name = talloc_asprintf(NULL, "%s/%s", path,
 114                                        dirent->d_name);
 115                 if (name == NULL) {
 116                         closedir(dir);
 117                         return -1;
 118                 }
 119                 DEBUG(0, ("About to remove %s\n", name));
 120                 ret = remove(name);
 121                 if (ret == 0) {
 122                         talloc_free(name);
 123                         continue;
 124                 }
 125
 126                 if (errno == ENOTEMPTY) {
 127                         ret = local_deltree(name);
 128                         if (ret == 0) {
 129                                 ret = remove(name);
 130                         }
 131                 }
 132                 talloc_free(name);
 133                 if (ret != 0) {
 134                         char *error = talloc_asprintf(NULL, "Could not remove %s", path);
 135                         perror(error);
 136                         talloc_free(error);
 137                         break;
 138                 }
 139         }
 140         closedir(dir);
 141         return ret;
 142 }
 143
 144 _PUBLIC_ NTSTATUS torture_deltree_outputdir(struct torture_context *tctx)
 145 {
 146         SMB_ASSERT(tctx->outputdir != NULL);
 147         if ((strcmp(tctx->outputdir, "/") == 0)
 148             || (strcmp(tctx->outputdir, "") == 0)) {
 149                 return NT_STATUS_INVALID_PARAMETER;
 150         }
 151
 152         if (local_deltree(tctx->outputdir) == -1) {
 153                 if (errno != 0) {
 154                         return map_nt_error_from_unix(errno);
 155                 }
 156                 return NT_STATUS_UNSUCCESSFUL;
 157         }
 158         return NT_STATUS_OK;
 159 }
 160
 161 /**
 162  * Comment on the status/progress of a test
 163  */
 164 void torture_comment(struct torture_context *context, const char *comment, ...)
 165 {
 166         va_list ap;
 167         char *tmp;
 168
 169         if (!context->results->ui_ops->comment)
 170                 return;
 171
 172         va_start(ap, comment);
 173         tmp = talloc_vasprintf(context, comment, ap);
 174         va_end(ap);
 175
 176         context->results->ui_ops->comment(context, tmp);
 177
 178         talloc_free(tmp);
 179 }
 180
 181 /**
 182  * Print a warning about the current test
 183  */
 184 void torture_warning(struct torture_context *context, const char *comment, ...)
 185 {
 186         va_list ap;
 187         char *tmp;
 188
 189         if (!context->results->ui_ops->warning)
 190                 return;
 191
 192         va_start(ap, comment);
 193         tmp = talloc_vasprintf(context, comment, ap);
 194         va_end(ap);
 195
 196         context->results->ui_ops->warning(context, tmp);
 197
 198         talloc_free(tmp);
 199 }
 200
 201 /**
 202  * Store the result of a torture test.
 203  */
 204 void torture_result(struct torture_context *context,
 205                     enum torture_result result, const char *fmt, ...)
 206 {
 207         va_list ap;
 208
 209         va_start(ap, fmt);
 210
 211         if (context->last_reason) {
 212                 torture_warning(context, "%s", context->last_reason);
 213                 talloc_free(context->last_reason);
 214         }
 215
 216         context->last_result = result;
 217         context->last_reason = talloc_vasprintf(context, fmt, ap);
 218         va_end(ap);
 219 }
 220
 221 /**
 222  * Create a new torture suite
 223  */
 224 struct torture_suite *torture_suite_create(TALLOC_CTX *ctx, const char *name)
 225 {
 226         struct torture_suite *suite = talloc_zero(ctx, struct torture_suite);
 227
 228         suite->name = talloc_strdup(suite, name);
 229         suite->testcases = NULL;
 230         suite->children = NULL;
 231
 232         return suite;
 233 }
 234
 235 /**
 236  * Set the setup() and teardown() functions for a testcase.
 237  */
 238 void torture_tcase_set_fixture(struct torture_tcase *tcase,
 239                 bool (*setup) (struct torture_context *, void **),
 240                 bool (*teardown) (struct torture_context *, void *))
 241 {
 242         tcase->setup = setup;
 243         tcase->teardown = teardown;
 244 }
 245
 246 static bool wrap_test_with_testcase_const(struct torture_context *torture_ctx,
 247                                     struct torture_tcase *tcase,
 248                                     struct torture_test *test)
 249 {
 250         bool (*fn) (struct torture_context *,
 251                     const void *tcase_data,
 252                     const void *test_data);
 253
 254         fn = test->fn;
 255
 256         return fn(torture_ctx, tcase->data, test->data);
 257 }
 258
 259 /**
 260  * Add a test that uses const data to a testcase
 261  */
 262 struct torture_test *torture_tcase_add_test_const(struct torture_tcase *tcase,
 263                 const char *name,
 264                 bool (*run) (struct torture_context *, const void *tcase_data,
 265                         const void *test_data),
 266                 const void *data)
 267 {
 268         struct torture_test *test = talloc(tcase, struct torture_test);
 269
 270         test->name = talloc_strdup(test, name);
 271         test->description = NULL;
 272         test->run = wrap_test_with_testcase_const;
 273         test->fn = run;
 274         test->dangerous = false;
 275         test->data = data;
 276
 277         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
 278
 279         return test;
 280 }
 281
 282 /**
 283  * Add a new testcase
 284  */
 285 bool torture_suite_init_tcase(struct torture_suite *suite,
 286                               struct torture_tcase *tcase,
 287                               const char *name)
 288 {
 289         tcase->name = talloc_strdup(tcase, name);
 290         tcase->description = NULL;
 291         tcase->setup = NULL;
 292         tcase->teardown = NULL;
 293         tcase->fixture_persistent = true;
 294         tcase->tests = NULL;
 295
 296         DLIST_ADD_END(suite->testcases, tcase, struct torture_tcase *);
 297
 298         return true;
 299 }
 300
 301
 302 struct torture_tcase *torture_suite_add_tcase(struct torture_suite *suite,
 303                                                          const char *name)
 304 {
 305         struct torture_tcase *tcase = talloc(suite, struct torture_tcase);
 306
 307         if (!torture_suite_init_tcase(suite, tcase, name))
 308                 return NULL;
 309
 310         return tcase;
 311 }
 312
 313 int torture_suite_children_count(const struct torture_suite *suite)
 314 {
 315         int ret = 0;
 316         struct torture_tcase *tcase;
 317         struct torture_test *test;
 318         struct torture_suite *tsuite;
 319         for (tcase = suite->testcases; tcase; tcase = tcase->next) {
 320                 for (test = tcase->tests; test; test = test->next) {
 321                         ret++;
 322                 }
 323         }
 324         for (tsuite = suite->children; tsuite; tsuite = tsuite->next) {
 325                 ret ++;
 326         }
 327         return ret;
 328 }
 329
 330 /**
 331  * Run a torture test suite.
 332  */
 333 bool torture_run_suite(struct torture_context *context,
 334                        struct torture_suite *suite)
 335 {
 336         return torture_run_suite_restricted(context, suite, NULL);
 337 }
 338
 339 bool torture_run_suite_restricted(struct torture_context *context,
 340                        struct torture_suite *suite, const char **restricted)
 341 {
 342         bool ret = true;
 343         struct torture_tcase *tcase;
 344         struct torture_suite *tsuite;
 345
 346         if (context->results->ui_ops->suite_start)
 347                 context->results->ui_ops->suite_start(context, suite);
 348
 349         /* FIXME: Adjust torture_suite_children_count if restricted != NULL */
 350         context->results->ui_ops->progress(context,
 351                 torture_suite_children_count(suite), TORTURE_PROGRESS_SET);
 352
 353         for (tcase = suite->testcases; tcase; tcase = tcase->next) {
 354                 ret &= torture_run_tcase_restricted(context, tcase, restricted);
 355         }
 356
 357         for (tsuite = suite->children; tsuite; tsuite = tsuite->next) {
 358                 context->results->ui_ops->progress(context, 0, TORTURE_PROGRESS_PUSH);
 359                 ret &= torture_run_suite_restricted(context, tsuite, restricted);
 360                 context->results->ui_ops->progress(context, 0, TORTURE_PROGRESS_POP);
 361         }
 362
 363         if (context->results->ui_ops->suite_finish)
 364                 context->results->ui_ops->suite_finish(context, suite);
 365
 366         return ret;
 367 }
 368
 369 void torture_ui_test_start(struct torture_context *context,
 370                            struct torture_tcase *tcase,
 371                            struct torture_test *test)
 372 {
 373         if (context->results->ui_ops->test_start)
 374                 context->results->ui_ops->test_start(context, tcase, test);
 375 }
 376
 377 void torture_ui_test_result(struct torture_context *context,
 378                             enum torture_result result,
 379                             const char *comment)
 380 {
 381         if (context->results->ui_ops->test_result)
 382                 context->results->ui_ops->test_result(context, result, comment);
 383
 384         if (result == TORTURE_ERROR || result == TORTURE_FAIL)
 385                 context->results->returncode = false;
 386 }
 387
 388 static bool test_needs_running(const char *name, const char **restricted)
 389 {
 390         int i;
 391         if (restricted == NULL)
 392                 return true;
 393         for (i = 0; restricted[i]; i++) {
 394                 if (!strcmp(name, restricted[i]))
 395                         return true;
 396         }
 397         return false;
 398 }
 399
 400 static bool internal_torture_run_test(struct torture_context *context,
 401                                           struct torture_tcase *tcase,
 402                                           struct torture_test *test,
 403                                           bool already_setup,
 404                                           const char **restricted)
 405 {
 406         bool success;
 407         char *subunit_testname = NULL;
 408
 409         if (tcase == NULL || strcmp(test->name, tcase->name) != 0) {
 410                 subunit_testname = talloc_asprintf(context, "%s.%s", tcase->name, test->name);
 411         } else {
 412                 subunit_testname = talloc_strdup(context, test->name);
 413         }
 414
 415         if (!test_needs_running(subunit_testname, restricted))
 416                 return true;
 417
 418         context->active_tcase = tcase;
 419         context->active_test = test;
 420
 421         torture_ui_test_start(context, tcase, test);
 422
 423         context->last_reason = NULL;
 424         context->last_result = TORTURE_OK;
 425
 426         if (!already_setup && tcase->setup &&
 427                 !tcase->setup(context, &(tcase->data))) {
 428                 if (context->last_reason == NULL)
 429                         context->last_reason = talloc_strdup(context, "Setup failure");
 430                 context->last_result = TORTURE_ERROR;
 431                 success = false;
 432         } else if (test->dangerous &&
 433             !torture_setting_bool(context, "dangerous", false)) {
 434             context->last_result = TORTURE_SKIP;
 435             context->last_reason = talloc_asprintf(context,
 436                 "disabled %s - enable dangerous tests to use", test->name);
 437             success = true;
 438         } else {
 439             success = test->run(context, tcase, test);
 440
 441             if (!success && context->last_result == TORTURE_OK) {
 442                     if (context->last_reason == NULL)
 443                             context->last_reason = talloc_strdup(context, "Unknown error/failure");
 444                     context->last_result = TORTURE_ERROR;
 445             }
 446         }
 447
 448         if (!already_setup && tcase->teardown && !tcase->teardown(context, tcase->data)) {
 449                 if (context->last_reason == NULL)
 450                     context->last_reason = talloc_strdup(context, "Setup failure");
 451                 context->last_result = TORTURE_ERROR;
 452                 success = false;
 453         }
 454
 455         torture_ui_test_result(context, context->last_result,
 456                                context->last_reason);
 457
 458         talloc_free(context->last_reason);
 459
 460         context->active_test = NULL;
 461         context->active_tcase = NULL;
 462
 463         return success;
 464 }
 465
 466 bool torture_run_tcase(struct torture_context *context,
 467                        struct torture_tcase *tcase)
 468 {
 469         return torture_run_tcase_restricted(context, tcase, NULL);
 470 }
 471
 472 bool torture_run_tcase_restricted(struct torture_context *context,
 473                        struct torture_tcase *tcase, const char **restricted)
 474 {
 475         bool ret = true;
 476         struct torture_test *test;
 477         bool setup_succeeded = true;
 478         const char * setup_reason = "Setup failed";
 479
 480         context->active_tcase = tcase;
 481         if (context->results->ui_ops->tcase_start)
 482                 context->results->ui_ops->tcase_start(context, tcase);
 483
 484         if (tcase->fixture_persistent && tcase->setup) {
 485                 setup_succeeded = tcase->setup(context, &tcase->data);
 486         }
 487
 488         if (!setup_succeeded) {
 489                 /* Uh-oh. The setup failed, so we can't run any of the tests
 490                  * in this testcase. The subunit format doesn't specify what
 491                  * to do here, so we keep the failure reason, and manually
 492                  * use it to fail every test.
 493                  */
 494                 if (context->last_reason != NULL) {
 495                         setup_reason = talloc_asprintf(context,
 496                                 "Setup failed: %s", context->last_reason);
 497                 }
 498         }
 499
 500         for (test = tcase->tests; test; test = test->next) {
 501                 if (setup_succeeded) {
 502                         ret &= internal_torture_run_test(context, tcase, test,
 503                                         tcase->fixture_persistent, restricted);
 504                 } else {
 505                         context->active_tcase = tcase;
 506                         context->active_test = test;
 507                         torture_ui_test_start(context, tcase, test);
 508                         torture_ui_test_result(context, TORTURE_FAIL, setup_reason);
 509                 }
 510         }
 511
 512         if (setup_succeeded && tcase->fixture_persistent && tcase->teardown &&
 513                 !tcase->teardown(context, tcase->data)) {
 514                 ret = false;
 515         }
 516
 517         context->active_tcase = NULL;
 518         context->active_test = NULL;
 519
 520         if (context->results->ui_ops->tcase_finish)
 521                 context->results->ui_ops->tcase_finish(context, tcase);
 522
 523         return (!setup_succeeded) ? false : ret;
 524 }
 525
 526 bool torture_run_test(struct torture_context *context,
 527                                           struct torture_tcase *tcase,
 528                                           struct torture_test *test)
 529 {
 530         return internal_torture_run_test(context, tcase, test, false, NULL);
 531 }
 532
 533 bool torture_run_test_restricted(struct torture_context *context,
 534                                           struct torture_tcase *tcase,
 535                                           struct torture_test *test,
 536                                           const char **restricted)
 537 {
 538         return internal_torture_run_test(context, tcase, test, false, restricted);
 539 }
 540
 541 int torture_setting_int(struct torture_context *test, const char *name,
 542                                                         int default_value)
 543 {
 544         return lpcfg_parm_int(test->lp_ctx, NULL, "torture", name, default_value);
 545 }
 546
 547 unsigned long torture_setting_ulong(struct torture_context *test,
 548                                     const char *name,
 549                                     unsigned long default_value)
 550 {
 551         return lpcfg_parm_ulong(test->lp_ctx, NULL, "torture", name,
 552                              default_value);
 553 }
 554
 555 double torture_setting_double(struct torture_context *test, const char *name,
 556                                                         double default_value)
 557 {
 558         return lpcfg_parm_double(test->lp_ctx, NULL, "torture", name, default_value);
 559 }
 560
 561 bool torture_setting_bool(struct torture_context *test, const char *name,
 562                                                         bool default_value)
 563 {
 564         return lpcfg_parm_bool(test->lp_ctx, NULL, "torture", name, default_value);
 565 }
 566
 567 const char *torture_setting_string(struct torture_context *test,
 568                                    const char *name,
 569                                    const char *default_value)
 570 {
 571         const char *ret;
 572
 573         SMB_ASSERT(test != NULL);
 574         SMB_ASSERT(test->lp_ctx != NULL);
 575
 576         ret = lpcfg_parm_string(test->lp_ctx, NULL, "torture", name);
 577
 578         if (ret == NULL)
 579                 return default_value;
 580
 581         return ret;
 582 }
 583
 584 static bool wrap_test_with_simple_tcase_const (
 585                 struct torture_context *torture_ctx,
 586                 struct torture_tcase *tcase,
 587                 struct torture_test *test)
 588 {
 589         bool (*fn) (struct torture_context *, const void *tcase_data);
 590
 591         fn = test->fn;
 592
 593         return fn(torture_ctx, test->data);
 594 }
 595
 596 struct torture_tcase *torture_suite_add_simple_tcase_const(
 597                 struct torture_suite *suite, const char *name,
 598                 bool (*run) (struct torture_context *test, const void *),
 599                 const void *data)
 600 {
 601         struct torture_tcase *tcase;
 602         struct torture_test *test;
 603
 604         tcase = torture_suite_add_tcase(suite, name);
 605
 606         test = talloc(tcase, struct torture_test);
 607
 608         test->name = talloc_strdup(test, name);
 609         test->description = NULL;
 610         test->run = wrap_test_with_simple_tcase_const;
 611         test->fn = run;
 612         test->data = data;
 613         test->dangerous = false;
 614
 615         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
 616
 617         return tcase;
 618 }
 619
 620 static bool wrap_simple_test(struct torture_context *torture_ctx,
 621                              struct torture_tcase *tcase,
 622                              struct torture_test *test)
 623 {
 624         bool (*fn) (struct torture_context *);
 625
 626         fn = test->fn;
 627
 628         return fn(torture_ctx);
 629 }
 630
 631 struct torture_tcase *torture_suite_add_simple_test(
 632                                         struct torture_suite *suite,
 633                                         const char *name,
 634                                         bool (*run) (struct torture_context *test))
 635 {
 636         struct torture_test *test;
 637         struct torture_tcase *tcase;
 638
 639         tcase = torture_suite_add_tcase(suite, name);
 640
 641         test = talloc(tcase, struct torture_test);
 642
 643         test->name = talloc_strdup(test, name);
 644         test->description = NULL;
 645         test->run = wrap_simple_test;
 646         test->fn = run;
 647         test->dangerous = false;
 648
 649         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
 650
 651         return tcase;
 652 }
 653
 654 /**
 655  * Add a child testsuite to a testsuite.
 656  */
 657 bool torture_suite_add_suite(struct torture_suite *suite,
 658                              struct torture_suite *child)
 659 {
 660         if (child == NULL)
 661                 return false;
 662
 663         DLIST_ADD_END(suite->children, child, struct torture_suite *);
 664
 665         /* FIXME: Check for duplicates and return false if the
 666          * added suite already exists as a child */
 667
 668         return true;
 669 }
 670
 671 /**
 672  * Find the child testsuite with the specified name.
 673  */
 674 struct torture_suite *torture_find_suite(struct torture_suite *parent,
 675                                          const char *name)
 676 {
 677         struct torture_suite *child;
 678
 679         for (child = parent->children; child; child = child->next)
 680                 if (!strcmp(child->name, name))
 681                         return child;
 682
 683         return NULL;
 684 }
 685
 686 static bool wrap_test_with_simple_test_const(struct torture_context *torture_ctx,
 687                                        struct torture_tcase *tcase,
 688                                        struct torture_test *test)
 689 {
 690         bool (*fn) (struct torture_context *, const void *tcase_data);
 691
 692         fn = test->fn;
 693
 694         return fn(torture_ctx, tcase->data);
 695 }
 696
 697 struct torture_test *torture_tcase_add_simple_test_const(
 698                 struct torture_tcase *tcase,
 699                 const char *name,
 700                 bool (*run) (struct torture_context *test,
 701                         const void *tcase_data))
 702 {
 703         struct torture_test *test;
 704
 705         test = talloc(tcase, struct torture_test);
 706
 707         test->name = talloc_strdup(test, name);
 708         test->description = NULL;
 709         test->run = wrap_test_with_simple_test_const;
 710         test->fn = run;
 711         test->data = NULL;
 712         test->dangerous = false;
 713
 714         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
 715
 716         return test;
 717 }
 718
 719 static bool wrap_test_with_simple_test(struct torture_context *torture_ctx,
 720                                        struct torture_tcase *tcase,
 721                                        struct torture_test *test)
 722 {
 723         bool (*fn) (struct torture_context *, void *tcase_data);
 724
 725         fn = test->fn;
 726
 727         return fn(torture_ctx, tcase->data);
 728 }
 729
 730 struct torture_test *torture_tcase_add_simple_test(struct torture_tcase *tcase,
 731                 const char *name,
 732                 bool (*run) (struct torture_context *test, void *tcase_data))
 733 {
 734         struct torture_test *test;
 735
 736         test = talloc(tcase, struct torture_test);
 737
 738         test->name = talloc_strdup(test, name);
 739         test->description = NULL;
 740         test->run = wrap_test_with_simple_test;
 741         test->fn = run;
 742         test->data = NULL;
 743         test->dangerous = false;
 744
 745         DLIST_ADD_END(tcase->tests, test, struct torture_test *);
 746
 747         return test;
 748 }
 749
 750 void torture_ui_report_time(struct torture_context *context)
 751 {
 752         if (context->results->ui_ops->report_time)
 753                 context->results->ui_ops->report_time(context);
 754 }