X-Git-Url: https://git.xonotic.org/?p=xonotic%2Fgmqcc.git;a=blobdiff_plain;f=test.c;h=629a10e9e711187df4686a03decdfdd114e38896;hp=5f7eac7c83e948b141d314f658d2005e66479486;hb=a68f0fcb355db42acabe72da5939fbd1b04f6016;hpb=684112474b4ff1eee2dde4aa3f84c8b6c52c612f diff --git a/test.c b/test.c index 5f7eac7..629a10e 100644 --- a/test.c +++ b/test.c @@ -104,13 +104,13 @@ static FILE ** task_popen(const char *command, const char *mode) { data->pipes [0] = inhandle [1]; data->pipes [1] = outhandle[0]; data->pipes [2] = errhandle[0]; + data->handles[0] = fdopen(inhandle [1], "w"); data->handles[1] = fdopen(outhandle[0], mode); data->handles[2] = fdopen(errhandle[0], mode); /* sigh */ - if (argv) - vec_free(argv); + vec_free(argv); return data->handles; } else if (data->pid == 0) { /* child */ @@ -119,9 +119,9 @@ static FILE ** task_popen(const char *command, const char *mode) { close(errhandle[0]); /* see piping documentation for this sillyness :P */ - close(0); (void)!dup(inhandle [0]); - close(1); (void)!dup(outhandle[1]); - close(2); (void)!dup(errhandle[1]); + dup2(inhandle [0], 0); + dup2(outhandle[1], 1); + dup2(errhandle[1], 2); execvp(*argv, argv); exit(EXIT_FAILURE); @@ -135,8 +135,7 @@ task_popen_error_2: close(outhandle[0]), close(outhandle[1]); task_popen_error_1: close(inhandle [0]), close(inhandle [1]); task_popen_error_0: - if (argv) - vec_free(argv); + vec_free(argv); return NULL; } @@ -439,7 +438,7 @@ static bool task_template_parse(const char *file, task_template_t *tmpl, FILE *f goto failure; } - if (value && *value && (*value == ' ' || *value == '\t')) + if (value && (*value == ' ' || *value == '\t')) value++; /* @@ -474,8 +473,7 @@ static bool task_template_parse(const char *file, task_template_t *tmpl, FILE *f return true; failure: - if (back) - mem_d (back); + mem_d (back); return false; } @@ -584,6 +582,13 @@ static task_template_t *task_template_compile(const char *file, const char *dir, con_err("template compile warning: %s erroneous tag `E:` when only failing\n", file); if (tmpl->comparematch) con_err("template compile warning: %s erroneous tag `M:` when only failing\n", file); + } else if (!strcmp(tmpl->proceduretype, "-diagnostic")) { + if (tmpl->executeflags) + con_err("template compile warning: %s erroneous tag `E:` when only diagnostic\n", file); + if (!tmpl->comparematch) { + con_err("template compile error: %s missing `M:` tag (use `$null` for exclude)\n", file); + goto failure; + } } else if (!strcmp(tmpl->proceduretype, "-pp")) { if (tmpl->executeflags) con_err("template compile warning: %s erroneous tag `E:` when only preprocessing\n", file); @@ -640,6 +645,7 @@ static void task_template_destroy(task_template_t **tmpl) { * Nullify all the template members otherwise NULL comparision * checks will fail if tmpl pointer is reused. */ + mem_d((*tmpl)->tempfilename); mem_d(*tmpl); } @@ -670,172 +676,204 @@ static bool task_propagate(const char *curdir, size_t *pad, const char *defs) { struct stat directory; char buffer[4096]; size_t found = 0; + char **directories = NULL; + char *claim = util_strdup(curdir); + size_t i; + + vec_push(directories, claim); + dir = fs_dir_open(claim); - dir = fs_dir_open(curdir); - + /* + * Generate a list of subdirectories since we'll be checking them too + * for tmpl files. + */ while ((files = fs_dir_read(dir))) { - util_snprintf(buffer, sizeof(buffer), "%s/%s", curdir, files->d_name); - - if (stat(buffer, &directory) == -1) { - con_err("internal error: stat failed, aborting\n"); - abort(); + util_asprintf(&claim, "%s/%s", curdir, files->d_name); + if (stat(claim, &directory) == -1) + return false; + + if (S_ISDIR(directory.st_mode) && files->d_name[0] != '.') { + vec_push(directories, claim); + } else { + mem_d(claim); + claim = NULL; } + } + fs_dir_close(dir); - /* skip directories */ - if (S_ISDIR(directory.st_mode)) - continue; + /* + * Now do all the work, by touching all the directories inside + * test as well and compile the task templates into data we can + * use to run the tests. + */ + for (i = 0; i < vec_size(directories); i++) { + dir = fs_dir_open(directories[i]); + + while ((files = fs_dir_read(dir))) { + util_snprintf(buffer, sizeof(buffer), "%s/%s", directories[i], files->d_name); + if (stat(buffer, &directory) == -1) { + con_err("internal error: stat failed, aborting\n"); + abort(); + } - /* - * We made it here, which concludes the file/directory is not - * actually a directory, so it must be a file :) - */ - if (strcmp(files->d_name + strlen(files->d_name) - 5, ".tmpl") == 0) { - task_template_t *tmpl = 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); - found ++; - if (!tmpl) { - con_err("error compiling task template: %s\n", files->d_name); - success = false; + if (S_ISDIR(directory.st_mode)) continue; - } - /* - * Generate a temportary file name for the output binary - * so we don't trample over an existing one. - */ - tmpl->tempfilename = NULL; - util_asprintf(&tmpl->tempfilename, "%s/TMPDAT.%s", curdir, files->d_name); /* - * 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) + * We made it here, which concludes the file/directory is not + * actually a directory, so it must be a file :) */ - #ifdef _MSC_VER - { - char buffer[4096]; - size_t size; - getenv_s(&size, buffer, sizeof(buffer), "QCFLAGS"); - qcflags = buffer; - } - #else - qcflags = getenv("QCFLAGS"); - #endif + if (strcmp(files->d_name + strlen(files->d_name) - 5, ".tmpl") == 0) { + task_template_t *tmpl = task_template_compile(files->d_name, directories[i], pad); + char buf[4096]; /* one page should be enough */ + char *qcflags = NULL; + task_t task; + + util_debug("TEST", "compiling task template: %s/%s\n", directories[i], files->d_name); + found ++; + if (!tmpl) { + con_err("error compiling task template: %s\n", files->d_name); + success = false; + continue; + } + /* + * Generate a temportary file name for the output binary + * so we don't trample over an existing one. + */ + tmpl->tempfilename = NULL; + util_asprintf(&tmpl->tempfilename, "%s/TMPDAT.%s", directories[i], files->d_name); - /* - * 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. - */ - if (strcmp(tmpl->proceduretype, "-pp")) { - if (qcflags) { - if (tmpl->testflags && !strcmp(tmpl->testflags, "-no-defs")) { - util_snprintf(buf, sizeof(buf), "%s %s/%s %s %s -o %s", - task_bins[TASK_COMPILE], - curdir, - tmpl->sourcefile, - qcflags, - tmpl->compileflags, - tmpl->tempfilename - ); + /* + * 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) + */ + #ifdef _MSC_VER + { + char buffer[4096]; + size_t size; + getenv_s(&size, buffer, sizeof(buffer), "QCFLAGS"); + qcflags = buffer; + } + #else + qcflags = getenv("QCFLAGS"); + #endif + + /* + * 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. + */ + if (strcmp(tmpl->proceduretype, "-pp")) { + if (qcflags) { + if (tmpl->testflags && !strcmp(tmpl->testflags, "-no-defs")) { + util_snprintf(buf, sizeof(buf), "%s %s/%s %s %s -o %s", + task_bins[TASK_COMPILE], + directories[i], + tmpl->sourcefile, + qcflags, + tmpl->compileflags, + tmpl->tempfilename + ); + } else { + util_snprintf(buf, sizeof(buf), "%s %s/%s %s/%s %s %s -o %s", + task_bins[TASK_COMPILE], + curdir, + defs, + directories[i], + tmpl->sourcefile, + qcflags, + tmpl->compileflags, + tmpl->tempfilename + ); + } } else { - util_snprintf(buf, sizeof(buf), "%s %s/%s %s/%s %s %s -o %s", - task_bins[TASK_COMPILE], - curdir, - defs, - curdir, - tmpl->sourcefile, - qcflags, - tmpl->compileflags, - tmpl->tempfilename - ); + if (tmpl->testflags && !strcmp(tmpl->testflags, "-no-defs")) { + util_snprintf(buf, sizeof(buf), "%s %s/%s %s -o %s", + task_bins[TASK_COMPILE], + directories[i], + tmpl->sourcefile, + tmpl->compileflags, + tmpl->tempfilename + ); + } else { + util_snprintf(buf, sizeof(buf), "%s %s/%s %s/%s %s -o %s", + task_bins[TASK_COMPILE], + curdir, + defs, + directories[i], + tmpl->sourcefile, + tmpl->compileflags, + tmpl->tempfilename + ); + } } } else { + /* Preprocessing (qcflags mean shit all here we don't allow them) */ if (tmpl->testflags && !strcmp(tmpl->testflags, "-no-defs")) { - util_snprintf(buf, sizeof(buf), "%s %s/%s %s -o %s", + util_snprintf(buf, sizeof(buf), "%s -E %s/%s -o %s", task_bins[TASK_COMPILE], - curdir, + directories[i], tmpl->sourcefile, - tmpl->compileflags, tmpl->tempfilename ); } else { - util_snprintf(buf, sizeof(buf), "%s %s/%s %s/%s %s -o %s", + util_snprintf(buf, sizeof(buf), "%s -E %s/%s %s/%s -o %s", task_bins[TASK_COMPILE], curdir, defs, - curdir, + directories[i], tmpl->sourcefile, - tmpl->compileflags, tmpl->tempfilename ); } } - } else { - /* Preprocessing (qcflags mean shit all here we don't allow them) */ - if (tmpl->testflags && !strcmp(tmpl->testflags, "-no-defs")) { - util_snprintf(buf, sizeof(buf), "%s -E %s/%s -o %s", - task_bins[TASK_COMPILE], - curdir, - tmpl->sourcefile, - tmpl->tempfilename - ); - } else { - util_snprintf(buf, sizeof(buf), "%s -E %s/%s %s/%s -o %s", - task_bins[TASK_COMPILE], - curdir, - defs, - curdir, - tmpl->sourcefile, - tmpl->tempfilename - ); + + /* + * The task template was compiled, now lets create a task from + * the template data which has now been propagated. + */ + task.tmpl = tmpl; + if (!(task.runhandles = task_popen(buf, "r"))) { + con_err("error opening pipe to process for test: %s\n", tmpl->description); + success = false; + continue; } - } - /* - * The task template was compiled, now lets create a task from - * the template data which has now been propagated. - */ - task.tmpl = tmpl; - if (!(task.runhandles = task_popen(buf, "r"))) { - con_err("error opening pipe to process for test: %s\n", tmpl->description); - success = false; - continue; - } + util_debug("TEST", "executing test: `%s` [%s]\n", tmpl->description, buf); - util_debug("TEST", "executing test: `%s` [%s]\n", tmpl->description, buf); + /* + * Open up some file desciptors for logging the stdout/stderr + * to our own. + */ + util_snprintf(buf, sizeof(buf), "%s.stdout", tmpl->tempfilename); + task.stdoutlogfile = util_strdup(buf); + if (!(task.stdoutlog = fs_file_open(buf, "w"))) { + con_err("error opening %s for stdout\n", buf); + continue; + } - /* - * Open up some file desciptors for logging the stdout/stderr - * to our own. - */ - util_snprintf(buf, sizeof(buf), "%s.stdout", tmpl->tempfilename); - task.stdoutlogfile = util_strdup(buf); - if (!(task.stdoutlog = fs_file_open(buf, "w"))) { - con_err("error opening %s for stdout\n", buf); - continue; - } + util_snprintf(buf, sizeof(buf), "%s.stderr", tmpl->tempfilename); + task.stderrlogfile = util_strdup(buf); + if (!(task.stderrlog = fs_file_open(buf, "w"))) { + con_err("error opening %s for stderr\n", buf); + continue; + } - util_snprintf(buf, sizeof(buf), "%s.stderr", tmpl->tempfilename); - task.stderrlogfile = util_strdup(buf); - if (!(task.stderrlog = fs_file_open(buf, "w"))) { - con_err("error opening %s for stderr\n", buf); - continue; + vec_push(task_tasks, task); } - - vec_push(task_tasks, task); } + + fs_dir_close(dir); + mem_d(directories[i]); /* free claimed memory */ } + vec_free(directories); util_debug("TEST", "compiled %d task template files out of %d\n", vec_size(task_tasks), found ); - fs_dir_close(dir); return success; } @@ -897,7 +935,7 @@ static void task_destroy(void) { else util_debug("TEST", "removed stderr log file: %s\n", task_tasks[i].stderrlogfile); - remove(task_tasks[i].tmpl->tempfilename); + (void)!remove(task_tasks[i].tmpl->tempfilename); } /* free util_strdup data for log files */ @@ -915,14 +953,16 @@ static void task_destroy(void) { * messages IF the procedure type is -execute, otherwise it matches * the preprocessor output. */ -static bool task_trymatch(task_template_t *tmpl, char ***line) { - bool success = true; - bool preprocessing = false; - FILE *execute; - char buffer[4096]; +static bool task_trymatch(size_t i, char ***line) { + bool success = true; + bool process = true; + FILE *execute; + char buffer[4096]; + task_template_t *tmpl = task_tasks[i].tmpl; + memset (buffer,0,sizeof(buffer)); - if (strcmp(tmpl->proceduretype, "-pp")) { + if (!strcmp(tmpl->proceduretype, "-execute")) { /* * Drop the execution flags for the QCVM if none where * actually specified. @@ -948,7 +988,7 @@ static bool task_trymatch(task_template_t *tmpl, char ***line) { execute = popen(buffer, "r"); if (!execute) return false; - } else { + } else if (!strcmp(tmpl->proceduretype, "-pp")) { /* * we're preprocessing, which means we need to read int * the produced file and do some really weird shit. @@ -956,7 +996,17 @@ static bool task_trymatch(task_template_t *tmpl, char ***line) { if (!(execute = fs_file_open(tmpl->tempfilename, "r"))) return false; - preprocessing = true; + process = false; + } else { + /* + * we're testing diagnostic output, which means it will be + * in runhandles[2] (stderr) since that is where the compiler + * puts it's errors. + */ + if (!(execute = fs_file_open(task_tasks[i].stderrlogfile, "r"))) + return false; + + process = false; } /* @@ -967,13 +1017,14 @@ static bool task_trymatch(task_template_t *tmpl, char ***line) { char *data = NULL; size_t size = 0; size_t compare = 0; + while (fs_file_getline(&data, &size, execute) != EOF) { if (!strcmp(data, "No main function found\n")) { con_err("test failure: `%s` (No main function found) [%s]\n", tmpl->description, tmpl->rulesfile ); - if (preprocessing) + if (!process) fs_file_close(execute); else pclose(execute); @@ -986,6 +1037,20 @@ static bool task_trymatch(task_template_t *tmpl, char ***line) { */ if (strrchr(data, '\n')) *strrchr(data, '\n') = '\0'; + + /* + * We remove the file/directory and stuff from the error + * match messages when testing diagnostics. + */ + if(!strcmp(tmpl->proceduretype, "-diagnostic")) { + if (strstr(data, "there have been errors, bailing out")) + continue; /* ignore it */ + if (strstr(data, ": error: ")) { + char *claim = util_strdup(data + (strstr(data, ": error: ") - data) + 9); + mem_d(data); + data = claim; + } + } /* * If data is just null now, that means the line was an empty @@ -995,10 +1060,11 @@ static bool task_trymatch(task_template_t *tmpl, char ***line) { continue; if (vec_size(tmpl->comparematch) > compare) { - if (strcmp(data, tmpl->comparematch[compare++])) + if (strcmp(data, tmpl->comparematch[compare++])) { success = false; + } } else { - success = false; + success = false; } /* @@ -1015,7 +1081,7 @@ static bool task_trymatch(task_template_t *tmpl, char ***line) { data = NULL; } - if (!preprocessing) + if (process) pclose(execute); else fs_file_close(execute); @@ -1030,6 +1096,8 @@ static const char *task_type(task_template_t *tmpl) { return "type: execution"; if (!strcmp(tmpl->proceduretype, "-compile")) return "type: compile"; + if (!strcmp(tmpl->proceduretype, "-diagnostic")) + return "type: diagnostic"; return "type: fail"; } @@ -1040,7 +1108,7 @@ static const char *task_type(task_template_t *tmpl) { * from thin air and executed INLINE. */ #include -static void task_schedualize(size_t *pad) { +static size_t task_schedualize(size_t *pad) { char space[2][64]; bool execute = false; char *data = NULL; @@ -1048,6 +1116,7 @@ static void task_schedualize(size_t *pad) { size_t size = 0; size_t i = 0; size_t j = 0; + size_t failed = 0; util_snprintf(space[0], sizeof(space[0]), "%d", (int)vec_size(task_tasks)); @@ -1062,8 +1131,11 @@ static void task_schedualize(size_t *pad) { * Generate a task from thin air if it requires execution in * the QCVM. */ + + /* diagnostic is not executed, but compare tested instead, like preproessor */ execute = !! (!strcmp(task_tasks[i].tmpl->proceduretype, "-execute")) || - (!strcmp(task_tasks[i].tmpl->proceduretype, "-pp")); + (!strcmp(task_tasks[i].tmpl->proceduretype, "-pp")) || + (!strcmp(task_tasks[i].tmpl->proceduretype, "-diagnostic")); /* * We assume it compiled before we actually compiled :). On error @@ -1092,12 +1164,13 @@ static void task_schedualize(size_t *pad) { * that refers to a variable named error, or something like * that .. then this will blowup :P */ - if (strstr(data, "error")) { + if (strstr(data, "error") && strcmp(task_tasks[i].tmpl->proceduretype, "-diagnostic")) { execute = false; task_tasks[i].compiled = false; } fs_file_puts (task_tasks[i].stderrlog, data); + fflush(task_tasks[i].stderrlog); /* fast flush for read */ } if (!task_tasks[i].compiled && strcmp(task_tasks[i].tmpl->proceduretype, "-fail")) { @@ -1108,6 +1181,7 @@ static void task_schedualize(size_t *pad) { (pad[1] + pad[2] - strlen(task_tasks[i].tmpl->rulesfile)) + (strlen("(failed to compile)") - pad[2]), "(failed to compile)" ); + failed++; continue; } @@ -1128,7 +1202,7 @@ static void task_schedualize(size_t *pad) { * in the virtual machine (or the preprocessor output needs to * be matched). */ - if (!task_trymatch(task_tasks[i].tmpl, &match)) { + if (!task_trymatch(i, &match)) { size_t d = 0; con_out("failure: `%s` %*s %*s\n", @@ -1138,11 +1212,15 @@ static void task_schedualize(size_t *pad) { (pad[1] + pad[2] - strlen(task_tasks[i].tmpl->rulesfile)) + (strlen( (strcmp(task_tasks[i].tmpl->proceduretype, "-pp")) ? "(invalid results from execution)" - : "(invalid results from preprocessing)" + : (strcmp(task_tasks[i].tmpl->proceduretype, "-diagnostic")) + ? "(invalid results from preprocessing)" + : "(invalid results from compiler diagnsotics)" ) - pad[2]), (strcmp(task_tasks[i].tmpl->proceduretype, "-pp")) ? "(invalid results from execution)" - : "(invalid results from preprocessing)" + : (strcmp(task_tasks[i].tmpl->proceduretype, "-diagnostic")) + ? "(invalid results from preprocessing)" + : "(invalid results from compiler diagnsotics)" ); /* @@ -1156,7 +1234,7 @@ static void task_schedualize(size_t *pad) { ); for (; d < vec_size(task_tasks[i].tmpl->comparematch); d++) { char *select = task_tasks[i].tmpl->comparematch[d]; - size_t length = 40 - strlen(select); + size_t length = 60 - strlen(select); con_out(" Expected: \"%s\"", select); while (length --) @@ -1171,7 +1249,7 @@ static void task_schedualize(size_t *pad) { */ if (vec_size(match) > vec_size(task_tasks[i].tmpl->comparematch)) { for (d = 0; d < vec_size(match) - vec_size(task_tasks[i].tmpl->comparematch); d++) { - con_out(" Expected: Nothing | Got: \"%s\"\n", + con_out(" Expected: Nothing | Got: \"%s\"\n", match[d + vec_size(task_tasks[i].tmpl->comparematch)] ); } @@ -1181,8 +1259,10 @@ static void task_schedualize(size_t *pad) { for (j = 0; j < vec_size(match); j++) mem_d(match[j]); vec_free(match); + failed++; continue; } + for (j = 0; j < vec_size(match); j++) mem_d(match[j]); vec_free(match); @@ -1197,6 +1277,7 @@ static void task_schedualize(size_t *pad) { ); } mem_d(data); + return failed; } /* @@ -1214,6 +1295,7 @@ static void task_schedualize(size_t *pad) { * It expects con_init() was called before hand. */ static GMQCC_WARN bool test_perform(const char *curdir, const char *defs) { + size_t failed = false; static const char *default_defs = "defs.qh"; size_t pad[] = { @@ -1243,10 +1325,12 @@ static GMQCC_WARN bool test_perform(const char *curdir, const char *defs) { * it's designed to prevent lock contention, and possible syncronization * issues. */ - task_schedualize(pad); + failed = task_schedualize(pad); + if (failed) + con_out("%u out of %u tests failed\n", failed, vec_size(task_tasks)); task_destroy(); - return true; + return (failed) ? false : true; } /*