test.c

   1 /*
   2  * Copyright (C) 2012
   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 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 = 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(1);
 125     } else {
 126         /* fork failed */
 127         goto task_popen_error_3;
 128     }
 129
 130     if (argv)
 131         vec_free(argv);
 132     return data->handles;
 133
 134 task_popen_error_3: close(errhandle[0]), close(errhandle[1]);
 135 task_popen_error_2: close(outhandle[0]), close(outhandle[1]);
 136 task_popen_error_1: close(inhandle [0]), close(inhandle [1]);
 137 task_popen_error_0:
 138
 139     if (argv)
 140         vec_free(argv);
 141     return NULL;
 142 }
 143
 144 int task_pclose(FILE **handles) {
 145     popen_t *data   = (popen_t*)handles;
 146     int      status = 0;
 147
 148     close(data->pipes[0]); /* stdin  */
 149     close(data->pipes[1]); /* stdout */
 150     close(data->pipes[2]); /* stderr */
 151
 152     waitpid(data->pid, &status, 0);
 153
 154     mem_d(data);
 155
 156     return status;
 157 }
 158 #else
 159 #       ifdef __MINGW32__
 160         /* mingw32 has dirent.h */
 161 #               include <dirent.h>
 162 #       elif defined (_MSC_VER)
 163 #               define _WIN32_LEAN_AND_MEAN
 164 #               include <Windows.h>
 165 #               include <io.h>
 166         /*
 167          * visual studio lacks dirent.h it's a posix thing
 168          * so we emulate it with the WinAPI.
 169          */
 170
 171         struct dirent {
 172             long           d_ino;
 173             unsigned short d_reclen;
 174             unsigned short d_namlen;
 175             char           d_name[FILENAME_MAX];
 176         };
 177
 178         typedef struct {
 179             struct _finddata_t dd_dta;
 180             struct dirent      dd_dir;
 181             long               dd_handle;
 182             int                dd_stat;
 183             char               dd_name[1];
 184         } DIR;
 185
 186         DIR *opendir(const char *name) {
 187             DIR *dir = (DIR*)mem_a(sizeof(DIR) + strlen(name));
 188             if (!dir)
 189                 return NULL;
 190
 191             strcpy(dir->dd_name, name);
 192             return dir;
 193         }
 194
 195         int closedir(DIR *dir) {
 196             FindClose((HANDLE)dir->dd_handle);
 197             mem_d ((void*)dir);
 198             return 0;
 199         }
 200
 201         struct dirent *readdir(DIR *dir) {
 202             WIN32_FIND_DATA info;
 203             struct dirent  *data;
 204             int             rets;
 205
 206             if (!dir->dd_handle) {
 207                 char *dirname;
 208                 if (*dir->dd_name) {
 209                     size_t n = strlen(dir->dd_name);
 210                     if ((dirname  = (char*)mem_a(n + 5) /* 4 + 1 */)) {
 211                         strcpy(dirname,     dir->dd_name);
 212                         strcpy(dirname + n, "\\*.*");   /* 4 + 1 */
 213                     }
 214                 } else {
 215                     if (!(dirname = util_strdup("\\*.*")))
 216                         return NULL;
 217                 }
 218
 219                 dir->dd_handle = (long)FindFirstFile(dirname, &info);
 220                 mem_d(dirname);
 221                 rets = !(!dir->dd_handle);
 222             } else if (dir->dd_handle != -11) {
 223                 rets = FindNextFile ((HANDLE)dir->dd_handle, &info);
 224             } else {
 225                 rets = 0;
 226             }
 227
 228             if (!rets)
 229                 return NULL;
 230
 231             if ((data = (struct dirent*)mem_a(sizeof(struct dirent)))) {
 232                 strncpy(data->d_name, info.cFileName, FILENAME_MAX - 1);
 233                 data->d_name[FILENAME_MAX - 1] = '\0'; /* terminate */
 234                 data->d_namlen                 = strlen(data->d_name);
 235             }
 236             return data;
 237         }
 238 #       endif
 239 #endif
 240
 241 #define TASK_COMPILE 0
 242 #define TASK_EXECUTE 1
 243
 244 /*
 245  * Task template system:
 246  *  templates are rules for a specific test, used to create a "task" that
 247  *  is executed with those set of rules (arguments, and what not). Tests
 248  *  that don't have a template with them cannot become tasks, since without
 249  *  the information for that test there is no way to properly "test" them.
 250  *  Rules for these templates are described in a template file, using a
 251  *  task template language.
 252  *
 253  *  The language is a basic finite statemachine, top-down single-line
 254  *  description language.
 255  *
 256  *  The languge is composed entierly of "tags" which describe a string of
 257  *  text for a task.  Think of it much like a configuration file.  Except
 258  *  it's been designed to allow flexibility and future support for prodecual
 259  *  semantics.
 260  *
 261  *  The following "tags" are suported by the language
 262  *
 263  *      D:
 264  *          Used to set a description of the current test, this must be
 265  *          provided, this tag is NOT optional.
 266  *
 267  *      F:
 268  *          Used to set a failure message, this message will be displayed
 269  *          if the test fails, this tag is optional
 270  *
 271  *      S:
 272  *          Used to set a success message, this message will be displayed
 273  *          if the test succeeds, this tag is optional.
 274  *
 275  *      T:
 276  *          Used to set the procedure for the given task, there are two
 277  *          options for this:
 278  *              -compile
 279  *                  This simply performs compilation only
 280  *              -execute
 281  *                  This will perform compilation and execution
 282  *              -fail
 283  *                  This will perform compilation, but requires
 284  *                  the compilation to fail in order to succeed.
 285  *
 286  *          This must be provided, this tag is NOT optional.
 287  *
 288  *      C:
 289  *          Used to set the compilation flags for the given task, this
 290  *          must be provided, this tag is NOT optional.
 291  *
 292  *      E:
 293  *          Used to set the execution flags for the given task. This tag
 294  *          must be provided if T == -execute, otherwise it's erroneous
 295  *          as compilation only takes place.
 296  *
 297  *      M:
 298  *          Used to describe a string of text that should be matched from
 299  *          the output of executing the task.  If this doesn't match the
 300  *          task fails.  This tag must be provided if T == -execute, otherwise
 301  *          it's erroneous as compilation only takes place.
 302  *
 303  *      I:
 304  *          Used to specify the INPUT source file to operate on, this must be
 305  *          provided, this tag is NOT optional
 306  *
 307  *
 308  *  Notes:
 309  *      These tags have one-time use, using them more than once will result
 310  *      in template compilation errors.
 311  *
 312  *      Lines beginning with # or // in the template file are comments and
 313  *      are ignored by the template parser.
 314  *
 315  *      Whitespace is optional, with exception to the colon ':' between the
 316  *      tag and it's assignment value/
 317  *
 318  *      The template compiler will detect erronrous tags (optional tags
 319  *      that need not be set), as well as missing tags, and error accordingly
 320  *      this will result in the task failing.
 321  */
 322 typedef struct {
 323     char  *description;
 324     char  *failuremessage;
 325     char  *successmessage;
 326     char  *compileflags;
 327     char  *executeflags;
 328     char  *proceduretype;
 329     char  *sourcefile;
 330     char  *tempfilename;
 331     char **comparematch;
 332 } task_template_t;
 333
 334 /*
 335  * This is very much like a compiler code generator :-).  This generates
 336  * a value from some data observed from the compiler.
 337  */
 338 bool task_template_generate(task_template_t *template, char tag, const char *file, size_t line, const char *value) {
 339     char **destval = NULL;
 340
 341     if (!template)
 342         return false;
 343
 344     switch(tag) {
 345         case 'D': destval = &template->description;    break;
 346         case 'F': destval = &template->failuremessage; break;
 347         case 'S': destval = &template->successmessage; break;
 348         case 'T': destval = &template->proceduretype;  break;
 349         case 'C': destval = &template->compileflags;   break;
 350         case 'E': destval = &template->executeflags;   break;
 351         case 'I': destval = &template->sourcefile;     break;
 352         default:
 353             con_printmsg(LVL_ERROR, __FILE__, __LINE__, "internal error",
 354                 "invalid tag `%c:` during code generation\n",
 355                 tag
 356             );
 357             return false;
 358     }
 359
 360     /*
 361      * Ensure if for the given tag, there already exists a
 362      * assigned value.
 363      */
 364     if (*destval) {
 365         con_printmsg(LVL_ERROR, file, line, "compile error",
 366             "tag `%c:` already assigned value: %s\n",
 367             tag, *destval
 368         );
 369         return false;
 370     }
 371
 372     /*
 373      * Strip any whitespace that might exist in the value for assignments
 374      * like "D:      foo"
 375      */
 376     if (value && *value && (*value == ' ' || *value == '\t'))
 377         value++;
 378
 379     /*
 380      * Value will contain a newline character at the end, we need to strip
 381      * this otherwise kaboom, seriously, kaboom :P
 382      */
 383     *strrchr(value, '\n')='\0';
 384
 385     /*
 386      * Now allocate and set the actual value for the specific tag. Which
 387      * was properly selected and can be accessed with *destval.
 388      */
 389     *destval = util_strdup(value);
 390
 391     return true;
 392 }
 393
 394 bool task_template_parse(const char *file, task_template_t *template, FILE *fp) {
 395     char  *data = NULL;
 396     char  *back = NULL;
 397     size_t size = 0;
 398     size_t line = 1;
 399
 400     if (!template)
 401         return false;
 402
 403     /* top down parsing */
 404     while (util_getline(&back, &size, fp) != EOF) {
 405         /* skip whitespace */
 406         data = back;
 407         if (*data && (*data == ' ' || *data == '\t'))
 408             data++;
 409
 410         switch (*data) {
 411             /*
 412              * Handle comments inside task template files.  We're strict
 413              * about the language for fun :-)
 414              */
 415             case '/':
 416                 if (data[1] != '/') {
 417                     con_printmsg(LVL_ERROR, file, line, "template parse error",
 418                         "invalid character `/`, perhaps you meant `//` ?");
 419
 420                     mem_d(back);
 421                     return false;
 422                 }
 423             case '#':
 424                 break;
 425
 426             /*
 427              * Empty newlines are acceptable as well, so we handle that here
 428              * despite being just odd since there should't be that many
 429              * empty lines to begin with.
 430              */
 431             case '\r':
 432             case '\n':
 433                 break;
 434
 435
 436             /*
 437              * Now begin the actual "tag" stuff.  This works as you expect
 438              * it to.
 439              */
 440             case 'D':
 441             case 'F':
 442             case 'S':
 443             case 'T':
 444             case 'C':
 445             case 'E':
 446             case 'I':
 447                 if (data[1] != ':') {
 448                     con_printmsg(LVL_ERROR, file, line, "template parse error",
 449                         "expected `:` after `%c`",
 450                         *data
 451                     );
 452                     goto failure;
 453                 }
 454                 if (!task_template_generate(template, *data, file, line, &data[3])) {
 455                     con_printmsg(LVL_ERROR, file, line, "template compile error",
 456                         "failed to generate for given task\n"
 457                     );
 458                     goto failure;
 459                 }
 460                 break;
 461
 462             /*
 463              * Match requires it's own system since we allow multiple M's
 464              * for multi-line matching.
 465              */
 466             case 'M':
 467             {
 468                 char *value = &data[3];
 469                 if (data[1] != ':') {
 470                     con_printmsg(LVL_ERROR, file, line, "template parse error",
 471                         "expected `:` after `%c`",
 472                         *data
 473                     );
 474                     goto failure;
 475                 }
 476
 477                 if (value && *value && (*value == ' ' || *value == '\t'))
 478                     value++;
 479
 480                 /*
 481                  * Value will contain a newline character at the end, we need to strip
 482                  * this otherwise kaboom, seriously, kaboom :P
 483                  */
 484                 *strrchr(value, '\n')='\0';
 485
 486                 vec_push(template->comparematch, util_strdup(value));
 487
 488                 break;
 489             }
 490
 491             default:
 492                 con_printmsg(LVL_ERROR, file, line, "template parse error",
 493                     "invalid tag `%c`", *data
 494                 );
 495                 goto failure;
 496             /* no break required */
 497         }
 498
 499         /* update line and free old sata */
 500         line++;
 501         mem_d(back);
 502         back = NULL;
 503     }
 504     if (back)
 505         mem_d(back);
 506     return true;
 507
 508 failure:
 509     if (back)
 510         mem_d (back);
 511     return false;
 512 }
 513
 514 /*
 515  * Nullifies the template data: used during initialization of a new
 516  * template and free.
 517  */
 518 void task_template_nullify(task_template_t *template) {
 519     if (!template)
 520         return;
 521
 522     template->description    = NULL;
 523     template->failuremessage = NULL;
 524     template->successmessage = NULL;
 525     template->proceduretype  = NULL;
 526     template->compileflags   = NULL;
 527     template->executeflags   = NULL;
 528     template->comparematch   = NULL;
 529     template->sourcefile     = NULL;
 530     template->tempfilename   = NULL;
 531 }
 532
 533 task_template_t *task_template_compile(const char *file, const char *dir) {
 534     /* a page should be enough */
 535     char             fullfile[4096];
 536     FILE            *tempfile = NULL;
 537     task_template_t *template = NULL;
 538
 539     memset  (fullfile, 0, sizeof(fullfile));
 540     snprintf(fullfile,    sizeof(fullfile), "%s/%s", dir, file);
 541
 542     tempfile = fopen(fullfile, "r");
 543     template = mem_a(sizeof(task_template_t));
 544     task_template_nullify(template);
 545
 546     /*
 547      * Esnure the file even exists for the task, this is pretty useless
 548      * to even do.
 549      */
 550     if (!tempfile) {
 551         con_err("template file: %s does not exist or invalid permissions\n",
 552             file
 553         );
 554         goto failure;
 555     }
 556
 557     if (!task_template_parse(file, template, tempfile)) {
 558         con_err("template parse error: error during parsing\n");
 559         goto failure;
 560     }
 561
 562     /*
 563      * Regardless procedure type, the following tags must exist:
 564      *  D
 565      *  T
 566      *  C
 567      *  I
 568      */
 569     if (!template->description) {
 570         con_err("template compile error: %s missing `D:` tag\n", file);
 571         goto failure;
 572     }
 573     if (!template->proceduretype) {
 574         con_err("template compile error: %s missing `T:` tag\n", file);
 575         goto failure;
 576     }
 577     if (!template->compileflags) {
 578         con_err("template compile error: %s missing `C:` tag\n", file);
 579         goto failure;
 580     }
 581     if (!template->sourcefile) {
 582         con_err("template compile error: %s missing `I:` tag\n", file);
 583         goto failure;
 584     }
 585
 586     /*
 587      * Now lets compile the template, compilation is really just
 588      * the process of validating the input.
 589      */
 590     if (!strcmp(template->proceduretype, "-compile")) {
 591         if (template->executeflags)
 592             con_err("template compile warning: %s erroneous tag `E:` when only compiling\n", file);
 593         if (template->comparematch)
 594             con_err("template compile warning: %s erroneous tag `M:` when only compiling\n", file);
 595         goto success;
 596     } else if (!strcmp(template->proceduretype, "-execute")) {
 597         if (!template->executeflags) {
 598             /* default to $null */
 599             template->executeflags = util_strdup("$null");
 600         }
 601         if (!template->comparematch) {
 602             con_err("template compile error: %s missing `M:` tag (use `$null` for exclude)\n", file);
 603             goto failure;
 604         }
 605     } else if (!strcmp(template->proceduretype, "-fail")) {
 606         if (template->executeflags)
 607             con_err("template compile warning: %s erroneous tag `E:` when only failing\n", file);
 608         if (template->comparematch)
 609             con_err("template compile warning: %s erroneous tag `M:` when only failing\n", file);
 610         goto success;
 611     } else {
 612         con_err("template compile error: %s invalid procedure type: %s\n", file, template->proceduretype);
 613         goto failure;
 614     }
 615
 616 success:
 617     fclose(tempfile);
 618     return template;
 619
 620 failure:
 621     /*
 622      * The file might not exist and we jump here when that doesn't happen
 623      * so the check to see if it's not null here is required.
 624      */
 625     if (tempfile)
 626         fclose(tempfile);
 627     mem_d (template);
 628
 629     return NULL;
 630 }
 631
 632 void task_template_destroy(task_template_t **template) {
 633     if (!template)
 634         return;
 635
 636     if ((*template)->description)    mem_d((*template)->description);
 637     if ((*template)->failuremessage) mem_d((*template)->failuremessage);
 638     if ((*template)->successmessage) mem_d((*template)->successmessage);
 639     if ((*template)->proceduretype)  mem_d((*template)->proceduretype);
 640     if ((*template)->compileflags)   mem_d((*template)->compileflags);
 641     if ((*template)->executeflags)   mem_d((*template)->executeflags);
 642     if ((*template)->sourcefile)     mem_d((*template)->sourcefile);
 643
 644     /*
 645      * Delete all allocated string for task template then destroy the
 646      * main vector.
 647      */
 648     {
 649         size_t i = 0;
 650         for (; i < vec_size((*template)->comparematch); i++)
 651             mem_d((*template)->comparematch[i]);
 652
 653         vec_free((*template)->comparematch);
 654     }
 655
 656     /*
 657      * Nullify all the template members otherwise NULL comparision
 658      * checks will fail if template pointer is reused.
 659      */
 660     mem_d(*template);
 661 }
 662
 663 /*
 664  * Now comes the task manager, this system allows adding tasks in and out
 665  * of a task list.  This is the executor of the tasks essentially as well.
 666  */
 667 typedef struct {
 668     task_template_t *template;
 669     FILE           **runhandles;
 670     FILE            *stderrlog;
 671     FILE            *stdoutlog;
 672     char            *stdoutlogfile;
 673     char            *stderrlogfile;
 674     bool             compiled;
 675 } task_t;
 676
 677 task_t *task_tasks = NULL;
 678
 679 /*
 680  * Read a directory and searches for all template files in it
 681  * which is later used to run all tests.
 682  */
 683 bool task_propagate(const char *curdir) {
 684     bool             success = true;
 685     DIR             *dir;
 686     struct dirent   *files;
 687     struct stat      directory;
 688     char             buffer[4096];
 689     size_t           found = 0;
 690
 691     dir = opendir(curdir);
 692
 693     while ((files = readdir(dir))) {
 694         memset  (buffer, 0,sizeof(buffer));
 695         snprintf(buffer,   sizeof(buffer), "%s/%s", curdir, files->d_name);
 696
 697         if (stat(buffer, &directory) == -1) {
 698             con_err("internal error: stat failed, aborting\n");
 699             abort();
 700         }
 701
 702         /* skip directories */
 703         if (S_ISDIR(directory.st_mode))
 704             continue;
 705
 706         /*
 707          * We made it here, which concludes the file/directory is not
 708          * actually a directory, so it must be a file :)
 709          */
 710         if (strcmp(files->d_name + strlen(files->d_name) - 5, ".tmpl") == 0) {
 711             task_template_t *template = task_template_compile(files->d_name, curdir);
 712             char             buf[4096]; /* one page should be enough */
 713             task_t           task;
 714
 715             util_debug("TEST", "compiling task template: %s/%s\n", curdir, files->d_name);
 716             found ++;
 717             if (!template) {
 718                 con_err("error compiling task template: %s\n", files->d_name);
 719                 success = false;
 720                 continue;
 721             }
 722             /*
 723              * Generate a temportary file name for the output binary
 724              * so we don't trample over an existing one.
 725              */
 726             template->tempfilename = tempnam(curdir, "TMPDAT");
 727
 728             /*
 729              * Generate the command required to open a pipe to a process
 730              * which will be refered to with a handle in the task for
 731              * reading the data from the pipe.
 732              */
 733             memset  (buf,0,sizeof(buf));
 734             snprintf(buf,  sizeof(buf), "%s %s/%s %s -o %s",
 735                 task_bins[TASK_COMPILE],
 736                 curdir,
 737                 template->sourcefile,
 738                 template->compileflags,
 739                 template->tempfilename
 740             );
 741
 742             /*
 743              * The task template was compiled, now lets create a task from
 744              * the template data which has now been propagated.
 745              */
 746             task.template = template;
 747             if (!(task.runhandles = task_popen(buf, "r"))) {
 748                 con_err("error opening pipe to process for test: %s\n", template->description);
 749                 success = false;
 750                 continue;
 751             }
 752
 753             util_debug("TEST", "executing test: `%s` [%s]\n", template->description, buf);
 754
 755             /*
 756              * Open up some file desciptors for logging the stdout/stderr
 757              * to our own.
 758              */
 759             memset  (buf,0,sizeof(buf));
 760             snprintf(buf,  sizeof(buf), "%s.stdout", template->tempfilename);
 761             task.stdoutlogfile = util_strdup(buf);
 762             if (!(task.stdoutlog     = fopen(buf, "w"))) {
 763                 con_err("error opening %s for stdout\n", buf);
 764                 continue;
 765             }
 766
 767             memset  (buf,0,sizeof(buf));
 768             snprintf(buf,  sizeof(buf), "%s.stderr", template->tempfilename);
 769             task.stderrlogfile = util_strdup(buf);
 770             if (!(task.stderrlog     = fopen(buf, "w"))) {
 771                 con_err("error opening %s for stderr\n", buf);
 772                 continue;
 773             }
 774
 775             vec_push(task_tasks, task);
 776         }
 777     }
 778
 779     util_debug("TEST", "compiled %d task template files out of %d\n",
 780         vec_size(task_tasks),
 781         found
 782     );
 783
 784     closedir(dir);
 785     return success;
 786 }
 787
 788 /*
 789  * Removes all temporary 'progs.dat' files created during compilation
 790  * of all tests'
 791  */
 792 void task_cleanup(const char *curdir) {
 793     DIR             *dir;
 794     struct dirent   *files;
 795     char             buffer[4096];
 796
 797     dir = opendir(curdir);
 798
 799     while ((files = readdir(dir))) {
 800         memset(buffer, 0, sizeof(buffer));
 801         if (strstr(files->d_name, "TMP")) {
 802             snprintf(buffer, sizeof(buffer), "%s/%s", curdir, files->d_name);
 803             if (remove(buffer))
 804                 con_err("error removing temporary file: %s\n", buffer);
 805             else
 806                 util_debug("TEST", "removed temporary file: %s\n", buffer);
 807         }
 808     }
 809
 810     closedir(dir);
 811 }
 812
 813 /*
 814  * Task precleanup removes any existing temporary files or log files
 815  * left behind from a previous invoke of the test-suite.
 816  */
 817 void task_precleanup(const char *curdir) {
 818     DIR             *dir;
 819     struct dirent   *files;
 820     char             buffer[4096];
 821
 822     dir = opendir(curdir);
 823
 824     while ((files = readdir(dir))) {
 825         memset(buffer, 0, sizeof(buffer));
 826         if (strstr(files->d_name, "TMP")     ||
 827             strstr(files->d_name, ".stdout") ||
 828             strstr(files->d_name, ".stderr"))
 829         {
 830             snprintf(buffer, sizeof(buffer), "%s/%s", curdir, files->d_name);
 831             if (remove(buffer))
 832                 con_err("error removing temporary file: %s\n", buffer);
 833             else
 834                 util_debug("TEST", "removed temporary file: %s\n", buffer);
 835         }
 836     }
 837
 838     closedir(dir);
 839 }
 840
 841 void task_destroy(const char *curdir) {
 842     /*
 843      * Free all the data in the task list and finally the list itself
 844      * then proceed to cleanup anything else outside the program like
 845      * temporary files.
 846      */
 847     size_t i;
 848     for (i = 0; i < vec_size(task_tasks); i++) {
 849         /*
 850          * Close any open handles to files or processes here.  It's mighty
 851          * annoying to have to do all this cleanup work.
 852          */
 853         if (task_tasks[i].runhandles) task_pclose(task_tasks[i].runhandles);
 854         if (task_tasks[i].stdoutlog)  fclose     (task_tasks[i].stdoutlog);
 855         if (task_tasks[i].stderrlog)  fclose     (task_tasks[i].stderrlog);
 856
 857         /*
 858          * Only remove the log files if the test actually compiled otherwise
 859          * forget about it (or if it didn't compile, and the procedure type
 860          * was set to -fail (meaning it shouldn't compile) .. stil remove)
 861          */
 862         if (task_tasks[i].compiled || !strcmp(task_tasks[i].template->proceduretype, "-fail")) {
 863             if (remove(task_tasks[i].stdoutlogfile))
 864                 con_err("error removing stdout log file: %s\n", task_tasks[i].stdoutlogfile);
 865             else
 866                 util_debug("TEST", "removed stdout log file: %s\n", task_tasks[i].stdoutlogfile);
 867
 868             if (remove(task_tasks[i].stderrlogfile))
 869                 con_err("error removing stderr log file: %s\n", task_tasks[i].stderrlogfile);
 870             else
 871                 util_debug("TEST", "removed stderr log file: %s\n", task_tasks[i].stderrlogfile);
 872         }
 873
 874         /* free util_strdup data for log files */
 875         mem_d(task_tasks[i].stdoutlogfile);
 876         mem_d(task_tasks[i].stderrlogfile);
 877
 878         task_template_destroy(&task_tasks[i].template);
 879     }
 880     vec_free(task_tasks);
 881
 882     /*
 883      * Cleanup outside stuff like temporary files.
 884      */
 885     task_cleanup(curdir);
 886 }
 887
 888 /*
 889  * This executes the QCVM task for a specificly compiled progs.dat
 890  * using the template passed into it for call-flags and user defined
 891  * messages.
 892  */
 893 bool task_execute(task_template_t *template, char ***line) {
 894     bool     success = true;
 895     FILE    *execute;
 896     char     buffer[4096];
 897     memset  (buffer,0,sizeof(buffer));
 898
 899     /*
 900      * Drop the execution flags for the QCVM if none where
 901      * actually specified.
 902      */
 903     if (!strcmp(template->executeflags, "$null")) {
 904         snprintf(buffer,  sizeof(buffer), "%s %s",
 905             task_bins[TASK_EXECUTE],
 906             template->tempfilename
 907         );
 908     } else {
 909         snprintf(buffer,  sizeof(buffer), "%s %s %s",
 910             task_bins[TASK_EXECUTE],
 911             template->executeflags,
 912             template->tempfilename
 913         );
 914     }
 915
 916     util_debug("TEST", "executing qcvm: `%s` [%s]\n",
 917         template->description,
 918         buffer
 919     );
 920
 921     execute = popen(buffer, "r");
 922     if (!execute)
 923         return false;
 924
 925     /*
 926      * Now lets read the lines and compare them to the matches we expect
 927      * and handle accordingly.
 928      */
 929     {
 930         char  *data    = NULL;
 931         size_t size    = 0;
 932         size_t compare = 0;
 933         while (util_getline(&data, &size, execute) != EOF) {
 934             if (!strcmp(data, "No main function found\n")) {
 935                 con_err("test failure: `%s` [%s] (No main function found)\n",
 936                     template->description,
 937                     (template->failuremessage) ?
 938                     template->failuremessage : "unknown"
 939                 );
 940                 pclose(execute);
 941                 return false;
 942             }
 943
 944             /*
 945              * Trim newlines from data since they will just break our
 946              * ability to properly validate matches.
 947              */
 948             if  (strrchr(data, '\n'))
 949                 *strrchr(data, '\n') = '\0';
 950
 951             if (vec_size(template->comparematch) > compare) {
 952                 if (strcmp(data, template->comparematch[compare++]))
 953                     success = false;
 954             } else {
 955                     success = false;
 956             }
 957
 958             /*
 959              * Copy to output vector for diagnostics if execution match
 960              * fails.
 961              */
 962             vec_push(*line, data);
 963
 964             /* reset */
 965             data = NULL;
 966             size = 0;
 967         }
 968         mem_d(data);
 969         data = NULL;
 970     }
 971     pclose(execute);
 972     return success;
 973 }
 974
 975 /*
 976  * This schedualizes all tasks and actually runs them individually
 977  * this is generally easy for just -compile variants.  For compile and
 978  * execution this takes more work since a task needs to be generated
 979  * from thin air and executed INLINE.
 980  */
 981 void task_schedualize() {
 982     bool   execute  = false;
 983     char  *data     = NULL;
 984     char **match    = NULL;
 985     size_t size     = 0;
 986     size_t i;
 987     size_t j;
 988
 989     util_debug("TEST", "found %d tasks, preparing to execute\n", vec_size(task_tasks));
 990
 991     for (i = 0; i < vec_size(task_tasks); i++) {
 992         util_debug("TEST", "executing task: %d: %s\n", i, task_tasks[i].template->description);
 993         /*
 994          * Generate a task from thin air if it requires execution in
 995          * the QCVM.
 996          */
 997         execute = !!(!strcmp(task_tasks[i].template->proceduretype, "-execute"));
 998
 999         /*
1000          * We assume it compiled before we actually compiled :).  On error
1001          * we change the value
1002          */
1003         task_tasks[i].compiled = true;
1004
1005         /*
1006          * Read data from stdout first and pipe that stuff into a log file
1007          * then we do the same for stderr.
1008          */
1009         while (util_getline(&data, &size, task_tasks[i].runhandles[1]) != EOF) {
1010             fputs(data, task_tasks[i].stdoutlog);
1011
1012             if (strstr(data, "failed to open file")) {
1013                 task_tasks[i].compiled = false;
1014                 execute                = false;
1015             }
1016
1017             fflush(task_tasks[i].stdoutlog);
1018         }
1019         while (util_getline(&data, &size, task_tasks[i].runhandles[2]) != EOF) {
1020             /*
1021              * If a string contains an error we just dissalow execution
1022              * of it in the vm.
1023              *
1024              * TODO: make this more percise, e.g if we print a warning
1025              * that refers to a variable named error, or something like
1026              * that .. then this will blowup :P
1027              */
1028             if (strstr(data, "error")) {
1029                 execute                = false;
1030                 task_tasks[i].compiled = false;
1031             }
1032
1033             fputs(data, task_tasks[i].stderrlog);
1034             fflush(task_tasks[i].stdoutlog);
1035         }
1036
1037         if (!task_tasks[i].compiled && strcmp(task_tasks[i].template->proceduretype, "-fail")) {
1038             con_err("test failure: `%s` [%s] (failed to compile) see %s.stdout and %s.stderr\n",
1039                 task_tasks[i].template->description,
1040                 (task_tasks[i].template->failuremessage) ?
1041                 task_tasks[i].template->failuremessage : "unknown",
1042                 task_tasks[i].template->tempfilename,
1043                 task_tasks[i].template->tempfilename
1044             );
1045             continue;
1046         }
1047
1048         if (!execute) {
1049             con_out("test succeeded: `%s` [%s]\n",
1050                  task_tasks[i].template->description,
1051                 (task_tasks[i].template->successmessage) ?
1052                  task_tasks[i].template->successmessage  : "unknown"
1053             );
1054             continue;
1055         }
1056
1057         /*
1058          * If we made it here that concludes the task is to be executed
1059          * in the virtual machine.
1060          */
1061         if (!task_execute(task_tasks[i].template, &match)) {
1062             size_t d = 0;
1063
1064             con_err("test failure: `%s` [%s] (invalid results from execution)\n",
1065                  task_tasks[i].template->description,
1066                 (task_tasks[i].template->failuremessage) ?
1067                  task_tasks[i].template->failuremessage : "unknown"
1068             );
1069
1070             /*
1071              * Print nicely formatted expected match lists to console error
1072              * handler for the all the given matches in the template file and
1073              * what was actually returned from executing.
1074              */
1075             con_err("    Expected From %u Matches: (got %u Matches)\n",
1076                 vec_size(task_tasks[i].template->comparematch),
1077                 vec_size(match)
1078             );
1079             for (; d < vec_size(task_tasks[i].template->comparematch); d++) {
1080                 char  *select = task_tasks[i].template->comparematch[d];
1081                 size_t length = 40 - strlen(select);
1082
1083                 con_err("        Expected: \"%s\"", select);
1084                 while (length --)
1085                     con_err(" ");
1086                 con_err("| Got: \"%s\"\n", (d >= vec_size(match)) ? "<<nothing else to compare>>" : match[d]);
1087             }
1088
1089             /*
1090              * Print the non-expected out (since we are simply not expecting it)
1091              * This will help track down bugs in template files that fail to match
1092              * something.
1093              */
1094             if (vec_size(match) > vec_size(task_tasks[i].template->comparematch)) {
1095                 for (d = 0; d < vec_size(match) - vec_size(task_tasks[i].template->comparematch); d++) {
1096                     con_err("        Expected: Nothing                                   | Got: \"%s\"\n",
1097                         match[d + vec_size(task_tasks[i].template->comparematch)]
1098                     );
1099                 }
1100             }
1101
1102
1103             for (j = 0; j < vec_size(match); j++)
1104                 mem_d(match[j]);
1105             vec_free(match);
1106             continue;
1107         }
1108         for (j = 0; j < vec_size(match); j++)
1109             mem_d(match[j]);
1110         vec_free(match);
1111
1112         con_out("test succeeded: `%s` [%s]\n",
1113              task_tasks[i].template->description,
1114             (task_tasks[i].template->successmessage) ?
1115              task_tasks[i].template->successmessage  : "unknown"
1116         );
1117     }
1118     mem_d(data);
1119 }
1120
1121 /*
1122  * This is the heart of the whole test-suite process.  This cleans up
1123  * any existing temporary files left behind as well as log files left
1124  * behind.  Then it propagates a list of tests from `curdir` by scaning
1125  * it for template files and compiling them into tasks, in which it
1126  * schedualizes them (executes them) and actually reports errors and
1127  * what not.  It then proceeds to destroy the tasks and return memory
1128  * it's the engine :)
1129  *
1130  * It returns true of tests could be propagated, otherwise it returns
1131  * false.
1132  *
1133  * It expects con_init() was called before hand.
1134  */
1135 bool test_perform(const char *curdir) {
1136     task_precleanup(curdir);
1137     if (!task_propagate(curdir)) {
1138         con_err("error: failed to propagate tasks\n");
1139         task_destroy(curdir);
1140         return false;
1141     }
1142     /*
1143      * If we made it here all tasks where propagated from their resultant
1144      * template file.  So we can start the FILO scheduler, this has been
1145      * designed in the most thread-safe way possible for future threading
1146      * it's designed to prevent lock contention, and possible syncronization
1147      * issues.
1148      */
1149     task_schedualize();
1150     task_destroy(curdir);
1151
1152     return true;
1153 }
1154
1155 /*
1156  * Fancy GCC-like LONG parsing allows things like --opt=param with
1157  * assignment operator.  This is used for redirecting stdout/stderr
1158  * console to specific files of your choice.
1159  */
1160 static bool parsecmd(const char *optname, int *argc_, char ***argv_, char **out, int ds, bool split) {
1161     int  argc   = *argc_;
1162     char **argv = *argv_;
1163
1164     size_t len = strlen(optname);
1165
1166     if (strncmp(argv[0]+ds, optname, len))
1167         return false;
1168
1169     /* it's --optname, check how the parameter is supplied */
1170     if (argv[0][ds+len] == '=') {
1171         *out = argv[0]+ds+len+1;
1172         return true;
1173     }
1174
1175     if (!split || argc < ds) /* no parameter was provided, or only single-arg form accepted */
1176         return false;
1177
1178     /* using --opt param */
1179     *out = argv[1];
1180     --*argc_;
1181     ++*argv_;
1182     return true;
1183 }
1184
1185 int main(int argc, char **argv) {
1186     char         *redirout = (char*)stdout;
1187     char         *redirerr = (char*)stderr;
1188
1189     con_init();
1190
1191     /*
1192      * Command line option parsing commences now We only need to support
1193      * a few things in the test suite.
1194      */
1195     while (argc > 1) {
1196         ++argv;
1197         --argc;
1198
1199         if (argv[0][0] == '-') {
1200             if (parsecmd("redirout", &argc, &argv, &redirout, 1, false))
1201                 continue;
1202             if (parsecmd("redirerr", &argc, &argv, &redirerr, 1, false))
1203                 continue;
1204
1205             con_change(redirout, redirerr);
1206
1207             if (!strcmp(argv[0]+1, "debug")) {
1208                 opts.debug = true;
1209                 continue;
1210             }
1211             if (!strcmp(argv[0]+1, "memchk")) {
1212                 opts.memchk = true;
1213                 continue;
1214             }
1215             if (!strcmp(argv[0]+1, "nocolor")) {
1216                 con_color(0);
1217                 continue;
1218             }
1219
1220             con_err("invalid argument %s\n", argv[0]+1);
1221             return -1;
1222         }
1223     }
1224     con_change(redirout, redirerr);
1225     test_perform("tests");
1226     util_meminfo();
1227     return 0;
1228 }