0af74771cda014922689192acba012216030c2fa
[xonotic/gmqcc.git] / test.c
1 /*
2  * Copyright (C) 2012, 2013
3  *     Dale Weiler
4  *
5  * Permission is hereby granted, free of charge, to any person obtaining a copy of
6  * this software and associated documentation files (the "Software"), to deal in
7  * the Software without restriction, including without limitation the rights to
8  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
9  * of the Software, and to permit persons to whom the Software is furnished to do
10  * so, subject to the following conditions:
11  *
12  * The above copyright notice and this permission notice shall be included in all
13  * copies or substantial portions of the Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21  * SOFTWARE.
22  */
23 #include "gmqcc.h"
24 #include <sys/types.h>
25 #include <sys/stat.h>
26
27 opts_cmd_t opts;
28
29 static const char *task_bins[] = {
30     "./gmqcc",
31     "./qcvm"
32 };
33
34 /*
35  * TODO: Windows version
36  * this implements a unique bi-directional popen-like function that
37  * allows reading data from both stdout and stderr. And writing to
38  * stdin :)
39  *
40  * Example of use:
41  * FILE *handles[3] = task_popen("ls", "-l", "r");
42  * if (!handles) { perror("failed to open stdin/stdout/stderr to ls");
43  * // handles[0] = stdin
44  * // handles[1] = stdout
45  * // handles[2] = stderr
46  *
47  * task_pclose(handles); // to close
48  */
49 #ifndef _WIN32
50 #include <sys/types.h>
51 #include <sys/wait.h>
52 #include <dirent.h>
53 #include <unistd.h>
54 typedef struct {
55     FILE *handles[3];
56     int   pipes  [3];
57
58     int stderr_fd;
59     int stdout_fd;
60     int pid;
61 } popen_t;
62
63 FILE ** task_popen(const char *command, const char *mode) {
64     int     inhandle  [2];
65     int     outhandle [2];
66     int     errhandle [2];
67     int     trypipe;
68
69     popen_t *data = (popen_t*)mem_a(sizeof(popen_t));
70
71     /*
72      * Parse the command now into a list for execv, this is a pain
73      * in the ass.
74      */
75     char  *line = (char*)command;
76     char **argv = NULL;
77     {
78
79         while (*line != '\0') {
80             while (*line == ' ' || *line == '\t' || *line == '\n')
81                 *line++ = '\0';
82             vec_push(argv, line);
83
84             while (*line != '\0' && *line != ' ' &&
85                    *line != '\t' && *line != '\n') line++;
86         }
87         vec_push(argv, '\0');
88     }
89
90
91     if ((trypipe = pipe(inhandle))  < 0) goto task_popen_error_0;
92     if ((trypipe = pipe(outhandle)) < 0) goto task_popen_error_1;
93     if ((trypipe = pipe(errhandle)) < 0) goto task_popen_error_2;
94
95     if ((data->pid = fork()) > 0) {
96         /* parent */
97         close(inhandle  [0]);
98         close(outhandle [1]);
99         close(errhandle [1]);
100
101         data->pipes  [0] = inhandle [1];
102         data->pipes  [1] = outhandle[0];
103         data->pipes  [2] = errhandle[0];
104         data->handles[0] = fdopen(inhandle [1], "w");
105         data->handles[1] = fdopen(outhandle[0], mode);
106         data->handles[2] = fdopen(errhandle[0], mode);
107
108         /* sigh */
109         if (argv)
110             vec_free(argv);
111         return data->handles;
112     } else if (data->pid == 0) {
113         /* child */
114         close(inhandle [1]);
115         close(outhandle[0]);
116         close(errhandle[0]);
117
118         /* see piping documentation for this sillyness :P */
119         close(0), dup(inhandle [0]);
120         close(1), dup(outhandle[1]);
121         close(2), dup(errhandle[1]);
122
123         execvp(*argv, argv);
124         exit(EXIT_FAILURE);
125     } else {
126         /* fork failed */
127         goto task_popen_error_3;
128     }
129
130 task_popen_error_3: close(errhandle[0]), close(errhandle[1]);
131 task_popen_error_2: close(outhandle[0]), close(outhandle[1]);
132 task_popen_error_1: close(inhandle [0]), close(inhandle [1]);
133 task_popen_error_0:
134
135     if (argv)
136         vec_free(argv);
137     return NULL;
138 }
139
140 int task_pclose(FILE **handles) {
141     popen_t *data   = (popen_t*)handles;
142     int      status = 0;
143
144     close(data->pipes[0]); /* stdin  */
145     close(data->pipes[1]); /* stdout */
146     close(data->pipes[2]); /* stderr */
147
148     waitpid(data->pid, &status, 0);
149
150     mem_d(data);
151
152     return status;
153 }
154 #else
155     typedef struct {
156         FILE *handles[3];
157         char  name_err[L_tmpnam];
158         char  name_out[L_tmpnam];
159     } popen_t;
160
161     FILE **task_popen(const char *command, const char *mode) {
162         char    *cmd  = NULL;
163         popen_t *open = (popen_t*)mem_a(sizeof(popen_t));
164
165         tmpnam(open->name_err);
166         tmpnam(open->name_out);
167
168         (void)mode; /* excluded */
169
170         util_asprintf(&cmd, "%s -redirout=%s -redirerr=%s", command, open->name_out, open->name_err);
171
172         system(cmd); /* HACK */
173         open->handles[0] = NULL;
174         open->handles[1] = fs_file_open(open->name_out, "r");
175         open->handles[2] = fs_file_open(open->name_err, "r");
176
177         mem_d(cmd);
178
179         return open->handles;
180     }
181
182     void task_pclose(FILE **files) {
183         popen_t *open = ((popen_t*)files);
184         fs_file_close(files[1]);
185         fs_file_close(files[2]);
186         remove(open->name_err);
187         remove(open->name_out);
188
189         mem_d(open);
190     }
191 #endif /*! _WIN32 */
192
193 #define TASK_COMPILE    0
194 #define TASK_EXECUTE    1
195 /*
196  * Task template system:
197  *  templates are rules for a specific test, used to create a "task" that
198  *  is executed with those set of rules (arguments, and what not). Tests
199  *  that don't have a template with them cannot become tasks, since without
200  *  the information for that test there is no way to properly "test" them.
201  *  Rules for these templates are described in a template file, using a
202  *  task template language.
203  *
204  *  The language is a basic finite statemachine, top-down single-line
205  *  description language.
206  *
207  *  The languge is composed entierly of "tags" which describe a string of
208  *  text for a task.  Think of it much like a configuration file.  Except
209  *  it's been designed to allow flexibility and future support for prodecual
210  *  semantics.
211  *
212  *  The following "tags" are suported by the language
213  *
214  *      D:
215  *          Used to set a description of the current test, this must be
216  *          provided, this tag is NOT optional.
217  *
218  *      T:
219  *          Used to set the procedure for the given task, there are two
220  *          options for this:
221  *              -compile
222  *                  This simply performs compilation only
223  *              -execute
224  *                  This will perform compilation and execution
225  *              -fail
226  *                  This will perform compilation, but requires
227  *                  the compilation to fail in order to succeed.
228  *
229  *          This must be provided, this tag is NOT optional.
230  *
231  *      C:
232  *          Used to set the compilation flags for the given task, this
233  *          must be provided, this tag is NOT optional.
234  *
235  *      F:  Used to set some test suite flags, currently the only option
236  *          is -no-defs (to including of defs.qh)
237  *
238  *      E:
239  *          Used to set the execution flags for the given task. This tag
240  *          must be provided if T == -execute, otherwise it's erroneous
241  *          as compilation only takes place.
242  *
243  *      M:
244  *          Used to describe a string of text that should be matched from
245  *          the output of executing the task.  If this doesn't match the
246  *          task fails.  This tag must be provided if T == -execute, otherwise
247  *          it's erroneous as compilation only takes place.
248  *
249  *      I:
250  *          Used to specify the INPUT source file to operate on, this must be
251  *          provided, this tag is NOT optional
252  *
253  *
254  *  Notes:
255  *      These tags have one-time use, using them more than once will result
256  *      in template compilation errors.
257  *
258  *      Lines beginning with # or // in the template file are comments and
259  *      are ignored by the template parser.
260  *
261  *      Whitespace is optional, with exception to the colon ':' between the
262  *      tag and it's assignment value/
263  *
264  *      The template compiler will detect erronrous tags (optional tags
265  *      that need not be set), as well as missing tags, and error accordingly
266  *      this will result in the task failing.
267  */
268 typedef struct {
269     char  *description;
270     char  *compileflags;
271     char  *executeflags;
272     char  *proceduretype;
273     char  *sourcefile;
274     char  *tempfilename;
275     char **comparematch;
276     char  *rulesfile;
277     char  *testflags;
278 } task_template_t;
279
280 /*
281  * This is very much like a compiler code generator :-).  This generates
282  * a value from some data observed from the compiler.
283  */
284 bool task_template_generate(task_template_t *tmpl, char tag, const char *file, size_t line, char *value, size_t *pad) {
285     size_t desclen = 0;
286     size_t filelen = 0;
287     char **destval = NULL;
288
289     if (!tmpl)
290         return false;
291
292     switch(tag) {
293         case 'D': destval = &tmpl->description;    break;
294         case 'T': destval = &tmpl->proceduretype;  break;
295         case 'C': destval = &tmpl->compileflags;   break;
296         case 'E': destval = &tmpl->executeflags;   break;
297         case 'I': destval = &tmpl->sourcefile;     break;
298         case 'F': destval = &tmpl->testflags;      break;
299         default:
300             con_printmsg(LVL_ERROR, __FILE__, __LINE__, "internal error",
301                 "invalid tag `%c:` during code generation\n",
302                 tag
303             );
304             return false;
305     }
306
307     /*
308      * Ensure if for the given tag, there already exists a
309      * assigned value.
310      */
311     if (*destval) {
312         con_printmsg(LVL_ERROR, file, line, "compile error",
313             "tag `%c:` already assigned value: %s\n",
314             tag, *destval
315         );
316         return false;
317     }
318
319     /*
320      * Strip any whitespace that might exist in the value for assignments
321      * like "D:      foo"
322      */
323     if (value && *value && (*value == ' ' || *value == '\t'))
324         value++;
325
326     /*
327      * Value will contain a newline character at the end, we need to strip
328      * this otherwise kaboom, seriously, kaboom :P
329      */
330     if (strchr(value, '\n'))
331         *strrchr(value, '\n')='\0';
332     else /* cppcheck: possible nullpointer dereference */
333         exit(EXIT_FAILURE);
334
335     /*
336      * Now allocate and set the actual value for the specific tag. Which
337      * was properly selected and can be accessed with *destval.
338      */
339     *destval = util_strdup(value);
340
341
342     if (*destval == tmpl->description) {
343         /*
344          * Create some padding for the description to align the
345          * printing of the rules file.
346          */
347         if ((desclen = strlen(tmpl->description)) > pad[0])
348             pad[0] = desclen;
349     }
350
351     if ((filelen = strlen(file)) > pad[2])
352         pad[2] = filelen;
353
354     return true;
355 }
356
357 bool task_template_parse(const char *file, task_template_t *tmpl, FILE *fp, size_t *pad) {
358     char  *data = NULL;
359     char  *back = NULL;
360     size_t size = 0;
361     size_t line = 1;
362
363     if (!tmpl)
364         return false;
365
366     /* top down parsing */
367     while (fs_file_getline(&back, &size, fp) != EOF) {
368         /* skip whitespace */
369         data = back;
370         if (*data && (*data == ' ' || *data == '\t'))
371             data++;
372
373         switch (*data) {
374             /*
375              * Handle comments inside task tmpl files.  We're strict
376              * about the language for fun :-)
377              */
378             case '/':
379                 if (data[1] != '/') {
380                     con_printmsg(LVL_ERROR, file, line, "tmpl parse error",
381                         "invalid character `/`, perhaps you meant `//` ?");
382
383                     mem_d(back);
384                     return false;
385                 }
386             case '#':
387                 break;
388
389             /*
390              * Empty newlines are acceptable as well, so we handle that here
391              * despite being just odd since there should't be that many
392              * empty lines to begin with.
393              */
394             case '\r':
395             case '\n':
396                 break;
397
398
399             /*
400              * Now begin the actual "tag" stuff.  This works as you expect
401              * it to.
402              */
403             case 'D':
404             case 'T':
405             case 'C':
406             case 'E':
407             case 'I':
408             case 'F':
409                 if (data[1] != ':') {
410                     con_printmsg(LVL_ERROR, file, line, "tmpl parse error",
411                         "expected `:` after `%c`",
412                         *data
413                     );
414                     goto failure;
415                 }
416                 if (!task_template_generate(tmpl, *data, file, line, &data[3], pad)) {
417                     con_printmsg(LVL_ERROR, file, line, "tmpl compile error",
418                         "failed to generate for given task\n"
419                     );
420                     goto failure;
421                 }
422                 break;
423
424             /*
425              * Match requires it's own system since we allow multiple M's
426              * for multi-line matching.
427              */
428             case 'M':
429             {
430                 char *value = &data[3];
431                 if (data[1] != ':') {
432                     con_printmsg(LVL_ERROR, file, line, "tmpl parse error",
433                         "expected `:` after `%c`",
434                         *data
435                     );
436                     goto failure;
437                 }
438
439                 if (value && *value && (*value == ' ' || *value == '\t'))
440                     value++;
441
442                 /*
443                  * Value will contain a newline character at the end, we need to strip
444                  * this otherwise kaboom, seriously, kaboom :P
445                  */
446                 if (strrchr(value, '\n'))
447                     *strrchr(value, '\n')='\0';
448                 else /* cppcheck: possible null pointer dereference */
449                     exit(EXIT_FAILURE);
450
451                 vec_push(tmpl->comparematch, util_strdup(value));
452
453                 break;
454             }
455
456             default:
457                 con_printmsg(LVL_ERROR, file, line, "tmpl parse error",
458                     "invalid tag `%c`", *data
459                 );
460                 goto failure;
461             /* no break required */
462         }
463
464         /* update line and free old sata */
465         line++;
466         mem_d(back);
467         back = NULL;
468     }
469     if (back)
470         mem_d(back);
471     return true;
472
473 failure:
474     if (back)
475         mem_d (back);
476     return false;
477 }
478
479 /*
480  * Nullifies the template data: used during initialization of a new
481  * template and free.
482  */
483 void task_template_nullify(task_template_t *tmpl) {
484     if (!tmpl)
485         return;
486
487     tmpl->description    = NULL;
488     tmpl->proceduretype  = NULL;
489     tmpl->compileflags   = NULL;
490     tmpl->executeflags   = NULL;
491     tmpl->comparematch   = NULL;
492     tmpl->sourcefile     = NULL;
493     tmpl->tempfilename   = NULL;
494     tmpl->rulesfile      = NULL;
495     tmpl->testflags      = NULL;
496 }
497
498 task_template_t *task_template_compile(const char *file, const char *dir, size_t *pad) {
499     /* a page should be enough */
500     char             fullfile[4096];
501     size_t           filepadd = 0;
502     FILE            *tempfile = NULL;
503     task_template_t *tmpl     = NULL;
504
505     util_snprintf(fullfile,    sizeof(fullfile), "%s/%s", dir, file);
506
507     tempfile = fs_file_open(fullfile, "r");
508     tmpl     = (task_template_t*)mem_a(sizeof(task_template_t));
509     task_template_nullify(tmpl);
510
511     /*
512      * Create some padding for the printing to align the
513      * printing of the rules file to the console.
514      */
515     if ((filepadd = strlen(fullfile)) > pad[1])
516         pad[1] = filepadd;
517
518     tmpl->rulesfile = util_strdup(fullfile);
519
520     /*
521      * Esnure the file even exists for the task, this is pretty useless
522      * to even do.
523      */
524     if (!tempfile) {
525         con_err("template file: %s does not exist or invalid permissions\n",
526             file
527         );
528         goto failure;
529     }
530
531     if (!task_template_parse(file, tmpl, tempfile, pad)) {
532         con_err("template parse error: error during parsing\n");
533         goto failure;
534     }
535
536     /*
537      * Regardless procedure type, the following tags must exist:
538      *  D
539      *  T
540      *  C
541      *  I
542      */
543     if (!tmpl->description) {
544         con_err("template compile error: %s missing `D:` tag\n", file);
545         goto failure;
546     }
547     if (!tmpl->proceduretype) {
548         con_err("template compile error: %s missing `T:` tag\n", file);
549         goto failure;
550     }
551     if (!tmpl->compileflags) {
552         con_err("template compile error: %s missing `C:` tag\n", file);
553         goto failure;
554     }
555     if (!tmpl->sourcefile) {
556         con_err("template compile error: %s missing `I:` tag\n", file);
557         goto failure;
558     }
559
560     /*
561      * Now lets compile the template, compilation is really just
562      * the process of validating the input.
563      */
564     if (!strcmp(tmpl->proceduretype, "-compile")) {
565         if (tmpl->executeflags)
566             con_err("template compile warning: %s erroneous tag `E:` when only compiling\n", file);
567         if (tmpl->comparematch)
568             con_err("template compile warning: %s erroneous tag `M:` when only compiling\n", file);
569         goto success;
570     } else if (!strcmp(tmpl->proceduretype, "-execute")) {
571         if (!tmpl->executeflags) {
572             /* default to $null */
573             tmpl->executeflags = util_strdup("$null");
574         }
575         if (!tmpl->comparematch) {
576             con_err("template compile error: %s missing `M:` tag (use `$null` for exclude)\n", file);
577             goto failure;
578         }
579     } else if (!strcmp(tmpl->proceduretype, "-fail")) {
580         if (tmpl->executeflags)
581             con_err("template compile warning: %s erroneous tag `E:` when only failing\n", file);
582         if (tmpl->comparematch)
583             con_err("template compile warning: %s erroneous tag `M:` when only failing\n", file);
584     } else if (!strcmp(tmpl->proceduretype, "-pp")) {
585         if (tmpl->executeflags)
586             con_err("template compile warning: %s erroneous tag `E:` when only preprocessing\n", file);
587         if (!tmpl->comparematch) {
588             con_err("template compile error: %s missing `M:` tag (use `$null` for exclude)\n", file);
589             goto failure;
590         }
591     } else {
592         con_err("template compile error: %s invalid procedure type: %s\n", file, tmpl->proceduretype);
593         goto failure;
594     }
595
596 success:
597     fs_file_close(tempfile);
598     return tmpl;
599
600 failure:
601     /*
602      * The file might not exist and we jump here when that doesn't happen
603      * so the check to see if it's not null here is required.
604      */
605     if (tempfile)
606         fs_file_close(tempfile);
607     mem_d (tmpl);
608
609     return NULL;
610 }
611
612 void task_template_destroy(task_template_t **tmpl) {
613     if (!tmpl)
614         return;
615
616     if ((*tmpl)->description)    mem_d((*tmpl)->description);
617     if ((*tmpl)->proceduretype)  mem_d((*tmpl)->proceduretype);
618     if ((*tmpl)->compileflags)   mem_d((*tmpl)->compileflags);
619     if ((*tmpl)->executeflags)   mem_d((*tmpl)->executeflags);
620     if ((*tmpl)->sourcefile)     mem_d((*tmpl)->sourcefile);
621     if ((*tmpl)->rulesfile)      mem_d((*tmpl)->rulesfile);
622     if ((*tmpl)->testflags)      mem_d((*tmpl)->testflags);
623
624     /*
625      * Delete all allocated string for task tmpl then destroy the
626      * main vector.
627      */
628     {
629         size_t i = 0;
630         for (; i < vec_size((*tmpl)->comparematch); i++)
631             mem_d((*tmpl)->comparematch[i]);
632
633         vec_free((*tmpl)->comparematch);
634     }
635
636     /*
637      * Nullify all the template members otherwise NULL comparision
638      * checks will fail if tmpl pointer is reused.
639      */
640     mem_d(*tmpl);
641 }
642
643 /*
644  * Now comes the task manager, this system allows adding tasks in and out
645  * of a task list.  This is the executor of the tasks essentially as well.
646  */
647 typedef struct {
648     task_template_t *tmpl;
649     FILE           **runhandles;
650     FILE            *stderrlog;
651     FILE            *stdoutlog;
652     char            *stdoutlogfile;
653     char            *stderrlogfile;
654     bool             compiled;
655 } task_t;
656
657 static task_t *task_tasks = NULL;
658
659 /*
660  * Read a directory and searches for all template files in it
661  * which is later used to run all tests.
662  */
663 bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
664     bool             success = true;
665     DIR             *dir;
666     struct dirent   *files;
667     struct stat      directory;
668     char             buffer[4096];
669     size_t           found = 0;
670
671     dir = fs_dir_open(curdir);
672
673     while ((files = fs_dir_read(dir))) {
674         util_snprintf(buffer, sizeof(buffer), "%s/%s", curdir, files->d_name);
675
676         if (stat(buffer, &directory) == -1) {
677             con_err("internal error: stat failed, aborting\n");
678             abort();
679         }
680
681         /* skip directories */
682         if (S_ISDIR(directory.st_mode))
683             continue;
684
685         /*
686          * We made it here, which concludes the file/directory is not
687          * actually a directory, so it must be a file :)
688          */
689         if (strcmp(files->d_name + strlen(files->d_name) - 5, ".tmpl") == 0) {
690             task_template_t *tmpl = task_template_compile(files->d_name, curdir, pad);
691             char             buf[4096]; /* one page should be enough */
692             char            *qcflags = NULL;
693             task_t           task;
694
695             util_debug("TEST", "compiling task template: %s/%s\n", curdir, files->d_name);
696             found ++;
697             if (!tmpl) {
698                 con_err("error compiling task template: %s\n", files->d_name);
699                 success = false;
700                 continue;
701             }
702             /*
703              * Generate a temportary file name for the output binary
704              * so we don't trample over an existing one.
705              */
706             tmpl->tempfilename = NULL;
707             util_asprintf(&tmpl->tempfilename, "%s/TMPDAT.%s", curdir, files->d_name);
708
709             /*
710              * Additional QCFLAGS enviroment variable may be used
711              * to test compile flags for all tests.  This needs to be
712              * BEFORE other flags (so that the .tmpl can override them)
713              */
714             #ifdef _MSC_VER
715             {
716                 char   buffer[4096];
717                 size_t size;
718                 getenv_s(&size, buffer, sizeof(buffer), "QCFLAGS");
719                 qcflags = buffer;
720             }
721             #else
722             qcflags = getenv("QCFLAGS");
723             #endif
724
725             /*
726              * Generate the command required to open a pipe to a process
727              * which will be refered to with a handle in the task for
728              * reading the data from the pipe.
729              */
730             if (strcmp(tmpl->proceduretype, "-pp")) {
731                 if (qcflags) {
732                     if (tmpl->testflags && !strcmp(tmpl->testflags, "-no-defs")) {
733                         util_snprintf(buf, sizeof(buf), "%s %s/%s %s %s -o %s",
734                             task_bins[TASK_COMPILE],
735                             curdir,
736                             tmpl->sourcefile,
737                             qcflags,
738                             tmpl->compileflags,
739                             tmpl->tempfilename
740                         );
741                     } else {
742                         util_snprintf(buf, sizeof(buf), "%s %s/%s %s/%s %s %s -o %s",
743                             task_bins[TASK_COMPILE],
744                             curdir,
745                             defs,
746                             curdir,
747                             tmpl->sourcefile,
748                             qcflags,
749                             tmpl->compileflags,
750                             tmpl->tempfilename
751                         );
752                     }
753                 } else {
754                     if (tmpl->testflags && !strcmp(tmpl->testflags, "-no-defs")) {
755                         util_snprintf(buf, sizeof(buf), "%s %s/%s %s -o %s",
756                             task_bins[TASK_COMPILE],
757                             curdir,
758                             tmpl->sourcefile,
759                             tmpl->compileflags,
760                             tmpl->tempfilename
761                         );
762                     } else {
763                         util_snprintf(buf, sizeof(buf), "%s %s/%s %s/%s %s -o %s",
764                             task_bins[TASK_COMPILE],
765                             curdir,
766                             defs,
767                             curdir,
768                             tmpl->sourcefile,
769                             tmpl->compileflags,
770                             tmpl->tempfilename
771                         );
772                     }
773                 }
774             } else {
775                 /* Preprocessing (qcflags mean shit all here we don't allow them) */
776                 if (tmpl->testflags && !strcmp(tmpl->testflags, "-no-defs")) {
777                     util_snprintf(buf, sizeof(buf), "%s -E %s/%s -o %s",
778                         task_bins[TASK_COMPILE],
779                         curdir,
780                         tmpl->sourcefile,
781                         tmpl->tempfilename
782                     );
783                 } else {
784                     util_snprintf(buf, sizeof(buf), "%s -E %s/%s %s/%s -o %s",
785                         task_bins[TASK_COMPILE],
786                         curdir,
787                         defs,
788                         curdir,
789                         tmpl->sourcefile,
790                         tmpl->tempfilename
791                     );
792                 }
793             }
794
795             /*
796              * The task template was compiled, now lets create a task from
797              * the template data which has now been propagated.
798              */
799             task.tmpl = tmpl;
800             if (!(task.runhandles = task_popen(buf, "r"))) {
801                 con_err("error opening pipe to process for test: %s\n", tmpl->description);
802                 success = false;
803                 continue;
804             }
805
806             util_debug("TEST", "executing test: `%s` [%s]\n", tmpl->description, buf);
807
808             /*
809              * Open up some file desciptors for logging the stdout/stderr
810              * to our own.
811              */
812             util_snprintf(buf,  sizeof(buf), "%s.stdout", tmpl->tempfilename);
813             task.stdoutlogfile = util_strdup(buf);
814             if (!(task.stdoutlog     = fs_file_open(buf, "w"))) {
815                 con_err("error opening %s for stdout\n", buf);
816                 continue;
817             }
818
819             util_snprintf(buf,  sizeof(buf), "%s.stderr", tmpl->tempfilename);
820             task.stderrlogfile = util_strdup(buf);
821             if (!(task.stderrlog = fs_file_open(buf, "w"))) {
822                 con_err("error opening %s for stderr\n", buf);
823                 continue;
824             }
825
826             vec_push(task_tasks, task);
827         }
828     }
829
830     util_debug("TEST", "compiled %d task template files out of %d\n",
831         vec_size(task_tasks),
832         found
833     );
834
835     fs_dir_close(dir);
836     return success;
837 }
838
839 /*
840  * Task precleanup removes any existing temporary files or log files
841  * left behind from a previous invoke of the test-suite.
842  */
843 void task_precleanup(const char *curdir) {
844     DIR             *dir;
845     struct dirent   *files;
846     char             buffer[4096];
847
848     dir = fs_dir_open(curdir);
849
850     while ((files = fs_dir_read(dir))) {
851         if (strstr(files->d_name, "TMP")     ||
852             strstr(files->d_name, ".stdout") ||
853             strstr(files->d_name, ".stderr"))
854         {
855             util_snprintf(buffer, sizeof(buffer), "%s/%s", curdir, files->d_name);
856             if (remove(buffer))
857                 con_err("error removing temporary file: %s\n", buffer);
858             else
859                 util_debug("TEST", "removed temporary file: %s\n", buffer);
860         }
861     }
862
863     fs_dir_close(dir);
864 }
865
866 void task_destroy(void) {
867     /*
868      * Free all the data in the task list and finally the list itself
869      * then proceed to cleanup anything else outside the program like
870      * temporary files.
871      */
872     size_t i;
873     for (i = 0; i < vec_size(task_tasks); i++) {
874         /*
875          * Close any open handles to files or processes here.  It's mighty
876          * annoying to have to do all this cleanup work.
877          */
878         if (task_tasks[i].runhandles) task_pclose(task_tasks[i].runhandles);
879         if (task_tasks[i].stdoutlog)  fs_file_close (task_tasks[i].stdoutlog);
880         if (task_tasks[i].stderrlog)  fs_file_close (task_tasks[i].stderrlog);
881
882         /*
883          * Only remove the log files if the test actually compiled otherwise
884          * forget about it (or if it didn't compile, and the procedure type
885          * was set to -fail (meaning it shouldn't compile) .. stil remove)
886          */
887         if (task_tasks[i].compiled || !strcmp(task_tasks[i].tmpl->proceduretype, "-fail")) {
888             if (remove(task_tasks[i].stdoutlogfile))
889                 con_err("error removing stdout log file: %s\n", task_tasks[i].stdoutlogfile);
890             else
891                 util_debug("TEST", "removed stdout log file: %s\n", task_tasks[i].stdoutlogfile);
892             if (remove(task_tasks[i].stderrlogfile))
893                 con_err("error removing stderr log file: %s\n", task_tasks[i].stderrlogfile);
894             else
895                 util_debug("TEST", "removed stderr log file: %s\n", task_tasks[i].stderrlogfile);
896
897             remove(task_tasks[i].tmpl->tempfilename);
898         }
899
900         /* free util_strdup data for log files */
901         mem_d(task_tasks[i].stdoutlogfile);
902         mem_d(task_tasks[i].stderrlogfile);
903
904         task_template_destroy(&task_tasks[i].tmpl);
905     }
906     vec_free(task_tasks);
907 }
908
909 /*
910  * This executes the QCVM task for a specificly compiled progs.dat
911  * using the template passed into it for call-flags and user defined
912  * messages IF the procedure type is -execute, otherwise it matches
913  * the preprocessor output.
914  */
915 bool task_trymatch(task_template_t *tmpl, char ***line) {
916     bool     success = true;
917     bool     preprocessing = false;
918     FILE    *execute;
919     char     buffer[4096];
920     memset  (buffer,0,sizeof(buffer));
921
922     if (strcmp(tmpl->proceduretype, "-pp")) {
923         /*
924          * Drop the execution flags for the QCVM if none where
925          * actually specified.
926          */
927         if (!strcmp(tmpl->executeflags, "$null")) {
928             util_snprintf(buffer,  sizeof(buffer), "%s %s",
929                 task_bins[TASK_EXECUTE],
930                 tmpl->tempfilename
931             );
932         } else {
933             util_snprintf(buffer,  sizeof(buffer), "%s %s %s",
934                 task_bins[TASK_EXECUTE],
935                 tmpl->executeflags,
936                 tmpl->tempfilename
937             );
938         }
939
940         util_debug("TEST", "executing qcvm: `%s` [%s]\n",
941             tmpl->description,
942             buffer
943         );
944
945         execute = popen(buffer, "r");
946         if (!execute)
947             return false;
948     } else {
949         /*
950          * we're preprocessing, which means we need to read int
951          * the produced file and do some really weird shit.
952          */
953         if (!(execute = fs_file_open(tmpl->tempfilename, "r")))
954             return false;
955
956         preprocessing = true;
957     }
958
959     /*
960      * Now lets read the lines and compare them to the matches we expect
961      * and handle accordingly.
962      */
963     {
964         char  *data    = NULL;
965         size_t size    = 0;
966         size_t compare = 0;
967         while (fs_file_getline(&data, &size, execute) != EOF) {
968             if (!strcmp(data, "No main function found\n")) {
969                 con_err("test failure: `%s` (No main function found) [%s]\n",
970                     tmpl->description,
971                     tmpl->rulesfile
972                 );
973                 if (preprocessing)
974                     fs_file_close(execute);
975                 else
976                     pclose(execute);
977                 return false;
978             }
979
980             /*
981              * Trim newlines from data since they will just break our
982              * ability to properly validate matches.
983              */
984             if  (strrchr(data, '\n'))
985                 *strrchr(data, '\n') = '\0';
986
987             /*
988              * If data is just null now, that means the line was an empty
989              * one and for that, we just ignore it.
990              */
991             if (!*data)
992                 continue;
993
994             if (vec_size(tmpl->comparematch) > compare) {
995                 if (strcmp(data, tmpl->comparematch[compare++]))
996                     success = false;
997             } else {
998                     success = false;
999             }
1000
1001             /*
1002              * Copy to output vector for diagnostics if execution match
1003              * fails.
1004              */
1005             vec_push(*line, data);
1006
1007             /* reset */
1008             data = NULL;
1009             size = 0;
1010         }
1011         mem_d(data);
1012         data = NULL;
1013     }
1014
1015     if (!preprocessing)
1016         pclose(execute);
1017     else
1018         fs_file_close(execute);
1019
1020     return success;
1021 }
1022
1023 const char *task_type(task_template_t *tmpl) {
1024     if (!strcmp(tmpl->proceduretype, "-pp"))
1025         return "type: preprocessor";
1026     if (!strcmp(tmpl->proceduretype, "-execute"))
1027         return "type: execution";
1028     if (!strcmp(tmpl->proceduretype, "-compile"))
1029         return "type: compile";
1030     return "type: fail";
1031 }
1032
1033 /*
1034  * This schedualizes all tasks and actually runs them individually
1035  * this is generally easy for just -compile variants.  For compile and
1036  * execution this takes more work since a task needs to be generated
1037  * from thin air and executed INLINE.
1038  */
1039 #include <math.h>
1040 void task_schedualize(size_t *pad) {
1041     char   space[2][64];
1042     bool   execute  = false;
1043     char  *data     = NULL;
1044     char **match    = NULL;
1045     size_t size     = 0;
1046     size_t i        = 0;
1047     size_t j        = 0;
1048
1049     util_snprintf(space[0], sizeof(space[0]), "%d", (int)vec_size(task_tasks));
1050
1051     for (; i < vec_size(task_tasks); i++) {
1052         memset(space[1], 0, sizeof(space[1]));
1053         util_snprintf(space[1], sizeof(space[1]), "%d", (int)(i + 1));
1054
1055         con_out("test #%u %*s", i + 1, strlen(space[0]) - strlen(space[1]), "");
1056
1057         util_debug("TEST", "executing task: %d: %s\n", i, task_tasks[i].tmpl->description);
1058         /*
1059          * Generate a task from thin air if it requires execution in
1060          * the QCVM.
1061          */
1062         execute = !! (!strcmp(task_tasks[i].tmpl->proceduretype, "-execute")) ||
1063                      (!strcmp(task_tasks[i].tmpl->proceduretype, "-pp"));
1064
1065         /*
1066          * We assume it compiled before we actually compiled :).  On error
1067          * we change the value
1068          */
1069         task_tasks[i].compiled = true;
1070
1071         /*
1072          * Read data from stdout first and pipe that stuff into a log file
1073          * then we do the same for stderr.
1074          */
1075         while (fs_file_getline(&data, &size, task_tasks[i].runhandles[1]) != EOF) {
1076             fs_file_puts(task_tasks[i].stdoutlog, data);
1077
1078             if (strstr(data, "failed to open file")) {
1079                 task_tasks[i].compiled = false;
1080                 execute                = false;
1081             }
1082         }
1083         while (fs_file_getline(&data, &size, task_tasks[i].runhandles[2]) != EOF) {
1084             /*
1085              * If a string contains an error we just dissalow execution
1086              * of it in the vm.
1087              *
1088              * TODO: make this more percise, e.g if we print a warning
1089              * that refers to a variable named error, or something like
1090              * that .. then this will blowup :P
1091              */
1092             if (strstr(data, "error")) {
1093                 execute                = false;
1094                 task_tasks[i].compiled = false;
1095             }
1096
1097             fs_file_puts (task_tasks[i].stderrlog, data);
1098         }
1099
1100         if (!task_tasks[i].compiled && strcmp(task_tasks[i].tmpl->proceduretype, "-fail")) {
1101             con_out("failure:   `%s` %*s %*s\n",
1102                 task_tasks[i].tmpl->description,
1103                 (pad[0] + pad[1] - strlen(task_tasks[i].tmpl->description)) + (strlen(task_tasks[i].tmpl->rulesfile) - pad[1]),
1104                 task_tasks[i].tmpl->rulesfile,
1105                 (pad[1] + pad[2] - strlen(task_tasks[i].tmpl->rulesfile)) + (strlen("(failed to compile)") - pad[2]),
1106                 "(failed to compile)"
1107             );
1108             continue;
1109         }
1110
1111         if (!execute) {
1112             con_out("succeeded: `%s` %*s %*s\n",
1113                 task_tasks[i].tmpl->description,
1114                 (pad[0] + pad[1] - strlen(task_tasks[i].tmpl->description)) + (strlen(task_tasks[i].tmpl->rulesfile) - pad[1]),
1115                 task_tasks[i].tmpl->rulesfile,
1116                 (pad[1] + pad[2] - strlen(task_tasks[i].tmpl->rulesfile)) + (strlen(task_type(task_tasks[i].tmpl)) - pad[2]),
1117                 task_type(task_tasks[i].tmpl)
1118
1119             );
1120             continue;
1121         }
1122
1123         /*
1124          * If we made it here that concludes the task is to be executed
1125          * in the virtual machine (or the preprocessor output needs to
1126          * be matched).
1127          */
1128         if (!task_trymatch(task_tasks[i].tmpl, &match)) {
1129             size_t d = 0;
1130
1131             con_out("failure:   `%s` %*s %*s\n",
1132                 task_tasks[i].tmpl->description,
1133                 (pad[0] + pad[1] - strlen(task_tasks[i].tmpl->description)) + (strlen(task_tasks[i].tmpl->rulesfile) - pad[1]),
1134                 task_tasks[i].tmpl->rulesfile,
1135                 (pad[1] + pad[2] - strlen(task_tasks[i].tmpl->rulesfile)) + (strlen(
1136                     (strcmp(task_tasks[i].tmpl->proceduretype, "-pp"))
1137                         ? "(invalid results from execution)"
1138                         : "(invalid results from preprocessing)"
1139                 ) - pad[2]),
1140                 (strcmp(task_tasks[i].tmpl->proceduretype, "-pp"))
1141                     ? "(invalid results from execution)"
1142                     : "(invalid results from preprocessing)"
1143             );
1144
1145             /*
1146              * Print nicely formatted expected match lists to console error
1147              * handler for the all the given matches in the template file and
1148              * what was actually returned from executing.
1149              */
1150             con_out("    Expected From %u Matches: (got %u Matches)\n",
1151                 vec_size(task_tasks[i].tmpl->comparematch),
1152                 vec_size(match)
1153             );
1154             for (; d < vec_size(task_tasks[i].tmpl->comparematch); d++) {
1155                 char  *select = task_tasks[i].tmpl->comparematch[d];
1156                 size_t length = 40 - strlen(select);
1157
1158                 con_out("        Expected: \"%s\"", select);
1159                 while (length --)
1160                     con_out(" ");
1161                 con_out("| Got: \"%s\"\n", (d >= vec_size(match)) ? "<<nothing else to compare>>" : match[d]);
1162             }
1163
1164             /*
1165              * Print the non-expected out (since we are simply not expecting it)
1166              * This will help track down bugs in template files that fail to match
1167              * something.
1168              */
1169             if (vec_size(match) > vec_size(task_tasks[i].tmpl->comparematch)) {
1170                 for (d = 0; d < vec_size(match) - vec_size(task_tasks[i].tmpl->comparematch); d++) {
1171                     con_out("        Expected: Nothing                                   | Got: \"%s\"\n",
1172                         match[d + vec_size(task_tasks[i].tmpl->comparematch)]
1173                     );
1174                 }
1175             }
1176
1177
1178             for (j = 0; j < vec_size(match); j++)
1179                 mem_d(match[j]);
1180             vec_free(match);
1181             continue;
1182         }
1183         for (j = 0; j < vec_size(match); j++)
1184             mem_d(match[j]);
1185         vec_free(match);
1186
1187         con_out("succeeded: `%s` %*s %*s\n",
1188             task_tasks[i].tmpl->description,
1189             (pad[0] + pad[1] - strlen(task_tasks[i].tmpl->description)) + (strlen(task_tasks[i].tmpl->rulesfile) - pad[1]),
1190             task_tasks[i].tmpl->rulesfile,
1191             (pad[1] + pad[2] - strlen(task_tasks[i].tmpl->rulesfile)) + (strlen(task_type(task_tasks[i].tmpl))- pad[2]),
1192             task_type(task_tasks[i].tmpl)
1193
1194         );
1195     }
1196     mem_d(data);
1197 }
1198
1199 /*
1200  * This is the heart of the whole test-suite process.  This cleans up
1201  * any existing temporary files left behind as well as log files left
1202  * behind.  Then it propagates a list of tests from `curdir` by scaning
1203  * it for template files and compiling them into tasks, in which it
1204  * schedualizes them (executes them) and actually reports errors and
1205  * what not.  It then proceeds to destroy the tasks and return memory
1206  * it's the engine :)
1207  *
1208  * It returns true of tests could be propagated, otherwise it returns
1209  * false.
1210  *
1211  * It expects con_init() was called before hand.
1212  */
1213 GMQCC_WARN bool test_perform(const char *curdir, const char *defs) {
1214     static const char *default_defs = "defs.qh";
1215
1216     size_t pad[] = {
1217         /* test ### [succeed/fail]: `description`      [tests/template.tmpl]     [type] */
1218                     0,                                 0,                        0
1219     };
1220
1221     /*
1222      * If the default definition file isn't set to anything.  We will
1223      * use the default_defs here, which is "defs.qc"
1224      */
1225     if (!defs) {
1226         defs = default_defs;
1227     }
1228
1229
1230     task_precleanup(curdir);
1231     if (!task_propagate(curdir, pad, defs)) {
1232         con_err("error: failed to propagate tasks\n");
1233         task_destroy();
1234         return false;
1235     }
1236     /*
1237      * If we made it here all tasks where propagated from their resultant
1238      * template file.  So we can start the FILO scheduler, this has been
1239      * designed in the most thread-safe way possible for future threading
1240      * it's designed to prevent lock contention, and possible syncronization
1241      * issues.
1242      */
1243     task_schedualize(pad);
1244     task_destroy();
1245
1246     return true;
1247 }
1248
1249 /*
1250  * Fancy GCC-like LONG parsing allows things like --opt=param with
1251  * assignment operator.  This is used for redirecting stdout/stderr
1252  * console to specific files of your choice.
1253  */
1254 static bool parsecmd(const char *optname, int *argc_, char ***argv_, char **out, int ds, bool split) {
1255     int  argc   = *argc_;
1256     char **argv = *argv_;
1257
1258     size_t len = strlen(optname);
1259
1260     if (strncmp(argv[0]+ds, optname, len))
1261         return false;
1262
1263     /* it's --optname, check how the parameter is supplied */
1264     if (argv[0][ds+len] == '=') {
1265         *out = argv[0]+ds+len+1;
1266         return true;
1267     }
1268
1269     if (!split || argc < ds) /* no parameter was provided, or only single-arg form accepted */
1270         return false;
1271
1272     /* using --opt param */
1273     *out = argv[1];
1274     --*argc_;
1275     ++*argv_;
1276     return true;
1277 }
1278
1279 int main(int argc, char **argv) {
1280     bool          succeed  = false;
1281     char         *redirout = (char*)stdout;
1282     char         *redirerr = (char*)stderr;
1283     char         *defs     = NULL;
1284
1285     con_init();
1286
1287     /*
1288      * Command line option parsing commences now We only need to support
1289      * a few things in the test suite.
1290      */
1291     while (argc > 1) {
1292         ++argv;
1293         --argc;
1294
1295         if (argv[0][0] == '-') {
1296             if (parsecmd("redirout", &argc, &argv, &redirout, 1, false))
1297                 continue;
1298             if (parsecmd("redirerr", &argc, &argv, &redirerr, 1, false))
1299                 continue;
1300             if (parsecmd("defs",     &argc, &argv, &defs,     1, false))
1301                 continue;
1302
1303             con_change(redirout, redirerr);
1304
1305             if (!strcmp(argv[0]+1, "debug")) {
1306                 OPTS_OPTION_BOOL(OPTION_DEBUG) = true;
1307                 continue;
1308             }
1309             if (!strcmp(argv[0]+1, "memchk")) {
1310                 OPTS_OPTION_BOOL(OPTION_MEMCHK) = true;
1311                 continue;
1312             }
1313             if (!strcmp(argv[0]+1, "nocolor")) {
1314                 con_color(0);
1315                 continue;
1316             }
1317
1318             con_err("invalid argument %s\n", argv[0]+1);
1319             return -1;
1320         }
1321     }
1322     con_change(redirout, redirerr);
1323     succeed = test_perform("tests", defs);
1324     util_meminfo();
1325
1326
1327     return (succeed) ? EXIT_SUCCESS : EXIT_FAILURE;
1328 }