X-Git-Url: https://git.xonotic.org/?p=xonotic%2Fgmqcc.git;a=blobdiff_plain;f=test.c;h=d9a991fa8e2786cd7e7fd83897f0bc69d91bc115;hp=7202efb4667d40c768fb31757f0dac0719e63c09;hb=19c57c03cc8fdc804766136a27d1f6a57548dd5b;hpb=57d2876021390b1a6da236bb65ed7e2ec5cd6273

diff --git a/test.c b/test.c
old mode 100644
new mode 100755
index 7202efb..d9a991f
--- a/test.c
+++ b/test.c
@@ -157,22 +157,41 @@ int task_pclose(FILE **handles) {
      * other hacks.
      */
     typedef struct {
-        int __dummy;
-        /* TODO: implement */
+        char name_err[L_tmpnam];
+        char name_out[L_tmpnam];
     } popen_t;
 
     FILE **task_popen(const char *command, const char *mode) {
-        (void)command;
-        (void)mode;
+        FILE   **handles = NULL;
+        char    *cmd     = NULL;
+        popen_t *open    = (popen_t*)mem_a(sizeof(popen_t) * 3);
 
-        /* TODO: implement */
-        return NULL;
+        tmpnam(open->name_err);
+        tmpnam(open->name_out);
+
+        (void)mode; /* excluded */
+
+        util_asprintf(&cmd, "%s -redirout=%s -redirerr=%s", command, open->name_out, open->name_err);
+
+        system(cmd); /* HACK */
+        handles    = (FILE**)(open + 1);
+        handles[0] = NULL;
+        handles[1] = fs_file_open(open->name_out, "r");
+        handles[2] = fs_file_open(open->name_err, "r");
+
+        mem_d(cmd);
+
+        return handles;
     }
 
     void task_pclose(FILE **files) {
-        /* TODO: implement */
-        (void)files;
-        return;
+        popen_t *open = ((popen_t*)files) - 1;
+        fs_file_close(files[1]);
+        fs_file_close(files[2]);
+        remove(open->name_err);
+        remove(open->name_out);
+
+        mem_d(open);
     }
 #endif /*! _WIN32 */
 
@@ -210,7 +229,7 @@ int task_pclose(FILE **handles) {
  *                  This will perform compilation and execution
  *              -fail
  *                  This will perform compilation, but requires
- *                  the compilation to fail in order to succeed.   
+ *                  the compilation to fail in order to succeed.
  *
  *          This must be provided, this tag is NOT optional.
  *
@@ -329,7 +348,7 @@ bool task_template_generate(task_template_t *tmpl, char tag, const char *file, s
         /*
          * Create some padding for the description to align the
          * printing of the rules file.
-         */  
+         */
         if ((desclen = strlen(tmpl->description)) > pad[0])
             pad[0] = desclen;
     }
@@ -488,7 +507,7 @@ task_template_t *task_template_compile(const char *file, const char *dir, size_t
     FILE            *tempfile = NULL;
     task_template_t *tmpl     = NULL;
 
-    snprintf(fullfile,    sizeof(fullfile), "%s/%s", dir, file);
+    util_snprintf(fullfile,    sizeof(fullfile), "%s/%s", dir, file);
 
     tempfile = fs_file_open(fullfile, "r");
     tmpl     = (task_template_t*)mem_a(sizeof(task_template_t));
@@ -497,7 +516,7 @@ task_template_t *task_template_compile(const char *file, const char *dir, size_t
     /*
      * Create some padding for the printing to align the
      * printing of the rules file to the console.
-     */  
+     */
     if ((filepadd = strlen(fullfile)) > pad[1])
         pad[1] = filepadd;
 
@@ -568,7 +587,7 @@ task_template_t *task_template_compile(const char *file, const char *dir, size_t
         if (tmpl->comparematch)
             con_err("template compile warning: %s erroneous tag `M:` when only failing\n", file);
     } else if (!strcmp(tmpl->proceduretype, "-pp")) {
-        if (!tmpl->executeflags)
+        if (tmpl->executeflags)
             con_err("template compile warning: %s erroneous tag `E:` when only preprocessing\n", file);
         if (!tmpl->comparematch) {
             con_err("template compile error: %s missing `M:` tag (use `$null` for exclude)\n", file);
@@ -657,7 +676,7 @@ bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
     dir = fs_dir_open(curdir);
 
     while ((files = fs_dir_read(dir))) {
-        snprintf(buffer, sizeof(buffer), "%s/%s", curdir, files->d_name);
+        util_snprintf(buffer, sizeof(buffer), "%s/%s", curdir, files->d_name);
 
         if (stat(buffer, &directory) == -1) {
             con_err("internal error: stat failed, aborting\n");
@@ -697,7 +716,16 @@ bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
              * to test compile flags for all tests.  This needs to be
              * BEFORE other flags (so that the .tmpl can override them)
              */
+            #ifdef _MSC_VER
+            {
+                char   buffer[4096];
+                size_t size;
+                getenv_s(&size, buffer, sizeof(buffer), "QCFLAGS");
+                qcflags = buffer;
+            }
+            #else
             qcflags = getenv("QCFLAGS");
+            #endif
 
             /*
              * Generate the command required to open a pipe to a process
@@ -707,7 +735,7 @@ bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
             if (strcmp(tmpl->proceduretype, "-pp")) {
                 if (qcflags) {
                     if (tmpl->testflags && !strcmp(tmpl->testflags, "-no-defs")) {
-                        snprintf(buf, sizeof(buf), "%s %s/%s %s %s -o %s",
+                        util_snprintf(buf, sizeof(buf), "%s %s/%s %s %s -o %s",
                             task_bins[TASK_COMPILE],
                             curdir,
                             tmpl->sourcefile,
@@ -716,7 +744,7 @@ bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
                             tmpl->tempfilename
                         );
                     } else {
-                        snprintf(buf, sizeof(buf), "%s %s/%s %s/%s %s %s -o %s",
+                        util_snprintf(buf, sizeof(buf), "%s %s/%s %s/%s %s %s -o %s",
                             task_bins[TASK_COMPILE],
                             curdir,
                             defs,
@@ -729,7 +757,7 @@ bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
                     }
                 } else {
                     if (tmpl->testflags && !strcmp(tmpl->testflags, "-no-defs")) {
-                        snprintf(buf, sizeof(buf), "%s %s/%s %s -o %s",
+                        util_snprintf(buf, sizeof(buf), "%s %s/%s %s -o %s",
                             task_bins[TASK_COMPILE],
                             curdir,
                             tmpl->sourcefile,
@@ -737,7 +765,7 @@ bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
                             tmpl->tempfilename
                         );
                     } else {
-                        snprintf(buf, sizeof(buf), "%s %s/%s %s/%s %s -o %s",
+                        util_snprintf(buf, sizeof(buf), "%s %s/%s %s/%s %s -o %s",
                             task_bins[TASK_COMPILE],
                             curdir,
                             defs,
@@ -751,14 +779,14 @@ bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
             } else {
                 /* Preprocessing (qcflags mean shit all here we don't allow them) */
                 if (tmpl->testflags && !strcmp(tmpl->testflags, "-no-defs")) {
-                    snprintf(buf, sizeof(buf), "%s -E %s/%s -o %s",
+                    util_snprintf(buf, sizeof(buf), "%s -E %s/%s -o %s",
                         task_bins[TASK_COMPILE],
                         curdir,
                         tmpl->sourcefile,
                         tmpl->tempfilename
                     );
                 } else {
-                    snprintf(buf, sizeof(buf), "%s -E %s/%s %s/%s -o %s",
+                    util_snprintf(buf, sizeof(buf), "%s -E %s/%s %s/%s -o %s",
                         task_bins[TASK_COMPILE],
                         curdir,
                         defs,
@@ -786,14 +814,14 @@ bool task_propagate(const char *curdir, size_t *pad, const char *defs) {
              * Open up some file desciptors for logging the stdout/stderr
              * to our own.
              */
-            snprintf(buf,  sizeof(buf), "%s.stdout", tmpl->tempfilename);
+            util_snprintf(buf,  sizeof(buf), "%s.stdout", tmpl->tempfilename);
             task.stdoutlogfile = util_strdup(buf);
             if (!(task.stdoutlog     = fs_file_open(buf, "w"))) {
                 con_err("error opening %s for stdout\n", buf);
                 continue;
             }
 
-            snprintf(buf,  sizeof(buf), "%s.stderr", tmpl->tempfilename);
+            util_snprintf(buf,  sizeof(buf), "%s.stderr", tmpl->tempfilename);
             task.stderrlogfile = util_strdup(buf);
             if (!(task.stderrlog = fs_file_open(buf, "w"))) {
                 con_err("error opening %s for stderr\n", buf);
@@ -829,7 +857,7 @@ void task_precleanup(const char *curdir) {
             strstr(files->d_name, ".stdout") ||
             strstr(files->d_name, ".stderr"))
         {
-            snprintf(buffer, sizeof(buffer), "%s/%s", curdir, files->d_name);
+            util_snprintf(buffer, sizeof(buffer), "%s/%s", curdir, files->d_name);
             if (remove(buffer))
                 con_err("error removing temporary file: %s\n", buffer);
             else
@@ -859,7 +887,7 @@ void task_destroy(void) {
         /*
          * Only remove the log files if the test actually compiled otherwise
          * forget about it (or if it didn't compile, and the procedure type
-         * was set to -fail (meaning it shouldn't compile) .. stil remove) 
+         * was set to -fail (meaning it shouldn't compile) .. stil remove)
          */
         if (task_tasks[i].compiled || !strcmp(task_tasks[i].tmpl->proceduretype, "-fail")) {
             if (remove(task_tasks[i].stdoutlogfile))
@@ -886,39 +914,52 @@ void task_destroy(void) {
 /*
  * This executes the QCVM task for a specificly compiled progs.dat
  * using the template passed into it for call-flags and user defined
- * messages.
+ * messages IF the procedure type is -execute, otherwise it matches
+ * the preprocessor output.
  */
-bool task_execute(task_template_t *tmpl, char ***line) {
+bool task_trymatch(task_template_t *tmpl, char ***line) {
     bool     success = true;
+    bool     preprocessing = false;
     FILE    *execute;
     char     buffer[4096];
     memset  (buffer,0,sizeof(buffer));
 
-    /*
-     * Drop the execution flags for the QCVM if none where
-     * actually specified.
-     */
-    if (!strcmp(tmpl->executeflags, "$null")) {
-        snprintf(buffer,  sizeof(buffer), "%s %s",
-            task_bins[TASK_EXECUTE],
-            tmpl->tempfilename
-        );
-    } else {
-        snprintf(buffer,  sizeof(buffer), "%s %s %s",
-            task_bins[TASK_EXECUTE],
-            tmpl->executeflags,
-            tmpl->tempfilename
+    if (strcmp(tmpl->proceduretype, "-pp")) {
+        /*
+         * Drop the execution flags for the QCVM if none where
+         * actually specified.
+         */
+        if (!strcmp(tmpl->executeflags, "$null")) {
+            util_snprintf(buffer,  sizeof(buffer), "%s %s",
+                task_bins[TASK_EXECUTE],
+                tmpl->tempfilename
+            );
+        } else {
+            util_snprintf(buffer,  sizeof(buffer), "%s %s %s",
+                task_bins[TASK_EXECUTE],
+                tmpl->executeflags,
+                tmpl->tempfilename
+            );
+        }
+
+        util_debug("TEST", "executing qcvm: `%s` [%s]\n",
+            tmpl->description,
+            buffer
         );
-    }
 
-    util_debug("TEST", "executing qcvm: `%s` [%s]\n",
-        tmpl->description,
-        buffer
-    );
+        execute = popen(buffer, "r");
+        if (!execute)
+            return false;
+    } else {
+        /*
+         * we're preprocessing, which means we need to read int
+         * the produced file and do some really weird shit.
+         */
+        if (!(execute = fs_file_open(tmpl->tempfilename, "r")))
+            return false;
 
-    execute = popen(buffer, "r");
-    if (!execute)
-        return false;
+        preprocessing = true;
+    }
 
     /*
      * Now lets read the lines and compare them to the matches we expect
@@ -934,7 +975,10 @@ bool task_execute(task_template_t *tmpl, char ***line) {
                     tmpl->description,
                     tmpl->rulesfile
                 );
-                pclose(execute);
+                if (preprocessing)
+                    fs_file_close(execute);
+                else
+                    pclose(execute);
                 return false;
             }
 
@@ -945,6 +989,13 @@ bool task_execute(task_template_t *tmpl, char ***line) {
             if  (strrchr(data, '\n'))
                 *strrchr(data, '\n') = '\0';
 
+            /*
+             * If data is just null now, that means the line was an empty
+             * one and for that, we just ignore it.
+             */
+            if (!*data)
+                continue;
+
             if (vec_size(tmpl->comparematch) > compare) {
                 if (strcmp(data, tmpl->comparematch[compare++]))
                     success = false;
@@ -955,7 +1006,7 @@ bool task_execute(task_template_t *tmpl, char ***line) {
             /*
              * Copy to output vector for diagnostics if execution match
              * fails.
-             */  
+             */
             vec_push(*line, data);
 
             /* reset */
@@ -965,18 +1016,23 @@ bool task_execute(task_template_t *tmpl, char ***line) {
         mem_d(data);
         data = NULL;
     }
-    pclose(execute);
+
+    if (!preprocessing)
+        pclose(execute);
+    else
+        fs_file_close(execute);
+
     return success;
 }
 
 const char *task_type(task_template_t *tmpl) {
     if (!strcmp(tmpl->proceduretype, "-pp"))
-        return "type: preprocessor test";
+        return "type: preprocessor";
     if (!strcmp(tmpl->proceduretype, "-execute"))
-        return "type: execution test";
+        return "type: execution";
     if (!strcmp(tmpl->proceduretype, "-compile"))
-        return "type: compile test";
-    return "type: fail test";
+        return "type: compile";
+    return "type: fail";
 }
 
 /*
@@ -995,12 +1051,12 @@ void task_schedualize(size_t *pad) {
     size_t i        = 0;
     size_t j        = 0;
 
-    snprintf(space[0], sizeof(space[0]), "%d", (int)vec_size(task_tasks));
+    util_snprintf(space[0], sizeof(space[0]), "%d", (int)vec_size(task_tasks));
 
     for (; i < vec_size(task_tasks); i++) {
         memset(space[1], 0, sizeof(space[1]));
-        snprintf(space[1], sizeof(space[1]), "%d", (int)(i + 1));
-        
+        util_snprintf(space[1], sizeof(space[1]), "%d", (int)(i + 1));
+
         con_out("test #%u %*s", i + 1, strlen(space[0]) - strlen(space[1]), "");
 
         util_debug("TEST", "executing task: %d: %s\n", i, task_tasks[i].tmpl->description);
@@ -1008,7 +1064,8 @@ void task_schedualize(size_t *pad) {
          * Generate a task from thin air if it requires execution in
          * the QCVM.
          */
-        execute = !!(!strcmp(task_tasks[i].tmpl->proceduretype, "-execute"));
+        execute = !! (!strcmp(task_tasks[i].tmpl->proceduretype, "-execute")) ||
+                     (!strcmp(task_tasks[i].tmpl->proceduretype, "-pp"));
 
         /*
          * We assume it compiled before we actually compiled :).  On error
@@ -1046,11 +1103,12 @@ void task_schedualize(size_t *pad) {
         }
 
         if (!task_tasks[i].compiled && strcmp(task_tasks[i].tmpl->proceduretype, "-fail")) {
-            con_err("failure: `%s` (failed to compile) see %s.stdout and %s.stderr [%s]\n",
+            con_out("failure:   `%s` %*s %*s\n",
                 task_tasks[i].tmpl->description,
-                task_tasks[i].tmpl->tempfilename,
-                task_tasks[i].tmpl->tempfilename,
-                task_tasks[i].tmpl->rulesfile
+                (pad[0] + pad[1] - strlen(task_tasks[i].tmpl->description)) + (strlen(task_tasks[i].tmpl->rulesfile) - pad[1]),
+                task_tasks[i].tmpl->rulesfile,
+                (pad[1] + pad[2] - strlen(task_tasks[i].tmpl->rulesfile)) + (strlen("(failed to compile)") - pad[2]),
+                "(failed to compile)"
             );
             continue;
         }
@@ -1062,21 +1120,31 @@ void task_schedualize(size_t *pad) {
                 task_tasks[i].tmpl->rulesfile,
                 (pad[1] + pad[2] - strlen(task_tasks[i].tmpl->rulesfile)) + (strlen(task_type(task_tasks[i].tmpl)) - pad[2]),
                 task_type(task_tasks[i].tmpl)
-                
+
             );
             continue;
         }
 
         /*
          * If we made it here that concludes the task is to be executed
-         * in the virtual machine.
+         * in the virtual machine (or the preprocessor output needs to
+         * be matched).
          */
-        if (!task_execute(task_tasks[i].tmpl, &match)) {
+        if (!task_trymatch(task_tasks[i].tmpl, &match)) {
             size_t d = 0;
 
-            con_err("failure: `%s` (invalid results from execution) [%s]\n",
+            con_out("failure:   `%s` %*s %*s\n",
                 task_tasks[i].tmpl->description,
-                task_tasks[i].tmpl->rulesfile
+                (pad[0] + pad[1] - strlen(task_tasks[i].tmpl->description)) + (strlen(task_tasks[i].tmpl->rulesfile) - pad[1]),
+                task_tasks[i].tmpl->rulesfile,
+                (pad[1] + pad[2] - strlen(task_tasks[i].tmpl->rulesfile)) + (strlen(
+                    (strcmp(task_tasks[i].tmpl->proceduretype, "-pp"))
+                        ? "(invalid results from execution)"
+                        : "(invalid results from preprocessing)"
+                ) - pad[2]),
+                (strcmp(task_tasks[i].tmpl->proceduretype, "-pp"))
+                    ? "(invalid results from execution)"
+                    : "(invalid results from preprocessing)"
             );
 
             /*
@@ -1084,7 +1152,7 @@ void task_schedualize(size_t *pad) {
              * handler for the all the given matches in the template file and
              * what was actually returned from executing.
              */
-            con_err("    Expected From %u Matches: (got %u Matches)\n",
+            con_out("    Expected From %u Matches: (got %u Matches)\n",
                 vec_size(task_tasks[i].tmpl->comparematch),
                 vec_size(match)
             );
@@ -1092,25 +1160,25 @@ void task_schedualize(size_t *pad) {
                 char  *select = task_tasks[i].tmpl->comparematch[d];
                 size_t length = 40 - strlen(select);
 
-                con_err("        Expected: \"%s\"", select);
+                con_out("        Expected: \"%s\"", select);
                 while (length --)
-                    con_err(" ");
-                con_err("| Got: \"%s\"\n", (d >= vec_size(match)) ? "<<nothing else to compare>>" : match[d]);
+                    con_out(" ");
+                con_out("| Got: \"%s\"\n", (d >= vec_size(match)) ? "<<nothing else to compare>>" : match[d]);
             }
 
             /*
              * Print the non-expected out (since we are simply not expecting it)
              * This will help track down bugs in template files that fail to match
              * something.
-             */  
+             */
             if (vec_size(match) > vec_size(task_tasks[i].tmpl->comparematch)) {
                 for (d = 0; d < vec_size(match) - vec_size(task_tasks[i].tmpl->comparematch); d++) {
-                    con_err("        Expected: Nothing                                   | Got: \"%s\"\n",
+                    con_out("        Expected: Nothing                                   | Got: \"%s\"\n",
                         match[d + vec_size(task_tasks[i].tmpl->comparematch)]
                     );
                 }
             }
-                    
+
 
             for (j = 0; j < vec_size(match); j++)
                 mem_d(match[j]);
@@ -1127,7 +1195,7 @@ void task_schedualize(size_t *pad) {
             task_tasks[i].tmpl->rulesfile,
             (pad[1] + pad[2] - strlen(task_tasks[i].tmpl->rulesfile)) + (strlen(task_type(task_tasks[i].tmpl))- pad[2]),
             task_type(task_tasks[i].tmpl)
-            
+
         );
     }
     mem_d(data);
@@ -1158,11 +1226,11 @@ GMQCC_WARN bool test_perform(const char *curdir, const char *defs) {
     /*
      * If the default definition file isn't set to anything.  We will
      * use the default_defs here, which is "defs.qc"
-     */   
+     */
     if (!defs) {
         defs = default_defs;
     }
-        
+
 
     task_precleanup(curdir);
     if (!task_propagate(curdir, pad, defs)) {