1: /*
2: * testrecurse.c: C program to run libxml2 regression tests checking entities
3: * recursions
4: *
5: * To compile on Unixes:
6: * cc -o testrecurse `xml2-config --cflags` testrecurse.c `xml2-config --libs` -lpthread
7: *
8: * See Copyright for the status of this software.
9: *
10: * daniel@veillard.com
11: */
12:
13: #ifdef HAVE_CONFIG_H
14: #include "libxml.h"
15: #else
16: #include <stdio.h>
17: #endif
18:
19: #if !defined(_WIN32) || defined(__CYGWIN__)
20: #include <unistd.h>
21: #endif
22: #include <string.h>
23: #include <sys/types.h>
24: #include <sys/stat.h>
25: #include <fcntl.h>
26:
27: #include <libxml/parser.h>
28: #include <libxml/tree.h>
29: #include <libxml/uri.h>
30: #ifdef LIBXML_READER_ENABLED
31: #include <libxml/xmlreader.h>
32: #endif
33:
34: /*
35: * O_BINARY is just for Windows compatibility - if it isn't defined
36: * on this system, avoid any compilation error
37: */
38: #ifdef O_BINARY
39: #define RD_FLAGS O_RDONLY | O_BINARY
40: #else
41: #define RD_FLAGS O_RDONLY
42: #endif
43:
44: typedef int (*functest) (const char *filename, const char *result,
45: const char *error, int options);
46:
47: typedef struct testDesc testDesc;
48: typedef testDesc *testDescPtr;
49: struct testDesc {
50: const char *desc; /* descripton of the test */
51: functest func; /* function implementing the test */
52: const char *in; /* glob to path for input files */
53: const char *out; /* output directory */
54: const char *suffix;/* suffix for output files */
55: const char *err; /* suffix for error output files */
56: int options; /* parser options for the test */
57: };
58:
59: static int checkTestFile(const char *filename);
60:
61:
62: #if defined(_WIN32) && !defined(__CYGWIN__)
63:
64: #include <windows.h>
65: #include <io.h>
66:
67: typedef struct
68: {
69: size_t gl_pathc; /* Count of paths matched so far */
70: char **gl_pathv; /* List of matched pathnames. */
71: size_t gl_offs; /* Slots to reserve in 'gl_pathv'. */
72: } glob_t;
73:
74: #define GLOB_DOOFFS 0
75: static int glob(const char *pattern, int flags,
76: int errfunc(const char *epath, int eerrno),
77: glob_t *pglob) {
78: glob_t *ret;
79: WIN32_FIND_DATA FindFileData;
80: HANDLE hFind;
81: unsigned int nb_paths = 0;
82: char directory[500];
83: int len;
84:
85: if ((pattern == NULL) || (pglob == NULL)) return(-1);
86:
87: strncpy(directory, pattern, 499);
88: for (len = strlen(directory);len >= 0;len--) {
89: if (directory[len] == '/') {
90: len++;
91: directory[len] = 0;
92: break;
93: }
94: }
95: if (len <= 0)
96: len = 0;
97:
98:
99: ret = pglob;
100: memset(ret, 0, sizeof(glob_t));
101:
102: hFind = FindFirstFileA(pattern, &FindFileData);
103: if (hFind == INVALID_HANDLE_VALUE)
104: return(0);
105: nb_paths = 20;
106: ret->gl_pathv = (char **) malloc(nb_paths * sizeof(char *));
107: if (ret->gl_pathv == NULL) {
108: FindClose(hFind);
109: return(-1);
110: }
111: strncpy(directory + len, FindFileData.cFileName, 499 - len);
112: ret->gl_pathv[ret->gl_pathc] = strdup(directory);
113: if (ret->gl_pathv[ret->gl_pathc] == NULL)
114: goto done;
115: ret->gl_pathc++;
116: while(FindNextFileA(hFind, &FindFileData)) {
117: if (FindFileData.cFileName[0] == '.')
118: continue;
119: if (ret->gl_pathc + 2 > nb_paths) {
120: char **tmp = realloc(ret->gl_pathv, nb_paths * 2 * sizeof(char *));
121: if (tmp == NULL)
122: break;
123: ret->gl_pathv = tmp;
124: nb_paths *= 2;
125: }
126: strncpy(directory + len, FindFileData.cFileName, 499 - len);
127: ret->gl_pathv[ret->gl_pathc] = strdup(directory);
128: if (ret->gl_pathv[ret->gl_pathc] == NULL)
129: break;
130: ret->gl_pathc++;
131: }
132: ret->gl_pathv[ret->gl_pathc] = NULL;
133:
134: done:
135: FindClose(hFind);
136: return(0);
137: }
138:
139:
140:
141: static void globfree(glob_t *pglob) {
142: unsigned int i;
143: if (pglob == NULL)
144: return;
145:
146: for (i = 0;i < pglob->gl_pathc;i++) {
147: if (pglob->gl_pathv[i] != NULL)
148: free(pglob->gl_pathv[i]);
149: }
150: }
151:
152: #if !defined(__MINGW32__)
153: #define vsnprintf _vsnprintf
154: #define snprintf _snprintf
155: #endif
156: #else
157: #include <glob.h>
158: #endif
159:
160: /************************************************************************
161: * *
162: * Huge document generator *
163: * *
164: ************************************************************************/
165:
166: #include <libxml/xmlIO.h>
167:
168:
169: static const char *start = "<!DOCTYPE foo [\
170: <!ENTITY f 'some internal data'> \
171: <!ENTITY e '&f;&f;'> \
172: <!ENTITY d '&e;&e;'> \
173: ]> \
174: <foo>";
175:
176: static const char *segment = " <bar>&e; &f; &d;</bar>\n";
177: static const char *finish = "</foo>";
178:
179: static int curseg = 0;
180: static const char *current;
181: static int rlen;
182:
183: /**
184: * hugeMatch:
185: * @URI: an URI to test
186: *
187: * Check for an huge: query
188: *
189: * Returns 1 if yes and 0 if another Input module should be used
190: */
191: static int
192: hugeMatch(const char * URI) {
193: if ((URI != NULL) && (!strncmp(URI, "huge:", 4)))
194: return(1);
195: return(0);
196: }
197:
198: /**
199: * hugeOpen:
200: * @URI: an URI to test
201: *
202: * Return a pointer to the huge: query handler, in this example simply
203: * the current pointer...
204: *
205: * Returns an Input context or NULL in case or error
206: */
207: static void *
208: hugeOpen(const char * URI) {
209: if ((URI == NULL) || (strncmp(URI, "huge:", 4)))
210: return(NULL);
211: rlen = strlen(start);
212: current = start;
213: return((void *) current);
214: }
215:
216: /**
217: * hugeClose:
218: * @context: the read context
219: *
220: * Close the huge: query handler
221: *
222: * Returns 0 or -1 in case of error
223: */
224: static int
225: hugeClose(void * context) {
226: if (context == NULL) return(-1);
227: return(0);
228: }
229:
230: #define MAX_NODES 1000000
231:
232: /**
233: * hugeRead:
234: * @context: the read context
235: * @buffer: where to store data
236: * @len: number of bytes to read
237: *
238: * Implement an huge: query read.
239: *
240: * Returns the number of bytes read or -1 in case of error
241: */
242: static int
243: hugeRead(void *context, char *buffer, int len)
244: {
245: if ((context == NULL) || (buffer == NULL) || (len < 0))
246: return (-1);
247:
248: if (len >= rlen) {
249: if (curseg >= MAX_NODES + 1) {
250: rlen = 0;
251: return(0);
252: }
253: len = rlen;
254: rlen = 0;
255: memcpy(buffer, current, len);
256: curseg ++;
257: if (curseg == MAX_NODES) {
258: fprintf(stderr, "\n");
259: rlen = strlen(finish);
260: current = finish;
261: } else {
262: if (curseg % (MAX_NODES / 10) == 0)
263: fprintf(stderr, ".");
264: rlen = strlen(segment);
265: current = segment;
266: }
267: } else {
268: memcpy(buffer, current, len);
269: rlen -= len;
270: current += len;
271: }
272: return (len);
273: }
274:
275: /************************************************************************
276: * *
277: * Libxml2 specific routines *
278: * *
279: ************************************************************************/
280:
281: static int nb_tests = 0;
282: static int nb_errors = 0;
283: static int nb_leaks = 0;
284: static int extraMemoryFromResolver = 0;
285:
286: static int
287: fatalError(void) {
288: fprintf(stderr, "Exitting tests on fatal error\n");
289: exit(1);
290: }
291:
292: /*
293: * We need to trap calls to the resolver to not account memory for the catalog
294: * which is shared to the current running test. We also don't want to have
295: * network downloads modifying tests.
296: */
297: static xmlParserInputPtr
298: testExternalEntityLoader(const char *URL, const char *ID,
299: xmlParserCtxtPtr ctxt) {
300: xmlParserInputPtr ret;
301:
302: if (checkTestFile(URL)) {
303: ret = xmlNoNetExternalEntityLoader(URL, ID, ctxt);
304: } else {
305: int memused = xmlMemUsed();
306: ret = xmlNoNetExternalEntityLoader(URL, ID, ctxt);
307: extraMemoryFromResolver += xmlMemUsed() - memused;
308: }
309:
310: return(ret);
311: }
312:
313: /*
314: * Trapping the error messages at the generic level to grab the equivalent of
315: * stderr messages on CLI tools.
316: */
317: static char testErrors[32769];
318: static int testErrorsSize = 0;
319:
320: static void XMLCDECL
321: channel(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...) {
322: va_list args;
323: int res;
324:
325: if (testErrorsSize >= 32768)
326: return;
327: va_start(args, msg);
328: res = vsnprintf(&testErrors[testErrorsSize],
329: 32768 - testErrorsSize,
330: msg, args);
331: va_end(args);
332: if (testErrorsSize + res >= 32768) {
333: /* buffer is full */
334: testErrorsSize = 32768;
335: testErrors[testErrorsSize] = 0;
336: } else {
337: testErrorsSize += res;
338: }
339: testErrors[testErrorsSize] = 0;
340: }
341:
342: /**
343: * xmlParserPrintFileContext:
344: * @input: an xmlParserInputPtr input
345: *
346: * Displays current context within the input content for error tracking
347: */
348:
349: static void
350: xmlParserPrintFileContextInternal(xmlParserInputPtr input ,
351: xmlGenericErrorFunc chanl, void *data ) {
352: const xmlChar *cur, *base;
353: unsigned int n, col; /* GCC warns if signed, because compared with sizeof() */
354: xmlChar content[81]; /* space for 80 chars + line terminator */
355: xmlChar *ctnt;
356:
357: if (input == NULL) return;
358: cur = input->cur;
359: base = input->base;
360: /* skip backwards over any end-of-lines */
361: while ((cur > base) && ((*(cur) == '\n') || (*(cur) == '\r'))) {
362: cur--;
363: }
364: n = 0;
365: /* search backwards for beginning-of-line (to max buff size) */
366: while ((n++ < (sizeof(content)-1)) && (cur > base) &&
367: (*(cur) != '\n') && (*(cur) != '\r'))
368: cur--;
369: if ((*(cur) == '\n') || (*(cur) == '\r')) cur++;
370: /* calculate the error position in terms of the current position */
371: col = input->cur - cur;
372: /* search forward for end-of-line (to max buff size) */
373: n = 0;
374: ctnt = content;
375: /* copy selected text to our buffer */
376: while ((*cur != 0) && (*(cur) != '\n') &&
377: (*(cur) != '\r') && (n < sizeof(content)-1)) {
378: *ctnt++ = *cur++;
379: n++;
380: }
381: *ctnt = 0;
382: /* print out the selected text */
383: chanl(data ,"%s\n", content);
384: /* create blank line with problem pointer */
385: n = 0;
386: ctnt = content;
387: /* (leave buffer space for pointer + line terminator) */
388: while ((n<col) && (n++ < sizeof(content)-2) && (*ctnt != 0)) {
389: if (*(ctnt) != '\t')
390: *(ctnt) = ' ';
391: ctnt++;
392: }
393: *ctnt++ = '^';
394: *ctnt = 0;
395: chanl(data ,"%s\n", content);
396: }
397:
398: static void
399: testStructuredErrorHandler(void *ctx ATTRIBUTE_UNUSED, xmlErrorPtr err) {
400: char *file = NULL;
401: int line = 0;
402: int code = -1;
403: int domain;
404: void *data = NULL;
405: const char *str;
406: const xmlChar *name = NULL;
407: xmlNodePtr node;
408: xmlErrorLevel level;
409: xmlParserInputPtr input = NULL;
410: xmlParserInputPtr cur = NULL;
411: xmlParserCtxtPtr ctxt = NULL;
412:
413: if (err == NULL)
414: return;
415:
416: file = err->file;
417: line = err->line;
418: code = err->code;
419: domain = err->domain;
420: level = err->level;
421: node = err->node;
422: if ((domain == XML_FROM_PARSER) || (domain == XML_FROM_HTML) ||
423: (domain == XML_FROM_DTD) || (domain == XML_FROM_NAMESPACE) ||
424: (domain == XML_FROM_IO) || (domain == XML_FROM_VALID)) {
425: ctxt = err->ctxt;
426: }
427: str = err->message;
428:
429: if (code == XML_ERR_OK)
430: return;
431:
432: if ((node != NULL) && (node->type == XML_ELEMENT_NODE))
433: name = node->name;
434:
435: /*
436: * Maintain the compatibility with the legacy error handling
437: */
438: if (ctxt != NULL) {
439: input = ctxt->input;
440: if ((input != NULL) && (input->filename == NULL) &&
441: (ctxt->inputNr > 1)) {
442: cur = input;
443: input = ctxt->inputTab[ctxt->inputNr - 2];
444: }
445: if (input != NULL) {
446: if (input->filename)
447: channel(data, "%s:%d: ", input->filename, input->line);
448: else if ((line != 0) && (domain == XML_FROM_PARSER))
449: channel(data, "Entity: line %d: ", input->line);
450: }
451: } else {
452: if (file != NULL)
453: channel(data, "%s:%d: ", file, line);
454: else if ((line != 0) && (domain == XML_FROM_PARSER))
455: channel(data, "Entity: line %d: ", line);
456: }
457: if (name != NULL) {
458: channel(data, "element %s: ", name);
459: }
460: if (code == XML_ERR_OK)
461: return;
462: switch (domain) {
463: case XML_FROM_PARSER:
464: channel(data, "parser ");
465: break;
466: case XML_FROM_NAMESPACE:
467: channel(data, "namespace ");
468: break;
469: case XML_FROM_DTD:
470: case XML_FROM_VALID:
471: channel(data, "validity ");
472: break;
473: case XML_FROM_HTML:
474: channel(data, "HTML parser ");
475: break;
476: case XML_FROM_MEMORY:
477: channel(data, "memory ");
478: break;
479: case XML_FROM_OUTPUT:
480: channel(data, "output ");
481: break;
482: case XML_FROM_IO:
483: channel(data, "I/O ");
484: break;
485: case XML_FROM_XINCLUDE:
486: channel(data, "XInclude ");
487: break;
488: case XML_FROM_XPATH:
489: channel(data, "XPath ");
490: break;
491: case XML_FROM_XPOINTER:
492: channel(data, "parser ");
493: break;
494: case XML_FROM_REGEXP:
495: channel(data, "regexp ");
496: break;
497: case XML_FROM_MODULE:
498: channel(data, "module ");
499: break;
500: case XML_FROM_SCHEMASV:
501: channel(data, "Schemas validity ");
502: break;
503: case XML_FROM_SCHEMASP:
504: channel(data, "Schemas parser ");
505: break;
506: case XML_FROM_RELAXNGP:
507: channel(data, "Relax-NG parser ");
508: break;
509: case XML_FROM_RELAXNGV:
510: channel(data, "Relax-NG validity ");
511: break;
512: case XML_FROM_CATALOG:
513: channel(data, "Catalog ");
514: break;
515: case XML_FROM_C14N:
516: channel(data, "C14N ");
517: break;
518: case XML_FROM_XSLT:
519: channel(data, "XSLT ");
520: break;
521: default:
522: break;
523: }
524: if (code == XML_ERR_OK)
525: return;
526: switch (level) {
527: case XML_ERR_NONE:
528: channel(data, ": ");
529: break;
530: case XML_ERR_WARNING:
531: channel(data, "warning : ");
532: break;
533: case XML_ERR_ERROR:
534: channel(data, "error : ");
535: break;
536: case XML_ERR_FATAL:
537: channel(data, "error : ");
538: break;
539: }
540: if (code == XML_ERR_OK)
541: return;
542: if (str != NULL) {
543: int len;
544: len = xmlStrlen((const xmlChar *)str);
545: if ((len > 0) && (str[len - 1] != '\n'))
546: channel(data, "%s\n", str);
547: else
548: channel(data, "%s", str);
549: } else {
550: channel(data, "%s\n", "out of memory error");
551: }
552: if (code == XML_ERR_OK)
553: return;
554:
555: if (ctxt != NULL) {
556: xmlParserPrintFileContextInternal(input, channel, data);
557: if (cur != NULL) {
558: if (cur->filename)
559: channel(data, "%s:%d: \n", cur->filename, cur->line);
560: else if ((line != 0) && (domain == XML_FROM_PARSER))
561: channel(data, "Entity: line %d: \n", cur->line);
562: xmlParserPrintFileContextInternal(cur, channel, data);
563: }
564: }
565: if ((domain == XML_FROM_XPATH) && (err->str1 != NULL) &&
566: (err->int1 < 100) &&
567: (err->int1 < xmlStrlen((const xmlChar *)err->str1))) {
568: xmlChar buf[150];
569: int i;
570:
571: channel(data, "%s\n", err->str1);
572: for (i=0;i < err->int1;i++)
573: buf[i] = ' ';
574: buf[i++] = '^';
575: buf[i] = 0;
576: channel(data, "%s\n", buf);
577: }
578: }
579:
580: static void
581: initializeLibxml2(void) {
582: xmlGetWarningsDefaultValue = 0;
583: xmlPedanticParserDefault(0);
584:
585: xmlMemSetup(xmlMemFree, xmlMemMalloc, xmlMemRealloc, xmlMemoryStrdup);
586: xmlInitParser();
587: xmlSetExternalEntityLoader(testExternalEntityLoader);
588: xmlSetStructuredErrorFunc(NULL, testStructuredErrorHandler);
589: /*
590: * register the new I/O handlers
591: */
592: if (xmlRegisterInputCallbacks(hugeMatch, hugeOpen,
593: hugeRead, hugeClose) < 0) {
594: fprintf(stderr, "failed to register Huge handler\n");
595: exit(1);
596: }
597: }
598:
599: /************************************************************************
600: * *
601: * File name and path utilities *
602: * *
603: ************************************************************************/
604:
605: static const char *baseFilename(const char *filename) {
606: const char *cur;
607: if (filename == NULL)
608: return(NULL);
609: cur = &filename[strlen(filename)];
610: while ((cur > filename) && (*cur != '/'))
611: cur--;
612: if (*cur == '/')
613: return(cur + 1);
614: return(cur);
615: }
616:
617: static char *resultFilename(const char *filename, const char *out,
618: const char *suffix) {
619: const char *base;
620: char res[500];
621: char suffixbuff[500];
622:
623: /*************
624: if ((filename[0] == 't') && (filename[1] == 'e') &&
625: (filename[2] == 's') && (filename[3] == 't') &&
626: (filename[4] == '/'))
627: filename = &filename[5];
628: *************/
629:
630: base = baseFilename(filename);
631: if (suffix == NULL)
632: suffix = ".tmp";
633: if (out == NULL)
634: out = "";
635:
636: strncpy(suffixbuff,suffix,499);
637: #ifdef VMS
638: if(strstr(base,".") && suffixbuff[0]=='.')
639: suffixbuff[0]='_';
640: #endif
641:
642: snprintf(res, 499, "%s%s%s", out, base, suffixbuff);
643: res[499] = 0;
644: return(strdup(res));
645: }
646:
647: static int checkTestFile(const char *filename) {
648: struct stat buf;
649:
650: if (stat(filename, &buf) == -1)
651: return(0);
652:
653: #if defined(_WIN32) && !defined(__CYGWIN__)
654: if (!(buf.st_mode & _S_IFREG))
655: return(0);
656: #else
657: if (!S_ISREG(buf.st_mode))
658: return(0);
659: #endif
660:
661: return(1);
662: }
663:
664:
665:
666: /************************************************************************
667: * *
668: * Test to detect or not recursive entities *
669: * *
670: ************************************************************************/
671: /**
672: * recursiveDetectTest:
673: * @filename: the file to parse
674: * @result: the file with expected result
675: * @err: the file with error messages: unused
676: *
677: * Parse a file loading DTD and replacing entities check it fails for
678: * lol cases
679: *
680: * Returns 0 in case of success, an error code otherwise
681: */
682: static int
683: recursiveDetectTest(const char *filename,
684: const char *result ATTRIBUTE_UNUSED,
685: const char *err ATTRIBUTE_UNUSED,
686: int options ATTRIBUTE_UNUSED) {
687: xmlDocPtr doc;
688: xmlParserCtxtPtr ctxt;
689: int res = 0;
690: int mem;
691:
692: nb_tests++;
693:
694: ctxt = xmlNewParserCtxt();
695: mem = xmlMemUsed();
696: /*
697: * base of the test, parse with the old API
698: */
699: doc = xmlCtxtReadFile(ctxt, filename, NULL,
700: XML_PARSE_NOENT | XML_PARSE_DTDLOAD);
701: if ((doc != NULL) || (ctxt->lastError.code != XML_ERR_ENTITY_LOOP)) {
702: fprintf(stderr, "Failed to detect recursion in %s\n", filename);
703: xmlFreeParserCtxt(ctxt);
704: xmlFreeDoc(doc);
705: return(1);
706: }
707: xmlFreeParserCtxt(ctxt);
708:
709: return(res);
710: }
711:
712: /**
713: * notRecursiveDetectTest:
714: * @filename: the file to parse
715: * @result: the file with expected result
716: * @err: the file with error messages: unused
717: *
718: * Parse a file loading DTD and replacing entities check it works for
719: * good cases
720: *
721: * Returns 0 in case of success, an error code otherwise
722: */
723: static int
724: notRecursiveDetectTest(const char *filename,
725: const char *result ATTRIBUTE_UNUSED,
726: const char *err ATTRIBUTE_UNUSED,
727: int options ATTRIBUTE_UNUSED) {
728: xmlDocPtr doc;
729: xmlParserCtxtPtr ctxt;
730: int res = 0;
731: int mem;
732:
733: nb_tests++;
734:
735: ctxt = xmlNewParserCtxt();
736: mem = xmlMemUsed();
737: /*
738: * base of the test, parse with the old API
739: */
740: doc = xmlCtxtReadFile(ctxt, filename, NULL,
741: XML_PARSE_NOENT | XML_PARSE_DTDLOAD);
742: if (doc == NULL) {
743: fprintf(stderr, "Failed to parse correct file %s\n", filename);
744: xmlFreeParserCtxt(ctxt);
745: return(1);
746: }
747: xmlFreeDoc(doc);
748: xmlFreeParserCtxt(ctxt);
749:
750: return(res);
751: }
752:
753: #ifdef LIBXML_READER_ENABLED
754: /**
755: * notRecursiveHugeTest:
756: * @filename: the file to parse
757: * @result: the file with expected result
758: * @err: the file with error messages: unused
759: *
760: * Parse a memory generated file
761: * good cases
762: *
763: * Returns 0 in case of success, an error code otherwise
764: */
765: static int
766: notRecursiveHugeTest(const char *filename ATTRIBUTE_UNUSED,
767: const char *result ATTRIBUTE_UNUSED,
768: const char *err ATTRIBUTE_UNUSED,
769: int options ATTRIBUTE_UNUSED) {
770: xmlTextReaderPtr reader;
771: int res = 0;
772: int ret;
773:
774: nb_tests++;
775:
776: reader = xmlReaderForFile("huge:test" , NULL,
777: XML_PARSE_NOENT | XML_PARSE_DTDLOAD);
778: if (reader == NULL) {
779: fprintf(stderr, "Failed to open huge:test\n");
780: return(1);
781: }
782: ret = xmlTextReaderRead(reader);
783: while (ret == 1) {
784: ret = xmlTextReaderRead(reader);
785: }
786: if (ret != 0) {
787: fprintf(stderr, "Failed to parser huge:test with entities\n");
788: res = 1;
789: }
790: xmlFreeTextReader(reader);
791:
792: return(res);
793: }
794: #endif
795:
796: /************************************************************************
797: * *
798: * Tests Descriptions *
799: * *
800: ************************************************************************/
801:
802: static
803: testDesc testDescriptions[] = {
804: { "Parsing recursive test cases" ,
805: recursiveDetectTest, "./test/recurse/lol*.xml", NULL, NULL, NULL,
806: 0 },
807: { "Parsing non-recursive test cases" ,
808: notRecursiveDetectTest, "./test/recurse/good*.xml", NULL, NULL, NULL,
809: 0 },
810: #ifdef LIBXML_READER_ENABLED
811: { "Parsing non-recursive huge case" ,
812: notRecursiveHugeTest, NULL, NULL, NULL, NULL,
813: 0 },
814: #endif
815: {NULL, NULL, NULL, NULL, NULL, NULL, 0}
816: };
817:
818: /************************************************************************
819: * *
820: * The main code driving the tests *
821: * *
822: ************************************************************************/
823:
824: static int
825: launchTests(testDescPtr tst) {
826: int res = 0, err = 0;
827: size_t i;
828: char *result;
829: char *error;
830: int mem;
831:
832: if (tst == NULL) return(-1);
833: if (tst->in != NULL) {
834: glob_t globbuf;
835:
836: globbuf.gl_offs = 0;
837: glob(tst->in, GLOB_DOOFFS, NULL, &globbuf);
838: for (i = 0;i < globbuf.gl_pathc;i++) {
839: if (!checkTestFile(globbuf.gl_pathv[i]))
840: continue;
841: if (tst->suffix != NULL) {
842: result = resultFilename(globbuf.gl_pathv[i], tst->out,
843: tst->suffix);
844: if (result == NULL) {
845: fprintf(stderr, "Out of memory !\n");
846: fatalError();
847: }
848: } else {
849: result = NULL;
850: }
851: if (tst->err != NULL) {
852: error = resultFilename(globbuf.gl_pathv[i], tst->out,
853: tst->err);
854: if (error == NULL) {
855: fprintf(stderr, "Out of memory !\n");
856: fatalError();
857: }
858: } else {
859: error = NULL;
860: }
861: if ((result) &&(!checkTestFile(result))) {
862: fprintf(stderr, "Missing result file %s\n", result);
863: } else if ((error) &&(!checkTestFile(error))) {
864: fprintf(stderr, "Missing error file %s\n", error);
865: } else {
866: mem = xmlMemUsed();
867: extraMemoryFromResolver = 0;
868: testErrorsSize = 0;
869: testErrors[0] = 0;
870: res = tst->func(globbuf.gl_pathv[i], result, error,
871: tst->options | XML_PARSE_COMPACT);
872: xmlResetLastError();
873: if (res != 0) {
874: fprintf(stderr, "File %s generated an error\n",
875: globbuf.gl_pathv[i]);
876: nb_errors++;
877: err++;
878: }
879: else if (xmlMemUsed() != mem) {
880: if ((xmlMemUsed() != mem) &&
881: (extraMemoryFromResolver == 0)) {
882: fprintf(stderr, "File %s leaked %d bytes\n",
883: globbuf.gl_pathv[i], xmlMemUsed() - mem);
884: nb_leaks++;
885: err++;
886: }
887: }
888: testErrorsSize = 0;
889: }
890: if (result)
891: free(result);
892: if (error)
893: free(error);
894: }
895: globfree(&globbuf);
896: } else {
897: testErrorsSize = 0;
898: testErrors[0] = 0;
899: extraMemoryFromResolver = 0;
900: res = tst->func(NULL, NULL, NULL, tst->options);
901: if (res != 0) {
902: nb_errors++;
903: err++;
904: }
905: }
906: return(err);
907: }
908:
909: static int verbose = 0;
910: static int tests_quiet = 0;
911:
912: static int
913: runtest(int i) {
914: int ret = 0, res;
915: int old_errors, old_tests, old_leaks;
916:
917: old_errors = nb_errors;
918: old_tests = nb_tests;
919: old_leaks = nb_leaks;
920: if ((tests_quiet == 0) && (testDescriptions[i].desc != NULL))
921: printf("## %s\n", testDescriptions[i].desc);
922: res = launchTests(&testDescriptions[i]);
923: if (res != 0)
924: ret++;
925: if (verbose) {
926: if ((nb_errors == old_errors) && (nb_leaks == old_leaks))
927: printf("Ran %d tests, no errors\n", nb_tests - old_tests);
928: else
929: printf("Ran %d tests, %d errors, %d leaks\n",
930: nb_tests - old_tests,
931: nb_errors - old_errors,
932: nb_leaks - old_leaks);
933: }
934: return(ret);
935: }
936:
937: int
938: main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
939: int i, a, ret = 0;
940: int subset = 0;
941:
942: initializeLibxml2();
943:
944: for (a = 1; a < argc;a++) {
945: if (!strcmp(argv[a], "-v"))
946: verbose = 1;
947: else if (!strcmp(argv[a], "-quiet"))
948: tests_quiet = 1;
949: else {
950: for (i = 0; testDescriptions[i].func != NULL; i++) {
951: if (strstr(testDescriptions[i].desc, argv[a])) {
952: ret += runtest(i);
953: subset++;
954: }
955: }
956: }
957: }
958: if (subset == 0) {
959: for (i = 0; testDescriptions[i].func != NULL; i++) {
960: ret += runtest(i);
961: }
962: }
963: if ((nb_errors == 0) && (nb_leaks == 0)) {
964: ret = 0;
965: printf("Total %d tests, no errors\n",
966: nb_tests);
967: } else {
968: ret = 1;
969: printf("Total %d tests, %d errors, %d leaks\n",
970: nb_tests, nb_errors, nb_leaks);
971: }
972: xmlCleanupParser();
973: xmlMemoryDump();
974:
975: return(ret);
976: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to testrecurse.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2