Update libxml to 2.7.7.

third_party/libxml/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 111 matching lines @@
                 int errfunc(const char *epath, int eerrno),
                 glob_t *pglob) {
     glob_t *ret;
     WIN32_FIND_DATA FindFileData;
     HANDLE hFind;
     unsigned int nb_paths = 0;
     char directory[500];
     int len;
 
     if ((pattern == NULL) || (pglob == NULL)) return(-1);
-    
+
     strncpy(directory, pattern, 499);
     for (len = strlen(directory);len >= 0;len--) {
         if (directory[len] == '/') {
             len++;
             directory[len] = 0;
             break;
         }
     }
     if (len <= 0)
         len = 0;
 
-    
+
     ret = pglob;
     memset(ret, 0, sizeof(glob_t));
-    
+
     hFind = FindFirstFileA(pattern, &FindFileData);
-    if (hFind == INVALID_HANDLE_VALUE) 
+    if (hFind == INVALID_HANDLE_VALUE)
         return(0);
     nb_paths = 20;
     ret->gl_pathv = (char **) malloc(nb_paths * sizeof(char *));
     if (ret->gl_pathv == NULL) {
         FindClose(hFind);
         return(-1);
     }
     strncpy(directory + len, FindFileData.cFileName, 499 - len);
     ret->gl_pathv[ret->gl_pathc] = strdup(directory);
     if (ret->gl_pathv[ret->gl_pathc] == NULL)
@@ skipping 14 matching lines @@
         if (ret->gl_pathv[ret->gl_pathc] == NULL)
             break;
         ret->gl_pathc++;
     }
     ret->gl_pathv[ret->gl_pathc] = NULL;
 
 done:
     FindClose(hFind);
     return(0);
 }
- 
+
 
 
 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
@@ skipping 13 matching lines @@
 fatalError(void) {
     fprintf(stderr, "Exitting tests on fatal error\n");
     exit(1);
 }
 
 /*
  * We need to trap calls to the resolver to not account memory for the catalog
  * which is shared to the current running test. We also don't want to have
  * network downloads modifying tests.
  */
-static xmlParserInputPtr 
+static xmlParserInputPtr
 testExternalEntityLoader(const char *URL, const char *ID,
                          xmlParserCtxtPtr ctxt) {
     xmlParserInputPtr ret;
 
     if (checkTestFile(URL)) {
         ret = xmlNoNetExternalEntityLoader(URL, ID, ctxt);
     } else {
         int memused = xmlMemUsed();
         ret = xmlNoNetExternalEntityLoader(URL, ID, ctxt);
         extraMemoryFromResolver += xmlMemUsed() - memused;
     }
-      
+
     return(ret);
 }
 
 /*
  * Trapping the error messages at the generic level to grab the equivalent of
  * stderr messages on CLI tools.
  */
 static char testErrors[32769];
 static int testErrorsSize = 0;
 
@@ skipping 37 matching lines @@
         testErrors[testErrorsSize] = 0;
     } else {
         testErrorsSize += res;
     }
     testErrors[testErrorsSize] = 0;
 }
 
 /**
  * xmlParserPrintFileContext:
  * @input:  an xmlParserInputPtr input
- * 
+ *
  * Displays current context within the input content for error tracking
  */
 
 static void
-xmlParserPrintFileContextInternal(xmlParserInputPtr input , 
+xmlParserPrintFileContextInternal(xmlParserInputPtr input ,
                 xmlGenericErrorFunc chanl, void *data ) {
     const xmlChar *cur, *base;
     unsigned int n, col;        /* GCC warns if signed, because compared with sizeof() */
     xmlChar  content[81]; /* space for 80 chars + line terminator */
     xmlChar *ctnt;
 
     if (input == NULL) return;
     cur = input->cur;
     base = input->base;
     /* skip backwards over any end-of-lines */
     while ((cur > base) && ((*(cur) == '\n') || (*(cur) == '\r'))) {
         cur--;
     }
     n = 0;
     /* search backwards for beginning-of-line (to max buff size) */
-    while ((n++ < (sizeof(content)-1)) && (cur > base) && 
-           (*(cur) != '\n') && (*(cur) != '\r'))
+    while ((n++ < (sizeof(content)-1)) && (cur > base) &&
+   (*(cur) != '\n') && (*(cur) != '\r'))
         cur--;
     if ((*(cur) == '\n') || (*(cur) == '\r')) cur++;
     /* calculate the error position in terms of the current position */
     col = input->cur - cur;
     /* search forward for end-of-line (to max buff size) */
     n = 0;
     ctnt = content;
     /* copy selected text to our buffer */
-    while ((*cur != 0) && (*(cur) != '\n') && 
-           (*(cur) != '\r') && (n < sizeof(content)-1)) {
+    while ((*cur != 0) && (*(cur) != '\n') &&
+   (*(cur) != '\r') && (n < sizeof(content)-1)) {
                 *ctnt++ = *cur++;
         n++;
     }
     *ctnt = 0;
     /* print out the selected text */
     chanl(data ,"%s\n", content);
     /* create blank line with problem pointer */
     n = 0;
     ctnt = content;
     /* (leave buffer space for pointer + line terminator) */
@@ skipping 228 matching lines @@
     const char *base;
     char res[500];
     char suffixbuff[500];
 
 /*************
     if ((filename[0] == 't') && (filename[1] == 'e') &&
         (filename[2] == 's') && (filename[3] == 't') &&
         (filename[4] == '/'))
         filename = &filename[5];
  *************/
-    
+
     base = baseFilename(filename);
     if (suffix == NULL)
         suffix = ".tmp";
     if (out == NULL)
         out = "";
 
     strncpy(suffixbuff,suffix,499);
 #ifdef VMS
     if(strstr(base,".") && suffixbuff[0]=='.')
       suffixbuff[0]='_';
@@ skipping 56 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 (stat(filename, &info) < 0)
         return(-1);
     if (info.st_size != size)
         return(-1);
     fd = open(filename, RD_FLAGS);
     if (fd < 0)
         return(-1);
     while (idx < size) {
         res = read(fd, bytes, 4096);
         if (res <= 0)
             break;
-        if (res + idx > size) 
+        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);
     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) 
+    if (stat(filename, &info) < 0)
         return(-1);
     base = malloc(info.st_size + 1);
     if (base == NULL)
         return(-1);
     if ((fd = open(filename, RD_FLAGS)) < 0) {
         free(base);
         return(-1);
     }
     while ((res = read(fd, &base[siz], info.st_size - siz)) > 0) {
         siz += res;
@@ skipping 189 matching lines @@
  * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
  */
 static xmlParserInputPtr
 resolveEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *publicId, const xmlChar *systemId)
 {
     callbacks++;
     if (quiet)
         return(NULL);
     /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
 
-    
+
     fprintf(SAXdebug, "SAX.resolveEntity(");
     if (publicId != NULL)
         fprintf(SAXdebug, "%s", (char *)publicId);
     else
         fprintf(SAXdebug, " ");
     if (systemId != NULL)
         fprintf(SAXdebug, ", %s)\n", (char *)systemId);
     else
         fprintf(SAXdebug, ", )\n");
 /*********
@@ skipping 39 matching lines @@
     if (quiet)
         return(NULL);
     fprintf(SAXdebug, "SAX.getParameterEntity(%s)\n", name);
     return(NULL);
 }
 
 
 /**
  * entityDeclDebug:
  * @ctxt:  An XML parser context
- * @name:  the entity name 
- * @type:  the entity type 
+ * @name:  the entity name
+ * @type:  the entity type
  * @publicId: The public ID of the entity
  * @systemId: The system ID of the entity
  * @content: the entity value (without processing).
  *
  * An entity definition has been parsed
  */
 static void
 entityDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, int type,
           const xmlChar *publicId, const xmlChar *systemId, xmlChar *content)
 {
 const xmlChar *nullstr = BAD_CAST "(null)";
     /* not all libraries handle printing null pointers nicely */
     if (publicId == NULL)
         publicId = nullstr;
     if (systemId == NULL)
         systemId = nullstr;
     if (content == NULL)
         content = (xmlChar *)nullstr;
     callbacks++;
     if (quiet)
         return;
     fprintf(SAXdebug, "SAX.entityDecl(%s, %d, %s, %s, %s)\n",
             name, type, publicId, systemId, content);
 }
 
 /**
  * attributeDeclDebug:
  * @ctxt:  An XML parser context
- * @name:  the attribute name 
- * @type:  the attribute type 
+ * @name:  the attribute name
+ * @type:  the attribute type
  *
  * An attribute definition has been parsed
  */
 static void
 attributeDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar * elem,
                    const xmlChar * name, int type, int def,
                    const xmlChar * defaultValue, xmlEnumerationPtr tree)
 {
     callbacks++;
     if (quiet)
         return;
     if (defaultValue == NULL)
         fprintf(SAXdebug, "SAX.attributeDecl(%s, %s, %d, %d, NULL, ...)\n",
                 elem, name, type, def);
     else
         fprintf(SAXdebug, "SAX.attributeDecl(%s, %s, %d, %d, %s, ...)\n",
                 elem, name, type, def, defaultValue);
     xmlFreeEnumeration(tree);
 }
 
 /**
  * elementDeclDebug:
  * @ctxt:  An XML parser context
- * @name:  the element name 
- * @type:  the element type 
+ * @name:  the element name
+ * @type:  the element type
  * @content: the element value (without processing).
  *
  * An element definition has been parsed
  */
 static void
 elementDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, int type,
             xmlElementContentPtr content ATTRIBUTE_UNUSED)
 {
     callbacks++;
     if (quiet)
@@ skipping 165 matching lines @@
     output[i] = 0;
 
     fprintf(SAXdebug, "SAX.characters(%s, %d)\n", output, len);
 }
 
 /**
  * referenceDebug:
  * @ctxt:  An XML parser context
  * @name:  The entity name
  *
- * called when an entity reference is detected. 
+ * called when an entity reference is detected.
  */
 static void
 referenceDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
 {
     callbacks++;
     if (quiet)
         return;
     fprintf(SAXdebug, "SAX.reference(%s)\n", name);
 }
 
@@ skipping 215 matching lines @@
     fprintf(SAXdebug, "SAX.startElementNs(%s", (char *) localname);
     if (prefix == NULL)
         fprintf(SAXdebug, ", NULL");
     else
         fprintf(SAXdebug, ", %s", (char *) prefix);
     if (URI == NULL)
         fprintf(SAXdebug, ", NULL");
     else
         fprintf(SAXdebug, ", '%s'", (char *) URI);
     fprintf(SAXdebug, ", %d", nb_namespaces);
-    
+
     if (namespaces != NULL) {
         for (i = 0;i < nb_namespaces * 2;i++) {
             fprintf(SAXdebug, ", xmlns");
             if (namespaces[i] != NULL)
                 fprintf(SAXdebug, ":%s", namespaces[i]);
             i++;
             fprintf(SAXdebug, "='%s'", namespaces[i]);
         }
     }
     fprintf(SAXdebug, ", %d, %d", nb_attributes, nb_defaulted);
@@ skipping 252 matching lines @@
         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;
-    } else
-    unlink(temp);
-    free(temp);
-    
+    }
+    if (temp != NULL) {
+        unlink(temp);
+        free(temp);
+    }
+
     /* switch back to structured error handling */
     xmlSetGenericErrorFunc(NULL, NULL);
     xmlSetStructuredErrorFunc(NULL, testStructuredErrorHandler);
 
     return(ret);
 }
 #endif
 
 /************************************************************************
  *                                                                      *
@@ skipping 51 matching lines @@
     doc = xmlReadFile(temp, NULL, 0);
 #endif
     if (doc == NULL)
         return(1);
     xmlSaveFile(temp, doc);
     if (compareFiles(temp, result)) {
         res = 1;
     }
     xmlFreeDoc(doc);
 
-    unlink(temp);
-    free(temp);
+    if (temp != NULL) {
+        unlink(temp);
+        free(temp);
+    }
     return(res);
 }
 
 #ifdef LIBXML_PUSH_ENABLED
 /**
  * pushParseTest:
  * @filename: the file to parse
  * @result: the file with expected result
  * @err: the file with error messages: unused
  *
@@ skipping 13 matching lines @@
     int cur = 0;
 
     nb_tests++;
     /*
      * load the document in memory and work from there.
      */
     if (loadMem(filename, &base, &size) != 0) {
         fprintf(stderr, "Failed to load %s\n", filename);
         return(-1);
     }
-    
+
 #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) {
@@ skipping 76 matching lines @@
     int size, res;
 
     nb_tests++;
     /*
      * load and parse the memory
      */
     if (loadMem(filename, &base, &size) != 0) {
         fprintf(stderr, "Failed to load %s\n", filename);
         return(-1);
     }
-    
+
     doc = xmlReadMemory(base, size, filename, NULL, 0);
     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)
@@ skipping 48 matching lines @@
      */
     doc = xmlReadFile(filename, NULL, options);
     if (doc == NULL)
         return(1);
     xmlSaveFile(temp, doc);
     if (compareFiles(temp, result)) {
         res = 1;
     }
     xmlFreeDoc(doc);
 
-    unlink(temp);
-    free(temp);
+    if (temp != NULL) {
+        unlink(temp);
+        free(temp);
+    }
     return(res);
 }
 
 /**
  * errParseTest:
  * @filename: the file to parse
  * @result: the file with expected result
  * @err: the file with error messages
  *
  * Parse a file using the xmlReadFile API and check for errors.
@@ skipping 74 matching lines @@
 
     type = xmlTextReaderNodeType(reader);
     empty = xmlTextReaderIsEmptyElement(reader);
 
     name = xmlTextReaderConstName(reader);
     if (name == NULL)
         name = BAD_CAST "--";
 
     value = xmlTextReaderConstValue(reader);
 
-    
-    fprintf(out, "%d %d %s %d %d", 
+
+    fprintf(out, "%d %d %s %d %d",
             xmlTextReaderDepth(reader),
             type,
             name,
             empty,
             xmlTextReaderHasValue(reader));
     if (value == NULL)
         fprintf(out, "\n");
     else {
         fprintf(out, " %s\n", value);
     }
@@ skipping 22 matching lines @@
             return(-1);
         }
     }
 #ifdef LIBXML_SCHEMAS_ENABLED
     if (rng != NULL) {
         ret = xmlTextReaderRelaxNGValidate(reader, rng);
         if (ret < 0) {
             testErrorHandler(NULL, "Relax-NG schema %s failed to compile\n",
                              rng);
             fclose(t);
-            unlink(temp);
-            free(temp);
+            if (temp != NULL) {
+                unlink(temp);
+                free(temp);
+            }
             return(0);
         }
     }
 #endif
     xmlGetWarningsDefaultValue = 1;
     ret = xmlTextReaderRead(reader);
     while (ret == 1) {
         if ((t != NULL) && (rng == NULL))
             processNode(t, reader);
         ret = xmlTextReaderRead(reader);
     }
     if (ret != 0) {
         testErrorHandler(NULL, "%s : failed to parse\n", filename);
     }
     if (rng != NULL) {
         if (xmlTextReaderIsValid(reader) != 1) {
             testErrorHandler(NULL, "%s fails to validate\n", filename);
         } else {
             testErrorHandler(NULL, "%s validates\n", filename);
         }
     }
     xmlGetWarningsDefaultValue = 0;
     if (t != NULL) {
         fclose(t);
         ret = compareFiles(temp, result);
-        unlink(temp);
-        free(temp);
+        if (temp != NULL) {
+            unlink(temp);
+            free(temp);
+        }
         if (ret) {
             fprintf(stderr, "Result for %s failed\n", filename);
             return(-1);
         }
     }
     if (err != NULL) {
         ret = compareFileMem(err, testErrors, testErrorsSize);
         if (ret != 0) {
             fprintf(stderr, "Error for %s failed\n", filename);
             printf("%s", testErrors);
@@ skipping 96 matching lines @@
  *                                                                      *
  ************************************************************************/
 
 static FILE *xpathOutput;
 static xmlDocPtr xpathDocument;
 
 static void
 testXPath(const char *str, int xptr, int expr) {
     xmlXPathObjectPtr res;
     xmlXPathContextPtr ctxt;
-    
+
     nb_tests++;
 #if defined(LIBXML_XPTR_ENABLED)
     if (xptr) {
         ctxt = xmlXPtrNewContext(xpathDocument, NULL, NULL);
         res = xmlXPtrEval(BAD_CAST str, ctxt);
     } else {
 #endif
         ctxt = xmlXPathNewContext(xpathDocument);
         ctxt->node = xmlDocGetRootElement(xpathDocument);
         if (expr)
@@ skipping 50 matching lines @@
     input = fopen(filename, "rb");
     if (input == NULL) {
         xmlGenericError(xmlGenericErrorContext,
                 "Cannot open %s for reading\n", filename);
         free(temp);
         return(-1);
     }
     while (fgets(expression, 4500, input) != NULL) {
         len = strlen(expression);
         len--;
-        while ((len >= 0) && 
+        while ((len >= 0) &&
                ((expression[len] == '\n') || (expression[len] == '\t') ||
                 (expression[len] == '\r') || (expression[len] == ' '))) len--;
-        expression[len + 1] = 0;      
+        expression[len + 1] = 0;
         if (len >= 0) {
             fprintf(xpathOutput,
                     "\n========================\nExpression: %s\n",
                     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);
         }
     }
 
-    unlink(temp);
-    free(temp);
+    if (temp != NULL) {
+        unlink(temp);
+        free(temp);
+    }
     return(ret);
 }
 
 /**
  * xpathExprTest:
  * @filename: the file to parse
  * @result: the file with expected result
  * @err: the file with error messages
  *
  * Parse a file containing XPath standalone expressions and evaluate them
@@ skipping 148 matching lines @@
 
     fclose(xpathOutput);
     if (result != NULL) {
         ret = compareFiles(temp, result);
         if (ret) {
             fprintf(stderr, "Result for %s failed\n", filename);
             res = 1;
         }
     }
 
-    unlink(temp);
-    free(temp);
+    if (temp != NULL) {
+        unlink(temp);
+        free(temp);
+    }
     xmlFreeDoc(xpathDocument);
 
     if (err != NULL) {
         ret = compareFileMem(err, testErrors, testErrorsSize);
         if (ret != 0) {
             fprintf(stderr, "Error for %s failed\n", filename);
             res = 1;
         }
     }
     return(res);
@@ skipping 65 matching lines @@
     o = fopen(temp, "wb");
     if (o == NULL) {
         fprintf(stderr, "failed to open output file %s\n", temp);
         free(temp);
         return(-1);
     }
     f = fopen(filename, "rb");
     if (f == NULL) {
         fprintf(stderr, "failed to open input file %s\n", filename);
         fclose(o);
-        unlink(temp);
-        free(temp);
+        if (temp != NULL) {
+            unlink(temp);
+            free(temp);
+        }
         return(-1);
     }
 
     while (1) {
         /*
          * read one line in string buffer.
          */
         if (fgets (&str[0], sizeof (str) - 1, f) == NULL)
            break;
 
@@ skipping 22 matching lines @@
         }
     }
     if (err != NULL) {
         ret = compareFileMem(err, testErrors, testErrorsSize);
         if (ret != 0) {
             fprintf(stderr, "Error for %s failed\n", filename);
             res = 1;
         }
     }
 
-    unlink(temp);
-    free(temp);
+    if (temp != NULL) {
+        unlink(temp);
+        free(temp);
+    }
     return(res);
 }
 
 /**
  * uriParseTest:
  * @filename: the file to parse
  * @result: the file with expected result
  * @err: the file with error messages
  *
  * Parse a file containing URI and check for errors
@@ skipping 253 matching lines @@
         fprintf(schemasOutput, "%s validation generated an internal error\n",
                filename);
     }
     fclose(schemasOutput);
     if (result) {
         if (compareFiles(temp, result)) {
             fprintf(stderr, "Result for %s on %s failed\n", filename, sch);
             ret = 1;
         }
     }
-    unlink(temp);
-    free(temp);
+    if (temp != NULL) {
+        unlink(temp);
+        free(temp);
+    }
 
     if ((validResult != 0) && (err != NULL)) {
         if (compareFileMem(err, testErrors, testErrorsSize)) {
             fprintf(stderr, "Error for %s on %s failed\n", filename, sch);
             ret = 1;
         }
     }
 
     xmlSchemaFreeValidCtxt(ctxt);
     xmlFreeDoc(doc);
@@ skipping 145 matching lines @@
     ret = xmlRelaxNGValidateDoc(ctxt, doc);
     if (ret == 0) {
         testErrorHandler(NULL, "%s validates\n", filename);
     } else if (ret > 0) {
         testErrorHandler(NULL, "%s fails to validate\n", filename);
     } else {
         testErrorHandler(NULL, "%s validation generated an internal error\n",
                filename);
     }
     fclose(schemasOutput);
+    ret = 0;
     if (result) {
         if (compareFiles(temp, result)) {
             fprintf(stderr, "Result for %s on %s failed\n", filename, sch);
             ret = 1;
         }
     }
-    unlink(temp);
-    free(temp);
+    if (temp != NULL) {
+        unlink(temp);
+        free(temp);
+    }
 
     if (err != NULL) {
         if (compareFileMem(err, testErrors, testErrorsSize)) {
             fprintf(stderr, "Error for %s on %s failed\n", filename, sch);
             ret = 1;
             printf("%s", testErrors);
         }
     }
 
 
@@ skipping 14 matching lines @@
 static int
 rngTest(const char *filename,
             const char *resul ATTRIBUTE_UNUSED,
             const char *errr ATTRIBUTE_UNUSED,
             int options) {
     const char *base = baseFilename(filename);
     const char *base2;
     const char *instance;
     xmlRelaxNGParserCtxtPtr ctxt;
     xmlRelaxNGPtr schemas;
-    int res = 0, len, ret;
+    int res = 0, len, ret = 0;
     char pattern[500];
     char prefix[500];
     char result[500];
     char err[500];
     glob_t globbuf;
     size_t i;
     char count = 0;
 
     /* first compile the schemas if possible */
     ctxt = xmlRelaxNGNewParserCtxt(filename);
@@ skipping 44 matching lines @@
             nb_tests++;
             ret = rngOneTest(filename, instance, result, err,
                                  options, schemas);
             if (res != 0)
                 ret = res;
         }
     }
     globfree(&globbuf);
     xmlRelaxNGFree(schemas);
 
-    return(res);
+    return(ret);
 }
 
 #ifdef LIBXML_READER_ENABLED
 /**
  * rngStreamTest:
  * @filename: the schemas file
  * @result: the file with expected result
  * @err: the file with error messages
  *
- * Parse a set of files with streaming, applying an RNG schemas 
+ * Parse a set of files with streaming, applying an RNG schemas
  *
  * Returns 0 in case of success, an error code otherwise
  */
 static int
 rngStreamTest(const char *filename,
             const char *resul ATTRIBUTE_UNUSED,
             const char *errr ATTRIBUTE_UNUSED,
             int options) {
     const char *base = baseFilename(filename);
     const char *base2;
@@ skipping 19 matching lines @@
     }
     len -= 4; /* remove trailing .rng */
     memcpy(prefix, base, len);
     prefix[len] = 0;
 
     /*
      * strictly unifying the error messages is nearly impossible this
      * hack is also done in the Makefile
      */
     if ((!strcmp(prefix, "tutor10_1")) || (!strcmp(prefix, "tutor10_2")) ||
-        (!strcmp(prefix, "tutor3_2")) || (!strcmp(prefix, "307377"))) 
+        (!strcmp(prefix, "tutor3_2")) || (!strcmp(prefix, "307377")) ||
+        (!strcmp(prefix, "tutor8_2")))
         disable_err = 1;
 
     snprintf(pattern, 499, "./test/relaxng/%s_?.xml", prefix);
     pattern[499] = 0;
 
     globbuf.gl_offs = 0;
     glob(pattern, GLOB_DOOFFS, NULL, &globbuf);
     for (i = 0;i < globbuf.gl_pathc;i++) {
         testErrorsSize = 0;
         testErrors[0] = 0;
@@ skipping 43 matching lines @@
  ************************************************************************/
 static void patternNode(FILE *out, xmlTextReaderPtr reader,
                         const char *pattern, xmlPatternPtr patternc,
                         xmlStreamCtxtPtr patstream) {
     xmlChar *path = NULL;
     int match = -1;
     int type, empty;
 
     type = xmlTextReaderNodeType(reader);
     empty = xmlTextReaderIsEmptyElement(reader);
-        
+
     if (type == XML_READER_TYPE_ELEMENT) {
         /* do the check only on element start */
         match = xmlPatternMatch(patternc, xmlTextReaderCurrentNode(reader));
 
         if (match) {
             path = xmlGetNodePath(xmlTextReaderCurrentNode(reader));
             fprintf(out, "Node %s matches pattern %s\n", path, pattern);
         }
     }
     if (patstream != NULL) {
@@ skipping 11 matching lines @@
                 if (path == NULL) {
                     path = xmlGetNodePath(
                                    xmlTextReaderCurrentNode(reader));
                 }
                 fprintf(out,
                         "xmlPatternMatch and xmlStreamPush disagree\n");
                 fprintf(out,
                         "  pattern %s node %s\n",
                         pattern, path);
             }
-            
 
-        } 
+
+        }
         if ((type == XML_READER_TYPE_END_ELEMENT) ||
             ((type == XML_READER_TYPE_ELEMENT) && (empty))) {
             ret = xmlStreamPop(patstream);
             if (ret < 0) {
                 fprintf(out, "xmlStreamPop() failure\n");
                 xmlFreeStreamCtxt(patstream);
                 patstream = NULL;
             }
         }
     }
     if (path != NULL)
         xmlFree(path);
 }
 
 /**
  * patternTest:
  * @filename: the schemas file
  * @result: the file with expected result
  * @err: the file with error messages
  *
- * Parse a set of files with streaming, applying an RNG schemas 
+ * Parse a set of files with streaming, applying an RNG schemas
  *
  * Returns 0 in case of success, an error code otherwise
  */
 static int
 patternTest(const char *filename,
             const char *resul ATTRIBUTE_UNUSED,
             const char *err ATTRIBUTE_UNUSED,
             int options) {
     xmlPatternPtr patternc = NULL;
     xmlStreamCtxtPtr patstream = NULL;
@@ skipping 66 matching lines @@
             const xmlChar *namespaces[22];
             int j;
             xmlNsPtr ns;
 
             root = xmlDocGetRootElement(doc);
             for (ns = root->nsDef, j = 0;ns != NULL && j < 20;ns=ns->next) {
                 namespaces[j++] = ns->href;
                 namespaces[j++] = ns->prefix;
             }
             namespaces[j++] = NULL;
-            namespaces[j++] = NULL;
+            namespaces[j] = NULL;
 
             patternc = xmlPatterncompile((const xmlChar *) str, doc->dict,
                                          0, &namespaces[0]);
             if (patternc == NULL) {
                 testErrorHandler(NULL,
                         "Pattern %s failed to compile\n", str);
                 xmlFreeDoc(doc);
                 ret = 1;
                 continue;
             }
@@ skipping 27 matching lines @@
     }
 
     fclose(f);
     fclose(o);
 
     ret = compareFiles(temp, result);
     if (ret) {
         fprintf(stderr, "Result for %s failed\n", filename);
         ret = 1;
     }
-    unlink(temp);
-    free(temp);
+    if (temp != NULL) {
+        unlink(temp);
+        free(temp);
+    }
     return(ret);
 }
 #endif /* READER */
 #endif /* PATTERN */
 #ifdef LIBXML_C14N_ENABLED
 /************************************************************************
  *                                                                      *
  *                      Canonicalization tests                          *
  *                                                                      *
  ************************************************************************/
 static xmlXPathObjectPtr
 load_xpath_expr (xmlDocPtr parent_doc, const char* filename) {
-    xmlXPathObjectPtr xpath; 
+    xmlXPathObjectPtr xpath;
     xmlDocPtr doc;
     xmlChar *expr;
-    xmlXPathContextPtr ctx; 
+    xmlXPathContextPtr ctx;
     xmlNodePtr node;
     xmlNsPtr ns;
-    
+
     /*
      * load XPath expr as a file
      */
     xmlLoadExtDtdDefaultValue = XML_DETECT_IDS | XML_COMPLETE_ATTRS;
     xmlSubstituteEntitiesDefault(1);
 
     doc = xmlReadFile(filename, NULL, XML_PARSE_DTDATTR | XML_PARSE_NOENT);
     if (doc == NULL) {
         fprintf(stderr, "Error: unable to parse file \"%s\"\n", filename);
         return(NULL);
     }
-    
+
     /*
      * Check the document is of the right kind
-     */    
+     */
     if(xmlDocGetRootElement(doc) == NULL) {
         fprintf(stderr,"Error: empty document for file \"%s\"\n", filename);
         xmlFreeDoc(doc);
         return(NULL);
     }
 
     node = doc->children;
     while(node != NULL && !xmlStrEqual(node->name, (const xmlChar *)"XPath")) {
         node = node->next;
     }
-    
-    if(node == NULL) {   
+
+    if(node == NULL) {
         fprintf(stderr,"Error: XPath element expected in the file  \"%s\"\n", filename);
         xmlFreeDoc(doc);
         return(NULL);
     }
 
     expr = xmlNodeGetContent(node);
     if(expr == NULL) {
         fprintf(stderr,"Error: XPath content element is NULL \"%s\"\n", filename);
         xmlFreeDoc(doc);
         return(NULL);
     }
 
     ctx = xmlXPathNewContext(parent_doc);
     if(ctx == NULL) {
         fprintf(stderr,"Error: unable to create new context\n");
-        xmlFree(expr); 
-        xmlFreeDoc(doc); 
+        xmlFree(expr);
+        xmlFreeDoc(doc);
         return(NULL);
     }
 
     /*
      * Register namespaces
      */
     ns = node->nsDef;
     while(ns != NULL) {
         if(xmlXPathRegisterNs(ctx, ns->prefix, ns->href) != 0) {
             fprintf(stderr,"Error: unable to register NS with prefix=\"%s\" and href=\"%s\"\n", ns->prefix, ns->href);
-            xmlFree(expr); 
-            xmlXPathFreeContext(ctx); 
-            xmlFreeDoc(doc); 
+    xmlFree(expr);
+            xmlXPathFreeContext(ctx);
+            xmlFreeDoc(doc);
             return(NULL);
         }
         ns = ns->next;
     }
 
-    /*  
+    /*
      * Evaluate xpath
      */
     xpath = xmlXPathEvalExpression(expr, ctx);
     if(xpath == NULL) {
         fprintf(stderr,"Error: unable to evaluate xpath expression\n");
-        xmlFree(expr); 
-        xmlXPathFreeContext(ctx); 
-        xmlFreeDoc(doc); 
+xmlFree(expr);
+        xmlXPathFreeContext(ctx);
+        xmlFreeDoc(doc);
         return(NULL);
     }
 
     /* print_xpath_nodes(xpath->nodesetval); */
 
-    xmlFree(expr); 
-    xmlXPathFreeContext(ctx); 
-    xmlFreeDoc(doc); 
+    xmlFree(expr);
+    xmlXPathFreeContext(ctx);
+    xmlFreeDoc(doc);
     return(xpath);
 }
 
 /*
  * Macro used to grow the current buffer.
  */
 #define xxx_growBufferReentrant() {                                             \
     buffer_size *= 2;                                                   \
     buffer = (xmlChar **)                                               \
-                xmlRealloc(buffer, buffer_size * sizeof(xmlChar*));     \
+        xmlRealloc(buffer, buffer_size * sizeof(xmlChar*));     \
     if (buffer == NULL) {                                               \
         perror("realloc failed");                                       \
         return(NULL);                                                   \
     }                                                                   \
 }
 
 static xmlChar **
 parse_list(xmlChar *str) {
     xmlChar **buffer;
     xmlChar **out = NULL;
     int buffer_size = 0;
     int len;
 
     if(str == NULL) {
         return(NULL);
     }
 
     len = xmlStrlen(str);
     if((str[0] == '\'') && (str[len - 1] == '\'')) {
         str[len - 1] = '\0';
         str++;
-        len -= 2;
     }
     /*
      * allocate an translation buffer.
      */
     buffer_size = 1000;
     buffer = (xmlChar **) xmlMalloc(buffer_size * sizeof(xmlChar*));
     if (buffer == NULL) {
         perror("malloc failed");
         return(NULL);
     }
     out = buffer;
-    
+
     while(*str != '\0') {
         if (out - buffer > buffer_size - 10) {
             int indx = out - buffer;
 
             xxx_growBufferReentrant();
             out = &buffer[indx];
         }
         (*out++) = str;
         while(*str != ',' && *str != '\0') ++str;
         if(*str == ',') *(str++) = '\0';
     }
     (*out) = NULL;
     return buffer;
 }
 
-static int 
-c14nRunTest(const char* xml_filename, int with_comments, int exclusive,
+static int
+c14nRunTest(const char* xml_filename, int with_comments, int mode,
             const char* xpath_filename, const char *ns_filename,
             const char* result_file) {
     xmlDocPtr doc;
-    xmlXPathObjectPtr xpath = NULL; 
+    xmlXPathObjectPtr xpath = NULL;
     xmlChar *result = NULL;
     int ret;
     xmlChar **inclusive_namespaces = NULL;
     const char *nslist = NULL;
     int nssize;
 
 
     /*
      * build an XML tree from a the file; we need to add default
      * attributes and resolve all character and entities references
      */
     xmlLoadExtDtdDefaultValue = XML_DETECT_IDS | XML_COMPLETE_ATTRS;
     xmlSubstituteEntitiesDefault(1);
 
     doc = xmlReadFile(xml_filename, NULL, XML_PARSE_DTDATTR | XML_PARSE_NOENT);
     if (doc == NULL) {
         fprintf(stderr, "Error: unable to parse file \"%s\"\n", xml_filename);
         return(-1);
     }
-    
+
     /*
      * Check the document is of the right kind
-     */    
+     */
     if(xmlDocGetRootElement(doc) == NULL) {
         fprintf(stderr,"Error: empty document for file \"%s\"\n", xml_filename);
         xmlFreeDoc(doc);
         return(-1);
     }
 
-    /* 
-     * load xpath file if specified 
+    /*
+     * load xpath file if specified
      */
     if(xpath_filename) {
         xpath = load_xpath_expr(doc, xpath_filename);
         if(xpath == NULL) {
             fprintf(stderr,"Error: unable to evaluate xpath expression\n");
-            xmlFreeDoc(doc); 
+            xmlFreeDoc(doc);
             return(-1);
         }
     }
 
     if (ns_filename != NULL) {
         if (loadMem(ns_filename, &nslist, &nssize)) {
             fprintf(stderr,"Error: unable to evaluate xpath expression\n");
             if(xpath != NULL) xmlXPathFreeObject(xpath);
-            xmlFreeDoc(doc); 
+            xmlFreeDoc(doc);
             return(-1);
         }
         inclusive_namespaces = parse_list((xmlChar *) nslist);
     }
 
     /*
      * Canonical form
-     */      
+     */
     /* fprintf(stderr,"File \"%s\" loaded: start canonization\n", xml_filename); */
-    ret = xmlC14NDocDumpMemory(doc, 
-            (xpath) ? xpath->nodesetval : NULL, 
-            exclusive, inclusive_namespaces,
+    ret = xmlC14NDocDumpMemory(doc,
+            (xpath) ? xpath->nodesetval : NULL,
+            mode, inclusive_namespaces,
             with_comments, &result);
     if (ret >= 0) {
         if(result != NULL) {
             if (compareFileMem(result_file, (const char *) result, ret)) {
                 fprintf(stderr, "Result mismatch for %s\n", xml_filename);
+                fprintf(stderr, "RESULT:\n%s\n", (const char*)result);
                 ret = -1;
             }
         }
     } else {
         fprintf(stderr,"Error: failed to canonicalize XML file \"%s\" (ret=%d)\n", xml_filename, ret);
         ret = -1;
     }
-        
+
     /*
      * Cleanup
-     */ 
+     */
     if (result != NULL) xmlFree(result);
     if(xpath != NULL) xmlXPathFreeObject(xpath);
     if (inclusive_namespaces != NULL) xmlFree(inclusive_namespaces);
     if (nslist != NULL) free((char *) nslist);
-    xmlFreeDoc(doc);    
+    xmlFreeDoc(doc);
 
     return(ret);
 }
 
 static int
-c14nCommonTest(const char *filename, int with_comments, int exclusive,
+c14nCommonTest(const char *filename, int with_comments, int mode,
                const char *subdir) {
     char buf[500];
     char prefix[500];
     const char *base;
     int len;
     char *result = NULL;
     char *xpath = NULL;
     char *ns = NULL;
     int ret = 0;
 
@@ skipping 12 matching lines @@
     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)) {
         ns = strdup(buf);
     }
 
     nb_tests++;
-    if (c14nRunTest(filename, with_comments, exclusive,
+    if (c14nRunTest(filename, with_comments, mode,
                     xpath, ns, result) < 0)
         ret = 1;
 
     if (result != NULL) free(result);
     if (xpath != NULL) free(xpath);
     if (ns != NULL) free(ns);
     return(ret);
 }
 
 static int
 c14nWithCommentTest(const char *filename,
                     const char *resul ATTRIBUTE_UNUSED,
                     const char *err ATTRIBUTE_UNUSED,
                     int options ATTRIBUTE_UNUSED) {
-    return(c14nCommonTest(filename, 1, 0, "with-comments"));
+    return(c14nCommonTest(filename, 1, XML_C14N_1_0, "with-comments"));
 }
 static int
 c14nWithoutCommentTest(const char *filename,
                     const char *resul ATTRIBUTE_UNUSED,
                     const char *err ATTRIBUTE_UNUSED,
                     int options ATTRIBUTE_UNUSED) {
-    return(c14nCommonTest(filename, 0, 0, "without-comments"));
+    return(c14nCommonTest(filename, 0, XML_C14N_1_0, "without-comments"));
 }
 static int
 c14nExcWithoutCommentTest(const char *filename,
                     const char *resul ATTRIBUTE_UNUSED,
                     const char *err ATTRIBUTE_UNUSED,
                     int options ATTRIBUTE_UNUSED) {
-    return(c14nCommonTest(filename, 0, 1, "exc-without-comments"));
+    return(c14nCommonTest(filename, 0, XML_C14N_EXCLUSIVE_1_0, "exc-without-comments"));
+}
+static int
+c14n11WithoutCommentTest(const char *filename,
+                    const char *resul ATTRIBUTE_UNUSED,
+                    const char *err ATTRIBUTE_UNUSED,
+                    int options ATTRIBUTE_UNUSED) {
+    return(c14nCommonTest(filename, 0, XML_C14N_1_1, "1-1-without-comments"));
 }
 #endif
 #if defined(LIBXML_THREAD_ENABLED) && defined(LIBXML_CATALOG_ENABLED) && defined (LIBXML_SAX1_ENABLED)
 /************************************************************************
  *                                                                      *
  *                      Catalog and threads test                        *
  *                                                                      *
  ************************************************************************/
 
 /*
@@ skipping 60 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(solaris)
+#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;
         }
@@ skipping 55 matching lines @@
 
         for (i = 0; i < num_threads; i++) {
             results[i] = 0;
             tid[i] = (HANDLE) - 1;
         }
 
         for (i = 0; i < num_threads; i++) {
             DWORD useless;
 
             tid[i] = CreateThread(NULL, 0,
-                                  win32_thread_specific_data, 
+                                  win32_thread_specific_data,
                                   (void *) testfiles[i], 0,
                                   &useless);
             if (tid[i] == NULL) {
                 fprintf(stderr, "CreateThread failed\n");
                 return(1);
             }
         }
 
         if (WaitForMultipleObjects(num_threads, tid, TRUE, INFINITE) ==
             WAIT_FAILED) {
@@ skipping 77 matching lines @@
 }
 #else
 static int
 testThread(void)
 {
     fprintf(stderr,
             "Specific platform thread support not detected\n");
     return (-1);
 }
 #endif
-static int 
+static int
 threadsTest(const char *filename ATTRIBUTE_UNUSED,
             const char *resul ATTRIBUTE_UNUSED,
             const char *err ATTRIBUTE_UNUSED,
             int options ATTRIBUTE_UNUSED) {
     return(testThread());
 }
 #endif
 /************************************************************************
  *                                                                      *
  *                      Tests Descriptions                              *
@@ skipping 71 matching lines @@
       XML_PARSE_DTDVALID },
     { "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
     { "XInclude xmlReader regression tests",
       streamParseTest, "./test/XInclude/docs/*", "result/XInclude/", ".rdr",
       /* Ignore errors at this point ".err", */
       NULL, XML_PARSE_XINCLUDE },
+#endif
     { "XInclude regression tests stripping include nodes" ,
       errParseTest, "./test/XInclude/docs/*", "result/XInclude/", "", NULL,
       /* Ignore errors at this point ".err", */
       XML_PARSE_XINCLUDE | XML_PARSE_NOXINCNODE },
+#ifdef LIBXML_READER_ENABLED
     { "XInclude xmlReader regression tests stripping include nodes",
       streamParseTest, "./test/XInclude/docs/*", "result/XInclude/", ".rdr",
       /* Ignore errors at this point ".err", */
       NULL, XML_PARSE_XINCLUDE | XML_PARSE_NOXINCNODE },
 #endif
+#endif
 #ifdef LIBXML_XPATH_ENABLED
 #ifdef LIBXML_DEBUG_ENABLED
     { "XPath expressions regression tests" ,
       xpathExprTest, "./test/XPath/expr/*", "result/XPath/expr/", "", NULL,
       0 },
     { "XPath document queries regression tests" ,
       xpathDocTest, "./test/XPath/docs/*", NULL, NULL, NULL,
       0 },
 #ifdef LIBXML_XPTR_ENABLED
     { "XPointer document queries regression tests" ,
@@ skipping 37 matching lines @@
 #ifdef LIBXML_C14N_ENABLED
     { "C14N with comments regression tests" ,
       c14nWithCommentTest, "./test/c14n/with-comments/*.xml", NULL, NULL, NULL,
       0 },
     { "C14N without comments regression tests" ,
       c14nWithoutCommentTest, "./test/c14n/without-comments/*.xml", NULL, NULL, NULL,
       0 },
     { "C14N exclusive without comments regression tests" ,
       c14nExcWithoutCommentTest, "./test/c14n/exc-without-comments/*.xml", NULL, NULL, NULL,
       0 },
+    { "C14N 1.1 without comments regression tests" ,
+      c14n11WithoutCommentTest, "./test/c14n/1-1-without-comments/*.xml", NULL, NULL, NULL,
+      0 },
 #endif
 #if defined(LIBXML_THREAD_ENABLED) && defined(LIBXML_CATALOG_ENABLED) && defined(LIBXML_SAX1_ENABLED)
     { "Catalog and Threads regression tests" ,
       threadsTest, NULL, NULL, NULL, NULL,
       0 },
 #endif
     {NULL, NULL, NULL, NULL, NULL, NULL, 0}
 };
 
 /************************************************************************
@@ skipping 115 matching lines @@
     return(ret);
 }
 
 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], "-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 21 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