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