runtest.c@ 65211

Last change on this file since 65211 was 58072, checked in by vboxsync, 9 years ago
libxml 2.9.2 unmodified
Property svn:eol-style set to `native`
File size: 112.6 KB

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

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/libxml2-2.9.2/runtest.c@ 65211

Download in other formats: