1: /*
2: * runtest.c: C program to run libxml2 regression tests without
3: * requiring make or Python, and reducing platform dependancies
4: * to a strict minimum.
5: *
6: * To compile on Unixes:
7: * cc -o runtest `xml2-config --cflags` runtest.c `xml2-config --libs` -lpthread
8: *
9: * See Copyright for the status of this software.
10: *
11: * daniel@veillard.com
12: */
13:
14: #ifdef HAVE_CONFIG_H
15: #include "libxml.h"
16: #else
17: #include <stdio.h>
18: #endif
19:
20: #if !defined(_WIN32) || defined(__CYGWIN__)
21: #include <unistd.h>
22: #endif
23: #include <string.h>
24: #include <sys/types.h>
25: #include <sys/stat.h>
26: #include <fcntl.h>
27:
28: #include <libxml/parser.h>
29: #include <libxml/tree.h>
30: #include <libxml/uri.h>
31:
32: #ifdef LIBXML_OUTPUT_ENABLED
33: #ifdef LIBXML_READER_ENABLED
34: #include <libxml/xmlreader.h>
35: #endif
36:
37: #ifdef LIBXML_XINCLUDE_ENABLED
38: #include <libxml/xinclude.h>
39: #endif
40:
41: #ifdef LIBXML_XPATH_ENABLED
42: #include <libxml/xpath.h>
43: #include <libxml/xpathInternals.h>
44: #ifdef LIBXML_XPTR_ENABLED
45: #include <libxml/xpointer.h>
46: #endif
47: #endif
48:
49: #ifdef LIBXML_SCHEMAS_ENABLED
50: #include <libxml/relaxng.h>
51: #include <libxml/xmlschemas.h>
52: #include <libxml/xmlschemastypes.h>
53: #endif
54:
55: #ifdef LIBXML_PATTERN_ENABLED
56: #include <libxml/pattern.h>
57: #endif
58:
59: #ifdef LIBXML_C14N_ENABLED
60: #include <libxml/c14n.h>
61: #endif
62:
63: #ifdef LIBXML_HTML_ENABLED
64: #include <libxml/HTMLparser.h>
65: #include <libxml/HTMLtree.h>
66:
67: /*
68: * pseudo flag for the unification of HTML and XML tests
69: */
70: #define XML_PARSE_HTML 1 << 24
71: #endif
72:
73: #if defined(LIBXML_THREAD_ENABLED) && defined(LIBXML_CATALOG_ENABLED)
74: #include <libxml/globals.h>
75: #include <libxml/threads.h>
76: #include <libxml/parser.h>
77: #include <libxml/catalog.h>
78: #include <string.h>
79: #endif
80:
81: /*
82: * O_BINARY is just for Windows compatibility - if it isn't defined
83: * on this system, avoid any compilation error
84: */
85: #ifdef O_BINARY
86: #define RD_FLAGS O_RDONLY | O_BINARY
87: #else
88: #define RD_FLAGS O_RDONLY
89: #endif
90:
91: typedef int (*functest) (const char *filename, const char *result,
92: const char *error, int options);
93:
94: typedef struct testDesc testDesc;
95: typedef testDesc *testDescPtr;
96: struct testDesc {
97: const char *desc; /* descripton of the test */
98: functest func; /* function implementing the test */
99: const char *in; /* glob to path for input files */
100: const char *out; /* output directory */
101: const char *suffix;/* suffix for output files */
102: const char *err; /* suffix for error output files */
103: int options; /* parser options for the test */
104: };
105:
106: static int checkTestFile(const char *filename);
107:
108: #if defined(_WIN32) && !defined(__CYGWIN__)
109:
110: #include <windows.h>
111: #include <io.h>
112:
113: typedef struct
114: {
115: size_t gl_pathc; /* Count of paths matched so far */
116: char **gl_pathv; /* List of matched pathnames. */
117: size_t gl_offs; /* Slots to reserve in 'gl_pathv'. */
118: } glob_t;
119:
120: #define GLOB_DOOFFS 0
121: static int glob(const char *pattern, int flags,
122: int errfunc(const char *epath, int eerrno),
123: glob_t *pglob) {
124: glob_t *ret;
125: WIN32_FIND_DATA FindFileData;
126: HANDLE hFind;
127: unsigned int nb_paths = 0;
128: char directory[500];
129: int len;
130:
131: if ((pattern == NULL) || (pglob == NULL)) return(-1);
132:
133: strncpy(directory, pattern, 499);
134: for (len = strlen(directory);len >= 0;len--) {
135: if (directory[len] == '/') {
136: len++;
137: directory[len] = 0;
138: break;
139: }
140: }
141: if (len <= 0)
142: len = 0;
143:
144:
145: ret = pglob;
146: memset(ret, 0, sizeof(glob_t));
147:
148: hFind = FindFirstFileA(pattern, &FindFileData);
149: if (hFind == INVALID_HANDLE_VALUE)
150: return(0);
151: nb_paths = 20;
152: ret->gl_pathv = (char **) malloc(nb_paths * sizeof(char *));
153: if (ret->gl_pathv == NULL) {
154: FindClose(hFind);
155: return(-1);
156: }
157: strncpy(directory + len, FindFileData.cFileName, 499 - len);
158: ret->gl_pathv[ret->gl_pathc] = strdup(directory);
159: if (ret->gl_pathv[ret->gl_pathc] == NULL)
160: goto done;
161: ret->gl_pathc++;
162: while(FindNextFileA(hFind, &FindFileData)) {
163: if (FindFileData.cFileName[0] == '.')
164: continue;
165: if (ret->gl_pathc + 2 > nb_paths) {
166: char **tmp = realloc(ret->gl_pathv, nb_paths * 2 * sizeof(char *));
167: if (tmp == NULL)
168: break;
169: ret->gl_pathv = tmp;
170: nb_paths *= 2;
171: }
172: strncpy(directory + len, FindFileData.cFileName, 499 - len);
173: ret->gl_pathv[ret->gl_pathc] = strdup(directory);
174: if (ret->gl_pathv[ret->gl_pathc] == NULL)
175: break;
176: ret->gl_pathc++;
177: }
178: ret->gl_pathv[ret->gl_pathc] = NULL;
179:
180: done:
181: FindClose(hFind);
182: return(0);
183: }
184:
185:
186:
187: static void globfree(glob_t *pglob) {
188: unsigned int i;
189: if (pglob == NULL)
190: return;
191:
192: for (i = 0;i < pglob->gl_pathc;i++) {
193: if (pglob->gl_pathv[i] != NULL)
194: free(pglob->gl_pathv[i]);
195: }
196: }
197: #define vsnprintf _vsnprintf
198: #define snprintf _snprintf
199: #else
200: #include <glob.h>
201: #endif
202:
203: /************************************************************************
204: * *
205: * Libxml2 specific routines *
206: * *
207: ************************************************************************/
208:
209: static int nb_tests = 0;
210: static int nb_errors = 0;
211: static int nb_leaks = 0;
212: static int extraMemoryFromResolver = 0;
213:
214: static int
215: fatalError(void) {
216: fprintf(stderr, "Exitting tests on fatal error\n");
217: exit(1);
218: }
219:
220: /*
221: * We need to trap calls to the resolver to not account memory for the catalog
222: * which is shared to the current running test. We also don't want to have
223: * network downloads modifying tests.
224: */
225: static xmlParserInputPtr
226: testExternalEntityLoader(const char *URL, const char *ID,
227: xmlParserCtxtPtr ctxt) {
228: xmlParserInputPtr ret;
229:
230: if (checkTestFile(URL)) {
231: ret = xmlNoNetExternalEntityLoader(URL, ID, ctxt);
232: } else {
233: int memused = xmlMemUsed();
234: ret = xmlNoNetExternalEntityLoader(URL, ID, ctxt);
235: extraMemoryFromResolver += xmlMemUsed() - memused;
236: }
237:
238: return(ret);
239: }
240:
241: /*
242: * Trapping the error messages at the generic level to grab the equivalent of
243: * stderr messages on CLI tools.
244: */
245: static char testErrors[32769];
246: static int testErrorsSize = 0;
247:
248: static void XMLCDECL
249: testErrorHandler(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...) {
250: va_list args;
251: int res;
252:
253: if (testErrorsSize >= 32768)
254: return;
255: va_start(args, msg);
256: res = vsnprintf(&testErrors[testErrorsSize],
257: 32768 - testErrorsSize,
258: msg, args);
259: va_end(args);
260: if (testErrorsSize + res >= 32768) {
261: /* buffer is full */
262: testErrorsSize = 32768;
263: testErrors[testErrorsSize] = 0;
264: } else {
265: testErrorsSize += res;
266: }
267: testErrors[testErrorsSize] = 0;
268: }
269:
270: static void XMLCDECL
271: channel(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...) {
272: va_list args;
273: int res;
274:
275: if (testErrorsSize >= 32768)
276: return;
277: va_start(args, msg);
278: res = vsnprintf(&testErrors[testErrorsSize],
279: 32768 - testErrorsSize,
280: msg, args);
281: va_end(args);
282: if (testErrorsSize + res >= 32768) {
283: /* buffer is full */
284: testErrorsSize = 32768;
285: testErrors[testErrorsSize] = 0;
286: } else {
287: testErrorsSize += res;
288: }
289: testErrors[testErrorsSize] = 0;
290: }
291:
292: /**
293: * xmlParserPrintFileContext:
294: * @input: an xmlParserInputPtr input
295: *
296: * Displays current context within the input content for error tracking
297: */
298:
299: static void
300: xmlParserPrintFileContextInternal(xmlParserInputPtr input ,
301: xmlGenericErrorFunc chanl, void *data ) {
302: const xmlChar *cur, *base;
303: unsigned int n, col; /* GCC warns if signed, because compared with sizeof() */
304: xmlChar content[81]; /* space for 80 chars + line terminator */
305: xmlChar *ctnt;
306:
307: if (input == NULL) return;
308: cur = input->cur;
309: base = input->base;
310: /* skip backwards over any end-of-lines */
311: while ((cur > base) && ((*(cur) == '\n') || (*(cur) == '\r'))) {
312: cur--;
313: }
314: n = 0;
315: /* search backwards for beginning-of-line (to max buff size) */
316: while ((n++ < (sizeof(content)-1)) && (cur > base) &&
317: (*(cur) != '\n') && (*(cur) != '\r'))
318: cur--;
319: if ((*(cur) == '\n') || (*(cur) == '\r')) cur++;
320: /* calculate the error position in terms of the current position */
321: col = input->cur - cur;
322: /* search forward for end-of-line (to max buff size) */
323: n = 0;
324: ctnt = content;
325: /* copy selected text to our buffer */
326: while ((*cur != 0) && (*(cur) != '\n') &&
327: (*(cur) != '\r') && (n < sizeof(content)-1)) {
328: *ctnt++ = *cur++;
329: n++;
330: }
331: *ctnt = 0;
332: /* print out the selected text */
333: chanl(data ,"%s\n", content);
334: /* create blank line with problem pointer */
335: n = 0;
336: ctnt = content;
337: /* (leave buffer space for pointer + line terminator) */
338: while ((n<col) && (n++ < sizeof(content)-2) && (*ctnt != 0)) {
339: if (*(ctnt) != '\t')
340: *(ctnt) = ' ';
341: ctnt++;
342: }
343: *ctnt++ = '^';
344: *ctnt = 0;
345: chanl(data ,"%s\n", content);
346: }
347:
348: static void
349: testStructuredErrorHandler(void *ctx ATTRIBUTE_UNUSED, xmlErrorPtr err) {
350: char *file = NULL;
351: int line = 0;
352: int code = -1;
353: int domain;
354: void *data = NULL;
355: const char *str;
356: const xmlChar *name = NULL;
357: xmlNodePtr node;
358: xmlErrorLevel level;
359: xmlParserInputPtr input = NULL;
360: xmlParserInputPtr cur = NULL;
361: xmlParserCtxtPtr ctxt = NULL;
362:
363: if (err == NULL)
364: return;
365:
366: file = err->file;
367: line = err->line;
368: code = err->code;
369: domain = err->domain;
370: level = err->level;
371: node = err->node;
372: if ((domain == XML_FROM_PARSER) || (domain == XML_FROM_HTML) ||
373: (domain == XML_FROM_DTD) || (domain == XML_FROM_NAMESPACE) ||
374: (domain == XML_FROM_IO) || (domain == XML_FROM_VALID)) {
375: ctxt = err->ctxt;
376: }
377: str = err->message;
378:
379: if (code == XML_ERR_OK)
380: return;
381:
382: if ((node != NULL) && (node->type == XML_ELEMENT_NODE))
383: name = node->name;
384:
385: /*
386: * Maintain the compatibility with the legacy error handling
387: */
388: if (ctxt != NULL) {
389: input = ctxt->input;
390: if ((input != NULL) && (input->filename == NULL) &&
391: (ctxt->inputNr > 1)) {
392: cur = input;
393: input = ctxt->inputTab[ctxt->inputNr - 2];
394: }
395: if (input != NULL) {
396: if (input->filename)
397: channel(data, "%s:%d: ", input->filename, input->line);
398: else if ((line != 0) && (domain == XML_FROM_PARSER))
399: channel(data, "Entity: line %d: ", input->line);
400: }
401: } else {
402: if (file != NULL)
403: channel(data, "%s:%d: ", file, line);
404: else if ((line != 0) && (domain == XML_FROM_PARSER))
405: channel(data, "Entity: line %d: ", line);
406: }
407: if (name != NULL) {
408: channel(data, "element %s: ", name);
409: }
410: if (code == XML_ERR_OK)
411: return;
412: switch (domain) {
413: case XML_FROM_PARSER:
414: channel(data, "parser ");
415: break;
416: case XML_FROM_NAMESPACE:
417: channel(data, "namespace ");
418: break;
419: case XML_FROM_DTD:
420: case XML_FROM_VALID:
421: channel(data, "validity ");
422: break;
423: case XML_FROM_HTML:
424: channel(data, "HTML parser ");
425: break;
426: case XML_FROM_MEMORY:
427: channel(data, "memory ");
428: break;
429: case XML_FROM_OUTPUT:
430: channel(data, "output ");
431: break;
432: case XML_FROM_IO:
433: channel(data, "I/O ");
434: break;
435: case XML_FROM_XINCLUDE:
436: channel(data, "XInclude ");
437: break;
438: case XML_FROM_XPATH:
439: channel(data, "XPath ");
440: break;
441: case XML_FROM_XPOINTER:
442: channel(data, "parser ");
443: break;
444: case XML_FROM_REGEXP:
445: channel(data, "regexp ");
446: break;
447: case XML_FROM_MODULE:
448: channel(data, "module ");
449: break;
450: case XML_FROM_SCHEMASV:
451: channel(data, "Schemas validity ");
452: break;
453: case XML_FROM_SCHEMASP:
454: channel(data, "Schemas parser ");
455: break;
456: case XML_FROM_RELAXNGP:
457: channel(data, "Relax-NG parser ");
458: break;
459: case XML_FROM_RELAXNGV:
460: channel(data, "Relax-NG validity ");
461: break;
462: case XML_FROM_CATALOG:
463: channel(data, "Catalog ");
464: break;
465: case XML_FROM_C14N:
466: channel(data, "C14N ");
467: break;
468: case XML_FROM_XSLT:
469: channel(data, "XSLT ");
470: break;
471: default:
472: break;
473: }
474: if (code == XML_ERR_OK)
475: return;
476: switch (level) {
477: case XML_ERR_NONE:
478: channel(data, ": ");
479: break;
480: case XML_ERR_WARNING:
481: channel(data, "warning : ");
482: break;
483: case XML_ERR_ERROR:
484: channel(data, "error : ");
485: break;
486: case XML_ERR_FATAL:
487: channel(data, "error : ");
488: break;
489: }
490: if (code == XML_ERR_OK)
491: return;
492: if (str != NULL) {
493: int len;
494: len = xmlStrlen((const xmlChar *)str);
495: if ((len > 0) && (str[len - 1] != '\n'))
496: channel(data, "%s\n", str);
497: else
498: channel(data, "%s", str);
499: } else {
500: channel(data, "%s\n", "out of memory error");
501: }
502: if (code == XML_ERR_OK)
503: return;
504:
505: if (ctxt != NULL) {
506: xmlParserPrintFileContextInternal(input, channel, data);
507: if (cur != NULL) {
508: if (cur->filename)
509: channel(data, "%s:%d: \n", cur->filename, cur->line);
510: else if ((line != 0) && (domain == XML_FROM_PARSER))
511: channel(data, "Entity: line %d: \n", cur->line);
512: xmlParserPrintFileContextInternal(cur, channel, data);
513: }
514: }
515: if ((domain == XML_FROM_XPATH) && (err->str1 != NULL) &&
516: (err->int1 < 100) &&
517: (err->int1 < xmlStrlen((const xmlChar *)err->str1))) {
518: xmlChar buf[150];
519: int i;
520:
521: channel(data, "%s\n", err->str1);
522: for (i=0;i < err->int1;i++)
523: buf[i] = ' ';
524: buf[i++] = '^';
525: buf[i] = 0;
526: channel(data, "%s\n", buf);
527: }
528: }
529:
530: static void
531: initializeLibxml2(void) {
532: xmlGetWarningsDefaultValue = 0;
533: xmlPedanticParserDefault(0);
534:
535: xmlMemSetup(xmlMemFree, xmlMemMalloc, xmlMemRealloc, xmlMemoryStrdup);
536: xmlInitParser();
537: xmlSetExternalEntityLoader(testExternalEntityLoader);
538: xmlSetStructuredErrorFunc(NULL, testStructuredErrorHandler);
539: #ifdef LIBXML_SCHEMAS_ENABLED
540: xmlSchemaInitTypes();
541: xmlRelaxNGInitTypes();
542: #endif
543: }
544:
545:
546: /************************************************************************
547: * *
548: * File name and path utilities *
549: * *
550: ************************************************************************/
551:
552: static const char *baseFilename(const char *filename) {
553: const char *cur;
554: if (filename == NULL)
555: return(NULL);
556: cur = &filename[strlen(filename)];
557: while ((cur > filename) && (*cur != '/'))
558: cur--;
559: if (*cur == '/')
560: return(cur + 1);
561: return(cur);
562: }
563:
564: static char *resultFilename(const char *filename, const char *out,
565: const char *suffix) {
566: const char *base;
567: char res[500];
568: char suffixbuff[500];
569:
570: /*************
571: if ((filename[0] == 't') && (filename[1] == 'e') &&
572: (filename[2] == 's') && (filename[3] == 't') &&
573: (filename[4] == '/'))
574: filename = &filename[5];
575: *************/
576:
577: base = baseFilename(filename);
578: if (suffix == NULL)
579: suffix = ".tmp";
580: if (out == NULL)
581: out = "";
582:
583: strncpy(suffixbuff,suffix,499);
584: #ifdef VMS
585: if(strstr(base,".") && suffixbuff[0]=='.')
586: suffixbuff[0]='_';
587: #endif
588:
589: snprintf(res, 499, "%s%s%s", out, base, suffixbuff);
590: res[499] = 0;
591: return(strdup(res));
592: }
593:
594: static int checkTestFile(const char *filename) {
595: struct stat buf;
596:
597: if (stat(filename, &buf) == -1)
598: return(0);
599:
600: #if defined(_WIN32) && !defined(__CYGWIN__)
601: if (!(buf.st_mode & _S_IFREG))
602: return(0);
603: #else
604: if (!S_ISREG(buf.st_mode))
605: return(0);
606: #endif
607:
608: return(1);
609: }
610:
611: static int compareFiles(const char *r1, const char *r2) {
612: int res1, res2;
613: int fd1, fd2;
614: char bytes1[4096];
615: char bytes2[4096];
616:
617: fd1 = open(r1, RD_FLAGS);
618: if (fd1 < 0)
619: return(-1);
620: fd2 = open(r2, RD_FLAGS);
621: if (fd2 < 0) {
622: close(fd1);
623: return(-1);
624: }
625: while (1) {
626: res1 = read(fd1, bytes1, 4096);
627: res2 = read(fd2, bytes2, 4096);
628: if ((res1 != res2) || (res1 < 0)) {
629: close(fd1);
630: close(fd2);
631: return(1);
632: }
633: if (res1 == 0)
634: break;
635: if (memcmp(bytes1, bytes2, res1) != 0) {
636: close(fd1);
637: close(fd2);
638: return(1);
639: }
640: }
641: close(fd1);
642: close(fd2);
643: return(0);
644: }
645:
646: static int compareFileMem(const char *filename, const char *mem, int size) {
647: int res;
648: int fd;
649: char bytes[4096];
650: int idx = 0;
651: struct stat info;
652:
653: if (stat(filename, &info) < 0)
654: return(-1);
655: if (info.st_size != size)
656: return(-1);
657: fd = open(filename, RD_FLAGS);
658: if (fd < 0)
659: return(-1);
660: while (idx < size) {
661: res = read(fd, bytes, 4096);
662: if (res <= 0)
663: break;
664: if (res + idx > size)
665: break;
666: if (memcmp(bytes, &mem[idx], res) != 0) {
667: int ix;
668: for (ix=0; ix<res; ix++)
669: if (bytes[ix] != mem[idx+ix])
670: break;
671: fprintf(stderr,"Compare error at position %d\n", idx+ix);
672: close(fd);
673: return(1);
674: }
675: idx += res;
676: }
677: close(fd);
678: return(idx != size);
679: }
680:
681: static int loadMem(const char *filename, const char **mem, int *size) {
682: int fd, res;
683: struct stat info;
684: char *base;
685: int siz = 0;
686: if (stat(filename, &info) < 0)
687: return(-1);
688: base = malloc(info.st_size + 1);
689: if (base == NULL)
690: return(-1);
691: if ((fd = open(filename, RD_FLAGS)) < 0) {
692: free(base);
693: return(-1);
694: }
695: while ((res = read(fd, &base[siz], info.st_size - siz)) > 0) {
696: siz += res;
697: }
698: close(fd);
699: #if !defined(_WIN32)
700: if (siz != info.st_size) {
701: free(base);
702: return(-1);
703: }
704: #endif
705: base[siz] = 0;
706: *mem = base;
707: *size = siz;
708: return(0);
709: }
710:
711: static int unloadMem(const char *mem) {
712: free((char *)mem);
713: return(0);
714: }
715:
716: /************************************************************************
717: * *
718: * Tests implementations *
719: * *
720: ************************************************************************/
721:
722: /************************************************************************
723: * *
724: * Parse to SAX based tests *
725: * *
726: ************************************************************************/
727:
728: static FILE *SAXdebug = NULL;
729:
730: /*
731: * empty SAX block
732: */
733: static xmlSAXHandler emptySAXHandlerStruct = {
734: NULL, /* internalSubset */
735: NULL, /* isStandalone */
736: NULL, /* hasInternalSubset */
737: NULL, /* hasExternalSubset */
738: NULL, /* resolveEntity */
739: NULL, /* getEntity */
740: NULL, /* entityDecl */
741: NULL, /* notationDecl */
742: NULL, /* attributeDecl */
743: NULL, /* elementDecl */
744: NULL, /* unparsedEntityDecl */
745: NULL, /* setDocumentLocator */
746: NULL, /* startDocument */
747: NULL, /* endDocument */
748: NULL, /* startElement */
749: NULL, /* endElement */
750: NULL, /* reference */
751: NULL, /* characters */
752: NULL, /* ignorableWhitespace */
753: NULL, /* processingInstruction */
754: NULL, /* comment */
755: NULL, /* xmlParserWarning */
756: NULL, /* xmlParserError */
757: NULL, /* xmlParserError */
758: NULL, /* getParameterEntity */
759: NULL, /* cdataBlock; */
760: NULL, /* externalSubset; */
761: 1,
762: NULL,
763: NULL, /* startElementNs */
764: NULL, /* endElementNs */
765: NULL /* xmlStructuredErrorFunc */
766: };
767:
768: static xmlSAXHandlerPtr emptySAXHandler = &emptySAXHandlerStruct;
769: static int callbacks = 0;
770: static int quiet = 0;
771:
772: /**
773: * isStandaloneDebug:
774: * @ctxt: An XML parser context
775: *
776: * Is this document tagged standalone ?
777: *
778: * Returns 1 if true
779: */
780: static int
781: isStandaloneDebug(void *ctx ATTRIBUTE_UNUSED)
782: {
783: callbacks++;
784: if (quiet)
785: return(0);
786: fprintf(SAXdebug, "SAX.isStandalone()\n");
787: return(0);
788: }
789:
790: /**
791: * hasInternalSubsetDebug:
792: * @ctxt: An XML parser context
793: *
794: * Does this document has an internal subset
795: *
796: * Returns 1 if true
797: */
798: static int
799: hasInternalSubsetDebug(void *ctx ATTRIBUTE_UNUSED)
800: {
801: callbacks++;
802: if (quiet)
803: return(0);
804: fprintf(SAXdebug, "SAX.hasInternalSubset()\n");
805: return(0);
806: }
807:
808: /**
809: * hasExternalSubsetDebug:
810: * @ctxt: An XML parser context
811: *
812: * Does this document has an external subset
813: *
814: * Returns 1 if true
815: */
816: static int
817: hasExternalSubsetDebug(void *ctx ATTRIBUTE_UNUSED)
818: {
819: callbacks++;
820: if (quiet)
821: return(0);
822: fprintf(SAXdebug, "SAX.hasExternalSubset()\n");
823: return(0);
824: }
825:
826: /**
827: * internalSubsetDebug:
828: * @ctxt: An XML parser context
829: *
830: * Does this document has an internal subset
831: */
832: static void
833: internalSubsetDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
834: const xmlChar *ExternalID, const xmlChar *SystemID)
835: {
836: callbacks++;
837: if (quiet)
838: return;
839: fprintf(SAXdebug, "SAX.internalSubset(%s,", name);
840: if (ExternalID == NULL)
841: fprintf(SAXdebug, " ,");
842: else
843: fprintf(SAXdebug, " %s,", ExternalID);
844: if (SystemID == NULL)
845: fprintf(SAXdebug, " )\n");
846: else
847: fprintf(SAXdebug, " %s)\n", SystemID);
848: }
849:
850: /**
851: * externalSubsetDebug:
852: * @ctxt: An XML parser context
853: *
854: * Does this document has an external subset
855: */
856: static void
857: externalSubsetDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
858: const xmlChar *ExternalID, const xmlChar *SystemID)
859: {
860: callbacks++;
861: if (quiet)
862: return;
863: fprintf(SAXdebug, "SAX.externalSubset(%s,", name);
864: if (ExternalID == NULL)
865: fprintf(SAXdebug, " ,");
866: else
867: fprintf(SAXdebug, " %s,", ExternalID);
868: if (SystemID == NULL)
869: fprintf(SAXdebug, " )\n");
870: else
871: fprintf(SAXdebug, " %s)\n", SystemID);
872: }
873:
874: /**
875: * resolveEntityDebug:
876: * @ctxt: An XML parser context
877: * @publicId: The public ID of the entity
878: * @systemId: The system ID of the entity
879: *
880: * Special entity resolver, better left to the parser, it has
881: * more context than the application layer.
882: * The default behaviour is to NOT resolve the entities, in that case
883: * the ENTITY_REF nodes are built in the structure (and the parameter
884: * values).
885: *
886: * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
887: */
888: static xmlParserInputPtr
889: resolveEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *publicId, const xmlChar *systemId)
890: {
891: callbacks++;
892: if (quiet)
893: return(NULL);
894: /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
895:
896:
897: fprintf(SAXdebug, "SAX.resolveEntity(");
898: if (publicId != NULL)
899: fprintf(SAXdebug, "%s", (char *)publicId);
900: else
901: fprintf(SAXdebug, " ");
902: if (systemId != NULL)
903: fprintf(SAXdebug, ", %s)\n", (char *)systemId);
904: else
905: fprintf(SAXdebug, ", )\n");
906: /*********
907: if (systemId != NULL) {
908: return(xmlNewInputFromFile(ctxt, (char *) systemId));
909: }
910: *********/
911: return(NULL);
912: }
913:
914: /**
915: * getEntityDebug:
916: * @ctxt: An XML parser context
917: * @name: The entity name
918: *
919: * Get an entity by name
920: *
921: * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
922: */
923: static xmlEntityPtr
924: getEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
925: {
926: callbacks++;
927: if (quiet)
928: return(NULL);
929: fprintf(SAXdebug, "SAX.getEntity(%s)\n", name);
930: return(NULL);
931: }
932:
933: /**
934: * getParameterEntityDebug:
935: * @ctxt: An XML parser context
936: * @name: The entity name
937: *
938: * Get a parameter entity by name
939: *
940: * Returns the xmlParserInputPtr
941: */
942: static xmlEntityPtr
943: getParameterEntityDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
944: {
945: callbacks++;
946: if (quiet)
947: return(NULL);
948: fprintf(SAXdebug, "SAX.getParameterEntity(%s)\n", name);
949: return(NULL);
950: }
951:
952:
953: /**
954: * entityDeclDebug:
955: * @ctxt: An XML parser context
956: * @name: the entity name
957: * @type: the entity type
958: * @publicId: The public ID of the entity
959: * @systemId: The system ID of the entity
960: * @content: the entity value (without processing).
961: *
962: * An entity definition has been parsed
963: */
964: static void
965: entityDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, int type,
966: const xmlChar *publicId, const xmlChar *systemId, xmlChar *content)
967: {
968: const xmlChar *nullstr = BAD_CAST "(null)";
969: /* not all libraries handle printing null pointers nicely */
970: if (publicId == NULL)
971: publicId = nullstr;
972: if (systemId == NULL)
973: systemId = nullstr;
974: if (content == NULL)
975: content = (xmlChar *)nullstr;
976: callbacks++;
977: if (quiet)
978: return;
979: fprintf(SAXdebug, "SAX.entityDecl(%s, %d, %s, %s, %s)\n",
980: name, type, publicId, systemId, content);
981: }
982:
983: /**
984: * attributeDeclDebug:
985: * @ctxt: An XML parser context
986: * @name: the attribute name
987: * @type: the attribute type
988: *
989: * An attribute definition has been parsed
990: */
991: static void
992: attributeDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar * elem,
993: const xmlChar * name, int type, int def,
994: const xmlChar * defaultValue, xmlEnumerationPtr tree)
995: {
996: callbacks++;
997: if (quiet)
998: return;
999: if (defaultValue == NULL)
1000: fprintf(SAXdebug, "SAX.attributeDecl(%s, %s, %d, %d, NULL, ...)\n",
1001: elem, name, type, def);
1002: else
1003: fprintf(SAXdebug, "SAX.attributeDecl(%s, %s, %d, %d, %s, ...)\n",
1004: elem, name, type, def, defaultValue);
1005: xmlFreeEnumeration(tree);
1006: }
1007:
1008: /**
1009: * elementDeclDebug:
1010: * @ctxt: An XML parser context
1011: * @name: the element name
1012: * @type: the element type
1013: * @content: the element value (without processing).
1014: *
1015: * An element definition has been parsed
1016: */
1017: static void
1018: elementDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, int type,
1019: xmlElementContentPtr content ATTRIBUTE_UNUSED)
1020: {
1021: callbacks++;
1022: if (quiet)
1023: return;
1024: fprintf(SAXdebug, "SAX.elementDecl(%s, %d, ...)\n",
1025: name, type);
1026: }
1027:
1028: /**
1029: * notationDeclDebug:
1030: * @ctxt: An XML parser context
1031: * @name: The name of the notation
1032: * @publicId: The public ID of the entity
1033: * @systemId: The system ID of the entity
1034: *
1035: * What to do when a notation declaration has been parsed.
1036: */
1037: static void
1038: notationDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
1039: const xmlChar *publicId, const xmlChar *systemId)
1040: {
1041: callbacks++;
1042: if (quiet)
1043: return;
1044: fprintf(SAXdebug, "SAX.notationDecl(%s, %s, %s)\n",
1045: (char *) name, (char *) publicId, (char *) systemId);
1046: }
1047:
1048: /**
1049: * unparsedEntityDeclDebug:
1050: * @ctxt: An XML parser context
1051: * @name: The name of the entity
1052: * @publicId: The public ID of the entity
1053: * @systemId: The system ID of the entity
1054: * @notationName: the name of the notation
1055: *
1056: * What to do when an unparsed entity declaration is parsed
1057: */
1058: static void
1059: unparsedEntityDeclDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name,
1060: const xmlChar *publicId, const xmlChar *systemId,
1061: const xmlChar *notationName)
1062: {
1063: const xmlChar *nullstr = BAD_CAST "(null)";
1064:
1065: if (publicId == NULL)
1066: publicId = nullstr;
1067: if (systemId == NULL)
1068: systemId = nullstr;
1069: if (notationName == NULL)
1070: notationName = nullstr;
1071: callbacks++;
1072: if (quiet)
1073: return;
1074: fprintf(SAXdebug, "SAX.unparsedEntityDecl(%s, %s, %s, %s)\n",
1075: (char *) name, (char *) publicId, (char *) systemId,
1076: (char *) notationName);
1077: }
1078:
1079: /**
1080: * setDocumentLocatorDebug:
1081: * @ctxt: An XML parser context
1082: * @loc: A SAX Locator
1083: *
1084: * Receive the document locator at startup, actually xmlDefaultSAXLocator
1085: * Everything is available on the context, so this is useless in our case.
1086: */
1087: static void
1088: setDocumentLocatorDebug(void *ctx ATTRIBUTE_UNUSED, xmlSAXLocatorPtr loc ATTRIBUTE_UNUSED)
1089: {
1090: callbacks++;
1091: if (quiet)
1092: return;
1093: fprintf(SAXdebug, "SAX.setDocumentLocator()\n");
1094: }
1095:
1096: /**
1097: * startDocumentDebug:
1098: * @ctxt: An XML parser context
1099: *
1100: * called when the document start being processed.
1101: */
1102: static void
1103: startDocumentDebug(void *ctx ATTRIBUTE_UNUSED)
1104: {
1105: callbacks++;
1106: if (quiet)
1107: return;
1108: fprintf(SAXdebug, "SAX.startDocument()\n");
1109: }
1110:
1111: /**
1112: * endDocumentDebug:
1113: * @ctxt: An XML parser context
1114: *
1115: * called when the document end has been detected.
1116: */
1117: static void
1118: endDocumentDebug(void *ctx ATTRIBUTE_UNUSED)
1119: {
1120: callbacks++;
1121: if (quiet)
1122: return;
1123: fprintf(SAXdebug, "SAX.endDocument()\n");
1124: }
1125:
1126: /**
1127: * startElementDebug:
1128: * @ctxt: An XML parser context
1129: * @name: The element name
1130: *
1131: * called when an opening tag has been processed.
1132: */
1133: static void
1134: startElementDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, const xmlChar **atts)
1135: {
1136: int i;
1137:
1138: callbacks++;
1139: if (quiet)
1140: return;
1141: fprintf(SAXdebug, "SAX.startElement(%s", (char *) name);
1142: if (atts != NULL) {
1143: for (i = 0;(atts[i] != NULL);i++) {
1144: fprintf(SAXdebug, ", %s='", atts[i++]);
1145: if (atts[i] != NULL)
1146: fprintf(SAXdebug, "%s'", atts[i]);
1147: }
1148: }
1149: fprintf(SAXdebug, ")\n");
1150: }
1151:
1152: /**
1153: * endElementDebug:
1154: * @ctxt: An XML parser context
1155: * @name: The element name
1156: *
1157: * called when the end of an element has been detected.
1158: */
1159: static void
1160: endElementDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
1161: {
1162: callbacks++;
1163: if (quiet)
1164: return;
1165: fprintf(SAXdebug, "SAX.endElement(%s)\n", (char *) name);
1166: }
1167:
1168: /**
1169: * charactersDebug:
1170: * @ctxt: An XML parser context
1171: * @ch: a xmlChar string
1172: * @len: the number of xmlChar
1173: *
1174: * receiving some chars from the parser.
1175: * Question: how much at a time ???
1176: */
1177: static void
1178: charactersDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch, int len)
1179: {
1180: char output[40];
1181: int i;
1182:
1183: callbacks++;
1184: if (quiet)
1185: return;
1186: for (i = 0;(i<len) && (i < 30);i++)
1187: output[i] = ch[i];
1188: output[i] = 0;
1189:
1190: fprintf(SAXdebug, "SAX.characters(%s, %d)\n", output, len);
1191: }
1192:
1193: /**
1194: * referenceDebug:
1195: * @ctxt: An XML parser context
1196: * @name: The entity name
1197: *
1198: * called when an entity reference is detected.
1199: */
1200: static void
1201: referenceDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name)
1202: {
1203: callbacks++;
1204: if (quiet)
1205: return;
1206: fprintf(SAXdebug, "SAX.reference(%s)\n", name);
1207: }
1208:
1209: /**
1210: * ignorableWhitespaceDebug:
1211: * @ctxt: An XML parser context
1212: * @ch: a xmlChar string
1213: * @start: the first char in the string
1214: * @len: the number of xmlChar
1215: *
1216: * receiving some ignorable whitespaces from the parser.
1217: * Question: how much at a time ???
1218: */
1219: static void
1220: ignorableWhitespaceDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch, int len)
1221: {
1222: char output[40];
1223: int i;
1224:
1225: callbacks++;
1226: if (quiet)
1227: return;
1228: for (i = 0;(i<len) && (i < 30);i++)
1229: output[i] = ch[i];
1230: output[i] = 0;
1231: fprintf(SAXdebug, "SAX.ignorableWhitespace(%s, %d)\n", output, len);
1232: }
1233:
1234: /**
1235: * processingInstructionDebug:
1236: * @ctxt: An XML parser context
1237: * @target: the target name
1238: * @data: the PI data's
1239: * @len: the number of xmlChar
1240: *
1241: * A processing instruction has been parsed.
1242: */
1243: static void
1244: processingInstructionDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *target,
1245: const xmlChar *data)
1246: {
1247: callbacks++;
1248: if (quiet)
1249: return;
1250: if (data != NULL)
1251: fprintf(SAXdebug, "SAX.processingInstruction(%s, %s)\n",
1252: (char *) target, (char *) data);
1253: else
1254: fprintf(SAXdebug, "SAX.processingInstruction(%s, NULL)\n",
1255: (char *) target);
1256: }
1257:
1258: /**
1259: * cdataBlockDebug:
1260: * @ctx: the user data (XML parser context)
1261: * @value: The pcdata content
1262: * @len: the block length
1263: *
1264: * called when a pcdata block has been parsed
1265: */
1266: static void
1267: cdataBlockDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *value, int len)
1268: {
1269: callbacks++;
1270: if (quiet)
1271: return;
1272: fprintf(SAXdebug, "SAX.pcdata(%.20s, %d)\n",
1273: (char *) value, len);
1274: }
1275:
1276: /**
1277: * commentDebug:
1278: * @ctxt: An XML parser context
1279: * @value: the comment content
1280: *
1281: * A comment has been parsed.
1282: */
1283: static void
1284: commentDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *value)
1285: {
1286: callbacks++;
1287: if (quiet)
1288: return;
1289: fprintf(SAXdebug, "SAX.comment(%s)\n", value);
1290: }
1291:
1292: /**
1293: * warningDebug:
1294: * @ctxt: An XML parser context
1295: * @msg: the message to display/transmit
1296: * @...: extra parameters for the message display
1297: *
1298: * Display and format a warning messages, gives file, line, position and
1299: * extra parameters.
1300: */
1301: static void XMLCDECL
1302: warningDebug(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...)
1303: {
1304: va_list args;
1305:
1306: callbacks++;
1307: if (quiet)
1308: return;
1309: va_start(args, msg);
1310: fprintf(SAXdebug, "SAX.warning: ");
1311: vfprintf(SAXdebug, msg, args);
1312: va_end(args);
1313: }
1314:
1315: /**
1316: * errorDebug:
1317: * @ctxt: An XML parser context
1318: * @msg: the message to display/transmit
1319: * @...: extra parameters for the message display
1320: *
1321: * Display and format a error messages, gives file, line, position and
1322: * extra parameters.
1323: */
1324: static void XMLCDECL
1325: errorDebug(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...)
1326: {
1327: va_list args;
1328:
1329: callbacks++;
1330: if (quiet)
1331: return;
1332: va_start(args, msg);
1333: fprintf(SAXdebug, "SAX.error: ");
1334: vfprintf(SAXdebug, msg, args);
1335: va_end(args);
1336: }
1337:
1338: /**
1339: * fatalErrorDebug:
1340: * @ctxt: An XML parser context
1341: * @msg: the message to display/transmit
1342: * @...: extra parameters for the message display
1343: *
1344: * Display and format a fatalError messages, gives file, line, position and
1345: * extra parameters.
1346: */
1347: static void XMLCDECL
1348: fatalErrorDebug(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...)
1349: {
1350: va_list args;
1351:
1352: callbacks++;
1353: if (quiet)
1354: return;
1355: va_start(args, msg);
1356: fprintf(SAXdebug, "SAX.fatalError: ");
1357: vfprintf(SAXdebug, msg, args);
1358: va_end(args);
1359: }
1360:
1361: static xmlSAXHandler debugSAXHandlerStruct = {
1362: internalSubsetDebug,
1363: isStandaloneDebug,
1364: hasInternalSubsetDebug,
1365: hasExternalSubsetDebug,
1366: resolveEntityDebug,
1367: getEntityDebug,
1368: entityDeclDebug,
1369: notationDeclDebug,
1370: attributeDeclDebug,
1371: elementDeclDebug,
1372: unparsedEntityDeclDebug,
1373: setDocumentLocatorDebug,
1374: startDocumentDebug,
1375: endDocumentDebug,
1376: startElementDebug,
1377: endElementDebug,
1378: referenceDebug,
1379: charactersDebug,
1380: ignorableWhitespaceDebug,
1381: processingInstructionDebug,
1382: commentDebug,
1383: warningDebug,
1384: errorDebug,
1385: fatalErrorDebug,
1386: getParameterEntityDebug,
1387: cdataBlockDebug,
1388: externalSubsetDebug,
1389: 1,
1390: NULL,
1391: NULL,
1392: NULL,
1393: NULL
1394: };
1395:
1396: static xmlSAXHandlerPtr debugSAXHandler = &debugSAXHandlerStruct;
1397:
1398: /*
1399: * SAX2 specific callbacks
1400: */
1401: /**
1402: * startElementNsDebug:
1403: * @ctxt: An XML parser context
1404: * @name: The element name
1405: *
1406: * called when an opening tag has been processed.
1407: */
1408: static void
1409: startElementNsDebug(void *ctx ATTRIBUTE_UNUSED,
1410: const xmlChar *localname,
1411: const xmlChar *prefix,
1412: const xmlChar *URI,
1413: int nb_namespaces,
1414: const xmlChar **namespaces,
1415: int nb_attributes,
1416: int nb_defaulted,
1417: const xmlChar **attributes)
1418: {
1419: int i;
1420:
1421: callbacks++;
1422: if (quiet)
1423: return;
1424: fprintf(SAXdebug, "SAX.startElementNs(%s", (char *) localname);
1425: if (prefix == NULL)
1426: fprintf(SAXdebug, ", NULL");
1427: else
1428: fprintf(SAXdebug, ", %s", (char *) prefix);
1429: if (URI == NULL)
1430: fprintf(SAXdebug, ", NULL");
1431: else
1432: fprintf(SAXdebug, ", '%s'", (char *) URI);
1433: fprintf(SAXdebug, ", %d", nb_namespaces);
1434:
1435: if (namespaces != NULL) {
1436: for (i = 0;i < nb_namespaces * 2;i++) {
1437: fprintf(SAXdebug, ", xmlns");
1438: if (namespaces[i] != NULL)
1439: fprintf(SAXdebug, ":%s", namespaces[i]);
1440: i++;
1441: fprintf(SAXdebug, "='%s'", namespaces[i]);
1442: }
1443: }
1444: fprintf(SAXdebug, ", %d, %d", nb_attributes, nb_defaulted);
1445: if (attributes != NULL) {
1446: for (i = 0;i < nb_attributes * 5;i += 5) {
1447: if (attributes[i + 1] != NULL)
1448: fprintf(SAXdebug, ", %s:%s='", attributes[i + 1], attributes[i]);
1449: else
1450: fprintf(SAXdebug, ", %s='", attributes[i]);
1451: fprintf(SAXdebug, "%.4s...', %d", attributes[i + 3],
1452: (int)(attributes[i + 4] - attributes[i + 3]));
1453: }
1454: }
1455: fprintf(SAXdebug, ")\n");
1456: }
1457:
1458: /**
1459: * endElementDebug:
1460: * @ctxt: An XML parser context
1461: * @name: The element name
1462: *
1463: * called when the end of an element has been detected.
1464: */
1465: static void
1466: endElementNsDebug(void *ctx ATTRIBUTE_UNUSED,
1467: const xmlChar *localname,
1468: const xmlChar *prefix,
1469: const xmlChar *URI)
1470: {
1471: callbacks++;
1472: if (quiet)
1473: return;
1474: fprintf(SAXdebug, "SAX.endElementNs(%s", (char *) localname);
1475: if (prefix == NULL)
1476: fprintf(SAXdebug, ", NULL");
1477: else
1478: fprintf(SAXdebug, ", %s", (char *) prefix);
1479: if (URI == NULL)
1480: fprintf(SAXdebug, ", NULL)\n");
1481: else
1482: fprintf(SAXdebug, ", '%s')\n", (char *) URI);
1483: }
1484:
1485: static xmlSAXHandler debugSAX2HandlerStruct = {
1486: internalSubsetDebug,
1487: isStandaloneDebug,
1488: hasInternalSubsetDebug,
1489: hasExternalSubsetDebug,
1490: resolveEntityDebug,
1491: getEntityDebug,
1492: entityDeclDebug,
1493: notationDeclDebug,
1494: attributeDeclDebug,
1495: elementDeclDebug,
1496: unparsedEntityDeclDebug,
1497: setDocumentLocatorDebug,
1498: startDocumentDebug,
1499: endDocumentDebug,
1500: NULL,
1501: NULL,
1502: referenceDebug,
1503: charactersDebug,
1504: ignorableWhitespaceDebug,
1505: processingInstructionDebug,
1506: commentDebug,
1507: warningDebug,
1508: errorDebug,
1509: fatalErrorDebug,
1510: getParameterEntityDebug,
1511: cdataBlockDebug,
1512: externalSubsetDebug,
1513: XML_SAX2_MAGIC,
1514: NULL,
1515: startElementNsDebug,
1516: endElementNsDebug,
1517: NULL
1518: };
1519:
1520: static xmlSAXHandlerPtr debugSAX2Handler = &debugSAX2HandlerStruct;
1521:
1522: #ifdef LIBXML_HTML_ENABLED
1523: /**
1524: * htmlstartElementDebug:
1525: * @ctxt: An XML parser context
1526: * @name: The element name
1527: *
1528: * called when an opening tag has been processed.
1529: */
1530: static void
1531: htmlstartElementDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *name, const xmlChar **atts)
1532: {
1533: int i;
1534:
1535: fprintf(SAXdebug, "SAX.startElement(%s", (char *) name);
1536: if (atts != NULL) {
1537: for (i = 0;(atts[i] != NULL);i++) {
1538: fprintf(SAXdebug, ", %s", atts[i++]);
1539: if (atts[i] != NULL) {
1540: unsigned char output[40];
1541: const unsigned char *att = atts[i];
1542: int outlen, attlen;
1543: fprintf(SAXdebug, "='");
1544: while ((attlen = strlen((char*)att)) > 0) {
1545: outlen = sizeof output - 1;
1546: htmlEncodeEntities(output, &outlen, att, &attlen, '\'');
1547: output[outlen] = 0;
1548: fprintf(SAXdebug, "%s", (char *) output);
1549: att += attlen;
1550: }
1551: fprintf(SAXdebug, "'");
1552: }
1553: }
1554: }
1555: fprintf(SAXdebug, ")\n");
1556: }
1557:
1558: /**
1559: * htmlcharactersDebug:
1560: * @ctxt: An XML parser context
1561: * @ch: a xmlChar string
1562: * @len: the number of xmlChar
1563: *
1564: * receiving some chars from the parser.
1565: * Question: how much at a time ???
1566: */
1567: static void
1568: htmlcharactersDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch, int len)
1569: {
1570: unsigned char output[40];
1571: int inlen = len, outlen = 30;
1572:
1573: htmlEncodeEntities(output, &outlen, ch, &inlen, 0);
1574: output[outlen] = 0;
1575:
1576: fprintf(SAXdebug, "SAX.characters(%s, %d)\n", output, len);
1577: }
1578:
1579: /**
1580: * htmlcdataDebug:
1581: * @ctxt: An XML parser context
1582: * @ch: a xmlChar string
1583: * @len: the number of xmlChar
1584: *
1585: * receiving some cdata chars from the parser.
1586: * Question: how much at a time ???
1587: */
1588: static void
1589: htmlcdataDebug(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch, int len)
1590: {
1591: unsigned char output[40];
1592: int inlen = len, outlen = 30;
1593:
1594: htmlEncodeEntities(output, &outlen, ch, &inlen, 0);
1595: output[outlen] = 0;
1596:
1597: fprintf(SAXdebug, "SAX.cdata(%s, %d)\n", output, len);
1598: }
1599:
1600: static xmlSAXHandler debugHTMLSAXHandlerStruct = {
1601: internalSubsetDebug,
1602: isStandaloneDebug,
1603: hasInternalSubsetDebug,
1604: hasExternalSubsetDebug,
1605: resolveEntityDebug,
1606: getEntityDebug,
1607: entityDeclDebug,
1608: notationDeclDebug,
1609: attributeDeclDebug,
1610: elementDeclDebug,
1611: unparsedEntityDeclDebug,
1612: setDocumentLocatorDebug,
1613: startDocumentDebug,
1614: endDocumentDebug,
1615: htmlstartElementDebug,
1616: endElementDebug,
1617: referenceDebug,
1618: htmlcharactersDebug,
1619: ignorableWhitespaceDebug,
1620: processingInstructionDebug,
1621: commentDebug,
1622: warningDebug,
1623: errorDebug,
1624: fatalErrorDebug,
1625: getParameterEntityDebug,
1626: htmlcdataDebug,
1627: externalSubsetDebug,
1628: 1,
1629: NULL,
1630: NULL,
1631: NULL,
1632: NULL
1633: };
1634:
1635: static xmlSAXHandlerPtr debugHTMLSAXHandler = &debugHTMLSAXHandlerStruct;
1636: #endif /* LIBXML_HTML_ENABLED */
1637:
1638: #ifdef LIBXML_SAX1_ENABLED
1639: /**
1640: * saxParseTest:
1641: * @filename: the file to parse
1642: * @result: the file with expected result
1643: * @err: the file with error messages
1644: *
1645: * Parse a file using the SAX API and check for errors.
1646: *
1647: * Returns 0 in case of success, an error code otherwise
1648: */
1649: static int
1650: saxParseTest(const char *filename, const char *result,
1651: const char *err ATTRIBUTE_UNUSED,
1652: int options) {
1653: int ret;
1654: char *temp;
1655:
1656: nb_tests++;
1657: temp = resultFilename(filename, "", ".res");
1658: if (temp == NULL) {
1659: fprintf(stderr, "out of memory\n");
1660: fatalError();
1661: }
1662: SAXdebug = fopen(temp, "wb");
1663: if (SAXdebug == NULL) {
1664: fprintf(stderr, "Failed to write to %s\n", temp);
1665: free(temp);
1666: return(-1);
1667: }
1668:
1669: /* for SAX we really want the callbacks though the context handlers */
1670: xmlSetStructuredErrorFunc(NULL, NULL);
1671: xmlSetGenericErrorFunc(NULL, testErrorHandler);
1672:
1673: #ifdef LIBXML_HTML_ENABLED
1674: if (options & XML_PARSE_HTML) {
1675: htmlSAXParseFile(filename, NULL, emptySAXHandler, NULL);
1676: ret = 0;
1677: } else
1678: #endif
1679: ret = xmlSAXUserParseFile(emptySAXHandler, NULL, filename);
1680: if (ret == XML_WAR_UNDECLARED_ENTITY) {
1681: fprintf(SAXdebug, "xmlSAXUserParseFile returned error %d\n", ret);
1682: ret = 0;
1683: }
1684: if (ret != 0) {
1685: fprintf(stderr, "Failed to parse %s\n", filename);
1686: return(1);
1687: }
1688: #ifdef LIBXML_HTML_ENABLED
1689: if (options & XML_PARSE_HTML) {
1690: htmlSAXParseFile(filename, NULL, debugHTMLSAXHandler, NULL);
1691: ret = 0;
1692: } else
1693: #endif
1694: if (options & XML_PARSE_SAX1) {
1695: ret = xmlSAXUserParseFile(debugSAXHandler, NULL, filename);
1696: } else {
1697: ret = xmlSAXUserParseFile(debugSAX2Handler, NULL, filename);
1698: }
1699: if (ret == XML_WAR_UNDECLARED_ENTITY) {
1700: fprintf(SAXdebug, "xmlSAXUserParseFile returned error %d\n", ret);
1701: ret = 0;
1702: }
1703: fclose(SAXdebug);
1704: if (compareFiles(temp, result)) {
1705: fprintf(stderr, "Got a difference for %s\n", filename);
1706: ret = 1;
1707: }
1708: if (temp != NULL) {
1709: unlink(temp);
1710: free(temp);
1711: }
1712:
1713: /* switch back to structured error handling */
1714: xmlSetGenericErrorFunc(NULL, NULL);
1715: xmlSetStructuredErrorFunc(NULL, testStructuredErrorHandler);
1716:
1717: return(ret);
1718: }
1719: #endif
1720:
1721: /************************************************************************
1722: * *
1723: * Parse to tree based tests *
1724: * *
1725: ************************************************************************/
1726: /**
1727: * oldParseTest:
1728: * @filename: the file to parse
1729: * @result: the file with expected result
1730: * @err: the file with error messages: unused
1731: *
1732: * Parse a file using the old xmlParseFile API, then serialize back
1733: * reparse the result and serialize again, then check for deviation
1734: * in serialization.
1735: *
1736: * Returns 0 in case of success, an error code otherwise
1737: */
1738: static int
1739: oldParseTest(const char *filename, const char *result,
1740: const char *err ATTRIBUTE_UNUSED,
1741: int options ATTRIBUTE_UNUSED) {
1742: xmlDocPtr doc;
1743: char *temp;
1744: int res = 0;
1745:
1746: nb_tests++;
1747: /*
1748: * base of the test, parse with the old API
1749: */
1750: #ifdef LIBXML_SAX1_ENABLED
1751: doc = xmlParseFile(filename);
1752: #else
1753: doc = xmlReadFile(filename, NULL, 0);
1754: #endif
1755: if (doc == NULL)
1756: return(1);
1757: temp = resultFilename(filename, "", ".res");
1758: if (temp == NULL) {
1759: fprintf(stderr, "out of memory\n");
1760: fatalError();
1761: }
1762: xmlSaveFile(temp, doc);
1763: if (compareFiles(temp, result)) {
1764: res = 1;
1765: }
1766: xmlFreeDoc(doc);
1767:
1768: /*
1769: * Parse the saved result to make sure the round trip is okay
1770: */
1771: #ifdef LIBXML_SAX1_ENABLED
1772: doc = xmlParseFile(temp);
1773: #else
1774: doc = xmlReadFile(temp, NULL, 0);
1775: #endif
1776: if (doc == NULL)
1777: return(1);
1778: xmlSaveFile(temp, doc);
1779: if (compareFiles(temp, result)) {
1780: res = 1;
1781: }
1782: xmlFreeDoc(doc);
1783:
1784: if (temp != NULL) {
1785: unlink(temp);
1786: free(temp);
1787: }
1788: return(res);
1789: }
1790:
1791: #ifdef LIBXML_PUSH_ENABLED
1792: /**
1793: * pushParseTest:
1794: * @filename: the file to parse
1795: * @result: the file with expected result
1796: * @err: the file with error messages: unused
1797: *
1798: * Parse a file using the Push API, then serialize back
1799: * to check for content.
1800: *
1801: * Returns 0 in case of success, an error code otherwise
1802: */
1803: static int
1804: pushParseTest(const char *filename, const char *result,
1805: const char *err ATTRIBUTE_UNUSED,
1806: int options) {
1807: xmlParserCtxtPtr ctxt;
1808: xmlDocPtr doc;
1809: const char *base;
1810: int size, res;
1811: int cur = 0;
1812:
1813: nb_tests++;
1814: /*
1815: * load the document in memory and work from there.
1816: */
1817: if (loadMem(filename, &base, &size) != 0) {
1818: fprintf(stderr, "Failed to load %s\n", filename);
1819: return(-1);
1820: }
1821:
1822: #ifdef LIBXML_HTML_ENABLED
1823: if (options & XML_PARSE_HTML)
1824: ctxt = htmlCreatePushParserCtxt(NULL, NULL, base + cur, 4, filename,
1825: XML_CHAR_ENCODING_NONE);
1826: else
1827: #endif
1828: ctxt = xmlCreatePushParserCtxt(NULL, NULL, base + cur, 4, filename);
1829: xmlCtxtUseOptions(ctxt, options);
1830: cur += 4;
1831: while (cur < size) {
1832: if (cur + 1024 >= size) {
1833: #ifdef LIBXML_HTML_ENABLED
1834: if (options & XML_PARSE_HTML)
1835: htmlParseChunk(ctxt, base + cur, size - cur, 1);
1836: else
1837: #endif
1838: xmlParseChunk(ctxt, base + cur, size - cur, 1);
1839: break;
1840: } else {
1841: #ifdef LIBXML_HTML_ENABLED
1842: if (options & XML_PARSE_HTML)
1843: htmlParseChunk(ctxt, base + cur, 1024, 0);
1844: else
1845: #endif
1846: xmlParseChunk(ctxt, base + cur, 1024, 0);
1847: cur += 1024;
1848: }
1849: }
1850: doc = ctxt->myDoc;
1851: #ifdef LIBXML_HTML_ENABLED
1852: if (options & XML_PARSE_HTML)
1853: res = 1;
1854: else
1855: #endif
1856: res = ctxt->wellFormed;
1857: xmlFreeParserCtxt(ctxt);
1858: free((char *)base);
1859: if (!res) {
1860: xmlFreeDoc(doc);
1861: fprintf(stderr, "Failed to parse %s\n", filename);
1862: return(-1);
1863: }
1864: #ifdef LIBXML_HTML_ENABLED
1865: if (options & XML_PARSE_HTML)
1866: htmlDocDumpMemory(doc, (xmlChar **) &base, &size);
1867: else
1868: #endif
1869: xmlDocDumpMemory(doc, (xmlChar **) &base, &size);
1870: xmlFreeDoc(doc);
1871: res = compareFileMem(result, base, size);
1872: if ((base == NULL) || (res != 0)) {
1873: if (base != NULL)
1874: xmlFree((char *)base);
1875: fprintf(stderr, "Result for %s failed\n", filename);
1876: return(-1);
1877: }
1878: xmlFree((char *)base);
1879: if (err != NULL) {
1880: res = compareFileMem(err, testErrors, testErrorsSize);
1881: if (res != 0) {
1882: fprintf(stderr, "Error for %s failed\n", filename);
1883: return(-1);
1884: }
1885: }
1886: return(0);
1887: }
1888: #endif
1889:
1890: /**
1891: * memParseTest:
1892: * @filename: the file to parse
1893: * @result: the file with expected result
1894: * @err: the file with error messages: unused
1895: *
1896: * Parse a file using the old xmlReadMemory API, then serialize back
1897: * reparse the result and serialize again, then check for deviation
1898: * in serialization.
1899: *
1900: * Returns 0 in case of success, an error code otherwise
1901: */
1902: static int
1903: memParseTest(const char *filename, const char *result,
1904: const char *err ATTRIBUTE_UNUSED,
1905: int options ATTRIBUTE_UNUSED) {
1906: xmlDocPtr doc;
1907: const char *base;
1908: int size, res;
1909:
1910: nb_tests++;
1911: /*
1912: * load and parse the memory
1913: */
1914: if (loadMem(filename, &base, &size) != 0) {
1915: fprintf(stderr, "Failed to load %s\n", filename);
1916: return(-1);
1917: }
1918:
1919: doc = xmlReadMemory(base, size, filename, NULL, 0);
1920: unloadMem(base);
1921: if (doc == NULL) {
1922: return(1);
1923: }
1924: xmlDocDumpMemory(doc, (xmlChar **) &base, &size);
1925: xmlFreeDoc(doc);
1926: res = compareFileMem(result, base, size);
1927: if ((base == NULL) || (res != 0)) {
1928: if (base != NULL)
1929: xmlFree((char *)base);
1930: fprintf(stderr, "Result for %s failed\n", filename);
1931: return(-1);
1932: }
1933: xmlFree((char *)base);
1934: return(0);
1935: }
1936:
1937: /**
1938: * noentParseTest:
1939: * @filename: the file to parse
1940: * @result: the file with expected result
1941: * @err: the file with error messages: unused
1942: *
1943: * Parse a file with entity resolution, then serialize back
1944: * reparse the result and serialize again, then check for deviation
1945: * in serialization.
1946: *
1947: * Returns 0 in case of success, an error code otherwise
1948: */
1949: static int
1950: noentParseTest(const char *filename, const char *result,
1951: const char *err ATTRIBUTE_UNUSED,
1952: int options) {
1953: xmlDocPtr doc;
1954: char *temp;
1955: int res = 0;
1956:
1957: nb_tests++;
1958: /*
1959: * base of the test, parse with the old API
1960: */
1961: doc = xmlReadFile(filename, NULL, options);
1962: if (doc == NULL)
1963: return(1);
1964: temp = resultFilename(filename, "", ".res");
1965: if (temp == NULL) {
1966: fprintf(stderr, "Out of memory\n");
1967: fatalError();
1968: }
1969: xmlSaveFile(temp, doc);
1970: if (compareFiles(temp, result)) {
1971: res = 1;
1972: }
1973: xmlFreeDoc(doc);
1974:
1975: /*
1976: * Parse the saved result to make sure the round trip is okay
1977: */
1978: doc = xmlReadFile(filename, NULL, options);
1979: if (doc == NULL)
1980: return(1);
1981: xmlSaveFile(temp, doc);
1982: if (compareFiles(temp, result)) {
1983: res = 1;
1984: }
1985: xmlFreeDoc(doc);
1986:
1987: if (temp != NULL) {
1988: unlink(temp);
1989: free(temp);
1990: }
1991: return(res);
1992: }
1993:
1994: /**
1995: * errParseTest:
1996: * @filename: the file to parse
1997: * @result: the file with expected result
1998: * @err: the file with error messages
1999: *
2000: * Parse a file using the xmlReadFile API and check for errors.
2001: *
2002: * Returns 0 in case of success, an error code otherwise
2003: */
2004: static int
2005: errParseTest(const char *filename, const char *result, const char *err,
2006: int options) {
2007: xmlDocPtr doc;
2008: const char *base = NULL;
2009: int size, res = 0;
2010:
2011: nb_tests++;
2012: #ifdef LIBXML_HTML_ENABLED
2013: if (options & XML_PARSE_HTML) {
2014: doc = htmlReadFile(filename, NULL, options);
2015: } else
2016: #endif
2017: #ifdef LIBXML_XINCLUDE_ENABLED
2018: if (options & XML_PARSE_XINCLUDE) {
2019: doc = xmlReadFile(filename, NULL, options);
2020: xmlXIncludeProcessFlags(doc, options);
2021: } else
2022: #endif
2023: {
2024: xmlGetWarningsDefaultValue = 1;
2025: doc = xmlReadFile(filename, NULL, options);
2026: }
2027: xmlGetWarningsDefaultValue = 0;
2028: if (result) {
2029: if (doc == NULL) {
2030: base = "";
2031: size = 0;
2032: } else {
2033: #ifdef LIBXML_HTML_ENABLED
2034: if (options & XML_PARSE_HTML) {
2035: htmlDocDumpMemory(doc, (xmlChar **) &base, &size);
2036: } else
2037: #endif
2038: xmlDocDumpMemory(doc, (xmlChar **) &base, &size);
2039: }
2040: res = compareFileMem(result, base, size);
2041: }
2042: if (doc != NULL) {
2043: if (base != NULL)
2044: xmlFree((char *)base);
2045: xmlFreeDoc(doc);
2046: }
2047: if (res != 0) {
2048: fprintf(stderr, "Result for %s failed\n", filename);
2049: return(-1);
2050: }
2051: if (err != NULL) {
2052: res = compareFileMem(err, testErrors, testErrorsSize);
2053: if (res != 0) {
2054: fprintf(stderr, "Error for %s failed\n", filename);
2055: return(-1);
2056: }
2057: } else if (options & XML_PARSE_DTDVALID) {
2058: if (testErrorsSize != 0)
2059: fprintf(stderr, "Validation for %s failed\n", filename);
2060: }
2061:
2062: return(0);
2063: }
2064:
2065: #ifdef LIBXML_READER_ENABLED
2066: /************************************************************************
2067: * *
2068: * Reader based tests *
2069: * *
2070: ************************************************************************/
2071:
2072: static void processNode(FILE *out, xmlTextReaderPtr reader) {
2073: const xmlChar *name, *value;
2074: int type, empty;
2075:
2076: type = xmlTextReaderNodeType(reader);
2077: empty = xmlTextReaderIsEmptyElement(reader);
2078:
2079: name = xmlTextReaderConstName(reader);
2080: if (name == NULL)
2081: name = BAD_CAST "--";
2082:
2083: value = xmlTextReaderConstValue(reader);
2084:
2085:
2086: fprintf(out, "%d %d %s %d %d",
2087: xmlTextReaderDepth(reader),
2088: type,
2089: name,
2090: empty,
2091: xmlTextReaderHasValue(reader));
2092: if (value == NULL)
2093: fprintf(out, "\n");
2094: else {
2095: fprintf(out, " %s\n", value);
2096: }
2097: }
2098: static int
2099: streamProcessTest(const char *filename, const char *result, const char *err,
2100: xmlTextReaderPtr reader, const char *rng) {
2101: int ret;
2102: char *temp = NULL;
2103: FILE *t = NULL;
2104:
2105: if (reader == NULL)
2106: return(-1);
2107:
2108: nb_tests++;
2109: if (result != NULL) {
2110: temp = resultFilename(filename, "", ".res");
2111: if (temp == NULL) {
2112: fprintf(stderr, "Out of memory\n");
2113: fatalError();
2114: }
2115: t = fopen(temp, "wb");
2116: if (t == NULL) {
2117: fprintf(stderr, "Can't open temp file %s\n", temp);
2118: free(temp);
2119: return(-1);
2120: }
2121: }
2122: #ifdef LIBXML_SCHEMAS_ENABLED
2123: if (rng != NULL) {
2124: ret = xmlTextReaderRelaxNGValidate(reader, rng);
2125: if (ret < 0) {
2126: testErrorHandler(NULL, "Relax-NG schema %s failed to compile\n",
2127: rng);
2128: fclose(t);
2129: if (temp != NULL) {
2130: unlink(temp);
2131: free(temp);
2132: }
2133: return(0);
2134: }
2135: }
2136: #endif
2137: xmlGetWarningsDefaultValue = 1;
2138: ret = xmlTextReaderRead(reader);
2139: while (ret == 1) {
2140: if ((t != NULL) && (rng == NULL))
2141: processNode(t, reader);
2142: ret = xmlTextReaderRead(reader);
2143: }
2144: if (ret != 0) {
2145: testErrorHandler(NULL, "%s : failed to parse\n", filename);
2146: }
2147: if (rng != NULL) {
2148: if (xmlTextReaderIsValid(reader) != 1) {
2149: testErrorHandler(NULL, "%s fails to validate\n", filename);
2150: } else {
2151: testErrorHandler(NULL, "%s validates\n", filename);
2152: }
2153: }
2154: xmlGetWarningsDefaultValue = 0;
2155: if (t != NULL) {
2156: fclose(t);
2157: ret = compareFiles(temp, result);
2158: if (temp != NULL) {
2159: unlink(temp);
2160: free(temp);
2161: }
2162: if (ret) {
2163: fprintf(stderr, "Result for %s failed\n", filename);
2164: return(-1);
2165: }
2166: }
2167: if (err != NULL) {
2168: ret = compareFileMem(err, testErrors, testErrorsSize);
2169: if (ret != 0) {
2170: fprintf(stderr, "Error for %s failed\n", filename);
2171: printf("%s", testErrors);
2172: return(-1);
2173: }
2174: }
2175:
2176: return(0);
2177: }
2178:
2179: /**
2180: * streamParseTest:
2181: * @filename: the file to parse
2182: * @result: the file with expected result
2183: * @err: the file with error messages
2184: *
2185: * Parse a file using the reader API and check for errors.
2186: *
2187: * Returns 0 in case of success, an error code otherwise
2188: */
2189: static int
2190: streamParseTest(const char *filename, const char *result, const char *err,
2191: int options) {
2192: xmlTextReaderPtr reader;
2193: int ret;
2194:
2195: reader = xmlReaderForFile(filename, NULL, options);
2196: ret = streamProcessTest(filename, result, err, reader, NULL);
2197: xmlFreeTextReader(reader);
2198: return(ret);
2199: }
2200:
2201: /**
2202: * walkerParseTest:
2203: * @filename: the file to parse
2204: * @result: the file with expected result
2205: * @err: the file with error messages
2206: *
2207: * Parse a file using the walker, i.e. a reader built from a atree.
2208: *
2209: * Returns 0 in case of success, an error code otherwise
2210: */
2211: static int
2212: walkerParseTest(const char *filename, const char *result, const char *err,
2213: int options) {
2214: xmlDocPtr doc;
2215: xmlTextReaderPtr reader;
2216: int ret;
2217:
2218: doc = xmlReadFile(filename, NULL, options);
2219: if (doc == NULL) {
2220: fprintf(stderr, "Failed to parse %s\n", filename);
2221: return(-1);
2222: }
2223: reader = xmlReaderWalker(doc);
2224: ret = streamProcessTest(filename, result, err, reader, NULL);
2225: xmlFreeTextReader(reader);
2226: xmlFreeDoc(doc);
2227: return(ret);
2228: }
2229:
2230: /**
2231: * streamMemParseTest:
2232: * @filename: the file to parse
2233: * @result: the file with expected result
2234: * @err: the file with error messages
2235: *
2236: * Parse a file using the reader API from memory and check for errors.
2237: *
2238: * Returns 0 in case of success, an error code otherwise
2239: */
2240: static int
2241: streamMemParseTest(const char *filename, const char *result, const char *err,
2242: int options) {
2243: xmlTextReaderPtr reader;
2244: int ret;
2245: const char *base;
2246: int size;
2247:
2248: /*
2249: * load and parse the memory
2250: */
2251: if (loadMem(filename, &base, &size) != 0) {
2252: fprintf(stderr, "Failed to load %s\n", filename);
2253: return(-1);
2254: }
2255: reader = xmlReaderForMemory(base, size, filename, NULL, options);
2256: ret = streamProcessTest(filename, result, err, reader, NULL);
2257: free((char *)base);
2258: xmlFreeTextReader(reader);
2259: return(ret);
2260: }
2261: #endif
2262:
2263: #ifdef LIBXML_XPATH_ENABLED
2264: #ifdef LIBXML_DEBUG_ENABLED
2265: /************************************************************************
2266: * *
2267: * XPath and XPointer based tests *
2268: * *
2269: ************************************************************************/
2270:
2271: static FILE *xpathOutput;
2272: static xmlDocPtr xpathDocument;
2273:
2274: static void
2275: testXPath(const char *str, int xptr, int expr) {
2276: xmlXPathObjectPtr res;
2277: xmlXPathContextPtr ctxt;
2278:
2279: nb_tests++;
2280: #if defined(LIBXML_XPTR_ENABLED)
2281: if (xptr) {
2282: ctxt = xmlXPtrNewContext(xpathDocument, NULL, NULL);
2283: res = xmlXPtrEval(BAD_CAST str, ctxt);
2284: } else {
2285: #endif
2286: ctxt = xmlXPathNewContext(xpathDocument);
2287: ctxt->node = xmlDocGetRootElement(xpathDocument);
2288: if (expr)
2289: res = xmlXPathEvalExpression(BAD_CAST str, ctxt);
2290: else {
2291: /* res = xmlXPathEval(BAD_CAST str, ctxt); */
2292: xmlXPathCompExprPtr comp;
2293:
2294: comp = xmlXPathCompile(BAD_CAST str);
2295: if (comp != NULL) {
2296: res = xmlXPathCompiledEval(comp, ctxt);
2297: xmlXPathFreeCompExpr(comp);
2298: } else
2299: res = NULL;
2300: }
2301: #if defined(LIBXML_XPTR_ENABLED)
2302: }
2303: #endif
2304: xmlXPathDebugDumpObject(xpathOutput, res, 0);
2305: xmlXPathFreeObject(res);
2306: xmlXPathFreeContext(ctxt);
2307: }
2308:
2309: /**
2310: * xpathExprTest:
2311: * @filename: the file to parse
2312: * @result: the file with expected result
2313: * @err: the file with error messages
2314: *
2315: * Parse a file containing XPath standalone expressions and evaluate them
2316: *
2317: * Returns 0 in case of success, an error code otherwise
2318: */
2319: static int
2320: xpathCommonTest(const char *filename, const char *result,
2321: int xptr, int expr) {
2322: FILE *input;
2323: char expression[5000];
2324: int len, ret = 0;
2325: char *temp;
2326:
2327: temp = resultFilename(filename, "", ".res");
2328: if (temp == NULL) {
2329: fprintf(stderr, "Out of memory\n");
2330: fatalError();
2331: }
2332: xpathOutput = fopen(temp, "wb");
2333: if (xpathOutput == NULL) {
2334: fprintf(stderr, "failed to open output file %s\n", temp);
2335: free(temp);
2336: return(-1);
2337: }
2338:
2339: input = fopen(filename, "rb");
2340: if (input == NULL) {
2341: xmlGenericError(xmlGenericErrorContext,
2342: "Cannot open %s for reading\n", filename);
2343: free(temp);
2344: return(-1);
2345: }
2346: while (fgets(expression, 4500, input) != NULL) {
2347: len = strlen(expression);
2348: len--;
2349: while ((len >= 0) &&
2350: ((expression[len] == '\n') || (expression[len] == '\t') ||
2351: (expression[len] == '\r') || (expression[len] == ' '))) len--;
2352: expression[len + 1] = 0;
2353: if (len >= 0) {
2354: fprintf(xpathOutput,
2355: "\n========================\nExpression: %s\n",
2356: expression) ;
2357: testXPath(expression, xptr, expr);
2358: }
2359: }
2360:
2361: fclose(input);
2362: fclose(xpathOutput);
2363: if (result != NULL) {
2364: ret = compareFiles(temp, result);
2365: if (ret) {
2366: fprintf(stderr, "Result for %s failed\n", filename);
2367: }
2368: }
2369:
2370: if (temp != NULL) {
2371: unlink(temp);
2372: free(temp);
2373: }
2374: return(ret);
2375: }
2376:
2377: /**
2378: * xpathExprTest:
2379: * @filename: the file to parse
2380: * @result: the file with expected result
2381: * @err: the file with error messages
2382: *
2383: * Parse a file containing XPath standalone expressions and evaluate them
2384: *
2385: * Returns 0 in case of success, an error code otherwise
2386: */
2387: static int
2388: xpathExprTest(const char *filename, const char *result,
2389: const char *err ATTRIBUTE_UNUSED,
2390: int options ATTRIBUTE_UNUSED) {
2391: return(xpathCommonTest(filename, result, 0, 1));
2392: }
2393:
2394: /**
2395: * xpathDocTest:
2396: * @filename: the file to parse
2397: * @result: the file with expected result
2398: * @err: the file with error messages
2399: *
2400: * Parse a file containing XPath expressions and evaluate them against
2401: * a set of corresponding documents.
2402: *
2403: * Returns 0 in case of success, an error code otherwise
2404: */
2405: static int
2406: xpathDocTest(const char *filename,
2407: const char *resul ATTRIBUTE_UNUSED,
2408: const char *err ATTRIBUTE_UNUSED,
2409: int options) {
2410:
2411: char pattern[500];
2412: char result[500];
2413: glob_t globbuf;
2414: size_t i;
2415: int ret = 0, res;
2416:
2417: xpathDocument = xmlReadFile(filename, NULL,
2418: options | XML_PARSE_DTDATTR | XML_PARSE_NOENT);
2419: if (xpathDocument == NULL) {
2420: fprintf(stderr, "Failed to load %s\n", filename);
2421: return(-1);
2422: }
2423:
2424: snprintf(pattern, 499, "./test/XPath/tests/%s*", baseFilename(filename));
2425: pattern[499] = 0;
2426: globbuf.gl_offs = 0;
2427: glob(pattern, GLOB_DOOFFS, NULL, &globbuf);
2428: for (i = 0;i < globbuf.gl_pathc;i++) {
2429: snprintf(result, 499, "result/XPath/tests/%s",
2430: baseFilename(globbuf.gl_pathv[i]));
2431: res = xpathCommonTest(globbuf.gl_pathv[i], &result[0], 0, 0);
2432: if (res != 0)
2433: ret = res;
2434: }
2435: globfree(&globbuf);
2436:
2437: xmlFreeDoc(xpathDocument);
2438: return(ret);
2439: }
2440:
2441: #ifdef LIBXML_XPTR_ENABLED
2442: /**
2443: * xptrDocTest:
2444: * @filename: the file to parse
2445: * @result: the file with expected result
2446: * @err: the file with error messages
2447: *
2448: * Parse a file containing XPath expressions and evaluate them against
2449: * a set of corresponding documents.
2450: *
2451: * Returns 0 in case of success, an error code otherwise
2452: */
2453: static int
2454: xptrDocTest(const char *filename,
2455: const char *resul ATTRIBUTE_UNUSED,
2456: const char *err ATTRIBUTE_UNUSED,
2457: int options) {
2458:
2459: char pattern[500];
2460: char result[500];
2461: glob_t globbuf;
2462: size_t i;
2463: int ret = 0, res;
2464:
2465: xpathDocument = xmlReadFile(filename, NULL,
2466: options | XML_PARSE_DTDATTR | XML_PARSE_NOENT);
2467: if (xpathDocument == NULL) {
2468: fprintf(stderr, "Failed to load %s\n", filename);
2469: return(-1);
2470: }
2471:
2472: snprintf(pattern, 499, "./test/XPath/xptr/%s*", baseFilename(filename));
2473: pattern[499] = 0;
2474: globbuf.gl_offs = 0;
2475: glob(pattern, GLOB_DOOFFS, NULL, &globbuf);
2476: for (i = 0;i < globbuf.gl_pathc;i++) {
2477: snprintf(result, 499, "result/XPath/xptr/%s",
2478: baseFilename(globbuf.gl_pathv[i]));
2479: res = xpathCommonTest(globbuf.gl_pathv[i], &result[0], 1, 0);
2480: if (res != 0)
2481: ret = res;
2482: }
2483: globfree(&globbuf);
2484:
2485: xmlFreeDoc(xpathDocument);
2486: return(ret);
2487: }
2488: #endif /* LIBXML_XPTR_ENABLED */
2489:
2490: /**
2491: * xmlidDocTest:
2492: * @filename: the file to parse
2493: * @result: the file with expected result
2494: * @err: the file with error messages
2495: *
2496: * Parse a file containing xml:id and check for errors and verify
2497: * that XPath queries will work on them as expected.
2498: *
2499: * Returns 0 in case of success, an error code otherwise
2500: */
2501: static int
2502: xmlidDocTest(const char *filename,
2503: const char *result,
2504: const char *err,
2505: int options) {
2506:
2507: int res = 0;
2508: int ret = 0;
2509: char *temp;
2510:
2511: xpathDocument = xmlReadFile(filename, NULL,
2512: options | XML_PARSE_DTDATTR | XML_PARSE_NOENT);
2513: if (xpathDocument == NULL) {
2514: fprintf(stderr, "Failed to load %s\n", filename);
2515: return(-1);
2516: }
2517:
2518: temp = resultFilename(filename, "", ".res");
2519: if (temp == NULL) {
2520: fprintf(stderr, "Out of memory\n");
2521: fatalError();
2522: }
2523: xpathOutput = fopen(temp, "wb");
2524: if (xpathOutput == NULL) {
2525: fprintf(stderr, "failed to open output file %s\n", temp);
2526: xmlFreeDoc(xpathDocument);
2527: free(temp);
2528: return(-1);
2529: }
2530:
2531: testXPath("id('bar')", 0, 0);
2532:
2533: fclose(xpathOutput);
2534: if (result != NULL) {
2535: ret = compareFiles(temp, result);
2536: if (ret) {
2537: fprintf(stderr, "Result for %s failed\n", filename);
2538: res = 1;
2539: }
2540: }
2541:
2542: if (temp != NULL) {
2543: unlink(temp);
2544: free(temp);
2545: }
2546: xmlFreeDoc(xpathDocument);
2547:
2548: if (err != NULL) {
2549: ret = compareFileMem(err, testErrors, testErrorsSize);
2550: if (ret != 0) {
2551: fprintf(stderr, "Error for %s failed\n", filename);
2552: res = 1;
2553: }
2554: }
2555: return(res);
2556: }
2557:
2558: #endif /* LIBXML_DEBUG_ENABLED */
2559: #endif /* XPATH */
2560: /************************************************************************
2561: * *
2562: * URI based tests *
2563: * *
2564: ************************************************************************/
2565:
2566: static void
2567: handleURI(const char *str, const char *base, FILE *o) {
2568: int ret;
2569: xmlURIPtr uri;
2570: xmlChar *res = NULL;
2571:
2572: uri = xmlCreateURI();
2573:
2574: if (base == NULL) {
2575: ret = xmlParseURIReference(uri, str);
2576: if (ret != 0)
2577: fprintf(o, "%s : error %d\n", str, ret);
2578: else {
2579: xmlNormalizeURIPath(uri->path);
2580: xmlPrintURI(o, uri);
2581: fprintf(o, "\n");
2582: }
2583: } else {
2584: res = xmlBuildURI((xmlChar *)str, (xmlChar *) base);
2585: if (res != NULL) {
2586: fprintf(o, "%s\n", (char *) res);
2587: }
2588: else
2589: fprintf(o, "::ERROR::\n");
2590: }
2591: if (res != NULL)
2592: xmlFree(res);
2593: xmlFreeURI(uri);
2594: }
2595:
2596: /**
2597: * uriCommonTest:
2598: * @filename: the file to parse
2599: * @result: the file with expected result
2600: * @err: the file with error messages
2601: *
2602: * Parse a file containing URI and check for errors
2603: *
2604: * Returns 0 in case of success, an error code otherwise
2605: */
2606: static int
2607: uriCommonTest(const char *filename,
2608: const char *result,
2609: const char *err,
2610: const char *base) {
2611: char *temp;
2612: FILE *o, *f;
2613: char str[1024];
2614: int res = 0, i, ret;
2615:
2616: temp = resultFilename(filename, "", ".res");
2617: if (temp == NULL) {
2618: fprintf(stderr, "Out of memory\n");
2619: fatalError();
2620: }
2621: o = fopen(temp, "wb");
2622: if (o == NULL) {
2623: fprintf(stderr, "failed to open output file %s\n", temp);
2624: free(temp);
2625: return(-1);
2626: }
2627: f = fopen(filename, "rb");
2628: if (f == NULL) {
2629: fprintf(stderr, "failed to open input file %s\n", filename);
2630: fclose(o);
2631: if (temp != NULL) {
2632: unlink(temp);
2633: free(temp);
2634: }
2635: return(-1);
2636: }
2637:
2638: while (1) {
2639: /*
2640: * read one line in string buffer.
2641: */
2642: if (fgets (&str[0], sizeof (str) - 1, f) == NULL)
2643: break;
2644:
2645: /*
2646: * remove the ending spaces
2647: */
2648: i = strlen(str);
2649: while ((i > 0) &&
2650: ((str[i - 1] == '\n') || (str[i - 1] == '\r') ||
2651: (str[i - 1] == ' ') || (str[i - 1] == '\t'))) {
2652: i--;
2653: str[i] = 0;
2654: }
2655: nb_tests++;
2656: handleURI(str, base, o);
2657: }
2658:
2659: fclose(f);
2660: fclose(o);
2661:
2662: if (result != NULL) {
2663: ret = compareFiles(temp, result);
2664: if (ret) {
2665: fprintf(stderr, "Result for %s failed\n", filename);
2666: res = 1;
2667: }
2668: }
2669: if (err != NULL) {
2670: ret = compareFileMem(err, testErrors, testErrorsSize);
2671: if (ret != 0) {
2672: fprintf(stderr, "Error for %s failed\n", filename);
2673: res = 1;
2674: }
2675: }
2676:
2677: if (temp != NULL) {
2678: unlink(temp);
2679: free(temp);
2680: }
2681: return(res);
2682: }
2683:
2684: /**
2685: * uriParseTest:
2686: * @filename: the file to parse
2687: * @result: the file with expected result
2688: * @err: the file with error messages
2689: *
2690: * Parse a file containing URI and check for errors
2691: *
2692: * Returns 0 in case of success, an error code otherwise
2693: */
2694: static int
2695: uriParseTest(const char *filename,
2696: const char *result,
2697: const char *err,
2698: int options ATTRIBUTE_UNUSED) {
2699: return(uriCommonTest(filename, result, err, NULL));
2700: }
2701:
2702: /**
2703: * uriBaseTest:
2704: * @filename: the file to parse
2705: * @result: the file with expected result
2706: * @err: the file with error messages
2707: *
2708: * Parse a file containing URI, compose them against a fixed base and
2709: * check for errors
2710: *
2711: * Returns 0 in case of success, an error code otherwise
2712: */
2713: static int
2714: uriBaseTest(const char *filename,
2715: const char *result,
2716: const char *err,
2717: int options ATTRIBUTE_UNUSED) {
2718: return(uriCommonTest(filename, result, err,
2719: "http://foo.com/path/to/index.html?orig#help"));
2720: }
2721:
2722: static int urip_success = 1;
2723: static int urip_current = 0;
2724: static const char *urip_testURLs[] = {
2725: "urip://example.com/a b.html",
2726: "urip://example.com/a%20b.html",
2727: "file:///path/to/a b.html",
2728: "file:///path/to/a%20b.html",
2729: "/path/to/a b.html",
2730: "/path/to/a%20b.html",
2731: "urip://example.com/résumé.html",
2732: "urip://example.com/test?a=1&b=2%263&c=4#foo",
2733: NULL
2734: };
2735: static const char *urip_rcvsURLs[] = {
2736: /* it is an URI the strings must be escaped */
2737: "urip://example.com/a%20b.html",
2738: /* check that % escaping is not broken */
2739: "urip://example.com/a%20b.html",
2740: /* it's an URI path the strings must be escaped */
2741: "file:///path/to/a%20b.html",
2742: /* check that % escaping is not broken */
2743: "file:///path/to/a%20b.html",
2744: /* this is not an URI, this is a path, so this should not be escaped */
2745: "/path/to/a b.html",
2746: /* check that paths with % are not broken */
2747: "/path/to/a%20b.html",
2748: /* out of context the encoding can't be guessed byte by byte conversion */
2749: "urip://example.com/r%E9sum%E9.html",
2750: /* verify we don't destroy URIs especially the query part */
2751: "urip://example.com/test?a=1&b=2%263&c=4#foo",
2752: NULL
2753: };
2754: static const char *urip_res = "<list/>";
2755: static const char *urip_cur = NULL;
2756: static int urip_rlen;
2757:
2758: /**
2759: * uripMatch:
2760: * @URI: an URI to test
2761: *
2762: * Check for an urip: query
2763: *
2764: * Returns 1 if yes and 0 if another Input module should be used
2765: */
2766: static int
2767: uripMatch(const char * URI) {
2768: if ((URI == NULL) || (!strcmp(URI, "file:///etc/xml/catalog")))
2769: return(0);
2770: /* Verify we received the escaped URL */
2771: if (strcmp(urip_rcvsURLs[urip_current], URI))
2772: urip_success = 0;
2773: return(1);
2774: }
2775:
2776: /**
2777: * uripOpen:
2778: * @URI: an URI to test
2779: *
2780: * Return a pointer to the urip: query handler, in this example simply
2781: * the urip_current pointer...
2782: *
2783: * Returns an Input context or NULL in case or error
2784: */
2785: static void *
2786: uripOpen(const char * URI) {
2787: if ((URI == NULL) || (!strcmp(URI, "file:///etc/xml/catalog")))
2788: return(NULL);
2789: /* Verify we received the escaped URL */
2790: if (strcmp(urip_rcvsURLs[urip_current], URI))
2791: urip_success = 0;
2792: urip_cur = urip_res;
2793: urip_rlen = strlen(urip_res);
2794: return((void *) urip_cur);
2795: }
2796:
2797: /**
2798: * uripClose:
2799: * @context: the read context
2800: *
2801: * Close the urip: query handler
2802: *
2803: * Returns 0 or -1 in case of error
2804: */
2805: static int
2806: uripClose(void * context) {
2807: if (context == NULL) return(-1);
2808: urip_cur = NULL;
2809: urip_rlen = 0;
2810: return(0);
2811: }
2812:
2813: /**
2814: * uripRead:
2815: * @context: the read context
2816: * @buffer: where to store data
2817: * @len: number of bytes to read
2818: *
2819: * Implement an urip: query read.
2820: *
2821: * Returns the number of bytes read or -1 in case of error
2822: */
2823: static int
2824: uripRead(void * context, char * buffer, int len) {
2825: const char *ptr = (const char *) context;
2826:
2827: if ((context == NULL) || (buffer == NULL) || (len < 0))
2828: return(-1);
2829:
2830: if (len > urip_rlen) len = urip_rlen;
2831: memcpy(buffer, ptr, len);
2832: urip_rlen -= len;
2833: return(len);
2834: }
2835:
2836: static int
2837: urip_checkURL(const char *URL) {
2838: xmlDocPtr doc;
2839:
2840: doc = xmlReadFile(URL, NULL, 0);
2841: if (doc == NULL)
2842: return(-1);
2843: xmlFreeDoc(doc);
2844: return(1);
2845: }
2846:
2847: /**
2848: * uriPathTest:
2849: * @filename: ignored
2850: * @result: ignored
2851: * @err: ignored
2852: *
2853: * Run a set of tests to check how Path and URI are handled before
2854: * being passed to the I/O layer
2855: *
2856: * Returns 0 in case of success, an error code otherwise
2857: */
2858: static int
2859: uriPathTest(const char *filename ATTRIBUTE_UNUSED,
2860: const char *result ATTRIBUTE_UNUSED,
2861: const char *err ATTRIBUTE_UNUSED,
2862: int options ATTRIBUTE_UNUSED) {
2863: int parsed;
2864: int failures = 0;
2865:
2866: /*
2867: * register the new I/O handlers
2868: */
2869: if (xmlRegisterInputCallbacks(uripMatch, uripOpen, uripRead, uripClose) < 0)
2870: {
2871: fprintf(stderr, "failed to register HTTP handler\n");
2872: return(-1);
2873: }
2874:
2875: for (urip_current = 0;urip_testURLs[urip_current] != NULL;urip_current++) {
2876: urip_success = 1;
2877: parsed = urip_checkURL(urip_testURLs[urip_current]);
2878: if (urip_success != 1) {
2879: fprintf(stderr, "failed the URL passing test for %s",
2880: urip_testURLs[urip_current]);
2881: failures++;
2882: } else if (parsed != 1) {
2883: fprintf(stderr, "failed the parsing test for %s",
2884: urip_testURLs[urip_current]);
2885: failures++;
2886: }
2887: nb_tests++;
2888: }
2889:
2890: xmlPopInputCallbacks();
2891: return(failures);
2892: }
2893:
2894: #ifdef LIBXML_SCHEMAS_ENABLED
2895: /************************************************************************
2896: * *
2897: * Schemas tests *
2898: * *
2899: ************************************************************************/
2900: static int
2901: schemasOneTest(const char *sch,
2902: const char *filename,
2903: const char *result,
2904: const char *err,
2905: int options,
2906: xmlSchemaPtr schemas) {
2907: xmlDocPtr doc;
2908: xmlSchemaValidCtxtPtr ctxt;
2909: int ret = 0;
2910: int validResult = 0;
2911: char *temp;
2912: FILE *schemasOutput;
2913:
2914: doc = xmlReadFile(filename, NULL, options);
2915: if (doc == NULL) {
2916: fprintf(stderr, "failed to parse instance %s for %s\n", filename, sch);
2917: return(-1);
2918: }
2919:
2920: temp = resultFilename(result, "", ".res");
2921: if (temp == NULL) {
2922: fprintf(stderr, "Out of memory\n");
2923: fatalError();
2924: }
2925: schemasOutput = fopen(temp, "wb");
2926: if (schemasOutput == NULL) {
2927: fprintf(stderr, "failed to open output file %s\n", temp);
2928: xmlFreeDoc(doc);
2929: free(temp);
2930: return(-1);
2931: }
2932:
2933: ctxt = xmlSchemaNewValidCtxt(schemas);
2934: xmlSchemaSetValidErrors(ctxt,
2935: (xmlSchemaValidityErrorFunc) testErrorHandler,
2936: (xmlSchemaValidityWarningFunc) testErrorHandler,
2937: ctxt);
2938: validResult = xmlSchemaValidateDoc(ctxt, doc);
2939: if (validResult == 0) {
2940: fprintf(schemasOutput, "%s validates\n", filename);
2941: } else if (validResult > 0) {
2942: fprintf(schemasOutput, "%s fails to validate\n", filename);
2943: } else {
2944: fprintf(schemasOutput, "%s validation generated an internal error\n",
2945: filename);
2946: }
2947: fclose(schemasOutput);
2948: if (result) {
2949: if (compareFiles(temp, result)) {
2950: fprintf(stderr, "Result for %s on %s failed\n", filename, sch);
2951: ret = 1;
2952: }
2953: }
2954: if (temp != NULL) {
2955: unlink(temp);
2956: free(temp);
2957: }
2958:
2959: if ((validResult != 0) && (err != NULL)) {
2960: if (compareFileMem(err, testErrors, testErrorsSize)) {
2961: fprintf(stderr, "Error for %s on %s failed\n", filename, sch);
2962: ret = 1;
2963: }
2964: }
2965:
2966: xmlSchemaFreeValidCtxt(ctxt);
2967: xmlFreeDoc(doc);
2968: return(ret);
2969: }
2970: /**
2971: * schemasTest:
2972: * @filename: the schemas file
2973: * @result: the file with expected result
2974: * @err: the file with error messages
2975: *
2976: * Parse a file containing URI, compose them against a fixed base and
2977: * check for errors
2978: *
2979: * Returns 0 in case of success, an error code otherwise
2980: */
2981: static int
2982: schemasTest(const char *filename,
2983: const char *resul ATTRIBUTE_UNUSED,
2984: const char *errr ATTRIBUTE_UNUSED,
2985: int options) {
2986: const char *base = baseFilename(filename);
2987: const char *base2;
2988: const char *instance;
2989: xmlSchemaParserCtxtPtr ctxt;
2990: xmlSchemaPtr schemas;
2991: int res = 0, len, ret;
2992: char pattern[500];
2993: char prefix[500];
2994: char result[500];
2995: char err[500];
2996: glob_t globbuf;
2997: size_t i;
2998: char count = 0;
2999:
3000: /* first compile the schemas if possible */
3001: ctxt = xmlSchemaNewParserCtxt(filename);
3002: xmlSchemaSetParserErrors(ctxt,
3003: (xmlSchemaValidityErrorFunc) testErrorHandler,
3004: (xmlSchemaValidityWarningFunc) testErrorHandler,
3005: ctxt);
3006: schemas = xmlSchemaParse(ctxt);
3007: xmlSchemaFreeParserCtxt(ctxt);
3008:
3009: /*
3010: * most of the mess is about the output filenames generated by the Makefile
3011: */
3012: len = strlen(base);
3013: if ((len > 499) || (len < 5)) {
3014: xmlSchemaFree(schemas);
3015: return(-1);
3016: }
3017: len -= 4; /* remove trailing .xsd */
3018: if (base[len - 2] == '_') {
3019: len -= 2; /* remove subtest number */
3020: }
3021: if (base[len - 2] == '_') {
3022: len -= 2; /* remove subtest number */
3023: }
3024: memcpy(prefix, base, len);
3025: prefix[len] = 0;
3026:
3027: snprintf(pattern, 499, "./test/schemas/%s_?.xml", prefix);
3028: pattern[499] = 0;
3029:
3030: if (base[len] == '_') {
3031: len += 2;
3032: memcpy(prefix, base, len);
3033: prefix[len] = 0;
3034: }
3035:
3036: globbuf.gl_offs = 0;
3037: glob(pattern, GLOB_DOOFFS, NULL, &globbuf);
3038: for (i = 0;i < globbuf.gl_pathc;i++) {
3039: testErrorsSize = 0;
3040: testErrors[0] = 0;
3041: instance = globbuf.gl_pathv[i];
3042: base2 = baseFilename(instance);
3043: len = strlen(base2);
3044: if ((len > 6) && (base2[len - 6] == '_')) {
3045: count = base2[len - 5];
3046: snprintf(result, 499, "result/schemas/%s_%c",
3047: prefix, count);
3048: result[499] = 0;
3049: snprintf(err, 499, "result/schemas/%s_%c.err",
3050: prefix, count);
3051: err[499] = 0;
3052: } else {
3053: fprintf(stderr, "don't know how to process %s\n", instance);
3054: continue;
3055: }
3056: if (schemas == NULL) {
3057: } else {
3058: nb_tests++;
3059: ret = schemasOneTest(filename, instance, result, err,
3060: options, schemas);
3061: if (ret != 0)
3062: res = ret;
3063: }
3064: }
3065: globfree(&globbuf);
3066: xmlSchemaFree(schemas);
3067:
3068: return(res);
3069: }
3070:
3071: /************************************************************************
3072: * *
3073: * Schemas tests *
3074: * *
3075: ************************************************************************/
3076: static int
3077: rngOneTest(const char *sch,
3078: const char *filename,
3079: const char *result,
3080: const char *err,
3081: int options,
3082: xmlRelaxNGPtr schemas) {
3083: xmlDocPtr doc;
3084: xmlRelaxNGValidCtxtPtr ctxt;
3085: int ret = 0;
3086: char *temp;
3087: FILE *schemasOutput;
3088:
3089: doc = xmlReadFile(filename, NULL, options);
3090: if (doc == NULL) {
3091: fprintf(stderr, "failed to parse instance %s for %s\n", filename, sch);
3092: return(-1);
3093: }
3094:
3095: temp = resultFilename(result, "", ".res");
3096: if (temp == NULL) {
3097: fprintf(stderr, "Out of memory\n");
3098: fatalError();
3099: }
3100: schemasOutput = fopen(temp, "wb");
3101: if (schemasOutput == NULL) {
3102: fprintf(stderr, "failed to open output file %s\n", temp);
3103: xmlFreeDoc(doc);
3104: free(temp);
3105: return(-1);
3106: }
3107:
3108: ctxt = xmlRelaxNGNewValidCtxt(schemas);
3109: xmlRelaxNGSetValidErrors(ctxt,
3110: (xmlRelaxNGValidityErrorFunc) testErrorHandler,
3111: (xmlRelaxNGValidityWarningFunc) testErrorHandler,
3112: ctxt);
3113: ret = xmlRelaxNGValidateDoc(ctxt, doc);
3114: if (ret == 0) {
3115: testErrorHandler(NULL, "%s validates\n", filename);
3116: } else if (ret > 0) {
3117: testErrorHandler(NULL, "%s fails to validate\n", filename);
3118: } else {
3119: testErrorHandler(NULL, "%s validation generated an internal error\n",
3120: filename);
3121: }
3122: fclose(schemasOutput);
3123: ret = 0;
3124: if (result) {
3125: if (compareFiles(temp, result)) {
3126: fprintf(stderr, "Result for %s on %s failed\n", filename, sch);
3127: ret = 1;
3128: }
3129: }
3130: if (temp != NULL) {
3131: unlink(temp);
3132: free(temp);
3133: }
3134:
3135: if (err != NULL) {
3136: if (compareFileMem(err, testErrors, testErrorsSize)) {
3137: fprintf(stderr, "Error for %s on %s failed\n", filename, sch);
3138: ret = 1;
3139: printf("%s", testErrors);
3140: }
3141: }
3142:
3143:
3144: xmlRelaxNGFreeValidCtxt(ctxt);
3145: xmlFreeDoc(doc);
3146: return(ret);
3147: }
3148: /**
3149: * rngTest:
3150: * @filename: the schemas file
3151: * @result: the file with expected result
3152: * @err: the file with error messages
3153: *
3154: * Parse an RNG schemas and then apply it to the related .xml
3155: *
3156: * Returns 0 in case of success, an error code otherwise
3157: */
3158: static int
3159: rngTest(const char *filename,
3160: const char *resul ATTRIBUTE_UNUSED,
3161: const char *errr ATTRIBUTE_UNUSED,
3162: int options) {
3163: const char *base = baseFilename(filename);
3164: const char *base2;
3165: const char *instance;
3166: xmlRelaxNGParserCtxtPtr ctxt;
3167: xmlRelaxNGPtr schemas;
3168: int res = 0, len, ret = 0;
3169: char pattern[500];
3170: char prefix[500];
3171: char result[500];
3172: char err[500];
3173: glob_t globbuf;
3174: size_t i;
3175: char count = 0;
3176:
3177: /* first compile the schemas if possible */
3178: ctxt = xmlRelaxNGNewParserCtxt(filename);
3179: xmlRelaxNGSetParserErrors(ctxt,
3180: (xmlRelaxNGValidityErrorFunc) testErrorHandler,
3181: (xmlRelaxNGValidityWarningFunc) testErrorHandler,
3182: ctxt);
3183: schemas = xmlRelaxNGParse(ctxt);
3184: xmlRelaxNGFreeParserCtxt(ctxt);
3185:
3186: /*
3187: * most of the mess is about the output filenames generated by the Makefile
3188: */
3189: len = strlen(base);
3190: if ((len > 499) || (len < 5)) {
3191: xmlRelaxNGFree(schemas);
3192: return(-1);
3193: }
3194: len -= 4; /* remove trailing .rng */
3195: memcpy(prefix, base, len);
3196: prefix[len] = 0;
3197:
3198: snprintf(pattern, 499, "./test/relaxng/%s_?.xml", prefix);
3199: pattern[499] = 0;
3200:
3201: globbuf.gl_offs = 0;
3202: glob(pattern, GLOB_DOOFFS, NULL, &globbuf);
3203: for (i = 0;i < globbuf.gl_pathc;i++) {
3204: testErrorsSize = 0;
3205: testErrors[0] = 0;
3206: instance = globbuf.gl_pathv[i];
3207: base2 = baseFilename(instance);
3208: len = strlen(base2);
3209: if ((len > 6) && (base2[len - 6] == '_')) {
3210: count = base2[len - 5];
3211: snprintf(result, 499, "result/relaxng/%s_%c",
3212: prefix, count);
3213: result[499] = 0;
3214: snprintf(err, 499, "result/relaxng/%s_%c.err",
3215: prefix, count);
3216: err[499] = 0;
3217: } else {
3218: fprintf(stderr, "don't know how to process %s\n", instance);
3219: continue;
3220: }
3221: if (schemas == NULL) {
3222: } else {
3223: nb_tests++;
3224: ret = rngOneTest(filename, instance, result, err,
3225: options, schemas);
3226: if (res != 0)
3227: ret = res;
3228: }
3229: }
3230: globfree(&globbuf);
3231: xmlRelaxNGFree(schemas);
3232:
3233: return(ret);
3234: }
3235:
3236: #ifdef LIBXML_READER_ENABLED
3237: /**
3238: * rngStreamTest:
3239: * @filename: the schemas file
3240: * @result: the file with expected result
3241: * @err: the file with error messages
3242: *
3243: * Parse a set of files with streaming, applying an RNG schemas
3244: *
3245: * Returns 0 in case of success, an error code otherwise
3246: */
3247: static int
3248: rngStreamTest(const char *filename,
3249: const char *resul ATTRIBUTE_UNUSED,
3250: const char *errr ATTRIBUTE_UNUSED,
3251: int options) {
3252: const char *base = baseFilename(filename);
3253: const char *base2;
3254: const char *instance;
3255: int res = 0, len, ret;
3256: char pattern[500];
3257: char prefix[500];
3258: char result[500];
3259: char err[500];
3260: glob_t globbuf;
3261: size_t i;
3262: char count = 0;
3263: xmlTextReaderPtr reader;
3264: int disable_err = 0;
3265:
3266: /*
3267: * most of the mess is about the output filenames generated by the Makefile
3268: */
3269: len = strlen(base);
3270: if ((len > 499) || (len < 5)) {
3271: fprintf(stderr, "len(base) == %d !\n", len);
3272: return(-1);
3273: }
3274: len -= 4; /* remove trailing .rng */
3275: memcpy(prefix, base, len);
3276: prefix[len] = 0;
3277:
3278: /*
3279: * strictly unifying the error messages is nearly impossible this
3280: * hack is also done in the Makefile
3281: */
3282: if ((!strcmp(prefix, "tutor10_1")) || (!strcmp(prefix, "tutor10_2")) ||
3283: (!strcmp(prefix, "tutor3_2")) || (!strcmp(prefix, "307377")) ||
3284: (!strcmp(prefix, "tutor8_2")))
3285: disable_err = 1;
3286:
3287: snprintf(pattern, 499, "./test/relaxng/%s_?.xml", prefix);
3288: pattern[499] = 0;
3289:
3290: globbuf.gl_offs = 0;
3291: glob(pattern, GLOB_DOOFFS, NULL, &globbuf);
3292: for (i = 0;i < globbuf.gl_pathc;i++) {
3293: testErrorsSize = 0;
3294: testErrors[0] = 0;
3295: instance = globbuf.gl_pathv[i];
3296: base2 = baseFilename(instance);
3297: len = strlen(base2);
3298: if ((len > 6) && (base2[len - 6] == '_')) {
3299: count = base2[len - 5];
3300: snprintf(result, 499, "result/relaxng/%s_%c",
3301: prefix, count);
3302: result[499] = 0;
3303: snprintf(err, 499, "result/relaxng/%s_%c.err",
3304: prefix, count);
3305: err[499] = 0;
3306: } else {
3307: fprintf(stderr, "don't know how to process %s\n", instance);
3308: continue;
3309: }
3310: reader = xmlReaderForFile(instance, NULL, options);
3311: if (reader == NULL) {
3312: fprintf(stderr, "Failed to build reder for %s\n", instance);
3313: }
3314: if (disable_err == 1)
3315: ret = streamProcessTest(instance, result, NULL, reader, filename);
3316: else
3317: ret = streamProcessTest(instance, result, err, reader, filename);
3318: xmlFreeTextReader(reader);
3319: if (ret != 0) {
3320: fprintf(stderr, "instance %s failed\n", instance);
3321: res = ret;
3322: }
3323: }
3324: globfree(&globbuf);
3325:
3326: return(res);
3327: }
3328: #endif /* READER */
3329:
3330: #endif
3331:
3332: #ifdef LIBXML_PATTERN_ENABLED
3333: #ifdef LIBXML_READER_ENABLED
3334: /************************************************************************
3335: * *
3336: * Patterns tests *
3337: * *
3338: ************************************************************************/
3339: static void patternNode(FILE *out, xmlTextReaderPtr reader,
3340: const char *pattern, xmlPatternPtr patternc,
3341: xmlStreamCtxtPtr patstream) {
3342: xmlChar *path = NULL;
3343: int match = -1;
3344: int type, empty;
3345:
3346: type = xmlTextReaderNodeType(reader);
3347: empty = xmlTextReaderIsEmptyElement(reader);
3348:
3349: if (type == XML_READER_TYPE_ELEMENT) {
3350: /* do the check only on element start */
3351: match = xmlPatternMatch(patternc, xmlTextReaderCurrentNode(reader));
3352:
3353: if (match) {
3354: path = xmlGetNodePath(xmlTextReaderCurrentNode(reader));
3355: fprintf(out, "Node %s matches pattern %s\n", path, pattern);
3356: }
3357: }
3358: if (patstream != NULL) {
3359: int ret;
3360:
3361: if (type == XML_READER_TYPE_ELEMENT) {
3362: ret = xmlStreamPush(patstream,
3363: xmlTextReaderConstLocalName(reader),
3364: xmlTextReaderConstNamespaceUri(reader));
3365: if (ret < 0) {
3366: fprintf(out, "xmlStreamPush() failure\n");
3367: xmlFreeStreamCtxt(patstream);
3368: patstream = NULL;
3369: } else if (ret != match) {
3370: if (path == NULL) {
3371: path = xmlGetNodePath(
3372: xmlTextReaderCurrentNode(reader));
3373: }
3374: fprintf(out,
3375: "xmlPatternMatch and xmlStreamPush disagree\n");
3376: fprintf(out,
3377: " pattern %s node %s\n",
3378: pattern, path);
3379: }
3380:
3381:
3382: }
3383: if ((type == XML_READER_TYPE_END_ELEMENT) ||
3384: ((type == XML_READER_TYPE_ELEMENT) && (empty))) {
3385: ret = xmlStreamPop(patstream);
3386: if (ret < 0) {
3387: fprintf(out, "xmlStreamPop() failure\n");
3388: xmlFreeStreamCtxt(patstream);
3389: patstream = NULL;
3390: }
3391: }
3392: }
3393: if (path != NULL)
3394: xmlFree(path);
3395: }
3396:
3397: /**
3398: * patternTest:
3399: * @filename: the schemas file
3400: * @result: the file with expected result
3401: * @err: the file with error messages
3402: *
3403: * Parse a set of files with streaming, applying an RNG schemas
3404: *
3405: * Returns 0 in case of success, an error code otherwise
3406: */
3407: static int
3408: patternTest(const char *filename,
3409: const char *resul ATTRIBUTE_UNUSED,
3410: const char *err ATTRIBUTE_UNUSED,
3411: int options) {
3412: xmlPatternPtr patternc = NULL;
3413: xmlStreamCtxtPtr patstream = NULL;
3414: FILE *o, *f;
3415: char str[1024];
3416: char xml[500];
3417: char result[500];
3418: int len, i;
3419: int ret = 0, res;
3420: char *temp;
3421: xmlTextReaderPtr reader;
3422: xmlDocPtr doc;
3423:
3424: len = strlen(filename);
3425: len -= 4;
3426: memcpy(xml, filename, len);
3427: xml[len] = 0;
3428: snprintf(result, 499, "result/pattern/%s", baseFilename(xml));
3429: result[499] = 0;
3430: memcpy(xml + len, ".xml", 5);
3431:
3432: if (!checkTestFile(xml)) {
3433: fprintf(stderr, "Missing xml file %s\n", xml);
3434: return(-1);
3435: }
3436: if (!checkTestFile(result)) {
3437: fprintf(stderr, "Missing result file %s\n", result);
3438: return(-1);
3439: }
3440: f = fopen(filename, "rb");
3441: if (f == NULL) {
3442: fprintf(stderr, "Failed to open %s\n", filename);
3443: return(-1);
3444: }
3445: temp = resultFilename(filename, "", ".res");
3446: if (temp == NULL) {
3447: fprintf(stderr, "Out of memory\n");
3448: fatalError();
3449: }
3450: o = fopen(temp, "wb");
3451: if (o == NULL) {
3452: fprintf(stderr, "failed to open output file %s\n", temp);
3453: fclose(f);
3454: free(temp);
3455: return(-1);
3456: }
3457: while (1) {
3458: /*
3459: * read one line in string buffer.
3460: */
3461: if (fgets (&str[0], sizeof (str) - 1, f) == NULL)
3462: break;
3463:
3464: /*
3465: * remove the ending spaces
3466: */
3467: i = strlen(str);
3468: while ((i > 0) &&
3469: ((str[i - 1] == '\n') || (str[i - 1] == '\r') ||
3470: (str[i - 1] == ' ') || (str[i - 1] == '\t'))) {
3471: i--;
3472: str[i] = 0;
3473: }
3474: doc = xmlReadFile(xml, NULL, options);
3475: if (doc == NULL) {
3476: fprintf(stderr, "Failed to parse %s\n", xml);
3477: ret = 1;
3478: } else {
3479: xmlNodePtr root;
3480: const xmlChar *namespaces[22];
3481: int j;
3482: xmlNsPtr ns;
3483:
3484: root = xmlDocGetRootElement(doc);
3485: for (ns = root->nsDef, j = 0;ns != NULL && j < 20;ns=ns->next) {
3486: namespaces[j++] = ns->href;
3487: namespaces[j++] = ns->prefix;
3488: }
3489: namespaces[j++] = NULL;
3490: namespaces[j] = NULL;
3491:
3492: patternc = xmlPatterncompile((const xmlChar *) str, doc->dict,
3493: 0, &namespaces[0]);
3494: if (patternc == NULL) {
3495: testErrorHandler(NULL,
3496: "Pattern %s failed to compile\n", str);
3497: xmlFreeDoc(doc);
3498: ret = 1;
3499: continue;
3500: }
3501: patstream = xmlPatternGetStreamCtxt(patternc);
3502: if (patstream != NULL) {
3503: ret = xmlStreamPush(patstream, NULL, NULL);
3504: if (ret < 0) {
3505: fprintf(stderr, "xmlStreamPush() failure\n");
3506: xmlFreeStreamCtxt(patstream);
3507: patstream = NULL;
3508: }
3509: }
3510: nb_tests++;
3511:
3512: reader = xmlReaderWalker(doc);
3513: res = xmlTextReaderRead(reader);
3514: while (res == 1) {
3515: patternNode(o, reader, str, patternc, patstream);
3516: res = xmlTextReaderRead(reader);
3517: }
3518: if (res != 0) {
3519: fprintf(o, "%s : failed to parse\n", filename);
3520: }
3521: xmlFreeTextReader(reader);
3522: xmlFreeDoc(doc);
3523: xmlFreeStreamCtxt(patstream);
3524: patstream = NULL;
3525: xmlFreePattern(patternc);
3526:
3527: }
3528: }
3529:
3530: fclose(f);
3531: fclose(o);
3532:
3533: ret = compareFiles(temp, result);
3534: if (ret) {
3535: fprintf(stderr, "Result for %s failed\n", filename);
3536: ret = 1;
3537: }
3538: if (temp != NULL) {
3539: unlink(temp);
3540: free(temp);
3541: }
3542: return(ret);
3543: }
3544: #endif /* READER */
3545: #endif /* PATTERN */
3546: #ifdef LIBXML_C14N_ENABLED
3547: /************************************************************************
3548: * *
3549: * Canonicalization tests *
3550: * *
3551: ************************************************************************/
3552: static xmlXPathObjectPtr
3553: load_xpath_expr (xmlDocPtr parent_doc, const char* filename) {
3554: xmlXPathObjectPtr xpath;
3555: xmlDocPtr doc;
3556: xmlChar *expr;
3557: xmlXPathContextPtr ctx;
3558: xmlNodePtr node;
3559: xmlNsPtr ns;
3560:
3561: /*
3562: * load XPath expr as a file
3563: */
3564: xmlLoadExtDtdDefaultValue = XML_DETECT_IDS | XML_COMPLETE_ATTRS;
3565: xmlSubstituteEntitiesDefault(1);
3566:
3567: doc = xmlReadFile(filename, NULL, XML_PARSE_DTDATTR | XML_PARSE_NOENT);
3568: if (doc == NULL) {
3569: fprintf(stderr, "Error: unable to parse file \"%s\"\n", filename);
3570: return(NULL);
3571: }
3572:
3573: /*
3574: * Check the document is of the right kind
3575: */
3576: if(xmlDocGetRootElement(doc) == NULL) {
3577: fprintf(stderr,"Error: empty document for file \"%s\"\n", filename);
3578: xmlFreeDoc(doc);
3579: return(NULL);
3580: }
3581:
3582: node = doc->children;
3583: while(node != NULL && !xmlStrEqual(node->name, (const xmlChar *)"XPath")) {
3584: node = node->next;
3585: }
3586:
3587: if(node == NULL) {
3588: fprintf(stderr,"Error: XPath element expected in the file \"%s\"\n", filename);
3589: xmlFreeDoc(doc);
3590: return(NULL);
3591: }
3592:
3593: expr = xmlNodeGetContent(node);
3594: if(expr == NULL) {
3595: fprintf(stderr,"Error: XPath content element is NULL \"%s\"\n", filename);
3596: xmlFreeDoc(doc);
3597: return(NULL);
3598: }
3599:
3600: ctx = xmlXPathNewContext(parent_doc);
3601: if(ctx == NULL) {
3602: fprintf(stderr,"Error: unable to create new context\n");
3603: xmlFree(expr);
3604: xmlFreeDoc(doc);
3605: return(NULL);
3606: }
3607:
3608: /*
3609: * Register namespaces
3610: */
3611: ns = node->nsDef;
3612: while(ns != NULL) {
3613: if(xmlXPathRegisterNs(ctx, ns->prefix, ns->href) != 0) {
3614: fprintf(stderr,"Error: unable to register NS with prefix=\"%s\" and href=\"%s\"\n", ns->prefix, ns->href);
3615: xmlFree(expr);
3616: xmlXPathFreeContext(ctx);
3617: xmlFreeDoc(doc);
3618: return(NULL);
3619: }
3620: ns = ns->next;
3621: }
3622:
3623: /*
3624: * Evaluate xpath
3625: */
3626: xpath = xmlXPathEvalExpression(expr, ctx);
3627: if(xpath == NULL) {
3628: fprintf(stderr,"Error: unable to evaluate xpath expression\n");
3629: xmlFree(expr);
3630: xmlXPathFreeContext(ctx);
3631: xmlFreeDoc(doc);
3632: return(NULL);
3633: }
3634:
3635: /* print_xpath_nodes(xpath->nodesetval); */
3636:
3637: xmlFree(expr);
3638: xmlXPathFreeContext(ctx);
3639: xmlFreeDoc(doc);
3640: return(xpath);
3641: }
3642:
3643: /*
3644: * Macro used to grow the current buffer.
3645: */
3646: #define xxx_growBufferReentrant() { \
3647: buffer_size *= 2; \
3648: buffer = (xmlChar **) \
3649: xmlRealloc(buffer, buffer_size * sizeof(xmlChar*)); \
3650: if (buffer == NULL) { \
3651: perror("realloc failed"); \
3652: return(NULL); \
3653: } \
3654: }
3655:
3656: static xmlChar **
3657: parse_list(xmlChar *str) {
3658: xmlChar **buffer;
3659: xmlChar **out = NULL;
3660: int buffer_size = 0;
3661: int len;
3662:
3663: if(str == NULL) {
3664: return(NULL);
3665: }
3666:
3667: len = xmlStrlen(str);
3668: if((str[0] == '\'') && (str[len - 1] == '\'')) {
3669: str[len - 1] = '\0';
3670: str++;
3671: }
3672: /*
3673: * allocate an translation buffer.
3674: */
3675: buffer_size = 1000;
3676: buffer = (xmlChar **) xmlMalloc(buffer_size * sizeof(xmlChar*));
3677: if (buffer == NULL) {
3678: perror("malloc failed");
3679: return(NULL);
3680: }
3681: out = buffer;
3682:
3683: while(*str != '\0') {
3684: if (out - buffer > buffer_size - 10) {
3685: int indx = out - buffer;
3686:
3687: xxx_growBufferReentrant();
3688: out = &buffer[indx];
3689: }
3690: (*out++) = str;
3691: while(*str != ',' && *str != '\0') ++str;
3692: if(*str == ',') *(str++) = '\0';
3693: }
3694: (*out) = NULL;
3695: return buffer;
3696: }
3697:
3698: static int
3699: c14nRunTest(const char* xml_filename, int with_comments, int mode,
3700: const char* xpath_filename, const char *ns_filename,
3701: const char* result_file) {
3702: xmlDocPtr doc;
3703: xmlXPathObjectPtr xpath = NULL;
3704: xmlChar *result = NULL;
3705: int ret;
3706: xmlChar **inclusive_namespaces = NULL;
3707: const char *nslist = NULL;
3708: int nssize;
3709:
3710:
3711: /*
3712: * build an XML tree from a the file; we need to add default
3713: * attributes and resolve all character and entities references
3714: */
3715: xmlLoadExtDtdDefaultValue = XML_DETECT_IDS | XML_COMPLETE_ATTRS;
3716: xmlSubstituteEntitiesDefault(1);
3717:
3718: doc = xmlReadFile(xml_filename, NULL, XML_PARSE_DTDATTR | XML_PARSE_NOENT);
3719: if (doc == NULL) {
3720: fprintf(stderr, "Error: unable to parse file \"%s\"\n", xml_filename);
3721: return(-1);
3722: }
3723:
3724: /*
3725: * Check the document is of the right kind
3726: */
3727: if(xmlDocGetRootElement(doc) == NULL) {
3728: fprintf(stderr,"Error: empty document for file \"%s\"\n", xml_filename);
3729: xmlFreeDoc(doc);
3730: return(-1);
3731: }
3732:
3733: /*
3734: * load xpath file if specified
3735: */
3736: if(xpath_filename) {
3737: xpath = load_xpath_expr(doc, xpath_filename);
3738: if(xpath == NULL) {
3739: fprintf(stderr,"Error: unable to evaluate xpath expression\n");
3740: xmlFreeDoc(doc);
3741: return(-1);
3742: }
3743: }
3744:
3745: if (ns_filename != NULL) {
3746: if (loadMem(ns_filename, &nslist, &nssize)) {
3747: fprintf(stderr,"Error: unable to evaluate xpath expression\n");
3748: if(xpath != NULL) xmlXPathFreeObject(xpath);
3749: xmlFreeDoc(doc);
3750: return(-1);
3751: }
3752: inclusive_namespaces = parse_list((xmlChar *) nslist);
3753: }
3754:
3755: /*
3756: * Canonical form
3757: */
3758: /* fprintf(stderr,"File \"%s\" loaded: start canonization\n", xml_filename); */
3759: ret = xmlC14NDocDumpMemory(doc,
3760: (xpath) ? xpath->nodesetval : NULL,
3761: mode, inclusive_namespaces,
3762: with_comments, &result);
3763: if (ret >= 0) {
3764: if(result != NULL) {
3765: if (compareFileMem(result_file, (const char *) result, ret)) {
3766: fprintf(stderr, "Result mismatch for %s\n", xml_filename);
3767: fprintf(stderr, "RESULT:\n%s\n", (const char*)result);
3768: ret = -1;
3769: }
3770: }
3771: } else {
3772: fprintf(stderr,"Error: failed to canonicalize XML file \"%s\" (ret=%d)\n", xml_filename, ret);
3773: ret = -1;
3774: }
3775:
3776: /*
3777: * Cleanup
3778: */
3779: if (result != NULL) xmlFree(result);
3780: if(xpath != NULL) xmlXPathFreeObject(xpath);
3781: if (inclusive_namespaces != NULL) xmlFree(inclusive_namespaces);
3782: if (nslist != NULL) free((char *) nslist);
3783: xmlFreeDoc(doc);
3784:
3785: return(ret);
3786: }
3787:
3788: static int
3789: c14nCommonTest(const char *filename, int with_comments, int mode,
3790: const char *subdir) {
3791: char buf[500];
3792: char prefix[500];
3793: const char *base;
3794: int len;
3795: char *result = NULL;
3796: char *xpath = NULL;
3797: char *ns = NULL;
3798: int ret = 0;
3799:
3800: base = baseFilename(filename);
3801: len = strlen(base);
3802: len -= 4;
3803: memcpy(prefix, base, len);
3804: prefix[len] = 0;
3805:
3806: snprintf(buf, 499, "result/c14n/%s/%s", subdir,prefix);
3807: if (!checkTestFile(buf)) {
3808: fprintf(stderr, "Missing result file %s", buf);
3809: return(-1);
3810: }
3811: result = strdup(buf);
3812: snprintf(buf, 499, "test/c14n/%s/%s.xpath", subdir,prefix);
3813: if (checkTestFile(buf)) {
3814: xpath = strdup(buf);
3815: }
3816: snprintf(buf, 499, "test/c14n/%s/%s.ns", subdir,prefix);
3817: if (checkTestFile(buf)) {
3818: ns = strdup(buf);
3819: }
3820:
3821: nb_tests++;
3822: if (c14nRunTest(filename, with_comments, mode,
3823: xpath, ns, result) < 0)
3824: ret = 1;
3825:
3826: if (result != NULL) free(result);
3827: if (xpath != NULL) free(xpath);
3828: if (ns != NULL) free(ns);
3829: return(ret);
3830: }
3831:
3832: static int
3833: c14nWithCommentTest(const char *filename,
3834: const char *resul ATTRIBUTE_UNUSED,
3835: const char *err ATTRIBUTE_UNUSED,
3836: int options ATTRIBUTE_UNUSED) {
3837: return(c14nCommonTest(filename, 1, XML_C14N_1_0, "with-comments"));
3838: }
3839: static int
3840: c14nWithoutCommentTest(const char *filename,
3841: const char *resul ATTRIBUTE_UNUSED,
3842: const char *err ATTRIBUTE_UNUSED,
3843: int options ATTRIBUTE_UNUSED) {
3844: return(c14nCommonTest(filename, 0, XML_C14N_1_0, "without-comments"));
3845: }
3846: static int
3847: c14nExcWithoutCommentTest(const char *filename,
3848: const char *resul ATTRIBUTE_UNUSED,
3849: const char *err ATTRIBUTE_UNUSED,
3850: int options ATTRIBUTE_UNUSED) {
3851: return(c14nCommonTest(filename, 0, XML_C14N_EXCLUSIVE_1_0, "exc-without-comments"));
3852: }
3853: static int
3854: c14n11WithoutCommentTest(const char *filename,
3855: const char *resul ATTRIBUTE_UNUSED,
3856: const char *err ATTRIBUTE_UNUSED,
3857: int options ATTRIBUTE_UNUSED) {
3858: return(c14nCommonTest(filename, 0, XML_C14N_1_1, "1-1-without-comments"));
3859: }
3860: #endif
3861: #if defined(LIBXML_THREAD_ENABLED) && defined(LIBXML_CATALOG_ENABLED) && defined (LIBXML_SAX1_ENABLED)
3862: /************************************************************************
3863: * *
3864: * Catalog and threads test *
3865: * *
3866: ************************************************************************/
3867:
3868: /*
3869: * mostly a cut and paste from testThreads.c
3870: */
3871: #define MAX_ARGC 20
3872:
3873: static const char *catalog = "test/threads/complex.xml";
3874: static const char *testfiles[] = {
3875: "test/threads/abc.xml",
3876: "test/threads/acb.xml",
3877: "test/threads/bac.xml",
3878: "test/threads/bca.xml",
3879: "test/threads/cab.xml",
3880: "test/threads/cba.xml",
3881: "test/threads/invalid.xml",
3882: };
3883:
3884: static const char *Okay = "OK";
3885: static const char *Failed = "Failed";
3886:
3887: #ifndef xmlDoValidityCheckingDefaultValue
3888: #error xmlDoValidityCheckingDefaultValue is not a macro
3889: #endif
3890: #ifndef xmlGenericErrorContext
3891: #error xmlGenericErrorContext is not a macro
3892: #endif
3893:
3894: static void *
3895: thread_specific_data(void *private_data)
3896: {
3897: xmlDocPtr myDoc;
3898: const char *filename = (const char *) private_data;
3899: int okay = 1;
3900:
3901: if (!strcmp(filename, "test/threads/invalid.xml")) {
3902: xmlDoValidityCheckingDefaultValue = 0;
3903: xmlGenericErrorContext = stdout;
3904: } else {
3905: xmlDoValidityCheckingDefaultValue = 1;
3906: xmlGenericErrorContext = stderr;
3907: }
3908: myDoc = xmlParseFile(filename);
3909: if (myDoc) {
3910: xmlFreeDoc(myDoc);
3911: } else {
3912: printf("parse failed\n");
3913: okay = 0;
3914: }
3915: if (!strcmp(filename, "test/threads/invalid.xml")) {
3916: if (xmlDoValidityCheckingDefaultValue != 0) {
3917: printf("ValidityCheckingDefaultValue override failed\n");
3918: okay = 0;
3919: }
3920: if (xmlGenericErrorContext != stdout) {
3921: printf("xmlGenericErrorContext override failed\n");
3922: okay = 0;
3923: }
3924: } else {
3925: if (xmlDoValidityCheckingDefaultValue != 1) {
3926: printf("ValidityCheckingDefaultValue override failed\n");
3927: okay = 0;
3928: }
3929: if (xmlGenericErrorContext != stderr) {
3930: printf("xmlGenericErrorContext override failed\n");
3931: okay = 0;
3932: }
3933: }
3934: if (okay == 0)
3935: return ((void *) Failed);
3936: return ((void *) Okay);
3937: }
3938:
3939: #if defined(linux) || defined(__sun) || defined(__APPLE_CC__)
3940:
3941: #include <pthread.h>
3942:
3943: static pthread_t tid[MAX_ARGC];
3944:
3945: static int
3946: testThread(void)
3947: {
3948: unsigned int i, repeat;
3949: unsigned int num_threads = sizeof(testfiles) / sizeof(testfiles[0]);
3950: void *results[MAX_ARGC];
3951: int ret;
3952: int res = 0;
3953:
3954: xmlInitParser();
3955:
3956: for (repeat = 0; repeat < 500; repeat++) {
3957: xmlLoadCatalog(catalog);
3958: nb_tests++;
3959:
3960: for (i = 0; i < num_threads; i++) {
3961: results[i] = NULL;
3962: tid[i] = (pthread_t) - 1;
3963: }
3964:
3965: for (i = 0; i < num_threads; i++) {
3966: ret = pthread_create(&tid[i], 0, thread_specific_data,
3967: (void *) testfiles[i]);
3968: if (ret != 0) {
3969: fprintf(stderr, "pthread_create failed\n");
3970: return (1);
3971: }
3972: }
3973: for (i = 0; i < num_threads; i++) {
3974: ret = pthread_join(tid[i], &results[i]);
3975: if (ret != 0) {
3976: fprintf(stderr, "pthread_join failed\n");
3977: return (1);
3978: }
3979: }
3980:
3981: xmlCatalogCleanup();
3982: for (i = 0; i < num_threads; i++)
3983: if (results[i] != (void *) Okay) {
3984: fprintf(stderr, "Thread %d handling %s failed\n",
3985: i, testfiles[i]);
3986: res = 1;
3987: }
3988: }
3989: return (res);
3990: }
3991:
3992: #elif defined WIN32
3993: #include <windows.h>
3994: #include <string.h>
3995:
3996: #define TEST_REPEAT_COUNT 500
3997:
3998: static HANDLE tid[MAX_ARGC];
3999:
4000: static DWORD WINAPI
4001: win32_thread_specific_data(void *private_data)
4002: {
4003: return((DWORD) thread_specific_data(private_data));
4004: }
4005:
4006: static int
4007: testThread(void)
4008: {
4009: unsigned int i, repeat;
4010: unsigned int num_threads = sizeof(testfiles) / sizeof(testfiles[0]);
4011: DWORD results[MAX_ARGC];
4012: BOOL ret;
4013: int res = 0;
4014:
4015: xmlInitParser();
4016: for (repeat = 0; repeat < TEST_REPEAT_COUNT; repeat++) {
4017: xmlLoadCatalog(catalog);
4018: nb_tests++;
4019:
4020: for (i = 0; i < num_threads; i++) {
4021: results[i] = 0;
4022: tid[i] = (HANDLE) - 1;
4023: }
4024:
4025: for (i = 0; i < num_threads; i++) {
4026: DWORD useless;
4027:
4028: tid[i] = CreateThread(NULL, 0,
4029: win32_thread_specific_data,
4030: (void *) testfiles[i], 0,
4031: &useless);
4032: if (tid[i] == NULL) {
4033: fprintf(stderr, "CreateThread failed\n");
4034: return(1);
4035: }
4036: }
4037:
4038: if (WaitForMultipleObjects(num_threads, tid, TRUE, INFINITE) ==
4039: WAIT_FAILED) {
4040: fprintf(stderr, "WaitForMultipleObjects failed\n");
4041: return(1);
4042: }
4043:
4044: for (i = 0; i < num_threads; i++) {
4045: ret = GetExitCodeThread(tid[i], &results[i]);
4046: if (ret == 0) {
4047: fprintf(stderr, "GetExitCodeThread failed\n");
4048: return(1);
4049: }
4050: CloseHandle(tid[i]);
4051: }
4052:
4053: xmlCatalogCleanup();
4054: for (i = 0; i < num_threads; i++) {
4055: if (results[i] != (DWORD) Okay) {
4056: fprintf(stderr, "Thread %d handling %s failed\n",
4057: i, testfiles[i]);
4058: res = 1;
4059: }
4060: }
4061: }
4062:
4063: return (res);
4064: }
4065:
4066: #elif defined __BEOS__
4067: #include <OS.h>
4068:
4069: static thread_id tid[MAX_ARGC];
4070:
4071: static int
4072: testThread(void)
4073: {
4074: unsigned int i, repeat;
4075: unsigned int num_threads = sizeof(testfiles) / sizeof(testfiles[0]);
4076: void *results[MAX_ARGC];
4077: status_t ret;
4078: int res = 0;
4079:
4080: xmlInitParser();
4081: for (repeat = 0; repeat < 500; repeat++) {
4082: xmlLoadCatalog(catalog);
4083: for (i = 0; i < num_threads; i++) {
4084: results[i] = NULL;
4085: tid[i] = (thread_id) - 1;
4086: }
4087: for (i = 0; i < num_threads; i++) {
4088: tid[i] =
4089: spawn_thread(thread_specific_data, "xmlTestThread",
4090: B_NORMAL_PRIORITY, (void *) testfiles[i]);
4091: if (tid[i] < B_OK) {
4092: fprintf(stderr, "beos_thread_create failed\n");
4093: return (1);
4094: }
4095: printf("beos_thread_create %d -> %d\n", i, tid[i]);
4096: }
4097: for (i = 0; i < num_threads; i++) {
4098: ret = wait_for_thread(tid[i], &results[i]);
4099: printf("beos_thread_wait %d -> %d\n", i, ret);
4100: if (ret != B_OK) {
4101: fprintf(stderr, "beos_thread_wait failed\n");
4102: return (1);
4103: }
4104: }
4105:
4106: xmlCatalogCleanup();
4107: ret = B_OK;
4108: for (i = 0; i < num_threads; i++)
4109: if (results[i] != (void *) Okay) {
4110: printf("Thread %d handling %s failed\n", i, testfiles[i]);
4111: ret = B_ERROR;
4112: }
4113: }
4114: if (ret != B_OK)
4115: return(1);
4116: return (0);
4117: }
4118: #else
4119: static int
4120: testThread(void)
4121: {
4122: fprintf(stderr,
4123: "Specific platform thread support not detected\n");
4124: return (-1);
4125: }
4126: #endif
4127: static int
4128: threadsTest(const char *filename ATTRIBUTE_UNUSED,
4129: const char *resul ATTRIBUTE_UNUSED,
4130: const char *err ATTRIBUTE_UNUSED,
4131: int options ATTRIBUTE_UNUSED) {
4132: return(testThread());
4133: }
4134: #endif
4135: /************************************************************************
4136: * *
4137: * Tests Descriptions *
4138: * *
4139: ************************************************************************/
4140:
4141: static
4142: testDesc testDescriptions[] = {
4143: { "XML regression tests" ,
4144: oldParseTest, "./test/*", "result/", "", NULL,
4145: 0 },
4146: { "XML regression tests on memory" ,
4147: memParseTest, "./test/*", "result/", "", NULL,
4148: 0 },
4149: { "XML entity subst regression tests" ,
4150: noentParseTest, "./test/*", "result/noent/", "", NULL,
4151: XML_PARSE_NOENT },
4152: { "XML Namespaces regression tests",
4153: errParseTest, "./test/namespaces/*", "result/namespaces/", "", ".err",
4154: 0 },
4155: { "Error cases regression tests",
4156: errParseTest, "./test/errors/*.xml", "result/errors/", "", ".err",
4157: 0 },
4158: #ifdef LIBXML_READER_ENABLED
4159: { "Error cases stream regression tests",
4160: streamParseTest, "./test/errors/*.xml", "result/errors/", NULL, ".str",
4161: 0 },
4162: { "Reader regression tests",
4163: streamParseTest, "./test/*", "result/", ".rdr", NULL,
4164: 0 },
4165: { "Reader entities substitution regression tests",
4166: streamParseTest, "./test/*", "result/", ".rde", NULL,
4167: XML_PARSE_NOENT },
4168: { "Reader on memory regression tests",
4169: streamMemParseTest, "./test/*", "result/", ".rdr", NULL,
4170: 0 },
4171: { "Walker regression tests",
4172: walkerParseTest, "./test/*", "result/", ".rdr", NULL,
4173: 0 },
4174: #endif
4175: #ifdef LIBXML_SAX1_ENABLED
4176: { "SAX1 callbacks regression tests" ,
4177: saxParseTest, "./test/*", "result/", ".sax", NULL,
4178: XML_PARSE_SAX1 },
4179: { "SAX2 callbacks regression tests" ,
4180: saxParseTest, "./test/*", "result/", ".sax2", NULL,
4181: 0 },
4182: #endif
4183: #ifdef LIBXML_PUSH_ENABLED
4184: { "XML push regression tests" ,
4185: pushParseTest, "./test/*", "result/", "", NULL,
4186: 0 },
4187: #endif
4188: #ifdef LIBXML_HTML_ENABLED
4189: { "HTML regression tests" ,
4190: errParseTest, "./test/HTML/*", "result/HTML/", "", ".err",
4191: XML_PARSE_HTML },
4192: #ifdef LIBXML_PUSH_ENABLED
4193: { "Push HTML regression tests" ,
4194: pushParseTest, "./test/HTML/*", "result/HTML/", "", ".err",
4195: XML_PARSE_HTML },
4196: #endif
4197: #ifdef LIBXML_SAX1_ENABLED
4198: { "HTML SAX regression tests" ,
4199: saxParseTest, "./test/HTML/*", "result/HTML/", ".sax", NULL,
4200: XML_PARSE_HTML },
4201: #endif
4202: #endif
4203: #ifdef LIBXML_VALID_ENABLED
4204: { "Valid documents regression tests" ,
4205: errParseTest, "./test/VCM/*", NULL, NULL, NULL,
4206: XML_PARSE_DTDVALID },
4207: { "Validity checking regression tests" ,
4208: errParseTest, "./test/VC/*", "result/VC/", NULL, "",
4209: XML_PARSE_DTDVALID },
4210: { "General documents valid regression tests" ,
4211: errParseTest, "./test/valid/*", "result/valid/", "", ".err",
4212: XML_PARSE_DTDVALID },
4213: #endif
4214: #ifdef LIBXML_XINCLUDE_ENABLED
4215: { "XInclude regression tests" ,
4216: errParseTest, "./test/XInclude/docs/*", "result/XInclude/", "", NULL,
4217: /* Ignore errors at this point ".err", */
4218: XML_PARSE_XINCLUDE },
4219: #ifdef LIBXML_READER_ENABLED
4220: { "XInclude xmlReader regression tests",
4221: streamParseTest, "./test/XInclude/docs/*", "result/XInclude/", ".rdr",
4222: /* Ignore errors at this point ".err", */
4223: NULL, XML_PARSE_XINCLUDE },
4224: #endif
4225: { "XInclude regression tests stripping include nodes" ,
4226: errParseTest, "./test/XInclude/docs/*", "result/XInclude/", "", NULL,
4227: /* Ignore errors at this point ".err", */
4228: XML_PARSE_XINCLUDE | XML_PARSE_NOXINCNODE },
4229: #ifdef LIBXML_READER_ENABLED
4230: { "XInclude xmlReader regression tests stripping include nodes",
4231: streamParseTest, "./test/XInclude/docs/*", "result/XInclude/", ".rdr",
4232: /* Ignore errors at this point ".err", */
4233: NULL, XML_PARSE_XINCLUDE | XML_PARSE_NOXINCNODE },
4234: #endif
4235: #endif
4236: #ifdef LIBXML_XPATH_ENABLED
4237: #ifdef LIBXML_DEBUG_ENABLED
4238: { "XPath expressions regression tests" ,
4239: xpathExprTest, "./test/XPath/expr/*", "result/XPath/expr/", "", NULL,
4240: 0 },
4241: { "XPath document queries regression tests" ,
4242: xpathDocTest, "./test/XPath/docs/*", NULL, NULL, NULL,
4243: 0 },
4244: #ifdef LIBXML_XPTR_ENABLED
4245: { "XPointer document queries regression tests" ,
4246: xptrDocTest, "./test/XPath/docs/*", NULL, NULL, NULL,
4247: 0 },
4248: #endif
4249: { "xml:id regression tests" ,
4250: xmlidDocTest, "./test/xmlid/*", "result/xmlid/", "", ".err",
4251: 0 },
4252: #endif
4253: #endif
4254: { "URI parsing tests" ,
4255: uriParseTest, "./test/URI/*.uri", "result/URI/", "", NULL,
4256: 0 },
4257: { "URI base composition tests" ,
4258: uriBaseTest, "./test/URI/*.data", "result/URI/", "", NULL,
4259: 0 },
4260: { "Path URI conversion tests" ,
4261: uriPathTest, NULL, NULL, NULL, NULL,
4262: 0 },
4263: #ifdef LIBXML_SCHEMAS_ENABLED
4264: { "Schemas regression tests" ,
4265: schemasTest, "./test/schemas/*_*.xsd", NULL, NULL, NULL,
4266: 0 },
4267: { "Relax-NG regression tests" ,
4268: rngTest, "./test/relaxng/*.rng", NULL, NULL, NULL,
4269: XML_PARSE_DTDATTR | XML_PARSE_NOENT },
4270: #ifdef LIBXML_READER_ENABLED
4271: { "Relax-NG streaming regression tests" ,
4272: rngStreamTest, "./test/relaxng/*.rng", NULL, NULL, NULL,
4273: XML_PARSE_DTDATTR | XML_PARSE_NOENT },
4274: #endif
4275: #endif
4276: #ifdef LIBXML_PATTERN_ENABLED
4277: #ifdef LIBXML_READER_ENABLED
4278: { "Pattern regression tests" ,
4279: patternTest, "./test/pattern/*.pat", "result/pattern/", NULL, NULL,
4280: 0 },
4281: #endif
4282: #endif
4283: #ifdef LIBXML_C14N_ENABLED
4284: { "C14N with comments regression tests" ,
4285: c14nWithCommentTest, "./test/c14n/with-comments/*.xml", NULL, NULL, NULL,
4286: 0 },
4287: { "C14N without comments regression tests" ,
4288: c14nWithoutCommentTest, "./test/c14n/without-comments/*.xml", NULL, NULL, NULL,
4289: 0 },
4290: { "C14N exclusive without comments regression tests" ,
4291: c14nExcWithoutCommentTest, "./test/c14n/exc-without-comments/*.xml", NULL, NULL, NULL,
4292: 0 },
4293: { "C14N 1.1 without comments regression tests" ,
4294: c14n11WithoutCommentTest, "./test/c14n/1-1-without-comments/*.xml", NULL, NULL, NULL,
4295: 0 },
4296: #endif
4297: #if defined(LIBXML_THREAD_ENABLED) && defined(LIBXML_CATALOG_ENABLED) && defined(LIBXML_SAX1_ENABLED)
4298: { "Catalog and Threads regression tests" ,
4299: threadsTest, NULL, NULL, NULL, NULL,
4300: 0 },
4301: #endif
4302: {NULL, NULL, NULL, NULL, NULL, NULL, 0}
4303: };
4304:
4305: /************************************************************************
4306: * *
4307: * The main code driving the tests *
4308: * *
4309: ************************************************************************/
4310:
4311: static int
4312: launchTests(testDescPtr tst) {
4313: int res = 0, err = 0;
4314: size_t i;
4315: char *result;
4316: char *error;
4317: int mem;
4318:
4319: if (tst == NULL) return(-1);
4320: if (tst->in != NULL) {
4321: glob_t globbuf;
4322:
4323: globbuf.gl_offs = 0;
4324: glob(tst->in, GLOB_DOOFFS, NULL, &globbuf);
4325: for (i = 0;i < globbuf.gl_pathc;i++) {
4326: if (!checkTestFile(globbuf.gl_pathv[i]))
4327: continue;
4328: if (tst->suffix != NULL) {
4329: result = resultFilename(globbuf.gl_pathv[i], tst->out,
4330: tst->suffix);
4331: if (result == NULL) {
4332: fprintf(stderr, "Out of memory !\n");
4333: fatalError();
4334: }
4335: } else {
4336: result = NULL;
4337: }
4338: if (tst->err != NULL) {
4339: error = resultFilename(globbuf.gl_pathv[i], tst->out,
4340: tst->err);
4341: if (error == NULL) {
4342: fprintf(stderr, "Out of memory !\n");
4343: fatalError();
4344: }
4345: } else {
4346: error = NULL;
4347: }
4348: if ((result) &&(!checkTestFile(result))) {
4349: fprintf(stderr, "Missing result file %s\n", result);
4350: } else if ((error) &&(!checkTestFile(error))) {
4351: fprintf(stderr, "Missing error file %s\n", error);
4352: } else {
4353: mem = xmlMemUsed();
4354: extraMemoryFromResolver = 0;
4355: testErrorsSize = 0;
4356: testErrors[0] = 0;
4357: res = tst->func(globbuf.gl_pathv[i], result, error,
4358: tst->options | XML_PARSE_COMPACT);
4359: xmlResetLastError();
4360: if (res != 0) {
4361: fprintf(stderr, "File %s generated an error\n",
4362: globbuf.gl_pathv[i]);
4363: nb_errors++;
4364: err++;
4365: }
4366: else if (xmlMemUsed() != mem) {
4367: if ((xmlMemUsed() != mem) &&
4368: (extraMemoryFromResolver == 0)) {
4369: fprintf(stderr, "File %s leaked %d bytes\n",
4370: globbuf.gl_pathv[i], xmlMemUsed() - mem);
4371: nb_leaks++;
4372: err++;
4373: }
4374: }
4375: testErrorsSize = 0;
4376: }
4377: if (result)
4378: free(result);
4379: if (error)
4380: free(error);
4381: }
4382: globfree(&globbuf);
4383: } else {
4384: testErrorsSize = 0;
4385: testErrors[0] = 0;
4386: extraMemoryFromResolver = 0;
4387: res = tst->func(NULL, NULL, NULL, tst->options);
4388: if (res != 0) {
4389: nb_errors++;
4390: err++;
4391: }
4392: }
4393: return(err);
4394: }
4395:
4396: static int verbose = 0;
4397: static int tests_quiet = 0;
4398:
4399: static int
4400: runtest(int i) {
4401: int ret = 0, res;
4402: int old_errors, old_tests, old_leaks;
4403:
4404: old_errors = nb_errors;
4405: old_tests = nb_tests;
4406: old_leaks = nb_leaks;
4407: if ((tests_quiet == 0) && (testDescriptions[i].desc != NULL))
4408: printf("## %s\n", testDescriptions[i].desc);
4409: res = launchTests(&testDescriptions[i]);
4410: if (res != 0)
4411: ret++;
4412: if (verbose) {
4413: if ((nb_errors == old_errors) && (nb_leaks == old_leaks))
4414: printf("Ran %d tests, no errors\n", nb_tests - old_tests);
4415: else
4416: printf("Ran %d tests, %d errors, %d leaks\n",
4417: nb_tests - old_tests,
4418: nb_errors - old_errors,
4419: nb_leaks - old_leaks);
4420: }
4421: return(ret);
4422: }
4423:
4424: int
4425: main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
4426: int i, a, ret = 0;
4427: int subset = 0;
4428:
4429: initializeLibxml2();
4430:
4431: for (a = 1; a < argc;a++) {
4432: if (!strcmp(argv[a], "-v"))
4433: verbose = 1;
4434: else if (!strcmp(argv[a], "-quiet"))
4435: tests_quiet = 1;
4436: else {
4437: for (i = 0; testDescriptions[i].func != NULL; i++) {
4438: if (strstr(testDescriptions[i].desc, argv[a])) {
4439: ret += runtest(i);
4440: subset++;
4441: }
4442: }
4443: }
4444: }
4445: if (subset == 0) {
4446: for (i = 0; testDescriptions[i].func != NULL; i++) {
4447: ret += runtest(i);
4448: }
4449: }
4450: if ((nb_errors == 0) && (nb_leaks == 0)) {
4451: ret = 0;
4452: printf("Total %d tests, no errors\n",
4453: nb_tests);
4454: } else {
4455: ret = 1;
4456: printf("Total %d tests, %d errors, %d leaks\n",
4457: nb_tests, nb_errors, nb_leaks);
4458: }
4459: xmlCleanupParser();
4460: xmlMemoryDump();
4461:
4462: return(ret);
4463: }
4464:
4465: #else /* ! LIBXML_OUTPUT_ENABLED */
4466: int
4467: main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
4468: fprintf(stderr, "runtest requires output to be enabled in libxml2\n");
4469: return(1);
4470: }
4471: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to runtest.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