Fix problems with event context not being the parent.
[gd/samba-autobuild/.git] / source4 / torture / smbtorture.c
index 2963e71366ae6ceabdc3a0dc9491a6255fdea452..faae784e4b09db4418f01e16b080670e168f66df 100644 (file)
@@ -6,7 +6,7 @@
    
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    
    This program is distributed in the hope that it will be useful,
@@ -15,8 +15,7 @@
    GNU General Public License for more details.
    
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "includes.h"
@@ -35,6 +34,9 @@
 #include "build.h"
 #include "lib/util/dlinklist.h"
 #include "librpc/rpc/dcerpc.h"
+#include "param/param.h"
+
+#include "auth/credentials/credentials.h"
 
 static bool run_matching(struct torture_context *torture,
                                                 const char *prefix, 
@@ -50,7 +52,7 @@ static bool run_matching(struct torture_context *torture,
                for (o = torture_root->children; o; o = o->next) {
                        if (gen_fnmatch(expr, o->name) == 0) {
                                *matched = true;
-                               init_iconv();
+                               reload_charcnv(torture->lp_ctx);
                                ret &= torture_run_suite(torture, o);
                                continue;
                        }
@@ -67,7 +69,7 @@ static bool run_matching(struct torture_context *torture,
 
                        if (gen_fnmatch(expr, name) == 0) {
                                *matched = true;
-                               init_iconv();
+                               reload_charcnv(torture->lp_ctx);
                                torture->active_testname = talloc_strdup(torture, prefix);
                                ret &= torture_run_suite(torture, c);
                                free(name);
@@ -83,7 +85,7 @@ static bool run_matching(struct torture_context *torture,
                        asprintf(&name, "%s-%s", prefix, t->name);
                        if (gen_fnmatch(expr, name) == 0) {
                                *matched = true;
-                               init_iconv();
+                               reload_charcnv(torture->lp_ctx);
                                torture->active_testname = talloc_strdup(torture, prefix);
                                ret &= torture_run_tcase(torture, t);
                                talloc_free(torture->active_testname);
@@ -123,7 +125,33 @@ static bool run_test(struct torture_context *torture, const char *name)
        return ret;
 }
 
-static void parse_dns(const char *dns)
+static bool parse_target(struct loadparm_context *lp_ctx, const char *target)
+{
+       char *host = NULL, *share = NULL;
+       struct dcerpc_binding *binding_struct;
+       NTSTATUS status;
+
+       /* see if its a RPC transport specifier */
+       if (!smbcli_parse_unc(target, NULL, &host, &share)) {
+               status = dcerpc_parse_binding(talloc_autofree_context(), target, &binding_struct);
+               if (NT_STATUS_IS_ERR(status)) {
+                       d_printf("Invalid option: %s is not a valid torture target (share or binding string)\n\n", target);
+                       return false;
+               }
+               lp_set_cmdline(lp_ctx, "torture:host", binding_struct->host);
+               if (lp_parm_string(lp_ctx, NULL, "torture", "share") == NULL)
+                       lp_set_cmdline(lp_ctx, "torture:share", "IPC$");
+               lp_set_cmdline(lp_ctx, "torture:binding", target);
+       } else {
+               lp_set_cmdline(lp_ctx, "torture:host", host);
+               lp_set_cmdline(lp_ctx, "torture:share", share);
+               lp_set_cmdline(lp_ctx, "torture:binding", host);
+       }
+
+       return true;
+}
+
+static void parse_dns(struct loadparm_context *lp_ctx, const char *dns)
 {
        char *userdn, *basedn, *secret;
        char *p, *d;
@@ -131,39 +159,59 @@ static void parse_dns(const char *dns)
        /* retrievieng the userdn */
        p = strchr_m(dns, '#');
        if (!p) {
-               lp_set_cmdline("torture:ldap_userdn", "");
-               lp_set_cmdline("torture:ldap_basedn", "");
-               lp_set_cmdline("torture:ldap_secret", "");
+               lp_set_cmdline(lp_ctx, "torture:ldap_userdn", "");
+               lp_set_cmdline(lp_ctx, "torture:ldap_basedn", "");
+               lp_set_cmdline(lp_ctx, "torture:ldap_secret", "");
                return;
        }
        userdn = strndup(dns, p - dns);
-       lp_set_cmdline("torture:ldap_userdn", userdn);
+       lp_set_cmdline(lp_ctx, "torture:ldap_userdn", userdn);
 
        /* retrieve the basedn */
        d = p + 1;
        p = strchr_m(d, '#');
        if (!p) {
-               lp_set_cmdline("torture:ldap_basedn", "");
-               lp_set_cmdline("torture:ldap_secret", "");
+               lp_set_cmdline(lp_ctx, "torture:ldap_basedn", "");
+               lp_set_cmdline(lp_ctx, "torture:ldap_secret", "");
                return;
        }
        basedn = strndup(d, p - d);
-       lp_set_cmdline("torture:ldap_basedn", basedn);
+       lp_set_cmdline(lp_ctx, "torture:ldap_basedn", basedn);
 
        /* retrieve the secret */
        p = p + 1;
        if (!p) {
-               lp_set_cmdline("torture:ldap_secret", "");
+               lp_set_cmdline(lp_ctx, "torture:ldap_secret", "");
                return;
        }
        secret = strdup(p);
-       lp_set_cmdline("torture:ldap_secret", secret);
+       lp_set_cmdline(lp_ctx, "torture:ldap_secret", secret);
 
        printf ("%s - %s - %s\n", userdn, basedn, secret);
 
 }
 
-static void usage(poptContext pc)
+static void print_test_list(void)
+{
+       struct torture_suite *o;
+       struct torture_suite *s;
+       struct torture_tcase *t;
+
+       if (torture_root == NULL)
+               return;
+
+       for (o = torture_root->children; o; o = o->next) {
+               for (s = o->children; s; s = s->next) {
+                       printf("%s-%s\n", o->name, s->name);
+               }
+
+               for (t = o->testcases; t; t = t->next) {
+                       printf("%s-%s\n", o->name, t->name);
+               }
+       }
+}
+
+_NORETURN_ static void usage(poptContext pc)
 {
        struct torture_suite *o;
        struct torture_suite *s;
@@ -222,6 +270,11 @@ static void usage(poptContext pc)
 
        printf("Tests are:");
 
+       if (torture_root == NULL) {
+           printf("NO TESTS LOADED\n");
+           exit(1);
+       }
+
        for (o = torture_root->children; o; o = o->next) {
                printf("\n%s (%s):\n  ", o->description, o->name);
 
@@ -250,19 +303,7 @@ static void usage(poptContext pc)
        exit(1);
 }
 
-static bool is_binding_string(const char *binding_string)
-{
-       TALLOC_CTX *mem_ctx = talloc_named_const(NULL, 0, "is_binding_string");
-       struct dcerpc_binding *binding_struct;
-       NTSTATUS status;
-       
-       status = dcerpc_parse_binding(mem_ctx, binding_string, &binding_struct);
-
-       talloc_free(mem_ctx);
-       return NT_STATUS_IS_OK(status);
-}
-
-static void max_runtime_handler(int sig)
+_NORETURN_ static void max_runtime_handler(int sig)
 {
        DEBUG(0,("maximum runtime exceeded for smbtorture - terminating\n"));
        exit(1);
@@ -271,22 +312,22 @@ static void max_runtime_handler(int sig)
 struct timeval last_suite_started;
 
 static void simple_suite_start(struct torture_context *ctx,
-                                                          struct torture_suite *suite)
+                              struct torture_suite *suite)
 {
        last_suite_started = timeval_current();
        printf("Running %s\n", suite->name);
 }
 
 static void simple_suite_finish(struct torture_context *ctx,
-                                                          struct torture_suite *suite)
+                               struct torture_suite *suite)
 {
 
        printf("%s took %g secs\n\n", suite->name, 
                   timeval_elapsed(&last_suite_started));
 }
 
-static void simple_test_result (struct torture_context *context, 
-                                                               enum torture_result res, const char *reason)
+static void simple_test_result(struct torture_context *context, 
+                              enum torture_result res, const char *reason)
 {
        switch (res) {
        case TORTURE_OK:
@@ -305,29 +346,45 @@ static void simple_test_result (struct torture_context *context,
        }
 }
 
-static void simple_comment (struct torture_context *test, 
-                                                       const char *comment)
+static void simple_comment(struct torture_context *test, 
+                          const char *comment)
 {
        printf("%s", comment);
 }
 
+static void simple_warning(struct torture_context *test, 
+                          const char *comment)
+{
+       fprintf(stderr, "WARNING: %s\n", comment);
+}
+
 const static struct torture_ui_ops std_ui_ops = {
        .comment = simple_comment,
+       .warning = simple_warning,
        .suite_start = simple_suite_start,
        .suite_finish = simple_suite_finish,
        .test_result = simple_test_result
 };
 
+static void subunit_init(struct torture_context *ctx) 
+{
+       /* FIXME: register segv and bus handler */
+}
+
+static void subunit_suite_start(struct torture_context *ctx,
+                               struct torture_suite *suite)
+{
+}
 
-static void subunit_test_start (struct torture_context *ctx, 
-                                                           struct torture_tcase *tcase,
-                                                               struct torture_test *test)
+static void subunit_test_start(struct torture_context *ctx, 
+                              struct torture_tcase *tcase,
+                              struct torture_test *test)
 {
        printf("test: %s\n", test->name);
 }
 
-static void subunit_test_result (struct torture_context *context, 
-                                                                enum torture_result res, const char *reason)
+static void subunit_test_result(struct torture_context *context, 
+                               enum torture_result res, const char *reason)
 {
        switch (res) {
        case TORTURE_OK:
@@ -344,59 +401,33 @@ static void subunit_test_result (struct torture_context *context,
                break;
        }
        if (reason)
-               printf(" [ %s ]", reason);
+               printf(" [\n%s\n]", reason);
        printf("\n");
 }
 
-static void subunit_comment (struct torture_context *test, 
-                                                        const char *comment)
+static void subunit_comment(struct torture_context *test,
+                           const char *comment)
 {
        fprintf(stderr, "%s", comment);
 }
 
-const static struct torture_ui_ops subunit_ui_ops = {
-       .comment = subunit_comment,
-       .test_start = subunit_test_start,
-       .test_result = subunit_test_result
-};
-
-static void harness_test_start (struct torture_context *ctx, 
-                                                           struct torture_tcase *tcase,
-                                                               struct torture_test *test)
+static void subunit_warning(struct torture_context *test,
+                           const char *comment)
 {
+       fprintf(stderr, "WARNING!: %s\n", comment);
 }
 
-static void harness_test_result (struct torture_context *context, 
-                                                                enum torture_result res, const char *reason)
-{
-       switch (res) {
-       case TORTURE_OK:
-               printf("ok %s - %s\n", context->active_test->name, reason);
-               break;
-       case TORTURE_FAIL:
-       case TORTURE_ERROR:
-               printf("not ok %s - %s\n", context->active_test->name, reason);
-               break;
-       case TORTURE_SKIP:
-               printf("skip %s - %s\n", context->active_test->name, reason);
-               break;
-       }
-}
-
-static void harness_comment (struct torture_context *test, 
-                                                        const char *comment)
-{
-       printf("# %s\n", comment);
-}
-
-const static struct torture_ui_ops harness_ui_ops = {
-       .comment = harness_comment,
-       .test_start = harness_test_start,
-       .test_result = harness_test_result
+const static struct torture_ui_ops subunit_ui_ops = {
+       .init = subunit_init,
+       .comment = subunit_comment,
+       .warning = subunit_warning,
+       .test_start = subunit_test_start,
+       .test_result = subunit_test_result,
+       .suite_start = subunit_suite_start
 };
 
 static void quiet_suite_start(struct torture_context *ctx,
-                                                 struct torture_suite *suite)
+                             struct torture_suite *suite)
 {
        int i;
        ctx->quiet = true;
@@ -406,13 +437,13 @@ static void quiet_suite_start(struct torture_context *ctx,
 }
 
 static void quiet_suite_finish(struct torture_context *ctx,
-                                                 struct torture_suite *suite)
+                              struct torture_suite *suite)
 {
        putchar('\n');
 }
 
-static void quiet_test_result (struct torture_context *context, 
-                                                          enum torture_result res, const char *reason)
+static void quiet_test_result(struct torture_context *context, 
+                             enum torture_result res, const char *reason)
 {
        fflush(stdout);
        switch (res) {
@@ -429,33 +460,6 @@ const static struct torture_ui_ops quiet_ui_ops = {
        .test_result = quiet_test_result
 };
 
-void run_recipe(struct torture_context *tctx, const char *recipe)
-{
-       int numlines, i, ret;
-       char **lines;
-
-       lines = file_lines_load(recipe, &numlines, NULL);
-       if (lines == NULL) {
-               fprintf(stderr, "Unable to load file %s\n", recipe);
-               return;
-       }
-
-       for (i = 0; i < numlines; i++) {
-               int argc;
-               const char **argv;
-
-               ret = poptParseArgvString(lines[i], &argc, &argv);
-               if (ret != 0) {
-                       fprintf(stderr, "Error parsing line\n");
-                       continue;
-               }
-
-               run_test(tctx, argv[0]);
-       }
-
-       talloc_free(lines);
-}
-
 void run_shell(struct torture_context *tctx)
 {
        char *cline;
@@ -482,7 +486,7 @@ void run_shell(struct torture_context *tctx)
                                fprintf(stderr, "Usage: set <variable> <value>\n");
                        } else {
                                char *name = talloc_asprintf(NULL, "torture:%s", argv[1]);
-                               lp_set_cmdline(name, argv[2]);
+                               lp_set_cmdline(tctx->lp_ctx, name, argv[2]);
                                talloc_free(name);
                        }
                } else if (!strcmp(argv[0], "help")) {
@@ -498,6 +502,7 @@ void run_shell(struct torture_context *tctx)
                                run_test(tctx, argv[1]);
                        }
                }
+               free(cline);
        }
 }
 
@@ -515,28 +520,34 @@ int main(int argc,char *argv[])
        char **argv_new;
        poptContext pc;
        static const char *target = "other";
-       const char **subunit_dir;
-       int shell = False;
+       NTSTATUS status;
+       int shell = false;
        static const char *ui_ops_name = "simple";
-       enum {OPT_LOADFILE=1000,OPT_UNCLIST,OPT_TIMELIMIT,OPT_DNS,
+       const char *basedir = NULL;
+       const char *extra_module = NULL;
+       static int list_tests = 0;
+       enum {OPT_LOADFILE=1000,OPT_UNCLIST,OPT_TIMELIMIT,OPT_DNS, OPT_LIST,
              OPT_DANGEROUS,OPT_SMB_PORTS,OPT_ASYNC,OPT_NUMPROGS};
        
        struct poptOption long_options[] = {
                POPT_AUTOHELP
-               {"format", 0, POPT_ARG_STRING, &ui_ops_name, 0, "Output format (one of: simple, subunit, harness)", NULL },
+               {"format", 0, POPT_ARG_STRING, &ui_ops_name, 0, "Output format (one of: simple, subunit)", NULL },
                {"smb-ports",   'p', POPT_ARG_STRING, NULL,     OPT_SMB_PORTS,  "SMB ports",    NULL},
-               {"seed",          0, POPT_ARG_INT,  &torture_seed,      0,      "seed",         NULL},
+               {"basedir",       0, POPT_ARG_STRING, &basedir, 0, "base directory", "BASEDIR" },
+               {"seed",          0, POPT_ARG_INT,  &torture_seed,      0,      "Seed to use for randomizer",   NULL},
                {"num-progs",     0, POPT_ARG_INT,  NULL,       OPT_NUMPROGS,   "num progs",    NULL},
                {"num-ops",       0, POPT_ARG_INT,  &torture_numops,    0,      "num ops",      NULL},
                {"entries",       0, POPT_ARG_INT,  &torture_entries,   0,      "entries",      NULL},
-               {"loadfile",      0, POPT_ARG_STRING,   NULL,   OPT_LOADFILE,   "loadfile",     NULL},
+               {"loadfile",      0, POPT_ARG_STRING,   NULL,   OPT_LOADFILE,   "NBench load file to use",      NULL},
+               {"list",          0, POPT_ARG_NONE, &list_tests, 0, "List available tests and exit", NULL },
                {"unclist",       0, POPT_ARG_STRING,   NULL,   OPT_UNCLIST,    "unclist",      NULL},
-               {"timelimit",   't', POPT_ARG_INT,      NULL,   OPT_TIMELIMIT,  "timelimit",    NULL},
+               {"timelimit",   't', POPT_ARG_INT,      NULL,   OPT_TIMELIMIT,  "Set time limit (in seconds)",  NULL},
                {"failures",    'f', POPT_ARG_INT,  &torture_failures,  0,      "failures",     NULL},
                {"parse-dns",   'D', POPT_ARG_STRING,   NULL,   OPT_DNS,        "parse-dns",    NULL},
                {"dangerous",   'X', POPT_ARG_NONE,     NULL,   OPT_DANGEROUS,
                 "run dangerous tests (eg. wiping out password database)", NULL},
-               {"shell",               0, POPT_ARG_NONE, &shell, True, "Run shell", NULL},
+               {"load-module",  0,  POPT_ARG_STRING, &extra_module,     0, "load tests from DSO file",    "SOFILE"},
+               {"shell",               0, POPT_ARG_NONE, &shell, true, "Run shell", NULL},
                {"target",              'T', POPT_ARG_STRING, &target, 0, "samba3|samba4|other", NULL},
                {"async",       'a', POPT_ARG_NONE,     NULL,   OPT_ASYNC,
                 "run async tests", NULL},
@@ -564,38 +575,36 @@ int main(int argc,char *argv[])
        while((opt = poptGetNextOpt(pc)) != -1) {
                switch (opt) {
                case OPT_LOADFILE:
-                       lp_set_cmdline("torture:loadfile", poptGetOptArg(pc));
+                       lp_set_cmdline(cmdline_lp_ctx, "torture:loadfile", poptGetOptArg(pc));
                        break;
                case OPT_UNCLIST:
-                       lp_set_cmdline("torture:unclist", poptGetOptArg(pc));
+                       lp_set_cmdline(cmdline_lp_ctx, "torture:unclist", poptGetOptArg(pc));
                        break;
                case OPT_TIMELIMIT:
-                       lp_set_cmdline("torture:timelimit", poptGetOptArg(pc));
+                       lp_set_cmdline(cmdline_lp_ctx, "torture:timelimit", poptGetOptArg(pc));
                        break;
                case OPT_NUMPROGS:
-                       lp_set_cmdline("torture:nprocs", poptGetOptArg(pc));
+                       lp_set_cmdline(cmdline_lp_ctx, "torture:nprocs", poptGetOptArg(pc));
                        break;
                case OPT_DNS:
-                       parse_dns(poptGetOptArg(pc));
+                       parse_dns(cmdline_lp_ctx, poptGetOptArg(pc));
                        break;
                case OPT_DANGEROUS:
-                       lp_set_cmdline("torture:dangerous", "Yes");
+                       lp_set_cmdline(cmdline_lp_ctx, "torture:dangerous", "Yes");
                        break;
                case OPT_ASYNC:
-                       lp_set_cmdline("torture:async", "Yes");
+                       lp_set_cmdline(cmdline_lp_ctx, "torture:async", "Yes");
                        break;
                case OPT_SMB_PORTS:
-                       lp_set_cmdline("smb ports", poptGetOptArg(pc));
+                       lp_set_cmdline(cmdline_lp_ctx, "smb ports", poptGetOptArg(pc));
                        break;
                }
        }
 
        if (strcmp(target, "samba3") == 0) {
-               lp_set_cmdline("torture:samba3", "true");
-               lp_set_cmdline("torture:knownfail", "samba3-knownfail");
+               lp_set_cmdline(cmdline_lp_ctx, "torture:samba3", "true");
        } else if (strcmp(target, "samba4") == 0) {
-               lp_set_cmdline("torture:samba4", "true");
-               lp_set_cmdline("torture:knownfail", "samba4-knownfail");
+               lp_set_cmdline(cmdline_lp_ctx, "torture:samba4", "true");
        }
 
        if (max_runtime) {
@@ -608,15 +617,25 @@ int main(int argc,char *argv[])
                alarm(max_runtime);
        }
 
-       torture_init();
-       ldb_global_init();
+       if (extra_module != NULL) {
+           init_module_fn fn = load_module(talloc_autofree_context(), poptGetOptArg(pc));
 
-       subunit_dir = lp_parm_string_list(-1, "torture", "subunitdir", ":");
-       if (subunit_dir == NULL) 
-               torture_subunit_load_testsuites(dyn_TORTUREDIR, true, NULL);
-       else {
-               for (i = 0; subunit_dir[i]; i++)
-                       torture_subunit_load_testsuites(subunit_dir[i], true, NULL);
+           if (fn == NULL) 
+               d_printf("Unable to load module from %s\n", poptGetOptArg(pc));
+           else {
+               status = fn();
+               if (NT_STATUS_IS_ERR(status)) {
+                   d_printf("Error initializing module %s: %s\n", 
+                            poptGetOptArg(pc), nt_errstr(status));
+               }
+           }
+       } else { 
+               torture_init();
+       }
+
+       if (list_tests) {
+               print_test_list();
+               return 0;
        }
 
        if (torture_seed == 0) {
@@ -640,30 +659,15 @@ int main(int argc,char *argv[])
                exit(1);
        }
 
-       /* see if its a RPC transport specifier */
-       if (is_binding_string(argv_new[1])) {
-               lp_set_cmdline("torture:binding", argv_new[1]);
-       } else {
-               char *binding = NULL;
-               char *host = NULL, *share = NULL;
-
-               if (!smbcli_parse_unc(argv_new[1], NULL, &host, &share)) {
-                       d_printf("Invalid option: %s is not a valid torture target (share or binding string)\n\n", argv_new[1]);
-                       usage(pc);
-               }
-
-               lp_set_cmdline("torture:host", host);
-               lp_set_cmdline("torture:share", share);
-               asprintf(&binding, "ncacn_np:%s", host);
-               lp_set_cmdline("torture:binding", binding);
+       if (!parse_target(cmdline_lp_ctx, argv_new[1])) {
+               usage(pc);
+               exit(1);
        }
 
        if (!strcmp(ui_ops_name, "simple")) {
                ui_ops = &std_ui_ops;
        } else if (!strcmp(ui_ops_name, "subunit")) {
                ui_ops = &subunit_ui_ops;
-       } else if (!strcmp(ui_ops_name, "harness")) {
-               ui_ops = &harness_ui_ops;
        } else if (!strcmp(ui_ops_name, "quiet")) {
                ui_ops = &quiet_ui_ops;
        } else {
@@ -671,67 +675,37 @@ int main(int argc,char *argv[])
                exit(1);
        }
 
-       torture = torture_context_init(talloc_autofree_context(), 
-                               lp_parm_string(-1, "torture", "knownfail"), ui_ops);
+       torture = torture_context_init(cli_credentials_get_event_context(cmdline_credentials), ui_ops);
+       if (basedir != NULL) {
+               if (basedir[0] != '/') {
+                       fprintf(stderr, "Please specify an absolute path to --basedir\n");
+                       return 1;
+               }
+               torture->outputdir = basedir;
+       } else {
+               char *pwd = talloc_size(torture, PATH_MAX);
+               if (!getcwd(pwd, PATH_MAX)) {
+                       fprintf(stderr, "Unable to determine current working directory\n");
+                       return 1;
+               }
+               torture->outputdir = pwd;
+       }
+
+       torture->lp_ctx = cmdline_lp_ctx;
 
        if (argc_new == 0) {
                printf("You must specify a test to run, or 'ALL'\n");
        } else if (shell) {
                run_shell(torture);
        } else {
-               int total;
-               double rate;
-               int unexpected_failures;
                for (i=2;i<argc_new;i++) {
-                       if (argv_new[i][0] == '@') {
-                               run_recipe(torture, argv_new[i]+1);
-                       } else if (!run_test(torture, argv_new[i])) {
+                       if (!run_test(torture, argv_new[i])) {
                                correct = false;
                        }
                }
-
-               unexpected_failures = str_list_length(torture->results.unexpected_failures);
-
-               total = torture->results.skipped+torture->results.success+torture->results.failed+torture->results.errors;
-               if (total == 0) {
-                       printf("No tests run.\n");
-               } else {
-                       rate = ((total - unexpected_failures - torture->results.errors) * (100.0 / total));
-               
-                       printf("Tests: %d, Failures: %d", total, torture->results.failed);
-                       if (torture->results.failed - unexpected_failures) {
-                               printf(" (%d expected)", torture->results.failed - unexpected_failures);
-                       }
-                       printf(", Errors: %d, Skipped: %d. Success rate: %.2f%%\n",
-                          torture->results.errors, torture->results.skipped, rate);
-               }
-
-               if (unexpected_failures) {
-                       printf("The following tests failed:\n");
-                       for (i = 0; torture->results.unexpected_failures[i]; i++) {
-                               printf("  %s\n", torture->results.unexpected_failures[i]);
-                       }
-                       printf("\n");
-               }
-
-               if (str_list_length(torture->results.unexpected_errors)) {
-                       printf("Errors occurred while running the following tests:\n");
-                       for (i = 0; torture->results.unexpected_errors[i]; i++) {
-                               printf("  %s\n", torture->results.unexpected_errors[i]);
-                       }
-                       printf("\n");
-               }
-
-               if (str_list_length(torture->results.unexpected_successes)) {
-                       printf("The following tests were expected to fail but succeeded:\n");
-                       for (i = 0; torture->results.unexpected_successes[i]; i++) {
-                               printf("  %s\n", torture->results.unexpected_successes[i]);
-                       }
-                       printf("\n");
-               }
        }
 
-       if (torture->results.returncode) {
+       if (torture->returncode && correct) {
                return(0);
        } else {
                return(1);