testlimits.c@ 98879

Last change on this file since 98879 was 95312, checked in by vboxsync, 2 years ago
libs/{curl,libxml2}: OSE export fixes, bugref:8515
Property svn:eol-style set to `native`
File size: 41.3 KB

Line
1	/*
2	* testlimits.c: C program to run libxml2 regression tests checking various
3	* limits in document size. Will consume a lot of RAM and CPU cycles
4	*
5	* To compile on Unixes:
6	* cc -o testlimits `xml2-config --cflags` testlimits.c `xml2-config --libs` -lpthread
7	*
8	* See Copyright for the status of this software.
9	*
10	* daniel@veillard.com
11	*/
12
13	#include "libxml.h"
14	#include <stdio.h>
15
16	#if !defined(_WIN32) \|\| defined(__CYGWIN__)
17	#include <unistd.h>
18	#endif
19	#include <string.h>
20	#include <sys/types.h>
21	#include <sys/stat.h>
22	#include <fcntl.h>
23	#include <time.h>
24
25	#include <libxml/parser.h>
26	#include <libxml/parserInternals.h>
27	#include <libxml/tree.h>
28	#include <libxml/uri.h>
29	#ifdef LIBXML_READER_ENABLED
30	#include <libxml/xmlreader.h>
31	#endif
32
33	static int verbose = 0;
34	static int tests_quiet = 0;
35
36	/************************************************************************
37	* *
38	* time handling *
39	* *
40	************************************************************************/
41
42	/* maximum time for one parsing before declaring a timeout */
43	#define MAX_TIME 2 /* seconds */
44
45	static clock_t t0;
46	int timeout = 0;
47
48	static void reset_timout(void) {
49	timeout = 0;
50	t0 = clock();
51	}
52
53	static int check_time(void) {
54	clock_t tnow = clock();
55	if (((tnow - t0) / CLOCKS_PER_SEC) > MAX_TIME) {
56	timeout = 1;
57	return(0);
58	}
59	return(1);
60	}
61
62	/************************************************************************
63	* *
64	* Huge document generator *
65	* *
66	************************************************************************/
67
68	#include <libxml/xmlIO.h>
69
70	/*
71	* Huge documents are built using fixed start and end chunks
72	* and filling between the two an unconventional amount of char data
73	*/
74	typedef struct hugeTest hugeTest;
75	typedef hugeTest *hugeTestPtr;
76	struct hugeTest {
77	const char *description;
78	const char *name;
79	const char *start;
80	const char *end;
81	};
82
83	static struct hugeTest hugeTests[] = {
84	{ "Huge text node", "huge:textNode", "<foo>", "</foo>" },
85	{ "Huge attribute node", "huge:attrNode", "<foo bar='", "'/>" },
86	{ "Huge comment node", "huge:commentNode", "<foo><!--", "--></foo>" },
87	{ "Huge PI node", "huge:piNode", "<foo><?bar ", "?></foo>" },
88	};
89
90	static const char *current;
91	static int rlen;
92	static unsigned int currentTest = 0;
93	static int instate = 0;
94
95	/**
96	* hugeMatch:
97	* @URI: an URI to test
98	*
99	* Check for an huge: query
100	*
101	* Returns 1 if yes and 0 if another Input module should be used
102	*/
103	static int
104	hugeMatch(const char * URI) {
105	if ((URI != NULL) && (!strncmp(URI, "huge:", 5)))
106	return(1);
107	return(0);
108	}
109
110	/**
111	* hugeOpen:
112	* @URI: an URI to test
113	*
114	* Return a pointer to the huge: query handler, in this example simply
115	* the current pointer...
116	*
117	* Returns an Input context or NULL in case or error
118	*/
119	static void *
120	hugeOpen(const char * URI) {
121	if ((URI == NULL) \|\| (strncmp(URI, "huge:", 5)))
122	return(NULL);
123
124	for (currentTest = 0;currentTest < sizeof(hugeTests)/sizeof(hugeTests[0]);
125	currentTest++)
126	if (!strcmp(hugeTests[currentTest].name, URI))
127	goto found;
128
129	return(NULL);
130
131	found:
132	rlen = strlen(hugeTests[currentTest].start);
133	current = hugeTests[currentTest].start;
134	instate = 0;
135	return((void *) current);
136	}
137
138	/**
139	* hugeClose:
140	* @context: the read context
141	*
142	* Close the huge: query handler
143	*
144	* Returns 0 or -1 in case of error
145	*/
146	static int
147	hugeClose(void * context) {
148	if (context == NULL) return(-1);
149	fprintf(stderr, "\n");
150	return(0);
151	}
152
153	#define CHUNK 4096
154
155	char filling[CHUNK + 1];
156
157	static void fillFilling(void) {
158	int i;
159
160	for (i = 0;i < CHUNK;i++) {
161	filling[i] = 'a';
162	}
163	filling[CHUNK] = 0;
164	}
165
166	size_t maxlen = 64 * 1024 * 1024;
167	size_t curlen = 0;
168	size_t dotlen;
169
170	/**
171	* hugeRead:
172	* @context: the read context
173	* @buffer: where to store data
174	* @len: number of bytes to read
175	*
176	* Implement an huge: query read.
177	*
178	* Returns the number of bytes read or -1 in case of error
179	*/
180	static int
181	hugeRead(void context, char buffer, int len)
182	{
183	if ((context == NULL) \|\| (buffer == NULL) \|\| (len < 0))
184	return (-1);
185
186	if (instate == 0) {
187	if (len >= rlen) {
188	len = rlen;
189	rlen = 0;
190	memcpy(buffer, current, len);
191	instate = 1;
192	curlen = 0;
193	dotlen = maxlen / 10;
194	} else {
195	memcpy(buffer, current, len);
196	rlen -= len;
197	current += len;
198	}
199	} else if (instate == 2) {
200	if (len >= rlen) {
201	len = rlen;
202	rlen = 0;
203	memcpy(buffer, current, len);
204	instate = 3;
205	curlen = 0;
206	} else {
207	memcpy(buffer, current, len);
208	rlen -= len;
209	current += len;
210	}
211	} else if (instate == 1) {
212	if (len > CHUNK) len = CHUNK;
213	memcpy(buffer, &filling[0], len);
214	curlen += len;
215	if (curlen >= maxlen) {
216	rlen = strlen(hugeTests[currentTest].end);
217	current = hugeTests[currentTest].end;
218	instate = 2;
219	} else {
220	if (curlen > dotlen) {
221	fprintf(stderr, ".");
222	dotlen += maxlen / 10;
223	}
224	}
225	} else
226	len = 0;
227	return (len);
228	}
229
230	/************************************************************************
231	* *
232	* Crazy document generator *
233	* *
234	************************************************************************/
235
236	unsigned int crazy_indx = 0;
237
238	const char *crazy = "<?xml version='1.0' encoding='UTF-8'?>\
239	<?tst ?>\
240	<!-- tst -->\
241	<!DOCTYPE foo [\
242	<?tst ?>\
243	<!-- tst -->\
244	<!ELEMENT foo (#PCDATA)>\
245	<!ELEMENT p (#PCDATA\|emph)* >\
246	]>\
247	<?tst ?>\
248	<!-- tst -->\
249	<foo bar='foo'>\
250	<?tst ?>\
251	<!-- tst -->\
252	foo\
253	<![CDATA[ ]]>\
254	</foo>\
255	<?tst ?>\
256	<!-- tst -->";
257
258	/**
259	* crazyMatch:
260	* @URI: an URI to test
261	*
262	* Check for a crazy: query
263	*
264	* Returns 1 if yes and 0 if another Input module should be used
265	*/
266	static int
267	crazyMatch(const char * URI) {
268	if ((URI != NULL) && (!strncmp(URI, "crazy:", 6)))
269	return(1);
270	return(0);
271	}
272
273	/**
274	* crazyOpen:
275	* @URI: an URI to test
276	*
277	* Return a pointer to the crazy: query handler, in this example simply
278	* the current pointer...
279	*
280	* Returns an Input context or NULL in case or error
281	*/
282	static void *
283	crazyOpen(const char * URI) {
284	if ((URI == NULL) \|\| (strncmp(URI, "crazy:", 6)))
285	return(NULL);
286
287	if (crazy_indx > strlen(crazy))
288	return(NULL);
289	reset_timout();
290	rlen = crazy_indx;
291	current = &crazy[0];
292	instate = 0;
293	return((void *) current);
294	}
295
296	/**
297	* crazyClose:
298	* @context: the read context
299	*
300	* Close the crazy: query handler
301	*
302	* Returns 0 or -1 in case of error
303	*/
304	static int
305	crazyClose(void * context) {
306	if (context == NULL) return(-1);
307	return(0);
308	}
309
310
311	/**
312	* crazyRead:
313	* @context: the read context
314	* @buffer: where to store data
315	* @len: number of bytes to read
316	*
317	* Implement an crazy: query read.
318	*
319	* Returns the number of bytes read or -1 in case of error
320	*/
321	static int
322	crazyRead(void context, char buffer, int len)
323	{
324	if ((context == NULL) \|\| (buffer == NULL) \|\| (len < 0))
325	return (-1);
326
327	if ((check_time() <= 0) && (instate == 1)) {
328	fprintf(stderr, "\ntimeout in crazy(%d)\n", crazy_indx);
329	rlen = strlen(crazy) - crazy_indx;
330	current = &crazy[crazy_indx];
331	instate = 2;
332	}
333	if (instate == 0) {
334	if (len >= rlen) {
335	len = rlen;
336	rlen = 0;
337	memcpy(buffer, current, len);
338	instate = 1;
339	curlen = 0;
340	} else {
341	memcpy(buffer, current, len);
342	rlen -= len;
343	current += len;
344	}
345	} else if (instate == 2) {
346	if (len >= rlen) {
347	len = rlen;
348	rlen = 0;
349	memcpy(buffer, current, len);
350	instate = 3;
351	curlen = 0;
352	} else {
353	memcpy(buffer, current, len);
354	rlen -= len;
355	current += len;
356	}
357	} else if (instate == 1) {
358	if (len > CHUNK) len = CHUNK;
359	memcpy(buffer, &filling[0], len);
360	curlen += len;
361	if (curlen >= maxlen) {
362	rlen = strlen(crazy) - crazy_indx;
363	current = &crazy[crazy_indx];
364	instate = 2;
365	}
366	} else
367	len = 0;
368	return (len);
369	}
370	/************************************************************************
371	* *
372	* Libxml2 specific routines *
373	* *
374	************************************************************************/
375
376	static int nb_tests = 0;
377	static int nb_errors = 0;
378	static int nb_leaks = 0;
379	static int extraMemoryFromResolver = 0;
380
381	/*
382	* We need to trap calls to the resolver to not account memory for the catalog
383	* which is shared to the current running test. We also don't want to have
384	* network downloads modifying tests.
385	*/
386	static xmlParserInputPtr
387	testExternalEntityLoader(const char URL, const char ID,
388	xmlParserCtxtPtr ctxt) {
389	xmlParserInputPtr ret;
390	int memused = xmlMemUsed();
391
392	ret = xmlNoNetExternalEntityLoader(URL, ID, ctxt);
393	extraMemoryFromResolver += xmlMemUsed() - memused;
394
395	return(ret);
396	}
397
398	/*
399	* Trapping the error messages at the generic level to grab the equivalent of
400	* stderr messages on CLI tools.
401	*/
402	static char testErrors[32769];
403	static int testErrorsSize = 0;
404
405	static void XMLCDECL
406	channel(void ctx ATTRIBUTE_UNUSED, const char msg, ...) {
407	va_list args;
408	int res;
409
410	if (testErrorsSize >= 32768)
411	return;
412	va_start(args, msg);
413	res = vsnprintf(&testErrors[testErrorsSize],
414	32768 - testErrorsSize,
415	msg, args);
416	va_end(args);
417	if (testErrorsSize + res >= 32768) {
418	/* buffer is full */
419	testErrorsSize = 32768;
420	testErrors[testErrorsSize] = 0;
421	} else {
422	testErrorsSize += res;
423	}
424	testErrors[testErrorsSize] = 0;
425	}
426
427	/**
428	* xmlParserPrintFileContext:
429	* @input: an xmlParserInputPtr input
430	*
431	* Displays current context within the input content for error tracking
432	*/
433
434	static void
435	xmlParserPrintFileContextInternal(xmlParserInputPtr input ,
436	xmlGenericErrorFunc chanl, void *data ) {
437	const xmlChar cur, base;
438	unsigned int n, col; /* GCC warns if signed, because compared with sizeof() */
439	xmlChar content[81]; /* space for 80 chars + line terminator */
440	xmlChar *ctnt;
441
442	if (input == NULL) return;
443	cur = input->cur;
444	base = input->base;
445	/* skip backwards over any end-of-lines */
446	while ((cur > base) && (((cur) == '\n') \|\| ((cur) == '\r'))) {
447	cur--;
448	}
449	n = 0;
450	/* search backwards for beginning-of-line (to max buff size) */
451	while ((n++ < (sizeof(content)-1)) && (cur > base) &&
452	((cur) != '\n') && ((cur) != '\r'))
453	cur--;
454	if (((cur) == '\n') \|\| ((cur) == '\r')) cur++;
455	/* calculate the error position in terms of the current position */
456	col = input->cur - cur;
457	/* search forward for end-of-line (to max buff size) */
458	n = 0;
459	ctnt = content;
460	/* copy selected text to our buffer */
461	while ((cur != 0) && ((cur) != '\n') &&
462	(*(cur) != '\r') && (n < sizeof(content)-1)) {
463	ctnt++ = cur++;
464	n++;
465	}
466	*ctnt = 0;
467	/* print out the selected text */
468	chanl(data ,"%s\n", content);
469	/* create blank line with problem pointer */
470	n = 0;
471	ctnt = content;
472	/* (leave buffer space for pointer + line terminator) */
473	while ((n<col) && (n++ < sizeof(content)-2) && (*ctnt != 0)) {
474	if (*(ctnt) != '\t')
475	*(ctnt) = ' ';
476	ctnt++;
477	}
478	*ctnt++ = '^';
479	*ctnt = 0;
480	chanl(data ,"%s\n", content);
481	}
482
483	static void
484	testStructuredErrorHandler(void *ctx ATTRIBUTE_UNUSED, xmlErrorPtr err) {
485	char *file = NULL;
486	int line = 0;
487	int code = -1;
488	int domain;
489	void *data = NULL;
490	const char *str;
491	const xmlChar *name = NULL;
492	xmlNodePtr node;
493	xmlErrorLevel level;
494	xmlParserInputPtr input = NULL;
495	xmlParserInputPtr cur = NULL;
496	xmlParserCtxtPtr ctxt = NULL;
497
498	if (err == NULL)
499	return;
500
501	file = err->file;
502	line = err->line;
503	code = err->code;
504	domain = err->domain;
505	level = err->level;
506	node = err->node;
507	if ((domain == XML_FROM_PARSER) \|\| (domain == XML_FROM_HTML) \|\|
508	(domain == XML_FROM_DTD) \|\| (domain == XML_FROM_NAMESPACE) \|\|
509	(domain == XML_FROM_IO) \|\| (domain == XML_FROM_VALID)) {
510	ctxt = err->ctxt;
511	}
512	str = err->message;
513
514	if (code == XML_ERR_OK)
515	return;
516
517	if ((node != NULL) && (node->type == XML_ELEMENT_NODE))
518	name = node->name;
519
520	/*
521	* Maintain the compatibility with the legacy error handling
522	*/
523	if (ctxt != NULL) {
524	input = ctxt->input;
525	if ((input != NULL) && (input->filename == NULL) &&
526	(ctxt->inputNr > 1)) {
527	cur = input;
528	input = ctxt->inputTab[ctxt->inputNr - 2];
529	}
530	if (input != NULL) {
531	if (input->filename)
532	channel(data, "%s:%d: ", input->filename, input->line);
533	else if ((line != 0) && (domain == XML_FROM_PARSER))
534	channel(data, "Entity: line %d: ", input->line);
535	}
536	} else {
537	if (file != NULL)
538	channel(data, "%s:%d: ", file, line);
539	else if ((line != 0) && (domain == XML_FROM_PARSER))
540	channel(data, "Entity: line %d: ", line);
541	}
542	if (name != NULL) {
543	channel(data, "element %s: ", name);
544	}
545	if (code == XML_ERR_OK)
546	return;
547	switch (domain) {
548	case XML_FROM_PARSER:
549	channel(data, "parser ");
550	break;
551	case XML_FROM_NAMESPACE:
552	channel(data, "namespace ");
553	break;
554	case XML_FROM_DTD:
555	case XML_FROM_VALID:
556	channel(data, "validity ");
557	break;
558	case XML_FROM_HTML:
559	channel(data, "HTML parser ");
560	break;
561	case XML_FROM_MEMORY:
562	channel(data, "memory ");
563	break;
564	case XML_FROM_OUTPUT:
565	channel(data, "output ");
566	break;
567	case XML_FROM_IO:
568	channel(data, "I/O ");
569	break;
570	case XML_FROM_XINCLUDE:
571	channel(data, "XInclude ");
572	break;
573	case XML_FROM_XPATH:
574	channel(data, "XPath ");
575	break;
576	case XML_FROM_XPOINTER:
577	channel(data, "parser ");
578	break;
579	case XML_FROM_REGEXP:
580	channel(data, "regexp ");
581	break;
582	case XML_FROM_MODULE:
583	channel(data, "module ");
584	break;
585	case XML_FROM_SCHEMASV:
586	channel(data, "Schemas validity ");
587	break;
588	case XML_FROM_SCHEMASP:
589	channel(data, "Schemas parser ");
590	break;
591	case XML_FROM_RELAXNGP:
592	channel(data, "Relax-NG parser ");
593	break;
594	case XML_FROM_RELAXNGV:
595	channel(data, "Relax-NG validity ");
596	break;
597	case XML_FROM_CATALOG:
598	channel(data, "Catalog ");
599	break;
600	case XML_FROM_C14N:
601	channel(data, "C14N ");
602	break;
603	case XML_FROM_XSLT:
604	channel(data, "XSLT ");
605	break;
606	default:
607	break;
608	}
609	if (code == XML_ERR_OK)
610	return;
611	switch (level) {
612	case XML_ERR_NONE:
613	channel(data, ": ");
614	break;
615	case XML_ERR_WARNING:
616	channel(data, "warning : ");
617	break;
618	case XML_ERR_ERROR:
619	channel(data, "error : ");
620	break;
621	case XML_ERR_FATAL:
622	channel(data, "error : ");
623	break;
624	}
625	if (code == XML_ERR_OK)
626	return;
627	if (str != NULL) {
628	int len;
629	len = xmlStrlen((const xmlChar *)str);
630	if ((len > 0) && (str[len - 1] != '\n'))
631	channel(data, "%s\n", str);
632	else
633	channel(data, "%s", str);
634	} else {
635	channel(data, "%s\n", "out of memory error");
636	}
637	if (code == XML_ERR_OK)
638	return;
639
640	if (ctxt != NULL) {
641	xmlParserPrintFileContextInternal(input, channel, data);
642	if (cur != NULL) {
643	if (cur->filename)
644	channel(data, "%s:%d: \n", cur->filename, cur->line);
645	else if ((line != 0) && (domain == XML_FROM_PARSER))
646	channel(data, "Entity: line %d: \n", cur->line);
647	xmlParserPrintFileContextInternal(cur, channel, data);
648	}
649	}
650	if ((domain == XML_FROM_XPATH) && (err->str1 != NULL) &&
651	(err->int1 < 100) &&
652	(err->int1 < xmlStrlen((const xmlChar *)err->str1))) {
653	xmlChar buf[150];
654	int i;
655
656	channel(data, "%s\n", err->str1);
657	for (i=0;i < err->int1;i++)
658	buf[i] = ' ';
659	buf[i++] = '^';
660	buf[i] = 0;
661	channel(data, "%s\n", buf);
662	}
663	}
664
665	static void
666	initializeLibxml2(void) {
667	xmlGetWarningsDefaultValue = 0;
668	xmlPedanticParserDefault(0);
669
670	xmlMemSetup(xmlMemFree, xmlMemMalloc, xmlMemRealloc, xmlMemoryStrdup);
671	xmlInitParser();
672	xmlSetExternalEntityLoader(testExternalEntityLoader);
673	xmlSetStructuredErrorFunc(NULL, testStructuredErrorHandler);
674	/*
675	* register the new I/O handlers
676	*/
677	if (xmlRegisterInputCallbacks(hugeMatch, hugeOpen,
678	hugeRead, hugeClose) < 0) {
679	fprintf(stderr, "failed to register Huge handlers\n");
680	exit(1);
681	}
682	if (xmlRegisterInputCallbacks(crazyMatch, crazyOpen,
683	crazyRead, crazyClose) < 0) {
684	fprintf(stderr, "failed to register Crazy handlers\n");
685	exit(1);
686	}
687	}
688
689	/************************************************************************
690	* *
691	* SAX empty callbacks *
692	* *
693	************************************************************************/
694
695	unsigned long callbacks = 0;
696
697	/**
698	* isStandaloneCallback:
699	* @ctxt: An XML parser context
700	*
701	* Is this document tagged standalone ?
702	*
703	* Returns 1 if true
704	*/
705	static int
706	isStandaloneCallback(void *ctx ATTRIBUTE_UNUSED)
707	{
708	callbacks++;
709	return (0);
710	}
711
712	/**
713	* hasInternalSubsetCallback:
714	* @ctxt: An XML parser context
715	*
716	* Does this document has an internal subset
717	*
718	* Returns 1 if true
719	*/
720	static int
721	hasInternalSubsetCallback(void *ctx ATTRIBUTE_UNUSED)
722	{
723	callbacks++;
724	return (0);
725	}
726
727	/**
728	* hasExternalSubsetCallback:
729	* @ctxt: An XML parser context
730	*
731	* Does this document has an external subset
732	*
733	* Returns 1 if true
734	*/
735	static int
736	hasExternalSubsetCallback(void *ctx ATTRIBUTE_UNUSED)
737	{
738	callbacks++;
739	return (0);
740	}
741
742	/**
743	* internalSubsetCallback:
744	* @ctxt: An XML parser context
745	*
746	* Does this document has an internal subset
747	*/
748	static void
749	internalSubsetCallback(void *ctx ATTRIBUTE_UNUSED,
750	const xmlChar * name ATTRIBUTE_UNUSED,
751	const xmlChar * ExternalID ATTRIBUTE_UNUSED,
752	const xmlChar * SystemID ATTRIBUTE_UNUSED)
753	{
754	callbacks++;
755	return;
756	}
757
758	/**
759	* externalSubsetCallback:
760	* @ctxt: An XML parser context
761	*
762	* Does this document has an external subset
763	*/
764	static void
765	externalSubsetCallback(void *ctx ATTRIBUTE_UNUSED,
766	const xmlChar * name ATTRIBUTE_UNUSED,
767	const xmlChar * ExternalID ATTRIBUTE_UNUSED,
768	const xmlChar * SystemID ATTRIBUTE_UNUSED)
769	{
770	callbacks++;
771	return;
772	}
773
774	/**
775	* resolveEntityCallback:
776	* @ctxt: An XML parser context
777	* @publicId: The public ID of the entity
778	* @systemId: The system ID of the entity
779	*
780	* Special entity resolver, better left to the parser, it has
781	* more context than the application layer.
782	* The default behaviour is to NOT resolve the entities, in that case
783	* the ENTITY_REF nodes are built in the structure (and the parameter
784	* values).
785	*
786	* Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
787	*/
788	static xmlParserInputPtr
789	resolveEntityCallback(void *ctx ATTRIBUTE_UNUSED,
790	const xmlChar * publicId ATTRIBUTE_UNUSED,
791	const xmlChar * systemId ATTRIBUTE_UNUSED)
792	{
793	callbacks++;
794	return (NULL);
795	}
796
797	/**
798	* getEntityCallback:
799	* @ctxt: An XML parser context
800	* @name: The entity name
801	*
802	* Get an entity by name
803	*
804	* Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
805	*/
806	static xmlEntityPtr
807	getEntityCallback(void *ctx ATTRIBUTE_UNUSED,
808	const xmlChar * name ATTRIBUTE_UNUSED)
809	{
810	callbacks++;
811	return (NULL);
812	}
813
814	/**
815	* getParameterEntityCallback:
816	* @ctxt: An XML parser context
817	* @name: The entity name
818	*
819	* Get a parameter entity by name
820	*
821	* Returns the xmlParserInputPtr
822	*/
823	static xmlEntityPtr
824	getParameterEntityCallback(void *ctx ATTRIBUTE_UNUSED,
825	const xmlChar * name ATTRIBUTE_UNUSED)
826	{
827	callbacks++;
828	return (NULL);
829	}
830
831
832	/**
833	* entityDeclCallback:
834	* @ctxt: An XML parser context
835	* @name: the entity name
836	* @type: the entity type
837	* @publicId: The public ID of the entity
838	* @systemId: The system ID of the entity
839	* @content: the entity value (without processing).
840	*
841	* An entity definition has been parsed
842	*/
843	static void
844	entityDeclCallback(void *ctx ATTRIBUTE_UNUSED,
845	const xmlChar * name ATTRIBUTE_UNUSED,
846	int type ATTRIBUTE_UNUSED,
847	const xmlChar * publicId ATTRIBUTE_UNUSED,
848	const xmlChar * systemId ATTRIBUTE_UNUSED,
849	xmlChar * content ATTRIBUTE_UNUSED)
850	{
851	callbacks++;
852	return;
853	}
854
855	/**
856	* attributeDeclCallback:
857	* @ctxt: An XML parser context
858	* @name: the attribute name
859	* @type: the attribute type
860	*
861	* An attribute definition has been parsed
862	*/
863	static void
864	attributeDeclCallback(void *ctx ATTRIBUTE_UNUSED,
865	const xmlChar * elem ATTRIBUTE_UNUSED,
866	const xmlChar * name ATTRIBUTE_UNUSED,
867	int type ATTRIBUTE_UNUSED, int def ATTRIBUTE_UNUSED,
868	const xmlChar * defaultValue ATTRIBUTE_UNUSED,
869	xmlEnumerationPtr tree ATTRIBUTE_UNUSED)
870	{
871	callbacks++;
872	return;
873	}
874
875	/**
876	* elementDeclCallback:
877	* @ctxt: An XML parser context
878	* @name: the element name
879	* @type: the element type
880	* @content: the element value (without processing).
881	*
882	* An element definition has been parsed
883	*/
884	static void
885	elementDeclCallback(void *ctx ATTRIBUTE_UNUSED,
886	const xmlChar * name ATTRIBUTE_UNUSED,
887	int type ATTRIBUTE_UNUSED,
888	xmlElementContentPtr content ATTRIBUTE_UNUSED)
889	{
890	callbacks++;
891	return;
892	}
893
894	/**
895	* notationDeclCallback:
896	* @ctxt: An XML parser context
897	* @name: The name of the notation
898	* @publicId: The public ID of the entity
899	* @systemId: The system ID of the entity
900	*
901	* What to do when a notation declaration has been parsed.
902	*/
903	static void
904	notationDeclCallback(void *ctx ATTRIBUTE_UNUSED,
905	const xmlChar * name ATTRIBUTE_UNUSED,
906	const xmlChar * publicId ATTRIBUTE_UNUSED,
907	const xmlChar * systemId ATTRIBUTE_UNUSED)
908	{
909	callbacks++;
910	return;
911	}
912
913	/**
914	* unparsedEntityDeclCallback:
915	* @ctxt: An XML parser context
916	* @name: The name of the entity
917	* @publicId: The public ID of the entity
918	* @systemId: The system ID of the entity
919	* @notationName: the name of the notation
920	*
921	* What to do when an unparsed entity declaration is parsed
922	*/
923	static void
924	unparsedEntityDeclCallback(void *ctx ATTRIBUTE_UNUSED,
925	const xmlChar * name ATTRIBUTE_UNUSED,
926	const xmlChar * publicId ATTRIBUTE_UNUSED,
927	const xmlChar * systemId ATTRIBUTE_UNUSED,
928	const xmlChar * notationName ATTRIBUTE_UNUSED)
929	{
930	callbacks++;
931	return;
932	}
933
934	/**
935	* setDocumentLocatorCallback:
936	* @ctxt: An XML parser context
937	* @loc: A SAX Locator
938	*
939	* Receive the document locator at startup, actually xmlDefaultSAXLocator
940	* Everything is available on the context, so this is useless in our case.
941	*/
942	static void
943	setDocumentLocatorCallback(void *ctx ATTRIBUTE_UNUSED,
944	xmlSAXLocatorPtr loc ATTRIBUTE_UNUSED)
945	{
946	callbacks++;
947	return;
948	}
949
950	/**
951	* startDocumentCallback:
952	* @ctxt: An XML parser context
953	*
954	* called when the document start being processed.
955	*/
956	static void
957	startDocumentCallback(void *ctx ATTRIBUTE_UNUSED)
958	{
959	callbacks++;
960	return;
961	}
962
963	/**
964	* endDocumentCallback:
965	* @ctxt: An XML parser context
966	*
967	* called when the document end has been detected.
968	*/
969	static void
970	endDocumentCallback(void *ctx ATTRIBUTE_UNUSED)
971	{
972	callbacks++;
973	return;
974	}
975
976	#if 0
977	/**
978	* startElementCallback:
979	* @ctxt: An XML parser context
980	* @name: The element name
981	*
982	* called when an opening tag has been processed.
983	*/
984	static void
985	startElementCallback(void *ctx ATTRIBUTE_UNUSED,
986	const xmlChar * name ATTRIBUTE_UNUSED,
987	const xmlChar ** atts ATTRIBUTE_UNUSED)
988	{
989	callbacks++;
990	return;
991	}
992
993	/**
994	* endElementCallback:
995	* @ctxt: An XML parser context
996	* @name: The element name
997	*
998	* called when the end of an element has been detected.
999	*/
1000	static void
1001	endElementCallback(void *ctx ATTRIBUTE_UNUSED,
1002	const xmlChar * name ATTRIBUTE_UNUSED)
1003	{
1004	callbacks++;
1005	return;
1006	}
1007	#endif
1008
1009	/**
1010	* charactersCallback:
1011	* @ctxt: An XML parser context
1012	* @ch: a xmlChar string
1013	* @len: the number of xmlChar
1014	*
1015	* receiving some chars from the parser.
1016	* Question: how much at a time ???
1017	*/
1018	static void
1019	charactersCallback(void *ctx ATTRIBUTE_UNUSED,
1020	const xmlChar * ch ATTRIBUTE_UNUSED,
1021	int len ATTRIBUTE_UNUSED)
1022	{
1023	callbacks++;
1024	return;
1025	}
1026
1027	/**
1028	* referenceCallback:
1029	* @ctxt: An XML parser context
1030	* @name: The entity name
1031	*
1032	* called when an entity reference is detected.
1033	*/
1034	static void
1035	referenceCallback(void *ctx ATTRIBUTE_UNUSED,
1036	const xmlChar * name ATTRIBUTE_UNUSED)
1037	{
1038	callbacks++;
1039	return;
1040	}
1041
1042	/**
1043	* ignorableWhitespaceCallback:
1044	* @ctxt: An XML parser context
1045	* @ch: a xmlChar string
1046	* @start: the first char in the string
1047	* @len: the number of xmlChar
1048	*
1049	* receiving some ignorable whitespaces from the parser.
1050	* Question: how much at a time ???
1051	*/
1052	static void
1053	ignorableWhitespaceCallback(void *ctx ATTRIBUTE_UNUSED,
1054	const xmlChar * ch ATTRIBUTE_UNUSED,
1055	int len ATTRIBUTE_UNUSED)
1056	{
1057	callbacks++;
1058	return;
1059	}
1060
1061	/**
1062	* processingInstructionCallback:
1063	* @ctxt: An XML parser context
1064	* @target: the target name
1065	* @data: the PI data's
1066	* @len: the number of xmlChar
1067	*
1068	* A processing instruction has been parsed.
1069	*/
1070	static void
1071	processingInstructionCallback(void *ctx ATTRIBUTE_UNUSED,
1072	const xmlChar * target ATTRIBUTE_UNUSED,
1073	const xmlChar * data ATTRIBUTE_UNUSED)
1074	{
1075	callbacks++;
1076	return;
1077	}
1078
1079	/**
1080	* cdataBlockCallback:
1081	* @ctx: the user data (XML parser context)
1082	* @value: The pcdata content
1083	* @len: the block length
1084	*
1085	* called when a pcdata block has been parsed
1086	*/
1087	static void
1088	cdataBlockCallback(void *ctx ATTRIBUTE_UNUSED,
1089	const xmlChar * value ATTRIBUTE_UNUSED,
1090	int len ATTRIBUTE_UNUSED)
1091	{
1092	callbacks++;
1093	return;
1094	}
1095
1096	/**
1097	* commentCallback:
1098	* @ctxt: An XML parser context
1099	* @value: the comment content
1100	*
1101	* A comment has been parsed.
1102	*/
1103	static void
1104	commentCallback(void *ctx ATTRIBUTE_UNUSED,
1105	const xmlChar * value ATTRIBUTE_UNUSED)
1106	{
1107	callbacks++;
1108	return;
1109	}
1110
1111	/**
1112	* warningCallback:
1113	* @ctxt: An XML parser context
1114	* @msg: the message to display/transmit
1115	* @...: extra parameters for the message display
1116	*
1117	* Display and format a warning messages, gives file, line, position and
1118	* extra parameters.
1119	*/
1120	static void XMLCDECL
1121	warningCallback(void *ctx ATTRIBUTE_UNUSED,
1122	const char *msg ATTRIBUTE_UNUSED, ...)
1123	{
1124	callbacks++;
1125	return;
1126	}
1127
1128	/**
1129	* errorCallback:
1130	* @ctxt: An XML parser context
1131	* @msg: the message to display/transmit
1132	* @...: extra parameters for the message display
1133	*
1134	* Display and format a error messages, gives file, line, position and
1135	* extra parameters.
1136	*/
1137	static void XMLCDECL
1138	errorCallback(void ctx ATTRIBUTE_UNUSED, const char msg ATTRIBUTE_UNUSED,
1139	...)
1140	{
1141	callbacks++;
1142	return;
1143	}
1144
1145	/**
1146	* fatalErrorCallback:
1147	* @ctxt: An XML parser context
1148	* @msg: the message to display/transmit
1149	* @...: extra parameters for the message display
1150	*
1151	* Display and format a fatalError messages, gives file, line, position and
1152	* extra parameters.
1153	*/
1154	static void XMLCDECL
1155	fatalErrorCallback(void *ctx ATTRIBUTE_UNUSED,
1156	const char *msg ATTRIBUTE_UNUSED, ...)
1157	{
1158	return;
1159	}
1160
1161
1162	/*
1163	* SAX2 specific callbacks
1164	*/
1165
1166	/**
1167	* startElementNsCallback:
1168	* @ctxt: An XML parser context
1169	* @name: The element name
1170	*
1171	* called when an opening tag has been processed.
1172	*/
1173	static void
1174	startElementNsCallback(void *ctx ATTRIBUTE_UNUSED,
1175	const xmlChar * localname ATTRIBUTE_UNUSED,
1176	const xmlChar * prefix ATTRIBUTE_UNUSED,
1177	const xmlChar * URI ATTRIBUTE_UNUSED,
1178	int nb_namespaces ATTRIBUTE_UNUSED,
1179	const xmlChar ** namespaces ATTRIBUTE_UNUSED,
1180	int nb_attributes ATTRIBUTE_UNUSED,
1181	int nb_defaulted ATTRIBUTE_UNUSED,
1182	const xmlChar ** attributes ATTRIBUTE_UNUSED)
1183	{
1184	callbacks++;
1185	return;
1186	}
1187
1188	/**
1189	* endElementCallback:
1190	* @ctxt: An XML parser context
1191	* @name: The element name
1192	*
1193	* called when the end of an element has been detected.
1194	*/
1195	static void
1196	endElementNsCallback(void *ctx ATTRIBUTE_UNUSED,
1197	const xmlChar * localname ATTRIBUTE_UNUSED,
1198	const xmlChar * prefix ATTRIBUTE_UNUSED,
1199	const xmlChar * URI ATTRIBUTE_UNUSED)
1200	{
1201	callbacks++;
1202	return;
1203	}
1204
1205	static xmlSAXHandler callbackSAX2HandlerStruct = {
1206	internalSubsetCallback,
1207	isStandaloneCallback,
1208	hasInternalSubsetCallback,
1209	hasExternalSubsetCallback,
1210	resolveEntityCallback,
1211	getEntityCallback,
1212	entityDeclCallback,
1213	notationDeclCallback,
1214	attributeDeclCallback,
1215	elementDeclCallback,
1216	unparsedEntityDeclCallback,
1217	setDocumentLocatorCallback,
1218	startDocumentCallback,
1219	endDocumentCallback,
1220	NULL,
1221	NULL,
1222	referenceCallback,
1223	charactersCallback,
1224	ignorableWhitespaceCallback,
1225	processingInstructionCallback,
1226	commentCallback,
1227	warningCallback,
1228	errorCallback,
1229	fatalErrorCallback,
1230	getParameterEntityCallback,
1231	cdataBlockCallback,
1232	externalSubsetCallback,
1233	XML_SAX2_MAGIC,
1234	NULL,
1235	startElementNsCallback,
1236	endElementNsCallback,
1237	NULL
1238	};
1239
1240	static xmlSAXHandlerPtr callbackSAX2Handler = &callbackSAX2HandlerStruct;
1241
1242	/************************************************************************
1243	* *
1244	* The tests front-ends *
1245	* *
1246	************************************************************************/
1247
1248	/**
1249	* readerTest:
1250	* @filename: the file to parse
1251	* @max_size: size of the limit to test
1252	* @options: parsing options
1253	* @fail: should a failure be reported
1254	*
1255	* Parse a memory generated file using SAX
1256	*
1257	* Returns 0 in case of success, an error code otherwise
1258	*/
1259	static int
1260	saxTest(const char *filename, size_t limit, int options, int fail) {
1261	int res = 0;
1262	xmlParserCtxtPtr ctxt;
1263	xmlDocPtr doc;
1264	xmlSAXHandlerPtr old_sax;
1265
1266	nb_tests++;
1267
1268	maxlen = limit;
1269	ctxt = xmlNewParserCtxt();
1270	if (ctxt == NULL) {
1271	fprintf(stderr, "Failed to create parser context\n");
1272	return(1);
1273	}
1274	old_sax = ctxt->sax;
1275	ctxt->sax = callbackSAX2Handler;
1276	ctxt->userData = NULL;
1277	doc = xmlCtxtReadFile(ctxt, filename, NULL, options);
1278
1279	if (doc != NULL) {
1280	fprintf(stderr, "SAX parsing generated a document !\n");
1281	xmlFreeDoc(doc);
1282	res = 0;
1283	} else if (ctxt->wellFormed == 0) {
1284	if (fail)
1285	res = 0;
1286	else {
1287	fprintf(stderr, "Failed to parse '%s' %lu\n", filename,
1288	(unsigned long) limit);
1289	res = 1;
1290	}
1291	} else {
1292	if (fail) {
1293	fprintf(stderr, "Failed to get failure for '%s' %lu\n",
1294	filename, (unsigned long) limit);
1295	res = 1;
1296	} else
1297	res = 0;
1298	}
1299	ctxt->sax = old_sax;
1300	xmlFreeParserCtxt(ctxt);
1301
1302	return(res);
1303	}
1304	#ifdef LIBXML_READER_ENABLED
1305	/**
1306	* readerTest:
1307	* @filename: the file to parse
1308	* @max_size: size of the limit to test
1309	* @options: parsing options
1310	* @fail: should a failure be reported
1311	*
1312	* Parse a memory generated file using the xmlReader
1313	*
1314	* Returns 0 in case of success, an error code otherwise
1315	*/
1316	static int
1317	readerTest(const char *filename, size_t limit, int options, int fail) {
1318	xmlTextReaderPtr reader;
1319	int res = 0;
1320	int ret;
1321
1322	nb_tests++;
1323
1324	maxlen = limit;
1325	reader = xmlReaderForFile(filename , NULL, options);
1326	if (reader == NULL) {
1327	fprintf(stderr, "Failed to open '%s' test\n", filename);
1328	return(1);
1329	}
1330	ret = xmlTextReaderRead(reader);
1331	while (ret == 1) {
1332	ret = xmlTextReaderRead(reader);
1333	}
1334	if (ret != 0) {
1335	if (fail)
1336	res = 0;
1337	else {
1338	if (strncmp(filename, "crazy:", 6) == 0)
1339	fprintf(stderr, "Failed to parse '%s' %u\n",
1340	filename, crazy_indx);
1341	else
1342	fprintf(stderr, "Failed to parse '%s' %lu\n",
1343	filename, (unsigned long) limit);
1344	res = 1;
1345	}
1346	} else {
1347	if (fail) {
1348	if (strncmp(filename, "crazy:", 6) == 0)
1349	fprintf(stderr, "Failed to get failure for '%s' %u\n",
1350	filename, crazy_indx);
1351	else
1352	fprintf(stderr, "Failed to get failure for '%s' %lu\n",
1353	filename, (unsigned long) limit);
1354	res = 1;
1355	} else
1356	res = 0;
1357	}
1358	if (timeout)
1359	res = 1;
1360	xmlFreeTextReader(reader);
1361
1362	return(res);
1363	}
1364	#endif
1365
1366	/************************************************************************
1367	* *
1368	* Tests descriptions *
1369	* *
1370	************************************************************************/
1371
1372	typedef int (functest) (const char filename, size_t limit, int options,
1373	int fail);
1374
1375	typedef struct limitDesc limitDesc;
1376	typedef limitDesc *limitDescPtr;
1377	struct limitDesc {
1378	const char name; / the huge generator name */
1379	size_t limit; /* the limit to test */
1380	int options; /* extra parser options */
1381	int fail; /* whether the test should fail */
1382	};
1383
1384	static limitDesc limitDescriptions[] = {
1385	/* max length of a text node in content */
1386	{"huge:textNode", XML_MAX_TEXT_LENGTH - CHUNK, 0, 0},
1387	{"huge:textNode", XML_MAX_TEXT_LENGTH + CHUNK, 0, 1},
1388	{"huge:textNode", XML_MAX_TEXT_LENGTH + CHUNK, XML_PARSE_HUGE, 0},
1389	/* max length of a text node in content */
1390	{"huge:attrNode", XML_MAX_TEXT_LENGTH - CHUNK, 0, 0},
1391	{"huge:attrNode", XML_MAX_TEXT_LENGTH + CHUNK, 0, 1},
1392	{"huge:attrNode", XML_MAX_TEXT_LENGTH + CHUNK, XML_PARSE_HUGE, 0},
1393	/* max length of a comment node */
1394	{"huge:commentNode", XML_MAX_TEXT_LENGTH - CHUNK, 0, 0},
1395	{"huge:commentNode", XML_MAX_TEXT_LENGTH + CHUNK, 0, 1},
1396	{"huge:commentNode", XML_MAX_TEXT_LENGTH + CHUNK, XML_PARSE_HUGE, 0},
1397	/* max length of a PI node */
1398	{"huge:piNode", XML_MAX_TEXT_LENGTH - CHUNK, 0, 0},
1399	{"huge:piNode", XML_MAX_TEXT_LENGTH + CHUNK, 0, 1},
1400	{"huge:piNode", XML_MAX_TEXT_LENGTH + CHUNK, XML_PARSE_HUGE, 0},
1401	};
1402
1403	typedef struct testDesc testDesc;
1404	typedef testDesc *testDescPtr;
1405	struct testDesc {
1406	const char desc; / description of the test */
1407	functest func; /* function implementing the test */
1408	};
1409
1410	static
1411	testDesc testDescriptions[] = {
1412	{ "Parsing of huge files with the sax parser", saxTest},
1413	/* { "Parsing of huge files with the tree parser", treeTest}, */
1414	#ifdef LIBXML_READER_ENABLED
1415	{ "Parsing of huge files with the reader", readerTest},
1416	#endif
1417	{NULL, NULL}
1418	};
1419
1420	typedef struct testException testException;
1421	typedef testException *testExceptionPtr;
1422	struct testException {
1423	unsigned int test; /* the parser test number */
1424	unsigned int limit; /* the limit test number */
1425	int fail; /* new fail value or -1*/
1426	size_t size; /* new limit value or 0 */
1427	};
1428
1429	static
1430	testException testExceptions[] = {
1431	/* the SAX parser doesn't hit a limit of XML_MAX_TEXT_LENGTH text nodes */
1432	{ 0, 1, 0, 0},
1433	};
1434
1435	static int
1436	launchTests(testDescPtr tst, unsigned int test) {
1437	int res = 0, err = 0;
1438	unsigned int i, j;
1439	size_t limit;
1440	int fail;
1441
1442	if (tst == NULL) return(-1);
1443
1444	for (i = 0;i < sizeof(limitDescriptions)/sizeof(limitDescriptions[0]);i++) {
1445	limit = limitDescriptions[i].limit;
1446	fail = limitDescriptions[i].fail;
1447	/*
1448	* Handle exceptions if any
1449	*/
1450	for (j = 0;j < sizeof(testExceptions)/sizeof(testExceptions[0]);j++) {
1451	if ((testExceptions[j].test == test) &&
1452	(testExceptions[j].limit == i)) {
1453	if (testExceptions[j].fail != -1)
1454	fail = testExceptions[j].fail;
1455	if (testExceptions[j].size != 0)
1456	limit = testExceptions[j].size;
1457	break;
1458	}
1459	}
1460	res = tst->func(limitDescriptions[i].name, limit,
1461	limitDescriptions[i].options, fail);
1462	if (res != 0) {
1463	nb_errors++;
1464	err++;
1465	}
1466	}
1467	return(err);
1468	}
1469
1470
1471	static int
1472	runtest(unsigned int i) {
1473	int ret = 0, res;
1474	int old_errors, old_tests, old_leaks;
1475
1476	old_errors = nb_errors;
1477	old_tests = nb_tests;
1478	old_leaks = nb_leaks;
1479	if ((tests_quiet == 0) && (testDescriptions[i].desc != NULL))
1480	printf("## %s\n", testDescriptions[i].desc);
1481	res = launchTests(&testDescriptions[i], i);
1482	if (res != 0)
1483	ret++;
1484	if (verbose) {
1485	if ((nb_errors == old_errors) && (nb_leaks == old_leaks))
1486	printf("Ran %d tests, no errors\n", nb_tests - old_tests);
1487	else
1488	printf("Ran %d tests, %d errors, %d leaks\n",
1489	nb_tests - old_tests,
1490	nb_errors - old_errors,
1491	nb_leaks - old_leaks);
1492	}
1493	return(ret);
1494	}
1495
1496	static int
1497	launchCrazySAX(unsigned int test, int fail) {
1498	int res = 0, err = 0;
1499
1500	crazy_indx = test;
1501
1502	res = saxTest("crazy::test", XML_MAX_LOOKUP_LIMIT - CHUNK, 0, fail);
1503	if (res != 0) {
1504	nb_errors++;
1505	err++;
1506	}
1507	if (tests_quiet == 0)
1508	fprintf(stderr, "%c", crazy[test]);
1509
1510	return(err);
1511	}
1512
1513	#ifdef LIBXML_READER_ENABLED
1514	static int
1515	launchCrazy(unsigned int test, int fail) {
1516	int res = 0, err = 0;
1517
1518	crazy_indx = test;
1519
1520	res = readerTest("crazy::test", XML_MAX_LOOKUP_LIMIT - CHUNK, 0, fail);
1521	if (res != 0) {
1522	nb_errors++;
1523	err++;
1524	}
1525	if (tests_quiet == 0)
1526	fprintf(stderr, "%c", crazy[test]);
1527
1528	return(err);
1529	}
1530	#endif
1531
1532	static int get_crazy_fail(int test) {
1533	/*
1534	* adding 1000000 of character 'a' leads to parser failure mostly
1535	* everywhere except in those special spots. Need to be updated
1536	* each time crazy is updated
1537	*/
1538	int fail = 1;
1539	if ((test == 44) \|\| /* PI in Misc */
1540	((test >= 50) && (test <= 55)) \|\| /* Comment in Misc */
1541	(test == 79) \|\| /* PI in DTD */
1542	((test >= 85) && (test <= 90)) \|\| /* Comment in DTD */
1543	(test == 154) \|\| /* PI in Misc */
1544	((test >= 160) && (test <= 165)) \|\| /* Comment in Misc */
1545	((test >= 178) && (test <= 181)) \|\| /* attribute value */
1546	(test == 183) \|\| /* Text */
1547	(test == 189) \|\| /* PI in Content */
1548	(test == 191) \|\| /* Text */
1549	((test >= 195) && (test <= 200)) \|\| /* Comment in Content */
1550	((test >= 203) && (test <= 206)) \|\| /* Text */
1551	(test == 215) \|\| (test == 216) \|\| /* in CDATA */
1552	(test == 219) \|\| /* Text */
1553	(test == 231) \|\| /* PI in Misc */
1554	((test >= 237) && (test <= 242))) /* Comment in Misc */
1555	fail = 0;
1556	return(fail);
1557	}
1558
1559	static int
1560	runcrazy(void) {
1561	int ret = 0, res = 0;
1562	int old_errors, old_tests, old_leaks;
1563	unsigned int i;
1564
1565	old_errors = nb_errors;
1566	old_tests = nb_tests;
1567	old_leaks = nb_leaks;
1568
1569	#ifdef LIBXML_READER_ENABLED
1570	if (tests_quiet == 0) {
1571	printf("## Crazy tests on reader\n");
1572	}
1573	for (i = 0;i < strlen(crazy);i++) {
1574	res += launchCrazy(i, get_crazy_fail(i));
1575	if (res != 0)
1576	ret++;
1577	}
1578	#endif
1579
1580	if (tests_quiet == 0) {
1581	printf("\n## Crazy tests on SAX\n");
1582	}
1583	for (i = 0;i < strlen(crazy);i++) {
1584	res += launchCrazySAX(i, get_crazy_fail(i));
1585	if (res != 0)
1586	ret++;
1587	}
1588	if (tests_quiet == 0)
1589	fprintf(stderr, "\n");
1590	if (verbose) {
1591	if ((nb_errors == old_errors) && (nb_leaks == old_leaks))
1592	printf("Ran %d tests, no errors\n", nb_tests - old_tests);
1593	else
1594	printf("Ran %d tests, %d errors, %d leaks\n",
1595	nb_tests - old_tests,
1596	nb_errors - old_errors,
1597	nb_leaks - old_leaks);
1598	}
1599	return(ret);
1600	}
1601
1602
1603	int
1604	main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
1605	int i, a, ret = 0;
1606	int subset = 0;
1607
1608	fillFilling();
1609	initializeLibxml2();
1610
1611	for (a = 1; a < argc;a++) {
1612	if (!strcmp(argv[a], "-v"))
1613	verbose = 1;
1614	else if (!strcmp(argv[a], "-quiet"))
1615	tests_quiet = 1;
1616	else if (!strcmp(argv[a], "-crazy"))
1617	subset = 1;
1618	}
1619	if (subset == 0) {
1620	for (i = 0; testDescriptions[i].func != NULL; i++) {
1621	ret += runtest(i);
1622	}
1623	}
1624	ret += runcrazy();
1625	if ((nb_errors == 0) && (nb_leaks == 0)) {
1626	ret = 0;
1627	printf("Total %d tests, no errors\n",
1628	nb_tests);
1629	} else {
1630	ret = 1;
1631	printf("Total %d tests, %d errors, %d leaks\n",
1632	nb_tests, nb_errors, nb_leaks);
1633	}
1634	xmlCleanupParser();
1635	xmlMemoryDump();
1636
1637	return(ret);
1638	}

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

source: vbox/trunk/src/libs/libxml2-2.9.14/testlimits.c@ 98879

Download in other formats: