Upgrade to libxml 2.9.2 and libxslt 1.1.28

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.
  *
  * daniel@veillard.com
  */
 
-#ifdef HAVE_CONFIG_H
 #include "libxml.h"
-#else
 #include <stdio.h>
-#endif
 
 #if !defined(_WIN32) || defined(__CYGWIN__)
 #include <unistd.h>
 #endif
 #include <string.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 
 #include <libxml/parser.h>
@@ skipping 158 matching lines @@
 static void globfree(glob_t *pglob) {
     unsigned int i;
     if (pglob == NULL)
         return;
 
     for (i = 0;i < pglob->gl_pathc;i++) {
          if (pglob->gl_pathv[i] != NULL)
              free(pglob->gl_pathv[i]);
     }
 }
-#define vsnprintf _vsnprintf
-#define snprintf _snprintf
+
 #else
 #include <glob.h>
 #endif
 
 /************************************************************************
  *                                                                      *
  *              Libxml2 specific routines                               *
  *                                                                      *
  ************************************************************************/
 
@@ skipping 1467 matching lines @@
         ret = 0;
     } else
 #endif
     ret = xmlSAXUserParseFile(emptySAXHandler, NULL, filename);
     if (ret == XML_WAR_UNDECLARED_ENTITY) {
         fprintf(SAXdebug, "xmlSAXUserParseFile returned error %d\n", ret);
         ret = 0;
     }
     if (ret != 0) {
         fprintf(stderr, "Failed to parse %s\n", filename);
-        return(1);
+        ret = 1;
+        goto done;
     }
 #ifdef LIBXML_HTML_ENABLED
     if (options & XML_PARSE_HTML) {
         htmlSAXParseFile(filename, NULL, debugHTMLSAXHandler, NULL);
         ret = 0;
     } else
 #endif
     if (options & XML_PARSE_SAX1) {
         ret = xmlSAXUserParseFile(debugSAXHandler, NULL, filename);
     } else {
         ret = xmlSAXUserParseFile(debugSAX2Handler, NULL, filename);
     }
     if (ret == XML_WAR_UNDECLARED_ENTITY) {
         fprintf(SAXdebug, "xmlSAXUserParseFile returned error %d\n", ret);
         ret = 0;
     }
     fclose(SAXdebug);
     if (compareFiles(temp, result)) {
         fprintf(stderr, "Got a difference for %s\n", filename);
         ret = 1;
     }
+
+done:
     if (temp != NULL) {
         unlink(temp);
         free(temp);
     }
 
     /* switch back to structured error handling */
     xmlSetGenericErrorFunc(NULL, NULL);
     xmlSetStructuredErrorFunc(NULL, testStructuredErrorHandler);
 
     return(ret);
@@ skipping 372 matching lines @@
             empty,
             xmlTextReaderHasValue(reader));
     if (value == NULL)
         fprintf(out, "\n");
     else {
         fprintf(out, " %s\n", value);
     }
 }
 static int
 streamProcessTest(const char *filename, const char *result, const char *err,
-                  xmlTextReaderPtr reader, const char *rng) {
+                  xmlTextReaderPtr reader, const char *rng, int options) {
     int ret;
     char *temp = NULL;
     FILE *t = NULL;
 
     if (reader == NULL)
         return(-1);
 
     nb_tests++;
     if (result != NULL) {
         temp = resultFilename(filename, "", ".res");
@@ skipping 75 matching lines @@
  *
  * Returns 0 in case of success, an error code otherwise
  */
 static int
 streamParseTest(const char *filename, const char *result, const char *err,
                 int options) {
     xmlTextReaderPtr reader;
     int ret;
 
     reader = xmlReaderForFile(filename, NULL, options);
-    ret = streamProcessTest(filename, result, err, reader, NULL);
+    ret = streamProcessTest(filename, result, err, reader, NULL, options);
     xmlFreeTextReader(reader);
     return(ret);
 }
 
 /**
  * walkerParseTest:
  * @filename: the file to parse
  * @result: the file with expected result
  * @err: the file with error messages
  *
  * Parse a file using the walker, i.e. a reader built from a atree.
  *
  * Returns 0 in case of success, an error code otherwise
  */
 static int
 walkerParseTest(const char *filename, const char *result, const char *err,
                 int options) {
     xmlDocPtr doc;
     xmlTextReaderPtr reader;
     int ret;
 
     doc = xmlReadFile(filename, NULL, options);
     if (doc == NULL) {
         fprintf(stderr, "Failed to parse %s\n", filename);
         return(-1);
     }
     reader = xmlReaderWalker(doc);
-    ret = streamProcessTest(filename, result, err, reader, NULL);
+    ret = streamProcessTest(filename, result, err, reader, NULL, options);
     xmlFreeTextReader(reader);
     xmlFreeDoc(doc);
     return(ret);
 }
 
 /**
  * streamMemParseTest:
  * @filename: the file to parse
  * @result: the file with expected result
  * @err: the file with error messages
@@ skipping 11 matching lines @@
     int size;
 
     /*
      * load and parse the memory
      */
     if (loadMem(filename, &base, &size) != 0) {
         fprintf(stderr, "Failed to load %s\n", filename);
         return(-1);
     }
     reader = xmlReaderForMemory(base, size, filename, NULL, options);
-    ret = streamProcessTest(filename, result, err, reader, NULL);
+    ret = streamProcessTest(filename, result, err, reader, NULL, options);
     free((char *)base);
     xmlFreeTextReader(reader);
     return(ret);
 }
 #endif
 
 #ifdef LIBXML_XPATH_ENABLED
 #ifdef LIBXML_DEBUG_ENABLED
 /************************************************************************
  *                                                                      *
@@ skipping 454 matching lines @@
 
 static int urip_success = 1;
 static int urip_current = 0;
 static const char *urip_testURLs[] = {
     "urip://example.com/a b.html",
     "urip://example.com/a%20b.html",
     "file:///path/to/a b.html",
     "file:///path/to/a%20b.html",
     "/path/to/a b.html",
     "/path/to/a%20b.html",
-    "urip://example.com/résumé.html",
+    "urip://example.com/r" "\xe9" "sum" "\xe9" ".html",
     "urip://example.com/test?a=1&b=2%263&c=4#foo",
     NULL
 };
 static const char *urip_rcvsURLs[] = {
     /* it is an URI the strings must be escaped */
     "urip://example.com/a%20b.html",
     /* check that % escaping is not broken */
     "urip://example.com/a%20b.html",
     /* it's an URI path the strings must be escaped */
     "file:///path/to/a%20b.html",
@@ skipping 563 matching lines @@
             err[499] = 0;
         } else {
             fprintf(stderr, "don't know how to process %s\n", instance);
             continue;
         }
         reader = xmlReaderForFile(instance, NULL, options);
         if (reader == NULL) {
             fprintf(stderr, "Failed to build reder for %s\n", instance);
         }
         if (disable_err == 1)
-            ret = streamProcessTest(instance, result, NULL, reader, filename);
+            ret = streamProcessTest(instance, result, NULL, reader, filename,
+                                    options);
         else
-            ret = streamProcessTest(instance, result, err, reader, filename);
+            ret = streamProcessTest(instance, result, err, reader, filename,
+                                    options);
         xmlFreeTextReader(reader);
         if (ret != 0) {
             fprintf(stderr, "instance %s failed\n", instance);
             res = ret;
         }
     }
     globfree(&globbuf);
 
     return(res);
 }
@@ skipping 601 matching lines @@
         if (xmlGenericErrorContext != stderr) {
             printf("xmlGenericErrorContext override failed\n");
             okay = 0;
         }
     }
     if (okay == 0)
         return ((void *) Failed);
     return ((void *) Okay);
 }
 
-#if defined(linux) || defined(__sun) || defined(__APPLE_CC__)
-
-#include <pthread.h>
-
-static pthread_t tid[MAX_ARGC];
-
-static int
-testThread(void)
-{
-    unsigned int i, repeat;
-    unsigned int num_threads = sizeof(testfiles) / sizeof(testfiles[0]);
-    void *results[MAX_ARGC];
-    int ret;
-    int res = 0;
-
-    xmlInitParser();
-
-    for (repeat = 0; repeat < 500; repeat++) {
-        xmlLoadCatalog(catalog);
-        nb_tests++;
-
-        for (i = 0; i < num_threads; i++) {
-            results[i] = NULL;
-            tid[i] = (pthread_t) - 1;
-        }
-
-        for (i = 0; i < num_threads; i++) {
-            ret = pthread_create(&tid[i], 0, thread_specific_data,
-                                 (void *) testfiles[i]);
-            if (ret != 0) {
-                fprintf(stderr, "pthread_create failed\n");
-                return (1);
-            }
-        }
-        for (i = 0; i < num_threads; i++) {
-            ret = pthread_join(tid[i], &results[i]);
-            if (ret != 0) {
-                fprintf(stderr, "pthread_join failed\n");
-                return (1);
-            }
-        }
-
-        xmlCatalogCleanup();
-        for (i = 0; i < num_threads; i++)
-            if (results[i] != (void *) Okay) {
-                fprintf(stderr, "Thread %d handling %s failed\n",
-                        i, testfiles[i]);
-                res = 1;
-            }
-    }
-    return (res);
-}
-
-#elif defined WIN32
+#if defined WIN32
 #include <windows.h>
 #include <string.h>
 
 #define TEST_REPEAT_COUNT 500
 
 static HANDLE tid[MAX_ARGC];
 
 static DWORD WINAPI
 win32_thread_specific_data(void *private_data)
 {
@@ skipping 105 matching lines @@
         for (i = 0; i < num_threads; i++)
             if (results[i] != (void *) Okay) {
                 printf("Thread %d handling %s failed\n", i, testfiles[i]);
                 ret = B_ERROR;
             }
     }
     if (ret != B_OK)
         return(1);
     return (0);
 }
+
+#elif defined HAVE_PTHREAD_H
+#include <pthread.h>
+
+static pthread_t tid[MAX_ARGC];
+
+static int
+testThread(void)
+{
+    unsigned int i, repeat;
+    unsigned int num_threads = sizeof(testfiles) / sizeof(testfiles[0]);
+    void *results[MAX_ARGC];
+    int ret;
+    int res = 0;
+
+    xmlInitParser();
+
+    for (repeat = 0; repeat < 500; repeat++) {
+        xmlLoadCatalog(catalog);
+        nb_tests++;
+
+        for (i = 0; i < num_threads; i++) {
+            results[i] = NULL;
+            tid[i] = (pthread_t) - 1;
+        }
+
+        for (i = 0; i < num_threads; i++) {
+            ret = pthread_create(&tid[i], 0, thread_specific_data,
+                                 (void *) testfiles[i]);
+            if (ret != 0) {
+                fprintf(stderr, "pthread_create failed\n");
+                return (1);
+            }
+        }
+        for (i = 0; i < num_threads; i++) {
+            ret = pthread_join(tid[i], &results[i]);
+            if (ret != 0) {
+                fprintf(stderr, "pthread_join failed\n");
+                return (1);
+            }
+        }
+
+        xmlCatalogCleanup();
+        for (i = 0; i < num_threads; i++)
+            if (results[i] != (void *) Okay) {
+                fprintf(stderr, "Thread %d handling %s failed\n",
+                        i, testfiles[i]);
+                res = 1;
+            }
+    }
+    return (res);
+}
+
 #else
 static int
 testThread(void)
 {
     fprintf(stderr,
             "Specific platform thread support not detected\n");
     return (-1);
 }
 #endif
 static int
@@ skipping 72 matching lines @@
       XML_PARSE_HTML },
 #endif
 #endif
 #ifdef LIBXML_VALID_ENABLED
     { "Valid documents regression tests" ,
       errParseTest, "./test/VCM/*", NULL, NULL, NULL,
       XML_PARSE_DTDVALID },
     { "Validity checking regression tests" ,
       errParseTest, "./test/VC/*", "result/VC/", NULL, "",
       XML_PARSE_DTDVALID },
+#ifdef LIBXML_READER_ENABLED
+    { "Streaming validity checking regression tests" ,
+      streamParseTest, "./test/valid/*.xml", "result/valid/", NULL, ".err.rdr",
+      XML_PARSE_DTDVALID },
+    { "Streaming validity error checking regression tests" ,
+      streamParseTest, "./test/VC/*", "result/VC/", NULL, ".rdr",
+      XML_PARSE_DTDVALID },
+#endif
     { "General documents valid regression tests" ,
       errParseTest, "./test/valid/*", "result/valid/", "", ".err",
       XML_PARSE_DTDVALID },
 #endif
 #ifdef LIBXML_XINCLUDE_ENABLED
     { "XInclude regression tests" ,
       errParseTest, "./test/XInclude/docs/*", "result/XInclude/", "", NULL,
       /* Ignore errors at this point ".err", */
       XML_PARSE_XINCLUDE },
 #ifdef LIBXML_READER_ENABLED
@@ skipping 242 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