Roll libxml to bdec2183f34b37ee89ae1d330c6ad2bb4d76605f

third_party/libxml/src/runtest.c

 /*
  * runtest.c: C program to run libxml2 regression tests without
  *            requiring make or Python, and reducing platform dependancies
  *            to a strict minimum.
  *
  * To compile on Unixes:
  * cc -o runtest `xml2-config --cflags` runtest.c `xml2-config --libs` -lpthread
  *
  * See Copyright for the status of this software.
  *
@@ skipping 63 matching lines @@
 #include <libxml/catalog.h>
 #include <string.h>
 #endif
 
 /*
  * O_BINARY is just for Windows compatibility - if it isn't defined
  * on this system, avoid any compilation error
  */
 #ifdef  O_BINARY
 #define RD_FLAGS        O_RDONLY | O_BINARY
+#define WR_FLAGS        O_WRONLY | O_CREAT | O_TRUNC | O_BINARY
 #else
-#define RD_FLAGS        O_RDONLY
+#define RD_FLAGS        O_RDONLY
+#define WR_FLAGS        O_WRONLY | O_CREAT | O_TRUNC
 #endif
 
 typedef int (*functest) (const char *filename, const char *result,
                          const char *error, int options);
 
 typedef struct testDesc testDesc;
 typedef testDesc *testDescPtr;
 struct testDesc {
     const char *desc; /* descripton of the test */
     functest    func; /* function implementing the test */
     const char *in;   /* glob to path for input files */
     const char *out;  /* output directory */
     const char *suffix;/* suffix for output files */
     const char *err;  /* suffix for error output files */
     int     options;  /* parser options for the test */
 };
 
+static int update_results = 0;
 static int checkTestFile(const char *filename);
 
 #if defined(_WIN32) && !defined(__CYGWIN__)
 
 #include <windows.h>
 #include <io.h>
 
 typedef struct
 {
       size_t gl_pathc;    /* Count of paths matched so far  */
@@ skipping 484 matching lines @@
     if (!(buf.st_mode & _S_IFREG))
         return(0);
 #else
     if (!S_ISREG(buf.st_mode))
         return(0);
 #endif
 
     return(1);
 }
 
-static int compareFiles(const char *r1, const char *r2) {
+static int compareFiles(const char *r1 /* temp */, const char *r2 /* result */) {
     int res1, res2;
     int fd1, fd2;
     char bytes1[4096];
     char bytes2[4096];
 
+    if (update_results) {
+        fd1 = open(r1, RD_FLAGS);
+        if (fd1 < 0)
+            return(-1);
+        fd2 = open(r2, WR_FLAGS, 0644);
+        if (fd2 < 0) {
+            close(fd1);
+            return(-1);
+        }
+        do {
+            res1 = read(fd1, bytes1, 4096);
+            if (res1 <= 0)
+                break;
+            res2 = write(fd2, bytes1, res1);
+            if (res2 <= 0 || res2 != res1)
+                break;
+        } while (1);
+        close(fd2);
+        close(fd1);
+        return(res1 != 0);
+    }
+
     fd1 = open(r1, RD_FLAGS);
     if (fd1 < 0)
         return(-1);
     fd2 = open(r2, RD_FLAGS);
     if (fd2 < 0) {
         close(fd1);
         return(-1);
     }
     while (1) {
         res1 = read(fd1, bytes1, 4096);
@@ skipping 16 matching lines @@
     return(0);
 }
 
 static int compareFileMem(const char *filename, const char *mem, int size) {
     int res;
     int fd;
     char bytes[4096];
     int idx = 0;
     struct stat info;
 
-    if (stat(filename, &info) < 0)
+    if (update_results) {
+        fd = open(filename, WR_FLAGS, 0644);
+        if (fd < 0) {
+            fprintf(stderr, "failed to open %s for writing", filename);
+            return(-1);
+        }
+        res = write(fd, mem, size);
+        close(fd);
+        return(res != size);
+    }
+
+    if (stat(filename, &info) < 0) {
+        fprintf(stderr, "failed to stat %s\n", filename);
         return(-1);
-    if (info.st_size != size)
+    }
+    if (info.st_size != size) {
+        fprintf(stderr, "file %s is %ld bytes, result is %d bytes\n",
+                filename, info.st_size, size);
         return(-1);
+    }
     fd = open(filename, RD_FLAGS);
-    if (fd < 0)
+    if (fd < 0) {
+        fprintf(stderr, "failed to open %s for reading", filename);
         return(-1);
+    }
     while (idx < size) {
         res = read(fd, bytes, 4096);
         if (res <= 0)
             break;
         if (res + idx > size)
             break;
         if (memcmp(bytes, &mem[idx], res) != 0) {
             int ix;
             for (ix=0; ix<res; ix++)
                 if (bytes[ix] != mem[idx+ix])
                         break;
             fprintf(stderr,"Compare error at position %d\n", idx+ix);
             close(fd);
             return(1);
         }
         idx += res;
     }
     close(fd);
+    if (idx != size) {
+        fprintf(stderr,"Compare error index %d, size %d\n", idx, size);
+    }
     return(idx != size);
 }
 
 static int loadMem(const char *filename, const char **mem, int *size) {
     int fd, res;
     struct stat info;
     char *base;
     int siz = 0;
     if (stat(filename, &info) < 0)
         return(-1);
@@ skipping 1136 matching lines @@
 
 #ifdef LIBXML_HTML_ENABLED
     if (options & XML_PARSE_HTML)
         ctxt = htmlCreatePushParserCtxt(NULL, NULL, base + cur, 4, filename,
                                         XML_CHAR_ENCODING_NONE);
     else
 #endif
     ctxt = xmlCreatePushParserCtxt(NULL, NULL, base + cur, 4, filename);
     xmlCtxtUseOptions(ctxt, options);
     cur += 4;
-    while (cur < size) {
+    do {
         if (cur + 1024 >= size) {
 #ifdef LIBXML_HTML_ENABLED
             if (options & XML_PARSE_HTML)
                 htmlParseChunk(ctxt, base + cur, size - cur, 1);
             else
 #endif
             xmlParseChunk(ctxt, base + cur, size - cur, 1);
             break;
         } else {
 #ifdef LIBXML_HTML_ENABLED
             if (options & XML_PARSE_HTML)
                 htmlParseChunk(ctxt, base + cur, 1024, 0);
             else
 #endif
             xmlParseChunk(ctxt, base + cur, 1024, 0);
             cur += 1024;
         }
-    }
+    } while (cur < size);
     doc = ctxt->myDoc;
 #ifdef LIBXML_HTML_ENABLED
     if (options & XML_PARSE_HTML)
         res = 1;
     else
 #endif
     res = ctxt->wellFormed;
     xmlFreeParserCtxt(ctxt);
     free((char *)base);
     if (!res) {
         xmlFreeDoc(doc);
         fprintf(stderr, "Failed to parse %s\n", filename);
         return(-1);
     }
 #ifdef LIBXML_HTML_ENABLED
     if (options & XML_PARSE_HTML)
         htmlDocDumpMemory(doc, (xmlChar **) &base, &size);
     else
 #endif
     xmlDocDumpMemory(doc, (xmlChar **) &base, &size);
     xmlFreeDoc(doc);
     res = compareFileMem(result, base, size);
     if ((base == NULL) || (res != 0)) {
         if (base != NULL)
             xmlFree((char *)base);
-        fprintf(stderr, "Result for %s failed\n", filename);
+        fprintf(stderr, "Result for %s failed in %s\n", filename, result);
         return(-1);
     }
     xmlFree((char *)base);
     if (err != NULL) {
         res = compareFileMem(err, testErrors, testErrorsSize);
         if (res != 0) {
             fprintf(stderr, "Error for %s failed\n", filename);
             return(-1);
         }
     }
@@ skipping 34 matching lines @@
     unloadMem(base);
     if (doc == NULL) {
         return(1);
     }
     xmlDocDumpMemory(doc, (xmlChar **) &base, &size);
     xmlFreeDoc(doc);
     res = compareFileMem(result, base, size);
     if ((base == NULL) || (res != 0)) {
         if (base != NULL)
             xmlFree((char *)base);
-        fprintf(stderr, "Result for %s failed\n", filename);
+        fprintf(stderr, "Result for %s failed in %s\n", filename, result);
         return(-1);
     }
     xmlFree((char *)base);
     return(0);
 }
 
 /**
  * noentParseTest:
  * @filename: the file to parse
  * @result: the file with expected result
@@ skipping 90 matching lines @@
             size = 0;
         } else {
 #ifdef LIBXML_HTML_ENABLED
             if (options & XML_PARSE_HTML) {
                 htmlDocDumpMemory(doc, (xmlChar **) &base, &size);
             } else
 #endif
             xmlDocDumpMemory(doc, (xmlChar **) &base, &size);
         }
         res = compareFileMem(result, base, size);
+        if (res != 0) {
+            fprintf(stderr, "Result for %s failed in %s\n", filename, result);
+            return(-1);
+        }
     }
     if (doc != NULL) {
         if (base != NULL)
             xmlFree((char *)base);
         xmlFreeDoc(doc);
     }
-    if (res != 0) {
-        fprintf(stderr, "Result for %s failed\n", filename);
-        return(-1);
-    }
     if (err != NULL) {
         res = compareFileMem(err, testErrors, testErrorsSize);
         if (res != 0) {
             fprintf(stderr, "Error for %s failed\n", filename);
             return(-1);
         }
     } else if (options & XML_PARSE_DTDVALID) {
         if (testErrorsSize != 0)
             fprintf(stderr, "Validation for %s failed\n", filename);
     }
@@ skipping 92 matching lines @@
     }
     xmlGetWarningsDefaultValue = 0;
     if (t != NULL) {
         fclose(t);
         ret = compareFiles(temp, result);
         if (temp != NULL) {
             unlink(temp);
             free(temp);
         }
         if (ret) {
-            fprintf(stderr, "Result for %s failed\n", filename);
+            fprintf(stderr, "Result for %s failed in %s\n", filename, result);
             return(-1);
         }
     }
     if (err != NULL) {
         ret = compareFileMem(err, testErrors, testErrorsSize);
         if (ret != 0) {
             fprintf(stderr, "Error for %s failed\n", filename);
             printf("%s", testErrors);
             return(-1);
         }
@@ skipping 182 matching lines @@
                     expression) ;
             testXPath(expression, xptr, expr);
         }
     }
 
     fclose(input);
     fclose(xpathOutput);
     if (result != NULL) {
         ret = compareFiles(temp, result);
         if (ret) {
-            fprintf(stderr, "Result for %s failed\n", filename);
+            fprintf(stderr, "Result for %s failed in %s\n", filename, result);
         }
     }
 
     if (temp != NULL) {
         unlink(temp);
         free(temp);
     }
     return(ret);
 }
 
@@ skipping 150 matching lines @@
         free(temp);
         return(-1);
     }
 
     testXPath("id('bar')", 0, 0);
 
     fclose(xpathOutput);
     if (result != NULL) {
         ret = compareFiles(temp, result);
         if (ret) {
-            fprintf(stderr, "Result for %s failed\n", filename);
+            fprintf(stderr, "Result for %s failed in %s\n", filename, result);
             res = 1;
         }
     }
 
     if (temp != NULL) {
         unlink(temp);
         free(temp);
     }
     xmlFreeDoc(xpathDocument);
 
@@ skipping 107 matching lines @@
         nb_tests++;
         handleURI(str, base, o);
     }
 
     fclose(f);
     fclose(o);
 
     if (result != NULL) {
         ret = compareFiles(temp, result);
         if (ret) {
-            fprintf(stderr, "Result for %s failed\n", filename);
+            fprintf(stderr, "Result for %s failed in %s\n", filename, result);
             res = 1;
         }
     }
     if (err != NULL) {
         ret = compareFileMem(err, testErrors, testErrorsSize);
         if (ret != 0) {
             fprintf(stderr, "Error for %s failed\n", filename);
             res = 1;
         }
     }
@@ skipping 748 matching lines @@
     xmlDocPtr doc;
 
     len = strlen(filename);
     len -= 4;
     memcpy(xml, filename, len);
     xml[len] = 0;
     snprintf(result, 499, "result/pattern/%s", baseFilename(xml));
     result[499] = 0;
     memcpy(xml + len, ".xml", 5);
 
-    if (!checkTestFile(xml)) {
+    if (!checkTestFile(xml) && !update_results) {
         fprintf(stderr, "Missing xml file %s\n", xml);
         return(-1);
     }
-    if (!checkTestFile(result)) {
+    if (!checkTestFile(result) && !update_results) {
         fprintf(stderr, "Missing result file %s\n", result);
         return(-1);
     }
     f = fopen(filename, "rb");
     if (f == NULL) {
         fprintf(stderr, "Failed to open %s\n", filename);
         return(-1);
     }
     temp = resultFilename(filename, "", ".res");
     if (temp == NULL) {
@@ skipping 78 matching lines @@
             xmlFreePattern(patternc);
 
         }
     }
 
     fclose(f);
     fclose(o);
 
     ret = compareFiles(temp, result);
     if (ret) {
-        fprintf(stderr, "Result for %s failed\n", filename);
+        fprintf(stderr, "Result for %s failed in %s\n", filename, result);
         ret = 1;
     }
     if (temp != NULL) {
         unlink(temp);
         free(temp);
     }
     return(ret);
 }
 #endif /* READER */
 #endif /* PATTERN */
@@ skipping 251 matching lines @@
     char *ns = NULL;
     int ret = 0;
 
     base = baseFilename(filename);
     len = strlen(base);
     len -= 4;
     memcpy(prefix, base, len);
     prefix[len] = 0;
 
     snprintf(buf, 499, "result/c14n/%s/%s", subdir,prefix);
-    if (!checkTestFile(buf)) {
+    if (!checkTestFile(buf) && !update_results) {
         fprintf(stderr, "Missing result file %s", buf);
         return(-1);
     }
     result = strdup(buf);
     snprintf(buf, 499, "test/c14n/%s/%s.xpath", subdir,prefix);
     if (checkTestFile(buf)) {
         xpath = strdup(buf);
     }
     snprintf(buf, 499, "test/c14n/%s/%s.ns", subdir,prefix);
     if (checkTestFile(buf)) {
@@ skipping 528 matching lines @@
             if (tst->err != NULL) {
                 error = resultFilename(globbuf.gl_pathv[i], tst->out,
                                         tst->err);
                 if (error == NULL) {
                     fprintf(stderr, "Out of memory !\n");
                     fatalError();
                 }
             } else {
                 error = NULL;
             }
-            if ((result) &&(!checkTestFile(result))) {
+            if ((result) &&(!checkTestFile(result)) && !update_results) {
                 fprintf(stderr, "Missing result file %s\n", result);
-            } else if ((error) &&(!checkTestFile(error))) {
+            } else if ((error) &&(!checkTestFile(error)) && !update_results) {
                 fprintf(stderr, "Missing error file %s\n", error);
             } else {
                 mem = xmlMemUsed();
                 extraMemoryFromResolver = 0;
                 testErrorsSize = 0;
                 testErrors[0] = 0;
                 res = tst->func(globbuf.gl_pathv[i], result, error,
                                 tst->options | XML_PARSE_COMPACT);
                 xmlResetLastError();
                 if (res != 0) {
@@ skipping 63 matching lines @@
 int
 main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
     int i, a, ret = 0;
     int subset = 0;
 
     initializeLibxml2();
 
     for (a = 1; a < argc;a++) {
         if (!strcmp(argv[a], "-v"))
             verbose = 1;
+        else if (!strcmp(argv[a], "-u"))
+            update_results = 1;
         else if (!strcmp(argv[a], "-quiet"))
             tests_quiet = 1;
         else {
             for (i = 0; testDescriptions[i].func != NULL; i++) {
                 if (strstr(testDescriptions[i].desc, argv[a])) {
                     ret += runtest(i);
                     subset++;
                 }
             }
         }
@@ skipping 18 matching lines @@
     return(ret);
 }
 
 #else /* ! LIBXML_OUTPUT_ENABLED */
 int
 main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
     fprintf(stderr, "runtest requires output to be enabled in libxml2\n");
     return(1);
 }
 #endif