darkplaces/gmqcc
0
0
Fork 0
mirror of https://github.com/DarkPlacesEngine/gmqcc.git synced 2025-01-05 16:40:50 +00:00
Code Issues Projects Releases Packages Wiki Activity

Make the testsuite C++ compatible.

Browse source
This commit is contained in:
Dale Weiler 2013-02-06 10:52:09 +00:00
parent eb0e3c2898
commit ecd9e3be97
1 changed files with 132 additions and 132 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

264
test.c
View file

@ -26,7 +26,7 @@
opts_cmd_t opts; opts_cmd_t opts;
char *task_bins[] = { const char *task_bins[] = {
"./gmqcc", "./gmqcc",
"./qcvm" "./qcvm"
}; };
@ -66,7 +66,7 @@ FILE ** task_popen(const char *command, const char *mode) {
int errhandle [2]; int errhandle [2];
int trypipe; int trypipe;
popen_t *data = mem_a(sizeof(popen_t)); popen_t *data = (popen_t*)mem_a(sizeof(popen_t));
/* /*
* Parse the command now into a list for execv, this is a pain * Parse the command now into a list for execv, this is a pain
@ -360,20 +360,20 @@ typedef struct {
* This is very much like a compiler code generator :-). This generates * This is very much like a compiler code generator :-). This generates
* a value from some data observed from the compiler. * 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, size_t *pad) { bool task_template_generate(task_template_t *tmpl, char tag, const char *file, size_t line, char *value, size_t *pad) {
size_t desclen = 0; size_t desclen = 0;
char **destval = NULL; char **destval = NULL;
if (!template) if (!tmpl)
return false; return false;
switch(tag) { switch(tag) {
case 'D': destval = &template->description; break; case 'D': destval = &tmpl->description; break;
case 'T': destval = &template->proceduretype; break; case 'T': destval = &tmpl->proceduretype; break;
case 'C': destval = &template->compileflags; break; case 'C': destval = &tmpl->compileflags; break;
case 'E': destval = &template->executeflags; break; case 'E': destval = &tmpl->executeflags; break;
case 'I': destval = &template->sourcefile; break; case 'I': destval = &tmpl->sourcefile; break;
case 'F': destval = &template->testflags; break; case 'F': destval = &tmpl->testflags; break;
default: default:
con_printmsg(LVL_ERROR, __FILE__, __LINE__, "internal error", con_printmsg(LVL_ERROR, __FILE__, __LINE__, "internal error",
"invalid tag `%c:` during code generation\n", "invalid tag `%c:` during code generation\n",
@ -417,25 +417,25 @@ bool task_template_generate(task_template_t *template, char tag, const char *fil
*destval = util_strdup(value); *destval = util_strdup(value);
if (*destval == template->description) { if (*destval == tmpl->description) {
/* /*
* Create some padding for the description to align the * Create some padding for the description to align the
* printing of the rules file. * printing of the rules file.
*/ */
if ((desclen = strlen(template->description)) > pad[0]) if ((desclen = strlen(tmpl->description)) > pad[0])
pad[0] = desclen; pad[0] = desclen;
} }
return true; return true;
} }
bool task_template_parse(const char *file, task_template_t *template, FILE *fp, size_t *pad) { bool task_template_parse(const char *file, task_template_t *tmpl, FILE *fp, size_t *pad) {
char *data = NULL; char *data = NULL;
char *back = NULL; char *back = NULL;
size_t size = 0; size_t size = 0;
size_t line = 1; size_t line = 1;
if (!template) if (!tmpl)
return false; return false;
/* top down parsing */ /* top down parsing */
@ -447,12 +447,12 @@ bool task_template_parse(const char *file, task_template_t *template, FILE *fp,
switch (*data) { switch (*data) {
/* /*
* Handle comments inside task template files. We're strict * Handle comments inside task tmpl files. We're strict
* about the language for fun :-) * about the language for fun :-)
*/ */
case '/': case '/':
if (data[1] != '/') { if (data[1] != '/') {
con_printmsg(LVL_ERROR, file, line, "template parse error", con_printmsg(LVL_ERROR, file, line, "tmpl parse error",
"invalid character `/`, perhaps you meant `//` ?"); "invalid character `/`, perhaps you meant `//` ?");
mem_d(back); mem_d(back);
@ -482,14 +482,14 @@ bool task_template_parse(const char *file, task_template_t *template, FILE *fp,
case 'I': case 'I':
case 'F': case 'F':
if (data[1] != ':') { if (data[1] != ':') {
con_printmsg(LVL_ERROR, file, line, "template parse error", con_printmsg(LVL_ERROR, file, line, "tmpl parse error",
"expected `:` after `%c`", "expected `:` after `%c`",
*data *data
); );
goto failure; goto failure;
} }
if (!task_template_generate(template, *data, file, line, &data[3], pad)) { if (!task_template_generate(tmpl, *data, file, line, &data[3], pad)) {
con_printmsg(LVL_ERROR, file, line, "template compile error", con_printmsg(LVL_ERROR, file, line, "tmpl compile error",
"failed to generate for given task\n" "failed to generate for given task\n"
); );
goto failure; goto failure;
@ -504,7 +504,7 @@ bool task_template_parse(const char *file, task_template_t *template, FILE *fp,
{ {
char *value = &data[3]; char *value = &data[3];
if (data[1] != ':') { if (data[1] != ':') {
con_printmsg(LVL_ERROR, file, line, "template parse error", con_printmsg(LVL_ERROR, file, line, "tmpl parse error",
"expected `:` after `%c`", "expected `:` after `%c`",
*data *data
); );
@ -523,13 +523,13 @@ bool task_template_parse(const char *file, task_template_t *template, FILE *fp,
else /* cppcheck: possible null pointer dereference */ else /* cppcheck: possible null pointer dereference */
abort(); abort();
vec_push(template->comparematch, util_strdup(value)); vec_push(tmpl->comparematch, util_strdup(value));
break; break;
} }
default: default:
con_printmsg(LVL_ERROR, file, line, "template parse error", con_printmsg(LVL_ERROR, file, line, "tmpl parse error",
"invalid tag `%c`", *data "invalid tag `%c`", *data
); );
goto failure; goto failure;
@ -555,19 +555,19 @@ failure:
* Nullifies the template data: used during initialization of a new * Nullifies the template data: used during initialization of a new
* template and free. * template and free.
*/ */
void task_template_nullify(task_template_t *template) { void task_template_nullify(task_template_t *tmpl) {
if (!template) if (!tmpl)
return; return;
template->description = NULL; tmpl->description = NULL;
template->proceduretype = NULL; tmpl->proceduretype = NULL;
template->compileflags = NULL; tmpl->compileflags = NULL;
template->executeflags = NULL; tmpl->executeflags = NULL;
template->comparematch = NULL; tmpl->comparematch = NULL;
template->sourcefile = NULL; tmpl->sourcefile = NULL;
template->tempfilename = NULL; tmpl->tempfilename = NULL;
template->rulesfile = NULL; tmpl->rulesfile = NULL;
template->testflags = NULL; tmpl->testflags = NULL;
} }
task_template_t *task_template_compile(const char *file, const char *dir, size_t *pad) { task_template_t *task_template_compile(const char *file, const char *dir, size_t *pad) {
@ -575,14 +575,14 @@ task_template_t *task_template_compile(const char *file, const char *dir, size_t
char fullfile[4096]; char fullfile[4096];
size_t filepadd = 0; size_t filepadd = 0;
FILE *tempfile = NULL; FILE *tempfile = NULL;
task_template_t *template = NULL; task_template_t *tmpl = NULL;
memset (fullfile, 0, sizeof(fullfile)); memset (fullfile, 0, sizeof(fullfile));
snprintf(fullfile, sizeof(fullfile), "%s/%s", dir, file); snprintf(fullfile, sizeof(fullfile), "%s/%s", dir, file);
tempfile = file_open(fullfile, "r"); tempfile = file_open(fullfile, "r");
template = mem_a(sizeof(task_template_t)); tmpl = (task_template_t*)mem_a(sizeof(task_template_t));
task_template_nullify(template); task_template_nullify(tmpl);
/* /*
* Create some padding for the printing to align the * Create some padding for the printing to align the
@ -591,7 +591,7 @@ task_template_t *task_template_compile(const char *file, const char *dir, size_t
if ((filepadd = strlen(fullfile)) > pad[1]) if ((filepadd = strlen(fullfile)) > pad[1])
pad[1] = filepadd; pad[1] = filepadd;
template->rulesfile = util_strdup(fullfile); tmpl->rulesfile = util_strdup(fullfile);
/* /*
* Esnure the file even exists for the task, this is pretty useless * Esnure the file even exists for the task, this is pretty useless
@ -604,7 +604,7 @@ task_template_t *task_template_compile(const char *file, const char *dir, size_t
goto failure; goto failure;
} }
if (!task_template_parse(file, template, tempfile, pad)) { if (!task_template_parse(file, tmpl, tempfile, pad)) {
con_err("template parse error: error during parsing\n"); con_err("template parse error: error during parsing\n");
goto failure; goto failure;
} }
@ -616,19 +616,19 @@ task_template_t *task_template_compile(const char *file, const char *dir, size_t
* C * C
* I * I
*/ */
if (!template->description) { if (!tmpl->description) {
con_err("template compile error: %s missing `D:` tag\n", file); con_err("template compile error: %s missing `D:` tag\n", file);
goto failure; goto failure;
} }
if (!template->proceduretype) { if (!tmpl->proceduretype) {
con_err("template compile error: %s missing `T:` tag\n", file); con_err("template compile error: %s missing `T:` tag\n", file);
goto failure; goto failure;
} }
if (!template->compileflags) { if (!tmpl->compileflags) {
con_err("template compile error: %s missing `C:` tag\n", file); con_err("template compile error: %s missing `C:` tag\n", file);
goto failure; goto failure;
} }
if (!template->sourcefile) { if (!tmpl->sourcefile) {
con_err("template compile error: %s missing `I:` tag\n", file); con_err("template compile error: %s missing `I:` tag\n", file);
goto failure; goto failure;
} }
@ -637,35 +637,35 @@ task_template_t *task_template_compile(const char *file, const char *dir, size_t
* Now lets compile the template, compilation is really just * Now lets compile the template, compilation is really just
* the process of validating the input. * the process of validating the input.
*/ */
if (!strcmp(template->proceduretype, "-compile")) { if (!strcmp(tmpl->proceduretype, "-compile")) {
if (template->executeflags) if (tmpl->executeflags)
con_err("template compile warning: %s erroneous tag `E:` when only compiling\n", file); con_err("template compile warning: %s erroneous tag `E:` when only compiling\n", file);
if (template->comparematch) if (tmpl->comparematch)
con_err("template compile warning: %s erroneous tag `M:` when only compiling\n", file); con_err("template compile warning: %s erroneous tag `M:` when only compiling\n", file);
goto success; goto success;
} else if (!strcmp(template->proceduretype, "-execute")) { } else if (!strcmp(tmpl->proceduretype, "-execute")) {
if (!template->executeflags) { if (!tmpl->executeflags) {
/* default to $null */ /* default to $null */
template->executeflags = util_strdup("$null"); tmpl->executeflags = util_strdup("$null");
} }
if (!template->comparematch) { if (!tmpl->comparematch) {
con_err("template compile error: %s missing `M:` tag (use `$null` for exclude)\n", file); con_err("template compile error: %s missing `M:` tag (use `$null` for exclude)\n", file);
goto failure; goto failure;
} }
} else if (!strcmp(template->proceduretype, "-fail")) { } else if (!strcmp(tmpl->proceduretype, "-fail")) {
if (template->executeflags) if (tmpl->executeflags)
con_err("template compile warning: %s erroneous tag `E:` when only failing\n", file); con_err("template compile warning: %s erroneous tag `E:` when only failing\n", file);
if (template->comparematch) if (tmpl->comparematch)
con_err("template compile warning: %s erroneous tag `M:` when only failing\n", file); con_err("template compile warning: %s erroneous tag `M:` when only failing\n", file);
goto success; goto success;
} else { } else {
con_err("template compile error: %s invalid procedure type: %s\n", file, template->proceduretype); con_err("template compile error: %s invalid procedure type: %s\n", file, tmpl->proceduretype);
goto failure; goto failure;
} }
success: success:
file_close(tempfile); file_close(tempfile);
return template; return tmpl;
failure: failure:
/* /*
@ -674,40 +674,40 @@ failure:
*/ */
if (tempfile) if (tempfile)
file_close(tempfile); file_close(tempfile);
mem_d (template); mem_d (tmpl);
return NULL; return NULL;
} }
void task_template_destroy(task_template_t **template) { void task_template_destroy(task_template_t **tmpl) {
if (!template) if (!tmpl)
return; return;
if ((*template)->description) mem_d((*template)->description); if ((*tmpl)->description) mem_d((*tmpl)->description);
if ((*template)->proceduretype) mem_d((*template)->proceduretype); if ((*tmpl)->proceduretype) mem_d((*tmpl)->proceduretype);
if ((*template)->compileflags) mem_d((*template)->compileflags); if ((*tmpl)->compileflags) mem_d((*tmpl)->compileflags);
if ((*template)->executeflags) mem_d((*template)->executeflags); if ((*tmpl)->executeflags) mem_d((*tmpl)->executeflags);
if ((*template)->sourcefile) mem_d((*template)->sourcefile); if ((*tmpl)->sourcefile) mem_d((*tmpl)->sourcefile);
if ((*template)->rulesfile) mem_d((*template)->rulesfile); if ((*tmpl)->rulesfile) mem_d((*tmpl)->rulesfile);
if ((*template)->testflags) mem_d((*template)->testflags); if ((*tmpl)->testflags) mem_d((*tmpl)->testflags);
/* /*
* Delete all allocated string for task template then destroy the * Delete all allocated string for task tmpl then destroy the
* main vector. * main vector.
*/ */
{ {
size_t i = 0; size_t i = 0;
for (; i < vec_size((*template)->comparematch); i++) for (; i < vec_size((*tmpl)->comparematch); i++)
mem_d((*template)->comparematch[i]); mem_d((*tmpl)->comparematch[i]);
vec_free((*template)->comparematch); vec_free((*tmpl)->comparematch);
} }
/* /*
* Nullify all the template members otherwise NULL comparision * Nullify all the template members otherwise NULL comparision
* checks will fail if template pointer is reused. * checks will fail if tmpl pointer is reused.
*/ */
mem_d(*template); mem_d(*tmpl);
} }
/* /*
@ -715,7 +715,7 @@ void task_template_destroy(task_template_t **template) {
* of a task list. This is the executor of the tasks essentially as well. * of a task list. This is the executor of the tasks essentially as well.
*/ */
typedef struct { typedef struct {
task_template_t *template; task_template_t *tmpl;
FILE **runhandles; FILE **runhandles;
FILE *stderrlog; FILE *stderrlog;
FILE *stdoutlog; FILE *stdoutlog;
@ -758,14 +758,14 @@ bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
* actually a directory, so it must be a file :) * actually a directory, so it must be a file :)
*/ */
if (strcmp(files->d_name + strlen(files->d_name) - 5, ".tmpl") == 0) { if (strcmp(files->d_name + strlen(files->d_name) - 5, ".tmpl") == 0) {
task_template_t *template = task_template_compile(files->d_name, curdir, pad); task_template_t *tmpl = task_template_compile(files->d_name, curdir, pad);
char buf[4096]; /* one page should be enough */ char buf[4096]; /* one page should be enough */
char *qcflags = NULL; char *qcflags = NULL;
task_t task; task_t task;
util_debug("TEST", "compiling task template: %s/%s\n", curdir, files->d_name); util_debug("TEST", "compiling task template: %s/%s\n", curdir, files->d_name);
found ++; found ++;
if (!template) { if (!tmpl) {
con_err("error compiling task template: %s\n", files->d_name); con_err("error compiling task template: %s\n", files->d_name);
success = false; success = false;
continue; continue;
@ -774,7 +774,7 @@ bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
* Generate a temportary file name for the output binary * Generate a temportary file name for the output binary
* so we don't trample over an existing one. * so we don't trample over an existing one.
*/ */
template->tempfilename = tempnam(curdir, "TMPDAT"); tmpl->tempfilename = tempnam(curdir, "TMPDAT");
/* /*
* Additional QCFLAGS enviroment variable may be used * Additional QCFLAGS enviroment variable may be used
@ -790,14 +790,14 @@ bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
*/ */
memset (buf,0,sizeof(buf)); memset (buf,0,sizeof(buf));
if (qcflags) { if (qcflags) {
if (template->testflags && !strcmp(template->testflags, "-no-defs")) { if (tmpl->testflags && !strcmp(tmpl->testflags, "-no-defs")) {
snprintf(buf, sizeof(buf), "%s %s/%s %s %s -o %s", snprintf(buf, sizeof(buf), "%s %s/%s %s %s -o %s",
task_bins[TASK_COMPILE], task_bins[TASK_COMPILE],
curdir, curdir,
template->sourcefile, tmpl->sourcefile,
qcflags, qcflags,
template->compileflags, tmpl->compileflags,
template->tempfilename tmpl->tempfilename
); );
} else { } else {
snprintf(buf, sizeof(buf), "%s %s/%s %s/%s %s %s -o %s", snprintf(buf, sizeof(buf), "%s %s/%s %s/%s %s %s -o %s",
@ -805,20 +805,20 @@ bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
curdir, curdir,
defs, defs,
curdir, curdir,
template->sourcefile, tmpl->sourcefile,
qcflags, qcflags,
template->compileflags, tmpl->compileflags,
template->tempfilename tmpl->tempfilename
); );
} }
} else { } else {
if (template->testflags && !strcmp(template->testflags, "-no-defs")) { if (tmpl->testflags && !strcmp(tmpl->testflags, "-no-defs")) {
snprintf(buf, sizeof(buf), "%s %s/%s %s -o %s", snprintf(buf, sizeof(buf), "%s %s/%s %s -o %s",
task_bins[TASK_COMPILE], task_bins[TASK_COMPILE],
curdir, curdir,
template->sourcefile, tmpl->sourcefile,
template->compileflags, tmpl->compileflags,
template->tempfilename tmpl->tempfilename
); );
} else { } else {
snprintf(buf, sizeof(buf), "%s %s/%s %s/%s %s -o %s", snprintf(buf, sizeof(buf), "%s %s/%s %s/%s %s -o %s",
@ -826,9 +826,9 @@ bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
curdir, curdir,
defs, defs,
curdir, curdir,
template->sourcefile, tmpl->sourcefile,
template->compileflags, tmpl->compileflags,
template->tempfilename tmpl->tempfilename
); );
} }
} }
@ -837,21 +837,21 @@ bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
* The task template was compiled, now lets create a task from * The task template was compiled, now lets create a task from
* the template data which has now been propagated. * the template data which has now been propagated.
*/ */
task.template = template; task.tmpl = tmpl;
if (!(task.runhandles = task_popen(buf, "r"))) { if (!(task.runhandles = task_popen(buf, "r"))) {
con_err("error opening pipe to process for test: %s\n", template->description); con_err("error opening pipe to process for test: %s\n", tmpl->description);
success = false; success = false;
continue; continue;
} }
util_debug("TEST", "executing test: `%s` [%s]\n", template->description, buf); util_debug("TEST", "executing test: `%s` [%s]\n", tmpl->description, buf);
/* /*
* Open up some file desciptors for logging the stdout/stderr * Open up some file desciptors for logging the stdout/stderr
* to our own. * to our own.
*/ */
memset (buf,0,sizeof(buf)); memset (buf,0,sizeof(buf));
snprintf(buf, sizeof(buf), "%s.stdout", template->tempfilename); snprintf(buf, sizeof(buf), "%s.stdout", tmpl->tempfilename);
task.stdoutlogfile = util_strdup(buf); task.stdoutlogfile = util_strdup(buf);
if (!(task.stdoutlog = file_open(buf, "w"))) { if (!(task.stdoutlog = file_open(buf, "w"))) {
con_err("error opening %s for stdout\n", buf); con_err("error opening %s for stdout\n", buf);
@ -859,9 +859,9 @@ bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
} }
memset (buf,0,sizeof(buf)); memset (buf,0,sizeof(buf));
snprintf(buf, sizeof(buf), "%s.stderr", template->tempfilename); snprintf(buf, sizeof(buf), "%s.stderr", tmpl->tempfilename);
task.stderrlogfile = util_strdup(buf); task.stderrlogfile = util_strdup(buf);
if (!(task.stderrlog = file_open(buf, "w"))) { if (!(task.stderrlog = file_open(buf, "w"))) {
con_err("error opening %s for stderr\n", buf); con_err("error opening %s for stderr\n", buf);
continue; continue;
} }
@ -928,7 +928,7 @@ void task_destroy(void) {
* forget about it (or if it didn't compile, and the procedure type * forget about it (or if it didn't compile, and the procedure type
* was set to -fail (meaning it shouldn't compile) .. stil remove) * was set to -fail (meaning it shouldn't compile) .. stil remove)
*/ */
if (task_tasks[i].compiled || !strcmp(task_tasks[i].template->proceduretype, "-fail")) { if (task_tasks[i].compiled || !strcmp(task_tasks[i].tmpl->proceduretype, "-fail")) {
if (remove(task_tasks[i].stdoutlogfile)) if (remove(task_tasks[i].stdoutlogfile))
con_err("error removing stdout log file: %s\n", task_tasks[i].stdoutlogfile); con_err("error removing stdout log file: %s\n", task_tasks[i].stdoutlogfile);
else else
@ -938,14 +938,14 @@ void task_destroy(void) {
else else
util_debug("TEST", "removed stderr log file: %s\n", task_tasks[i].stderrlogfile); util_debug("TEST", "removed stderr log file: %s\n", task_tasks[i].stderrlogfile);
remove(task_tasks[i].template->tempfilename); remove(task_tasks[i].tmpl->tempfilename);
} }
/* free util_strdup data for log files */ /* free util_strdup data for log files */
mem_d(task_tasks[i].stdoutlogfile); mem_d(task_tasks[i].stdoutlogfile);
mem_d(task_tasks[i].stderrlogfile); mem_d(task_tasks[i].stderrlogfile);
task_template_destroy(&task_tasks[i].template); task_template_destroy(&task_tasks[i].tmpl);
} }
vec_free(task_tasks); vec_free(task_tasks);
} }
@ -955,7 +955,7 @@ void task_destroy(void) {
* using the template passed into it for call-flags and user defined * using the template passed into it for call-flags and user defined
* messages. * messages.
*/ */
bool task_execute(task_template_t *template, char ***line) { bool task_execute(task_template_t *tmpl, char ***line) {
bool success = true; bool success = true;
FILE *execute; FILE *execute;
char buffer[4096]; char buffer[4096];
@ -965,21 +965,21 @@ bool task_execute(task_template_t *template, char ***line) {
* Drop the execution flags for the QCVM if none where * Drop the execution flags for the QCVM if none where
* actually specified. * actually specified.
*/ */
if (!strcmp(template->executeflags, "$null")) { if (!strcmp(tmpl->executeflags, "$null")) {
snprintf(buffer, sizeof(buffer), "%s %s", snprintf(buffer, sizeof(buffer), "%s %s",
task_bins[TASK_EXECUTE], task_bins[TASK_EXECUTE],
template->tempfilename tmpl->tempfilename
); );
} else { } else {
snprintf(buffer, sizeof(buffer), "%s %s %s", snprintf(buffer, sizeof(buffer), "%s %s %s",
task_bins[TASK_EXECUTE], task_bins[TASK_EXECUTE],
template->executeflags, tmpl->executeflags,
template->tempfilename tmpl->tempfilename
); );
} }
util_debug("TEST", "executing qcvm: `%s` [%s]\n", util_debug("TEST", "executing qcvm: `%s` [%s]\n",
template->description, tmpl->description,
buffer buffer
); );
@ -998,8 +998,8 @@ bool task_execute(task_template_t *template, char ***line) {
while (file_getline(&data, &size, execute) != EOF) { while (file_getline(&data, &size, execute) != EOF) {
if (!strcmp(data, "No main function found\n")) { if (!strcmp(data, "No main function found\n")) {
con_err("test failure: `%s` (No main function found) [%s]\n", con_err("test failure: `%s` (No main function found) [%s]\n",
template->description, tmpl->description,
template->rulesfile tmpl->rulesfile
); );
pclose(execute); pclose(execute);
return false; return false;
@ -1012,8 +1012,8 @@ bool task_execute(task_template_t *template, char ***line) {
if (strrchr(data, '\n')) if (strrchr(data, '\n'))
*strrchr(data, '\n') = '\0'; *strrchr(data, '\n') = '\0';
if (vec_size(template->comparematch) > compare) { if (vec_size(tmpl->comparematch) > compare) {
if (strcmp(data, template->comparematch[compare++])) if (strcmp(data, tmpl->comparematch[compare++]))
success = false; success = false;
} else { } else {
success = false; success = false;
@ -1053,12 +1053,12 @@ void task_schedualize(size_t *pad) {
util_debug("TEST", "found %d tasks, preparing to execute\n", vec_size(task_tasks)); util_debug("TEST", "found %d tasks, preparing to execute\n", vec_size(task_tasks));
for (i = 0; i < vec_size(task_tasks); i++) { for (i = 0; i < vec_size(task_tasks); i++) {
util_debug("TEST", "executing task: %d: %s\n", i, task_tasks[i].template->description); util_debug("TEST", "executing task: %d: %s\n", i, task_tasks[i].tmpl->description);
/* /*
* Generate a task from thin air if it requires execution in * Generate a task from thin air if it requires execution in
* the QCVM. * the QCVM.
*/ */
execute = !!(!strcmp(task_tasks[i].template->proceduretype, "-execute")); execute = !!(!strcmp(task_tasks[i].tmpl->proceduretype, "-execute"));
/* /*
* We assume it compiled before we actually compiled :). On error * We assume it compiled before we actually compiled :). On error
@ -1098,22 +1098,22 @@ void task_schedualize(size_t *pad) {
fflush(task_tasks[i].stdoutlog); fflush(task_tasks[i].stdoutlog);
} }
if (!task_tasks[i].compiled && strcmp(task_tasks[i].template->proceduretype, "-fail")) { if (!task_tasks[i].compiled && strcmp(task_tasks[i].tmpl->proceduretype, "-fail")) {
con_err("test failure: `%s` (failed to compile) see %s.stdout and %s.stderr [%s]\n", con_err("test failure: `%s` (failed to compile) see %s.stdout and %s.stderr [%s]\n",
task_tasks[i].template->description, task_tasks[i].tmpl->description,
task_tasks[i].template->tempfilename, task_tasks[i].tmpl->tempfilename,
task_tasks[i].template->tempfilename, task_tasks[i].tmpl->tempfilename,
task_tasks[i].template->rulesfile task_tasks[i].tmpl->rulesfile
); );
continue; continue;
} }
if (!execute) { if (!execute) {
con_out("test succeeded: `%s` %*s\n", con_out("test succeeded: `%s` %*s\n",
task_tasks[i].template->description, task_tasks[i].tmpl->description,
(pad[0] + pad[1] - strlen(task_tasks[i].template->description)) + (pad[0] + pad[1] - strlen(task_tasks[i].tmpl->description)) +
(strlen(task_tasks[i].template->rulesfile) - pad[1]), (strlen(task_tasks[i].tmpl->rulesfile) - pad[1]),
task_tasks[i].template->rulesfile task_tasks[i].tmpl->rulesfile
); );
continue; continue;
@ -1123,12 +1123,12 @@ void task_schedualize(size_t *pad) {
* If we made it here that concludes the task is to be executed * If we made it here that concludes the task is to be executed
* in the virtual machine. * in the virtual machine.
*/ */
if (!task_execute(task_tasks[i].template, &match)) { if (!task_execute(task_tasks[i].tmpl, &match)) {
size_t d = 0; size_t d = 0;
con_err("test failure: `%s` (invalid results from execution) [%s]\n", con_err("test failure: `%s` (invalid results from execution) [%s]\n",
task_tasks[i].template->description, task_tasks[i].tmpl->description,
task_tasks[i].template->rulesfile task_tasks[i].tmpl->rulesfile
); );
/* /*
@ -1137,11 +1137,11 @@ void task_schedualize(size_t *pad) {
* what was actually returned from executing. * what was actually returned from executing.
*/ */
con_err(" Expected From %u Matches: (got %u Matches)\n", con_err(" Expected From %u Matches: (got %u Matches)\n",
vec_size(task_tasks[i].template->comparematch), vec_size(task_tasks[i].tmpl->comparematch),
vec_size(match) vec_size(match)
); );
for (; d < vec_size(task_tasks[i].template->comparematch); d++) { for (; d < vec_size(task_tasks[i].tmpl->comparematch); d++) {
char *select = task_tasks[i].template->comparematch[d]; char *select = task_tasks[i].tmpl->comparematch[d];
size_t length = 40 - strlen(select); size_t length = 40 - strlen(select);
con_err(" Expected: \"%s\"", select); con_err(" Expected: \"%s\"", select);
@ -1155,10 +1155,10 @@ void task_schedualize(size_t *pad) {
* This will help track down bugs in template files that fail to match * This will help track down bugs in template files that fail to match
* something. * something.
*/ */
if (vec_size(match) > vec_size(task_tasks[i].template->comparematch)) { if (vec_size(match) > vec_size(task_tasks[i].tmpl->comparematch)) {
for (d = 0; d < vec_size(match) - vec_size(task_tasks[i].template->comparematch); d++) { for (d = 0; d < vec_size(match) - vec_size(task_tasks[i].tmpl->comparematch); d++) {
con_err(" Expected: Nothing | Got: \"%s\"\n", con_err(" Expected: Nothing | Got: \"%s\"\n",
match[d + vec_size(task_tasks[i].template->comparematch)] match[d + vec_size(task_tasks[i].tmpl->comparematch)]
); );
} }
} }
@ -1174,10 +1174,10 @@ void task_schedualize(size_t *pad) {
vec_free(match); vec_free(match);
con_out("test succeeded: `%s` %*s\n", con_out("test succeeded: `%s` %*s\n",
task_tasks[i].template->description, task_tasks[i].tmpl->description,
(pad[0] + pad[1] - strlen(task_tasks[i].template->description)) + (pad[0] + pad[1] - strlen(task_tasks[i].tmpl->description)) +
(strlen(task_tasks[i].template->rulesfile) - pad[1]), (strlen(task_tasks[i].tmpl->rulesfile) - pad[1]),
task_tasks[i].template->rulesfile task_tasks[i].tmpl->rulesfile
); );
} }