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