X-Git-Url: https://git.xonotic.org/?p=xonotic%2Fgmqcc.git;a=blobdiff_plain;f=test.c;h=5e99df404063de4b7d638cd3e6217107414f5f36;hp=a3956e99c9c8d18183b8add937ec5c85f52259f7;hb=d45853f5fedc64ae493253b37ee2ba51a9b870bf;hpb=a5e0542f95d8ab316a6faf47b7d3fc07653ac75b diff --git a/test.c b/test.c index a3956e9..5e99df4 100644 --- a/test.c +++ b/test.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2012 + * Copyright (C) 2012, 2013 * Dale Weiler * * Permission is hereby granted, free of charge, to any person obtaining a copy of @@ -23,7 +23,6 @@ #include "gmqcc.h" #include #include -#include opts_cmd_t opts; @@ -50,7 +49,7 @@ char *task_bins[] = { #ifndef _WIN32 #include #include - +#include #include typedef struct { FILE *handles[3]; @@ -122,16 +121,12 @@ FILE ** task_popen(const char *command, const char *mode) { close(2), dup(errhandle[1]); execvp(*argv, argv); - exit(1); + exit(EXIT_FAILURE); } else { /* fork failed */ goto task_popen_error_3; } - if (argv) - vec_free(argv); - return data->handles; - task_popen_error_3: close(errhandle[0]), close(errhandle[1]); task_popen_error_2: close(outhandle[0]), close(outhandle[1]); task_popen_error_1: close(inhandle [0]), close(inhandle [1]); @@ -157,7 +152,120 @@ int task_pclose(FILE **handles) { return status; } #else +# define _WIN32_LEAN_AND_MEAN +# define popen _popen +# define pclose _pclose +# include +# include +# include + /* + * Bidirectional piping implementation for windows using CreatePipe and DuplicateHandle + + * other hacks. + */ + + typedef struct { + int __dummy; + /* TODO: implement */ + } popen_t; + + FILE **task_popen(const char *command, const char *mode) { + (void)command; + (void)mode; + + /* TODO: implement */ + return NULL; + } + + void task_pclose(FILE **files) { + /* TODO: implement */ + (void)files; + return; + } + +# ifdef __MINGW32__ + /* mingw32 has dirent.h */ +# include +# elif defined (_WIN32) + /* + * visual studio lacks dirent.h it's a posix thing + * so we emulate it with the WinAPI. + */ + + struct dirent { + long d_ino; + unsigned short d_reclen; + unsigned short d_namlen; + char d_name[FILENAME_MAX]; + }; + + typedef struct { + struct _finddata_t dd_dta; + struct dirent dd_dir; + long dd_handle; + int dd_stat; + char dd_name[1]; + } DIR; + + DIR *opendir(const char *name) { + DIR *dir = (DIR*)mem_a(sizeof(DIR) + strlen(name)); + if (!dir) + return NULL; + + strcpy(dir->dd_name, name); + return dir; + } + + int closedir(DIR *dir) { + FindClose((HANDLE)dir->dd_handle); + mem_d ((void*)dir); + return 0; + } + + struct dirent *readdir(DIR *dir) { + WIN32_FIND_DATA info; + struct dirent *data; + int rets; + + if (!dir->dd_handle) { + char *dirname; + if (*dir->dd_name) { + size_t n = strlen(dir->dd_name); + if ((dirname = (char*)mem_a(n + 5) /* 4 + 1 */)) { + strcpy(dirname, dir->dd_name); + strcpy(dirname + n, "\\*.*"); /* 4 + 1 */ + } + } else { + if (!(dirname = util_strdup("\\*.*"))) + return NULL; + } + + dir->dd_handle = (long)FindFirstFile(dirname, &info); + mem_d(dirname); + rets = !(!dir->dd_handle); + } else if (dir->dd_handle != -11) { + rets = FindNextFile ((HANDLE)dir->dd_handle, &info); + } else { + rets = 0; + } + + if (!rets) + return NULL; + + if ((data = (struct dirent*)mem_a(sizeof(struct dirent)))) { + strncpy(data->d_name, info.cFileName, FILENAME_MAX - 1); + data->d_name[FILENAME_MAX - 1] = '\0'; /* terminate */ + data->d_namlen = strlen(data->d_name); + } + return data; + } + /* + * Visual studio also lacks S_ISDIR for sys/stat.h, so we emulate this as well + * which is not hard at all. + */ +# undef S_ISDIR /* undef just incase */ +# define S_ISDIR(X) ((X)&_S_IFDIR) +# endif #endif #define TASK_COMPILE 0 @@ -186,14 +294,6 @@ int task_pclose(FILE **handles) { * Used to set a description of the current test, this must be * provided, this tag is NOT optional. * - * F: - * Used to set a failure message, this message will be displayed - * if the test fails, this tag is optional - * - * S: - * Used to set a success message, this message will be displayed - * if the test succeeds, this tag is optional. - * * T: * Used to set the procedure for the given task, there are two * options for this: @@ -201,6 +301,9 @@ int task_pclose(FILE **handles) { * This simply performs compilation only * -execute * This will perform compilation and execution + * -fail + * This will perform compilation, but requires + * the compilation to fail in order to succeed. * * This must be provided, this tag is NOT optional. * @@ -208,6 +311,9 @@ int task_pclose(FILE **handles) { * Used to set the compilation flags for the given task, this * must be provided, this tag is NOT optional. * + * F: Used to set some test suite flags, currently the only option + * is -no-defs (to including of defs.qh) + * * E: * Used to set the execution flags for the given task. This tag * must be provided if T == -execute, otherwise it's erroneous @@ -240,21 +346,22 @@ int task_pclose(FILE **handles) { */ typedef struct { char *description; - char *failuremessage; - char *successmessage; char *compileflags; char *executeflags; char *proceduretype; char *sourcefile; char *tempfilename; char **comparematch; + char *rulesfile; + char *testflags; } task_template_t; /* * This is very much like a compiler code generator :-). This generates * a value from some data observed from the compiler. */ -bool task_template_generate(task_template_t *template, char tag, const char *file, size_t line, const char *value) { +bool task_template_generate(task_template_t *template, char tag, const char *file, size_t line, const char *value, size_t *pad) { + size_t desclen = 0; char **destval = NULL; if (!template) @@ -262,12 +369,11 @@ bool task_template_generate(task_template_t *template, char tag, const char *fil switch(tag) { case 'D': destval = &template->description; break; - case 'F': destval = &template->failuremessage; break; - case 'S': destval = &template->successmessage; break; case 'T': destval = &template->proceduretype; break; case 'C': destval = &template->compileflags; break; case 'E': destval = &template->executeflags; break; case 'I': destval = &template->sourcefile; break; + case 'F': destval = &template->testflags; break; default: con_printmsg(LVL_ERROR, __FILE__, __LINE__, "internal error", "invalid tag `%c:` during code generation\n", @@ -299,7 +405,10 @@ bool task_template_generate(task_template_t *template, char tag, const char *fil * Value will contain a newline character at the end, we need to strip * this otherwise kaboom, seriously, kaboom :P */ - *strrchr(value, '\n')='\0'; + if (strchr(value, '\n')) + *strrchr(value, '\n')='\0'; + else /* cppcheck: possible nullpointer dereference */ + abort(); /* * Now allocate and set the actual value for the specific tag. Which @@ -307,10 +416,20 @@ bool task_template_generate(task_template_t *template, char tag, const char *fil */ *destval = util_strdup(value); + + if (*destval == template->description) { + /* + * Create some padding for the description to align the + * printing of the rules file. + */ + if ((desclen = strlen(template->description)) > pad[0]) + pad[0] = desclen; + } + return true; } -bool task_template_parse(const char *file, task_template_t *template, FILE *fp) { +bool task_template_parse(const char *file, task_template_t *template, FILE *fp, size_t *pad) { char *data = NULL; char *back = NULL; size_t size = 0; @@ -320,7 +439,7 @@ bool task_template_parse(const char *file, task_template_t *template, FILE *fp) return false; /* top down parsing */ - while (util_getline(&back, &size, fp) != EOF) { + while (file_getline(&back, &size, fp) != EOF) { /* skip whitespace */ data = back; if (*data && (*data == ' ' || *data == '\t')) @@ -357,12 +476,11 @@ bool task_template_parse(const char *file, task_template_t *template, FILE *fp) * it to. */ case 'D': - case 'F': - case 'S': case 'T': case 'C': case 'E': case 'I': + case 'F': if (data[1] != ':') { con_printmsg(LVL_ERROR, file, line, "template parse error", "expected `:` after `%c`", @@ -370,7 +488,7 @@ bool task_template_parse(const char *file, task_template_t *template, FILE *fp) ); goto failure; } - if (!task_template_generate(template, *data, file, line, &data[3])) { + if (!task_template_generate(template, *data, file, line, &data[3], pad)) { con_printmsg(LVL_ERROR, file, line, "template compile error", "failed to generate for given task\n" ); @@ -400,7 +518,10 @@ bool task_template_parse(const char *file, task_template_t *template, FILE *fp) * Value will contain a newline character at the end, we need to strip * this otherwise kaboom, seriously, kaboom :P */ - *strrchr(value, '\n')='\0'; + if (strrchr(value, '\n')) + *strrchr(value, '\n')='\0'; + else /* cppcheck: possible null pointer dereference */ + abort(); vec_push(template->comparematch, util_strdup(value)); @@ -439,29 +560,39 @@ void task_template_nullify(task_template_t *template) { return; template->description = NULL; - template->failuremessage = NULL; - template->successmessage = NULL; template->proceduretype = NULL; template->compileflags = NULL; template->executeflags = NULL; template->comparematch = NULL; template->sourcefile = NULL; template->tempfilename = NULL; + template->rulesfile = NULL; + template->testflags = NULL; } -task_template_t *task_template_compile(const char *file, const char *dir) { +task_template_t *task_template_compile(const char *file, const char *dir, size_t *pad) { /* a page should be enough */ char fullfile[4096]; + size_t filepadd = 0; FILE *tempfile = NULL; task_template_t *template = NULL; memset (fullfile, 0, sizeof(fullfile)); snprintf(fullfile, sizeof(fullfile), "%s/%s", dir, file); - tempfile = fopen(fullfile, "r"); - template = mem_a(sizeof(task_template_t)); + tempfile = file_open(fullfile, "r"); + template = mem_a(sizeof(task_template_t)); task_template_nullify(template); + /* + * Create some padding for the printing to align the + * printing of the rules file to the console. + */ + if ((filepadd = strlen(fullfile)) > pad[1]) + pad[1] = filepadd; + + template->rulesfile = util_strdup(fullfile); + /* * Esnure the file even exists for the task, this is pretty useless * to even do. @@ -473,7 +604,7 @@ task_template_t *task_template_compile(const char *file, const char *dir) { goto failure; } - if (!task_template_parse(file, template, tempfile)) { + if (!task_template_parse(file, template, tempfile, pad)) { con_err("template parse error: error during parsing\n"); goto failure; } @@ -521,13 +652,19 @@ task_template_t *task_template_compile(const char *file, const char *dir) { con_err("template compile error: %s missing `M:` tag (use `$null` for exclude)\n", file); goto failure; } + } else if (!strcmp(template->proceduretype, "-fail")) { + if (template->executeflags) + con_err("template compile warning: %s erroneous tag `E:` when only failing\n", file); + if (template->comparematch) + con_err("template compile warning: %s erroneous tag `M:` when only failing\n", file); + goto success; } else { con_err("template compile error: %s invalid procedure type: %s\n", file, template->proceduretype); goto failure; } success: - fclose(tempfile); + file_close(tempfile); return template; failure: @@ -536,7 +673,7 @@ failure: * so the check to see if it's not null here is required. */ if (tempfile) - fclose(tempfile); + file_close(tempfile); mem_d (template); return NULL; @@ -547,12 +684,12 @@ void task_template_destroy(task_template_t **template) { return; if ((*template)->description) mem_d((*template)->description); - if ((*template)->failuremessage) mem_d((*template)->failuremessage); - if ((*template)->successmessage) mem_d((*template)->successmessage); if ((*template)->proceduretype) mem_d((*template)->proceduretype); if ((*template)->compileflags) mem_d((*template)->compileflags); if ((*template)->executeflags) mem_d((*template)->executeflags); if ((*template)->sourcefile) mem_d((*template)->sourcefile); + if ((*template)->rulesfile) mem_d((*template)->rulesfile); + if ((*template)->testflags) mem_d((*template)->testflags); /* * Delete all allocated string for task template then destroy the @@ -593,7 +730,7 @@ task_t *task_tasks = NULL; * Read a directory and searches for all template files in it * which is later used to run all tests. */ -bool task_propagate(const char *curdir) { +bool task_propagate(const char *curdir, size_t *pad, const char *defs) { bool success = true; DIR *dir; struct dirent *files; @@ -621,8 +758,9 @@ bool task_propagate(const char *curdir) { * actually a directory, so it must be a file :) */ if (strcmp(files->d_name + strlen(files->d_name) - 5, ".tmpl") == 0) { - task_template_t *template = task_template_compile(files->d_name, curdir); + task_template_t *template = task_template_compile(files->d_name, curdir, pad); char buf[4096]; /* one page should be enough */ + char *qcflags = NULL; task_t task; util_debug("TEST", "compiling task template: %s/%s\n", curdir, files->d_name); @@ -638,19 +776,62 @@ bool task_propagate(const char *curdir) { */ template->tempfilename = tempnam(curdir, "TMPDAT"); + /* + * Additional QCFLAGS enviroment variable may be used + * to test compile flags for all tests. This needs to be + * BEFORE other flags (so that the .tmpl can override them) + */ + qcflags = getenv("QCFLAGS"); + /* * Generate the command required to open a pipe to a process * which will be refered to with a handle in the task for * reading the data from the pipe. */ - memset (buf,0,sizeof(buf)); - snprintf(buf, sizeof(buf), "%s %s/%s %s -o %s", - task_bins[TASK_COMPILE], - curdir, - template->sourcefile, - template->compileflags, - template->tempfilename - ); + memset (buf,0,sizeof(buf)); + if (qcflags) { + if (template->testflags && !strcmp(template->testflags, "-no-defs")) { + snprintf(buf, sizeof(buf), "%s %s/%s %s %s -o %s", + task_bins[TASK_COMPILE], + curdir, + template->sourcefile, + qcflags, + template->compileflags, + template->tempfilename + ); + } else { + snprintf(buf, sizeof(buf), "%s %s/%s %s/%s %s %s -o %s", + task_bins[TASK_COMPILE], + curdir, + defs, + curdir, + template->sourcefile, + qcflags, + template->compileflags, + template->tempfilename + ); + } + } else { + if (template->testflags && !strcmp(template->testflags, "-no-defs")) { + snprintf(buf, sizeof(buf), "%s %s/%s %s -o %s", + task_bins[TASK_COMPILE], + curdir, + template->sourcefile, + template->compileflags, + template->tempfilename + ); + } else { + snprintf(buf, sizeof(buf), "%s %s/%s %s/%s %s -o %s", + task_bins[TASK_COMPILE], + curdir, + defs, + curdir, + template->sourcefile, + template->compileflags, + template->tempfilename + ); + } + } /* * The task template was compiled, now lets create a task from @@ -672,7 +853,7 @@ bool task_propagate(const char *curdir) { memset (buf,0,sizeof(buf)); snprintf(buf, sizeof(buf), "%s.stdout", template->tempfilename); task.stdoutlogfile = util_strdup(buf); - if (!(task.stdoutlog = fopen(buf, "w"))) { + if (!(task.stdoutlog = file_open(buf, "w"))) { con_err("error opening %s for stdout\n", buf); continue; } @@ -680,7 +861,7 @@ bool task_propagate(const char *curdir) { memset (buf,0,sizeof(buf)); snprintf(buf, sizeof(buf), "%s.stderr", template->tempfilename); task.stderrlogfile = util_strdup(buf); - if (!(task.stderrlog = fopen(buf, "w"))) { + if (!(task.stderrlog = file_open(buf, "w"))) { con_err("error opening %s for stderr\n", buf); continue; } @@ -698,31 +879,6 @@ bool task_propagate(const char *curdir) { return success; } -/* - * Removes all temporary 'progs.dat' files created during compilation - * of all tests' - */ -void task_cleanup(const char *curdir) { - DIR *dir; - struct dirent *files; - char buffer[4096]; - - dir = opendir(curdir); - - while ((files = readdir(dir))) { - memset(buffer, 0, sizeof(buffer)); - if (strstr(files->d_name, "TMP")) { - snprintf(buffer, sizeof(buffer), "%s/%s", curdir, files->d_name); - if (remove(buffer)) - con_err("error removing temporary file: %s\n", buffer); - else - util_debug("TEST", "removed temporary file: %s\n", buffer); - } - } - - closedir(dir); -} - /* * Task precleanup removes any existing temporary files or log files * left behind from a previous invoke of the test-suite. @@ -751,7 +907,7 @@ void task_precleanup(const char *curdir) { closedir(dir); } -void task_destroy(const char *curdir) { +void task_destroy(void) { /* * Free all the data in the task list and finally the list itself * then proceed to cleanup anything else outside the program like @@ -764,23 +920,25 @@ void task_destroy(const char *curdir) { * annoying to have to do all this cleanup work. */ if (task_tasks[i].runhandles) task_pclose(task_tasks[i].runhandles); - if (task_tasks[i].stdoutlog) fclose (task_tasks[i].stdoutlog); - if (task_tasks[i].stderrlog) fclose (task_tasks[i].stderrlog); + if (task_tasks[i].stdoutlog) file_close (task_tasks[i].stdoutlog); + if (task_tasks[i].stderrlog) file_close (task_tasks[i].stderrlog); /* * Only remove the log files if the test actually compiled otherwise - * forget about it. + * forget about it (or if it didn't compile, and the procedure type + * was set to -fail (meaning it shouldn't compile) .. stil remove) */ - if (task_tasks[i].compiled) { + if (task_tasks[i].compiled || !strcmp(task_tasks[i].template->proceduretype, "-fail")) { if (remove(task_tasks[i].stdoutlogfile)) con_err("error removing stdout log file: %s\n", task_tasks[i].stdoutlogfile); else util_debug("TEST", "removed stdout log file: %s\n", task_tasks[i].stdoutlogfile); - if (remove(task_tasks[i].stderrlogfile)) con_err("error removing stderr log file: %s\n", task_tasks[i].stderrlogfile); else util_debug("TEST", "removed stderr log file: %s\n", task_tasks[i].stderrlogfile); + + remove(task_tasks[i].template->tempfilename); } /* free util_strdup data for log files */ @@ -790,11 +948,6 @@ void task_destroy(const char *curdir) { task_template_destroy(&task_tasks[i].template); } vec_free(task_tasks); - - /* - * Cleanup outside stuff like temporary files. - */ - task_cleanup(curdir); } /* @@ -842,12 +995,11 @@ bool task_execute(task_template_t *template, char ***line) { char *data = NULL; size_t size = 0; size_t compare = 0; - while (util_getline(&data, &size, execute) != EOF) { + while (file_getline(&data, &size, execute) != EOF) { if (!strcmp(data, "No main function found\n")) { - con_err("test failure: `%s` [%s] (No main function found)\n", + con_err("test failure: `%s` (No main function found) [%s]\n", template->description, - (template->failuremessage) ? - template->failuremessage : "unknown" + template->rulesfile ); pclose(execute); return false; @@ -890,7 +1042,7 @@ bool task_execute(task_template_t *template, char ***line) { * execution this takes more work since a task needs to be generated * from thin air and executed INLINE. */ -void task_schedualize() { +void task_schedualize(size_t *pad) { bool execute = false; char *data = NULL; char **match = NULL; @@ -918,8 +1070,8 @@ void task_schedualize() { * Read data from stdout first and pipe that stuff into a log file * then we do the same for stderr. */ - while (util_getline(&data, &size, task_tasks[i].runhandles[1]) != EOF) { - fputs(data, task_tasks[i].stdoutlog); + while (file_getline(&data, &size, task_tasks[i].runhandles[1]) != EOF) { + file_puts(task_tasks[i].stdoutlog, data); if (strstr(data, "failed to open file")) { task_tasks[i].compiled = false; @@ -928,7 +1080,7 @@ void task_schedualize() { fflush(task_tasks[i].stdoutlog); } - while (util_getline(&data, &size, task_tasks[i].runhandles[2]) != EOF) { + while (file_getline(&data, &size, task_tasks[i].runhandles[2]) != EOF) { /* * If a string contains an error we just dissalow execution * of it in the vm. @@ -942,26 +1094,27 @@ void task_schedualize() { task_tasks[i].compiled = false; } - fputs(data, task_tasks[i].stderrlog); + file_puts(task_tasks[i].stderrlog, data); fflush(task_tasks[i].stdoutlog); } - if (!task_tasks[i].compiled) { - con_err("test failure: `%s` [%s] (failed to compile) see %s.stdout and %s.stderr\n", + if (!task_tasks[i].compiled && strcmp(task_tasks[i].template->proceduretype, "-fail")) { + con_err("test failure: `%s` (failed to compile) see %s.stdout and %s.stderr [%s]\n", task_tasks[i].template->description, - (task_tasks[i].template->failuremessage) ? - task_tasks[i].template->failuremessage : "unknown", task_tasks[i].template->tempfilename, - task_tasks[i].template->tempfilename + task_tasks[i].template->tempfilename, + task_tasks[i].template->rulesfile ); continue; } if (!execute) { - con_out("test succeeded: `%s` [%s]\n", - task_tasks[i].template->description, - (task_tasks[i].template->successmessage) ? - task_tasks[i].template->successmessage : "unknown" + con_out("test succeeded: `%s` %*s\n", + task_tasks[i].template->description, + (pad[0] + pad[1] - strlen(task_tasks[i].template->description)) + + (strlen(task_tasks[i].template->rulesfile) - pad[1]), + task_tasks[i].template->rulesfile + ); continue; } @@ -973,10 +1126,9 @@ void task_schedualize() { if (!task_execute(task_tasks[i].template, &match)) { size_t d = 0; - con_err("test failure: `%s` [%s] (invalid results from execution)\n", - task_tasks[i].template->description, - (task_tasks[i].template->failuremessage) ? - task_tasks[i].template->failuremessage : "unknown" + con_err("test failure: `%s` (invalid results from execution) [%s]\n", + task_tasks[i].template->description, + task_tasks[i].template->rulesfile ); /* @@ -1021,10 +1173,12 @@ void task_schedualize() { mem_d(match[j]); vec_free(match); - con_out("test succeeded: `%s` [%s]\n", - task_tasks[i].template->description, - (task_tasks[i].template->successmessage) ? - task_tasks[i].template->successmessage : "unknown" + con_out("test succeeded: `%s` %*s\n", + task_tasks[i].template->description, + (pad[0] + pad[1] - strlen(task_tasks[i].template->description)) + + (strlen(task_tasks[i].template->rulesfile) - pad[1]), + task_tasks[i].template->rulesfile + ); } mem_d(data); @@ -1044,11 +1198,26 @@ void task_schedualize() { * * It expects con_init() was called before hand. */ -bool test_perform(const char *curdir) { +GMQCC_WARN bool test_perform(const char *curdir, const char *defs) { + static const char *default_defs = "defs.qh"; + + size_t pad[] = { + 0, 0 + }; + + /* + * If the default definition file isn't set to anything. We will + * use the default_defs here, which is "defs.qc" + */ + if (!defs) { + defs = default_defs; + } + + task_precleanup(curdir); - if (!task_propagate(curdir)) { + if (!task_propagate(curdir, pad, defs)) { con_err("error: failed to propagate tasks\n"); - task_destroy(curdir); + task_destroy(); return false; } /* @@ -1058,8 +1227,8 @@ bool test_perform(const char *curdir) { * it's designed to prevent lock contention, and possible syncronization * issues. */ - task_schedualize(); - task_destroy(curdir); + task_schedualize(pad); + task_destroy(); return true; } @@ -1095,8 +1264,10 @@ static bool parsecmd(const char *optname, int *argc_, char ***argv_, char **out, } int main(int argc, char **argv) { + bool succeed = false; char *redirout = (char*)stdout; char *redirerr = (char*)stderr; + char *defs = NULL; con_init(); @@ -1113,15 +1284,17 @@ int main(int argc, char **argv) { continue; if (parsecmd("redirerr", &argc, &argv, &redirerr, 1, false)) continue; + if (parsecmd("defs", &argc, &argv, &defs, 1, false)) + continue; con_change(redirout, redirerr); if (!strcmp(argv[0]+1, "debug")) { - opts.debug = true; + OPTS_OPTION_BOOL(OPTION_DEBUG) = true; continue; } if (!strcmp(argv[0]+1, "memchk")) { - opts.memchk = true; + OPTS_OPTION_BOOL(OPTION_MEMCHK) = true; continue; } if (!strcmp(argv[0]+1, "nocolor")) { @@ -1134,7 +1307,9 @@ int main(int argc, char **argv) { } } con_change(redirout, redirerr); - test_perform("tests"); + succeed = test_perform("tests", defs); util_meminfo(); - return 0; + + + return (succeed) ? EXIT_SUCCESS : EXIT_FAILURE; }