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