Index: third_party/libxml/src/testrecurse.c |
diff --git a/third_party/libxml/src/testrecurse.c b/third_party/libxml/src/testrecurse.c |
new file mode 100644 |
index 0000000000000000000000000000000000000000..e5d5d1b307ac14c03b79161738f3c0548c3ea301 |
--- /dev/null |
+++ b/third_party/libxml/src/testrecurse.c |
@@ -0,0 +1,965 @@ |
+/* |
+ * testrecurse.c: C program to run libxml2 regression tests checking entities |
+ * recursions |
+ * |
+ * To compile on Unixes: |
+ * cc -o testrecurse `xml2-config --cflags` testrecurse.c `xml2-config --libs` -lpthread |
+ * |
+ * See Copyright for the status of this software. |
+ * |
+ * daniel@veillard.com |
+ */ |
+ |
+#include "libxml.h" |
+#include <stdio.h> |
+ |
+#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> |
+#include <libxml/tree.h> |
+#include <libxml/uri.h> |
+#ifdef LIBXML_READER_ENABLED |
+#include <libxml/xmlreader.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 |
+#else |
+#define RD_FLAGS O_RDONLY |
+#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 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 */ |
+ char **gl_pathv; /* List of matched pathnames. */ |
+ size_t gl_offs; /* Slots to reserve in 'gl_pathv'. */ |
+} glob_t; |
+ |
+#define GLOB_DOOFFS 0 |
+static int glob(const char *pattern, int flags, |
+ 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) |
+ 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) |
+ goto done; |
+ ret->gl_pathc++; |
+ while(FindNextFileA(hFind, &FindFileData)) { |
+ if (FindFileData.cFileName[0] == '.') |
+ continue; |
+ if (ret->gl_pathc + 2 > nb_paths) { |
+ char **tmp = realloc(ret->gl_pathv, nb_paths * 2 * sizeof(char *)); |
+ if (tmp == NULL) |
+ break; |
+ ret->gl_pathv = tmp; |
+ nb_paths *= 2; |
+ } |
+ strncpy(directory + len, FindFileData.cFileName, 499 - len); |
+ ret->gl_pathv[ret->gl_pathc] = strdup(directory); |
+ 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]); |
+ } |
+} |
+ |
+#else |
+#include <glob.h> |
+#endif |
+ |
+/************************************************************************ |
+ * * |
+ * Huge document generator * |
+ * * |
+ ************************************************************************/ |
+ |
+#include <libxml/xmlIO.h> |
+ |
+ |
+static const char *start = "<!DOCTYPE foo [\ |
+<!ENTITY f 'some internal data'> \ |
+<!ENTITY e '&f;&f;'> \ |
+<!ENTITY d '&e;&e;'> \ |
+]> \ |
+<foo>"; |
+ |
+static const char *segment = " <bar>&e; &f; &d;</bar>\n"; |
+static const char *finish = "</foo>"; |
+ |
+static int curseg = 0; |
+static const char *current; |
+static int rlen; |
+ |
+/** |
+ * hugeMatch: |
+ * @URI: an URI to test |
+ * |
+ * Check for an huge: query |
+ * |
+ * Returns 1 if yes and 0 if another Input module should be used |
+ */ |
+static int |
+hugeMatch(const char * URI) { |
+ if ((URI != NULL) && (!strncmp(URI, "huge:", 4))) |
+ return(1); |
+ return(0); |
+} |
+ |
+/** |
+ * hugeOpen: |
+ * @URI: an URI to test |
+ * |
+ * Return a pointer to the huge: query handler, in this example simply |
+ * the current pointer... |
+ * |
+ * Returns an Input context or NULL in case or error |
+ */ |
+static void * |
+hugeOpen(const char * URI) { |
+ if ((URI == NULL) || (strncmp(URI, "huge:", 4))) |
+ return(NULL); |
+ rlen = strlen(start); |
+ current = start; |
+ return((void *) current); |
+} |
+ |
+/** |
+ * hugeClose: |
+ * @context: the read context |
+ * |
+ * Close the huge: query handler |
+ * |
+ * Returns 0 or -1 in case of error |
+ */ |
+static int |
+hugeClose(void * context) { |
+ if (context == NULL) return(-1); |
+ return(0); |
+} |
+ |
+#define MAX_NODES 1000000 |
+ |
+/** |
+ * hugeRead: |
+ * @context: the read context |
+ * @buffer: where to store data |
+ * @len: number of bytes to read |
+ * |
+ * Implement an huge: query read. |
+ * |
+ * Returns the number of bytes read or -1 in case of error |
+ */ |
+static int |
+hugeRead(void *context, char *buffer, int len) |
+{ |
+ if ((context == NULL) || (buffer == NULL) || (len < 0)) |
+ return (-1); |
+ |
+ if (len >= rlen) { |
+ if (curseg >= MAX_NODES + 1) { |
+ rlen = 0; |
+ return(0); |
+ } |
+ len = rlen; |
+ rlen = 0; |
+ memcpy(buffer, current, len); |
+ curseg ++; |
+ if (curseg == MAX_NODES) { |
+ fprintf(stderr, "\n"); |
+ rlen = strlen(finish); |
+ current = finish; |
+ } else { |
+ if (curseg % (MAX_NODES / 10) == 0) |
+ fprintf(stderr, "."); |
+ rlen = strlen(segment); |
+ current = segment; |
+ } |
+ } else { |
+ memcpy(buffer, current, len); |
+ rlen -= len; |
+ current += len; |
+ } |
+ return (len); |
+} |
+ |
+/************************************************************************ |
+ * * |
+ * Libxml2 specific routines * |
+ * * |
+ ************************************************************************/ |
+ |
+static int nb_tests = 0; |
+static int nb_errors = 0; |
+static int nb_leaks = 0; |
+static int extraMemoryFromResolver = 0; |
+ |
+static int |
+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 |
+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; |
+ |
+static void XMLCDECL |
+channel(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...) { |
+ va_list args; |
+ int res; |
+ |
+ if (testErrorsSize >= 32768) |
+ return; |
+ va_start(args, msg); |
+ res = vsnprintf(&testErrors[testErrorsSize], |
+ 32768 - testErrorsSize, |
+ msg, args); |
+ va_end(args); |
+ if (testErrorsSize + res >= 32768) { |
+ /* buffer is full */ |
+ testErrorsSize = 32768; |
+ 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 , |
+ 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')) |
+ 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)) { |
+ *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) */ |
+ while ((n<col) && (n++ < sizeof(content)-2) && (*ctnt != 0)) { |
+ if (*(ctnt) != '\t') |
+ *(ctnt) = ' '; |
+ ctnt++; |
+ } |
+ *ctnt++ = '^'; |
+ *ctnt = 0; |
+ chanl(data ,"%s\n", content); |
+} |
+ |
+static void |
+testStructuredErrorHandler(void *ctx ATTRIBUTE_UNUSED, xmlErrorPtr err) { |
+ char *file = NULL; |
+ int line = 0; |
+ int code = -1; |
+ int domain; |
+ void *data = NULL; |
+ const char *str; |
+ const xmlChar *name = NULL; |
+ xmlNodePtr node; |
+ xmlErrorLevel level; |
+ xmlParserInputPtr input = NULL; |
+ xmlParserInputPtr cur = NULL; |
+ xmlParserCtxtPtr ctxt = NULL; |
+ |
+ if (err == NULL) |
+ return; |
+ |
+ file = err->file; |
+ line = err->line; |
+ code = err->code; |
+ domain = err->domain; |
+ level = err->level; |
+ node = err->node; |
+ if ((domain == XML_FROM_PARSER) || (domain == XML_FROM_HTML) || |
+ (domain == XML_FROM_DTD) || (domain == XML_FROM_NAMESPACE) || |
+ (domain == XML_FROM_IO) || (domain == XML_FROM_VALID)) { |
+ ctxt = err->ctxt; |
+ } |
+ str = err->message; |
+ |
+ if (code == XML_ERR_OK) |
+ return; |
+ |
+ if ((node != NULL) && (node->type == XML_ELEMENT_NODE)) |
+ name = node->name; |
+ |
+ /* |
+ * Maintain the compatibility with the legacy error handling |
+ */ |
+ if (ctxt != NULL) { |
+ input = ctxt->input; |
+ if ((input != NULL) && (input->filename == NULL) && |
+ (ctxt->inputNr > 1)) { |
+ cur = input; |
+ input = ctxt->inputTab[ctxt->inputNr - 2]; |
+ } |
+ if (input != NULL) { |
+ if (input->filename) |
+ channel(data, "%s:%d: ", input->filename, input->line); |
+ else if ((line != 0) && (domain == XML_FROM_PARSER)) |
+ channel(data, "Entity: line %d: ", input->line); |
+ } |
+ } else { |
+ if (file != NULL) |
+ channel(data, "%s:%d: ", file, line); |
+ else if ((line != 0) && (domain == XML_FROM_PARSER)) |
+ channel(data, "Entity: line %d: ", line); |
+ } |
+ if (name != NULL) { |
+ channel(data, "element %s: ", name); |
+ } |
+ if (code == XML_ERR_OK) |
+ return; |
+ switch (domain) { |
+ case XML_FROM_PARSER: |
+ channel(data, "parser "); |
+ break; |
+ case XML_FROM_NAMESPACE: |
+ channel(data, "namespace "); |
+ break; |
+ case XML_FROM_DTD: |
+ case XML_FROM_VALID: |
+ channel(data, "validity "); |
+ break; |
+ case XML_FROM_HTML: |
+ channel(data, "HTML parser "); |
+ break; |
+ case XML_FROM_MEMORY: |
+ channel(data, "memory "); |
+ break; |
+ case XML_FROM_OUTPUT: |
+ channel(data, "output "); |
+ break; |
+ case XML_FROM_IO: |
+ channel(data, "I/O "); |
+ break; |
+ case XML_FROM_XINCLUDE: |
+ channel(data, "XInclude "); |
+ break; |
+ case XML_FROM_XPATH: |
+ channel(data, "XPath "); |
+ break; |
+ case XML_FROM_XPOINTER: |
+ channel(data, "parser "); |
+ break; |
+ case XML_FROM_REGEXP: |
+ channel(data, "regexp "); |
+ break; |
+ case XML_FROM_MODULE: |
+ channel(data, "module "); |
+ break; |
+ case XML_FROM_SCHEMASV: |
+ channel(data, "Schemas validity "); |
+ break; |
+ case XML_FROM_SCHEMASP: |
+ channel(data, "Schemas parser "); |
+ break; |
+ case XML_FROM_RELAXNGP: |
+ channel(data, "Relax-NG parser "); |
+ break; |
+ case XML_FROM_RELAXNGV: |
+ channel(data, "Relax-NG validity "); |
+ break; |
+ case XML_FROM_CATALOG: |
+ channel(data, "Catalog "); |
+ break; |
+ case XML_FROM_C14N: |
+ channel(data, "C14N "); |
+ break; |
+ case XML_FROM_XSLT: |
+ channel(data, "XSLT "); |
+ break; |
+ default: |
+ break; |
+ } |
+ if (code == XML_ERR_OK) |
+ return; |
+ switch (level) { |
+ case XML_ERR_NONE: |
+ channel(data, ": "); |
+ break; |
+ case XML_ERR_WARNING: |
+ channel(data, "warning : "); |
+ break; |
+ case XML_ERR_ERROR: |
+ channel(data, "error : "); |
+ break; |
+ case XML_ERR_FATAL: |
+ channel(data, "error : "); |
+ break; |
+ } |
+ if (code == XML_ERR_OK) |
+ return; |
+ if (str != NULL) { |
+ int len; |
+ len = xmlStrlen((const xmlChar *)str); |
+ if ((len > 0) && (str[len - 1] != '\n')) |
+ channel(data, "%s\n", str); |
+ else |
+ channel(data, "%s", str); |
+ } else { |
+ channel(data, "%s\n", "out of memory error"); |
+ } |
+ if (code == XML_ERR_OK) |
+ return; |
+ |
+ if (ctxt != NULL) { |
+ xmlParserPrintFileContextInternal(input, channel, data); |
+ if (cur != NULL) { |
+ if (cur->filename) |
+ channel(data, "%s:%d: \n", cur->filename, cur->line); |
+ else if ((line != 0) && (domain == XML_FROM_PARSER)) |
+ channel(data, "Entity: line %d: \n", cur->line); |
+ xmlParserPrintFileContextInternal(cur, channel, data); |
+ } |
+ } |
+ if ((domain == XML_FROM_XPATH) && (err->str1 != NULL) && |
+ (err->int1 < 100) && |
+ (err->int1 < xmlStrlen((const xmlChar *)err->str1))) { |
+ xmlChar buf[150]; |
+ int i; |
+ |
+ channel(data, "%s\n", err->str1); |
+ for (i=0;i < err->int1;i++) |
+ buf[i] = ' '; |
+ buf[i++] = '^'; |
+ buf[i] = 0; |
+ channel(data, "%s\n", buf); |
+ } |
+} |
+ |
+static void |
+initializeLibxml2(void) { |
+ xmlGetWarningsDefaultValue = 0; |
+ xmlPedanticParserDefault(0); |
+ |
+ xmlMemSetup(xmlMemFree, xmlMemMalloc, xmlMemRealloc, xmlMemoryStrdup); |
+ xmlInitParser(); |
+ xmlSetExternalEntityLoader(testExternalEntityLoader); |
+ xmlSetStructuredErrorFunc(NULL, testStructuredErrorHandler); |
+ /* |
+ * register the new I/O handlers |
+ */ |
+ if (xmlRegisterInputCallbacks(hugeMatch, hugeOpen, |
+ hugeRead, hugeClose) < 0) { |
+ fprintf(stderr, "failed to register Huge handler\n"); |
+ exit(1); |
+ } |
+} |
+ |
+/************************************************************************ |
+ * * |
+ * File name and path utilities * |
+ * * |
+ ************************************************************************/ |
+ |
+static const char *baseFilename(const char *filename) { |
+ const char *cur; |
+ if (filename == NULL) |
+ return(NULL); |
+ cur = &filename[strlen(filename)]; |
+ while ((cur > filename) && (*cur != '/')) |
+ cur--; |
+ if (*cur == '/') |
+ return(cur + 1); |
+ return(cur); |
+} |
+ |
+static char *resultFilename(const char *filename, const char *out, |
+ const char *suffix) { |
+ 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]='_'; |
+#endif |
+ |
+ snprintf(res, 499, "%s%s%s", out, base, suffixbuff); |
+ res[499] = 0; |
+ return(strdup(res)); |
+} |
+ |
+static int checkTestFile(const char *filename) { |
+ struct stat buf; |
+ |
+ if (stat(filename, &buf) == -1) |
+ return(0); |
+ |
+#if defined(_WIN32) && !defined(__CYGWIN__) |
+ if (!(buf.st_mode & _S_IFREG)) |
+ return(0); |
+#else |
+ if (!S_ISREG(buf.st_mode)) |
+ return(0); |
+#endif |
+ |
+ return(1); |
+} |
+ |
+ |
+ |
+/************************************************************************ |
+ * * |
+ * Test to detect or not recursive entities * |
+ * * |
+ ************************************************************************/ |
+/** |
+ * recursiveDetectTest: |
+ * @filename: the file to parse |
+ * @result: the file with expected result |
+ * @err: the file with error messages: unused |
+ * |
+ * Parse a file loading DTD and replacing entities check it fails for |
+ * lol cases |
+ * |
+ * Returns 0 in case of success, an error code otherwise |
+ */ |
+static int |
+recursiveDetectTest(const char *filename, |
+ const char *result ATTRIBUTE_UNUSED, |
+ const char *err ATTRIBUTE_UNUSED, |
+ int options ATTRIBUTE_UNUSED) { |
+ xmlDocPtr doc; |
+ xmlParserCtxtPtr ctxt; |
+ int res = 0; |
+ |
+ nb_tests++; |
+ |
+ ctxt = xmlNewParserCtxt(); |
+ /* |
+ * base of the test, parse with the old API |
+ */ |
+ doc = xmlCtxtReadFile(ctxt, filename, NULL, |
+ XML_PARSE_NOENT | XML_PARSE_DTDLOAD); |
+ if ((doc != NULL) || (ctxt->lastError.code != XML_ERR_ENTITY_LOOP)) { |
+ fprintf(stderr, "Failed to detect recursion in %s\n", filename); |
+ xmlFreeParserCtxt(ctxt); |
+ xmlFreeDoc(doc); |
+ return(1); |
+ } |
+ xmlFreeParserCtxt(ctxt); |
+ |
+ return(res); |
+} |
+ |
+/** |
+ * notRecursiveDetectTest: |
+ * @filename: the file to parse |
+ * @result: the file with expected result |
+ * @err: the file with error messages: unused |
+ * |
+ * Parse a file loading DTD and replacing entities check it works for |
+ * good cases |
+ * |
+ * Returns 0 in case of success, an error code otherwise |
+ */ |
+static int |
+notRecursiveDetectTest(const char *filename, |
+ const char *result ATTRIBUTE_UNUSED, |
+ const char *err ATTRIBUTE_UNUSED, |
+ int options ATTRIBUTE_UNUSED) { |
+ xmlDocPtr doc; |
+ xmlParserCtxtPtr ctxt; |
+ int res = 0; |
+ |
+ nb_tests++; |
+ |
+ ctxt = xmlNewParserCtxt(); |
+ /* |
+ * base of the test, parse with the old API |
+ */ |
+ doc = xmlCtxtReadFile(ctxt, filename, NULL, |
+ XML_PARSE_NOENT | XML_PARSE_DTDLOAD); |
+ if (doc == NULL) { |
+ fprintf(stderr, "Failed to parse correct file %s\n", filename); |
+ xmlFreeParserCtxt(ctxt); |
+ return(1); |
+ } |
+ xmlFreeDoc(doc); |
+ xmlFreeParserCtxt(ctxt); |
+ |
+ return(res); |
+} |
+ |
+#ifdef LIBXML_READER_ENABLED |
+/** |
+ * notRecursiveHugeTest: |
+ * @filename: the file to parse |
+ * @result: the file with expected result |
+ * @err: the file with error messages: unused |
+ * |
+ * Parse a memory generated file |
+ * good cases |
+ * |
+ * Returns 0 in case of success, an error code otherwise |
+ */ |
+static int |
+notRecursiveHugeTest(const char *filename ATTRIBUTE_UNUSED, |
+ const char *result ATTRIBUTE_UNUSED, |
+ const char *err ATTRIBUTE_UNUSED, |
+ int options ATTRIBUTE_UNUSED) { |
+ xmlTextReaderPtr reader; |
+ int res = 0; |
+ int ret; |
+ |
+ nb_tests++; |
+ |
+ reader = xmlReaderForFile("huge:test" , NULL, |
+ XML_PARSE_NOENT | XML_PARSE_DTDLOAD); |
+ if (reader == NULL) { |
+ fprintf(stderr, "Failed to open huge:test\n"); |
+ return(1); |
+ } |
+ ret = xmlTextReaderRead(reader); |
+ while (ret == 1) { |
+ ret = xmlTextReaderRead(reader); |
+ } |
+ if (ret != 0) { |
+ fprintf(stderr, "Failed to parser huge:test with entities\n"); |
+ res = 1; |
+ } |
+ xmlFreeTextReader(reader); |
+ |
+ return(res); |
+} |
+#endif |
+ |
+/************************************************************************ |
+ * * |
+ * Tests Descriptions * |
+ * * |
+ ************************************************************************/ |
+ |
+static |
+testDesc testDescriptions[] = { |
+ { "Parsing recursive test cases" , |
+ recursiveDetectTest, "./test/recurse/lol*.xml", NULL, NULL, NULL, |
+ 0 }, |
+ { "Parsing non-recursive test cases" , |
+ notRecursiveDetectTest, "./test/recurse/good*.xml", NULL, NULL, NULL, |
+ 0 }, |
+#ifdef LIBXML_READER_ENABLED |
+ { "Parsing non-recursive huge case" , |
+ notRecursiveHugeTest, NULL, NULL, NULL, NULL, |
+ 0 }, |
+#endif |
+ {NULL, NULL, NULL, NULL, NULL, NULL, 0} |
+}; |
+ |
+/************************************************************************ |
+ * * |
+ * The main code driving the tests * |
+ * * |
+ ************************************************************************/ |
+ |
+static int |
+launchTests(testDescPtr tst) { |
+ int res = 0, err = 0; |
+ size_t i; |
+ char *result; |
+ char *error; |
+ int mem; |
+ |
+ if (tst == NULL) return(-1); |
+ if (tst->in != NULL) { |
+ glob_t globbuf; |
+ |
+ globbuf.gl_offs = 0; |
+ glob(tst->in, GLOB_DOOFFS, NULL, &globbuf); |
+ for (i = 0;i < globbuf.gl_pathc;i++) { |
+ if (!checkTestFile(globbuf.gl_pathv[i])) |
+ continue; |
+ if (tst->suffix != NULL) { |
+ result = resultFilename(globbuf.gl_pathv[i], tst->out, |
+ tst->suffix); |
+ if (result == NULL) { |
+ fprintf(stderr, "Out of memory !\n"); |
+ fatalError(); |
+ } |
+ } else { |
+ result = NULL; |
+ } |
+ 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))) { |
+ fprintf(stderr, "Missing result file %s\n", result); |
+ } else if ((error) &&(!checkTestFile(error))) { |
+ 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) { |
+ fprintf(stderr, "File %s generated an error\n", |
+ globbuf.gl_pathv[i]); |
+ nb_errors++; |
+ err++; |
+ } |
+ else if (xmlMemUsed() != mem) { |
+ if ((xmlMemUsed() != mem) && |
+ (extraMemoryFromResolver == 0)) { |
+ fprintf(stderr, "File %s leaked %d bytes\n", |
+ globbuf.gl_pathv[i], xmlMemUsed() - mem); |
+ nb_leaks++; |
+ err++; |
+ } |
+ } |
+ testErrorsSize = 0; |
+ } |
+ if (result) |
+ free(result); |
+ if (error) |
+ free(error); |
+ } |
+ globfree(&globbuf); |
+ } else { |
+ testErrorsSize = 0; |
+ testErrors[0] = 0; |
+ extraMemoryFromResolver = 0; |
+ res = tst->func(NULL, NULL, NULL, tst->options); |
+ if (res != 0) { |
+ nb_errors++; |
+ err++; |
+ } |
+ } |
+ return(err); |
+} |
+ |
+static int verbose = 0; |
+static int tests_quiet = 0; |
+ |
+static int |
+runtest(int i) { |
+ int ret = 0, res; |
+ int old_errors, old_tests, old_leaks; |
+ |
+ old_errors = nb_errors; |
+ old_tests = nb_tests; |
+ old_leaks = nb_leaks; |
+ if ((tests_quiet == 0) && (testDescriptions[i].desc != NULL)) |
+ printf("## %s\n", testDescriptions[i].desc); |
+ res = launchTests(&testDescriptions[i]); |
+ if (res != 0) |
+ ret++; |
+ if (verbose) { |
+ if ((nb_errors == old_errors) && (nb_leaks == old_leaks)) |
+ printf("Ran %d tests, no errors\n", nb_tests - old_tests); |
+ else |
+ printf("Ran %d tests, %d errors, %d leaks\n", |
+ nb_tests - old_tests, |
+ nb_errors - old_errors, |
+ nb_leaks - old_leaks); |
+ } |
+ 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++; |
+ } |
+ } |
+ } |
+ } |
+ if (subset == 0) { |
+ for (i = 0; testDescriptions[i].func != NULL; i++) { |
+ ret += runtest(i); |
+ } |
+ } |
+ if ((nb_errors == 0) && (nb_leaks == 0)) { |
+ ret = 0; |
+ printf("Total %d tests, no errors\n", |
+ nb_tests); |
+ } else { |
+ ret = 1; |
+ printf("Total %d tests, %d errors, %d leaks\n", |
+ nb_tests, nb_errors, nb_leaks); |
+ } |
+ xmlCleanupParser(); |
+ xmlMemoryDump(); |
+ |
+ return(ret); |
+} |