Annotation of embedaddon/libxml2/testapi.c, revision 1.1.1.1
1.1 misho 1: /*
2: * testapi.c: libxml2 API tester program.
3: *
4: * Automatically generated by gentest.py from libxml2-api.xml
5: *
6: * See Copyright for the status of this software.
7: *
8: * daniel@veillard.com
9: */
10:
11: #ifdef HAVE_CONFIG_H
12: #include "libxml.h"
13: #else
14: #include <stdio.h>
15: #endif
16:
17: #include <stdlib.h> /* for putenv() */
18: #include <string.h>
19: #include <libxml/xmlerror.h>
20: #include <libxml/relaxng.h>
21:
22: #if defined(_WIN32) && !defined(__CYGWIN__)
23: #define snprintf _snprintf
24: #endif
25:
26: static int testlibxml2(void);
27: static int test_module(const char *module);
28:
29: static int generic_errors = 0;
30: static int call_tests = 0;
31: static int function_tests = 0;
32:
33: static xmlChar chartab[1024];
34: static int inttab[1024];
35: static unsigned long longtab[1024];
36:
37: static xmlDocPtr api_doc = NULL;
38: static xmlDtdPtr api_dtd = NULL;
39: static xmlNodePtr api_root = NULL;
40: static xmlAttrPtr api_attr = NULL;
41: static xmlNsPtr api_ns = NULL;
42:
43: static void
44: structured_errors(void *userData ATTRIBUTE_UNUSED,
45: xmlErrorPtr error ATTRIBUTE_UNUSED) {
46: generic_errors++;
47: }
48:
49: static void
50: free_api_doc(void) {
51: xmlFreeDoc(api_doc);
52: api_doc = NULL;
53: api_dtd = NULL;
54: api_root = NULL;
55: api_attr = NULL;
56: api_ns = NULL;
57: }
58:
59: static xmlDocPtr
60: get_api_doc(void) {
61: if (api_doc == NULL) {
62: api_doc = xmlReadMemory("<!DOCTYPE root [<!ELEMENT root EMPTY>]><root xmlns:h='http://example.com/' h:foo='bar'/>", 88, "root_test", NULL, 0);
63: api_root = NULL;
64: api_attr = NULL;
65: }
66: return(api_doc);
67: }
68:
69: static xmlDtdPtr
70: get_api_dtd(void) {
71: if ((api_dtd == NULL) || (api_dtd->type != XML_DTD_NODE)) {
72: get_api_doc();
73: if ((api_doc != NULL) && (api_doc->children != NULL) &&
74: (api_doc->children->type == XML_DTD_NODE))
75: api_dtd = (xmlDtdPtr) api_doc->children;
76: }
77: return(api_dtd);
78: }
79:
80: static xmlNodePtr
81: get_api_root(void) {
82: if ((api_root == NULL) || (api_root->type != XML_ELEMENT_NODE)) {
83: get_api_doc();
84: if ((api_doc != NULL) && (api_doc->children != NULL) &&
85: (api_doc->children->next != NULL) &&
86: (api_doc->children->next->type == XML_ELEMENT_NODE))
87: api_root = api_doc->children->next;
88: }
89: return(api_root);
90: }
91:
92: static xmlNsPtr
93: get_api_ns(void) {
94: get_api_root();
95: if (api_root != NULL)
96: api_ns = api_root->nsDef;
97: return(api_ns);
98: }
99:
100: static xmlAttrPtr
101: get_api_attr(void) {
102: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
103: static int nr = 0;
104: xmlChar name[20];
105: #endif
106:
107: if ((api_root == NULL) || (api_root->type != XML_ELEMENT_NODE)) {
108: get_api_root();
109: }
110: if (api_root == NULL)
111: return(NULL);
112: if (api_root->properties != NULL) {
113: api_attr = api_root->properties;
114: return(api_root->properties);
115: }
116: api_attr = NULL;
117: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
118: snprintf((char *) name, 20, "foo%d", nr++);
119: api_attr = xmlSetProp(api_root, name, (const xmlChar *) "bar");
120: #endif
121: return(api_attr);
122: }
123:
124: static int quiet = 0;
125:
126: int main(int argc, char **argv) {
127: int ret;
128: int blocks, mem;
129:
130: /* access to the proxy can slow up regression tests a lot */
131: putenv((char *) "http_proxy=");
132:
133: memset(chartab, 0, sizeof(chartab));
134: strncpy((char *) chartab, " chartab\n", 20);
135: memset(inttab, 0, sizeof(inttab));
136: memset(longtab, 0, sizeof(longtab));
137:
138: xmlInitParser();
139: #ifdef LIBXML_SCHEMAS_ENABLED
140: xmlRelaxNGInitTypes();
141: #endif
142:
143: LIBXML_TEST_VERSION
144:
145: xmlSetStructuredErrorFunc(NULL, structured_errors);
146:
147: if (argc >= 2) {
148: if (!strcmp(argv[1], "-q")) {
149: quiet = 1;
150: if (argc >= 3)
151: ret = test_module(argv[2]);
152: else
153: ret = testlibxml2();
154: } else {
155: ret = test_module(argv[1]);
156: }
157: } else
158: ret = testlibxml2();
159:
160: xmlCleanupParser();
161: blocks = xmlMemBlocks();
162: mem = xmlMemUsed();
163: if ((blocks != 0) || (mem != 0)) {
164: printf("testapi leaked %d bytes in %d blocks\n", mem, blocks);
165: }
166: xmlMemoryDump();
167:
168: return (ret != 0);
169: }
170:
171: #include <libxml/HTMLparser.h>
172: #include <libxml/HTMLtree.h>
173: #include <libxml/catalog.h>
174: #include <libxml/chvalid.h>
175: #include <libxml/dict.h>
176: #include <libxml/encoding.h>
177: #include <libxml/entities.h>
178: #include <libxml/hash.h>
179: #include <libxml/list.h>
180: #include <libxml/nanoftp.h>
181: #include <libxml/nanohttp.h>
182: #include <libxml/parser.h>
183: #include <libxml/parserInternals.h>
184: #include <libxml/pattern.h>
185: #include <libxml/relaxng.h>
186: #include <libxml/schemasInternals.h>
187: #include <libxml/schematron.h>
188: #include <libxml/tree.h>
189: #include <libxml/uri.h>
190: #include <libxml/valid.h>
191: #include <libxml/xinclude.h>
192: #include <libxml/xmlIO.h>
193: #include <libxml/xmlerror.h>
194: #include <libxml/xmlreader.h>
195: #include <libxml/xmlsave.h>
196: #include <libxml/xmlschemas.h>
197: #include <libxml/xmlschemastypes.h>
198: #include <libxml/xmlstring.h>
199: #include <libxml/xmlwriter.h>
200: #include <libxml/xpath.h>
201: #include <libxml/xpointer.h>
202: #include <libxml/debugXML.h>
203:
204: /*
205: We manually define xmlErrMemory because it's normal declaration
206: is "hidden" by #ifdef IN_LIBXML
207: */
208: void xmlErrMemory(xmlParserCtxtPtr ctxt, const char *extra);
209:
210: /*
211: We need some "remote" addresses, but want to avoid getting into
212: name resolution delays, so we use these
213: */
214: #define REMOTE1GOOD "http://localhost/"
215: #define REMOTE1BAD "http:http://http"
216: #define REMOTE2GOOD "ftp://localhost/foo"
217:
218: #define gen_nb_void_ptr 2
219:
220: static void *gen_void_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
221: return(NULL);
222: }
223: static void des_void_ptr(int no ATTRIBUTE_UNUSED, void *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
224: }
225:
226: #if 0
227: #define gen_nb_const_void_ptr 2
228:
229: static const void *gen_const_void_ptr(int no, int nr ATTRIBUTE_UNUSED) {
230: if (no == 0) return((const void *) "immutable string");
231: return(NULL);
232: }
233: static void des_const_void_ptr(int no ATTRIBUTE_UNUSED, const void *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
234: }
235: #endif
236:
237: #define gen_nb_userdata 3
238:
239: static void *gen_userdata(int no, int nr ATTRIBUTE_UNUSED) {
240: if (no == 0) return((void *) &call_tests);
241: if (no == 1) return((void *) -1);
242: return(NULL);
243: }
244: static void des_userdata(int no ATTRIBUTE_UNUSED, void *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
245: }
246:
247:
248: #define gen_nb_int 4
249:
250: static int gen_int(int no, int nr ATTRIBUTE_UNUSED) {
251: if (no == 0) return(0);
252: if (no == 1) return(1);
253: if (no == 2) return(-1);
254: if (no == 3) return(122);
255: return(-1);
256: }
257:
258: static void des_int(int no ATTRIBUTE_UNUSED, int val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
259: }
260:
261: #define gen_nb_parseroptions 5
262:
263: static int gen_parseroptions(int no, int nr ATTRIBUTE_UNUSED) {
264: if (no == 0) return(XML_PARSE_NOBLANKS | XML_PARSE_RECOVER);
265: if (no == 1) return(XML_PARSE_NOENT | XML_PARSE_DTDLOAD | XML_PARSE_DTDATTR | XML_PARSE_DTDVALID | XML_PARSE_NOCDATA);
266: if (no == 2) return(XML_PARSE_XINCLUDE | XML_PARSE_NOXINCNODE | XML_PARSE_NSCLEAN);
267: if (no == 3) return(XML_PARSE_XINCLUDE | XML_PARSE_NODICT);
268: return(XML_PARSE_SAX1);
269: }
270:
271: static void des_parseroptions(int no ATTRIBUTE_UNUSED, int val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
272: }
273:
274: #if 0
275: #define gen_nb_long 5
276:
277: static long gen_long(int no, int nr ATTRIBUTE_UNUSED) {
278: if (no == 0) return(0);
279: if (no == 1) return(1);
280: if (no == 2) return(-1);
281: if (no == 3) return(122);
282: return(-1);
283: }
284:
285: static void des_long(int no ATTRIBUTE_UNUSED, long val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
286: }
287: #endif
288:
289: #define gen_nb_xmlChar 4
290:
291: static xmlChar gen_xmlChar(int no, int nr ATTRIBUTE_UNUSED) {
292: if (no == 0) return('a');
293: if (no == 1) return(' ');
294: if (no == 2) return((xmlChar) 'ø');
295: return(0);
296: }
297:
298: static void des_xmlChar(int no ATTRIBUTE_UNUSED, xmlChar val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
299: }
300:
301: #define gen_nb_unsigned_int 3
302:
303: static unsigned int gen_unsigned_int(int no, int nr ATTRIBUTE_UNUSED) {
304: if (no == 0) return(0);
305: if (no == 1) return(1);
306: if (no == 2) return(122);
307: return((unsigned int) -1);
308: }
309:
310: static void des_unsigned_int(int no ATTRIBUTE_UNUSED, unsigned int val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
311: }
312:
313: #define gen_nb_unsigned_long 4
314:
315: static unsigned long gen_unsigned_long(int no, int nr ATTRIBUTE_UNUSED) {
316: if (no == 0) return(0);
317: if (no == 1) return(1);
318: if (no == 2) return(122);
319: return((unsigned long) -1);
320: }
321:
322: static void des_unsigned_long(int no ATTRIBUTE_UNUSED, unsigned long val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
323: }
324:
325: #define gen_nb_double 4
326:
327: static double gen_double(int no, int nr ATTRIBUTE_UNUSED) {
328: if (no == 0) return(0);
329: if (no == 1) return(-1.1);
330: #if defined(LIBXML_XPATH_ENABLED)
331: if (no == 2) return(xmlXPathNAN);
332: #endif
333: return(-1);
334: }
335:
336: static void des_double(int no ATTRIBUTE_UNUSED, double val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
337: }
338:
339: #define gen_nb_unsigned_long_ptr 2
340:
341: static unsigned long *gen_unsigned_long_ptr(int no, int nr) {
342: if (no == 0) return(&longtab[nr]);
343: return(NULL);
344: }
345:
346: static void des_unsigned_long_ptr(int no ATTRIBUTE_UNUSED, unsigned long *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
347: }
348:
349: #define gen_nb_int_ptr 2
350:
351: static int *gen_int_ptr(int no, int nr) {
352: if (no == 0) return(&inttab[nr]);
353: return(NULL);
354: }
355:
356: static void des_int_ptr(int no ATTRIBUTE_UNUSED, int *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
357: }
358:
359: #define gen_nb_const_char_ptr 4
360:
361: static char *gen_const_char_ptr(int no, int nr ATTRIBUTE_UNUSED) {
362: if (no == 0) return((char *) "foo");
363: if (no == 1) return((char *) "<foo/>");
364: if (no == 2) return((char *) "test/ent2");
365: return(NULL);
366: }
367: static void des_const_char_ptr(int no ATTRIBUTE_UNUSED, const char *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
368: }
369:
370: #define gen_nb_xmlChar_ptr 2
371:
372: static xmlChar *gen_xmlChar_ptr(int no, int nr ATTRIBUTE_UNUSED) {
373: if (no == 0) return(&chartab[0]);
374: return(NULL);
375: }
376: static void des_xmlChar_ptr(int no ATTRIBUTE_UNUSED, xmlChar *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
377: }
378:
379: #define gen_nb_FILE_ptr 2
380:
381: static FILE *gen_FILE_ptr(int no, int nr ATTRIBUTE_UNUSED) {
382: if (no == 0) return(fopen("test.out", "a+"));
383: return(NULL);
384: }
385: static void des_FILE_ptr(int no ATTRIBUTE_UNUSED, FILE *val, int nr ATTRIBUTE_UNUSED) {
386: if (val != NULL) fclose(val);
387: }
388:
389: #define gen_nb_debug_FILE_ptr 2
390: static FILE *gen_debug_FILE_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
391: return(fopen("test.out", "a+"));
392: }
393: static void des_debug_FILE_ptr(int no ATTRIBUTE_UNUSED, FILE *val, int nr ATTRIBUTE_UNUSED) {
394: if (val != NULL) fclose(val);
395: }
396:
397: #define gen_nb_const_xmlChar_ptr 5
398:
399: static xmlChar *gen_const_xmlChar_ptr(int no, int nr ATTRIBUTE_UNUSED) {
400: if (no == 0) return((xmlChar *) "foo");
401: if (no == 1) return((xmlChar *) "<foo/>");
402: if (no == 2) return((xmlChar *) "nøne");
403: if (no == 3) return((xmlChar *) " 2ab ");
404: return(NULL);
405: }
406: static void des_const_xmlChar_ptr(int no ATTRIBUTE_UNUSED, const xmlChar *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
407: }
408:
409: #define gen_nb_filepath 8
410:
411: static const char *gen_filepath(int no, int nr ATTRIBUTE_UNUSED) {
412: if (no == 0) return("missing.xml");
413: if (no == 1) return("<foo/>");
414: if (no == 2) return("test/ent2");
415: if (no == 3) return("test/valid/REC-xml-19980210.xml");
416: if (no == 4) return("test/valid/dtds/xhtml1-strict.dtd");
417: if (no == 5) return(REMOTE1GOOD);
418: if (no == 6) return(REMOTE1BAD);
419: return(NULL);
420: }
421: static void des_filepath(int no ATTRIBUTE_UNUSED, const char *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
422: }
423:
424: #define gen_nb_eaten_name 2
425:
426: static xmlChar *gen_eaten_name(int no, int nr ATTRIBUTE_UNUSED) {
427: if (no == 0) return(xmlStrdup(BAD_CAST "eaten"));
428: return(NULL);
429: }
430: static void des_eaten_name(int no ATTRIBUTE_UNUSED, xmlChar *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
431: }
432:
433: #define gen_nb_fileoutput 6
434:
435: static const char *gen_fileoutput(int no, int nr ATTRIBUTE_UNUSED) {
436: if (no == 0) return("/missing.xml");
437: if (no == 1) return("<foo/>");
438: if (no == 2) return(REMOTE2GOOD);
439: if (no == 3) return(REMOTE1GOOD);
440: if (no == 4) return(REMOTE1BAD);
441: return(NULL);
442: }
443: static void des_fileoutput(int no ATTRIBUTE_UNUSED, const char *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
444: }
445:
446: #define gen_nb_xmlParserCtxtPtr 3
447: static xmlParserCtxtPtr gen_xmlParserCtxtPtr(int no, int nr ATTRIBUTE_UNUSED) {
448: if (no == 0) return(xmlNewParserCtxt());
449: if (no == 1) return(xmlCreateMemoryParserCtxt("<doc/>", 6));
450: return(NULL);
451: }
452: static void des_xmlParserCtxtPtr(int no ATTRIBUTE_UNUSED, xmlParserCtxtPtr val, int nr ATTRIBUTE_UNUSED) {
453: if (val != NULL)
454: xmlFreeParserCtxt(val);
455: }
456:
457: #define gen_nb_xmlSAXHandlerPtr 2
458: static xmlSAXHandlerPtr gen_xmlSAXHandlerPtr(int no, int nr ATTRIBUTE_UNUSED) {
459: #ifdef LIBXML_SAX1_ENABLED
460: if (no == 0) return((xmlSAXHandlerPtr) &xmlDefaultSAXHandler);
461: #endif
462: return(NULL);
463: }
464: static void des_xmlSAXHandlerPtr(int no ATTRIBUTE_UNUSED, xmlSAXHandlerPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
465: }
466:
467: #define gen_nb_xmlValidCtxtPtr 2
468: static xmlValidCtxtPtr gen_xmlValidCtxtPtr(int no, int nr ATTRIBUTE_UNUSED) {
469: #ifdef LIBXML_VALID_ENABLED
470: if (no == 0) return(xmlNewValidCtxt());
471: #endif
472: return(NULL);
473: }
474: static void des_xmlValidCtxtPtr(int no ATTRIBUTE_UNUSED, xmlValidCtxtPtr val, int nr ATTRIBUTE_UNUSED) {
475: #ifdef LIBXML_VALID_ENABLED
476: if (val != NULL)
477: xmlFreeValidCtxt(val);
478: #endif
479: }
480:
481: #define gen_nb_xmlParserInputBufferPtr 8
482:
483: static xmlParserInputBufferPtr gen_xmlParserInputBufferPtr(int no, int nr ATTRIBUTE_UNUSED) {
484: if (no == 0) return(xmlParserInputBufferCreateFilename("missing.xml", XML_CHAR_ENCODING_NONE));
485: if (no == 1) return(xmlParserInputBufferCreateFilename("<foo/>", XML_CHAR_ENCODING_NONE));
486: if (no == 2) return(xmlParserInputBufferCreateFilename("test/ent2", XML_CHAR_ENCODING_NONE));
487: if (no == 3) return(xmlParserInputBufferCreateFilename("test/valid/REC-xml-19980210.xml", XML_CHAR_ENCODING_NONE));
488: if (no == 4) return(xmlParserInputBufferCreateFilename("test/valid/dtds/xhtml1-strict.dtd", XML_CHAR_ENCODING_NONE));
489: if (no == 5) return(xmlParserInputBufferCreateFilename(REMOTE1GOOD, XML_CHAR_ENCODING_NONE));
490: if (no == 6) return(xmlParserInputBufferCreateFilename(REMOTE1BAD, XML_CHAR_ENCODING_NONE));
491: return(NULL);
492: }
493: static void des_xmlParserInputBufferPtr(int no ATTRIBUTE_UNUSED, xmlParserInputBufferPtr val, int nr ATTRIBUTE_UNUSED) {
494: xmlFreeParserInputBuffer(val);
495: }
496:
497: #define gen_nb_xmlDocPtr 4
498: static xmlDocPtr gen_xmlDocPtr(int no, int nr ATTRIBUTE_UNUSED) {
499: if (no == 0) return(xmlNewDoc(BAD_CAST "1.0"));
500: if (no == 1) return(xmlReadMemory("<foo/>", 6, "test", NULL, 0));
501: if (no == 2) return(xmlReadMemory("<!DOCTYPE foo []> <foo/>", 24, "test", NULL, 0));
502: return(NULL);
503: }
504: static void des_xmlDocPtr(int no ATTRIBUTE_UNUSED, xmlDocPtr val, int nr ATTRIBUTE_UNUSED) {
505: if ((val != NULL) && (val != api_doc) && (val->doc != api_doc))
506: xmlFreeDoc(val);
507: }
508:
509: #define gen_nb_xmlAttrPtr 2
510: static xmlAttrPtr gen_xmlAttrPtr(int no, int nr ATTRIBUTE_UNUSED) {
511: if (no == 0) return(get_api_attr());
512: return(NULL);
513: }
514: static void des_xmlAttrPtr(int no, xmlAttrPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
515: if (no == 0) free_api_doc();
516: }
517:
518: #define gen_nb_xmlDictPtr 2
519: static xmlDictPtr gen_xmlDictPtr(int no, int nr ATTRIBUTE_UNUSED) {
520: if (no == 0) return(xmlDictCreate());
521: return(NULL);
522: }
523: static void des_xmlDictPtr(int no ATTRIBUTE_UNUSED, xmlDictPtr val, int nr ATTRIBUTE_UNUSED) {
524: if (val != NULL)
525: xmlDictFree(val);
526: }
527:
528: #define gen_nb_xmlNodePtr 3
529: static xmlNodePtr gen_xmlNodePtr(int no, int nr ATTRIBUTE_UNUSED) {
530: if (no == 0) return(xmlNewPI(BAD_CAST "test", NULL));
531: if (no == 1) return(get_api_root());
532: return(NULL);
533: /* if (no == 2) return((xmlNodePtr) get_api_doc()); */
534: }
535: static void des_xmlNodePtr(int no, xmlNodePtr val, int nr ATTRIBUTE_UNUSED) {
536: if (no == 1) {
537: free_api_doc();
538: } else if (val != NULL) {
539: xmlUnlinkNode(val);
540: xmlFreeNode(val);
541: }
542: }
543:
544: #define gen_nb_xmlDtdPtr 3
545: static xmlDtdPtr gen_xmlDtdPtr(int no, int nr ATTRIBUTE_UNUSED) {
546: if (no == 0)
547: return(xmlNewDtd(NULL, BAD_CAST "dtd", BAD_CAST"foo", BAD_CAST"bar"));
548: if (no == 1) return(get_api_dtd());
549: return(NULL);
550: }
551: static void des_xmlDtdPtr(int no, xmlDtdPtr val, int nr ATTRIBUTE_UNUSED) {
552: if (no == 1) free_api_doc();
553: else if (val != NULL) {
554: xmlUnlinkNode((xmlNodePtr) val);
555: xmlFreeNode((xmlNodePtr) val);
556: }
557: }
558:
559: #define gen_nb_xmlNsPtr 2
560: static xmlNsPtr gen_xmlNsPtr(int no, int nr ATTRIBUTE_UNUSED) {
561: if (no == 0) return(get_api_ns());
562: return(NULL);
563: }
564: static void des_xmlNsPtr(int no, xmlNsPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
565: if (no == 0) free_api_doc();
566: }
567:
568: #define gen_nb_xmlNodePtr_in 3
569: static xmlNodePtr gen_xmlNodePtr_in(int no, int nr ATTRIBUTE_UNUSED) {
570: if (no == 0) return(xmlNewPI(BAD_CAST "test", NULL));
571: if (no == 0) return(xmlNewText(BAD_CAST "text"));
572: return(NULL);
573: }
574: static void des_xmlNodePtr_in(int no ATTRIBUTE_UNUSED, xmlNodePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
575: }
576:
577: #ifdef LIBXML_WRITER_ENABLED
578: #define gen_nb_xmlTextWriterPtr 2
579: static xmlTextWriterPtr gen_xmlTextWriterPtr(int no, int nr ATTRIBUTE_UNUSED) {
580: if (no == 0) return(xmlNewTextWriterFilename("test.out", 0));
581: return(NULL);
582: }
583: static void des_xmlTextWriterPtr(int no ATTRIBUTE_UNUSED, xmlTextWriterPtr val, int nr ATTRIBUTE_UNUSED) {
584: if (val != NULL) xmlFreeTextWriter(val);
585: }
586: #endif
587:
588: #ifdef LIBXML_READER_ENABLED
589: #define gen_nb_xmlTextReaderPtr 4
590: static xmlTextReaderPtr gen_xmlTextReaderPtr(int no, int nr ATTRIBUTE_UNUSED) {
591: if (no == 0) return(xmlNewTextReaderFilename("test/ent2"));
592: if (no == 1) return(xmlNewTextReaderFilename("test/valid/REC-xml-19980210.xml"));
593: if (no == 2) return(xmlNewTextReaderFilename("test/valid/dtds/xhtml1-strict.dtd"));
594: return(NULL);
595: }
596: static void des_xmlTextReaderPtr(int no ATTRIBUTE_UNUSED, xmlTextReaderPtr val, int nr ATTRIBUTE_UNUSED) {
597: if (val != NULL) xmlFreeTextReader(val);
598: }
599: #endif
600:
601: #define gen_nb_xmlBufferPtr 3
602: static const char *static_buf_content = "a static buffer";
603: static xmlBufferPtr gen_xmlBufferPtr(int no, int nr ATTRIBUTE_UNUSED) {
604: if (no == 0) return(xmlBufferCreate());
605: if (no == 1) return(xmlBufferCreateStatic((void *)static_buf_content, 13));
606: return(NULL);
607: }
608: static void des_xmlBufferPtr(int no ATTRIBUTE_UNUSED, xmlBufferPtr val, int nr ATTRIBUTE_UNUSED) {
609: if (val != NULL) {
610: xmlBufferFree(val);
611: }
612: }
613:
614: #define gen_nb_xmlListPtr 2
615: static xmlListPtr gen_xmlListPtr(int no, int nr ATTRIBUTE_UNUSED) {
616: if (no == 0) return(xmlListCreate(NULL, NULL));
617: return(NULL);
618: }
619: static void des_xmlListPtr(int no ATTRIBUTE_UNUSED, xmlListPtr val, int nr ATTRIBUTE_UNUSED) {
620: if (val != NULL) {
621: xmlListDelete(val);
622: }
623: }
624:
625: #define gen_nb_xmlHashTablePtr 2
626: static xmlHashTablePtr gen_xmlHashTablePtr(int no, int nr ATTRIBUTE_UNUSED) {
627: if (no == 0) return(xmlHashCreate(10));
628: return(NULL);
629: }
630: static void des_xmlHashTablePtr(int no ATTRIBUTE_UNUSED, xmlHashTablePtr val, int nr ATTRIBUTE_UNUSED) {
631: if (val != NULL) {
632: xmlHashFree(val, NULL);
633: }
634: }
635:
636: #include <libxml/xpathInternals.h>
637:
638: #ifdef LIBXML_XPATH_ENABLED
639: #define gen_nb_xmlXPathObjectPtr 5
640: static xmlXPathObjectPtr gen_xmlXPathObjectPtr(int no, int nr ATTRIBUTE_UNUSED) {
641: if (no == 0) return(xmlXPathNewString(BAD_CAST "string object"));
642: if (no == 1) return(xmlXPathNewFloat(1.1));
643: if (no == 2) return(xmlXPathNewBoolean(1));
644: if (no == 3) return(xmlXPathNewNodeSet(NULL));
645: return(NULL);
646: }
647: static void des_xmlXPathObjectPtr(int no ATTRIBUTE_UNUSED, xmlXPathObjectPtr val, int nr ATTRIBUTE_UNUSED) {
648: if (val != NULL) {
649: xmlXPathFreeObject(val);
650: }
651: }
652: #endif
653:
654: #ifdef LIBXML_OUTPUT_ENABLED
655: #define gen_nb_xmlOutputBufferPtr 2
656: static xmlOutputBufferPtr gen_xmlOutputBufferPtr(int no, int nr ATTRIBUTE_UNUSED) {
657: if (no == 0) return(xmlOutputBufferCreateFilename("test.out", NULL, 0));
658: return(NULL);
659: }
660: static void des_xmlOutputBufferPtr(int no ATTRIBUTE_UNUSED, xmlOutputBufferPtr val, int nr ATTRIBUTE_UNUSED) {
661: if (val != NULL) {
662: xmlOutputBufferClose(val);
663: }
664: }
665: #endif
666:
667: #ifdef LIBXML_FTP_ENABLED
668: #define gen_nb_xmlNanoFTPCtxtPtr 4
669: static void *gen_xmlNanoFTPCtxtPtr(int no, int nr ATTRIBUTE_UNUSED) {
670: if (no == 0) return(xmlNanoFTPNewCtxt(REMOTE2GOOD));
671: if (no == 1) return(xmlNanoFTPNewCtxt(REMOTE1GOOD));
672: if (no == 2) return(xmlNanoFTPNewCtxt("foo"));
673: return(NULL);
674: }
675: static void des_xmlNanoFTPCtxtPtr(int no ATTRIBUTE_UNUSED, void *val, int nr ATTRIBUTE_UNUSED) {
676: if (val != NULL) {
677: xmlNanoFTPFreeCtxt(val);
678: }
679: }
680: #endif
681:
682: #ifdef LIBXML_HTTP_ENABLED
683: #define gen_nb_xmlNanoHTTPCtxtPtr 1
684: static void *gen_xmlNanoHTTPCtxtPtr(int no, int nr ATTRIBUTE_UNUSED) {
685: if (no == 0) return(xmlNanoHTTPOpen(REMOTE1GOOD, NULL));
686: if (no == 1) return(xmlNanoHTTPOpen(REMOTE2GOOD, NULL));
687: if (no == 2) return(xmlNanoHTTPOpen(REMOTE1BAD, NULL));
688: return(NULL);
689: }
690: static void des_xmlNanoHTTPCtxtPtr(int no ATTRIBUTE_UNUSED, void *val, int nr ATTRIBUTE_UNUSED) {
691: if (val != NULL) {
692: xmlNanoHTTPClose(val);
693: }
694: }
695: #endif
696:
697: #define gen_nb_xmlCharEncoding 4
698: static xmlCharEncoding gen_xmlCharEncoding(int no, int nr ATTRIBUTE_UNUSED) {
699: if (no == 0) return(XML_CHAR_ENCODING_UTF8);
700: if (no == 1) return(XML_CHAR_ENCODING_NONE);
701: if (no == 2) return(XML_CHAR_ENCODING_8859_1);
702: return(XML_CHAR_ENCODING_ERROR);
703: }
704: static void des_xmlCharEncoding(int no ATTRIBUTE_UNUSED, xmlCharEncoding val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
705: }
706:
707: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
708:
709: #define gen_nb_xmlExpCtxtPtr 1
710: static xmlExpCtxtPtr gen_xmlExpCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
711: return(NULL);
712: }
713: static void des_xmlExpCtxtPtr(int no ATTRIBUTE_UNUSED, xmlExpCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
714: }
715:
716: #define gen_nb_xmlExpNodePtr 1
717: static xmlExpNodePtr gen_xmlExpNodePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
718: return(NULL);
719: }
720: static void des_xmlExpNodePtr(int no ATTRIBUTE_UNUSED, xmlExpNodePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
721: }
722:
723: #endif
724:
725: #if defined(LIBXML_SCHEMAS_ENABLED)
726: #define gen_nb_xmlSchemaPtr 1
727: static xmlSchemaPtr gen_xmlSchemaPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
728: return(NULL);
729: }
730: static void des_xmlSchemaPtr(int no ATTRIBUTE_UNUSED, xmlSchemaPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
731: }
732:
733: #define gen_nb_xmlSchemaValidCtxtPtr 1
734: static xmlSchemaValidCtxtPtr gen_xmlSchemaValidCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
735: return(NULL);
736: }
737: static void des_xmlSchemaValidCtxtPtr(int no ATTRIBUTE_UNUSED, xmlSchemaValidCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
738: }
739:
740: #endif /* LIBXML_SCHEMAS_ENABLED */
741:
742: #define gen_nb_xmlHashDeallocator 2
743: static void
744: test_xmlHashDeallocator(void *payload ATTRIBUTE_UNUSED, xmlChar *name ATTRIBUTE_UNUSED) {
745: }
746:
747: static xmlHashDeallocator gen_xmlHashDeallocator(int no, int nr ATTRIBUTE_UNUSED) {
748: if (no == 0) return(test_xmlHashDeallocator);
749: return(NULL);
750: }
751: static void des_xmlHashDeallocator(int no ATTRIBUTE_UNUSED, xmlHashDeallocator val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
752: }
753:
754:
755: static void desret_int(int val ATTRIBUTE_UNUSED) {
756: }
757: static void desret_xmlChar(xmlChar val ATTRIBUTE_UNUSED) {
758: }
759: static void desret_long(long val ATTRIBUTE_UNUSED) {
760: }
761: static void desret_unsigned_long(unsigned long val ATTRIBUTE_UNUSED) {
762: }
763: static void desret_double(double val ATTRIBUTE_UNUSED) {
764: }
765: static void desret_xmlCharEncoding(xmlCharEncoding val ATTRIBUTE_UNUSED) {
766: }
767: #if 0
768: static void desret_const_void_ptr(void *val ATTRIBUTE_UNUSED) {
769: }
770: #endif
771: static void desret_void_ptr(void *val ATTRIBUTE_UNUSED) {
772: }
773: static void desret_const_char_ptr(const char *val ATTRIBUTE_UNUSED) {
774: }
775: static void desret_const_xmlChar_ptr(const xmlChar *val ATTRIBUTE_UNUSED) {
776: }
777: static void desret_xmlChar_ptr(xmlChar *val) {
778: if (val != NULL)
779: xmlFree(val);
780: }
781: static void desret_xmlDocPtr(xmlDocPtr val) {
782: if (val != api_doc)
783: xmlFreeDoc(val);
784: }
785: static void desret_xmlDictPtr(xmlDictPtr val) {
786: xmlDictFree(val);
787: }
788: #ifdef LIBXML_OUTPUT_ENABLED
789: static void desret_xmlOutputBufferPtr(xmlOutputBufferPtr val) {
790: xmlOutputBufferClose(val);
791: }
792: #endif
793: #ifdef LIBXML_READER_ENABLED
794: static void desret_xmlTextReaderPtr(xmlTextReaderPtr val) {
795: xmlFreeTextReader(val);
796: }
797: #endif
798: static void desret_xmlNodePtr(xmlNodePtr val) {
799: if ((val != NULL) && (val != api_root) && (val != (xmlNodePtr) api_doc)) {
800: xmlUnlinkNode(val);
801: xmlFreeNode(val);
802: }
803: }
804: static void desret_xmlAttrPtr(xmlAttrPtr val) {
805: if (val != NULL) {
806: xmlUnlinkNode((xmlNodePtr) val);
807: xmlFreeNode((xmlNodePtr) val);
808: }
809: }
810: static void desret_xmlEntityPtr(xmlEntityPtr val) {
811: if (val != NULL) {
812: xmlUnlinkNode((xmlNodePtr) val);
813: xmlFreeNode((xmlNodePtr) val);
814: }
815: }
816: static void desret_xmlElementPtr(xmlElementPtr val) {
817: if (val != NULL) {
818: xmlUnlinkNode((xmlNodePtr) val);
819: }
820: }
821: static void desret_xmlAttributePtr(xmlAttributePtr val) {
822: if (val != NULL) {
823: xmlUnlinkNode((xmlNodePtr) val);
824: }
825: }
826: static void desret_xmlNsPtr(xmlNsPtr val ATTRIBUTE_UNUSED) {
827: }
828: static void desret_xmlDtdPtr(xmlDtdPtr val) {
829: desret_xmlNodePtr((xmlNodePtr)val);
830: }
831: #ifdef LIBXML_XPATH_ENABLED
832: static void desret_xmlXPathObjectPtr(xmlXPathObjectPtr val) {
833: xmlXPathFreeObject(val);
834: }
835: static void desret_xmlNodeSetPtr(xmlNodeSetPtr val) {
836: xmlXPathFreeNodeSet(val);
837: }
838: #endif
839: static void desret_xmlParserCtxtPtr(xmlParserCtxtPtr val) {
840: xmlFreeParserCtxt(val);
841: }
842: static void desret_xmlParserInputBufferPtr(xmlParserInputBufferPtr val) {
843: xmlFreeParserInputBuffer(val);
844: }
845: static void desret_xmlParserInputPtr(xmlParserInputPtr val) {
846: xmlFreeInputStream(val);
847: }
848: #ifdef LIBXML_WRITER_ENABLED
849: static void desret_xmlTextWriterPtr(xmlTextWriterPtr val) {
850: xmlFreeTextWriter(val);
851: }
852: #endif
853: static void desret_xmlBufferPtr(xmlBufferPtr val) {
854: xmlBufferFree(val);
855: }
856: #ifdef LIBXML_SCHEMAS_ENABLED
857: static void desret_xmlSchemaParserCtxtPtr(xmlSchemaParserCtxtPtr val) {
858: xmlSchemaFreeParserCtxt(val);
859: }
860: static void desret_xmlSchemaTypePtr(xmlSchemaTypePtr val ATTRIBUTE_UNUSED) {
861: }
862: static void desret_xmlRelaxNGParserCtxtPtr(xmlRelaxNGParserCtxtPtr val) {
863: xmlRelaxNGFreeParserCtxt(val);
864: }
865: #endif
866: #ifdef LIBXML_HTML_ENABLED
867: static void desret_const_htmlEntityDesc_ptr(const htmlEntityDesc * val ATTRIBUTE_UNUSED) {
868: }
869: #endif
870: #ifdef LIBXML_HTTP_ENABLED
871: static void desret_xmlNanoHTTPCtxtPtr(void *val) {
872: xmlNanoHTTPClose(val);
873: }
874: #endif
875: #ifdef LIBXML_FTP_ENABLED
876: static void desret_xmlNanoFTPCtxtPtr(void *val) {
877: xmlNanoFTPClose(val);
878: }
879: #endif
880: /* cut and pasted from autogenerated to avoid troubles */
881: #define gen_nb_const_xmlChar_ptr_ptr 1
882: static xmlChar ** gen_const_xmlChar_ptr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
883: return(NULL);
884: }
885: static void des_const_xmlChar_ptr_ptr(int no ATTRIBUTE_UNUSED, const xmlChar ** val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
886: }
887:
888: #define gen_nb_unsigned_char_ptr 1
889: static unsigned char * gen_unsigned_char_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
890: return(NULL);
891: }
892: static void des_unsigned_char_ptr(int no ATTRIBUTE_UNUSED, unsigned char * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
893: }
894:
895: #define gen_nb_const_unsigned_char_ptr 1
896: static unsigned char * gen_const_unsigned_char_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
897: return(NULL);
898: }
899: static void des_const_unsigned_char_ptr(int no ATTRIBUTE_UNUSED, const unsigned char * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
900: }
901:
902: #ifdef LIBXML_HTML_ENABLED
903: #define gen_nb_const_htmlNodePtr 1
904: static htmlNodePtr gen_const_htmlNodePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
905: return(NULL);
906: }
907: static void des_const_htmlNodePtr(int no ATTRIBUTE_UNUSED, const htmlNodePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
908: }
909: #endif
910:
911: #ifdef LIBXML_HTML_ENABLED
912: #define gen_nb_htmlDocPtr 3
913: static htmlDocPtr gen_htmlDocPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
914: if (no == 0) return(htmlNewDoc(NULL, NULL));
915: if (no == 1) return(htmlReadMemory("<html/>", 7, "test", NULL, 0));
916: return(NULL);
917: }
918: static void des_htmlDocPtr(int no ATTRIBUTE_UNUSED, htmlDocPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
919: if ((val != NULL) && (val != api_doc) && (val->doc != api_doc))
920: xmlFreeDoc(val);
921: }
922: static void desret_htmlDocPtr(htmlDocPtr val) {
923: if ((val != NULL) && (val != api_doc) && (val->doc != api_doc))
924: xmlFreeDoc(val);
925: }
926: #define gen_nb_htmlParserCtxtPtr 3
927: static htmlParserCtxtPtr gen_htmlParserCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
928: if (no == 0) return(xmlNewParserCtxt());
929: if (no == 1) return(htmlCreateMemoryParserCtxt("<html/>", 7));
930: return(NULL);
931: }
932: static void des_htmlParserCtxtPtr(int no ATTRIBUTE_UNUSED, htmlParserCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
933: if (val != NULL)
934: htmlFreeParserCtxt(val);
935: }
936: static void desret_htmlParserCtxtPtr(htmlParserCtxtPtr val) {
937: if (val != NULL)
938: htmlFreeParserCtxt(val);
939: }
940: #endif
941:
942: #ifdef LIBXML_XPATH_ENABLED
943: #define gen_nb_xmlNodeSetPtr 1
944: static xmlNodeSetPtr gen_xmlNodeSetPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
945: return(NULL);
946: }
947: static void des_xmlNodeSetPtr(int no ATTRIBUTE_UNUSED, xmlNodeSetPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
948: }
949: #endif
950:
951: #ifdef LIBXML_DEBUG_ENABLED
952: #ifdef LIBXML_XPATH_ENABLED
953: #define gen_nb_xmlShellCtxtPtr 1
954: static xmlShellCtxtPtr gen_xmlShellCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
955: return(NULL);
956: }
957: static void des_xmlShellCtxtPtr(int no ATTRIBUTE_UNUSED, xmlShellCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
958: }
959: #endif
960: #endif
961:
962: #ifdef LIBXML_PATTERN_ENABLED
963: #define gen_nb_xmlPatternPtr 1
964: static xmlPatternPtr gen_xmlPatternPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
965: return(NULL);
966: }
967: static void des_xmlPatternPtr(int no ATTRIBUTE_UNUSED, xmlPatternPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
968: }
969: #endif
970:
971: #define gen_nb_xmlElementContentPtr 1
972: static xmlElementContentPtr gen_xmlElementContentPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
973: return(NULL);
974: }
975: static void des_xmlElementContentPtr(int no ATTRIBUTE_UNUSED, xmlElementContentPtr val, int nr ATTRIBUTE_UNUSED) {
976: if (val != NULL)
977: xmlFreeElementContent(val);
978: }
979: static void desret_xmlElementContentPtr(xmlElementContentPtr val) {
980: if (val != NULL)
981: xmlFreeElementContent(val);
982: }
983:
984: #define gen_nb_xmlParserNodeInfoSeqPtr 1
985: static xmlParserNodeInfoSeqPtr gen_xmlParserNodeInfoSeqPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
986: return(NULL);
987: }
988: static void des_xmlParserNodeInfoSeqPtr(int no ATTRIBUTE_UNUSED, xmlParserNodeInfoSeqPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
989: }
990:
991: static void desret_const_xmlParserNodeInfo_ptr(const xmlParserNodeInfo *val ATTRIBUTE_UNUSED) {
992: }
993:
994: #define gen_nb_void_ptr_ptr 1
995: static void ** gen_void_ptr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
996: return(NULL);
997: }
998: static void des_void_ptr_ptr(int no ATTRIBUTE_UNUSED, void ** val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
999: }
1000:
1001: /************************************************************************
1002: * *
1003: * WARNING: end of the manually maintained part of the test code *
1004: * do not remove or alter the CUT HERE line *
1005: * *
1006: ************************************************************************/
1007:
1008: /* CUT HERE: everything below that line is generated */
1009: #ifdef LIBXML_HTML_ENABLED
1010: static void desret_htmlStatus(htmlStatus val ATTRIBUTE_UNUSED) {
1011: }
1012:
1013: #endif
1014:
1015: #define gen_nb_xmlAttributeDefault 4
1016: static xmlAttributeDefault gen_xmlAttributeDefault(int no, int nr ATTRIBUTE_UNUSED) {
1017: if (no == 1) return(XML_ATTRIBUTE_FIXED);
1018: if (no == 2) return(XML_ATTRIBUTE_IMPLIED);
1019: if (no == 3) return(XML_ATTRIBUTE_NONE);
1020: if (no == 4) return(XML_ATTRIBUTE_REQUIRED);
1021: return(0);
1022: }
1023:
1024: static void des_xmlAttributeDefault(int no ATTRIBUTE_UNUSED, xmlAttributeDefault val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1025: }
1026:
1027: #define gen_nb_xmlAttributeType 4
1028: static xmlAttributeType gen_xmlAttributeType(int no, int nr ATTRIBUTE_UNUSED) {
1029: if (no == 1) return(XML_ATTRIBUTE_CDATA);
1030: if (no == 2) return(XML_ATTRIBUTE_ENTITIES);
1031: if (no == 3) return(XML_ATTRIBUTE_ENTITY);
1032: if (no == 4) return(XML_ATTRIBUTE_ENUMERATION);
1033: return(0);
1034: }
1035:
1036: static void des_xmlAttributeType(int no ATTRIBUTE_UNUSED, xmlAttributeType val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1037: }
1038:
1039: #define gen_nb_xmlBufferAllocationScheme 4
1040: static xmlBufferAllocationScheme gen_xmlBufferAllocationScheme(int no, int nr ATTRIBUTE_UNUSED) {
1041: if (no == 1) return(XML_BUFFER_ALLOC_DOUBLEIT);
1042: if (no == 2) return(XML_BUFFER_ALLOC_EXACT);
1043: if (no == 3) return(XML_BUFFER_ALLOC_IMMUTABLE);
1044: if (no == 4) return(XML_BUFFER_ALLOC_IO);
1045: return(0);
1046: }
1047:
1048: static void des_xmlBufferAllocationScheme(int no ATTRIBUTE_UNUSED, xmlBufferAllocationScheme val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1049: }
1050:
1051: static void desret_xmlBufferAllocationScheme(xmlBufferAllocationScheme val ATTRIBUTE_UNUSED) {
1052: }
1053:
1054: #ifdef LIBXML_CATALOG_ENABLED
1055: #define gen_nb_xmlCatalogAllow 4
1056: static xmlCatalogAllow gen_xmlCatalogAllow(int no, int nr ATTRIBUTE_UNUSED) {
1057: if (no == 1) return(XML_CATA_ALLOW_ALL);
1058: if (no == 2) return(XML_CATA_ALLOW_DOCUMENT);
1059: if (no == 3) return(XML_CATA_ALLOW_GLOBAL);
1060: if (no == 4) return(XML_CATA_ALLOW_NONE);
1061: return(0);
1062: }
1063:
1064: static void des_xmlCatalogAllow(int no ATTRIBUTE_UNUSED, xmlCatalogAllow val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1065: }
1066:
1067: static void desret_xmlCatalogAllow(xmlCatalogAllow val ATTRIBUTE_UNUSED) {
1068: }
1069:
1070: #endif
1071:
1072: #ifdef LIBXML_CATALOG_ENABLED
1073: #define gen_nb_xmlCatalogPrefer 3
1074: static xmlCatalogPrefer gen_xmlCatalogPrefer(int no, int nr ATTRIBUTE_UNUSED) {
1075: if (no == 1) return(XML_CATA_PREFER_NONE);
1076: if (no == 2) return(XML_CATA_PREFER_PUBLIC);
1077: if (no == 3) return(XML_CATA_PREFER_SYSTEM);
1078: return(0);
1079: }
1080:
1081: static void des_xmlCatalogPrefer(int no ATTRIBUTE_UNUSED, xmlCatalogPrefer val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1082: }
1083:
1084: static void desret_xmlCatalogPrefer(xmlCatalogPrefer val ATTRIBUTE_UNUSED) {
1085: }
1086:
1087: #endif
1088:
1089: #define gen_nb_xmlElementContentType 4
1090: static xmlElementContentType gen_xmlElementContentType(int no, int nr ATTRIBUTE_UNUSED) {
1091: if (no == 1) return(XML_ELEMENT_CONTENT_ELEMENT);
1092: if (no == 2) return(XML_ELEMENT_CONTENT_OR);
1093: if (no == 3) return(XML_ELEMENT_CONTENT_PCDATA);
1094: if (no == 4) return(XML_ELEMENT_CONTENT_SEQ);
1095: return(0);
1096: }
1097:
1098: static void des_xmlElementContentType(int no ATTRIBUTE_UNUSED, xmlElementContentType val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1099: }
1100:
1101: #define gen_nb_xmlElementTypeVal 4
1102: static xmlElementTypeVal gen_xmlElementTypeVal(int no, int nr ATTRIBUTE_UNUSED) {
1103: if (no == 1) return(XML_ELEMENT_TYPE_ANY);
1104: if (no == 2) return(XML_ELEMENT_TYPE_ELEMENT);
1105: if (no == 3) return(XML_ELEMENT_TYPE_EMPTY);
1106: if (no == 4) return(XML_ELEMENT_TYPE_MIXED);
1107: return(0);
1108: }
1109:
1110: static void des_xmlElementTypeVal(int no ATTRIBUTE_UNUSED, xmlElementTypeVal val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1111: }
1112:
1113: #define gen_nb_xmlFeature 4
1114: static xmlFeature gen_xmlFeature(int no, int nr ATTRIBUTE_UNUSED) {
1115: if (no == 1) return(XML_WITH_AUTOMATA);
1116: if (no == 2) return(XML_WITH_C14N);
1117: if (no == 3) return(XML_WITH_CATALOG);
1118: if (no == 4) return(XML_WITH_DEBUG);
1119: return(0);
1120: }
1121:
1122: static void des_xmlFeature(int no ATTRIBUTE_UNUSED, xmlFeature val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1123: }
1124:
1125: static void desret_xmlParserErrors(xmlParserErrors val ATTRIBUTE_UNUSED) {
1126: }
1127:
1128: #ifdef LIBXML_SCHEMAS_ENABLED
1129: #define gen_nb_xmlSchemaValType 4
1130: static xmlSchemaValType gen_xmlSchemaValType(int no, int nr ATTRIBUTE_UNUSED) {
1131: if (no == 1) return(XML_SCHEMAS_ANYSIMPLETYPE);
1132: if (no == 2) return(XML_SCHEMAS_ANYTYPE);
1133: if (no == 3) return(XML_SCHEMAS_ANYURI);
1134: if (no == 4) return(XML_SCHEMAS_BASE64BINARY);
1135: return(0);
1136: }
1137:
1138: static void des_xmlSchemaValType(int no ATTRIBUTE_UNUSED, xmlSchemaValType val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1139: }
1140:
1141: static void desret_xmlSchemaValType(xmlSchemaValType val ATTRIBUTE_UNUSED) {
1142: }
1143:
1144: #endif
1145:
1146: #ifdef LIBXML_SCHEMAS_ENABLED
1147: #define gen_nb_xmlSchemaWhitespaceValueType 4
1148: static xmlSchemaWhitespaceValueType gen_xmlSchemaWhitespaceValueType(int no, int nr ATTRIBUTE_UNUSED) {
1149: if (no == 1) return(XML_SCHEMA_WHITESPACE_COLLAPSE);
1150: if (no == 2) return(XML_SCHEMA_WHITESPACE_PRESERVE);
1151: if (no == 3) return(XML_SCHEMA_WHITESPACE_REPLACE);
1152: if (no == 4) return(XML_SCHEMA_WHITESPACE_UNKNOWN);
1153: return(0);
1154: }
1155:
1156: static void des_xmlSchemaWhitespaceValueType(int no ATTRIBUTE_UNUSED, xmlSchemaWhitespaceValueType val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1157: }
1158:
1159: #endif
1160:
1161: #include <libxml/HTMLparser.h>
1162: #include <libxml/HTMLtree.h>
1163: #include <libxml/SAX2.h>
1164: #include <libxml/c14n.h>
1165: #include <libxml/catalog.h>
1166: #include <libxml/chvalid.h>
1167: #include <libxml/debugXML.h>
1168: #include <libxml/dict.h>
1169: #include <libxml/encoding.h>
1170: #include <libxml/entities.h>
1171: #include <libxml/hash.h>
1172: #include <libxml/list.h>
1173: #include <libxml/nanoftp.h>
1174: #include <libxml/nanohttp.h>
1175: #include <libxml/parser.h>
1176: #include <libxml/parserInternals.h>
1177: #include <libxml/pattern.h>
1178: #include <libxml/relaxng.h>
1179: #include <libxml/schemasInternals.h>
1180: #include <libxml/schematron.h>
1181: #include <libxml/tree.h>
1182: #include <libxml/uri.h>
1183: #include <libxml/valid.h>
1184: #include <libxml/xinclude.h>
1185: #include <libxml/xmlIO.h>
1186: #include <libxml/xmlautomata.h>
1187: #include <libxml/xmlerror.h>
1188: #include <libxml/xmlmodule.h>
1189: #include <libxml/xmlreader.h>
1190: #include <libxml/xmlregexp.h>
1191: #include <libxml/xmlsave.h>
1192: #include <libxml/xmlschemas.h>
1193: #include <libxml/xmlschemastypes.h>
1194: #include <libxml/xmlstring.h>
1195: #include <libxml/xmlunicode.h>
1196: #include <libxml/xmlwriter.h>
1197: #include <libxml/xpath.h>
1198: #include <libxml/xpathInternals.h>
1199: #include <libxml/xpointer.h>
1200: static int test_HTMLparser(void);
1201: static int test_HTMLtree(void);
1202: static int test_SAX2(void);
1203: static int test_c14n(void);
1204: static int test_catalog(void);
1205: static int test_chvalid(void);
1206: static int test_debugXML(void);
1207: static int test_dict(void);
1208: static int test_encoding(void);
1209: static int test_entities(void);
1210: static int test_hash(void);
1211: static int test_list(void);
1212: static int test_nanoftp(void);
1213: static int test_nanohttp(void);
1214: static int test_parser(void);
1215: static int test_parserInternals(void);
1216: static int test_pattern(void);
1217: static int test_relaxng(void);
1218: static int test_schemasInternals(void);
1219: static int test_schematron(void);
1220: static int test_tree(void);
1221: static int test_uri(void);
1222: static int test_valid(void);
1223: static int test_xinclude(void);
1224: static int test_xmlIO(void);
1225: static int test_xmlautomata(void);
1226: static int test_xmlerror(void);
1227: static int test_xmlmodule(void);
1228: static int test_xmlreader(void);
1229: static int test_xmlregexp(void);
1230: static int test_xmlsave(void);
1231: static int test_xmlschemas(void);
1232: static int test_xmlschemastypes(void);
1233: static int test_xmlstring(void);
1234: static int test_xmlunicode(void);
1235: static int test_xmlwriter(void);
1236: static int test_xpath(void);
1237: static int test_xpathInternals(void);
1238: static int test_xpointer(void);
1239:
1240: /**
1241: * testlibxml2:
1242: *
1243: * Main entry point of the tester for the full libxml2 module,
1244: * it calls all the tester entry point for each module.
1245: *
1246: * Returns the number of error found
1247: */
1248: static int
1249: testlibxml2(void)
1250: {
1251: int test_ret = 0;
1252:
1253: test_ret += test_HTMLparser();
1254: test_ret += test_HTMLtree();
1255: test_ret += test_SAX2();
1256: test_ret += test_c14n();
1257: test_ret += test_catalog();
1258: test_ret += test_chvalid();
1259: test_ret += test_debugXML();
1260: test_ret += test_dict();
1261: test_ret += test_encoding();
1262: test_ret += test_entities();
1263: test_ret += test_hash();
1264: test_ret += test_list();
1265: test_ret += test_nanoftp();
1266: test_ret += test_nanohttp();
1267: test_ret += test_parser();
1268: test_ret += test_parserInternals();
1269: test_ret += test_pattern();
1270: test_ret += test_relaxng();
1271: test_ret += test_schemasInternals();
1272: test_ret += test_schematron();
1273: test_ret += test_tree();
1274: test_ret += test_uri();
1275: test_ret += test_valid();
1276: test_ret += test_xinclude();
1277: test_ret += test_xmlIO();
1278: test_ret += test_xmlautomata();
1279: test_ret += test_xmlerror();
1280: test_ret += test_xmlmodule();
1281: test_ret += test_xmlreader();
1282: test_ret += test_xmlregexp();
1283: test_ret += test_xmlsave();
1284: test_ret += test_xmlschemas();
1285: test_ret += test_xmlschemastypes();
1286: test_ret += test_xmlstring();
1287: test_ret += test_xmlunicode();
1288: test_ret += test_xmlwriter();
1289: test_ret += test_xpath();
1290: test_ret += test_xpathInternals();
1291: test_ret += test_xpointer();
1292:
1293: printf("Total: %d functions, %d tests, %d errors\n",
1294: function_tests, call_tests, test_ret);
1295: return(test_ret);
1296: }
1297:
1298:
1299: static int
1300: test_UTF8ToHtml(void) {
1301: int test_ret = 0;
1302:
1303: #if defined(LIBXML_HTML_ENABLED)
1304: int mem_base;
1305: int ret_val;
1306: unsigned char * out; /* a pointer to an array of bytes to store the result */
1307: int n_out;
1308: int * outlen; /* the length of @out */
1309: int n_outlen;
1310: unsigned char * in; /* a pointer to an array of UTF-8 chars */
1311: int n_in;
1312: int * inlen; /* the length of @in */
1313: int n_inlen;
1314:
1315: for (n_out = 0;n_out < gen_nb_unsigned_char_ptr;n_out++) {
1316: for (n_outlen = 0;n_outlen < gen_nb_int_ptr;n_outlen++) {
1317: for (n_in = 0;n_in < gen_nb_const_unsigned_char_ptr;n_in++) {
1318: for (n_inlen = 0;n_inlen < gen_nb_int_ptr;n_inlen++) {
1319: mem_base = xmlMemBlocks();
1320: out = gen_unsigned_char_ptr(n_out, 0);
1321: outlen = gen_int_ptr(n_outlen, 1);
1322: in = gen_const_unsigned_char_ptr(n_in, 2);
1323: inlen = gen_int_ptr(n_inlen, 3);
1324:
1325: ret_val = UTF8ToHtml(out, outlen, (const unsigned char *)in, inlen);
1326: desret_int(ret_val);
1327: call_tests++;
1328: des_unsigned_char_ptr(n_out, out, 0);
1329: des_int_ptr(n_outlen, outlen, 1);
1330: des_const_unsigned_char_ptr(n_in, (const unsigned char *)in, 2);
1331: des_int_ptr(n_inlen, inlen, 3);
1332: xmlResetLastError();
1333: if (mem_base != xmlMemBlocks()) {
1334: printf("Leak of %d blocks found in UTF8ToHtml",
1335: xmlMemBlocks() - mem_base);
1336: test_ret++;
1337: printf(" %d", n_out);
1338: printf(" %d", n_outlen);
1339: printf(" %d", n_in);
1340: printf(" %d", n_inlen);
1341: printf("\n");
1342: }
1343: }
1344: }
1345: }
1346: }
1347: function_tests++;
1348: #endif
1349:
1350: return(test_ret);
1351: }
1352:
1353: #ifdef LIBXML_HTML_ENABLED
1354:
1355: #define gen_nb_const_htmlElemDesc_ptr 1
1356: static htmlElemDesc * gen_const_htmlElemDesc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1357: return(NULL);
1358: }
1359: static void des_const_htmlElemDesc_ptr(int no ATTRIBUTE_UNUSED, const htmlElemDesc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1360: }
1361: #endif
1362:
1363:
1364: static int
1365: test_htmlAttrAllowed(void) {
1366: int test_ret = 0;
1367:
1368: #if defined(LIBXML_HTML_ENABLED)
1369: int mem_base;
1370: htmlStatus ret_val;
1371: htmlElemDesc * elt; /* HTML element */
1372: int n_elt;
1373: xmlChar * attr; /* HTML attribute */
1374: int n_attr;
1375: int legacy; /* whether to allow deprecated attributes */
1376: int n_legacy;
1377:
1378: for (n_elt = 0;n_elt < gen_nb_const_htmlElemDesc_ptr;n_elt++) {
1379: for (n_attr = 0;n_attr < gen_nb_const_xmlChar_ptr;n_attr++) {
1380: for (n_legacy = 0;n_legacy < gen_nb_int;n_legacy++) {
1381: mem_base = xmlMemBlocks();
1382: elt = gen_const_htmlElemDesc_ptr(n_elt, 0);
1383: attr = gen_const_xmlChar_ptr(n_attr, 1);
1384: legacy = gen_int(n_legacy, 2);
1385:
1386: ret_val = htmlAttrAllowed((const htmlElemDesc *)elt, (const xmlChar *)attr, legacy);
1387: desret_htmlStatus(ret_val);
1388: call_tests++;
1389: des_const_htmlElemDesc_ptr(n_elt, (const htmlElemDesc *)elt, 0);
1390: des_const_xmlChar_ptr(n_attr, (const xmlChar *)attr, 1);
1391: des_int(n_legacy, legacy, 2);
1392: xmlResetLastError();
1393: if (mem_base != xmlMemBlocks()) {
1394: printf("Leak of %d blocks found in htmlAttrAllowed",
1395: xmlMemBlocks() - mem_base);
1396: test_ret++;
1397: printf(" %d", n_elt);
1398: printf(" %d", n_attr);
1399: printf(" %d", n_legacy);
1400: printf("\n");
1401: }
1402: }
1403: }
1404: }
1405: function_tests++;
1406: #endif
1407:
1408: return(test_ret);
1409: }
1410:
1411: #ifdef LIBXML_HTML_ENABLED
1412:
1413: #define gen_nb_htmlNodePtr 1
1414: static htmlNodePtr gen_htmlNodePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1415: return(NULL);
1416: }
1417: static void des_htmlNodePtr(int no ATTRIBUTE_UNUSED, htmlNodePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1418: }
1419: #endif
1420:
1421:
1422: static int
1423: test_htmlAutoCloseTag(void) {
1424: int test_ret = 0;
1425:
1426: #if defined(LIBXML_HTML_ENABLED)
1427: int mem_base;
1428: int ret_val;
1429: htmlDocPtr doc; /* the HTML document */
1430: int n_doc;
1431: xmlChar * name; /* The tag name */
1432: int n_name;
1433: htmlNodePtr elem; /* the HTML element */
1434: int n_elem;
1435:
1436: for (n_doc = 0;n_doc < gen_nb_htmlDocPtr;n_doc++) {
1437: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
1438: for (n_elem = 0;n_elem < gen_nb_htmlNodePtr;n_elem++) {
1439: mem_base = xmlMemBlocks();
1440: doc = gen_htmlDocPtr(n_doc, 0);
1441: name = gen_const_xmlChar_ptr(n_name, 1);
1442: elem = gen_htmlNodePtr(n_elem, 2);
1443:
1444: ret_val = htmlAutoCloseTag(doc, (const xmlChar *)name, elem);
1445: desret_int(ret_val);
1446: call_tests++;
1447: des_htmlDocPtr(n_doc, doc, 0);
1448: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
1449: des_htmlNodePtr(n_elem, elem, 2);
1450: xmlResetLastError();
1451: if (mem_base != xmlMemBlocks()) {
1452: printf("Leak of %d blocks found in htmlAutoCloseTag",
1453: xmlMemBlocks() - mem_base);
1454: test_ret++;
1455: printf(" %d", n_doc);
1456: printf(" %d", n_name);
1457: printf(" %d", n_elem);
1458: printf("\n");
1459: }
1460: }
1461: }
1462: }
1463: function_tests++;
1464: #endif
1465:
1466: return(test_ret);
1467: }
1468:
1469:
1470: static int
1471: test_htmlCreateMemoryParserCtxt(void) {
1472: int test_ret = 0;
1473:
1474: #if defined(LIBXML_HTML_ENABLED)
1475: int mem_base;
1476: htmlParserCtxtPtr ret_val;
1477: char * buffer; /* a pointer to a char array */
1478: int n_buffer;
1479: int size; /* the size of the array */
1480: int n_size;
1481:
1482: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
1483: for (n_size = 0;n_size < gen_nb_int;n_size++) {
1484: mem_base = xmlMemBlocks();
1485: buffer = gen_const_char_ptr(n_buffer, 0);
1486: size = gen_int(n_size, 1);
1487:
1488: ret_val = htmlCreateMemoryParserCtxt((const char *)buffer, size);
1489: desret_htmlParserCtxtPtr(ret_val);
1490: call_tests++;
1491: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
1492: des_int(n_size, size, 1);
1493: xmlResetLastError();
1494: if (mem_base != xmlMemBlocks()) {
1495: printf("Leak of %d blocks found in htmlCreateMemoryParserCtxt",
1496: xmlMemBlocks() - mem_base);
1497: test_ret++;
1498: printf(" %d", n_buffer);
1499: printf(" %d", n_size);
1500: printf("\n");
1501: }
1502: }
1503: }
1504: function_tests++;
1505: #endif
1506:
1507: return(test_ret);
1508: }
1509:
1510: #ifdef LIBXML_HTML_ENABLED
1511:
1512: #define gen_nb_htmlSAXHandlerPtr 1
1513: static htmlSAXHandlerPtr gen_htmlSAXHandlerPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1514: return(NULL);
1515: }
1516: static void des_htmlSAXHandlerPtr(int no ATTRIBUTE_UNUSED, htmlSAXHandlerPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1517: }
1518: #endif
1519:
1520:
1521: static int
1522: test_htmlCreatePushParserCtxt(void) {
1523: int test_ret = 0;
1524:
1525: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_PUSH_ENABLED)
1526: int mem_base;
1527: htmlParserCtxtPtr ret_val;
1528: htmlSAXHandlerPtr sax; /* a SAX handler */
1529: int n_sax;
1530: void * user_data; /* The user data returned on SAX callbacks */
1531: int n_user_data;
1532: char * chunk; /* a pointer to an array of chars */
1533: int n_chunk;
1534: int size; /* number of chars in the array */
1535: int n_size;
1536: const char * filename; /* an optional file name or URI */
1537: int n_filename;
1538: xmlCharEncoding enc; /* an optional encoding */
1539: int n_enc;
1540:
1541: for (n_sax = 0;n_sax < gen_nb_htmlSAXHandlerPtr;n_sax++) {
1542: for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
1543: for (n_chunk = 0;n_chunk < gen_nb_const_char_ptr;n_chunk++) {
1544: for (n_size = 0;n_size < gen_nb_int;n_size++) {
1545: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
1546: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
1547: mem_base = xmlMemBlocks();
1548: sax = gen_htmlSAXHandlerPtr(n_sax, 0);
1549: user_data = gen_userdata(n_user_data, 1);
1550: chunk = gen_const_char_ptr(n_chunk, 2);
1551: size = gen_int(n_size, 3);
1552: filename = gen_fileoutput(n_filename, 4);
1553: enc = gen_xmlCharEncoding(n_enc, 5);
1554:
1555: ret_val = htmlCreatePushParserCtxt(sax, user_data, (const char *)chunk, size, filename, enc);
1556: desret_htmlParserCtxtPtr(ret_val);
1557: call_tests++;
1558: des_htmlSAXHandlerPtr(n_sax, sax, 0);
1559: des_userdata(n_user_data, user_data, 1);
1560: des_const_char_ptr(n_chunk, (const char *)chunk, 2);
1561: des_int(n_size, size, 3);
1562: des_fileoutput(n_filename, filename, 4);
1563: des_xmlCharEncoding(n_enc, enc, 5);
1564: xmlResetLastError();
1565: if (mem_base != xmlMemBlocks()) {
1566: printf("Leak of %d blocks found in htmlCreatePushParserCtxt",
1567: xmlMemBlocks() - mem_base);
1568: test_ret++;
1569: printf(" %d", n_sax);
1570: printf(" %d", n_user_data);
1571: printf(" %d", n_chunk);
1572: printf(" %d", n_size);
1573: printf(" %d", n_filename);
1574: printf(" %d", n_enc);
1575: printf("\n");
1576: }
1577: }
1578: }
1579: }
1580: }
1581: }
1582: }
1583: function_tests++;
1584: #endif
1585:
1586: return(test_ret);
1587: }
1588:
1589:
1590: static int
1591: test_htmlCtxtReadDoc(void) {
1592: int test_ret = 0;
1593:
1594: #if defined(LIBXML_HTML_ENABLED)
1595: int mem_base;
1596: htmlDocPtr ret_val;
1597: htmlParserCtxtPtr ctxt; /* an HTML parser context */
1598: int n_ctxt;
1599: xmlChar * cur; /* a pointer to a zero terminated string */
1600: int n_cur;
1601: const char * URL; /* the base URL to use for the document */
1602: int n_URL;
1603: char * encoding; /* the document encoding, or NULL */
1604: int n_encoding;
1605: int options; /* a combination of htmlParserOption(s) */
1606: int n_options;
1607:
1608: for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
1609: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
1610: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
1611: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
1612: for (n_options = 0;n_options < gen_nb_int;n_options++) {
1613: mem_base = xmlMemBlocks();
1614: ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
1615: cur = gen_const_xmlChar_ptr(n_cur, 1);
1616: URL = gen_filepath(n_URL, 2);
1617: encoding = gen_const_char_ptr(n_encoding, 3);
1618: options = gen_int(n_options, 4);
1619:
1620: ret_val = htmlCtxtReadDoc(ctxt, (const xmlChar *)cur, URL, (const char *)encoding, options);
1621: desret_htmlDocPtr(ret_val);
1622: call_tests++;
1623: des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
1624: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 1);
1625: des_filepath(n_URL, URL, 2);
1626: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
1627: des_int(n_options, options, 4);
1628: xmlResetLastError();
1629: if (mem_base != xmlMemBlocks()) {
1630: printf("Leak of %d blocks found in htmlCtxtReadDoc",
1631: xmlMemBlocks() - mem_base);
1632: test_ret++;
1633: printf(" %d", n_ctxt);
1634: printf(" %d", n_cur);
1635: printf(" %d", n_URL);
1636: printf(" %d", n_encoding);
1637: printf(" %d", n_options);
1638: printf("\n");
1639: }
1640: }
1641: }
1642: }
1643: }
1644: }
1645: function_tests++;
1646: #endif
1647:
1648: return(test_ret);
1649: }
1650:
1651:
1652: static int
1653: test_htmlCtxtReadFile(void) {
1654: int test_ret = 0;
1655:
1656: #if defined(LIBXML_HTML_ENABLED)
1657: htmlDocPtr ret_val;
1658: htmlParserCtxtPtr ctxt; /* an HTML parser context */
1659: int n_ctxt;
1660: const char * filename; /* a file or URL */
1661: int n_filename;
1662: char * encoding; /* the document encoding, or NULL */
1663: int n_encoding;
1664: int options; /* a combination of htmlParserOption(s) */
1665: int n_options;
1666:
1667: for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
1668: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
1669: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
1670: for (n_options = 0;n_options < gen_nb_int;n_options++) {
1671: ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
1672: filename = gen_filepath(n_filename, 1);
1673: encoding = gen_const_char_ptr(n_encoding, 2);
1674: options = gen_int(n_options, 3);
1675:
1676: ret_val = htmlCtxtReadFile(ctxt, filename, (const char *)encoding, options);
1677: desret_htmlDocPtr(ret_val);
1678: call_tests++;
1679: des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
1680: des_filepath(n_filename, filename, 1);
1681: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
1682: des_int(n_options, options, 3);
1683: xmlResetLastError();
1684: }
1685: }
1686: }
1687: }
1688: function_tests++;
1689: #endif
1690:
1691: return(test_ret);
1692: }
1693:
1694:
1695: static int
1696: test_htmlCtxtReadMemory(void) {
1697: int test_ret = 0;
1698:
1699: #if defined(LIBXML_HTML_ENABLED)
1700: int mem_base;
1701: htmlDocPtr ret_val;
1702: htmlParserCtxtPtr ctxt; /* an HTML parser context */
1703: int n_ctxt;
1704: char * buffer; /* a pointer to a char array */
1705: int n_buffer;
1706: int size; /* the size of the array */
1707: int n_size;
1708: const char * URL; /* the base URL to use for the document */
1709: int n_URL;
1710: char * encoding; /* the document encoding, or NULL */
1711: int n_encoding;
1712: int options; /* a combination of htmlParserOption(s) */
1713: int n_options;
1714:
1715: for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
1716: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
1717: for (n_size = 0;n_size < gen_nb_int;n_size++) {
1718: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
1719: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
1720: for (n_options = 0;n_options < gen_nb_int;n_options++) {
1721: mem_base = xmlMemBlocks();
1722: ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
1723: buffer = gen_const_char_ptr(n_buffer, 1);
1724: size = gen_int(n_size, 2);
1725: URL = gen_filepath(n_URL, 3);
1726: encoding = gen_const_char_ptr(n_encoding, 4);
1727: options = gen_int(n_options, 5);
1728:
1729: ret_val = htmlCtxtReadMemory(ctxt, (const char *)buffer, size, URL, (const char *)encoding, options);
1730: desret_htmlDocPtr(ret_val);
1731: call_tests++;
1732: des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
1733: des_const_char_ptr(n_buffer, (const char *)buffer, 1);
1734: des_int(n_size, size, 2);
1735: des_filepath(n_URL, URL, 3);
1736: des_const_char_ptr(n_encoding, (const char *)encoding, 4);
1737: des_int(n_options, options, 5);
1738: xmlResetLastError();
1739: if (mem_base != xmlMemBlocks()) {
1740: printf("Leak of %d blocks found in htmlCtxtReadMemory",
1741: xmlMemBlocks() - mem_base);
1742: test_ret++;
1743: printf(" %d", n_ctxt);
1744: printf(" %d", n_buffer);
1745: printf(" %d", n_size);
1746: printf(" %d", n_URL);
1747: printf(" %d", n_encoding);
1748: printf(" %d", n_options);
1749: printf("\n");
1750: }
1751: }
1752: }
1753: }
1754: }
1755: }
1756: }
1757: function_tests++;
1758: #endif
1759:
1760: return(test_ret);
1761: }
1762:
1763:
1764: static int
1765: test_htmlCtxtReset(void) {
1766: int test_ret = 0;
1767:
1768: #if defined(LIBXML_HTML_ENABLED)
1769: int mem_base;
1770: htmlParserCtxtPtr ctxt; /* an HTML parser context */
1771: int n_ctxt;
1772:
1773: for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
1774: mem_base = xmlMemBlocks();
1775: ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
1776:
1777: htmlCtxtReset(ctxt);
1778: call_tests++;
1779: des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
1780: xmlResetLastError();
1781: if (mem_base != xmlMemBlocks()) {
1782: printf("Leak of %d blocks found in htmlCtxtReset",
1783: xmlMemBlocks() - mem_base);
1784: test_ret++;
1785: printf(" %d", n_ctxt);
1786: printf("\n");
1787: }
1788: }
1789: function_tests++;
1790: #endif
1791:
1792: return(test_ret);
1793: }
1794:
1795:
1796: static int
1797: test_htmlCtxtUseOptions(void) {
1798: int test_ret = 0;
1799:
1800: #if defined(LIBXML_HTML_ENABLED)
1801: int mem_base;
1802: int ret_val;
1803: htmlParserCtxtPtr ctxt; /* an HTML parser context */
1804: int n_ctxt;
1805: int options; /* a combination of htmlParserOption(s) */
1806: int n_options;
1807:
1808: for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
1809: for (n_options = 0;n_options < gen_nb_int;n_options++) {
1810: mem_base = xmlMemBlocks();
1811: ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
1812: options = gen_int(n_options, 1);
1813:
1814: ret_val = htmlCtxtUseOptions(ctxt, options);
1815: desret_int(ret_val);
1816: call_tests++;
1817: des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
1818: des_int(n_options, options, 1);
1819: xmlResetLastError();
1820: if (mem_base != xmlMemBlocks()) {
1821: printf("Leak of %d blocks found in htmlCtxtUseOptions",
1822: xmlMemBlocks() - mem_base);
1823: test_ret++;
1824: printf(" %d", n_ctxt);
1825: printf(" %d", n_options);
1826: printf("\n");
1827: }
1828: }
1829: }
1830: function_tests++;
1831: #endif
1832:
1833: return(test_ret);
1834: }
1835:
1836:
1837: static int
1838: test_htmlElementAllowedHere(void) {
1839: int test_ret = 0;
1840:
1841: #if defined(LIBXML_HTML_ENABLED)
1842: int mem_base;
1843: int ret_val;
1844: htmlElemDesc * parent; /* HTML parent element */
1845: int n_parent;
1846: xmlChar * elt; /* HTML element */
1847: int n_elt;
1848:
1849: for (n_parent = 0;n_parent < gen_nb_const_htmlElemDesc_ptr;n_parent++) {
1850: for (n_elt = 0;n_elt < gen_nb_const_xmlChar_ptr;n_elt++) {
1851: mem_base = xmlMemBlocks();
1852: parent = gen_const_htmlElemDesc_ptr(n_parent, 0);
1853: elt = gen_const_xmlChar_ptr(n_elt, 1);
1854:
1855: ret_val = htmlElementAllowedHere((const htmlElemDesc *)parent, (const xmlChar *)elt);
1856: desret_int(ret_val);
1857: call_tests++;
1858: des_const_htmlElemDesc_ptr(n_parent, (const htmlElemDesc *)parent, 0);
1859: des_const_xmlChar_ptr(n_elt, (const xmlChar *)elt, 1);
1860: xmlResetLastError();
1861: if (mem_base != xmlMemBlocks()) {
1862: printf("Leak of %d blocks found in htmlElementAllowedHere",
1863: xmlMemBlocks() - mem_base);
1864: test_ret++;
1865: printf(" %d", n_parent);
1866: printf(" %d", n_elt);
1867: printf("\n");
1868: }
1869: }
1870: }
1871: function_tests++;
1872: #endif
1873:
1874: return(test_ret);
1875: }
1876:
1877:
1878: static int
1879: test_htmlElementStatusHere(void) {
1880: int test_ret = 0;
1881:
1882: #if defined(LIBXML_HTML_ENABLED)
1883: int mem_base;
1884: htmlStatus ret_val;
1885: htmlElemDesc * parent; /* HTML parent element */
1886: int n_parent;
1887: htmlElemDesc * elt; /* HTML element */
1888: int n_elt;
1889:
1890: for (n_parent = 0;n_parent < gen_nb_const_htmlElemDesc_ptr;n_parent++) {
1891: for (n_elt = 0;n_elt < gen_nb_const_htmlElemDesc_ptr;n_elt++) {
1892: mem_base = xmlMemBlocks();
1893: parent = gen_const_htmlElemDesc_ptr(n_parent, 0);
1894: elt = gen_const_htmlElemDesc_ptr(n_elt, 1);
1895:
1896: ret_val = htmlElementStatusHere((const htmlElemDesc *)parent, (const htmlElemDesc *)elt);
1897: desret_htmlStatus(ret_val);
1898: call_tests++;
1899: des_const_htmlElemDesc_ptr(n_parent, (const htmlElemDesc *)parent, 0);
1900: des_const_htmlElemDesc_ptr(n_elt, (const htmlElemDesc *)elt, 1);
1901: xmlResetLastError();
1902: if (mem_base != xmlMemBlocks()) {
1903: printf("Leak of %d blocks found in htmlElementStatusHere",
1904: xmlMemBlocks() - mem_base);
1905: test_ret++;
1906: printf(" %d", n_parent);
1907: printf(" %d", n_elt);
1908: printf("\n");
1909: }
1910: }
1911: }
1912: function_tests++;
1913: #endif
1914:
1915: return(test_ret);
1916: }
1917:
1918:
1919: static int
1920: test_htmlEncodeEntities(void) {
1921: int test_ret = 0;
1922:
1923: #if defined(LIBXML_HTML_ENABLED)
1924: int mem_base;
1925: int ret_val;
1926: unsigned char * out; /* a pointer to an array of bytes to store the result */
1927: int n_out;
1928: int * outlen; /* the length of @out */
1929: int n_outlen;
1930: unsigned char * in; /* a pointer to an array of UTF-8 chars */
1931: int n_in;
1932: int * inlen; /* the length of @in */
1933: int n_inlen;
1934: int quoteChar; /* the quote character to escape (' or ") or zero. */
1935: int n_quoteChar;
1936:
1937: for (n_out = 0;n_out < gen_nb_unsigned_char_ptr;n_out++) {
1938: for (n_outlen = 0;n_outlen < gen_nb_int_ptr;n_outlen++) {
1939: for (n_in = 0;n_in < gen_nb_const_unsigned_char_ptr;n_in++) {
1940: for (n_inlen = 0;n_inlen < gen_nb_int_ptr;n_inlen++) {
1941: for (n_quoteChar = 0;n_quoteChar < gen_nb_int;n_quoteChar++) {
1942: mem_base = xmlMemBlocks();
1943: out = gen_unsigned_char_ptr(n_out, 0);
1944: outlen = gen_int_ptr(n_outlen, 1);
1945: in = gen_const_unsigned_char_ptr(n_in, 2);
1946: inlen = gen_int_ptr(n_inlen, 3);
1947: quoteChar = gen_int(n_quoteChar, 4);
1948:
1949: ret_val = htmlEncodeEntities(out, outlen, (const unsigned char *)in, inlen, quoteChar);
1950: desret_int(ret_val);
1951: call_tests++;
1952: des_unsigned_char_ptr(n_out, out, 0);
1953: des_int_ptr(n_outlen, outlen, 1);
1954: des_const_unsigned_char_ptr(n_in, (const unsigned char *)in, 2);
1955: des_int_ptr(n_inlen, inlen, 3);
1956: des_int(n_quoteChar, quoteChar, 4);
1957: xmlResetLastError();
1958: if (mem_base != xmlMemBlocks()) {
1959: printf("Leak of %d blocks found in htmlEncodeEntities",
1960: xmlMemBlocks() - mem_base);
1961: test_ret++;
1962: printf(" %d", n_out);
1963: printf(" %d", n_outlen);
1964: printf(" %d", n_in);
1965: printf(" %d", n_inlen);
1966: printf(" %d", n_quoteChar);
1967: printf("\n");
1968: }
1969: }
1970: }
1971: }
1972: }
1973: }
1974: function_tests++;
1975: #endif
1976:
1977: return(test_ret);
1978: }
1979:
1980:
1981: static int
1982: test_htmlEntityLookup(void) {
1983: int test_ret = 0;
1984:
1985: #if defined(LIBXML_HTML_ENABLED)
1986: int mem_base;
1987: const htmlEntityDesc * ret_val;
1988: xmlChar * name; /* the entity name */
1989: int n_name;
1990:
1991: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
1992: mem_base = xmlMemBlocks();
1993: name = gen_const_xmlChar_ptr(n_name, 0);
1994:
1995: ret_val = htmlEntityLookup((const xmlChar *)name);
1996: desret_const_htmlEntityDesc_ptr(ret_val);
1997: call_tests++;
1998: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
1999: xmlResetLastError();
2000: if (mem_base != xmlMemBlocks()) {
2001: printf("Leak of %d blocks found in htmlEntityLookup",
2002: xmlMemBlocks() - mem_base);
2003: test_ret++;
2004: printf(" %d", n_name);
2005: printf("\n");
2006: }
2007: }
2008: function_tests++;
2009: #endif
2010:
2011: return(test_ret);
2012: }
2013:
2014:
2015: static int
2016: test_htmlEntityValueLookup(void) {
2017: int test_ret = 0;
2018:
2019: #if defined(LIBXML_HTML_ENABLED)
2020: int mem_base;
2021: const htmlEntityDesc * ret_val;
2022: unsigned int value; /* the entity's unicode value */
2023: int n_value;
2024:
2025: for (n_value = 0;n_value < gen_nb_unsigned_int;n_value++) {
2026: mem_base = xmlMemBlocks();
2027: value = gen_unsigned_int(n_value, 0);
2028:
2029: ret_val = htmlEntityValueLookup(value);
2030: desret_const_htmlEntityDesc_ptr(ret_val);
2031: call_tests++;
2032: des_unsigned_int(n_value, value, 0);
2033: xmlResetLastError();
2034: if (mem_base != xmlMemBlocks()) {
2035: printf("Leak of %d blocks found in htmlEntityValueLookup",
2036: xmlMemBlocks() - mem_base);
2037: test_ret++;
2038: printf(" %d", n_value);
2039: printf("\n");
2040: }
2041: }
2042: function_tests++;
2043: #endif
2044:
2045: return(test_ret);
2046: }
2047:
2048:
2049: static int
2050: test_htmlHandleOmittedElem(void) {
2051: int test_ret = 0;
2052:
2053: #if defined(LIBXML_HTML_ENABLED)
2054: int mem_base;
2055: int ret_val;
2056: int val; /* int 0 or 1 */
2057: int n_val;
2058:
2059: for (n_val = 0;n_val < gen_nb_int;n_val++) {
2060: mem_base = xmlMemBlocks();
2061: val = gen_int(n_val, 0);
2062:
2063: ret_val = htmlHandleOmittedElem(val);
2064: desret_int(ret_val);
2065: call_tests++;
2066: des_int(n_val, val, 0);
2067: xmlResetLastError();
2068: if (mem_base != xmlMemBlocks()) {
2069: printf("Leak of %d blocks found in htmlHandleOmittedElem",
2070: xmlMemBlocks() - mem_base);
2071: test_ret++;
2072: printf(" %d", n_val);
2073: printf("\n");
2074: }
2075: }
2076: function_tests++;
2077: #endif
2078:
2079: return(test_ret);
2080: }
2081:
2082:
2083: static int
2084: test_htmlIsAutoClosed(void) {
2085: int test_ret = 0;
2086:
2087: #if defined(LIBXML_HTML_ENABLED)
2088: int mem_base;
2089: int ret_val;
2090: htmlDocPtr doc; /* the HTML document */
2091: int n_doc;
2092: htmlNodePtr elem; /* the HTML element */
2093: int n_elem;
2094:
2095: for (n_doc = 0;n_doc < gen_nb_htmlDocPtr;n_doc++) {
2096: for (n_elem = 0;n_elem < gen_nb_htmlNodePtr;n_elem++) {
2097: mem_base = xmlMemBlocks();
2098: doc = gen_htmlDocPtr(n_doc, 0);
2099: elem = gen_htmlNodePtr(n_elem, 1);
2100:
2101: ret_val = htmlIsAutoClosed(doc, elem);
2102: desret_int(ret_val);
2103: call_tests++;
2104: des_htmlDocPtr(n_doc, doc, 0);
2105: des_htmlNodePtr(n_elem, elem, 1);
2106: xmlResetLastError();
2107: if (mem_base != xmlMemBlocks()) {
2108: printf("Leak of %d blocks found in htmlIsAutoClosed",
2109: xmlMemBlocks() - mem_base);
2110: test_ret++;
2111: printf(" %d", n_doc);
2112: printf(" %d", n_elem);
2113: printf("\n");
2114: }
2115: }
2116: }
2117: function_tests++;
2118: #endif
2119:
2120: return(test_ret);
2121: }
2122:
2123:
2124: static int
2125: test_htmlIsScriptAttribute(void) {
2126: int test_ret = 0;
2127:
2128: #if defined(LIBXML_HTML_ENABLED)
2129: int mem_base;
2130: int ret_val;
2131: xmlChar * name; /* an attribute name */
2132: int n_name;
2133:
2134: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
2135: mem_base = xmlMemBlocks();
2136: name = gen_const_xmlChar_ptr(n_name, 0);
2137:
2138: ret_val = htmlIsScriptAttribute((const xmlChar *)name);
2139: desret_int(ret_val);
2140: call_tests++;
2141: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
2142: xmlResetLastError();
2143: if (mem_base != xmlMemBlocks()) {
2144: printf("Leak of %d blocks found in htmlIsScriptAttribute",
2145: xmlMemBlocks() - mem_base);
2146: test_ret++;
2147: printf(" %d", n_name);
2148: printf("\n");
2149: }
2150: }
2151: function_tests++;
2152: #endif
2153:
2154: return(test_ret);
2155: }
2156:
2157:
2158: static int
2159: test_htmlNewParserCtxt(void) {
2160: int test_ret = 0;
2161:
2162: #if defined(LIBXML_HTML_ENABLED)
2163: int mem_base;
2164: htmlParserCtxtPtr ret_val;
2165:
2166: mem_base = xmlMemBlocks();
2167:
2168: ret_val = htmlNewParserCtxt();
2169: desret_htmlParserCtxtPtr(ret_val);
2170: call_tests++;
2171: xmlResetLastError();
2172: if (mem_base != xmlMemBlocks()) {
2173: printf("Leak of %d blocks found in htmlNewParserCtxt",
2174: xmlMemBlocks() - mem_base);
2175: test_ret++;
2176: printf("\n");
2177: }
2178: function_tests++;
2179: #endif
2180:
2181: return(test_ret);
2182: }
2183:
2184:
2185: static int
2186: test_htmlNodeStatus(void) {
2187: int test_ret = 0;
2188:
2189: #if defined(LIBXML_HTML_ENABLED)
2190: int mem_base;
2191: htmlStatus ret_val;
2192: htmlNodePtr node; /* an htmlNodePtr in a tree */
2193: int n_node;
2194: int legacy; /* whether to allow deprecated elements (YES is faster here for Element nodes) */
2195: int n_legacy;
2196:
2197: for (n_node = 0;n_node < gen_nb_const_htmlNodePtr;n_node++) {
2198: for (n_legacy = 0;n_legacy < gen_nb_int;n_legacy++) {
2199: mem_base = xmlMemBlocks();
2200: node = gen_const_htmlNodePtr(n_node, 0);
2201: legacy = gen_int(n_legacy, 1);
2202:
2203: ret_val = htmlNodeStatus((const htmlNodePtr)node, legacy);
2204: desret_htmlStatus(ret_val);
2205: call_tests++;
2206: des_const_htmlNodePtr(n_node, (const htmlNodePtr)node, 0);
2207: des_int(n_legacy, legacy, 1);
2208: xmlResetLastError();
2209: if (mem_base != xmlMemBlocks()) {
2210: printf("Leak of %d blocks found in htmlNodeStatus",
2211: xmlMemBlocks() - mem_base);
2212: test_ret++;
2213: printf(" %d", n_node);
2214: printf(" %d", n_legacy);
2215: printf("\n");
2216: }
2217: }
2218: }
2219: function_tests++;
2220: #endif
2221:
2222: return(test_ret);
2223: }
2224:
2225:
2226: static int
2227: test_htmlParseCharRef(void) {
2228: int test_ret = 0;
2229:
2230: #if defined(LIBXML_HTML_ENABLED)
2231: int mem_base;
2232: int ret_val;
2233: htmlParserCtxtPtr ctxt; /* an HTML parser context */
2234: int n_ctxt;
2235:
2236: for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
2237: mem_base = xmlMemBlocks();
2238: ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
2239:
2240: ret_val = htmlParseCharRef(ctxt);
2241: desret_int(ret_val);
2242: call_tests++;
2243: des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
2244: xmlResetLastError();
2245: if (mem_base != xmlMemBlocks()) {
2246: printf("Leak of %d blocks found in htmlParseCharRef",
2247: xmlMemBlocks() - mem_base);
2248: test_ret++;
2249: printf(" %d", n_ctxt);
2250: printf("\n");
2251: }
2252: }
2253: function_tests++;
2254: #endif
2255:
2256: return(test_ret);
2257: }
2258:
2259:
2260: static int
2261: test_htmlParseChunk(void) {
2262: int test_ret = 0;
2263:
2264: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_PUSH_ENABLED)
2265: int mem_base;
2266: int ret_val;
2267: htmlParserCtxtPtr ctxt; /* an HTML parser context */
2268: int n_ctxt;
2269: char * chunk; /* an char array */
2270: int n_chunk;
2271: int size; /* the size in byte of the chunk */
2272: int n_size;
2273: int terminate; /* last chunk indicator */
2274: int n_terminate;
2275:
2276: for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
2277: for (n_chunk = 0;n_chunk < gen_nb_const_char_ptr;n_chunk++) {
2278: for (n_size = 0;n_size < gen_nb_int;n_size++) {
2279: for (n_terminate = 0;n_terminate < gen_nb_int;n_terminate++) {
2280: mem_base = xmlMemBlocks();
2281: ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
2282: chunk = gen_const_char_ptr(n_chunk, 1);
2283: size = gen_int(n_size, 2);
2284: terminate = gen_int(n_terminate, 3);
2285:
2286: ret_val = htmlParseChunk(ctxt, (const char *)chunk, size, terminate);
2287: if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;}
2288: desret_int(ret_val);
2289: call_tests++;
2290: des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
2291: des_const_char_ptr(n_chunk, (const char *)chunk, 1);
2292: des_int(n_size, size, 2);
2293: des_int(n_terminate, terminate, 3);
2294: xmlResetLastError();
2295: if (mem_base != xmlMemBlocks()) {
2296: printf("Leak of %d blocks found in htmlParseChunk",
2297: xmlMemBlocks() - mem_base);
2298: test_ret++;
2299: printf(" %d", n_ctxt);
2300: printf(" %d", n_chunk);
2301: printf(" %d", n_size);
2302: printf(" %d", n_terminate);
2303: printf("\n");
2304: }
2305: }
2306: }
2307: }
2308: }
2309: function_tests++;
2310: #endif
2311:
2312: return(test_ret);
2313: }
2314:
2315:
2316: static int
2317: test_htmlParseDoc(void) {
2318: int test_ret = 0;
2319:
2320: #if defined(LIBXML_HTML_ENABLED)
2321: int mem_base;
2322: htmlDocPtr ret_val;
2323: xmlChar * cur; /* a pointer to an array of xmlChar */
2324: int n_cur;
2325: char * encoding; /* a free form C string describing the HTML document encoding, or NULL */
2326: int n_encoding;
2327:
2328: for (n_cur = 0;n_cur < gen_nb_xmlChar_ptr;n_cur++) {
2329: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
2330: mem_base = xmlMemBlocks();
2331: cur = gen_xmlChar_ptr(n_cur, 0);
2332: encoding = gen_const_char_ptr(n_encoding, 1);
2333:
2334: ret_val = htmlParseDoc(cur, (const char *)encoding);
2335: desret_htmlDocPtr(ret_val);
2336: call_tests++;
2337: des_xmlChar_ptr(n_cur, cur, 0);
2338: des_const_char_ptr(n_encoding, (const char *)encoding, 1);
2339: xmlResetLastError();
2340: if (mem_base != xmlMemBlocks()) {
2341: printf("Leak of %d blocks found in htmlParseDoc",
2342: xmlMemBlocks() - mem_base);
2343: test_ret++;
2344: printf(" %d", n_cur);
2345: printf(" %d", n_encoding);
2346: printf("\n");
2347: }
2348: }
2349: }
2350: function_tests++;
2351: #endif
2352:
2353: return(test_ret);
2354: }
2355:
2356:
2357: static int
2358: test_htmlParseDocument(void) {
2359: int test_ret = 0;
2360:
2361: #if defined(LIBXML_HTML_ENABLED)
2362: int mem_base;
2363: int ret_val;
2364: htmlParserCtxtPtr ctxt; /* an HTML parser context */
2365: int n_ctxt;
2366:
2367: for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
2368: mem_base = xmlMemBlocks();
2369: ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
2370:
2371: ret_val = htmlParseDocument(ctxt);
2372: if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;}
2373: desret_int(ret_val);
2374: call_tests++;
2375: des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
2376: xmlResetLastError();
2377: if (mem_base != xmlMemBlocks()) {
2378: printf("Leak of %d blocks found in htmlParseDocument",
2379: xmlMemBlocks() - mem_base);
2380: test_ret++;
2381: printf(" %d", n_ctxt);
2382: printf("\n");
2383: }
2384: }
2385: function_tests++;
2386: #endif
2387:
2388: return(test_ret);
2389: }
2390:
2391:
2392: static int
2393: test_htmlParseElement(void) {
2394: int test_ret = 0;
2395:
2396: #if defined(LIBXML_HTML_ENABLED)
2397: int mem_base;
2398: htmlParserCtxtPtr ctxt; /* an HTML parser context */
2399: int n_ctxt;
2400:
2401: for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
2402: mem_base = xmlMemBlocks();
2403: ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
2404:
2405: htmlParseElement(ctxt);
2406: call_tests++;
2407: des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
2408: xmlResetLastError();
2409: if (mem_base != xmlMemBlocks()) {
2410: printf("Leak of %d blocks found in htmlParseElement",
2411: xmlMemBlocks() - mem_base);
2412: test_ret++;
2413: printf(" %d", n_ctxt);
2414: printf("\n");
2415: }
2416: }
2417: function_tests++;
2418: #endif
2419:
2420: return(test_ret);
2421: }
2422:
2423:
2424: static int
2425: test_htmlParseEntityRef(void) {
2426: int test_ret = 0;
2427:
2428: #if defined(LIBXML_HTML_ENABLED)
2429: int mem_base;
2430: const htmlEntityDesc * ret_val;
2431: htmlParserCtxtPtr ctxt; /* an HTML parser context */
2432: int n_ctxt;
2433: xmlChar ** str; /* location to store the entity name */
2434: int n_str;
2435:
2436: for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
2437: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr_ptr;n_str++) {
2438: mem_base = xmlMemBlocks();
2439: ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
2440: str = gen_const_xmlChar_ptr_ptr(n_str, 1);
2441:
2442: ret_val = htmlParseEntityRef(ctxt, (const xmlChar **)str);
2443: desret_const_htmlEntityDesc_ptr(ret_val);
2444: call_tests++;
2445: des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
2446: des_const_xmlChar_ptr_ptr(n_str, (const xmlChar **)str, 1);
2447: xmlResetLastError();
2448: if (mem_base != xmlMemBlocks()) {
2449: printf("Leak of %d blocks found in htmlParseEntityRef",
2450: xmlMemBlocks() - mem_base);
2451: test_ret++;
2452: printf(" %d", n_ctxt);
2453: printf(" %d", n_str);
2454: printf("\n");
2455: }
2456: }
2457: }
2458: function_tests++;
2459: #endif
2460:
2461: return(test_ret);
2462: }
2463:
2464:
2465: static int
2466: test_htmlParseFile(void) {
2467: int test_ret = 0;
2468:
2469: #if defined(LIBXML_HTML_ENABLED)
2470: htmlDocPtr ret_val;
2471: const char * filename; /* the filename */
2472: int n_filename;
2473: char * encoding; /* a free form C string describing the HTML document encoding, or NULL */
2474: int n_encoding;
2475:
2476: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
2477: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
2478: filename = gen_filepath(n_filename, 0);
2479: encoding = gen_const_char_ptr(n_encoding, 1);
2480:
2481: ret_val = htmlParseFile(filename, (const char *)encoding);
2482: desret_htmlDocPtr(ret_val);
2483: call_tests++;
2484: des_filepath(n_filename, filename, 0);
2485: des_const_char_ptr(n_encoding, (const char *)encoding, 1);
2486: xmlResetLastError();
2487: }
2488: }
2489: function_tests++;
2490: #endif
2491:
2492: return(test_ret);
2493: }
2494:
2495:
2496: static int
2497: test_htmlReadDoc(void) {
2498: int test_ret = 0;
2499:
2500: #if defined(LIBXML_HTML_ENABLED)
2501: int mem_base;
2502: htmlDocPtr ret_val;
2503: xmlChar * cur; /* a pointer to a zero terminated string */
2504: int n_cur;
2505: const char * URL; /* the base URL to use for the document */
2506: int n_URL;
2507: char * encoding; /* the document encoding, or NULL */
2508: int n_encoding;
2509: int options; /* a combination of htmlParserOption(s) */
2510: int n_options;
2511:
2512: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
2513: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
2514: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
2515: for (n_options = 0;n_options < gen_nb_int;n_options++) {
2516: mem_base = xmlMemBlocks();
2517: cur = gen_const_xmlChar_ptr(n_cur, 0);
2518: URL = gen_filepath(n_URL, 1);
2519: encoding = gen_const_char_ptr(n_encoding, 2);
2520: options = gen_int(n_options, 3);
2521:
2522: ret_val = htmlReadDoc((const xmlChar *)cur, URL, (const char *)encoding, options);
2523: desret_htmlDocPtr(ret_val);
2524: call_tests++;
2525: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
2526: des_filepath(n_URL, URL, 1);
2527: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
2528: des_int(n_options, options, 3);
2529: xmlResetLastError();
2530: if (mem_base != xmlMemBlocks()) {
2531: printf("Leak of %d blocks found in htmlReadDoc",
2532: xmlMemBlocks() - mem_base);
2533: test_ret++;
2534: printf(" %d", n_cur);
2535: printf(" %d", n_URL);
2536: printf(" %d", n_encoding);
2537: printf(" %d", n_options);
2538: printf("\n");
2539: }
2540: }
2541: }
2542: }
2543: }
2544: function_tests++;
2545: #endif
2546:
2547: return(test_ret);
2548: }
2549:
2550:
2551: static int
2552: test_htmlReadFile(void) {
2553: int test_ret = 0;
2554:
2555: #if defined(LIBXML_HTML_ENABLED)
2556: int mem_base;
2557: htmlDocPtr ret_val;
2558: const char * filename; /* a file or URL */
2559: int n_filename;
2560: char * encoding; /* the document encoding, or NULL */
2561: int n_encoding;
2562: int options; /* a combination of htmlParserOption(s) */
2563: int n_options;
2564:
2565: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
2566: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
2567: for (n_options = 0;n_options < gen_nb_int;n_options++) {
2568: mem_base = xmlMemBlocks();
2569: filename = gen_filepath(n_filename, 0);
2570: encoding = gen_const_char_ptr(n_encoding, 1);
2571: options = gen_int(n_options, 2);
2572:
2573: ret_val = htmlReadFile(filename, (const char *)encoding, options);
2574: desret_htmlDocPtr(ret_val);
2575: call_tests++;
2576: des_filepath(n_filename, filename, 0);
2577: des_const_char_ptr(n_encoding, (const char *)encoding, 1);
2578: des_int(n_options, options, 2);
2579: xmlResetLastError();
2580: if (mem_base != xmlMemBlocks()) {
2581: printf("Leak of %d blocks found in htmlReadFile",
2582: xmlMemBlocks() - mem_base);
2583: test_ret++;
2584: printf(" %d", n_filename);
2585: printf(" %d", n_encoding);
2586: printf(" %d", n_options);
2587: printf("\n");
2588: }
2589: }
2590: }
2591: }
2592: function_tests++;
2593: #endif
2594:
2595: return(test_ret);
2596: }
2597:
2598:
2599: static int
2600: test_htmlReadMemory(void) {
2601: int test_ret = 0;
2602:
2603: #if defined(LIBXML_HTML_ENABLED)
2604: int mem_base;
2605: htmlDocPtr ret_val;
2606: char * buffer; /* a pointer to a char array */
2607: int n_buffer;
2608: int size; /* the size of the array */
2609: int n_size;
2610: const char * URL; /* the base URL to use for the document */
2611: int n_URL;
2612: char * encoding; /* the document encoding, or NULL */
2613: int n_encoding;
2614: int options; /* a combination of htmlParserOption(s) */
2615: int n_options;
2616:
2617: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
2618: for (n_size = 0;n_size < gen_nb_int;n_size++) {
2619: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
2620: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
2621: for (n_options = 0;n_options < gen_nb_int;n_options++) {
2622: mem_base = xmlMemBlocks();
2623: buffer = gen_const_char_ptr(n_buffer, 0);
2624: size = gen_int(n_size, 1);
2625: URL = gen_filepath(n_URL, 2);
2626: encoding = gen_const_char_ptr(n_encoding, 3);
2627: options = gen_int(n_options, 4);
2628:
2629: ret_val = htmlReadMemory((const char *)buffer, size, URL, (const char *)encoding, options);
2630: desret_htmlDocPtr(ret_val);
2631: call_tests++;
2632: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
2633: des_int(n_size, size, 1);
2634: des_filepath(n_URL, URL, 2);
2635: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
2636: des_int(n_options, options, 4);
2637: xmlResetLastError();
2638: if (mem_base != xmlMemBlocks()) {
2639: printf("Leak of %d blocks found in htmlReadMemory",
2640: xmlMemBlocks() - mem_base);
2641: test_ret++;
2642: printf(" %d", n_buffer);
2643: printf(" %d", n_size);
2644: printf(" %d", n_URL);
2645: printf(" %d", n_encoding);
2646: printf(" %d", n_options);
2647: printf("\n");
2648: }
2649: }
2650: }
2651: }
2652: }
2653: }
2654: function_tests++;
2655: #endif
2656:
2657: return(test_ret);
2658: }
2659:
2660:
2661: static int
2662: test_htmlSAXParseDoc(void) {
2663: int test_ret = 0;
2664:
2665: #if defined(LIBXML_HTML_ENABLED)
2666: int mem_base;
2667: htmlDocPtr ret_val;
2668: xmlChar * cur; /* a pointer to an array of xmlChar */
2669: int n_cur;
2670: char * encoding; /* a free form C string describing the HTML document encoding, or NULL */
2671: int n_encoding;
2672: htmlSAXHandlerPtr sax; /* the SAX handler block */
2673: int n_sax;
2674: void * userData; /* if using SAX, this pointer will be provided on callbacks. */
2675: int n_userData;
2676:
2677: for (n_cur = 0;n_cur < gen_nb_xmlChar_ptr;n_cur++) {
2678: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
2679: for (n_sax = 0;n_sax < gen_nb_htmlSAXHandlerPtr;n_sax++) {
2680: for (n_userData = 0;n_userData < gen_nb_userdata;n_userData++) {
2681: mem_base = xmlMemBlocks();
2682: cur = gen_xmlChar_ptr(n_cur, 0);
2683: encoding = gen_const_char_ptr(n_encoding, 1);
2684: sax = gen_htmlSAXHandlerPtr(n_sax, 2);
2685: userData = gen_userdata(n_userData, 3);
2686:
2687: ret_val = htmlSAXParseDoc(cur, (const char *)encoding, sax, userData);
2688: desret_htmlDocPtr(ret_val);
2689: call_tests++;
2690: des_xmlChar_ptr(n_cur, cur, 0);
2691: des_const_char_ptr(n_encoding, (const char *)encoding, 1);
2692: des_htmlSAXHandlerPtr(n_sax, sax, 2);
2693: des_userdata(n_userData, userData, 3);
2694: xmlResetLastError();
2695: if (mem_base != xmlMemBlocks()) {
2696: printf("Leak of %d blocks found in htmlSAXParseDoc",
2697: xmlMemBlocks() - mem_base);
2698: test_ret++;
2699: printf(" %d", n_cur);
2700: printf(" %d", n_encoding);
2701: printf(" %d", n_sax);
2702: printf(" %d", n_userData);
2703: printf("\n");
2704: }
2705: }
2706: }
2707: }
2708: }
2709: function_tests++;
2710: #endif
2711:
2712: return(test_ret);
2713: }
2714:
2715:
2716: static int
2717: test_htmlSAXParseFile(void) {
2718: int test_ret = 0;
2719:
2720: #if defined(LIBXML_HTML_ENABLED)
2721: int mem_base;
2722: htmlDocPtr ret_val;
2723: const char * filename; /* the filename */
2724: int n_filename;
2725: char * encoding; /* a free form C string describing the HTML document encoding, or NULL */
2726: int n_encoding;
2727: htmlSAXHandlerPtr sax; /* the SAX handler block */
2728: int n_sax;
2729: void * userData; /* if using SAX, this pointer will be provided on callbacks. */
2730: int n_userData;
2731:
2732: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
2733: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
2734: for (n_sax = 0;n_sax < gen_nb_htmlSAXHandlerPtr;n_sax++) {
2735: for (n_userData = 0;n_userData < gen_nb_userdata;n_userData++) {
2736: mem_base = xmlMemBlocks();
2737: filename = gen_filepath(n_filename, 0);
2738: encoding = gen_const_char_ptr(n_encoding, 1);
2739: sax = gen_htmlSAXHandlerPtr(n_sax, 2);
2740: userData = gen_userdata(n_userData, 3);
2741:
2742: ret_val = htmlSAXParseFile(filename, (const char *)encoding, sax, userData);
2743: desret_htmlDocPtr(ret_val);
2744: call_tests++;
2745: des_filepath(n_filename, filename, 0);
2746: des_const_char_ptr(n_encoding, (const char *)encoding, 1);
2747: des_htmlSAXHandlerPtr(n_sax, sax, 2);
2748: des_userdata(n_userData, userData, 3);
2749: xmlResetLastError();
2750: if (mem_base != xmlMemBlocks()) {
2751: printf("Leak of %d blocks found in htmlSAXParseFile",
2752: xmlMemBlocks() - mem_base);
2753: test_ret++;
2754: printf(" %d", n_filename);
2755: printf(" %d", n_encoding);
2756: printf(" %d", n_sax);
2757: printf(" %d", n_userData);
2758: printf("\n");
2759: }
2760: }
2761: }
2762: }
2763: }
2764: function_tests++;
2765: #endif
2766:
2767: return(test_ret);
2768: }
2769:
2770:
2771: static int
2772: test_htmlTagLookup(void) {
2773: int test_ret = 0;
2774:
2775:
2776: /* missing type support */
2777: return(test_ret);
2778: }
2779:
2780: static int
2781: test_HTMLparser(void) {
2782: int test_ret = 0;
2783:
2784: if (quiet == 0) printf("Testing HTMLparser : 32 of 38 functions ...\n");
2785: test_ret += test_UTF8ToHtml();
2786: test_ret += test_htmlAttrAllowed();
2787: test_ret += test_htmlAutoCloseTag();
2788: test_ret += test_htmlCreateMemoryParserCtxt();
2789: test_ret += test_htmlCreatePushParserCtxt();
2790: test_ret += test_htmlCtxtReadDoc();
2791: test_ret += test_htmlCtxtReadFile();
2792: test_ret += test_htmlCtxtReadMemory();
2793: test_ret += test_htmlCtxtReset();
2794: test_ret += test_htmlCtxtUseOptions();
2795: test_ret += test_htmlElementAllowedHere();
2796: test_ret += test_htmlElementStatusHere();
2797: test_ret += test_htmlEncodeEntities();
2798: test_ret += test_htmlEntityLookup();
2799: test_ret += test_htmlEntityValueLookup();
2800: test_ret += test_htmlHandleOmittedElem();
2801: test_ret += test_htmlIsAutoClosed();
2802: test_ret += test_htmlIsScriptAttribute();
2803: test_ret += test_htmlNewParserCtxt();
2804: test_ret += test_htmlNodeStatus();
2805: test_ret += test_htmlParseCharRef();
2806: test_ret += test_htmlParseChunk();
2807: test_ret += test_htmlParseDoc();
2808: test_ret += test_htmlParseDocument();
2809: test_ret += test_htmlParseElement();
2810: test_ret += test_htmlParseEntityRef();
2811: test_ret += test_htmlParseFile();
2812: test_ret += test_htmlReadDoc();
2813: test_ret += test_htmlReadFile();
2814: test_ret += test_htmlReadMemory();
2815: test_ret += test_htmlSAXParseDoc();
2816: test_ret += test_htmlSAXParseFile();
2817: test_ret += test_htmlTagLookup();
2818:
2819: if (test_ret != 0)
2820: printf("Module HTMLparser: %d errors\n", test_ret);
2821: return(test_ret);
2822: }
2823:
2824: static int
2825: test_htmlDocContentDumpFormatOutput(void) {
2826: int test_ret = 0;
2827:
2828: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
2829: int mem_base;
2830: xmlOutputBufferPtr buf; /* the HTML buffer output */
2831: int n_buf;
2832: xmlDocPtr cur; /* the document */
2833: int n_cur;
2834: char * encoding; /* the encoding string */
2835: int n_encoding;
2836: int format; /* should formatting spaces been added */
2837: int n_format;
2838:
2839: for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
2840: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
2841: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
2842: for (n_format = 0;n_format < gen_nb_int;n_format++) {
2843: mem_base = xmlMemBlocks();
2844: buf = gen_xmlOutputBufferPtr(n_buf, 0);
2845: cur = gen_xmlDocPtr(n_cur, 1);
2846: encoding = gen_const_char_ptr(n_encoding, 2);
2847: format = gen_int(n_format, 3);
2848:
2849: htmlDocContentDumpFormatOutput(buf, cur, (const char *)encoding, format);
2850: call_tests++;
2851: des_xmlOutputBufferPtr(n_buf, buf, 0);
2852: des_xmlDocPtr(n_cur, cur, 1);
2853: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
2854: des_int(n_format, format, 3);
2855: xmlResetLastError();
2856: if (mem_base != xmlMemBlocks()) {
2857: printf("Leak of %d blocks found in htmlDocContentDumpFormatOutput",
2858: xmlMemBlocks() - mem_base);
2859: test_ret++;
2860: printf(" %d", n_buf);
2861: printf(" %d", n_cur);
2862: printf(" %d", n_encoding);
2863: printf(" %d", n_format);
2864: printf("\n");
2865: }
2866: }
2867: }
2868: }
2869: }
2870: function_tests++;
2871: #endif
2872:
2873: return(test_ret);
2874: }
2875:
2876:
2877: static int
2878: test_htmlDocContentDumpOutput(void) {
2879: int test_ret = 0;
2880:
2881: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
2882: int mem_base;
2883: xmlOutputBufferPtr buf; /* the HTML buffer output */
2884: int n_buf;
2885: xmlDocPtr cur; /* the document */
2886: int n_cur;
2887: char * encoding; /* the encoding string */
2888: int n_encoding;
2889:
2890: for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
2891: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
2892: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
2893: mem_base = xmlMemBlocks();
2894: buf = gen_xmlOutputBufferPtr(n_buf, 0);
2895: cur = gen_xmlDocPtr(n_cur, 1);
2896: encoding = gen_const_char_ptr(n_encoding, 2);
2897:
2898: htmlDocContentDumpOutput(buf, cur, (const char *)encoding);
2899: call_tests++;
2900: des_xmlOutputBufferPtr(n_buf, buf, 0);
2901: des_xmlDocPtr(n_cur, cur, 1);
2902: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
2903: xmlResetLastError();
2904: if (mem_base != xmlMemBlocks()) {
2905: printf("Leak of %d blocks found in htmlDocContentDumpOutput",
2906: xmlMemBlocks() - mem_base);
2907: test_ret++;
2908: printf(" %d", n_buf);
2909: printf(" %d", n_cur);
2910: printf(" %d", n_encoding);
2911: printf("\n");
2912: }
2913: }
2914: }
2915: }
2916: function_tests++;
2917: #endif
2918:
2919: return(test_ret);
2920: }
2921:
2922:
2923: static int
2924: test_htmlDocDump(void) {
2925: int test_ret = 0;
2926:
2927: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
2928: int mem_base;
2929: int ret_val;
2930: FILE * f; /* the FILE* */
2931: int n_f;
2932: xmlDocPtr cur; /* the document */
2933: int n_cur;
2934:
2935: for (n_f = 0;n_f < gen_nb_FILE_ptr;n_f++) {
2936: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
2937: mem_base = xmlMemBlocks();
2938: f = gen_FILE_ptr(n_f, 0);
2939: cur = gen_xmlDocPtr(n_cur, 1);
2940:
2941: ret_val = htmlDocDump(f, cur);
2942: desret_int(ret_val);
2943: call_tests++;
2944: des_FILE_ptr(n_f, f, 0);
2945: des_xmlDocPtr(n_cur, cur, 1);
2946: xmlResetLastError();
2947: if (mem_base != xmlMemBlocks()) {
2948: printf("Leak of %d blocks found in htmlDocDump",
2949: xmlMemBlocks() - mem_base);
2950: test_ret++;
2951: printf(" %d", n_f);
2952: printf(" %d", n_cur);
2953: printf("\n");
2954: }
2955: }
2956: }
2957: function_tests++;
2958: #endif
2959:
2960: return(test_ret);
2961: }
2962:
2963:
2964: #define gen_nb_xmlChar_ptr_ptr 1
2965: static xmlChar ** gen_xmlChar_ptr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
2966: return(NULL);
2967: }
2968: static void des_xmlChar_ptr_ptr(int no ATTRIBUTE_UNUSED, xmlChar ** val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
2969: }
2970:
2971: static int
2972: test_htmlDocDumpMemory(void) {
2973: int test_ret = 0;
2974:
2975: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
2976: int mem_base;
2977: xmlDocPtr cur; /* the document */
2978: int n_cur;
2979: xmlChar ** mem; /* OUT: the memory pointer */
2980: int n_mem;
2981: int * size; /* OUT: the memory length */
2982: int n_size;
2983:
2984: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
2985: for (n_mem = 0;n_mem < gen_nb_xmlChar_ptr_ptr;n_mem++) {
2986: for (n_size = 0;n_size < gen_nb_int_ptr;n_size++) {
2987: mem_base = xmlMemBlocks();
2988: cur = gen_xmlDocPtr(n_cur, 0);
2989: mem = gen_xmlChar_ptr_ptr(n_mem, 1);
2990: size = gen_int_ptr(n_size, 2);
2991:
2992: htmlDocDumpMemory(cur, mem, size);
2993: call_tests++;
2994: des_xmlDocPtr(n_cur, cur, 0);
2995: des_xmlChar_ptr_ptr(n_mem, mem, 1);
2996: des_int_ptr(n_size, size, 2);
2997: xmlResetLastError();
2998: if (mem_base != xmlMemBlocks()) {
2999: printf("Leak of %d blocks found in htmlDocDumpMemory",
3000: xmlMemBlocks() - mem_base);
3001: test_ret++;
3002: printf(" %d", n_cur);
3003: printf(" %d", n_mem);
3004: printf(" %d", n_size);
3005: printf("\n");
3006: }
3007: }
3008: }
3009: }
3010: function_tests++;
3011: #endif
3012:
3013: return(test_ret);
3014: }
3015:
3016:
3017: static int
3018: test_htmlDocDumpMemoryFormat(void) {
3019: int test_ret = 0;
3020:
3021: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
3022: int mem_base;
3023: xmlDocPtr cur; /* the document */
3024: int n_cur;
3025: xmlChar ** mem; /* OUT: the memory pointer */
3026: int n_mem;
3027: int * size; /* OUT: the memory length */
3028: int n_size;
3029: int format; /* should formatting spaces been added */
3030: int n_format;
3031:
3032: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
3033: for (n_mem = 0;n_mem < gen_nb_xmlChar_ptr_ptr;n_mem++) {
3034: for (n_size = 0;n_size < gen_nb_int_ptr;n_size++) {
3035: for (n_format = 0;n_format < gen_nb_int;n_format++) {
3036: mem_base = xmlMemBlocks();
3037: cur = gen_xmlDocPtr(n_cur, 0);
3038: mem = gen_xmlChar_ptr_ptr(n_mem, 1);
3039: size = gen_int_ptr(n_size, 2);
3040: format = gen_int(n_format, 3);
3041:
3042: htmlDocDumpMemoryFormat(cur, mem, size, format);
3043: call_tests++;
3044: des_xmlDocPtr(n_cur, cur, 0);
3045: des_xmlChar_ptr_ptr(n_mem, mem, 1);
3046: des_int_ptr(n_size, size, 2);
3047: des_int(n_format, format, 3);
3048: xmlResetLastError();
3049: if (mem_base != xmlMemBlocks()) {
3050: printf("Leak of %d blocks found in htmlDocDumpMemoryFormat",
3051: xmlMemBlocks() - mem_base);
3052: test_ret++;
3053: printf(" %d", n_cur);
3054: printf(" %d", n_mem);
3055: printf(" %d", n_size);
3056: printf(" %d", n_format);
3057: printf("\n");
3058: }
3059: }
3060: }
3061: }
3062: }
3063: function_tests++;
3064: #endif
3065:
3066: return(test_ret);
3067: }
3068:
3069:
3070: static int
3071: test_htmlGetMetaEncoding(void) {
3072: int test_ret = 0;
3073:
3074: #if defined(LIBXML_HTML_ENABLED)
3075: int mem_base;
3076: const xmlChar * ret_val;
3077: htmlDocPtr doc; /* the document */
3078: int n_doc;
3079:
3080: for (n_doc = 0;n_doc < gen_nb_htmlDocPtr;n_doc++) {
3081: mem_base = xmlMemBlocks();
3082: doc = gen_htmlDocPtr(n_doc, 0);
3083:
3084: ret_val = htmlGetMetaEncoding(doc);
3085: desret_const_xmlChar_ptr(ret_val);
3086: call_tests++;
3087: des_htmlDocPtr(n_doc, doc, 0);
3088: xmlResetLastError();
3089: if (mem_base != xmlMemBlocks()) {
3090: printf("Leak of %d blocks found in htmlGetMetaEncoding",
3091: xmlMemBlocks() - mem_base);
3092: test_ret++;
3093: printf(" %d", n_doc);
3094: printf("\n");
3095: }
3096: }
3097: function_tests++;
3098: #endif
3099:
3100: return(test_ret);
3101: }
3102:
3103:
3104: static int
3105: test_htmlIsBooleanAttr(void) {
3106: int test_ret = 0;
3107:
3108: #if defined(LIBXML_HTML_ENABLED)
3109: int mem_base;
3110: int ret_val;
3111: xmlChar * name; /* the name of the attribute to check */
3112: int n_name;
3113:
3114: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
3115: mem_base = xmlMemBlocks();
3116: name = gen_const_xmlChar_ptr(n_name, 0);
3117:
3118: ret_val = htmlIsBooleanAttr((const xmlChar *)name);
3119: desret_int(ret_val);
3120: call_tests++;
3121: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
3122: xmlResetLastError();
3123: if (mem_base != xmlMemBlocks()) {
3124: printf("Leak of %d blocks found in htmlIsBooleanAttr",
3125: xmlMemBlocks() - mem_base);
3126: test_ret++;
3127: printf(" %d", n_name);
3128: printf("\n");
3129: }
3130: }
3131: function_tests++;
3132: #endif
3133:
3134: return(test_ret);
3135: }
3136:
3137:
3138: static int
3139: test_htmlNewDoc(void) {
3140: int test_ret = 0;
3141:
3142: #if defined(LIBXML_HTML_ENABLED)
3143: int mem_base;
3144: htmlDocPtr ret_val;
3145: xmlChar * URI; /* URI for the dtd, or NULL */
3146: int n_URI;
3147: xmlChar * ExternalID; /* the external ID of the DTD, or NULL */
3148: int n_ExternalID;
3149:
3150: for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
3151: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
3152: mem_base = xmlMemBlocks();
3153: URI = gen_const_xmlChar_ptr(n_URI, 0);
3154: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 1);
3155:
3156: ret_val = htmlNewDoc((const xmlChar *)URI, (const xmlChar *)ExternalID);
3157: desret_htmlDocPtr(ret_val);
3158: call_tests++;
3159: des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 0);
3160: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 1);
3161: xmlResetLastError();
3162: if (mem_base != xmlMemBlocks()) {
3163: printf("Leak of %d blocks found in htmlNewDoc",
3164: xmlMemBlocks() - mem_base);
3165: test_ret++;
3166: printf(" %d", n_URI);
3167: printf(" %d", n_ExternalID);
3168: printf("\n");
3169: }
3170: }
3171: }
3172: function_tests++;
3173: #endif
3174:
3175: return(test_ret);
3176: }
3177:
3178:
3179: static int
3180: test_htmlNewDocNoDtD(void) {
3181: int test_ret = 0;
3182:
3183: #if defined(LIBXML_HTML_ENABLED)
3184: int mem_base;
3185: htmlDocPtr ret_val;
3186: xmlChar * URI; /* URI for the dtd, or NULL */
3187: int n_URI;
3188: xmlChar * ExternalID; /* the external ID of the DTD, or NULL */
3189: int n_ExternalID;
3190:
3191: for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
3192: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
3193: mem_base = xmlMemBlocks();
3194: URI = gen_const_xmlChar_ptr(n_URI, 0);
3195: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 1);
3196:
3197: ret_val = htmlNewDocNoDtD((const xmlChar *)URI, (const xmlChar *)ExternalID);
3198: desret_htmlDocPtr(ret_val);
3199: call_tests++;
3200: des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 0);
3201: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 1);
3202: xmlResetLastError();
3203: if (mem_base != xmlMemBlocks()) {
3204: printf("Leak of %d blocks found in htmlNewDocNoDtD",
3205: xmlMemBlocks() - mem_base);
3206: test_ret++;
3207: printf(" %d", n_URI);
3208: printf(" %d", n_ExternalID);
3209: printf("\n");
3210: }
3211: }
3212: }
3213: function_tests++;
3214: #endif
3215:
3216: return(test_ret);
3217: }
3218:
3219:
3220: static int
3221: test_htmlNodeDump(void) {
3222: int test_ret = 0;
3223:
3224: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
3225: int mem_base;
3226: int ret_val;
3227: xmlBufferPtr buf; /* the HTML buffer output */
3228: int n_buf;
3229: xmlDocPtr doc; /* the document */
3230: int n_doc;
3231: xmlNodePtr cur; /* the current node */
3232: int n_cur;
3233:
3234: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
3235: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
3236: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
3237: mem_base = xmlMemBlocks();
3238: buf = gen_xmlBufferPtr(n_buf, 0);
3239: doc = gen_xmlDocPtr(n_doc, 1);
3240: cur = gen_xmlNodePtr(n_cur, 2);
3241:
3242: ret_val = htmlNodeDump(buf, doc, cur);
3243: desret_int(ret_val);
3244: call_tests++;
3245: des_xmlBufferPtr(n_buf, buf, 0);
3246: des_xmlDocPtr(n_doc, doc, 1);
3247: des_xmlNodePtr(n_cur, cur, 2);
3248: xmlResetLastError();
3249: if (mem_base != xmlMemBlocks()) {
3250: printf("Leak of %d blocks found in htmlNodeDump",
3251: xmlMemBlocks() - mem_base);
3252: test_ret++;
3253: printf(" %d", n_buf);
3254: printf(" %d", n_doc);
3255: printf(" %d", n_cur);
3256: printf("\n");
3257: }
3258: }
3259: }
3260: }
3261: function_tests++;
3262: #endif
3263:
3264: return(test_ret);
3265: }
3266:
3267:
3268: static int
3269: test_htmlNodeDumpFile(void) {
3270: int test_ret = 0;
3271:
3272: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
3273: int mem_base;
3274: FILE * out; /* the FILE pointer */
3275: int n_out;
3276: xmlDocPtr doc; /* the document */
3277: int n_doc;
3278: xmlNodePtr cur; /* the current node */
3279: int n_cur;
3280:
3281: for (n_out = 0;n_out < gen_nb_FILE_ptr;n_out++) {
3282: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
3283: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
3284: mem_base = xmlMemBlocks();
3285: out = gen_FILE_ptr(n_out, 0);
3286: doc = gen_xmlDocPtr(n_doc, 1);
3287: cur = gen_xmlNodePtr(n_cur, 2);
3288:
3289: htmlNodeDumpFile(out, doc, cur);
3290: call_tests++;
3291: des_FILE_ptr(n_out, out, 0);
3292: des_xmlDocPtr(n_doc, doc, 1);
3293: des_xmlNodePtr(n_cur, cur, 2);
3294: xmlResetLastError();
3295: if (mem_base != xmlMemBlocks()) {
3296: printf("Leak of %d blocks found in htmlNodeDumpFile",
3297: xmlMemBlocks() - mem_base);
3298: test_ret++;
3299: printf(" %d", n_out);
3300: printf(" %d", n_doc);
3301: printf(" %d", n_cur);
3302: printf("\n");
3303: }
3304: }
3305: }
3306: }
3307: function_tests++;
3308: #endif
3309:
3310: return(test_ret);
3311: }
3312:
3313:
3314: static int
3315: test_htmlNodeDumpFileFormat(void) {
3316: int test_ret = 0;
3317:
3318: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
3319: int mem_base;
3320: int ret_val;
3321: FILE * out; /* the FILE pointer */
3322: int n_out;
3323: xmlDocPtr doc; /* the document */
3324: int n_doc;
3325: xmlNodePtr cur; /* the current node */
3326: int n_cur;
3327: char * encoding; /* the document encoding */
3328: int n_encoding;
3329: int format; /* should formatting spaces been added */
3330: int n_format;
3331:
3332: for (n_out = 0;n_out < gen_nb_FILE_ptr;n_out++) {
3333: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
3334: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
3335: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
3336: for (n_format = 0;n_format < gen_nb_int;n_format++) {
3337: mem_base = xmlMemBlocks();
3338: out = gen_FILE_ptr(n_out, 0);
3339: doc = gen_xmlDocPtr(n_doc, 1);
3340: cur = gen_xmlNodePtr(n_cur, 2);
3341: encoding = gen_const_char_ptr(n_encoding, 3);
3342: format = gen_int(n_format, 4);
3343:
3344: ret_val = htmlNodeDumpFileFormat(out, doc, cur, (const char *)encoding, format);
3345: desret_int(ret_val);
3346: call_tests++;
3347: des_FILE_ptr(n_out, out, 0);
3348: des_xmlDocPtr(n_doc, doc, 1);
3349: des_xmlNodePtr(n_cur, cur, 2);
3350: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
3351: des_int(n_format, format, 4);
3352: xmlResetLastError();
3353: if (mem_base != xmlMemBlocks()) {
3354: printf("Leak of %d blocks found in htmlNodeDumpFileFormat",
3355: xmlMemBlocks() - mem_base);
3356: test_ret++;
3357: printf(" %d", n_out);
3358: printf(" %d", n_doc);
3359: printf(" %d", n_cur);
3360: printf(" %d", n_encoding);
3361: printf(" %d", n_format);
3362: printf("\n");
3363: }
3364: }
3365: }
3366: }
3367: }
3368: }
3369: function_tests++;
3370: #endif
3371:
3372: return(test_ret);
3373: }
3374:
3375:
3376: static int
3377: test_htmlNodeDumpFormatOutput(void) {
3378: int test_ret = 0;
3379:
3380: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
3381: int mem_base;
3382: xmlOutputBufferPtr buf; /* the HTML buffer output */
3383: int n_buf;
3384: xmlDocPtr doc; /* the document */
3385: int n_doc;
3386: xmlNodePtr cur; /* the current node */
3387: int n_cur;
3388: char * encoding; /* the encoding string */
3389: int n_encoding;
3390: int format; /* should formatting spaces been added */
3391: int n_format;
3392:
3393: for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
3394: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
3395: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
3396: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
3397: for (n_format = 0;n_format < gen_nb_int;n_format++) {
3398: mem_base = xmlMemBlocks();
3399: buf = gen_xmlOutputBufferPtr(n_buf, 0);
3400: doc = gen_xmlDocPtr(n_doc, 1);
3401: cur = gen_xmlNodePtr(n_cur, 2);
3402: encoding = gen_const_char_ptr(n_encoding, 3);
3403: format = gen_int(n_format, 4);
3404:
3405: htmlNodeDumpFormatOutput(buf, doc, cur, (const char *)encoding, format);
3406: call_tests++;
3407: des_xmlOutputBufferPtr(n_buf, buf, 0);
3408: des_xmlDocPtr(n_doc, doc, 1);
3409: des_xmlNodePtr(n_cur, cur, 2);
3410: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
3411: des_int(n_format, format, 4);
3412: xmlResetLastError();
3413: if (mem_base != xmlMemBlocks()) {
3414: printf("Leak of %d blocks found in htmlNodeDumpFormatOutput",
3415: xmlMemBlocks() - mem_base);
3416: test_ret++;
3417: printf(" %d", n_buf);
3418: printf(" %d", n_doc);
3419: printf(" %d", n_cur);
3420: printf(" %d", n_encoding);
3421: printf(" %d", n_format);
3422: printf("\n");
3423: }
3424: }
3425: }
3426: }
3427: }
3428: }
3429: function_tests++;
3430: #endif
3431:
3432: return(test_ret);
3433: }
3434:
3435:
3436: static int
3437: test_htmlNodeDumpOutput(void) {
3438: int test_ret = 0;
3439:
3440: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
3441: int mem_base;
3442: xmlOutputBufferPtr buf; /* the HTML buffer output */
3443: int n_buf;
3444: xmlDocPtr doc; /* the document */
3445: int n_doc;
3446: xmlNodePtr cur; /* the current node */
3447: int n_cur;
3448: char * encoding; /* the encoding string */
3449: int n_encoding;
3450:
3451: for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
3452: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
3453: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
3454: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
3455: mem_base = xmlMemBlocks();
3456: buf = gen_xmlOutputBufferPtr(n_buf, 0);
3457: doc = gen_xmlDocPtr(n_doc, 1);
3458: cur = gen_xmlNodePtr(n_cur, 2);
3459: encoding = gen_const_char_ptr(n_encoding, 3);
3460:
3461: htmlNodeDumpOutput(buf, doc, cur, (const char *)encoding);
3462: call_tests++;
3463: des_xmlOutputBufferPtr(n_buf, buf, 0);
3464: des_xmlDocPtr(n_doc, doc, 1);
3465: des_xmlNodePtr(n_cur, cur, 2);
3466: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
3467: xmlResetLastError();
3468: if (mem_base != xmlMemBlocks()) {
3469: printf("Leak of %d blocks found in htmlNodeDumpOutput",
3470: xmlMemBlocks() - mem_base);
3471: test_ret++;
3472: printf(" %d", n_buf);
3473: printf(" %d", n_doc);
3474: printf(" %d", n_cur);
3475: printf(" %d", n_encoding);
3476: printf("\n");
3477: }
3478: }
3479: }
3480: }
3481: }
3482: function_tests++;
3483: #endif
3484:
3485: return(test_ret);
3486: }
3487:
3488:
3489: static int
3490: test_htmlSaveFile(void) {
3491: int test_ret = 0;
3492:
3493: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
3494: int mem_base;
3495: int ret_val;
3496: const char * filename; /* the filename (or URL) */
3497: int n_filename;
3498: xmlDocPtr cur; /* the document */
3499: int n_cur;
3500:
3501: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
3502: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
3503: mem_base = xmlMemBlocks();
3504: filename = gen_fileoutput(n_filename, 0);
3505: cur = gen_xmlDocPtr(n_cur, 1);
3506:
3507: ret_val = htmlSaveFile(filename, cur);
3508: desret_int(ret_val);
3509: call_tests++;
3510: des_fileoutput(n_filename, filename, 0);
3511: des_xmlDocPtr(n_cur, cur, 1);
3512: xmlResetLastError();
3513: if (mem_base != xmlMemBlocks()) {
3514: printf("Leak of %d blocks found in htmlSaveFile",
3515: xmlMemBlocks() - mem_base);
3516: test_ret++;
3517: printf(" %d", n_filename);
3518: printf(" %d", n_cur);
3519: printf("\n");
3520: }
3521: }
3522: }
3523: function_tests++;
3524: #endif
3525:
3526: return(test_ret);
3527: }
3528:
3529:
3530: static int
3531: test_htmlSaveFileEnc(void) {
3532: int test_ret = 0;
3533:
3534: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
3535: int mem_base;
3536: int ret_val;
3537: const char * filename; /* the filename */
3538: int n_filename;
3539: xmlDocPtr cur; /* the document */
3540: int n_cur;
3541: char * encoding; /* the document encoding */
3542: int n_encoding;
3543:
3544: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
3545: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
3546: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
3547: mem_base = xmlMemBlocks();
3548: filename = gen_fileoutput(n_filename, 0);
3549: cur = gen_xmlDocPtr(n_cur, 1);
3550: encoding = gen_const_char_ptr(n_encoding, 2);
3551:
3552: ret_val = htmlSaveFileEnc(filename, cur, (const char *)encoding);
3553: desret_int(ret_val);
3554: call_tests++;
3555: des_fileoutput(n_filename, filename, 0);
3556: des_xmlDocPtr(n_cur, cur, 1);
3557: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
3558: xmlResetLastError();
3559: if (mem_base != xmlMemBlocks()) {
3560: printf("Leak of %d blocks found in htmlSaveFileEnc",
3561: xmlMemBlocks() - mem_base);
3562: test_ret++;
3563: printf(" %d", n_filename);
3564: printf(" %d", n_cur);
3565: printf(" %d", n_encoding);
3566: printf("\n");
3567: }
3568: }
3569: }
3570: }
3571: function_tests++;
3572: #endif
3573:
3574: return(test_ret);
3575: }
3576:
3577:
3578: static int
3579: test_htmlSaveFileFormat(void) {
3580: int test_ret = 0;
3581:
3582: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
3583: int mem_base;
3584: int ret_val;
3585: const char * filename; /* the filename */
3586: int n_filename;
3587: xmlDocPtr cur; /* the document */
3588: int n_cur;
3589: char * encoding; /* the document encoding */
3590: int n_encoding;
3591: int format; /* should formatting spaces been added */
3592: int n_format;
3593:
3594: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
3595: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
3596: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
3597: for (n_format = 0;n_format < gen_nb_int;n_format++) {
3598: mem_base = xmlMemBlocks();
3599: filename = gen_fileoutput(n_filename, 0);
3600: cur = gen_xmlDocPtr(n_cur, 1);
3601: encoding = gen_const_char_ptr(n_encoding, 2);
3602: format = gen_int(n_format, 3);
3603:
3604: ret_val = htmlSaveFileFormat(filename, cur, (const char *)encoding, format);
3605: desret_int(ret_val);
3606: call_tests++;
3607: des_fileoutput(n_filename, filename, 0);
3608: des_xmlDocPtr(n_cur, cur, 1);
3609: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
3610: des_int(n_format, format, 3);
3611: xmlResetLastError();
3612: if (mem_base != xmlMemBlocks()) {
3613: printf("Leak of %d blocks found in htmlSaveFileFormat",
3614: xmlMemBlocks() - mem_base);
3615: test_ret++;
3616: printf(" %d", n_filename);
3617: printf(" %d", n_cur);
3618: printf(" %d", n_encoding);
3619: printf(" %d", n_format);
3620: printf("\n");
3621: }
3622: }
3623: }
3624: }
3625: }
3626: function_tests++;
3627: #endif
3628:
3629: return(test_ret);
3630: }
3631:
3632:
3633: static int
3634: test_htmlSetMetaEncoding(void) {
3635: int test_ret = 0;
3636:
3637: #if defined(LIBXML_HTML_ENABLED)
3638: int mem_base;
3639: int ret_val;
3640: htmlDocPtr doc; /* the document */
3641: int n_doc;
3642: xmlChar * encoding; /* the encoding string */
3643: int n_encoding;
3644:
3645: for (n_doc = 0;n_doc < gen_nb_htmlDocPtr;n_doc++) {
3646: for (n_encoding = 0;n_encoding < gen_nb_const_xmlChar_ptr;n_encoding++) {
3647: mem_base = xmlMemBlocks();
3648: doc = gen_htmlDocPtr(n_doc, 0);
3649: encoding = gen_const_xmlChar_ptr(n_encoding, 1);
3650:
3651: ret_val = htmlSetMetaEncoding(doc, (const xmlChar *)encoding);
3652: desret_int(ret_val);
3653: call_tests++;
3654: des_htmlDocPtr(n_doc, doc, 0);
3655: des_const_xmlChar_ptr(n_encoding, (const xmlChar *)encoding, 1);
3656: xmlResetLastError();
3657: if (mem_base != xmlMemBlocks()) {
3658: printf("Leak of %d blocks found in htmlSetMetaEncoding",
3659: xmlMemBlocks() - mem_base);
3660: test_ret++;
3661: printf(" %d", n_doc);
3662: printf(" %d", n_encoding);
3663: printf("\n");
3664: }
3665: }
3666: }
3667: function_tests++;
3668: #endif
3669:
3670: return(test_ret);
3671: }
3672:
3673: static int
3674: test_HTMLtree(void) {
3675: int test_ret = 0;
3676:
3677: if (quiet == 0) printf("Testing HTMLtree : 18 of 18 functions ...\n");
3678: test_ret += test_htmlDocContentDumpFormatOutput();
3679: test_ret += test_htmlDocContentDumpOutput();
3680: test_ret += test_htmlDocDump();
3681: test_ret += test_htmlDocDumpMemory();
3682: test_ret += test_htmlDocDumpMemoryFormat();
3683: test_ret += test_htmlGetMetaEncoding();
3684: test_ret += test_htmlIsBooleanAttr();
3685: test_ret += test_htmlNewDoc();
3686: test_ret += test_htmlNewDocNoDtD();
3687: test_ret += test_htmlNodeDump();
3688: test_ret += test_htmlNodeDumpFile();
3689: test_ret += test_htmlNodeDumpFileFormat();
3690: test_ret += test_htmlNodeDumpFormatOutput();
3691: test_ret += test_htmlNodeDumpOutput();
3692: test_ret += test_htmlSaveFile();
3693: test_ret += test_htmlSaveFileEnc();
3694: test_ret += test_htmlSaveFileFormat();
3695: test_ret += test_htmlSetMetaEncoding();
3696:
3697: if (test_ret != 0)
3698: printf("Module HTMLtree: %d errors\n", test_ret);
3699: return(test_ret);
3700: }
3701:
3702: static int
3703: test_docbDefaultSAXHandlerInit(void) {
3704: int test_ret = 0;
3705:
3706: #if defined(LIBXML_DOCB_ENABLED)
3707: #ifdef LIBXML_DOCB_ENABLED
3708: int mem_base;
3709:
3710: mem_base = xmlMemBlocks();
3711:
3712: docbDefaultSAXHandlerInit();
3713: call_tests++;
3714: xmlResetLastError();
3715: if (mem_base != xmlMemBlocks()) {
3716: printf("Leak of %d blocks found in docbDefaultSAXHandlerInit",
3717: xmlMemBlocks() - mem_base);
3718: test_ret++;
3719: printf("\n");
3720: }
3721: function_tests++;
3722: #endif
3723: #endif
3724:
3725: return(test_ret);
3726: }
3727:
3728:
3729: static int
3730: test_htmlDefaultSAXHandlerInit(void) {
3731: int test_ret = 0;
3732:
3733: #if defined(LIBXML_HTML_ENABLED)
3734: #ifdef LIBXML_HTML_ENABLED
3735: int mem_base;
3736:
3737: mem_base = xmlMemBlocks();
3738:
3739: htmlDefaultSAXHandlerInit();
3740: call_tests++;
3741: xmlResetLastError();
3742: if (mem_base != xmlMemBlocks()) {
3743: printf("Leak of %d blocks found in htmlDefaultSAXHandlerInit",
3744: xmlMemBlocks() - mem_base);
3745: test_ret++;
3746: printf("\n");
3747: }
3748: function_tests++;
3749: #endif
3750: #endif
3751:
3752: return(test_ret);
3753: }
3754:
3755:
3756: static int
3757: test_xmlDefaultSAXHandlerInit(void) {
3758: int test_ret = 0;
3759:
3760: int mem_base;
3761:
3762: mem_base = xmlMemBlocks();
3763:
3764: xmlDefaultSAXHandlerInit();
3765: call_tests++;
3766: xmlResetLastError();
3767: if (mem_base != xmlMemBlocks()) {
3768: printf("Leak of %d blocks found in xmlDefaultSAXHandlerInit",
3769: xmlMemBlocks() - mem_base);
3770: test_ret++;
3771: printf("\n");
3772: }
3773: function_tests++;
3774:
3775: return(test_ret);
3776: }
3777:
3778:
3779: #define gen_nb_xmlEnumerationPtr 1
3780: static xmlEnumerationPtr gen_xmlEnumerationPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
3781: return(NULL);
3782: }
3783: static void des_xmlEnumerationPtr(int no ATTRIBUTE_UNUSED, xmlEnumerationPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
3784: }
3785:
3786: static int
3787: test_xmlSAX2AttributeDecl(void) {
3788: int test_ret = 0;
3789:
3790: int mem_base;
3791: void * ctx; /* the user data (XML parser context) */
3792: int n_ctx;
3793: xmlChar * elem; /* the name of the element */
3794: int n_elem;
3795: xmlChar * fullname; /* the attribute name */
3796: int n_fullname;
3797: int type; /* the attribute type */
3798: int n_type;
3799: int def; /* the type of default value */
3800: int n_def;
3801: xmlChar * defaultValue; /* the attribute default value */
3802: int n_defaultValue;
3803: xmlEnumerationPtr tree; /* the tree of enumerated value set */
3804: int n_tree;
3805:
3806: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
3807: for (n_elem = 0;n_elem < gen_nb_const_xmlChar_ptr;n_elem++) {
3808: for (n_fullname = 0;n_fullname < gen_nb_const_xmlChar_ptr;n_fullname++) {
3809: for (n_type = 0;n_type < gen_nb_int;n_type++) {
3810: for (n_def = 0;n_def < gen_nb_int;n_def++) {
3811: for (n_defaultValue = 0;n_defaultValue < gen_nb_const_xmlChar_ptr;n_defaultValue++) {
3812: for (n_tree = 0;n_tree < gen_nb_xmlEnumerationPtr;n_tree++) {
3813: mem_base = xmlMemBlocks();
3814: ctx = gen_void_ptr(n_ctx, 0);
3815: elem = gen_const_xmlChar_ptr(n_elem, 1);
3816: fullname = gen_const_xmlChar_ptr(n_fullname, 2);
3817: type = gen_int(n_type, 3);
3818: def = gen_int(n_def, 4);
3819: defaultValue = gen_const_xmlChar_ptr(n_defaultValue, 5);
3820: tree = gen_xmlEnumerationPtr(n_tree, 6);
3821:
3822: xmlSAX2AttributeDecl(ctx, (const xmlChar *)elem, (const xmlChar *)fullname, type, def, (const xmlChar *)defaultValue, tree);
3823: call_tests++;
3824: des_void_ptr(n_ctx, ctx, 0);
3825: des_const_xmlChar_ptr(n_elem, (const xmlChar *)elem, 1);
3826: des_const_xmlChar_ptr(n_fullname, (const xmlChar *)fullname, 2);
3827: des_int(n_type, type, 3);
3828: des_int(n_def, def, 4);
3829: des_const_xmlChar_ptr(n_defaultValue, (const xmlChar *)defaultValue, 5);
3830: des_xmlEnumerationPtr(n_tree, tree, 6);
3831: xmlResetLastError();
3832: if (mem_base != xmlMemBlocks()) {
3833: printf("Leak of %d blocks found in xmlSAX2AttributeDecl",
3834: xmlMemBlocks() - mem_base);
3835: test_ret++;
3836: printf(" %d", n_ctx);
3837: printf(" %d", n_elem);
3838: printf(" %d", n_fullname);
3839: printf(" %d", n_type);
3840: printf(" %d", n_def);
3841: printf(" %d", n_defaultValue);
3842: printf(" %d", n_tree);
3843: printf("\n");
3844: }
3845: }
3846: }
3847: }
3848: }
3849: }
3850: }
3851: }
3852: function_tests++;
3853:
3854: return(test_ret);
3855: }
3856:
3857:
3858: static int
3859: test_xmlSAX2CDataBlock(void) {
3860: int test_ret = 0;
3861:
3862: int mem_base;
3863: void * ctx; /* the user data (XML parser context) */
3864: int n_ctx;
3865: xmlChar * value; /* The pcdata content */
3866: int n_value;
3867: int len; /* the block length */
3868: int n_len;
3869:
3870: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
3871: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
3872: for (n_len = 0;n_len < gen_nb_int;n_len++) {
3873: mem_base = xmlMemBlocks();
3874: ctx = gen_void_ptr(n_ctx, 0);
3875: value = gen_const_xmlChar_ptr(n_value, 1);
3876: len = gen_int(n_len, 2);
3877:
3878: xmlSAX2CDataBlock(ctx, (const xmlChar *)value, len);
3879: call_tests++;
3880: des_void_ptr(n_ctx, ctx, 0);
3881: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
3882: des_int(n_len, len, 2);
3883: xmlResetLastError();
3884: if (mem_base != xmlMemBlocks()) {
3885: printf("Leak of %d blocks found in xmlSAX2CDataBlock",
3886: xmlMemBlocks() - mem_base);
3887: test_ret++;
3888: printf(" %d", n_ctx);
3889: printf(" %d", n_value);
3890: printf(" %d", n_len);
3891: printf("\n");
3892: }
3893: }
3894: }
3895: }
3896: function_tests++;
3897:
3898: return(test_ret);
3899: }
3900:
3901:
3902: static int
3903: test_xmlSAX2Characters(void) {
3904: int test_ret = 0;
3905:
3906: int mem_base;
3907: void * ctx; /* the user data (XML parser context) */
3908: int n_ctx;
3909: xmlChar * ch; /* a xmlChar string */
3910: int n_ch;
3911: int len; /* the number of xmlChar */
3912: int n_len;
3913:
3914: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
3915: for (n_ch = 0;n_ch < gen_nb_const_xmlChar_ptr;n_ch++) {
3916: for (n_len = 0;n_len < gen_nb_int;n_len++) {
3917: mem_base = xmlMemBlocks();
3918: ctx = gen_void_ptr(n_ctx, 0);
3919: ch = gen_const_xmlChar_ptr(n_ch, 1);
3920: len = gen_int(n_len, 2);
3921:
3922: xmlSAX2Characters(ctx, (const xmlChar *)ch, len);
3923: call_tests++;
3924: des_void_ptr(n_ctx, ctx, 0);
3925: des_const_xmlChar_ptr(n_ch, (const xmlChar *)ch, 1);
3926: des_int(n_len, len, 2);
3927: xmlResetLastError();
3928: if (mem_base != xmlMemBlocks()) {
3929: printf("Leak of %d blocks found in xmlSAX2Characters",
3930: xmlMemBlocks() - mem_base);
3931: test_ret++;
3932: printf(" %d", n_ctx);
3933: printf(" %d", n_ch);
3934: printf(" %d", n_len);
3935: printf("\n");
3936: }
3937: }
3938: }
3939: }
3940: function_tests++;
3941:
3942: return(test_ret);
3943: }
3944:
3945:
3946: static int
3947: test_xmlSAX2Comment(void) {
3948: int test_ret = 0;
3949:
3950: int mem_base;
3951: void * ctx; /* the user data (XML parser context) */
3952: int n_ctx;
3953: xmlChar * value; /* the xmlSAX2Comment content */
3954: int n_value;
3955:
3956: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
3957: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
3958: mem_base = xmlMemBlocks();
3959: ctx = gen_void_ptr(n_ctx, 0);
3960: value = gen_const_xmlChar_ptr(n_value, 1);
3961:
3962: xmlSAX2Comment(ctx, (const xmlChar *)value);
3963: call_tests++;
3964: des_void_ptr(n_ctx, ctx, 0);
3965: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
3966: xmlResetLastError();
3967: if (mem_base != xmlMemBlocks()) {
3968: printf("Leak of %d blocks found in xmlSAX2Comment",
3969: xmlMemBlocks() - mem_base);
3970: test_ret++;
3971: printf(" %d", n_ctx);
3972: printf(" %d", n_value);
3973: printf("\n");
3974: }
3975: }
3976: }
3977: function_tests++;
3978:
3979: return(test_ret);
3980: }
3981:
3982:
3983: static int
3984: test_xmlSAX2ElementDecl(void) {
3985: int test_ret = 0;
3986:
3987: int mem_base;
3988: void * ctx; /* the user data (XML parser context) */
3989: int n_ctx;
3990: xmlChar * name; /* the element name */
3991: int n_name;
3992: int type; /* the element type */
3993: int n_type;
3994: xmlElementContentPtr content; /* the element value tree */
3995: int n_content;
3996:
3997: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
3998: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
3999: for (n_type = 0;n_type < gen_nb_int;n_type++) {
4000: for (n_content = 0;n_content < gen_nb_xmlElementContentPtr;n_content++) {
4001: mem_base = xmlMemBlocks();
4002: ctx = gen_void_ptr(n_ctx, 0);
4003: name = gen_const_xmlChar_ptr(n_name, 1);
4004: type = gen_int(n_type, 2);
4005: content = gen_xmlElementContentPtr(n_content, 3);
4006:
4007: xmlSAX2ElementDecl(ctx, (const xmlChar *)name, type, content);
4008: call_tests++;
4009: des_void_ptr(n_ctx, ctx, 0);
4010: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
4011: des_int(n_type, type, 2);
4012: des_xmlElementContentPtr(n_content, content, 3);
4013: xmlResetLastError();
4014: if (mem_base != xmlMemBlocks()) {
4015: printf("Leak of %d blocks found in xmlSAX2ElementDecl",
4016: xmlMemBlocks() - mem_base);
4017: test_ret++;
4018: printf(" %d", n_ctx);
4019: printf(" %d", n_name);
4020: printf(" %d", n_type);
4021: printf(" %d", n_content);
4022: printf("\n");
4023: }
4024: }
4025: }
4026: }
4027: }
4028: function_tests++;
4029:
4030: return(test_ret);
4031: }
4032:
4033:
4034: static int
4035: test_xmlSAX2EndDocument(void) {
4036: int test_ret = 0;
4037:
4038: int mem_base;
4039: void * ctx; /* the user data (XML parser context) */
4040: int n_ctx;
4041:
4042: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4043: mem_base = xmlMemBlocks();
4044: ctx = gen_void_ptr(n_ctx, 0);
4045:
4046: xmlSAX2EndDocument(ctx);
4047: call_tests++;
4048: des_void_ptr(n_ctx, ctx, 0);
4049: xmlResetLastError();
4050: if (mem_base != xmlMemBlocks()) {
4051: printf("Leak of %d blocks found in xmlSAX2EndDocument",
4052: xmlMemBlocks() - mem_base);
4053: test_ret++;
4054: printf(" %d", n_ctx);
4055: printf("\n");
4056: }
4057: }
4058: function_tests++;
4059:
4060: return(test_ret);
4061: }
4062:
4063:
4064: static int
4065: test_xmlSAX2EndElement(void) {
4066: int test_ret = 0;
4067:
4068: #if defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_DOCB_ENABLED)
4069: #ifdef LIBXML_SAX1_ENABLED
4070: int mem_base;
4071: void * ctx; /* the user data (XML parser context) */
4072: int n_ctx;
4073: xmlChar * name; /* The element name */
4074: int n_name;
4075:
4076: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4077: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
4078: mem_base = xmlMemBlocks();
4079: ctx = gen_void_ptr(n_ctx, 0);
4080: name = gen_const_xmlChar_ptr(n_name, 1);
4081:
4082: xmlSAX2EndElement(ctx, (const xmlChar *)name);
4083: call_tests++;
4084: des_void_ptr(n_ctx, ctx, 0);
4085: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
4086: xmlResetLastError();
4087: if (mem_base != xmlMemBlocks()) {
4088: printf("Leak of %d blocks found in xmlSAX2EndElement",
4089: xmlMemBlocks() - mem_base);
4090: test_ret++;
4091: printf(" %d", n_ctx);
4092: printf(" %d", n_name);
4093: printf("\n");
4094: }
4095: }
4096: }
4097: function_tests++;
4098: #endif
4099: #endif
4100:
4101: return(test_ret);
4102: }
4103:
4104:
4105: static int
4106: test_xmlSAX2EndElementNs(void) {
4107: int test_ret = 0;
4108:
4109: int mem_base;
4110: void * ctx; /* the user data (XML parser context) */
4111: int n_ctx;
4112: xmlChar * localname; /* the local name of the element */
4113: int n_localname;
4114: xmlChar * prefix; /* the element namespace prefix if available */
4115: int n_prefix;
4116: xmlChar * URI; /* the element namespace name if available */
4117: int n_URI;
4118:
4119: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4120: for (n_localname = 0;n_localname < gen_nb_const_xmlChar_ptr;n_localname++) {
4121: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
4122: for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
4123: mem_base = xmlMemBlocks();
4124: ctx = gen_void_ptr(n_ctx, 0);
4125: localname = gen_const_xmlChar_ptr(n_localname, 1);
4126: prefix = gen_const_xmlChar_ptr(n_prefix, 2);
4127: URI = gen_const_xmlChar_ptr(n_URI, 3);
4128:
4129: xmlSAX2EndElementNs(ctx, (const xmlChar *)localname, (const xmlChar *)prefix, (const xmlChar *)URI);
4130: call_tests++;
4131: des_void_ptr(n_ctx, ctx, 0);
4132: des_const_xmlChar_ptr(n_localname, (const xmlChar *)localname, 1);
4133: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 2);
4134: des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 3);
4135: xmlResetLastError();
4136: if (mem_base != xmlMemBlocks()) {
4137: printf("Leak of %d blocks found in xmlSAX2EndElementNs",
4138: xmlMemBlocks() - mem_base);
4139: test_ret++;
4140: printf(" %d", n_ctx);
4141: printf(" %d", n_localname);
4142: printf(" %d", n_prefix);
4143: printf(" %d", n_URI);
4144: printf("\n");
4145: }
4146: }
4147: }
4148: }
4149: }
4150: function_tests++;
4151:
4152: return(test_ret);
4153: }
4154:
4155:
4156: static int
4157: test_xmlSAX2EntityDecl(void) {
4158: int test_ret = 0;
4159:
4160: int mem_base;
4161: void * ctx; /* the user data (XML parser context) */
4162: int n_ctx;
4163: xmlChar * name; /* the entity name */
4164: int n_name;
4165: int type; /* the entity type */
4166: int n_type;
4167: xmlChar * publicId; /* The public ID of the entity */
4168: int n_publicId;
4169: xmlChar * systemId; /* The system ID of the entity */
4170: int n_systemId;
4171: xmlChar * content; /* the entity value (without processing). */
4172: int n_content;
4173:
4174: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4175: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
4176: for (n_type = 0;n_type < gen_nb_int;n_type++) {
4177: for (n_publicId = 0;n_publicId < gen_nb_const_xmlChar_ptr;n_publicId++) {
4178: for (n_systemId = 0;n_systemId < gen_nb_const_xmlChar_ptr;n_systemId++) {
4179: for (n_content = 0;n_content < gen_nb_xmlChar_ptr;n_content++) {
4180: mem_base = xmlMemBlocks();
4181: ctx = gen_void_ptr(n_ctx, 0);
4182: name = gen_const_xmlChar_ptr(n_name, 1);
4183: type = gen_int(n_type, 2);
4184: publicId = gen_const_xmlChar_ptr(n_publicId, 3);
4185: systemId = gen_const_xmlChar_ptr(n_systemId, 4);
4186: content = gen_xmlChar_ptr(n_content, 5);
4187:
4188: xmlSAX2EntityDecl(ctx, (const xmlChar *)name, type, (const xmlChar *)publicId, (const xmlChar *)systemId, content);
4189: call_tests++;
4190: des_void_ptr(n_ctx, ctx, 0);
4191: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
4192: des_int(n_type, type, 2);
4193: des_const_xmlChar_ptr(n_publicId, (const xmlChar *)publicId, 3);
4194: des_const_xmlChar_ptr(n_systemId, (const xmlChar *)systemId, 4);
4195: des_xmlChar_ptr(n_content, content, 5);
4196: xmlResetLastError();
4197: if (mem_base != xmlMemBlocks()) {
4198: printf("Leak of %d blocks found in xmlSAX2EntityDecl",
4199: xmlMemBlocks() - mem_base);
4200: test_ret++;
4201: printf(" %d", n_ctx);
4202: printf(" %d", n_name);
4203: printf(" %d", n_type);
4204: printf(" %d", n_publicId);
4205: printf(" %d", n_systemId);
4206: printf(" %d", n_content);
4207: printf("\n");
4208: }
4209: }
4210: }
4211: }
4212: }
4213: }
4214: }
4215: function_tests++;
4216:
4217: return(test_ret);
4218: }
4219:
4220:
4221: static int
4222: test_xmlSAX2ExternalSubset(void) {
4223: int test_ret = 0;
4224:
4225: int mem_base;
4226: void * ctx; /* the user data (XML parser context) */
4227: int n_ctx;
4228: xmlChar * name; /* the root element name */
4229: int n_name;
4230: xmlChar * ExternalID; /* the external ID */
4231: int n_ExternalID;
4232: xmlChar * SystemID; /* the SYSTEM ID (e.g. filename or URL) */
4233: int n_SystemID;
4234:
4235: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4236: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
4237: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
4238: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
4239: mem_base = xmlMemBlocks();
4240: ctx = gen_void_ptr(n_ctx, 0);
4241: name = gen_const_xmlChar_ptr(n_name, 1);
4242: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 2);
4243: SystemID = gen_const_xmlChar_ptr(n_SystemID, 3);
4244:
4245: xmlSAX2ExternalSubset(ctx, (const xmlChar *)name, (const xmlChar *)ExternalID, (const xmlChar *)SystemID);
4246: call_tests++;
4247: des_void_ptr(n_ctx, ctx, 0);
4248: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
4249: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 2);
4250: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 3);
4251: xmlResetLastError();
4252: if (mem_base != xmlMemBlocks()) {
4253: printf("Leak of %d blocks found in xmlSAX2ExternalSubset",
4254: xmlMemBlocks() - mem_base);
4255: test_ret++;
4256: printf(" %d", n_ctx);
4257: printf(" %d", n_name);
4258: printf(" %d", n_ExternalID);
4259: printf(" %d", n_SystemID);
4260: printf("\n");
4261: }
4262: }
4263: }
4264: }
4265: }
4266: function_tests++;
4267:
4268: return(test_ret);
4269: }
4270:
4271:
4272: static int
4273: test_xmlSAX2GetColumnNumber(void) {
4274: int test_ret = 0;
4275:
4276: int mem_base;
4277: int ret_val;
4278: void * ctx; /* the user data (XML parser context) */
4279: int n_ctx;
4280:
4281: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4282: mem_base = xmlMemBlocks();
4283: ctx = gen_void_ptr(n_ctx, 0);
4284:
4285: ret_val = xmlSAX2GetColumnNumber(ctx);
4286: desret_int(ret_val);
4287: call_tests++;
4288: des_void_ptr(n_ctx, ctx, 0);
4289: xmlResetLastError();
4290: if (mem_base != xmlMemBlocks()) {
4291: printf("Leak of %d blocks found in xmlSAX2GetColumnNumber",
4292: xmlMemBlocks() - mem_base);
4293: test_ret++;
4294: printf(" %d", n_ctx);
4295: printf("\n");
4296: }
4297: }
4298: function_tests++;
4299:
4300: return(test_ret);
4301: }
4302:
4303:
4304: static int
4305: test_xmlSAX2GetEntity(void) {
4306: int test_ret = 0;
4307:
4308: int mem_base;
4309: xmlEntityPtr ret_val;
4310: void * ctx; /* the user data (XML parser context) */
4311: int n_ctx;
4312: xmlChar * name; /* The entity name */
4313: int n_name;
4314:
4315: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4316: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
4317: mem_base = xmlMemBlocks();
4318: ctx = gen_void_ptr(n_ctx, 0);
4319: name = gen_const_xmlChar_ptr(n_name, 1);
4320:
4321: ret_val = xmlSAX2GetEntity(ctx, (const xmlChar *)name);
4322: desret_xmlEntityPtr(ret_val);
4323: call_tests++;
4324: des_void_ptr(n_ctx, ctx, 0);
4325: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
4326: xmlResetLastError();
4327: if (mem_base != xmlMemBlocks()) {
4328: printf("Leak of %d blocks found in xmlSAX2GetEntity",
4329: xmlMemBlocks() - mem_base);
4330: test_ret++;
4331: printf(" %d", n_ctx);
4332: printf(" %d", n_name);
4333: printf("\n");
4334: }
4335: }
4336: }
4337: function_tests++;
4338:
4339: return(test_ret);
4340: }
4341:
4342:
4343: static int
4344: test_xmlSAX2GetLineNumber(void) {
4345: int test_ret = 0;
4346:
4347: int mem_base;
4348: int ret_val;
4349: void * ctx; /* the user data (XML parser context) */
4350: int n_ctx;
4351:
4352: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4353: mem_base = xmlMemBlocks();
4354: ctx = gen_void_ptr(n_ctx, 0);
4355:
4356: ret_val = xmlSAX2GetLineNumber(ctx);
4357: desret_int(ret_val);
4358: call_tests++;
4359: des_void_ptr(n_ctx, ctx, 0);
4360: xmlResetLastError();
4361: if (mem_base != xmlMemBlocks()) {
4362: printf("Leak of %d blocks found in xmlSAX2GetLineNumber",
4363: xmlMemBlocks() - mem_base);
4364: test_ret++;
4365: printf(" %d", n_ctx);
4366: printf("\n");
4367: }
4368: }
4369: function_tests++;
4370:
4371: return(test_ret);
4372: }
4373:
4374:
4375: static int
4376: test_xmlSAX2GetParameterEntity(void) {
4377: int test_ret = 0;
4378:
4379: int mem_base;
4380: xmlEntityPtr ret_val;
4381: void * ctx; /* the user data (XML parser context) */
4382: int n_ctx;
4383: xmlChar * name; /* The entity name */
4384: int n_name;
4385:
4386: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4387: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
4388: mem_base = xmlMemBlocks();
4389: ctx = gen_void_ptr(n_ctx, 0);
4390: name = gen_const_xmlChar_ptr(n_name, 1);
4391:
4392: ret_val = xmlSAX2GetParameterEntity(ctx, (const xmlChar *)name);
4393: desret_xmlEntityPtr(ret_val);
4394: call_tests++;
4395: des_void_ptr(n_ctx, ctx, 0);
4396: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
4397: xmlResetLastError();
4398: if (mem_base != xmlMemBlocks()) {
4399: printf("Leak of %d blocks found in xmlSAX2GetParameterEntity",
4400: xmlMemBlocks() - mem_base);
4401: test_ret++;
4402: printf(" %d", n_ctx);
4403: printf(" %d", n_name);
4404: printf("\n");
4405: }
4406: }
4407: }
4408: function_tests++;
4409:
4410: return(test_ret);
4411: }
4412:
4413:
4414: static int
4415: test_xmlSAX2GetPublicId(void) {
4416: int test_ret = 0;
4417:
4418: int mem_base;
4419: const xmlChar * ret_val;
4420: void * ctx; /* the user data (XML parser context) */
4421: int n_ctx;
4422:
4423: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4424: mem_base = xmlMemBlocks();
4425: ctx = gen_void_ptr(n_ctx, 0);
4426:
4427: ret_val = xmlSAX2GetPublicId(ctx);
4428: desret_const_xmlChar_ptr(ret_val);
4429: call_tests++;
4430: des_void_ptr(n_ctx, ctx, 0);
4431: xmlResetLastError();
4432: if (mem_base != xmlMemBlocks()) {
4433: printf("Leak of %d blocks found in xmlSAX2GetPublicId",
4434: xmlMemBlocks() - mem_base);
4435: test_ret++;
4436: printf(" %d", n_ctx);
4437: printf("\n");
4438: }
4439: }
4440: function_tests++;
4441:
4442: return(test_ret);
4443: }
4444:
4445:
4446: static int
4447: test_xmlSAX2GetSystemId(void) {
4448: int test_ret = 0;
4449:
4450: int mem_base;
4451: const xmlChar * ret_val;
4452: void * ctx; /* the user data (XML parser context) */
4453: int n_ctx;
4454:
4455: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4456: mem_base = xmlMemBlocks();
4457: ctx = gen_void_ptr(n_ctx, 0);
4458:
4459: ret_val = xmlSAX2GetSystemId(ctx);
4460: desret_const_xmlChar_ptr(ret_val);
4461: call_tests++;
4462: des_void_ptr(n_ctx, ctx, 0);
4463: xmlResetLastError();
4464: if (mem_base != xmlMemBlocks()) {
4465: printf("Leak of %d blocks found in xmlSAX2GetSystemId",
4466: xmlMemBlocks() - mem_base);
4467: test_ret++;
4468: printf(" %d", n_ctx);
4469: printf("\n");
4470: }
4471: }
4472: function_tests++;
4473:
4474: return(test_ret);
4475: }
4476:
4477:
4478: static int
4479: test_xmlSAX2HasExternalSubset(void) {
4480: int test_ret = 0;
4481:
4482: int mem_base;
4483: int ret_val;
4484: void * ctx; /* the user data (XML parser context) */
4485: int n_ctx;
4486:
4487: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4488: mem_base = xmlMemBlocks();
4489: ctx = gen_void_ptr(n_ctx, 0);
4490:
4491: ret_val = xmlSAX2HasExternalSubset(ctx);
4492: desret_int(ret_val);
4493: call_tests++;
4494: des_void_ptr(n_ctx, ctx, 0);
4495: xmlResetLastError();
4496: if (mem_base != xmlMemBlocks()) {
4497: printf("Leak of %d blocks found in xmlSAX2HasExternalSubset",
4498: xmlMemBlocks() - mem_base);
4499: test_ret++;
4500: printf(" %d", n_ctx);
4501: printf("\n");
4502: }
4503: }
4504: function_tests++;
4505:
4506: return(test_ret);
4507: }
4508:
4509:
4510: static int
4511: test_xmlSAX2HasInternalSubset(void) {
4512: int test_ret = 0;
4513:
4514: int mem_base;
4515: int ret_val;
4516: void * ctx; /* the user data (XML parser context) */
4517: int n_ctx;
4518:
4519: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4520: mem_base = xmlMemBlocks();
4521: ctx = gen_void_ptr(n_ctx, 0);
4522:
4523: ret_val = xmlSAX2HasInternalSubset(ctx);
4524: desret_int(ret_val);
4525: call_tests++;
4526: des_void_ptr(n_ctx, ctx, 0);
4527: xmlResetLastError();
4528: if (mem_base != xmlMemBlocks()) {
4529: printf("Leak of %d blocks found in xmlSAX2HasInternalSubset",
4530: xmlMemBlocks() - mem_base);
4531: test_ret++;
4532: printf(" %d", n_ctx);
4533: printf("\n");
4534: }
4535: }
4536: function_tests++;
4537:
4538: return(test_ret);
4539: }
4540:
4541:
4542: static int
4543: test_xmlSAX2IgnorableWhitespace(void) {
4544: int test_ret = 0;
4545:
4546: int mem_base;
4547: void * ctx; /* the user data (XML parser context) */
4548: int n_ctx;
4549: xmlChar * ch; /* a xmlChar string */
4550: int n_ch;
4551: int len; /* the number of xmlChar */
4552: int n_len;
4553:
4554: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4555: for (n_ch = 0;n_ch < gen_nb_const_xmlChar_ptr;n_ch++) {
4556: for (n_len = 0;n_len < gen_nb_int;n_len++) {
4557: mem_base = xmlMemBlocks();
4558: ctx = gen_void_ptr(n_ctx, 0);
4559: ch = gen_const_xmlChar_ptr(n_ch, 1);
4560: len = gen_int(n_len, 2);
4561:
4562: xmlSAX2IgnorableWhitespace(ctx, (const xmlChar *)ch, len);
4563: call_tests++;
4564: des_void_ptr(n_ctx, ctx, 0);
4565: des_const_xmlChar_ptr(n_ch, (const xmlChar *)ch, 1);
4566: des_int(n_len, len, 2);
4567: xmlResetLastError();
4568: if (mem_base != xmlMemBlocks()) {
4569: printf("Leak of %d blocks found in xmlSAX2IgnorableWhitespace",
4570: xmlMemBlocks() - mem_base);
4571: test_ret++;
4572: printf(" %d", n_ctx);
4573: printf(" %d", n_ch);
4574: printf(" %d", n_len);
4575: printf("\n");
4576: }
4577: }
4578: }
4579: }
4580: function_tests++;
4581:
4582: return(test_ret);
4583: }
4584:
4585:
4586: #define gen_nb_xmlSAXHandler_ptr 1
4587: static xmlSAXHandler * gen_xmlSAXHandler_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
4588: return(NULL);
4589: }
4590: static void des_xmlSAXHandler_ptr(int no ATTRIBUTE_UNUSED, xmlSAXHandler * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
4591: }
4592:
4593: static int
4594: test_xmlSAX2InitDefaultSAXHandler(void) {
4595: int test_ret = 0;
4596:
4597: int mem_base;
4598: xmlSAXHandler * hdlr; /* the SAX handler */
4599: int n_hdlr;
4600: int warning; /* flag if non-zero sets the handler warning procedure */
4601: int n_warning;
4602:
4603: for (n_hdlr = 0;n_hdlr < gen_nb_xmlSAXHandler_ptr;n_hdlr++) {
4604: for (n_warning = 0;n_warning < gen_nb_int;n_warning++) {
4605: mem_base = xmlMemBlocks();
4606: hdlr = gen_xmlSAXHandler_ptr(n_hdlr, 0);
4607: warning = gen_int(n_warning, 1);
4608:
4609: xmlSAX2InitDefaultSAXHandler(hdlr, warning);
4610: call_tests++;
4611: des_xmlSAXHandler_ptr(n_hdlr, hdlr, 0);
4612: des_int(n_warning, warning, 1);
4613: xmlResetLastError();
4614: if (mem_base != xmlMemBlocks()) {
4615: printf("Leak of %d blocks found in xmlSAX2InitDefaultSAXHandler",
4616: xmlMemBlocks() - mem_base);
4617: test_ret++;
4618: printf(" %d", n_hdlr);
4619: printf(" %d", n_warning);
4620: printf("\n");
4621: }
4622: }
4623: }
4624: function_tests++;
4625:
4626: return(test_ret);
4627: }
4628:
4629:
4630: static int
4631: test_xmlSAX2InitDocbDefaultSAXHandler(void) {
4632: int test_ret = 0;
4633:
4634: #if defined(LIBXML_DOCB_ENABLED)
4635: int mem_base;
4636: xmlSAXHandler * hdlr; /* the SAX handler */
4637: int n_hdlr;
4638:
4639: for (n_hdlr = 0;n_hdlr < gen_nb_xmlSAXHandler_ptr;n_hdlr++) {
4640: mem_base = xmlMemBlocks();
4641: hdlr = gen_xmlSAXHandler_ptr(n_hdlr, 0);
4642:
4643: xmlSAX2InitDocbDefaultSAXHandler(hdlr);
4644: call_tests++;
4645: des_xmlSAXHandler_ptr(n_hdlr, hdlr, 0);
4646: xmlResetLastError();
4647: if (mem_base != xmlMemBlocks()) {
4648: printf("Leak of %d blocks found in xmlSAX2InitDocbDefaultSAXHandler",
4649: xmlMemBlocks() - mem_base);
4650: test_ret++;
4651: printf(" %d", n_hdlr);
4652: printf("\n");
4653: }
4654: }
4655: function_tests++;
4656: #endif
4657:
4658: return(test_ret);
4659: }
4660:
4661:
4662: static int
4663: test_xmlSAX2InitHtmlDefaultSAXHandler(void) {
4664: int test_ret = 0;
4665:
4666: #if defined(LIBXML_HTML_ENABLED)
4667: int mem_base;
4668: xmlSAXHandler * hdlr; /* the SAX handler */
4669: int n_hdlr;
4670:
4671: for (n_hdlr = 0;n_hdlr < gen_nb_xmlSAXHandler_ptr;n_hdlr++) {
4672: mem_base = xmlMemBlocks();
4673: hdlr = gen_xmlSAXHandler_ptr(n_hdlr, 0);
4674:
4675: xmlSAX2InitHtmlDefaultSAXHandler(hdlr);
4676: call_tests++;
4677: des_xmlSAXHandler_ptr(n_hdlr, hdlr, 0);
4678: xmlResetLastError();
4679: if (mem_base != xmlMemBlocks()) {
4680: printf("Leak of %d blocks found in xmlSAX2InitHtmlDefaultSAXHandler",
4681: xmlMemBlocks() - mem_base);
4682: test_ret++;
4683: printf(" %d", n_hdlr);
4684: printf("\n");
4685: }
4686: }
4687: function_tests++;
4688: #endif
4689:
4690: return(test_ret);
4691: }
4692:
4693:
4694: static int
4695: test_xmlSAX2InternalSubset(void) {
4696: int test_ret = 0;
4697:
4698: int mem_base;
4699: void * ctx; /* the user data (XML parser context) */
4700: int n_ctx;
4701: xmlChar * name; /* the root element name */
4702: int n_name;
4703: xmlChar * ExternalID; /* the external ID */
4704: int n_ExternalID;
4705: xmlChar * SystemID; /* the SYSTEM ID (e.g. filename or URL) */
4706: int n_SystemID;
4707:
4708: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4709: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
4710: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
4711: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
4712: mem_base = xmlMemBlocks();
4713: ctx = gen_void_ptr(n_ctx, 0);
4714: name = gen_const_xmlChar_ptr(n_name, 1);
4715: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 2);
4716: SystemID = gen_const_xmlChar_ptr(n_SystemID, 3);
4717:
4718: xmlSAX2InternalSubset(ctx, (const xmlChar *)name, (const xmlChar *)ExternalID, (const xmlChar *)SystemID);
4719: call_tests++;
4720: des_void_ptr(n_ctx, ctx, 0);
4721: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
4722: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 2);
4723: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 3);
4724: xmlResetLastError();
4725: if (mem_base != xmlMemBlocks()) {
4726: printf("Leak of %d blocks found in xmlSAX2InternalSubset",
4727: xmlMemBlocks() - mem_base);
4728: test_ret++;
4729: printf(" %d", n_ctx);
4730: printf(" %d", n_name);
4731: printf(" %d", n_ExternalID);
4732: printf(" %d", n_SystemID);
4733: printf("\n");
4734: }
4735: }
4736: }
4737: }
4738: }
4739: function_tests++;
4740:
4741: return(test_ret);
4742: }
4743:
4744:
4745: static int
4746: test_xmlSAX2IsStandalone(void) {
4747: int test_ret = 0;
4748:
4749: int mem_base;
4750: int ret_val;
4751: void * ctx; /* the user data (XML parser context) */
4752: int n_ctx;
4753:
4754: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4755: mem_base = xmlMemBlocks();
4756: ctx = gen_void_ptr(n_ctx, 0);
4757:
4758: ret_val = xmlSAX2IsStandalone(ctx);
4759: desret_int(ret_val);
4760: call_tests++;
4761: des_void_ptr(n_ctx, ctx, 0);
4762: xmlResetLastError();
4763: if (mem_base != xmlMemBlocks()) {
4764: printf("Leak of %d blocks found in xmlSAX2IsStandalone",
4765: xmlMemBlocks() - mem_base);
4766: test_ret++;
4767: printf(" %d", n_ctx);
4768: printf("\n");
4769: }
4770: }
4771: function_tests++;
4772:
4773: return(test_ret);
4774: }
4775:
4776:
4777: static int
4778: test_xmlSAX2NotationDecl(void) {
4779: int test_ret = 0;
4780:
4781: int mem_base;
4782: void * ctx; /* the user data (XML parser context) */
4783: int n_ctx;
4784: xmlChar * name; /* The name of the notation */
4785: int n_name;
4786: xmlChar * publicId; /* The public ID of the entity */
4787: int n_publicId;
4788: xmlChar * systemId; /* The system ID of the entity */
4789: int n_systemId;
4790:
4791: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4792: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
4793: for (n_publicId = 0;n_publicId < gen_nb_const_xmlChar_ptr;n_publicId++) {
4794: for (n_systemId = 0;n_systemId < gen_nb_const_xmlChar_ptr;n_systemId++) {
4795: mem_base = xmlMemBlocks();
4796: ctx = gen_void_ptr(n_ctx, 0);
4797: name = gen_const_xmlChar_ptr(n_name, 1);
4798: publicId = gen_const_xmlChar_ptr(n_publicId, 2);
4799: systemId = gen_const_xmlChar_ptr(n_systemId, 3);
4800:
4801: xmlSAX2NotationDecl(ctx, (const xmlChar *)name, (const xmlChar *)publicId, (const xmlChar *)systemId);
4802: call_tests++;
4803: des_void_ptr(n_ctx, ctx, 0);
4804: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
4805: des_const_xmlChar_ptr(n_publicId, (const xmlChar *)publicId, 2);
4806: des_const_xmlChar_ptr(n_systemId, (const xmlChar *)systemId, 3);
4807: xmlResetLastError();
4808: if (mem_base != xmlMemBlocks()) {
4809: printf("Leak of %d blocks found in xmlSAX2NotationDecl",
4810: xmlMemBlocks() - mem_base);
4811: test_ret++;
4812: printf(" %d", n_ctx);
4813: printf(" %d", n_name);
4814: printf(" %d", n_publicId);
4815: printf(" %d", n_systemId);
4816: printf("\n");
4817: }
4818: }
4819: }
4820: }
4821: }
4822: function_tests++;
4823:
4824: return(test_ret);
4825: }
4826:
4827:
4828: static int
4829: test_xmlSAX2ProcessingInstruction(void) {
4830: int test_ret = 0;
4831:
4832: int mem_base;
4833: void * ctx; /* the user data (XML parser context) */
4834: int n_ctx;
4835: xmlChar * target; /* the target name */
4836: int n_target;
4837: xmlChar * data; /* the PI data's */
4838: int n_data;
4839:
4840: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4841: for (n_target = 0;n_target < gen_nb_const_xmlChar_ptr;n_target++) {
4842: for (n_data = 0;n_data < gen_nb_const_xmlChar_ptr;n_data++) {
4843: mem_base = xmlMemBlocks();
4844: ctx = gen_void_ptr(n_ctx, 0);
4845: target = gen_const_xmlChar_ptr(n_target, 1);
4846: data = gen_const_xmlChar_ptr(n_data, 2);
4847:
4848: xmlSAX2ProcessingInstruction(ctx, (const xmlChar *)target, (const xmlChar *)data);
4849: call_tests++;
4850: des_void_ptr(n_ctx, ctx, 0);
4851: des_const_xmlChar_ptr(n_target, (const xmlChar *)target, 1);
4852: des_const_xmlChar_ptr(n_data, (const xmlChar *)data, 2);
4853: xmlResetLastError();
4854: if (mem_base != xmlMemBlocks()) {
4855: printf("Leak of %d blocks found in xmlSAX2ProcessingInstruction",
4856: xmlMemBlocks() - mem_base);
4857: test_ret++;
4858: printf(" %d", n_ctx);
4859: printf(" %d", n_target);
4860: printf(" %d", n_data);
4861: printf("\n");
4862: }
4863: }
4864: }
4865: }
4866: function_tests++;
4867:
4868: return(test_ret);
4869: }
4870:
4871:
4872: static int
4873: test_xmlSAX2Reference(void) {
4874: int test_ret = 0;
4875:
4876: int mem_base;
4877: void * ctx; /* the user data (XML parser context) */
4878: int n_ctx;
4879: xmlChar * name; /* The entity name */
4880: int n_name;
4881:
4882: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4883: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
4884: mem_base = xmlMemBlocks();
4885: ctx = gen_void_ptr(n_ctx, 0);
4886: name = gen_const_xmlChar_ptr(n_name, 1);
4887:
4888: xmlSAX2Reference(ctx, (const xmlChar *)name);
4889: call_tests++;
4890: des_void_ptr(n_ctx, ctx, 0);
4891: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
4892: xmlResetLastError();
4893: if (mem_base != xmlMemBlocks()) {
4894: printf("Leak of %d blocks found in xmlSAX2Reference",
4895: xmlMemBlocks() - mem_base);
4896: test_ret++;
4897: printf(" %d", n_ctx);
4898: printf(" %d", n_name);
4899: printf("\n");
4900: }
4901: }
4902: }
4903: function_tests++;
4904:
4905: return(test_ret);
4906: }
4907:
4908:
4909: static int
4910: test_xmlSAX2ResolveEntity(void) {
4911: int test_ret = 0;
4912:
4913: int mem_base;
4914: xmlParserInputPtr ret_val;
4915: void * ctx; /* the user data (XML parser context) */
4916: int n_ctx;
4917: xmlChar * publicId; /* The public ID of the entity */
4918: int n_publicId;
4919: xmlChar * systemId; /* The system ID of the entity */
4920: int n_systemId;
4921:
4922: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4923: for (n_publicId = 0;n_publicId < gen_nb_const_xmlChar_ptr;n_publicId++) {
4924: for (n_systemId = 0;n_systemId < gen_nb_const_xmlChar_ptr;n_systemId++) {
4925: mem_base = xmlMemBlocks();
4926: ctx = gen_void_ptr(n_ctx, 0);
4927: publicId = gen_const_xmlChar_ptr(n_publicId, 1);
4928: systemId = gen_const_xmlChar_ptr(n_systemId, 2);
4929:
4930: ret_val = xmlSAX2ResolveEntity(ctx, (const xmlChar *)publicId, (const xmlChar *)systemId);
4931: desret_xmlParserInputPtr(ret_val);
4932: call_tests++;
4933: des_void_ptr(n_ctx, ctx, 0);
4934: des_const_xmlChar_ptr(n_publicId, (const xmlChar *)publicId, 1);
4935: des_const_xmlChar_ptr(n_systemId, (const xmlChar *)systemId, 2);
4936: xmlResetLastError();
4937: if (mem_base != xmlMemBlocks()) {
4938: printf("Leak of %d blocks found in xmlSAX2ResolveEntity",
4939: xmlMemBlocks() - mem_base);
4940: test_ret++;
4941: printf(" %d", n_ctx);
4942: printf(" %d", n_publicId);
4943: printf(" %d", n_systemId);
4944: printf("\n");
4945: }
4946: }
4947: }
4948: }
4949: function_tests++;
4950:
4951: return(test_ret);
4952: }
4953:
4954:
4955: #define gen_nb_xmlSAXLocatorPtr 1
4956: static xmlSAXLocatorPtr gen_xmlSAXLocatorPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
4957: return(NULL);
4958: }
4959: static void des_xmlSAXLocatorPtr(int no ATTRIBUTE_UNUSED, xmlSAXLocatorPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
4960: }
4961:
4962: static int
4963: test_xmlSAX2SetDocumentLocator(void) {
4964: int test_ret = 0;
4965:
4966: int mem_base;
4967: void * ctx; /* the user data (XML parser context) */
4968: int n_ctx;
4969: xmlSAXLocatorPtr loc; /* A SAX Locator */
4970: int n_loc;
4971:
4972: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4973: for (n_loc = 0;n_loc < gen_nb_xmlSAXLocatorPtr;n_loc++) {
4974: mem_base = xmlMemBlocks();
4975: ctx = gen_void_ptr(n_ctx, 0);
4976: loc = gen_xmlSAXLocatorPtr(n_loc, 1);
4977:
4978: xmlSAX2SetDocumentLocator(ctx, loc);
4979: call_tests++;
4980: des_void_ptr(n_ctx, ctx, 0);
4981: des_xmlSAXLocatorPtr(n_loc, loc, 1);
4982: xmlResetLastError();
4983: if (mem_base != xmlMemBlocks()) {
4984: printf("Leak of %d blocks found in xmlSAX2SetDocumentLocator",
4985: xmlMemBlocks() - mem_base);
4986: test_ret++;
4987: printf(" %d", n_ctx);
4988: printf(" %d", n_loc);
4989: printf("\n");
4990: }
4991: }
4992: }
4993: function_tests++;
4994:
4995: return(test_ret);
4996: }
4997:
4998:
4999: static int
5000: test_xmlSAX2StartDocument(void) {
5001: int test_ret = 0;
5002:
5003: int mem_base;
5004: void * ctx; /* the user data (XML parser context) */
5005: int n_ctx;
5006:
5007: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
5008: mem_base = xmlMemBlocks();
5009: ctx = gen_void_ptr(n_ctx, 0);
5010:
5011: xmlSAX2StartDocument(ctx);
5012: call_tests++;
5013: des_void_ptr(n_ctx, ctx, 0);
5014: xmlResetLastError();
5015: if (mem_base != xmlMemBlocks()) {
5016: printf("Leak of %d blocks found in xmlSAX2StartDocument",
5017: xmlMemBlocks() - mem_base);
5018: test_ret++;
5019: printf(" %d", n_ctx);
5020: printf("\n");
5021: }
5022: }
5023: function_tests++;
5024:
5025: return(test_ret);
5026: }
5027:
5028:
5029: static int
5030: test_xmlSAX2StartElement(void) {
5031: int test_ret = 0;
5032:
5033: #if defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_DOCB_ENABLED)
5034: #ifdef LIBXML_SAX1_ENABLED
5035: int mem_base;
5036: void * ctx; /* the user data (XML parser context) */
5037: int n_ctx;
5038: xmlChar * fullname; /* The element name, including namespace prefix */
5039: int n_fullname;
5040: xmlChar ** atts; /* An array of name/value attributes pairs, NULL terminated */
5041: int n_atts;
5042:
5043: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
5044: for (n_fullname = 0;n_fullname < gen_nb_const_xmlChar_ptr;n_fullname++) {
5045: for (n_atts = 0;n_atts < gen_nb_const_xmlChar_ptr_ptr;n_atts++) {
5046: mem_base = xmlMemBlocks();
5047: ctx = gen_void_ptr(n_ctx, 0);
5048: fullname = gen_const_xmlChar_ptr(n_fullname, 1);
5049: atts = gen_const_xmlChar_ptr_ptr(n_atts, 2);
5050:
5051: xmlSAX2StartElement(ctx, (const xmlChar *)fullname, (const xmlChar **)atts);
5052: call_tests++;
5053: des_void_ptr(n_ctx, ctx, 0);
5054: des_const_xmlChar_ptr(n_fullname, (const xmlChar *)fullname, 1);
5055: des_const_xmlChar_ptr_ptr(n_atts, (const xmlChar **)atts, 2);
5056: xmlResetLastError();
5057: if (mem_base != xmlMemBlocks()) {
5058: printf("Leak of %d blocks found in xmlSAX2StartElement",
5059: xmlMemBlocks() - mem_base);
5060: test_ret++;
5061: printf(" %d", n_ctx);
5062: printf(" %d", n_fullname);
5063: printf(" %d", n_atts);
5064: printf("\n");
5065: }
5066: }
5067: }
5068: }
5069: function_tests++;
5070: #endif
5071: #endif
5072:
5073: return(test_ret);
5074: }
5075:
5076:
5077: static int
5078: test_xmlSAX2StartElementNs(void) {
5079: int test_ret = 0;
5080:
5081: int mem_base;
5082: void * ctx; /* the user data (XML parser context) */
5083: int n_ctx;
5084: xmlChar * localname; /* the local name of the element */
5085: int n_localname;
5086: xmlChar * prefix; /* the element namespace prefix if available */
5087: int n_prefix;
5088: xmlChar * URI; /* the element namespace name if available */
5089: int n_URI;
5090: int nb_namespaces; /* number of namespace definitions on that node */
5091: int n_nb_namespaces;
5092: xmlChar ** namespaces; /* pointer to the array of prefix/URI pairs namespace definitions */
5093: int n_namespaces;
5094: int nb_attributes; /* the number of attributes on that node */
5095: int n_nb_attributes;
5096: int nb_defaulted; /* the number of defaulted attributes. */
5097: int n_nb_defaulted;
5098: xmlChar ** attributes; /* pointer to the array of (localname/prefix/URI/value/end) attribute values. */
5099: int n_attributes;
5100:
5101: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
5102: for (n_localname = 0;n_localname < gen_nb_const_xmlChar_ptr;n_localname++) {
5103: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
5104: for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
5105: for (n_nb_namespaces = 0;n_nb_namespaces < gen_nb_int;n_nb_namespaces++) {
5106: for (n_namespaces = 0;n_namespaces < gen_nb_const_xmlChar_ptr_ptr;n_namespaces++) {
5107: for (n_nb_attributes = 0;n_nb_attributes < gen_nb_int;n_nb_attributes++) {
5108: for (n_nb_defaulted = 0;n_nb_defaulted < gen_nb_int;n_nb_defaulted++) {
5109: for (n_attributes = 0;n_attributes < gen_nb_const_xmlChar_ptr_ptr;n_attributes++) {
5110: mem_base = xmlMemBlocks();
5111: ctx = gen_void_ptr(n_ctx, 0);
5112: localname = gen_const_xmlChar_ptr(n_localname, 1);
5113: prefix = gen_const_xmlChar_ptr(n_prefix, 2);
5114: URI = gen_const_xmlChar_ptr(n_URI, 3);
5115: nb_namespaces = gen_int(n_nb_namespaces, 4);
5116: namespaces = gen_const_xmlChar_ptr_ptr(n_namespaces, 5);
5117: nb_attributes = gen_int(n_nb_attributes, 6);
5118: nb_defaulted = gen_int(n_nb_defaulted, 7);
5119: attributes = gen_const_xmlChar_ptr_ptr(n_attributes, 8);
5120:
5121: xmlSAX2StartElementNs(ctx, (const xmlChar *)localname, (const xmlChar *)prefix, (const xmlChar *)URI, nb_namespaces, (const xmlChar **)namespaces, nb_attributes, nb_defaulted, (const xmlChar **)attributes);
5122: call_tests++;
5123: des_void_ptr(n_ctx, ctx, 0);
5124: des_const_xmlChar_ptr(n_localname, (const xmlChar *)localname, 1);
5125: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 2);
5126: des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 3);
5127: des_int(n_nb_namespaces, nb_namespaces, 4);
5128: des_const_xmlChar_ptr_ptr(n_namespaces, (const xmlChar **)namespaces, 5);
5129: des_int(n_nb_attributes, nb_attributes, 6);
5130: des_int(n_nb_defaulted, nb_defaulted, 7);
5131: des_const_xmlChar_ptr_ptr(n_attributes, (const xmlChar **)attributes, 8);
5132: xmlResetLastError();
5133: if (mem_base != xmlMemBlocks()) {
5134: printf("Leak of %d blocks found in xmlSAX2StartElementNs",
5135: xmlMemBlocks() - mem_base);
5136: test_ret++;
5137: printf(" %d", n_ctx);
5138: printf(" %d", n_localname);
5139: printf(" %d", n_prefix);
5140: printf(" %d", n_URI);
5141: printf(" %d", n_nb_namespaces);
5142: printf(" %d", n_namespaces);
5143: printf(" %d", n_nb_attributes);
5144: printf(" %d", n_nb_defaulted);
5145: printf(" %d", n_attributes);
5146: printf("\n");
5147: }
5148: }
5149: }
5150: }
5151: }
5152: }
5153: }
5154: }
5155: }
5156: }
5157: function_tests++;
5158:
5159: return(test_ret);
5160: }
5161:
5162:
5163: static int
5164: test_xmlSAX2UnparsedEntityDecl(void) {
5165: int test_ret = 0;
5166:
5167: int mem_base;
5168: void * ctx; /* the user data (XML parser context) */
5169: int n_ctx;
5170: xmlChar * name; /* The name of the entity */
5171: int n_name;
5172: xmlChar * publicId; /* The public ID of the entity */
5173: int n_publicId;
5174: xmlChar * systemId; /* The system ID of the entity */
5175: int n_systemId;
5176: xmlChar * notationName; /* the name of the notation */
5177: int n_notationName;
5178:
5179: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
5180: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
5181: for (n_publicId = 0;n_publicId < gen_nb_const_xmlChar_ptr;n_publicId++) {
5182: for (n_systemId = 0;n_systemId < gen_nb_const_xmlChar_ptr;n_systemId++) {
5183: for (n_notationName = 0;n_notationName < gen_nb_const_xmlChar_ptr;n_notationName++) {
5184: mem_base = xmlMemBlocks();
5185: ctx = gen_void_ptr(n_ctx, 0);
5186: name = gen_const_xmlChar_ptr(n_name, 1);
5187: publicId = gen_const_xmlChar_ptr(n_publicId, 2);
5188: systemId = gen_const_xmlChar_ptr(n_systemId, 3);
5189: notationName = gen_const_xmlChar_ptr(n_notationName, 4);
5190:
5191: xmlSAX2UnparsedEntityDecl(ctx, (const xmlChar *)name, (const xmlChar *)publicId, (const xmlChar *)systemId, (const xmlChar *)notationName);
5192: call_tests++;
5193: des_void_ptr(n_ctx, ctx, 0);
5194: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
5195: des_const_xmlChar_ptr(n_publicId, (const xmlChar *)publicId, 2);
5196: des_const_xmlChar_ptr(n_systemId, (const xmlChar *)systemId, 3);
5197: des_const_xmlChar_ptr(n_notationName, (const xmlChar *)notationName, 4);
5198: xmlResetLastError();
5199: if (mem_base != xmlMemBlocks()) {
5200: printf("Leak of %d blocks found in xmlSAX2UnparsedEntityDecl",
5201: xmlMemBlocks() - mem_base);
5202: test_ret++;
5203: printf(" %d", n_ctx);
5204: printf(" %d", n_name);
5205: printf(" %d", n_publicId);
5206: printf(" %d", n_systemId);
5207: printf(" %d", n_notationName);
5208: printf("\n");
5209: }
5210: }
5211: }
5212: }
5213: }
5214: }
5215: function_tests++;
5216:
5217: return(test_ret);
5218: }
5219:
5220:
5221: static int
5222: test_xmlSAXDefaultVersion(void) {
5223: int test_ret = 0;
5224:
5225: #if defined(LIBXML_SAX1_ENABLED)
5226: #ifdef LIBXML_SAX1_ENABLED
5227: int mem_base;
5228: int ret_val;
5229: int version; /* the version, 1 or 2 */
5230: int n_version;
5231:
5232: for (n_version = 0;n_version < gen_nb_int;n_version++) {
5233: mem_base = xmlMemBlocks();
5234: version = gen_int(n_version, 0);
5235:
5236: ret_val = xmlSAXDefaultVersion(version);
5237: desret_int(ret_val);
5238: call_tests++;
5239: des_int(n_version, version, 0);
5240: xmlResetLastError();
5241: if (mem_base != xmlMemBlocks()) {
5242: printf("Leak of %d blocks found in xmlSAXDefaultVersion",
5243: xmlMemBlocks() - mem_base);
5244: test_ret++;
5245: printf(" %d", n_version);
5246: printf("\n");
5247: }
5248: }
5249: function_tests++;
5250: #endif
5251: #endif
5252:
5253: return(test_ret);
5254: }
5255:
5256:
5257: static int
5258: test_xmlSAXVersion(void) {
5259: int test_ret = 0;
5260:
5261: int mem_base;
5262: int ret_val;
5263: xmlSAXHandler * hdlr; /* the SAX handler */
5264: int n_hdlr;
5265: int version; /* the version, 1 or 2 */
5266: int n_version;
5267:
5268: for (n_hdlr = 0;n_hdlr < gen_nb_xmlSAXHandler_ptr;n_hdlr++) {
5269: for (n_version = 0;n_version < gen_nb_int;n_version++) {
5270: mem_base = xmlMemBlocks();
5271: hdlr = gen_xmlSAXHandler_ptr(n_hdlr, 0);
5272: version = gen_int(n_version, 1);
5273:
5274: ret_val = xmlSAXVersion(hdlr, version);
5275: desret_int(ret_val);
5276: call_tests++;
5277: des_xmlSAXHandler_ptr(n_hdlr, hdlr, 0);
5278: des_int(n_version, version, 1);
5279: xmlResetLastError();
5280: if (mem_base != xmlMemBlocks()) {
5281: printf("Leak of %d blocks found in xmlSAXVersion",
5282: xmlMemBlocks() - mem_base);
5283: test_ret++;
5284: printf(" %d", n_hdlr);
5285: printf(" %d", n_version);
5286: printf("\n");
5287: }
5288: }
5289: }
5290: function_tests++;
5291:
5292: return(test_ret);
5293: }
5294:
5295: static int
5296: test_SAX2(void) {
5297: int test_ret = 0;
5298:
5299: if (quiet == 0) printf("Testing SAX2 : 38 of 38 functions ...\n");
5300: test_ret += test_docbDefaultSAXHandlerInit();
5301: test_ret += test_htmlDefaultSAXHandlerInit();
5302: test_ret += test_xmlDefaultSAXHandlerInit();
5303: test_ret += test_xmlSAX2AttributeDecl();
5304: test_ret += test_xmlSAX2CDataBlock();
5305: test_ret += test_xmlSAX2Characters();
5306: test_ret += test_xmlSAX2Comment();
5307: test_ret += test_xmlSAX2ElementDecl();
5308: test_ret += test_xmlSAX2EndDocument();
5309: test_ret += test_xmlSAX2EndElement();
5310: test_ret += test_xmlSAX2EndElementNs();
5311: test_ret += test_xmlSAX2EntityDecl();
5312: test_ret += test_xmlSAX2ExternalSubset();
5313: test_ret += test_xmlSAX2GetColumnNumber();
5314: test_ret += test_xmlSAX2GetEntity();
5315: test_ret += test_xmlSAX2GetLineNumber();
5316: test_ret += test_xmlSAX2GetParameterEntity();
5317: test_ret += test_xmlSAX2GetPublicId();
5318: test_ret += test_xmlSAX2GetSystemId();
5319: test_ret += test_xmlSAX2HasExternalSubset();
5320: test_ret += test_xmlSAX2HasInternalSubset();
5321: test_ret += test_xmlSAX2IgnorableWhitespace();
5322: test_ret += test_xmlSAX2InitDefaultSAXHandler();
5323: test_ret += test_xmlSAX2InitDocbDefaultSAXHandler();
5324: test_ret += test_xmlSAX2InitHtmlDefaultSAXHandler();
5325: test_ret += test_xmlSAX2InternalSubset();
5326: test_ret += test_xmlSAX2IsStandalone();
5327: test_ret += test_xmlSAX2NotationDecl();
5328: test_ret += test_xmlSAX2ProcessingInstruction();
5329: test_ret += test_xmlSAX2Reference();
5330: test_ret += test_xmlSAX2ResolveEntity();
5331: test_ret += test_xmlSAX2SetDocumentLocator();
5332: test_ret += test_xmlSAX2StartDocument();
5333: test_ret += test_xmlSAX2StartElement();
5334: test_ret += test_xmlSAX2StartElementNs();
5335: test_ret += test_xmlSAX2UnparsedEntityDecl();
5336: test_ret += test_xmlSAXDefaultVersion();
5337: test_ret += test_xmlSAXVersion();
5338:
5339: if (test_ret != 0)
5340: printf("Module SAX2: %d errors\n", test_ret);
5341: return(test_ret);
5342: }
5343:
5344: static int
5345: test_xmlC14NDocDumpMemory(void) {
5346: int test_ret = 0;
5347:
5348: #if defined(LIBXML_C14N_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
5349: int mem_base;
5350: int ret_val;
5351: xmlDocPtr doc; /* the XML document for canonization */
5352: int n_doc;
5353: xmlNodeSetPtr nodes; /* the nodes set to be included in the canonized image or NULL if all document nodes should be included */
5354: int n_nodes;
5355: int mode; /* the c14n mode (see @xmlC14NMode) */
5356: int n_mode;
5357: xmlChar ** inclusive_ns_prefixes; /* the list of inclusive namespace prefixes ended with a NULL or NULL if there is no inclusive namespaces (only for exclusive canonicalization, ignored otherwise) */
5358: int n_inclusive_ns_prefixes;
5359: int with_comments; /* include comments in the result (!=0) or not (==0) */
5360: int n_with_comments;
5361: xmlChar ** doc_txt_ptr; /* the memory pointer for allocated canonical XML text; the caller of this functions is responsible for calling xmlFree() to free allocated memory */
5362: int n_doc_txt_ptr;
5363:
5364: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
5365: for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
5366: for (n_mode = 0;n_mode < gen_nb_int;n_mode++) {
5367: for (n_inclusive_ns_prefixes = 0;n_inclusive_ns_prefixes < gen_nb_xmlChar_ptr_ptr;n_inclusive_ns_prefixes++) {
5368: for (n_with_comments = 0;n_with_comments < gen_nb_int;n_with_comments++) {
5369: for (n_doc_txt_ptr = 0;n_doc_txt_ptr < gen_nb_xmlChar_ptr_ptr;n_doc_txt_ptr++) {
5370: mem_base = xmlMemBlocks();
5371: doc = gen_xmlDocPtr(n_doc, 0);
5372: nodes = gen_xmlNodeSetPtr(n_nodes, 1);
5373: mode = gen_int(n_mode, 2);
5374: inclusive_ns_prefixes = gen_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, 3);
5375: with_comments = gen_int(n_with_comments, 4);
5376: doc_txt_ptr = gen_xmlChar_ptr_ptr(n_doc_txt_ptr, 5);
5377:
5378: ret_val = xmlC14NDocDumpMemory(doc, nodes, mode, inclusive_ns_prefixes, with_comments, doc_txt_ptr);
5379: desret_int(ret_val);
5380: call_tests++;
5381: des_xmlDocPtr(n_doc, doc, 0);
5382: des_xmlNodeSetPtr(n_nodes, nodes, 1);
5383: des_int(n_mode, mode, 2);
5384: des_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, inclusive_ns_prefixes, 3);
5385: des_int(n_with_comments, with_comments, 4);
5386: des_xmlChar_ptr_ptr(n_doc_txt_ptr, doc_txt_ptr, 5);
5387: xmlResetLastError();
5388: if (mem_base != xmlMemBlocks()) {
5389: printf("Leak of %d blocks found in xmlC14NDocDumpMemory",
5390: xmlMemBlocks() - mem_base);
5391: test_ret++;
5392: printf(" %d", n_doc);
5393: printf(" %d", n_nodes);
5394: printf(" %d", n_mode);
5395: printf(" %d", n_inclusive_ns_prefixes);
5396: printf(" %d", n_with_comments);
5397: printf(" %d", n_doc_txt_ptr);
5398: printf("\n");
5399: }
5400: }
5401: }
5402: }
5403: }
5404: }
5405: }
5406: function_tests++;
5407: #endif
5408:
5409: return(test_ret);
5410: }
5411:
5412:
5413: static int
5414: test_xmlC14NDocSave(void) {
5415: int test_ret = 0;
5416:
5417: #if defined(LIBXML_C14N_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
5418: int mem_base;
5419: int ret_val;
5420: xmlDocPtr doc; /* the XML document for canonization */
5421: int n_doc;
5422: xmlNodeSetPtr nodes; /* the nodes set to be included in the canonized image or NULL if all document nodes should be included */
5423: int n_nodes;
5424: int mode; /* the c14n mode (see @xmlC14NMode) */
5425: int n_mode;
5426: xmlChar ** inclusive_ns_prefixes; /* the list of inclusive namespace prefixes ended with a NULL or NULL if there is no inclusive namespaces (only for exclusive canonicalization, ignored otherwise) */
5427: int n_inclusive_ns_prefixes;
5428: int with_comments; /* include comments in the result (!=0) or not (==0) */
5429: int n_with_comments;
5430: const char * filename; /* the filename to store canonical XML image */
5431: int n_filename;
5432: int compression; /* the compression level (zlib requred): -1 - libxml default, 0 - uncompressed, >0 - compression level */
5433: int n_compression;
5434:
5435: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
5436: for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
5437: for (n_mode = 0;n_mode < gen_nb_int;n_mode++) {
5438: for (n_inclusive_ns_prefixes = 0;n_inclusive_ns_prefixes < gen_nb_xmlChar_ptr_ptr;n_inclusive_ns_prefixes++) {
5439: for (n_with_comments = 0;n_with_comments < gen_nb_int;n_with_comments++) {
5440: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
5441: for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
5442: mem_base = xmlMemBlocks();
5443: doc = gen_xmlDocPtr(n_doc, 0);
5444: nodes = gen_xmlNodeSetPtr(n_nodes, 1);
5445: mode = gen_int(n_mode, 2);
5446: inclusive_ns_prefixes = gen_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, 3);
5447: with_comments = gen_int(n_with_comments, 4);
5448: filename = gen_fileoutput(n_filename, 5);
5449: compression = gen_int(n_compression, 6);
5450:
5451: ret_val = xmlC14NDocSave(doc, nodes, mode, inclusive_ns_prefixes, with_comments, filename, compression);
5452: desret_int(ret_val);
5453: call_tests++;
5454: des_xmlDocPtr(n_doc, doc, 0);
5455: des_xmlNodeSetPtr(n_nodes, nodes, 1);
5456: des_int(n_mode, mode, 2);
5457: des_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, inclusive_ns_prefixes, 3);
5458: des_int(n_with_comments, with_comments, 4);
5459: des_fileoutput(n_filename, filename, 5);
5460: des_int(n_compression, compression, 6);
5461: xmlResetLastError();
5462: if (mem_base != xmlMemBlocks()) {
5463: printf("Leak of %d blocks found in xmlC14NDocSave",
5464: xmlMemBlocks() - mem_base);
5465: test_ret++;
5466: printf(" %d", n_doc);
5467: printf(" %d", n_nodes);
5468: printf(" %d", n_mode);
5469: printf(" %d", n_inclusive_ns_prefixes);
5470: printf(" %d", n_with_comments);
5471: printf(" %d", n_filename);
5472: printf(" %d", n_compression);
5473: printf("\n");
5474: }
5475: }
5476: }
5477: }
5478: }
5479: }
5480: }
5481: }
5482: function_tests++;
5483: #endif
5484:
5485: return(test_ret);
5486: }
5487:
5488:
5489: static int
5490: test_xmlC14NDocSaveTo(void) {
5491: int test_ret = 0;
5492:
5493: #if defined(LIBXML_C14N_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
5494: int mem_base;
5495: int ret_val;
5496: xmlDocPtr doc; /* the XML document for canonization */
5497: int n_doc;
5498: xmlNodeSetPtr nodes; /* the nodes set to be included in the canonized image or NULL if all document nodes should be included */
5499: int n_nodes;
5500: int mode; /* the c14n mode (see @xmlC14NMode) */
5501: int n_mode;
5502: xmlChar ** inclusive_ns_prefixes; /* the list of inclusive namespace prefixes ended with a NULL or NULL if there is no inclusive namespaces (only for exclusive canonicalization, ignored otherwise) */
5503: int n_inclusive_ns_prefixes;
5504: int with_comments; /* include comments in the result (!=0) or not (==0) */
5505: int n_with_comments;
5506: xmlOutputBufferPtr buf; /* the output buffer to store canonical XML; this buffer MUST have encoder==NULL because C14N requires UTF-8 output */
5507: int n_buf;
5508:
5509: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
5510: for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
5511: for (n_mode = 0;n_mode < gen_nb_int;n_mode++) {
5512: for (n_inclusive_ns_prefixes = 0;n_inclusive_ns_prefixes < gen_nb_xmlChar_ptr_ptr;n_inclusive_ns_prefixes++) {
5513: for (n_with_comments = 0;n_with_comments < gen_nb_int;n_with_comments++) {
5514: for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
5515: mem_base = xmlMemBlocks();
5516: doc = gen_xmlDocPtr(n_doc, 0);
5517: nodes = gen_xmlNodeSetPtr(n_nodes, 1);
5518: mode = gen_int(n_mode, 2);
5519: inclusive_ns_prefixes = gen_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, 3);
5520: with_comments = gen_int(n_with_comments, 4);
5521: buf = gen_xmlOutputBufferPtr(n_buf, 5);
5522:
5523: ret_val = xmlC14NDocSaveTo(doc, nodes, mode, inclusive_ns_prefixes, with_comments, buf);
5524: desret_int(ret_val);
5525: call_tests++;
5526: des_xmlDocPtr(n_doc, doc, 0);
5527: des_xmlNodeSetPtr(n_nodes, nodes, 1);
5528: des_int(n_mode, mode, 2);
5529: des_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, inclusive_ns_prefixes, 3);
5530: des_int(n_with_comments, with_comments, 4);
5531: des_xmlOutputBufferPtr(n_buf, buf, 5);
5532: xmlResetLastError();
5533: if (mem_base != xmlMemBlocks()) {
5534: printf("Leak of %d blocks found in xmlC14NDocSaveTo",
5535: xmlMemBlocks() - mem_base);
5536: test_ret++;
5537: printf(" %d", n_doc);
5538: printf(" %d", n_nodes);
5539: printf(" %d", n_mode);
5540: printf(" %d", n_inclusive_ns_prefixes);
5541: printf(" %d", n_with_comments);
5542: printf(" %d", n_buf);
5543: printf("\n");
5544: }
5545: }
5546: }
5547: }
5548: }
5549: }
5550: }
5551: function_tests++;
5552: #endif
5553:
5554: return(test_ret);
5555: }
5556:
5557:
5558: static int
5559: test_xmlC14NExecute(void) {
5560: int test_ret = 0;
5561:
5562:
5563: /* missing type support */
5564: return(test_ret);
5565: }
5566:
5567: static int
5568: test_c14n(void) {
5569: int test_ret = 0;
5570:
5571: if (quiet == 0) printf("Testing c14n : 3 of 4 functions ...\n");
5572: test_ret += test_xmlC14NDocDumpMemory();
5573: test_ret += test_xmlC14NDocSave();
5574: test_ret += test_xmlC14NDocSaveTo();
5575: test_ret += test_xmlC14NExecute();
5576:
5577: if (test_ret != 0)
5578: printf("Module c14n: %d errors\n", test_ret);
5579: return(test_ret);
5580: }
5581: #ifdef LIBXML_CATALOG_ENABLED
5582:
5583: #define gen_nb_xmlCatalogPtr 1
5584: static xmlCatalogPtr gen_xmlCatalogPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
5585: return(NULL);
5586: }
5587: static void des_xmlCatalogPtr(int no ATTRIBUTE_UNUSED, xmlCatalogPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
5588: }
5589: #endif
5590:
5591:
5592: static int
5593: test_xmlACatalogAdd(void) {
5594: int test_ret = 0;
5595:
5596: #if defined(LIBXML_CATALOG_ENABLED)
5597: int mem_base;
5598: int ret_val;
5599: xmlCatalogPtr catal; /* a Catalog */
5600: int n_catal;
5601: xmlChar * type; /* the type of record to add to the catalog */
5602: int n_type;
5603: xmlChar * orig; /* the system, public or prefix to match */
5604: int n_orig;
5605: xmlChar * replace; /* the replacement value for the match */
5606: int n_replace;
5607:
5608: for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
5609: for (n_type = 0;n_type < gen_nb_const_xmlChar_ptr;n_type++) {
5610: for (n_orig = 0;n_orig < gen_nb_const_xmlChar_ptr;n_orig++) {
5611: for (n_replace = 0;n_replace < gen_nb_const_xmlChar_ptr;n_replace++) {
5612: mem_base = xmlMemBlocks();
5613: catal = gen_xmlCatalogPtr(n_catal, 0);
5614: type = gen_const_xmlChar_ptr(n_type, 1);
5615: orig = gen_const_xmlChar_ptr(n_orig, 2);
5616: replace = gen_const_xmlChar_ptr(n_replace, 3);
5617:
5618: ret_val = xmlACatalogAdd(catal, (const xmlChar *)type, (const xmlChar *)orig, (const xmlChar *)replace);
5619: desret_int(ret_val);
5620: call_tests++;
5621: des_xmlCatalogPtr(n_catal, catal, 0);
5622: des_const_xmlChar_ptr(n_type, (const xmlChar *)type, 1);
5623: des_const_xmlChar_ptr(n_orig, (const xmlChar *)orig, 2);
5624: des_const_xmlChar_ptr(n_replace, (const xmlChar *)replace, 3);
5625: xmlResetLastError();
5626: if (mem_base != xmlMemBlocks()) {
5627: printf("Leak of %d blocks found in xmlACatalogAdd",
5628: xmlMemBlocks() - mem_base);
5629: test_ret++;
5630: printf(" %d", n_catal);
5631: printf(" %d", n_type);
5632: printf(" %d", n_orig);
5633: printf(" %d", n_replace);
5634: printf("\n");
5635: }
5636: }
5637: }
5638: }
5639: }
5640: function_tests++;
5641: #endif
5642:
5643: return(test_ret);
5644: }
5645:
5646:
5647: static int
5648: test_xmlACatalogDump(void) {
5649: int test_ret = 0;
5650:
5651: #if defined(LIBXML_CATALOG_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
5652: int mem_base;
5653: xmlCatalogPtr catal; /* a Catalog */
5654: int n_catal;
5655: FILE * out; /* the file. */
5656: int n_out;
5657:
5658: for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
5659: for (n_out = 0;n_out < gen_nb_FILE_ptr;n_out++) {
5660: mem_base = xmlMemBlocks();
5661: catal = gen_xmlCatalogPtr(n_catal, 0);
5662: out = gen_FILE_ptr(n_out, 1);
5663:
5664: xmlACatalogDump(catal, out);
5665: call_tests++;
5666: des_xmlCatalogPtr(n_catal, catal, 0);
5667: des_FILE_ptr(n_out, out, 1);
5668: xmlResetLastError();
5669: if (mem_base != xmlMemBlocks()) {
5670: printf("Leak of %d blocks found in xmlACatalogDump",
5671: xmlMemBlocks() - mem_base);
5672: test_ret++;
5673: printf(" %d", n_catal);
5674: printf(" %d", n_out);
5675: printf("\n");
5676: }
5677: }
5678: }
5679: function_tests++;
5680: #endif
5681:
5682: return(test_ret);
5683: }
5684:
5685:
5686: static int
5687: test_xmlACatalogRemove(void) {
5688: int test_ret = 0;
5689:
5690: #if defined(LIBXML_CATALOG_ENABLED)
5691: int mem_base;
5692: int ret_val;
5693: xmlCatalogPtr catal; /* a Catalog */
5694: int n_catal;
5695: xmlChar * value; /* the value to remove */
5696: int n_value;
5697:
5698: for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
5699: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
5700: mem_base = xmlMemBlocks();
5701: catal = gen_xmlCatalogPtr(n_catal, 0);
5702: value = gen_const_xmlChar_ptr(n_value, 1);
5703:
5704: ret_val = xmlACatalogRemove(catal, (const xmlChar *)value);
5705: desret_int(ret_val);
5706: call_tests++;
5707: des_xmlCatalogPtr(n_catal, catal, 0);
5708: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
5709: xmlResetLastError();
5710: if (mem_base != xmlMemBlocks()) {
5711: printf("Leak of %d blocks found in xmlACatalogRemove",
5712: xmlMemBlocks() - mem_base);
5713: test_ret++;
5714: printf(" %d", n_catal);
5715: printf(" %d", n_value);
5716: printf("\n");
5717: }
5718: }
5719: }
5720: function_tests++;
5721: #endif
5722:
5723: return(test_ret);
5724: }
5725:
5726:
5727: static int
5728: test_xmlACatalogResolve(void) {
5729: int test_ret = 0;
5730:
5731: #if defined(LIBXML_CATALOG_ENABLED)
5732: int mem_base;
5733: xmlChar * ret_val;
5734: xmlCatalogPtr catal; /* a Catalog */
5735: int n_catal;
5736: xmlChar * pubID; /* the public ID string */
5737: int n_pubID;
5738: xmlChar * sysID; /* the system ID string */
5739: int n_sysID;
5740:
5741: for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
5742: for (n_pubID = 0;n_pubID < gen_nb_const_xmlChar_ptr;n_pubID++) {
5743: for (n_sysID = 0;n_sysID < gen_nb_const_xmlChar_ptr;n_sysID++) {
5744: mem_base = xmlMemBlocks();
5745: catal = gen_xmlCatalogPtr(n_catal, 0);
5746: pubID = gen_const_xmlChar_ptr(n_pubID, 1);
5747: sysID = gen_const_xmlChar_ptr(n_sysID, 2);
5748:
5749: ret_val = xmlACatalogResolve(catal, (const xmlChar *)pubID, (const xmlChar *)sysID);
5750: desret_xmlChar_ptr(ret_val);
5751: call_tests++;
5752: des_xmlCatalogPtr(n_catal, catal, 0);
5753: des_const_xmlChar_ptr(n_pubID, (const xmlChar *)pubID, 1);
5754: des_const_xmlChar_ptr(n_sysID, (const xmlChar *)sysID, 2);
5755: xmlResetLastError();
5756: if (mem_base != xmlMemBlocks()) {
5757: printf("Leak of %d blocks found in xmlACatalogResolve",
5758: xmlMemBlocks() - mem_base);
5759: test_ret++;
5760: printf(" %d", n_catal);
5761: printf(" %d", n_pubID);
5762: printf(" %d", n_sysID);
5763: printf("\n");
5764: }
5765: }
5766: }
5767: }
5768: function_tests++;
5769: #endif
5770:
5771: return(test_ret);
5772: }
5773:
5774:
5775: static int
5776: test_xmlACatalogResolvePublic(void) {
5777: int test_ret = 0;
5778:
5779: #if defined(LIBXML_CATALOG_ENABLED)
5780: int mem_base;
5781: xmlChar * ret_val;
5782: xmlCatalogPtr catal; /* a Catalog */
5783: int n_catal;
5784: xmlChar * pubID; /* the public ID string */
5785: int n_pubID;
5786:
5787: for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
5788: for (n_pubID = 0;n_pubID < gen_nb_const_xmlChar_ptr;n_pubID++) {
5789: mem_base = xmlMemBlocks();
5790: catal = gen_xmlCatalogPtr(n_catal, 0);
5791: pubID = gen_const_xmlChar_ptr(n_pubID, 1);
5792:
5793: ret_val = xmlACatalogResolvePublic(catal, (const xmlChar *)pubID);
5794: desret_xmlChar_ptr(ret_val);
5795: call_tests++;
5796: des_xmlCatalogPtr(n_catal, catal, 0);
5797: des_const_xmlChar_ptr(n_pubID, (const xmlChar *)pubID, 1);
5798: xmlResetLastError();
5799: if (mem_base != xmlMemBlocks()) {
5800: printf("Leak of %d blocks found in xmlACatalogResolvePublic",
5801: xmlMemBlocks() - mem_base);
5802: test_ret++;
5803: printf(" %d", n_catal);
5804: printf(" %d", n_pubID);
5805: printf("\n");
5806: }
5807: }
5808: }
5809: function_tests++;
5810: #endif
5811:
5812: return(test_ret);
5813: }
5814:
5815:
5816: static int
5817: test_xmlACatalogResolveSystem(void) {
5818: int test_ret = 0;
5819:
5820: #if defined(LIBXML_CATALOG_ENABLED)
5821: int mem_base;
5822: xmlChar * ret_val;
5823: xmlCatalogPtr catal; /* a Catalog */
5824: int n_catal;
5825: xmlChar * sysID; /* the system ID string */
5826: int n_sysID;
5827:
5828: for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
5829: for (n_sysID = 0;n_sysID < gen_nb_const_xmlChar_ptr;n_sysID++) {
5830: mem_base = xmlMemBlocks();
5831: catal = gen_xmlCatalogPtr(n_catal, 0);
5832: sysID = gen_const_xmlChar_ptr(n_sysID, 1);
5833:
5834: ret_val = xmlACatalogResolveSystem(catal, (const xmlChar *)sysID);
5835: desret_xmlChar_ptr(ret_val);
5836: call_tests++;
5837: des_xmlCatalogPtr(n_catal, catal, 0);
5838: des_const_xmlChar_ptr(n_sysID, (const xmlChar *)sysID, 1);
5839: xmlResetLastError();
5840: if (mem_base != xmlMemBlocks()) {
5841: printf("Leak of %d blocks found in xmlACatalogResolveSystem",
5842: xmlMemBlocks() - mem_base);
5843: test_ret++;
5844: printf(" %d", n_catal);
5845: printf(" %d", n_sysID);
5846: printf("\n");
5847: }
5848: }
5849: }
5850: function_tests++;
5851: #endif
5852:
5853: return(test_ret);
5854: }
5855:
5856:
5857: static int
5858: test_xmlACatalogResolveURI(void) {
5859: int test_ret = 0;
5860:
5861: #if defined(LIBXML_CATALOG_ENABLED)
5862: int mem_base;
5863: xmlChar * ret_val;
5864: xmlCatalogPtr catal; /* a Catalog */
5865: int n_catal;
5866: xmlChar * URI; /* the URI */
5867: int n_URI;
5868:
5869: for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
5870: for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
5871: mem_base = xmlMemBlocks();
5872: catal = gen_xmlCatalogPtr(n_catal, 0);
5873: URI = gen_const_xmlChar_ptr(n_URI, 1);
5874:
5875: ret_val = xmlACatalogResolveURI(catal, (const xmlChar *)URI);
5876: desret_xmlChar_ptr(ret_val);
5877: call_tests++;
5878: des_xmlCatalogPtr(n_catal, catal, 0);
5879: des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 1);
5880: xmlResetLastError();
5881: if (mem_base != xmlMemBlocks()) {
5882: printf("Leak of %d blocks found in xmlACatalogResolveURI",
5883: xmlMemBlocks() - mem_base);
5884: test_ret++;
5885: printf(" %d", n_catal);
5886: printf(" %d", n_URI);
5887: printf("\n");
5888: }
5889: }
5890: }
5891: function_tests++;
5892: #endif
5893:
5894: return(test_ret);
5895: }
5896:
5897:
5898: static int
5899: test_xmlCatalogAdd(void) {
5900: int test_ret = 0;
5901:
5902: #if defined(LIBXML_CATALOG_ENABLED)
5903: int mem_base;
5904: int ret_val;
5905: xmlChar * type; /* the type of record to add to the catalog */
5906: int n_type;
5907: xmlChar * orig; /* the system, public or prefix to match */
5908: int n_orig;
5909: xmlChar * replace; /* the replacement value for the match */
5910: int n_replace;
5911:
5912: for (n_type = 0;n_type < gen_nb_const_xmlChar_ptr;n_type++) {
5913: for (n_orig = 0;n_orig < gen_nb_const_xmlChar_ptr;n_orig++) {
5914: for (n_replace = 0;n_replace < gen_nb_const_xmlChar_ptr;n_replace++) {
5915: mem_base = xmlMemBlocks();
5916: type = gen_const_xmlChar_ptr(n_type, 0);
5917: orig = gen_const_xmlChar_ptr(n_orig, 1);
5918: replace = gen_const_xmlChar_ptr(n_replace, 2);
5919:
5920: ret_val = xmlCatalogAdd((const xmlChar *)type, (const xmlChar *)orig, (const xmlChar *)replace);
5921: desret_int(ret_val);
5922: call_tests++;
5923: des_const_xmlChar_ptr(n_type, (const xmlChar *)type, 0);
5924: des_const_xmlChar_ptr(n_orig, (const xmlChar *)orig, 1);
5925: des_const_xmlChar_ptr(n_replace, (const xmlChar *)replace, 2);
5926: xmlResetLastError();
5927: if (mem_base != xmlMemBlocks()) {
5928: printf("Leak of %d blocks found in xmlCatalogAdd",
5929: xmlMemBlocks() - mem_base);
5930: test_ret++;
5931: printf(" %d", n_type);
5932: printf(" %d", n_orig);
5933: printf(" %d", n_replace);
5934: printf("\n");
5935: }
5936: }
5937: }
5938: }
5939: function_tests++;
5940: #endif
5941:
5942: return(test_ret);
5943: }
5944:
5945:
5946: static int
5947: test_xmlCatalogCleanup(void) {
5948: int test_ret = 0;
5949:
5950: #if defined(LIBXML_CATALOG_ENABLED)
5951:
5952:
5953: xmlCatalogCleanup();
5954: call_tests++;
5955: xmlResetLastError();
5956: function_tests++;
5957: #endif
5958:
5959: return(test_ret);
5960: }
5961:
5962:
5963: static int
5964: test_xmlCatalogConvert(void) {
5965: int test_ret = 0;
5966:
5967: #if defined(LIBXML_CATALOG_ENABLED)
5968: int ret_val;
5969:
5970:
5971: ret_val = xmlCatalogConvert();
5972: desret_int(ret_val);
5973: call_tests++;
5974: xmlResetLastError();
5975: function_tests++;
5976: #endif
5977:
5978: return(test_ret);
5979: }
5980:
5981:
5982: static int
5983: test_xmlCatalogDump(void) {
5984: int test_ret = 0;
5985:
5986: #if defined(LIBXML_CATALOG_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
5987: int mem_base;
5988: FILE * out; /* the file. */
5989: int n_out;
5990:
5991: for (n_out = 0;n_out < gen_nb_FILE_ptr;n_out++) {
5992: mem_base = xmlMemBlocks();
5993: out = gen_FILE_ptr(n_out, 0);
5994:
5995: xmlCatalogDump(out);
5996: call_tests++;
5997: des_FILE_ptr(n_out, out, 0);
5998: xmlResetLastError();
5999: if (mem_base != xmlMemBlocks()) {
6000: printf("Leak of %d blocks found in xmlCatalogDump",
6001: xmlMemBlocks() - mem_base);
6002: test_ret++;
6003: printf(" %d", n_out);
6004: printf("\n");
6005: }
6006: }
6007: function_tests++;
6008: #endif
6009:
6010: return(test_ret);
6011: }
6012:
6013:
6014: static int
6015: test_xmlCatalogGetDefaults(void) {
6016: int test_ret = 0;
6017:
6018: #if defined(LIBXML_CATALOG_ENABLED)
6019: int mem_base;
6020: xmlCatalogAllow ret_val;
6021:
6022: mem_base = xmlMemBlocks();
6023:
6024: ret_val = xmlCatalogGetDefaults();
6025: desret_xmlCatalogAllow(ret_val);
6026: call_tests++;
6027: xmlResetLastError();
6028: if (mem_base != xmlMemBlocks()) {
6029: printf("Leak of %d blocks found in xmlCatalogGetDefaults",
6030: xmlMemBlocks() - mem_base);
6031: test_ret++;
6032: printf("\n");
6033: }
6034: function_tests++;
6035: #endif
6036:
6037: return(test_ret);
6038: }
6039:
6040:
6041: static int
6042: test_xmlCatalogIsEmpty(void) {
6043: int test_ret = 0;
6044:
6045: #if defined(LIBXML_CATALOG_ENABLED)
6046: int mem_base;
6047: int ret_val;
6048: xmlCatalogPtr catal; /* should this create an SGML catalog */
6049: int n_catal;
6050:
6051: for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
6052: mem_base = xmlMemBlocks();
6053: catal = gen_xmlCatalogPtr(n_catal, 0);
6054:
6055: ret_val = xmlCatalogIsEmpty(catal);
6056: desret_int(ret_val);
6057: call_tests++;
6058: des_xmlCatalogPtr(n_catal, catal, 0);
6059: xmlResetLastError();
6060: if (mem_base != xmlMemBlocks()) {
6061: printf("Leak of %d blocks found in xmlCatalogIsEmpty",
6062: xmlMemBlocks() - mem_base);
6063: test_ret++;
6064: printf(" %d", n_catal);
6065: printf("\n");
6066: }
6067: }
6068: function_tests++;
6069: #endif
6070:
6071: return(test_ret);
6072: }
6073:
6074:
6075: static int
6076: test_xmlCatalogLocalResolve(void) {
6077: int test_ret = 0;
6078:
6079: #if defined(LIBXML_CATALOG_ENABLED)
6080: int mem_base;
6081: xmlChar * ret_val;
6082: void * catalogs; /* a document's list of catalogs */
6083: int n_catalogs;
6084: xmlChar * pubID; /* the public ID string */
6085: int n_pubID;
6086: xmlChar * sysID; /* the system ID string */
6087: int n_sysID;
6088:
6089: for (n_catalogs = 0;n_catalogs < gen_nb_void_ptr;n_catalogs++) {
6090: for (n_pubID = 0;n_pubID < gen_nb_const_xmlChar_ptr;n_pubID++) {
6091: for (n_sysID = 0;n_sysID < gen_nb_const_xmlChar_ptr;n_sysID++) {
6092: mem_base = xmlMemBlocks();
6093: catalogs = gen_void_ptr(n_catalogs, 0);
6094: pubID = gen_const_xmlChar_ptr(n_pubID, 1);
6095: sysID = gen_const_xmlChar_ptr(n_sysID, 2);
6096:
6097: ret_val = xmlCatalogLocalResolve(catalogs, (const xmlChar *)pubID, (const xmlChar *)sysID);
6098: desret_xmlChar_ptr(ret_val);
6099: call_tests++;
6100: des_void_ptr(n_catalogs, catalogs, 0);
6101: des_const_xmlChar_ptr(n_pubID, (const xmlChar *)pubID, 1);
6102: des_const_xmlChar_ptr(n_sysID, (const xmlChar *)sysID, 2);
6103: xmlResetLastError();
6104: if (mem_base != xmlMemBlocks()) {
6105: printf("Leak of %d blocks found in xmlCatalogLocalResolve",
6106: xmlMemBlocks() - mem_base);
6107: test_ret++;
6108: printf(" %d", n_catalogs);
6109: printf(" %d", n_pubID);
6110: printf(" %d", n_sysID);
6111: printf("\n");
6112: }
6113: }
6114: }
6115: }
6116: function_tests++;
6117: #endif
6118:
6119: return(test_ret);
6120: }
6121:
6122:
6123: static int
6124: test_xmlCatalogLocalResolveURI(void) {
6125: int test_ret = 0;
6126:
6127: #if defined(LIBXML_CATALOG_ENABLED)
6128: int mem_base;
6129: xmlChar * ret_val;
6130: void * catalogs; /* a document's list of catalogs */
6131: int n_catalogs;
6132: xmlChar * URI; /* the URI */
6133: int n_URI;
6134:
6135: for (n_catalogs = 0;n_catalogs < gen_nb_void_ptr;n_catalogs++) {
6136: for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
6137: mem_base = xmlMemBlocks();
6138: catalogs = gen_void_ptr(n_catalogs, 0);
6139: URI = gen_const_xmlChar_ptr(n_URI, 1);
6140:
6141: ret_val = xmlCatalogLocalResolveURI(catalogs, (const xmlChar *)URI);
6142: desret_xmlChar_ptr(ret_val);
6143: call_tests++;
6144: des_void_ptr(n_catalogs, catalogs, 0);
6145: des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 1);
6146: xmlResetLastError();
6147: if (mem_base != xmlMemBlocks()) {
6148: printf("Leak of %d blocks found in xmlCatalogLocalResolveURI",
6149: xmlMemBlocks() - mem_base);
6150: test_ret++;
6151: printf(" %d", n_catalogs);
6152: printf(" %d", n_URI);
6153: printf("\n");
6154: }
6155: }
6156: }
6157: function_tests++;
6158: #endif
6159:
6160: return(test_ret);
6161: }
6162:
6163:
6164: static int
6165: test_xmlCatalogRemove(void) {
6166: int test_ret = 0;
6167:
6168: #if defined(LIBXML_CATALOG_ENABLED)
6169: int ret_val;
6170: xmlChar * value; /* the value to remove */
6171: int n_value;
6172:
6173: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
6174: value = gen_const_xmlChar_ptr(n_value, 0);
6175:
6176: ret_val = xmlCatalogRemove((const xmlChar *)value);
6177: desret_int(ret_val);
6178: call_tests++;
6179: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
6180: xmlResetLastError();
6181: }
6182: function_tests++;
6183: #endif
6184:
6185: return(test_ret);
6186: }
6187:
6188:
6189: static int
6190: test_xmlCatalogResolve(void) {
6191: int test_ret = 0;
6192:
6193: #if defined(LIBXML_CATALOG_ENABLED)
6194: xmlChar * ret_val;
6195: xmlChar * pubID; /* the public ID string */
6196: int n_pubID;
6197: xmlChar * sysID; /* the system ID string */
6198: int n_sysID;
6199:
6200: for (n_pubID = 0;n_pubID < gen_nb_const_xmlChar_ptr;n_pubID++) {
6201: for (n_sysID = 0;n_sysID < gen_nb_const_xmlChar_ptr;n_sysID++) {
6202: pubID = gen_const_xmlChar_ptr(n_pubID, 0);
6203: sysID = gen_const_xmlChar_ptr(n_sysID, 1);
6204:
6205: ret_val = xmlCatalogResolve((const xmlChar *)pubID, (const xmlChar *)sysID);
6206: desret_xmlChar_ptr(ret_val);
6207: call_tests++;
6208: des_const_xmlChar_ptr(n_pubID, (const xmlChar *)pubID, 0);
6209: des_const_xmlChar_ptr(n_sysID, (const xmlChar *)sysID, 1);
6210: xmlResetLastError();
6211: }
6212: }
6213: function_tests++;
6214: #endif
6215:
6216: return(test_ret);
6217: }
6218:
6219:
6220: static int
6221: test_xmlCatalogResolvePublic(void) {
6222: int test_ret = 0;
6223:
6224: #if defined(LIBXML_CATALOG_ENABLED)
6225: int mem_base;
6226: xmlChar * ret_val;
6227: xmlChar * pubID; /* the public ID string */
6228: int n_pubID;
6229:
6230: for (n_pubID = 0;n_pubID < gen_nb_const_xmlChar_ptr;n_pubID++) {
6231: mem_base = xmlMemBlocks();
6232: pubID = gen_const_xmlChar_ptr(n_pubID, 0);
6233:
6234: ret_val = xmlCatalogResolvePublic((const xmlChar *)pubID);
6235: desret_xmlChar_ptr(ret_val);
6236: call_tests++;
6237: des_const_xmlChar_ptr(n_pubID, (const xmlChar *)pubID, 0);
6238: xmlResetLastError();
6239: if (mem_base != xmlMemBlocks()) {
6240: printf("Leak of %d blocks found in xmlCatalogResolvePublic",
6241: xmlMemBlocks() - mem_base);
6242: test_ret++;
6243: printf(" %d", n_pubID);
6244: printf("\n");
6245: }
6246: }
6247: function_tests++;
6248: #endif
6249:
6250: return(test_ret);
6251: }
6252:
6253:
6254: static int
6255: test_xmlCatalogResolveSystem(void) {
6256: int test_ret = 0;
6257:
6258: #if defined(LIBXML_CATALOG_ENABLED)
6259: int mem_base;
6260: xmlChar * ret_val;
6261: xmlChar * sysID; /* the system ID string */
6262: int n_sysID;
6263:
6264: for (n_sysID = 0;n_sysID < gen_nb_const_xmlChar_ptr;n_sysID++) {
6265: mem_base = xmlMemBlocks();
6266: sysID = gen_const_xmlChar_ptr(n_sysID, 0);
6267:
6268: ret_val = xmlCatalogResolveSystem((const xmlChar *)sysID);
6269: desret_xmlChar_ptr(ret_val);
6270: call_tests++;
6271: des_const_xmlChar_ptr(n_sysID, (const xmlChar *)sysID, 0);
6272: xmlResetLastError();
6273: if (mem_base != xmlMemBlocks()) {
6274: printf("Leak of %d blocks found in xmlCatalogResolveSystem",
6275: xmlMemBlocks() - mem_base);
6276: test_ret++;
6277: printf(" %d", n_sysID);
6278: printf("\n");
6279: }
6280: }
6281: function_tests++;
6282: #endif
6283:
6284: return(test_ret);
6285: }
6286:
6287:
6288: static int
6289: test_xmlCatalogResolveURI(void) {
6290: int test_ret = 0;
6291:
6292: #if defined(LIBXML_CATALOG_ENABLED)
6293: int mem_base;
6294: xmlChar * ret_val;
6295: xmlChar * URI; /* the URI */
6296: int n_URI;
6297:
6298: for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
6299: mem_base = xmlMemBlocks();
6300: URI = gen_const_xmlChar_ptr(n_URI, 0);
6301:
6302: ret_val = xmlCatalogResolveURI((const xmlChar *)URI);
6303: desret_xmlChar_ptr(ret_val);
6304: call_tests++;
6305: des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 0);
6306: xmlResetLastError();
6307: if (mem_base != xmlMemBlocks()) {
6308: printf("Leak of %d blocks found in xmlCatalogResolveURI",
6309: xmlMemBlocks() - mem_base);
6310: test_ret++;
6311: printf(" %d", n_URI);
6312: printf("\n");
6313: }
6314: }
6315: function_tests++;
6316: #endif
6317:
6318: return(test_ret);
6319: }
6320:
6321:
6322: static int
6323: test_xmlCatalogSetDefaultPrefer(void) {
6324: int test_ret = 0;
6325:
6326: #if defined(LIBXML_CATALOG_ENABLED)
6327: int mem_base;
6328: xmlCatalogPrefer ret_val;
6329: xmlCatalogPrefer prefer; /* the default preference for delegation */
6330: int n_prefer;
6331:
6332: for (n_prefer = 0;n_prefer < gen_nb_xmlCatalogPrefer;n_prefer++) {
6333: mem_base = xmlMemBlocks();
6334: prefer = gen_xmlCatalogPrefer(n_prefer, 0);
6335:
6336: ret_val = xmlCatalogSetDefaultPrefer(prefer);
6337: desret_xmlCatalogPrefer(ret_val);
6338: call_tests++;
6339: des_xmlCatalogPrefer(n_prefer, prefer, 0);
6340: xmlResetLastError();
6341: if (mem_base != xmlMemBlocks()) {
6342: printf("Leak of %d blocks found in xmlCatalogSetDefaultPrefer",
6343: xmlMemBlocks() - mem_base);
6344: test_ret++;
6345: printf(" %d", n_prefer);
6346: printf("\n");
6347: }
6348: }
6349: function_tests++;
6350: #endif
6351:
6352: return(test_ret);
6353: }
6354:
6355:
6356: static int
6357: test_xmlCatalogSetDefaults(void) {
6358: int test_ret = 0;
6359:
6360: #if defined(LIBXML_CATALOG_ENABLED)
6361: int mem_base;
6362: xmlCatalogAllow allow; /* what catalogs should be accepted */
6363: int n_allow;
6364:
6365: for (n_allow = 0;n_allow < gen_nb_xmlCatalogAllow;n_allow++) {
6366: mem_base = xmlMemBlocks();
6367: allow = gen_xmlCatalogAllow(n_allow, 0);
6368:
6369: xmlCatalogSetDefaults(allow);
6370: call_tests++;
6371: des_xmlCatalogAllow(n_allow, allow, 0);
6372: xmlResetLastError();
6373: if (mem_base != xmlMemBlocks()) {
6374: printf("Leak of %d blocks found in xmlCatalogSetDefaults",
6375: xmlMemBlocks() - mem_base);
6376: test_ret++;
6377: printf(" %d", n_allow);
6378: printf("\n");
6379: }
6380: }
6381: function_tests++;
6382: #endif
6383:
6384: return(test_ret);
6385: }
6386:
6387:
6388: static int
6389: test_xmlConvertSGMLCatalog(void) {
6390: int test_ret = 0;
6391:
6392: #if defined(LIBXML_CATALOG_ENABLED)
6393: int mem_base;
6394: int ret_val;
6395: xmlCatalogPtr catal; /* the catalog */
6396: int n_catal;
6397:
6398: for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
6399: mem_base = xmlMemBlocks();
6400: catal = gen_xmlCatalogPtr(n_catal, 0);
6401:
6402: ret_val = xmlConvertSGMLCatalog(catal);
6403: desret_int(ret_val);
6404: call_tests++;
6405: des_xmlCatalogPtr(n_catal, catal, 0);
6406: xmlResetLastError();
6407: if (mem_base != xmlMemBlocks()) {
6408: printf("Leak of %d blocks found in xmlConvertSGMLCatalog",
6409: xmlMemBlocks() - mem_base);
6410: test_ret++;
6411: printf(" %d", n_catal);
6412: printf("\n");
6413: }
6414: }
6415: function_tests++;
6416: #endif
6417:
6418: return(test_ret);
6419: }
6420:
6421:
6422: static int
6423: test_xmlInitializeCatalog(void) {
6424: int test_ret = 0;
6425:
6426: #if defined(LIBXML_CATALOG_ENABLED)
6427: int mem_base;
6428:
6429: mem_base = xmlMemBlocks();
6430:
6431: xmlInitializeCatalog();
6432: call_tests++;
6433: xmlResetLastError();
6434: if (mem_base != xmlMemBlocks()) {
6435: printf("Leak of %d blocks found in xmlInitializeCatalog",
6436: xmlMemBlocks() - mem_base);
6437: test_ret++;
6438: printf("\n");
6439: }
6440: function_tests++;
6441: #endif
6442:
6443: return(test_ret);
6444: }
6445:
6446:
6447: static int
6448: test_xmlLoadACatalog(void) {
6449: int test_ret = 0;
6450:
6451:
6452: /* missing type support */
6453: return(test_ret);
6454: }
6455:
6456:
6457: static int
6458: test_xmlLoadCatalog(void) {
6459: int test_ret = 0;
6460:
6461: #if defined(LIBXML_CATALOG_ENABLED)
6462: int ret_val;
6463: const char * filename; /* a file path */
6464: int n_filename;
6465:
6466: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
6467: filename = gen_filepath(n_filename, 0);
6468:
6469: ret_val = xmlLoadCatalog(filename);
6470: desret_int(ret_val);
6471: call_tests++;
6472: des_filepath(n_filename, filename, 0);
6473: xmlResetLastError();
6474: }
6475: function_tests++;
6476: #endif
6477:
6478: return(test_ret);
6479: }
6480:
6481:
6482: static int
6483: test_xmlLoadCatalogs(void) {
6484: int test_ret = 0;
6485:
6486: #if defined(LIBXML_CATALOG_ENABLED)
6487: char * pathss; /* a list of directories separated by a colon or a space. */
6488: int n_pathss;
6489:
6490: for (n_pathss = 0;n_pathss < gen_nb_const_char_ptr;n_pathss++) {
6491: pathss = gen_const_char_ptr(n_pathss, 0);
6492:
6493: xmlLoadCatalogs((const char *)pathss);
6494: call_tests++;
6495: des_const_char_ptr(n_pathss, (const char *)pathss, 0);
6496: xmlResetLastError();
6497: }
6498: function_tests++;
6499: #endif
6500:
6501: return(test_ret);
6502: }
6503:
6504:
6505: static int
6506: test_xmlLoadSGMLSuperCatalog(void) {
6507: int test_ret = 0;
6508:
6509:
6510: /* missing type support */
6511: return(test_ret);
6512: }
6513:
6514:
6515: static int
6516: test_xmlNewCatalog(void) {
6517: int test_ret = 0;
6518:
6519:
6520: /* missing type support */
6521: return(test_ret);
6522: }
6523:
6524:
6525: static int
6526: test_xmlParseCatalogFile(void) {
6527: int test_ret = 0;
6528:
6529: #if defined(LIBXML_CATALOG_ENABLED)
6530: int mem_base;
6531: xmlDocPtr ret_val;
6532: const char * filename; /* the filename */
6533: int n_filename;
6534:
6535: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
6536: mem_base = xmlMemBlocks();
6537: filename = gen_filepath(n_filename, 0);
6538:
6539: ret_val = xmlParseCatalogFile(filename);
6540: desret_xmlDocPtr(ret_val);
6541: call_tests++;
6542: des_filepath(n_filename, filename, 0);
6543: xmlResetLastError();
6544: if (mem_base != xmlMemBlocks()) {
6545: printf("Leak of %d blocks found in xmlParseCatalogFile",
6546: xmlMemBlocks() - mem_base);
6547: test_ret++;
6548: printf(" %d", n_filename);
6549: printf("\n");
6550: }
6551: }
6552: function_tests++;
6553: #endif
6554:
6555: return(test_ret);
6556: }
6557:
6558: static int
6559: test_catalog(void) {
6560: int test_ret = 0;
6561:
6562: if (quiet == 0) printf("Testing catalog : 27 of 36 functions ...\n");
6563: test_ret += test_xmlACatalogAdd();
6564: test_ret += test_xmlACatalogDump();
6565: test_ret += test_xmlACatalogRemove();
6566: test_ret += test_xmlACatalogResolve();
6567: test_ret += test_xmlACatalogResolvePublic();
6568: test_ret += test_xmlACatalogResolveSystem();
6569: test_ret += test_xmlACatalogResolveURI();
6570: test_ret += test_xmlCatalogAdd();
6571: test_ret += test_xmlCatalogCleanup();
6572: test_ret += test_xmlCatalogConvert();
6573: test_ret += test_xmlCatalogDump();
6574: test_ret += test_xmlCatalogGetDefaults();
6575: test_ret += test_xmlCatalogIsEmpty();
6576: test_ret += test_xmlCatalogLocalResolve();
6577: test_ret += test_xmlCatalogLocalResolveURI();
6578: test_ret += test_xmlCatalogRemove();
6579: test_ret += test_xmlCatalogResolve();
6580: test_ret += test_xmlCatalogResolvePublic();
6581: test_ret += test_xmlCatalogResolveSystem();
6582: test_ret += test_xmlCatalogResolveURI();
6583: test_ret += test_xmlCatalogSetDefaultPrefer();
6584: test_ret += test_xmlCatalogSetDefaults();
6585: test_ret += test_xmlConvertSGMLCatalog();
6586: test_ret += test_xmlInitializeCatalog();
6587: test_ret += test_xmlLoadACatalog();
6588: test_ret += test_xmlLoadCatalog();
6589: test_ret += test_xmlLoadCatalogs();
6590: test_ret += test_xmlLoadSGMLSuperCatalog();
6591: test_ret += test_xmlNewCatalog();
6592: test_ret += test_xmlParseCatalogFile();
6593:
6594: if (test_ret != 0)
6595: printf("Module catalog: %d errors\n", test_ret);
6596: return(test_ret);
6597: }
6598:
6599: #define gen_nb_const_xmlChRangeGroup_ptr 1
6600: static xmlChRangeGroup * gen_const_xmlChRangeGroup_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
6601: return(NULL);
6602: }
6603: static void des_const_xmlChRangeGroup_ptr(int no ATTRIBUTE_UNUSED, const xmlChRangeGroup * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
6604: }
6605:
6606: static int
6607: test_xmlCharInRange(void) {
6608: int test_ret = 0;
6609:
6610: int mem_base;
6611: int ret_val;
6612: unsigned int val; /* character to be validated */
6613: int n_val;
6614: xmlChRangeGroup * rptr; /* pointer to range to be used to validate */
6615: int n_rptr;
6616:
6617: for (n_val = 0;n_val < gen_nb_unsigned_int;n_val++) {
6618: for (n_rptr = 0;n_rptr < gen_nb_const_xmlChRangeGroup_ptr;n_rptr++) {
6619: mem_base = xmlMemBlocks();
6620: val = gen_unsigned_int(n_val, 0);
6621: rptr = gen_const_xmlChRangeGroup_ptr(n_rptr, 1);
6622:
6623: ret_val = xmlCharInRange(val, (const xmlChRangeGroup *)rptr);
6624: desret_int(ret_val);
6625: call_tests++;
6626: des_unsigned_int(n_val, val, 0);
6627: des_const_xmlChRangeGroup_ptr(n_rptr, (const xmlChRangeGroup *)rptr, 1);
6628: xmlResetLastError();
6629: if (mem_base != xmlMemBlocks()) {
6630: printf("Leak of %d blocks found in xmlCharInRange",
6631: xmlMemBlocks() - mem_base);
6632: test_ret++;
6633: printf(" %d", n_val);
6634: printf(" %d", n_rptr);
6635: printf("\n");
6636: }
6637: }
6638: }
6639: function_tests++;
6640:
6641: return(test_ret);
6642: }
6643:
6644:
6645: static int
6646: test_xmlIsBaseChar(void) {
6647: int test_ret = 0;
6648:
6649: int mem_base;
6650: int ret_val;
6651: unsigned int ch; /* character to validate */
6652: int n_ch;
6653:
6654: for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
6655: mem_base = xmlMemBlocks();
6656: ch = gen_unsigned_int(n_ch, 0);
6657:
6658: ret_val = xmlIsBaseChar(ch);
6659: desret_int(ret_val);
6660: call_tests++;
6661: des_unsigned_int(n_ch, ch, 0);
6662: xmlResetLastError();
6663: if (mem_base != xmlMemBlocks()) {
6664: printf("Leak of %d blocks found in xmlIsBaseChar",
6665: xmlMemBlocks() - mem_base);
6666: test_ret++;
6667: printf(" %d", n_ch);
6668: printf("\n");
6669: }
6670: }
6671: function_tests++;
6672:
6673: return(test_ret);
6674: }
6675:
6676:
6677: static int
6678: test_xmlIsBlank(void) {
6679: int test_ret = 0;
6680:
6681: int mem_base;
6682: int ret_val;
6683: unsigned int ch; /* character to validate */
6684: int n_ch;
6685:
6686: for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
6687: mem_base = xmlMemBlocks();
6688: ch = gen_unsigned_int(n_ch, 0);
6689:
6690: ret_val = xmlIsBlank(ch);
6691: desret_int(ret_val);
6692: call_tests++;
6693: des_unsigned_int(n_ch, ch, 0);
6694: xmlResetLastError();
6695: if (mem_base != xmlMemBlocks()) {
6696: printf("Leak of %d blocks found in xmlIsBlank",
6697: xmlMemBlocks() - mem_base);
6698: test_ret++;
6699: printf(" %d", n_ch);
6700: printf("\n");
6701: }
6702: }
6703: function_tests++;
6704:
6705: return(test_ret);
6706: }
6707:
6708:
6709: static int
6710: test_xmlIsChar(void) {
6711: int test_ret = 0;
6712:
6713: int mem_base;
6714: int ret_val;
6715: unsigned int ch; /* character to validate */
6716: int n_ch;
6717:
6718: for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
6719: mem_base = xmlMemBlocks();
6720: ch = gen_unsigned_int(n_ch, 0);
6721:
6722: ret_val = xmlIsChar(ch);
6723: desret_int(ret_val);
6724: call_tests++;
6725: des_unsigned_int(n_ch, ch, 0);
6726: xmlResetLastError();
6727: if (mem_base != xmlMemBlocks()) {
6728: printf("Leak of %d blocks found in xmlIsChar",
6729: xmlMemBlocks() - mem_base);
6730: test_ret++;
6731: printf(" %d", n_ch);
6732: printf("\n");
6733: }
6734: }
6735: function_tests++;
6736:
6737: return(test_ret);
6738: }
6739:
6740:
6741: static int
6742: test_xmlIsCombining(void) {
6743: int test_ret = 0;
6744:
6745: int mem_base;
6746: int ret_val;
6747: unsigned int ch; /* character to validate */
6748: int n_ch;
6749:
6750: for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
6751: mem_base = xmlMemBlocks();
6752: ch = gen_unsigned_int(n_ch, 0);
6753:
6754: ret_val = xmlIsCombining(ch);
6755: desret_int(ret_val);
6756: call_tests++;
6757: des_unsigned_int(n_ch, ch, 0);
6758: xmlResetLastError();
6759: if (mem_base != xmlMemBlocks()) {
6760: printf("Leak of %d blocks found in xmlIsCombining",
6761: xmlMemBlocks() - mem_base);
6762: test_ret++;
6763: printf(" %d", n_ch);
6764: printf("\n");
6765: }
6766: }
6767: function_tests++;
6768:
6769: return(test_ret);
6770: }
6771:
6772:
6773: static int
6774: test_xmlIsDigit(void) {
6775: int test_ret = 0;
6776:
6777: int mem_base;
6778: int ret_val;
6779: unsigned int ch; /* character to validate */
6780: int n_ch;
6781:
6782: for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
6783: mem_base = xmlMemBlocks();
6784: ch = gen_unsigned_int(n_ch, 0);
6785:
6786: ret_val = xmlIsDigit(ch);
6787: desret_int(ret_val);
6788: call_tests++;
6789: des_unsigned_int(n_ch, ch, 0);
6790: xmlResetLastError();
6791: if (mem_base != xmlMemBlocks()) {
6792: printf("Leak of %d blocks found in xmlIsDigit",
6793: xmlMemBlocks() - mem_base);
6794: test_ret++;
6795: printf(" %d", n_ch);
6796: printf("\n");
6797: }
6798: }
6799: function_tests++;
6800:
6801: return(test_ret);
6802: }
6803:
6804:
6805: static int
6806: test_xmlIsExtender(void) {
6807: int test_ret = 0;
6808:
6809: int mem_base;
6810: int ret_val;
6811: unsigned int ch; /* character to validate */
6812: int n_ch;
6813:
6814: for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
6815: mem_base = xmlMemBlocks();
6816: ch = gen_unsigned_int(n_ch, 0);
6817:
6818: ret_val = xmlIsExtender(ch);
6819: desret_int(ret_val);
6820: call_tests++;
6821: des_unsigned_int(n_ch, ch, 0);
6822: xmlResetLastError();
6823: if (mem_base != xmlMemBlocks()) {
6824: printf("Leak of %d blocks found in xmlIsExtender",
6825: xmlMemBlocks() - mem_base);
6826: test_ret++;
6827: printf(" %d", n_ch);
6828: printf("\n");
6829: }
6830: }
6831: function_tests++;
6832:
6833: return(test_ret);
6834: }
6835:
6836:
6837: static int
6838: test_xmlIsIdeographic(void) {
6839: int test_ret = 0;
6840:
6841: int mem_base;
6842: int ret_val;
6843: unsigned int ch; /* character to validate */
6844: int n_ch;
6845:
6846: for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
6847: mem_base = xmlMemBlocks();
6848: ch = gen_unsigned_int(n_ch, 0);
6849:
6850: ret_val = xmlIsIdeographic(ch);
6851: desret_int(ret_val);
6852: call_tests++;
6853: des_unsigned_int(n_ch, ch, 0);
6854: xmlResetLastError();
6855: if (mem_base != xmlMemBlocks()) {
6856: printf("Leak of %d blocks found in xmlIsIdeographic",
6857: xmlMemBlocks() - mem_base);
6858: test_ret++;
6859: printf(" %d", n_ch);
6860: printf("\n");
6861: }
6862: }
6863: function_tests++;
6864:
6865: return(test_ret);
6866: }
6867:
6868:
6869: static int
6870: test_xmlIsPubidChar(void) {
6871: int test_ret = 0;
6872:
6873: int mem_base;
6874: int ret_val;
6875: unsigned int ch; /* character to validate */
6876: int n_ch;
6877:
6878: for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
6879: mem_base = xmlMemBlocks();
6880: ch = gen_unsigned_int(n_ch, 0);
6881:
6882: ret_val = xmlIsPubidChar(ch);
6883: desret_int(ret_val);
6884: call_tests++;
6885: des_unsigned_int(n_ch, ch, 0);
6886: xmlResetLastError();
6887: if (mem_base != xmlMemBlocks()) {
6888: printf("Leak of %d blocks found in xmlIsPubidChar",
6889: xmlMemBlocks() - mem_base);
6890: test_ret++;
6891: printf(" %d", n_ch);
6892: printf("\n");
6893: }
6894: }
6895: function_tests++;
6896:
6897: return(test_ret);
6898: }
6899:
6900: static int
6901: test_chvalid(void) {
6902: int test_ret = 0;
6903:
6904: if (quiet == 0) printf("Testing chvalid : 9 of 9 functions ...\n");
6905: test_ret += test_xmlCharInRange();
6906: test_ret += test_xmlIsBaseChar();
6907: test_ret += test_xmlIsBlank();
6908: test_ret += test_xmlIsChar();
6909: test_ret += test_xmlIsCombining();
6910: test_ret += test_xmlIsDigit();
6911: test_ret += test_xmlIsExtender();
6912: test_ret += test_xmlIsIdeographic();
6913: test_ret += test_xmlIsPubidChar();
6914:
6915: if (test_ret != 0)
6916: printf("Module chvalid: %d errors\n", test_ret);
6917: return(test_ret);
6918: }
6919:
6920: static int
6921: test_xmlBoolToText(void) {
6922: int test_ret = 0;
6923:
6924: #if defined(LIBXML_DEBUG_ENABLED)
6925: int mem_base;
6926: const char * ret_val;
6927: int boolval; /* a bool to turn into text */
6928: int n_boolval;
6929:
6930: for (n_boolval = 0;n_boolval < gen_nb_int;n_boolval++) {
6931: mem_base = xmlMemBlocks();
6932: boolval = gen_int(n_boolval, 0);
6933:
6934: ret_val = xmlBoolToText(boolval);
6935: desret_const_char_ptr(ret_val);
6936: call_tests++;
6937: des_int(n_boolval, boolval, 0);
6938: xmlResetLastError();
6939: if (mem_base != xmlMemBlocks()) {
6940: printf("Leak of %d blocks found in xmlBoolToText",
6941: xmlMemBlocks() - mem_base);
6942: test_ret++;
6943: printf(" %d", n_boolval);
6944: printf("\n");
6945: }
6946: }
6947: function_tests++;
6948: #endif
6949:
6950: return(test_ret);
6951: }
6952:
6953:
6954: static int
6955: test_xmlDebugCheckDocument(void) {
6956: int test_ret = 0;
6957:
6958: #if defined(LIBXML_DEBUG_ENABLED)
6959: int mem_base;
6960: int ret_val;
6961: FILE * output; /* the FILE * for the output */
6962: int n_output;
6963: xmlDocPtr doc; /* the document */
6964: int n_doc;
6965:
6966: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
6967: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
6968: mem_base = xmlMemBlocks();
6969: output = gen_debug_FILE_ptr(n_output, 0);
6970: doc = gen_xmlDocPtr(n_doc, 1);
6971:
6972: ret_val = xmlDebugCheckDocument(output, doc);
6973: desret_int(ret_val);
6974: call_tests++;
6975: des_debug_FILE_ptr(n_output, output, 0);
6976: des_xmlDocPtr(n_doc, doc, 1);
6977: xmlResetLastError();
6978: if (mem_base != xmlMemBlocks()) {
6979: printf("Leak of %d blocks found in xmlDebugCheckDocument",
6980: xmlMemBlocks() - mem_base);
6981: test_ret++;
6982: printf(" %d", n_output);
6983: printf(" %d", n_doc);
6984: printf("\n");
6985: }
6986: }
6987: }
6988: function_tests++;
6989: #endif
6990:
6991: return(test_ret);
6992: }
6993:
6994:
6995: static int
6996: test_xmlDebugDumpAttr(void) {
6997: int test_ret = 0;
6998:
6999: #if defined(LIBXML_DEBUG_ENABLED)
7000: int mem_base;
7001: FILE * output; /* the FILE * for the output */
7002: int n_output;
7003: xmlAttrPtr attr; /* the attribute */
7004: int n_attr;
7005: int depth; /* the indentation level. */
7006: int n_depth;
7007:
7008: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
7009: for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
7010: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
7011: mem_base = xmlMemBlocks();
7012: output = gen_debug_FILE_ptr(n_output, 0);
7013: attr = gen_xmlAttrPtr(n_attr, 1);
7014: depth = gen_int(n_depth, 2);
7015:
7016: xmlDebugDumpAttr(output, attr, depth);
7017: call_tests++;
7018: des_debug_FILE_ptr(n_output, output, 0);
7019: des_xmlAttrPtr(n_attr, attr, 1);
7020: des_int(n_depth, depth, 2);
7021: xmlResetLastError();
7022: if (mem_base != xmlMemBlocks()) {
7023: printf("Leak of %d blocks found in xmlDebugDumpAttr",
7024: xmlMemBlocks() - mem_base);
7025: test_ret++;
7026: printf(" %d", n_output);
7027: printf(" %d", n_attr);
7028: printf(" %d", n_depth);
7029: printf("\n");
7030: }
7031: }
7032: }
7033: }
7034: function_tests++;
7035: #endif
7036:
7037: return(test_ret);
7038: }
7039:
7040:
7041: static int
7042: test_xmlDebugDumpAttrList(void) {
7043: int test_ret = 0;
7044:
7045: #if defined(LIBXML_DEBUG_ENABLED)
7046: int mem_base;
7047: FILE * output; /* the FILE * for the output */
7048: int n_output;
7049: xmlAttrPtr attr; /* the attribute list */
7050: int n_attr;
7051: int depth; /* the indentation level. */
7052: int n_depth;
7053:
7054: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
7055: for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
7056: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
7057: mem_base = xmlMemBlocks();
7058: output = gen_debug_FILE_ptr(n_output, 0);
7059: attr = gen_xmlAttrPtr(n_attr, 1);
7060: depth = gen_int(n_depth, 2);
7061:
7062: xmlDebugDumpAttrList(output, attr, depth);
7063: call_tests++;
7064: des_debug_FILE_ptr(n_output, output, 0);
7065: des_xmlAttrPtr(n_attr, attr, 1);
7066: des_int(n_depth, depth, 2);
7067: xmlResetLastError();
7068: if (mem_base != xmlMemBlocks()) {
7069: printf("Leak of %d blocks found in xmlDebugDumpAttrList",
7070: xmlMemBlocks() - mem_base);
7071: test_ret++;
7072: printf(" %d", n_output);
7073: printf(" %d", n_attr);
7074: printf(" %d", n_depth);
7075: printf("\n");
7076: }
7077: }
7078: }
7079: }
7080: function_tests++;
7081: #endif
7082:
7083: return(test_ret);
7084: }
7085:
7086:
7087: static int
7088: test_xmlDebugDumpDTD(void) {
7089: int test_ret = 0;
7090:
7091: #if defined(LIBXML_DEBUG_ENABLED)
7092: int mem_base;
7093: FILE * output; /* the FILE * for the output */
7094: int n_output;
7095: xmlDtdPtr dtd; /* the DTD */
7096: int n_dtd;
7097:
7098: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
7099: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
7100: mem_base = xmlMemBlocks();
7101: output = gen_debug_FILE_ptr(n_output, 0);
7102: dtd = gen_xmlDtdPtr(n_dtd, 1);
7103:
7104: xmlDebugDumpDTD(output, dtd);
7105: call_tests++;
7106: des_debug_FILE_ptr(n_output, output, 0);
7107: des_xmlDtdPtr(n_dtd, dtd, 1);
7108: xmlResetLastError();
7109: if (mem_base != xmlMemBlocks()) {
7110: printf("Leak of %d blocks found in xmlDebugDumpDTD",
7111: xmlMemBlocks() - mem_base);
7112: test_ret++;
7113: printf(" %d", n_output);
7114: printf(" %d", n_dtd);
7115: printf("\n");
7116: }
7117: }
7118: }
7119: function_tests++;
7120: #endif
7121:
7122: return(test_ret);
7123: }
7124:
7125:
7126: static int
7127: test_xmlDebugDumpDocument(void) {
7128: int test_ret = 0;
7129:
7130: #if defined(LIBXML_DEBUG_ENABLED)
7131: int mem_base;
7132: FILE * output; /* the FILE * for the output */
7133: int n_output;
7134: xmlDocPtr doc; /* the document */
7135: int n_doc;
7136:
7137: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
7138: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
7139: mem_base = xmlMemBlocks();
7140: output = gen_debug_FILE_ptr(n_output, 0);
7141: doc = gen_xmlDocPtr(n_doc, 1);
7142:
7143: xmlDebugDumpDocument(output, doc);
7144: call_tests++;
7145: des_debug_FILE_ptr(n_output, output, 0);
7146: des_xmlDocPtr(n_doc, doc, 1);
7147: xmlResetLastError();
7148: if (mem_base != xmlMemBlocks()) {
7149: printf("Leak of %d blocks found in xmlDebugDumpDocument",
7150: xmlMemBlocks() - mem_base);
7151: test_ret++;
7152: printf(" %d", n_output);
7153: printf(" %d", n_doc);
7154: printf("\n");
7155: }
7156: }
7157: }
7158: function_tests++;
7159: #endif
7160:
7161: return(test_ret);
7162: }
7163:
7164:
7165: static int
7166: test_xmlDebugDumpDocumentHead(void) {
7167: int test_ret = 0;
7168:
7169: #if defined(LIBXML_DEBUG_ENABLED)
7170: int mem_base;
7171: FILE * output; /* the FILE * for the output */
7172: int n_output;
7173: xmlDocPtr doc; /* the document */
7174: int n_doc;
7175:
7176: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
7177: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
7178: mem_base = xmlMemBlocks();
7179: output = gen_debug_FILE_ptr(n_output, 0);
7180: doc = gen_xmlDocPtr(n_doc, 1);
7181:
7182: xmlDebugDumpDocumentHead(output, doc);
7183: call_tests++;
7184: des_debug_FILE_ptr(n_output, output, 0);
7185: des_xmlDocPtr(n_doc, doc, 1);
7186: xmlResetLastError();
7187: if (mem_base != xmlMemBlocks()) {
7188: printf("Leak of %d blocks found in xmlDebugDumpDocumentHead",
7189: xmlMemBlocks() - mem_base);
7190: test_ret++;
7191: printf(" %d", n_output);
7192: printf(" %d", n_doc);
7193: printf("\n");
7194: }
7195: }
7196: }
7197: function_tests++;
7198: #endif
7199:
7200: return(test_ret);
7201: }
7202:
7203:
7204: static int
7205: test_xmlDebugDumpEntities(void) {
7206: int test_ret = 0;
7207:
7208: #if defined(LIBXML_DEBUG_ENABLED)
7209: int mem_base;
7210: FILE * output; /* the FILE * for the output */
7211: int n_output;
7212: xmlDocPtr doc; /* the document */
7213: int n_doc;
7214:
7215: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
7216: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
7217: mem_base = xmlMemBlocks();
7218: output = gen_debug_FILE_ptr(n_output, 0);
7219: doc = gen_xmlDocPtr(n_doc, 1);
7220:
7221: xmlDebugDumpEntities(output, doc);
7222: call_tests++;
7223: des_debug_FILE_ptr(n_output, output, 0);
7224: des_xmlDocPtr(n_doc, doc, 1);
7225: xmlResetLastError();
7226: if (mem_base != xmlMemBlocks()) {
7227: printf("Leak of %d blocks found in xmlDebugDumpEntities",
7228: xmlMemBlocks() - mem_base);
7229: test_ret++;
7230: printf(" %d", n_output);
7231: printf(" %d", n_doc);
7232: printf("\n");
7233: }
7234: }
7235: }
7236: function_tests++;
7237: #endif
7238:
7239: return(test_ret);
7240: }
7241:
7242:
7243: static int
7244: test_xmlDebugDumpNode(void) {
7245: int test_ret = 0;
7246:
7247: #if defined(LIBXML_DEBUG_ENABLED)
7248: int mem_base;
7249: FILE * output; /* the FILE * for the output */
7250: int n_output;
7251: xmlNodePtr node; /* the node */
7252: int n_node;
7253: int depth; /* the indentation level. */
7254: int n_depth;
7255:
7256: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
7257: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7258: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
7259: mem_base = xmlMemBlocks();
7260: output = gen_debug_FILE_ptr(n_output, 0);
7261: node = gen_xmlNodePtr(n_node, 1);
7262: depth = gen_int(n_depth, 2);
7263:
7264: xmlDebugDumpNode(output, node, depth);
7265: call_tests++;
7266: des_debug_FILE_ptr(n_output, output, 0);
7267: des_xmlNodePtr(n_node, node, 1);
7268: des_int(n_depth, depth, 2);
7269: xmlResetLastError();
7270: if (mem_base != xmlMemBlocks()) {
7271: printf("Leak of %d blocks found in xmlDebugDumpNode",
7272: xmlMemBlocks() - mem_base);
7273: test_ret++;
7274: printf(" %d", n_output);
7275: printf(" %d", n_node);
7276: printf(" %d", n_depth);
7277: printf("\n");
7278: }
7279: }
7280: }
7281: }
7282: function_tests++;
7283: #endif
7284:
7285: return(test_ret);
7286: }
7287:
7288:
7289: static int
7290: test_xmlDebugDumpNodeList(void) {
7291: int test_ret = 0;
7292:
7293: #if defined(LIBXML_DEBUG_ENABLED)
7294: int mem_base;
7295: FILE * output; /* the FILE * for the output */
7296: int n_output;
7297: xmlNodePtr node; /* the node list */
7298: int n_node;
7299: int depth; /* the indentation level. */
7300: int n_depth;
7301:
7302: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
7303: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7304: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
7305: mem_base = xmlMemBlocks();
7306: output = gen_debug_FILE_ptr(n_output, 0);
7307: node = gen_xmlNodePtr(n_node, 1);
7308: depth = gen_int(n_depth, 2);
7309:
7310: xmlDebugDumpNodeList(output, node, depth);
7311: call_tests++;
7312: des_debug_FILE_ptr(n_output, output, 0);
7313: des_xmlNodePtr(n_node, node, 1);
7314: des_int(n_depth, depth, 2);
7315: xmlResetLastError();
7316: if (mem_base != xmlMemBlocks()) {
7317: printf("Leak of %d blocks found in xmlDebugDumpNodeList",
7318: xmlMemBlocks() - mem_base);
7319: test_ret++;
7320: printf(" %d", n_output);
7321: printf(" %d", n_node);
7322: printf(" %d", n_depth);
7323: printf("\n");
7324: }
7325: }
7326: }
7327: }
7328: function_tests++;
7329: #endif
7330:
7331: return(test_ret);
7332: }
7333:
7334:
7335: static int
7336: test_xmlDebugDumpOneNode(void) {
7337: int test_ret = 0;
7338:
7339: #if defined(LIBXML_DEBUG_ENABLED)
7340: int mem_base;
7341: FILE * output; /* the FILE * for the output */
7342: int n_output;
7343: xmlNodePtr node; /* the node */
7344: int n_node;
7345: int depth; /* the indentation level. */
7346: int n_depth;
7347:
7348: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
7349: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7350: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
7351: mem_base = xmlMemBlocks();
7352: output = gen_debug_FILE_ptr(n_output, 0);
7353: node = gen_xmlNodePtr(n_node, 1);
7354: depth = gen_int(n_depth, 2);
7355:
7356: xmlDebugDumpOneNode(output, node, depth);
7357: call_tests++;
7358: des_debug_FILE_ptr(n_output, output, 0);
7359: des_xmlNodePtr(n_node, node, 1);
7360: des_int(n_depth, depth, 2);
7361: xmlResetLastError();
7362: if (mem_base != xmlMemBlocks()) {
7363: printf("Leak of %d blocks found in xmlDebugDumpOneNode",
7364: xmlMemBlocks() - mem_base);
7365: test_ret++;
7366: printf(" %d", n_output);
7367: printf(" %d", n_node);
7368: printf(" %d", n_depth);
7369: printf("\n");
7370: }
7371: }
7372: }
7373: }
7374: function_tests++;
7375: #endif
7376:
7377: return(test_ret);
7378: }
7379:
7380:
7381: static int
7382: test_xmlDebugDumpString(void) {
7383: int test_ret = 0;
7384:
7385: #if defined(LIBXML_DEBUG_ENABLED)
7386: int mem_base;
7387: FILE * output; /* the FILE * for the output */
7388: int n_output;
7389: xmlChar * str; /* the string */
7390: int n_str;
7391:
7392: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
7393: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
7394: mem_base = xmlMemBlocks();
7395: output = gen_debug_FILE_ptr(n_output, 0);
7396: str = gen_const_xmlChar_ptr(n_str, 1);
7397:
7398: xmlDebugDumpString(output, (const xmlChar *)str);
7399: call_tests++;
7400: des_debug_FILE_ptr(n_output, output, 0);
7401: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
7402: xmlResetLastError();
7403: if (mem_base != xmlMemBlocks()) {
7404: printf("Leak of %d blocks found in xmlDebugDumpString",
7405: xmlMemBlocks() - mem_base);
7406: test_ret++;
7407: printf(" %d", n_output);
7408: printf(" %d", n_str);
7409: printf("\n");
7410: }
7411: }
7412: }
7413: function_tests++;
7414: #endif
7415:
7416: return(test_ret);
7417: }
7418:
7419:
7420: static int
7421: test_xmlLsCountNode(void) {
7422: int test_ret = 0;
7423:
7424: #if defined(LIBXML_DEBUG_ENABLED)
7425: int mem_base;
7426: int ret_val;
7427: xmlNodePtr node; /* the node to count */
7428: int n_node;
7429:
7430: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7431: mem_base = xmlMemBlocks();
7432: node = gen_xmlNodePtr(n_node, 0);
7433:
7434: ret_val = xmlLsCountNode(node);
7435: desret_int(ret_val);
7436: call_tests++;
7437: des_xmlNodePtr(n_node, node, 0);
7438: xmlResetLastError();
7439: if (mem_base != xmlMemBlocks()) {
7440: printf("Leak of %d blocks found in xmlLsCountNode",
7441: xmlMemBlocks() - mem_base);
7442: test_ret++;
7443: printf(" %d", n_node);
7444: printf("\n");
7445: }
7446: }
7447: function_tests++;
7448: #endif
7449:
7450: return(test_ret);
7451: }
7452:
7453:
7454: static int
7455: test_xmlLsOneNode(void) {
7456: int test_ret = 0;
7457:
7458: #if defined(LIBXML_DEBUG_ENABLED)
7459: int mem_base;
7460: FILE * output; /* the FILE * for the output */
7461: int n_output;
7462: xmlNodePtr node; /* the node to dump */
7463: int n_node;
7464:
7465: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
7466: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7467: mem_base = xmlMemBlocks();
7468: output = gen_debug_FILE_ptr(n_output, 0);
7469: node = gen_xmlNodePtr(n_node, 1);
7470:
7471: xmlLsOneNode(output, node);
7472: call_tests++;
7473: des_debug_FILE_ptr(n_output, output, 0);
7474: des_xmlNodePtr(n_node, node, 1);
7475: xmlResetLastError();
7476: if (mem_base != xmlMemBlocks()) {
7477: printf("Leak of %d blocks found in xmlLsOneNode",
7478: xmlMemBlocks() - mem_base);
7479: test_ret++;
7480: printf(" %d", n_output);
7481: printf(" %d", n_node);
7482: printf("\n");
7483: }
7484: }
7485: }
7486: function_tests++;
7487: #endif
7488:
7489: return(test_ret);
7490: }
7491:
7492:
7493: #define gen_nb_char_ptr 1
7494: static char * gen_char_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
7495: return(NULL);
7496: }
7497: static void des_char_ptr(int no ATTRIBUTE_UNUSED, char * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
7498: }
7499:
7500: static int
7501: test_xmlShell(void) {
7502: int test_ret = 0;
7503:
7504:
7505: /* missing type support */
7506: return(test_ret);
7507: }
7508:
7509:
7510: static int
7511: test_xmlShellBase(void) {
7512: int test_ret = 0;
7513:
7514: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
7515: int mem_base;
7516: int ret_val;
7517: xmlShellCtxtPtr ctxt; /* the shell context */
7518: int n_ctxt;
7519: char * arg; /* unused */
7520: int n_arg;
7521: xmlNodePtr node; /* a node */
7522: int n_node;
7523: xmlNodePtr node2; /* unused */
7524: int n_node2;
7525:
7526: for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
7527: for (n_arg = 0;n_arg < gen_nb_char_ptr;n_arg++) {
7528: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7529: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
7530: mem_base = xmlMemBlocks();
7531: ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
7532: arg = gen_char_ptr(n_arg, 1);
7533: node = gen_xmlNodePtr(n_node, 2);
7534: node2 = gen_xmlNodePtr(n_node2, 3);
7535:
7536: ret_val = xmlShellBase(ctxt, arg, node, node2);
7537: desret_int(ret_val);
7538: call_tests++;
7539: des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
7540: des_char_ptr(n_arg, arg, 1);
7541: des_xmlNodePtr(n_node, node, 2);
7542: des_xmlNodePtr(n_node2, node2, 3);
7543: xmlResetLastError();
7544: if (mem_base != xmlMemBlocks()) {
7545: printf("Leak of %d blocks found in xmlShellBase",
7546: xmlMemBlocks() - mem_base);
7547: test_ret++;
7548: printf(" %d", n_ctxt);
7549: printf(" %d", n_arg);
7550: printf(" %d", n_node);
7551: printf(" %d", n_node2);
7552: printf("\n");
7553: }
7554: }
7555: }
7556: }
7557: }
7558: function_tests++;
7559: #endif
7560:
7561: return(test_ret);
7562: }
7563:
7564:
7565: static int
7566: test_xmlShellCat(void) {
7567: int test_ret = 0;
7568:
7569: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
7570: int mem_base;
7571: int ret_val;
7572: xmlShellCtxtPtr ctxt; /* the shell context */
7573: int n_ctxt;
7574: char * arg; /* unused */
7575: int n_arg;
7576: xmlNodePtr node; /* a node */
7577: int n_node;
7578: xmlNodePtr node2; /* unused */
7579: int n_node2;
7580:
7581: for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
7582: for (n_arg = 0;n_arg < gen_nb_char_ptr;n_arg++) {
7583: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7584: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
7585: mem_base = xmlMemBlocks();
7586: ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
7587: arg = gen_char_ptr(n_arg, 1);
7588: node = gen_xmlNodePtr(n_node, 2);
7589: node2 = gen_xmlNodePtr(n_node2, 3);
7590:
7591: ret_val = xmlShellCat(ctxt, arg, node, node2);
7592: desret_int(ret_val);
7593: call_tests++;
7594: des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
7595: des_char_ptr(n_arg, arg, 1);
7596: des_xmlNodePtr(n_node, node, 2);
7597: des_xmlNodePtr(n_node2, node2, 3);
7598: xmlResetLastError();
7599: if (mem_base != xmlMemBlocks()) {
7600: printf("Leak of %d blocks found in xmlShellCat",
7601: xmlMemBlocks() - mem_base);
7602: test_ret++;
7603: printf(" %d", n_ctxt);
7604: printf(" %d", n_arg);
7605: printf(" %d", n_node);
7606: printf(" %d", n_node2);
7607: printf("\n");
7608: }
7609: }
7610: }
7611: }
7612: }
7613: function_tests++;
7614: #endif
7615:
7616: return(test_ret);
7617: }
7618:
7619:
7620: static int
7621: test_xmlShellDir(void) {
7622: int test_ret = 0;
7623:
7624: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
7625: int mem_base;
7626: int ret_val;
7627: xmlShellCtxtPtr ctxt; /* the shell context */
7628: int n_ctxt;
7629: char * arg; /* unused */
7630: int n_arg;
7631: xmlNodePtr node; /* a node */
7632: int n_node;
7633: xmlNodePtr node2; /* unused */
7634: int n_node2;
7635:
7636: for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
7637: for (n_arg = 0;n_arg < gen_nb_char_ptr;n_arg++) {
7638: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7639: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
7640: mem_base = xmlMemBlocks();
7641: ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
7642: arg = gen_char_ptr(n_arg, 1);
7643: node = gen_xmlNodePtr(n_node, 2);
7644: node2 = gen_xmlNodePtr(n_node2, 3);
7645:
7646: ret_val = xmlShellDir(ctxt, arg, node, node2);
7647: desret_int(ret_val);
7648: call_tests++;
7649: des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
7650: des_char_ptr(n_arg, arg, 1);
7651: des_xmlNodePtr(n_node, node, 2);
7652: des_xmlNodePtr(n_node2, node2, 3);
7653: xmlResetLastError();
7654: if (mem_base != xmlMemBlocks()) {
7655: printf("Leak of %d blocks found in xmlShellDir",
7656: xmlMemBlocks() - mem_base);
7657: test_ret++;
7658: printf(" %d", n_ctxt);
7659: printf(" %d", n_arg);
7660: printf(" %d", n_node);
7661: printf(" %d", n_node2);
7662: printf("\n");
7663: }
7664: }
7665: }
7666: }
7667: }
7668: function_tests++;
7669: #endif
7670:
7671: return(test_ret);
7672: }
7673:
7674:
7675: static int
7676: test_xmlShellDu(void) {
7677: int test_ret = 0;
7678:
7679: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
7680: int mem_base;
7681: int ret_val;
7682: xmlShellCtxtPtr ctxt; /* the shell context */
7683: int n_ctxt;
7684: char * arg; /* unused */
7685: int n_arg;
7686: xmlNodePtr tree; /* a node defining a subtree */
7687: int n_tree;
7688: xmlNodePtr node2; /* unused */
7689: int n_node2;
7690:
7691: for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
7692: for (n_arg = 0;n_arg < gen_nb_char_ptr;n_arg++) {
7693: for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) {
7694: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
7695: mem_base = xmlMemBlocks();
7696: ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
7697: arg = gen_char_ptr(n_arg, 1);
7698: tree = gen_xmlNodePtr(n_tree, 2);
7699: node2 = gen_xmlNodePtr(n_node2, 3);
7700:
7701: ret_val = xmlShellDu(ctxt, arg, tree, node2);
7702: desret_int(ret_val);
7703: call_tests++;
7704: des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
7705: des_char_ptr(n_arg, arg, 1);
7706: des_xmlNodePtr(n_tree, tree, 2);
7707: des_xmlNodePtr(n_node2, node2, 3);
7708: xmlResetLastError();
7709: if (mem_base != xmlMemBlocks()) {
7710: printf("Leak of %d blocks found in xmlShellDu",
7711: xmlMemBlocks() - mem_base);
7712: test_ret++;
7713: printf(" %d", n_ctxt);
7714: printf(" %d", n_arg);
7715: printf(" %d", n_tree);
7716: printf(" %d", n_node2);
7717: printf("\n");
7718: }
7719: }
7720: }
7721: }
7722: }
7723: function_tests++;
7724: #endif
7725:
7726: return(test_ret);
7727: }
7728:
7729:
7730: static int
7731: test_xmlShellList(void) {
7732: int test_ret = 0;
7733:
7734: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
7735: int mem_base;
7736: int ret_val;
7737: xmlShellCtxtPtr ctxt; /* the shell context */
7738: int n_ctxt;
7739: char * arg; /* unused */
7740: int n_arg;
7741: xmlNodePtr node; /* a node */
7742: int n_node;
7743: xmlNodePtr node2; /* unused */
7744: int n_node2;
7745:
7746: for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
7747: for (n_arg = 0;n_arg < gen_nb_char_ptr;n_arg++) {
7748: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7749: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
7750: mem_base = xmlMemBlocks();
7751: ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
7752: arg = gen_char_ptr(n_arg, 1);
7753: node = gen_xmlNodePtr(n_node, 2);
7754: node2 = gen_xmlNodePtr(n_node2, 3);
7755:
7756: ret_val = xmlShellList(ctxt, arg, node, node2);
7757: desret_int(ret_val);
7758: call_tests++;
7759: des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
7760: des_char_ptr(n_arg, arg, 1);
7761: des_xmlNodePtr(n_node, node, 2);
7762: des_xmlNodePtr(n_node2, node2, 3);
7763: xmlResetLastError();
7764: if (mem_base != xmlMemBlocks()) {
7765: printf("Leak of %d blocks found in xmlShellList",
7766: xmlMemBlocks() - mem_base);
7767: test_ret++;
7768: printf(" %d", n_ctxt);
7769: printf(" %d", n_arg);
7770: printf(" %d", n_node);
7771: printf(" %d", n_node2);
7772: printf("\n");
7773: }
7774: }
7775: }
7776: }
7777: }
7778: function_tests++;
7779: #endif
7780:
7781: return(test_ret);
7782: }
7783:
7784:
7785: static int
7786: test_xmlShellLoad(void) {
7787: int test_ret = 0;
7788:
7789: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
7790: int mem_base;
7791: int ret_val;
7792: xmlShellCtxtPtr ctxt; /* the shell context */
7793: int n_ctxt;
7794: char * filename; /* the file name */
7795: int n_filename;
7796: xmlNodePtr node; /* unused */
7797: int n_node;
7798: xmlNodePtr node2; /* unused */
7799: int n_node2;
7800:
7801: for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
7802: for (n_filename = 0;n_filename < gen_nb_char_ptr;n_filename++) {
7803: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7804: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
7805: mem_base = xmlMemBlocks();
7806: ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
7807: filename = gen_char_ptr(n_filename, 1);
7808: node = gen_xmlNodePtr(n_node, 2);
7809: node2 = gen_xmlNodePtr(n_node2, 3);
7810:
7811: ret_val = xmlShellLoad(ctxt, filename, node, node2);
7812: desret_int(ret_val);
7813: call_tests++;
7814: des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
7815: des_char_ptr(n_filename, filename, 1);
7816: des_xmlNodePtr(n_node, node, 2);
7817: des_xmlNodePtr(n_node2, node2, 3);
7818: xmlResetLastError();
7819: if (mem_base != xmlMemBlocks()) {
7820: printf("Leak of %d blocks found in xmlShellLoad",
7821: xmlMemBlocks() - mem_base);
7822: test_ret++;
7823: printf(" %d", n_ctxt);
7824: printf(" %d", n_filename);
7825: printf(" %d", n_node);
7826: printf(" %d", n_node2);
7827: printf("\n");
7828: }
7829: }
7830: }
7831: }
7832: }
7833: function_tests++;
7834: #endif
7835:
7836: return(test_ret);
7837: }
7838:
7839:
7840: static int
7841: test_xmlShellPrintXPathResult(void) {
7842: int test_ret = 0;
7843:
7844: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
7845: int mem_base;
7846: xmlXPathObjectPtr list; /* a valid result generated by an xpath evaluation */
7847: int n_list;
7848:
7849: for (n_list = 0;n_list < gen_nb_xmlXPathObjectPtr;n_list++) {
7850: mem_base = xmlMemBlocks();
7851: list = gen_xmlXPathObjectPtr(n_list, 0);
7852:
7853: xmlShellPrintXPathResult(list);
7854: call_tests++;
7855: des_xmlXPathObjectPtr(n_list, list, 0);
7856: xmlResetLastError();
7857: if (mem_base != xmlMemBlocks()) {
7858: printf("Leak of %d blocks found in xmlShellPrintXPathResult",
7859: xmlMemBlocks() - mem_base);
7860: test_ret++;
7861: printf(" %d", n_list);
7862: printf("\n");
7863: }
7864: }
7865: function_tests++;
7866: #endif
7867:
7868: return(test_ret);
7869: }
7870:
7871:
7872: static int
7873: test_xmlShellPwd(void) {
7874: int test_ret = 0;
7875:
7876: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
7877: int mem_base;
7878: int ret_val;
7879: xmlShellCtxtPtr ctxt; /* the shell context */
7880: int n_ctxt;
7881: char * buffer; /* the output buffer */
7882: int n_buffer;
7883: xmlNodePtr node; /* a node */
7884: int n_node;
7885: xmlNodePtr node2; /* unused */
7886: int n_node2;
7887:
7888: for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
7889: for (n_buffer = 0;n_buffer < gen_nb_char_ptr;n_buffer++) {
7890: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7891: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
7892: mem_base = xmlMemBlocks();
7893: ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
7894: buffer = gen_char_ptr(n_buffer, 1);
7895: node = gen_xmlNodePtr(n_node, 2);
7896: node2 = gen_xmlNodePtr(n_node2, 3);
7897:
7898: ret_val = xmlShellPwd(ctxt, buffer, node, node2);
7899: desret_int(ret_val);
7900: call_tests++;
7901: des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
7902: des_char_ptr(n_buffer, buffer, 1);
7903: des_xmlNodePtr(n_node, node, 2);
7904: des_xmlNodePtr(n_node2, node2, 3);
7905: xmlResetLastError();
7906: if (mem_base != xmlMemBlocks()) {
7907: printf("Leak of %d blocks found in xmlShellPwd",
7908: xmlMemBlocks() - mem_base);
7909: test_ret++;
7910: printf(" %d", n_ctxt);
7911: printf(" %d", n_buffer);
7912: printf(" %d", n_node);
7913: printf(" %d", n_node2);
7914: printf("\n");
7915: }
7916: }
7917: }
7918: }
7919: }
7920: function_tests++;
7921: #endif
7922:
7923: return(test_ret);
7924: }
7925:
7926:
7927: static int
7928: test_xmlShellSave(void) {
7929: int test_ret = 0;
7930:
7931: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
7932: int mem_base;
7933: int ret_val;
7934: xmlShellCtxtPtr ctxt; /* the shell context */
7935: int n_ctxt;
7936: char * filename; /* the file name (optional) */
7937: int n_filename;
7938: xmlNodePtr node; /* unused */
7939: int n_node;
7940: xmlNodePtr node2; /* unused */
7941: int n_node2;
7942:
7943: for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
7944: for (n_filename = 0;n_filename < gen_nb_char_ptr;n_filename++) {
7945: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7946: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
7947: mem_base = xmlMemBlocks();
7948: ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
7949: filename = gen_char_ptr(n_filename, 1);
7950: node = gen_xmlNodePtr(n_node, 2);
7951: node2 = gen_xmlNodePtr(n_node2, 3);
7952:
7953: ret_val = xmlShellSave(ctxt, filename, node, node2);
7954: desret_int(ret_val);
7955: call_tests++;
7956: des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
7957: des_char_ptr(n_filename, filename, 1);
7958: des_xmlNodePtr(n_node, node, 2);
7959: des_xmlNodePtr(n_node2, node2, 3);
7960: xmlResetLastError();
7961: if (mem_base != xmlMemBlocks()) {
7962: printf("Leak of %d blocks found in xmlShellSave",
7963: xmlMemBlocks() - mem_base);
7964: test_ret++;
7965: printf(" %d", n_ctxt);
7966: printf(" %d", n_filename);
7967: printf(" %d", n_node);
7968: printf(" %d", n_node2);
7969: printf("\n");
7970: }
7971: }
7972: }
7973: }
7974: }
7975: function_tests++;
7976: #endif
7977:
7978: return(test_ret);
7979: }
7980:
7981:
7982: static int
7983: test_xmlShellValidate(void) {
7984: int test_ret = 0;
7985:
7986: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_VALID_ENABLED)
7987: int mem_base;
7988: int ret_val;
7989: xmlShellCtxtPtr ctxt; /* the shell context */
7990: int n_ctxt;
7991: char * dtd; /* the DTD URI (optional) */
7992: int n_dtd;
7993: xmlNodePtr node; /* unused */
7994: int n_node;
7995: xmlNodePtr node2; /* unused */
7996: int n_node2;
7997:
7998: for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
7999: for (n_dtd = 0;n_dtd < gen_nb_char_ptr;n_dtd++) {
8000: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
8001: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
8002: mem_base = xmlMemBlocks();
8003: ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
8004: dtd = gen_char_ptr(n_dtd, 1);
8005: node = gen_xmlNodePtr(n_node, 2);
8006: node2 = gen_xmlNodePtr(n_node2, 3);
8007:
8008: ret_val = xmlShellValidate(ctxt, dtd, node, node2);
8009: desret_int(ret_val);
8010: call_tests++;
8011: des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
8012: des_char_ptr(n_dtd, dtd, 1);
8013: des_xmlNodePtr(n_node, node, 2);
8014: des_xmlNodePtr(n_node2, node2, 3);
8015: xmlResetLastError();
8016: if (mem_base != xmlMemBlocks()) {
8017: printf("Leak of %d blocks found in xmlShellValidate",
8018: xmlMemBlocks() - mem_base);
8019: test_ret++;
8020: printf(" %d", n_ctxt);
8021: printf(" %d", n_dtd);
8022: printf(" %d", n_node);
8023: printf(" %d", n_node2);
8024: printf("\n");
8025: }
8026: }
8027: }
8028: }
8029: }
8030: function_tests++;
8031: #endif
8032:
8033: return(test_ret);
8034: }
8035:
8036:
8037: static int
8038: test_xmlShellWrite(void) {
8039: int test_ret = 0;
8040:
8041: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
8042: int mem_base;
8043: int ret_val;
8044: xmlShellCtxtPtr ctxt; /* the shell context */
8045: int n_ctxt;
8046: char * filename; /* the file name */
8047: int n_filename;
8048: xmlNodePtr node; /* a node in the tree */
8049: int n_node;
8050: xmlNodePtr node2; /* unused */
8051: int n_node2;
8052:
8053: for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
8054: for (n_filename = 0;n_filename < gen_nb_char_ptr;n_filename++) {
8055: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
8056: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
8057: mem_base = xmlMemBlocks();
8058: ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
8059: filename = gen_char_ptr(n_filename, 1);
8060: node = gen_xmlNodePtr(n_node, 2);
8061: node2 = gen_xmlNodePtr(n_node2, 3);
8062:
8063: ret_val = xmlShellWrite(ctxt, filename, node, node2);
8064: desret_int(ret_val);
8065: call_tests++;
8066: des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
8067: des_char_ptr(n_filename, filename, 1);
8068: des_xmlNodePtr(n_node, node, 2);
8069: des_xmlNodePtr(n_node2, node2, 3);
8070: xmlResetLastError();
8071: if (mem_base != xmlMemBlocks()) {
8072: printf("Leak of %d blocks found in xmlShellWrite",
8073: xmlMemBlocks() - mem_base);
8074: test_ret++;
8075: printf(" %d", n_ctxt);
8076: printf(" %d", n_filename);
8077: printf(" %d", n_node);
8078: printf(" %d", n_node2);
8079: printf("\n");
8080: }
8081: }
8082: }
8083: }
8084: }
8085: function_tests++;
8086: #endif
8087:
8088: return(test_ret);
8089: }
8090:
8091: static int
8092: test_debugXML(void) {
8093: int test_ret = 0;
8094:
8095: if (quiet == 0) printf("Testing debugXML : 25 of 28 functions ...\n");
8096: test_ret += test_xmlBoolToText();
8097: test_ret += test_xmlDebugCheckDocument();
8098: test_ret += test_xmlDebugDumpAttr();
8099: test_ret += test_xmlDebugDumpAttrList();
8100: test_ret += test_xmlDebugDumpDTD();
8101: test_ret += test_xmlDebugDumpDocument();
8102: test_ret += test_xmlDebugDumpDocumentHead();
8103: test_ret += test_xmlDebugDumpEntities();
8104: test_ret += test_xmlDebugDumpNode();
8105: test_ret += test_xmlDebugDumpNodeList();
8106: test_ret += test_xmlDebugDumpOneNode();
8107: test_ret += test_xmlDebugDumpString();
8108: test_ret += test_xmlLsCountNode();
8109: test_ret += test_xmlLsOneNode();
8110: test_ret += test_xmlShell();
8111: test_ret += test_xmlShellBase();
8112: test_ret += test_xmlShellCat();
8113: test_ret += test_xmlShellDir();
8114: test_ret += test_xmlShellDu();
8115: test_ret += test_xmlShellList();
8116: test_ret += test_xmlShellLoad();
8117: test_ret += test_xmlShellPrintXPathResult();
8118: test_ret += test_xmlShellPwd();
8119: test_ret += test_xmlShellSave();
8120: test_ret += test_xmlShellValidate();
8121: test_ret += test_xmlShellWrite();
8122:
8123: if (test_ret != 0)
8124: printf("Module debugXML: %d errors\n", test_ret);
8125: return(test_ret);
8126: }
8127:
8128: static int
8129: test_xmlDictCleanup(void) {
8130: int test_ret = 0;
8131:
8132: int mem_base;
8133:
8134: mem_base = xmlMemBlocks();
8135:
8136: xmlDictCleanup();
8137: call_tests++;
8138: xmlResetLastError();
8139: if (mem_base != xmlMemBlocks()) {
8140: printf("Leak of %d blocks found in xmlDictCleanup",
8141: xmlMemBlocks() - mem_base);
8142: test_ret++;
8143: printf("\n");
8144: }
8145: function_tests++;
8146:
8147: return(test_ret);
8148: }
8149:
8150:
8151: static int
8152: test_xmlDictCreate(void) {
8153: int test_ret = 0;
8154:
8155: int mem_base;
8156: xmlDictPtr ret_val;
8157:
8158: mem_base = xmlMemBlocks();
8159:
8160: ret_val = xmlDictCreate();
8161: desret_xmlDictPtr(ret_val);
8162: call_tests++;
8163: xmlResetLastError();
8164: if (mem_base != xmlMemBlocks()) {
8165: printf("Leak of %d blocks found in xmlDictCreate",
8166: xmlMemBlocks() - mem_base);
8167: test_ret++;
8168: printf("\n");
8169: }
8170: function_tests++;
8171:
8172: return(test_ret);
8173: }
8174:
8175:
8176: static int
8177: test_xmlDictCreateSub(void) {
8178: int test_ret = 0;
8179:
8180: int mem_base;
8181: xmlDictPtr ret_val;
8182: xmlDictPtr sub; /* an existing dictionnary */
8183: int n_sub;
8184:
8185: for (n_sub = 0;n_sub < gen_nb_xmlDictPtr;n_sub++) {
8186: mem_base = xmlMemBlocks();
8187: sub = gen_xmlDictPtr(n_sub, 0);
8188:
8189: ret_val = xmlDictCreateSub(sub);
8190: desret_xmlDictPtr(ret_val);
8191: call_tests++;
8192: des_xmlDictPtr(n_sub, sub, 0);
8193: xmlResetLastError();
8194: if (mem_base != xmlMemBlocks()) {
8195: printf("Leak of %d blocks found in xmlDictCreateSub",
8196: xmlMemBlocks() - mem_base);
8197: test_ret++;
8198: printf(" %d", n_sub);
8199: printf("\n");
8200: }
8201: }
8202: function_tests++;
8203:
8204: return(test_ret);
8205: }
8206:
8207:
8208: static int
8209: test_xmlDictExists(void) {
8210: int test_ret = 0;
8211:
8212: int mem_base;
8213: const xmlChar * ret_val;
8214: xmlDictPtr dict; /* the dictionnary */
8215: int n_dict;
8216: xmlChar * name; /* the name of the userdata */
8217: int n_name;
8218: int len; /* the length of the name, if -1 it is recomputed */
8219: int n_len;
8220:
8221: for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) {
8222: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
8223: for (n_len = 0;n_len < gen_nb_int;n_len++) {
8224: mem_base = xmlMemBlocks();
8225: dict = gen_xmlDictPtr(n_dict, 0);
8226: name = gen_const_xmlChar_ptr(n_name, 1);
8227: len = gen_int(n_len, 2);
8228:
8229: ret_val = xmlDictExists(dict, (const xmlChar *)name, len);
8230: desret_const_xmlChar_ptr(ret_val);
8231: call_tests++;
8232: des_xmlDictPtr(n_dict, dict, 0);
8233: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
8234: des_int(n_len, len, 2);
8235: xmlResetLastError();
8236: if (mem_base != xmlMemBlocks()) {
8237: printf("Leak of %d blocks found in xmlDictExists",
8238: xmlMemBlocks() - mem_base);
8239: test_ret++;
8240: printf(" %d", n_dict);
8241: printf(" %d", n_name);
8242: printf(" %d", n_len);
8243: printf("\n");
8244: }
8245: }
8246: }
8247: }
8248: function_tests++;
8249:
8250: return(test_ret);
8251: }
8252:
8253:
8254: static int
8255: test_xmlDictLookup(void) {
8256: int test_ret = 0;
8257:
8258: int mem_base;
8259: const xmlChar * ret_val;
8260: xmlDictPtr dict; /* the dictionnary */
8261: int n_dict;
8262: xmlChar * name; /* the name of the userdata */
8263: int n_name;
8264: int len; /* the length of the name, if -1 it is recomputed */
8265: int n_len;
8266:
8267: for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) {
8268: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
8269: for (n_len = 0;n_len < gen_nb_int;n_len++) {
8270: mem_base = xmlMemBlocks();
8271: dict = gen_xmlDictPtr(n_dict, 0);
8272: name = gen_const_xmlChar_ptr(n_name, 1);
8273: len = gen_int(n_len, 2);
8274:
8275: ret_val = xmlDictLookup(dict, (const xmlChar *)name, len);
8276: desret_const_xmlChar_ptr(ret_val);
8277: call_tests++;
8278: des_xmlDictPtr(n_dict, dict, 0);
8279: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
8280: des_int(n_len, len, 2);
8281: xmlResetLastError();
8282: if (mem_base != xmlMemBlocks()) {
8283: printf("Leak of %d blocks found in xmlDictLookup",
8284: xmlMemBlocks() - mem_base);
8285: test_ret++;
8286: printf(" %d", n_dict);
8287: printf(" %d", n_name);
8288: printf(" %d", n_len);
8289: printf("\n");
8290: }
8291: }
8292: }
8293: }
8294: function_tests++;
8295:
8296: return(test_ret);
8297: }
8298:
8299:
8300: static int
8301: test_xmlDictOwns(void) {
8302: int test_ret = 0;
8303:
8304: int mem_base;
8305: int ret_val;
8306: xmlDictPtr dict; /* the dictionnary */
8307: int n_dict;
8308: xmlChar * str; /* the string */
8309: int n_str;
8310:
8311: for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) {
8312: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
8313: mem_base = xmlMemBlocks();
8314: dict = gen_xmlDictPtr(n_dict, 0);
8315: str = gen_const_xmlChar_ptr(n_str, 1);
8316:
8317: ret_val = xmlDictOwns(dict, (const xmlChar *)str);
8318: desret_int(ret_val);
8319: call_tests++;
8320: des_xmlDictPtr(n_dict, dict, 0);
8321: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
8322: xmlResetLastError();
8323: if (mem_base != xmlMemBlocks()) {
8324: printf("Leak of %d blocks found in xmlDictOwns",
8325: xmlMemBlocks() - mem_base);
8326: test_ret++;
8327: printf(" %d", n_dict);
8328: printf(" %d", n_str);
8329: printf("\n");
8330: }
8331: }
8332: }
8333: function_tests++;
8334:
8335: return(test_ret);
8336: }
8337:
8338:
8339: static int
8340: test_xmlDictQLookup(void) {
8341: int test_ret = 0;
8342:
8343: int mem_base;
8344: const xmlChar * ret_val;
8345: xmlDictPtr dict; /* the dictionnary */
8346: int n_dict;
8347: xmlChar * prefix; /* the prefix */
8348: int n_prefix;
8349: xmlChar * name; /* the name */
8350: int n_name;
8351:
8352: for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) {
8353: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
8354: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
8355: mem_base = xmlMemBlocks();
8356: dict = gen_xmlDictPtr(n_dict, 0);
8357: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
8358: name = gen_const_xmlChar_ptr(n_name, 2);
8359:
8360: ret_val = xmlDictQLookup(dict, (const xmlChar *)prefix, (const xmlChar *)name);
8361: desret_const_xmlChar_ptr(ret_val);
8362: call_tests++;
8363: des_xmlDictPtr(n_dict, dict, 0);
8364: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
8365: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
8366: xmlResetLastError();
8367: if (mem_base != xmlMemBlocks()) {
8368: printf("Leak of %d blocks found in xmlDictQLookup",
8369: xmlMemBlocks() - mem_base);
8370: test_ret++;
8371: printf(" %d", n_dict);
8372: printf(" %d", n_prefix);
8373: printf(" %d", n_name);
8374: printf("\n");
8375: }
8376: }
8377: }
8378: }
8379: function_tests++;
8380:
8381: return(test_ret);
8382: }
8383:
8384:
8385: static int
8386: test_xmlDictReference(void) {
8387: int test_ret = 0;
8388:
8389: int mem_base;
8390: int ret_val;
8391: xmlDictPtr dict; /* the dictionnary */
8392: int n_dict;
8393:
8394: for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) {
8395: mem_base = xmlMemBlocks();
8396: dict = gen_xmlDictPtr(n_dict, 0);
8397:
8398: ret_val = xmlDictReference(dict);
8399: xmlDictFree(dict);
8400: desret_int(ret_val);
8401: call_tests++;
8402: des_xmlDictPtr(n_dict, dict, 0);
8403: xmlResetLastError();
8404: if (mem_base != xmlMemBlocks()) {
8405: printf("Leak of %d blocks found in xmlDictReference",
8406: xmlMemBlocks() - mem_base);
8407: test_ret++;
8408: printf(" %d", n_dict);
8409: printf("\n");
8410: }
8411: }
8412: function_tests++;
8413:
8414: return(test_ret);
8415: }
8416:
8417:
8418: static int
8419: test_xmlDictSize(void) {
8420: int test_ret = 0;
8421:
8422: int mem_base;
8423: int ret_val;
8424: xmlDictPtr dict; /* the dictionnary */
8425: int n_dict;
8426:
8427: for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) {
8428: mem_base = xmlMemBlocks();
8429: dict = gen_xmlDictPtr(n_dict, 0);
8430:
8431: ret_val = xmlDictSize(dict);
8432: desret_int(ret_val);
8433: call_tests++;
8434: des_xmlDictPtr(n_dict, dict, 0);
8435: xmlResetLastError();
8436: if (mem_base != xmlMemBlocks()) {
8437: printf("Leak of %d blocks found in xmlDictSize",
8438: xmlMemBlocks() - mem_base);
8439: test_ret++;
8440: printf(" %d", n_dict);
8441: printf("\n");
8442: }
8443: }
8444: function_tests++;
8445:
8446: return(test_ret);
8447: }
8448:
8449: static int
8450: test_dict(void) {
8451: int test_ret = 0;
8452:
8453: if (quiet == 0) printf("Testing dict : 9 of 10 functions ...\n");
8454: test_ret += test_xmlDictCleanup();
8455: test_ret += test_xmlDictCreate();
8456: test_ret += test_xmlDictCreateSub();
8457: test_ret += test_xmlDictExists();
8458: test_ret += test_xmlDictLookup();
8459: test_ret += test_xmlDictOwns();
8460: test_ret += test_xmlDictQLookup();
8461: test_ret += test_xmlDictReference();
8462: test_ret += test_xmlDictSize();
8463:
8464: if (test_ret != 0)
8465: printf("Module dict: %d errors\n", test_ret);
8466: return(test_ret);
8467: }
8468:
8469: static int
8470: test_UTF8Toisolat1(void) {
8471: int test_ret = 0;
8472:
8473: #if defined(LIBXML_OUTPUT_ENABLED)
8474: #ifdef LIBXML_OUTPUT_ENABLED
8475: int mem_base;
8476: int ret_val;
8477: unsigned char * out; /* a pointer to an array of bytes to store the result */
8478: int n_out;
8479: int * outlen; /* the length of @out */
8480: int n_outlen;
8481: unsigned char * in; /* a pointer to an array of UTF-8 chars */
8482: int n_in;
8483: int * inlen; /* the length of @in */
8484: int n_inlen;
8485:
8486: for (n_out = 0;n_out < gen_nb_unsigned_char_ptr;n_out++) {
8487: for (n_outlen = 0;n_outlen < gen_nb_int_ptr;n_outlen++) {
8488: for (n_in = 0;n_in < gen_nb_const_unsigned_char_ptr;n_in++) {
8489: for (n_inlen = 0;n_inlen < gen_nb_int_ptr;n_inlen++) {
8490: mem_base = xmlMemBlocks();
8491: out = gen_unsigned_char_ptr(n_out, 0);
8492: outlen = gen_int_ptr(n_outlen, 1);
8493: in = gen_const_unsigned_char_ptr(n_in, 2);
8494: inlen = gen_int_ptr(n_inlen, 3);
8495:
8496: ret_val = UTF8Toisolat1(out, outlen, (const unsigned char *)in, inlen);
8497: desret_int(ret_val);
8498: call_tests++;
8499: des_unsigned_char_ptr(n_out, out, 0);
8500: des_int_ptr(n_outlen, outlen, 1);
8501: des_const_unsigned_char_ptr(n_in, (const unsigned char *)in, 2);
8502: des_int_ptr(n_inlen, inlen, 3);
8503: xmlResetLastError();
8504: if (mem_base != xmlMemBlocks()) {
8505: printf("Leak of %d blocks found in UTF8Toisolat1",
8506: xmlMemBlocks() - mem_base);
8507: test_ret++;
8508: printf(" %d", n_out);
8509: printf(" %d", n_outlen);
8510: printf(" %d", n_in);
8511: printf(" %d", n_inlen);
8512: printf("\n");
8513: }
8514: }
8515: }
8516: }
8517: }
8518: function_tests++;
8519: #endif
8520: #endif
8521:
8522: return(test_ret);
8523: }
8524:
8525:
8526: static int
8527: test_isolat1ToUTF8(void) {
8528: int test_ret = 0;
8529:
8530: int mem_base;
8531: int ret_val;
8532: unsigned char * out; /* a pointer to an array of bytes to store the result */
8533: int n_out;
8534: int * outlen; /* the length of @out */
8535: int n_outlen;
8536: unsigned char * in; /* a pointer to an array of ISO Latin 1 chars */
8537: int n_in;
8538: int * inlen; /* the length of @in */
8539: int n_inlen;
8540:
8541: for (n_out = 0;n_out < gen_nb_unsigned_char_ptr;n_out++) {
8542: for (n_outlen = 0;n_outlen < gen_nb_int_ptr;n_outlen++) {
8543: for (n_in = 0;n_in < gen_nb_const_unsigned_char_ptr;n_in++) {
8544: for (n_inlen = 0;n_inlen < gen_nb_int_ptr;n_inlen++) {
8545: mem_base = xmlMemBlocks();
8546: out = gen_unsigned_char_ptr(n_out, 0);
8547: outlen = gen_int_ptr(n_outlen, 1);
8548: in = gen_const_unsigned_char_ptr(n_in, 2);
8549: inlen = gen_int_ptr(n_inlen, 3);
8550:
8551: ret_val = isolat1ToUTF8(out, outlen, (const unsigned char *)in, inlen);
8552: desret_int(ret_val);
8553: call_tests++;
8554: des_unsigned_char_ptr(n_out, out, 0);
8555: des_int_ptr(n_outlen, outlen, 1);
8556: des_const_unsigned_char_ptr(n_in, (const unsigned char *)in, 2);
8557: des_int_ptr(n_inlen, inlen, 3);
8558: xmlResetLastError();
8559: if (mem_base != xmlMemBlocks()) {
8560: printf("Leak of %d blocks found in isolat1ToUTF8",
8561: xmlMemBlocks() - mem_base);
8562: test_ret++;
8563: printf(" %d", n_out);
8564: printf(" %d", n_outlen);
8565: printf(" %d", n_in);
8566: printf(" %d", n_inlen);
8567: printf("\n");
8568: }
8569: }
8570: }
8571: }
8572: }
8573: function_tests++;
8574:
8575: return(test_ret);
8576: }
8577:
8578:
8579: static int
8580: test_xmlAddEncodingAlias(void) {
8581: int test_ret = 0;
8582:
8583: int ret_val;
8584: char * name; /* the encoding name as parsed, in UTF-8 format (ASCII actually) */
8585: int n_name;
8586: char * alias; /* the alias name as parsed, in UTF-8 format (ASCII actually) */
8587: int n_alias;
8588:
8589: for (n_name = 0;n_name < gen_nb_const_char_ptr;n_name++) {
8590: for (n_alias = 0;n_alias < gen_nb_const_char_ptr;n_alias++) {
8591: name = gen_const_char_ptr(n_name, 0);
8592: alias = gen_const_char_ptr(n_alias, 1);
8593:
8594: ret_val = xmlAddEncodingAlias((const char *)name, (const char *)alias);
8595: desret_int(ret_val);
8596: call_tests++;
8597: des_const_char_ptr(n_name, (const char *)name, 0);
8598: des_const_char_ptr(n_alias, (const char *)alias, 1);
8599: xmlResetLastError();
8600: }
8601: }
8602: function_tests++;
8603:
8604: return(test_ret);
8605: }
8606:
8607:
8608: #define gen_nb_xmlCharEncodingHandler_ptr 1
8609: static xmlCharEncodingHandler * gen_xmlCharEncodingHandler_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
8610: return(NULL);
8611: }
8612: static void des_xmlCharEncodingHandler_ptr(int no ATTRIBUTE_UNUSED, xmlCharEncodingHandler * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
8613: }
8614:
8615: static int
8616: test_xmlCharEncCloseFunc(void) {
8617: int test_ret = 0;
8618:
8619: int mem_base;
8620: int ret_val;
8621: xmlCharEncodingHandler * handler; /* char enconding transformation data structure */
8622: int n_handler;
8623:
8624: for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandler_ptr;n_handler++) {
8625: mem_base = xmlMemBlocks();
8626: handler = gen_xmlCharEncodingHandler_ptr(n_handler, 0);
8627:
8628: ret_val = xmlCharEncCloseFunc(handler);
8629: desret_int(ret_val);
8630: call_tests++;
8631: des_xmlCharEncodingHandler_ptr(n_handler, handler, 0);
8632: xmlResetLastError();
8633: if (mem_base != xmlMemBlocks()) {
8634: printf("Leak of %d blocks found in xmlCharEncCloseFunc",
8635: xmlMemBlocks() - mem_base);
8636: test_ret++;
8637: printf(" %d", n_handler);
8638: printf("\n");
8639: }
8640: }
8641: function_tests++;
8642:
8643: return(test_ret);
8644: }
8645:
8646:
8647: static int
8648: test_xmlCharEncFirstLine(void) {
8649: int test_ret = 0;
8650:
8651: int mem_base;
8652: int ret_val;
8653: xmlCharEncodingHandler * handler; /* char enconding transformation data structure */
8654: int n_handler;
8655: xmlBufferPtr out; /* an xmlBuffer for the output. */
8656: int n_out;
8657: xmlBufferPtr in; /* an xmlBuffer for the input */
8658: int n_in;
8659:
8660: for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandler_ptr;n_handler++) {
8661: for (n_out = 0;n_out < gen_nb_xmlBufferPtr;n_out++) {
8662: for (n_in = 0;n_in < gen_nb_xmlBufferPtr;n_in++) {
8663: mem_base = xmlMemBlocks();
8664: handler = gen_xmlCharEncodingHandler_ptr(n_handler, 0);
8665: out = gen_xmlBufferPtr(n_out, 1);
8666: in = gen_xmlBufferPtr(n_in, 2);
8667:
8668: ret_val = xmlCharEncFirstLine(handler, out, in);
8669: desret_int(ret_val);
8670: call_tests++;
8671: des_xmlCharEncodingHandler_ptr(n_handler, handler, 0);
8672: des_xmlBufferPtr(n_out, out, 1);
8673: des_xmlBufferPtr(n_in, in, 2);
8674: xmlResetLastError();
8675: if (mem_base != xmlMemBlocks()) {
8676: printf("Leak of %d blocks found in xmlCharEncFirstLine",
8677: xmlMemBlocks() - mem_base);
8678: test_ret++;
8679: printf(" %d", n_handler);
8680: printf(" %d", n_out);
8681: printf(" %d", n_in);
8682: printf("\n");
8683: }
8684: }
8685: }
8686: }
8687: function_tests++;
8688:
8689: return(test_ret);
8690: }
8691:
8692:
8693: static int
8694: test_xmlCharEncInFunc(void) {
8695: int test_ret = 0;
8696:
8697: int mem_base;
8698: int ret_val;
8699: xmlCharEncodingHandler * handler; /* char encoding transformation data structure */
8700: int n_handler;
8701: xmlBufferPtr out; /* an xmlBuffer for the output. */
8702: int n_out;
8703: xmlBufferPtr in; /* an xmlBuffer for the input */
8704: int n_in;
8705:
8706: for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandler_ptr;n_handler++) {
8707: for (n_out = 0;n_out < gen_nb_xmlBufferPtr;n_out++) {
8708: for (n_in = 0;n_in < gen_nb_xmlBufferPtr;n_in++) {
8709: mem_base = xmlMemBlocks();
8710: handler = gen_xmlCharEncodingHandler_ptr(n_handler, 0);
8711: out = gen_xmlBufferPtr(n_out, 1);
8712: in = gen_xmlBufferPtr(n_in, 2);
8713:
8714: ret_val = xmlCharEncInFunc(handler, out, in);
8715: desret_int(ret_val);
8716: call_tests++;
8717: des_xmlCharEncodingHandler_ptr(n_handler, handler, 0);
8718: des_xmlBufferPtr(n_out, out, 1);
8719: des_xmlBufferPtr(n_in, in, 2);
8720: xmlResetLastError();
8721: if (mem_base != xmlMemBlocks()) {
8722: printf("Leak of %d blocks found in xmlCharEncInFunc",
8723: xmlMemBlocks() - mem_base);
8724: test_ret++;
8725: printf(" %d", n_handler);
8726: printf(" %d", n_out);
8727: printf(" %d", n_in);
8728: printf("\n");
8729: }
8730: }
8731: }
8732: }
8733: function_tests++;
8734:
8735: return(test_ret);
8736: }
8737:
8738:
8739: static int
8740: test_xmlCharEncOutFunc(void) {
8741: int test_ret = 0;
8742:
8743: int mem_base;
8744: int ret_val;
8745: xmlCharEncodingHandler * handler; /* char enconding transformation data structure */
8746: int n_handler;
8747: xmlBufferPtr out; /* an xmlBuffer for the output. */
8748: int n_out;
8749: xmlBufferPtr in; /* an xmlBuffer for the input */
8750: int n_in;
8751:
8752: for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandler_ptr;n_handler++) {
8753: for (n_out = 0;n_out < gen_nb_xmlBufferPtr;n_out++) {
8754: for (n_in = 0;n_in < gen_nb_xmlBufferPtr;n_in++) {
8755: mem_base = xmlMemBlocks();
8756: handler = gen_xmlCharEncodingHandler_ptr(n_handler, 0);
8757: out = gen_xmlBufferPtr(n_out, 1);
8758: in = gen_xmlBufferPtr(n_in, 2);
8759:
8760: ret_val = xmlCharEncOutFunc(handler, out, in);
8761: desret_int(ret_val);
8762: call_tests++;
8763: des_xmlCharEncodingHandler_ptr(n_handler, handler, 0);
8764: des_xmlBufferPtr(n_out, out, 1);
8765: des_xmlBufferPtr(n_in, in, 2);
8766: xmlResetLastError();
8767: if (mem_base != xmlMemBlocks()) {
8768: printf("Leak of %d blocks found in xmlCharEncOutFunc",
8769: xmlMemBlocks() - mem_base);
8770: test_ret++;
8771: printf(" %d", n_handler);
8772: printf(" %d", n_out);
8773: printf(" %d", n_in);
8774: printf("\n");
8775: }
8776: }
8777: }
8778: }
8779: function_tests++;
8780:
8781: return(test_ret);
8782: }
8783:
8784:
8785: static int
8786: test_xmlCleanupCharEncodingHandlers(void) {
8787: int test_ret = 0;
8788:
8789:
8790:
8791: xmlCleanupCharEncodingHandlers();
8792: call_tests++;
8793: xmlResetLastError();
8794: function_tests++;
8795:
8796: return(test_ret);
8797: }
8798:
8799:
8800: static int
8801: test_xmlCleanupEncodingAliases(void) {
8802: int test_ret = 0;
8803:
8804: int mem_base;
8805:
8806: mem_base = xmlMemBlocks();
8807:
8808: xmlCleanupEncodingAliases();
8809: call_tests++;
8810: xmlResetLastError();
8811: if (mem_base != xmlMemBlocks()) {
8812: printf("Leak of %d blocks found in xmlCleanupEncodingAliases",
8813: xmlMemBlocks() - mem_base);
8814: test_ret++;
8815: printf("\n");
8816: }
8817: function_tests++;
8818:
8819: return(test_ret);
8820: }
8821:
8822:
8823: static int
8824: test_xmlDelEncodingAlias(void) {
8825: int test_ret = 0;
8826:
8827: int mem_base;
8828: int ret_val;
8829: char * alias; /* the alias name as parsed, in UTF-8 format (ASCII actually) */
8830: int n_alias;
8831:
8832: for (n_alias = 0;n_alias < gen_nb_const_char_ptr;n_alias++) {
8833: mem_base = xmlMemBlocks();
8834: alias = gen_const_char_ptr(n_alias, 0);
8835:
8836: ret_val = xmlDelEncodingAlias((const char *)alias);
8837: desret_int(ret_val);
8838: call_tests++;
8839: des_const_char_ptr(n_alias, (const char *)alias, 0);
8840: xmlResetLastError();
8841: if (mem_base != xmlMemBlocks()) {
8842: printf("Leak of %d blocks found in xmlDelEncodingAlias",
8843: xmlMemBlocks() - mem_base);
8844: test_ret++;
8845: printf(" %d", n_alias);
8846: printf("\n");
8847: }
8848: }
8849: function_tests++;
8850:
8851: return(test_ret);
8852: }
8853:
8854:
8855: static int
8856: test_xmlDetectCharEncoding(void) {
8857: int test_ret = 0;
8858:
8859: int mem_base;
8860: xmlCharEncoding ret_val;
8861: unsigned char * in; /* a pointer to the first bytes of the XML entity, must be at least 2 bytes long (at least 4 if encoding is UTF4 variant). */
8862: int n_in;
8863: int len; /* pointer to the length of the buffer */
8864: int n_len;
8865:
8866: for (n_in = 0;n_in < gen_nb_const_unsigned_char_ptr;n_in++) {
8867: for (n_len = 0;n_len < gen_nb_int;n_len++) {
8868: mem_base = xmlMemBlocks();
8869: in = gen_const_unsigned_char_ptr(n_in, 0);
8870: len = gen_int(n_len, 1);
8871:
8872: ret_val = xmlDetectCharEncoding((const unsigned char *)in, len);
8873: desret_xmlCharEncoding(ret_val);
8874: call_tests++;
8875: des_const_unsigned_char_ptr(n_in, (const unsigned char *)in, 0);
8876: des_int(n_len, len, 1);
8877: xmlResetLastError();
8878: if (mem_base != xmlMemBlocks()) {
8879: printf("Leak of %d blocks found in xmlDetectCharEncoding",
8880: xmlMemBlocks() - mem_base);
8881: test_ret++;
8882: printf(" %d", n_in);
8883: printf(" %d", n_len);
8884: printf("\n");
8885: }
8886: }
8887: }
8888: function_tests++;
8889:
8890: return(test_ret);
8891: }
8892:
8893:
8894: static int
8895: test_xmlFindCharEncodingHandler(void) {
8896: int test_ret = 0;
8897:
8898:
8899: /* missing type support */
8900: return(test_ret);
8901: }
8902:
8903:
8904: static int
8905: test_xmlGetCharEncodingHandler(void) {
8906: int test_ret = 0;
8907:
8908:
8909: /* missing type support */
8910: return(test_ret);
8911: }
8912:
8913:
8914: static int
8915: test_xmlGetCharEncodingName(void) {
8916: int test_ret = 0;
8917:
8918: int mem_base;
8919: const char * ret_val;
8920: xmlCharEncoding enc; /* the encoding */
8921: int n_enc;
8922:
8923: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
8924: mem_base = xmlMemBlocks();
8925: enc = gen_xmlCharEncoding(n_enc, 0);
8926:
8927: ret_val = xmlGetCharEncodingName(enc);
8928: desret_const_char_ptr(ret_val);
8929: call_tests++;
8930: des_xmlCharEncoding(n_enc, enc, 0);
8931: xmlResetLastError();
8932: if (mem_base != xmlMemBlocks()) {
8933: printf("Leak of %d blocks found in xmlGetCharEncodingName",
8934: xmlMemBlocks() - mem_base);
8935: test_ret++;
8936: printf(" %d", n_enc);
8937: printf("\n");
8938: }
8939: }
8940: function_tests++;
8941:
8942: return(test_ret);
8943: }
8944:
8945:
8946: static int
8947: test_xmlGetEncodingAlias(void) {
8948: int test_ret = 0;
8949:
8950: int mem_base;
8951: const char * ret_val;
8952: char * alias; /* the alias name as parsed, in UTF-8 format (ASCII actually) */
8953: int n_alias;
8954:
8955: for (n_alias = 0;n_alias < gen_nb_const_char_ptr;n_alias++) {
8956: mem_base = xmlMemBlocks();
8957: alias = gen_const_char_ptr(n_alias, 0);
8958:
8959: ret_val = xmlGetEncodingAlias((const char *)alias);
8960: desret_const_char_ptr(ret_val);
8961: call_tests++;
8962: des_const_char_ptr(n_alias, (const char *)alias, 0);
8963: xmlResetLastError();
8964: if (mem_base != xmlMemBlocks()) {
8965: printf("Leak of %d blocks found in xmlGetEncodingAlias",
8966: xmlMemBlocks() - mem_base);
8967: test_ret++;
8968: printf(" %d", n_alias);
8969: printf("\n");
8970: }
8971: }
8972: function_tests++;
8973:
8974: return(test_ret);
8975: }
8976:
8977:
8978: static int
8979: test_xmlInitCharEncodingHandlers(void) {
8980: int test_ret = 0;
8981:
8982:
8983:
8984: xmlInitCharEncodingHandlers();
8985: call_tests++;
8986: xmlResetLastError();
8987: function_tests++;
8988:
8989: return(test_ret);
8990: }
8991:
8992:
8993: static int
8994: test_xmlNewCharEncodingHandler(void) {
8995: int test_ret = 0;
8996:
8997:
8998: /* missing type support */
8999: return(test_ret);
9000: }
9001:
9002:
9003: static int
9004: test_xmlParseCharEncoding(void) {
9005: int test_ret = 0;
9006:
9007: int mem_base;
9008: xmlCharEncoding ret_val;
9009: char * name; /* the encoding name as parsed, in UTF-8 format (ASCII actually) */
9010: int n_name;
9011:
9012: for (n_name = 0;n_name < gen_nb_const_char_ptr;n_name++) {
9013: mem_base = xmlMemBlocks();
9014: name = gen_const_char_ptr(n_name, 0);
9015:
9016: ret_val = xmlParseCharEncoding((const char *)name);
9017: desret_xmlCharEncoding(ret_val);
9018: call_tests++;
9019: des_const_char_ptr(n_name, (const char *)name, 0);
9020: xmlResetLastError();
9021: if (mem_base != xmlMemBlocks()) {
9022: printf("Leak of %d blocks found in xmlParseCharEncoding",
9023: xmlMemBlocks() - mem_base);
9024: test_ret++;
9025: printf(" %d", n_name);
9026: printf("\n");
9027: }
9028: }
9029: function_tests++;
9030:
9031: return(test_ret);
9032: }
9033:
9034:
9035: #define gen_nb_xmlCharEncodingHandlerPtr 1
9036: static xmlCharEncodingHandlerPtr gen_xmlCharEncodingHandlerPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
9037: return(NULL);
9038: }
9039: static void des_xmlCharEncodingHandlerPtr(int no ATTRIBUTE_UNUSED, xmlCharEncodingHandlerPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
9040: }
9041:
9042: static int
9043: test_xmlRegisterCharEncodingHandler(void) {
9044: int test_ret = 0;
9045:
9046: int mem_base;
9047: xmlCharEncodingHandlerPtr handler; /* the xmlCharEncodingHandlerPtr handler block */
9048: int n_handler;
9049:
9050: for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandlerPtr;n_handler++) {
9051: mem_base = xmlMemBlocks();
9052: handler = gen_xmlCharEncodingHandlerPtr(n_handler, 0);
9053:
9054: xmlRegisterCharEncodingHandler(handler);
9055: call_tests++;
9056: des_xmlCharEncodingHandlerPtr(n_handler, handler, 0);
9057: xmlResetLastError();
9058: if (mem_base != xmlMemBlocks()) {
9059: printf("Leak of %d blocks found in xmlRegisterCharEncodingHandler",
9060: xmlMemBlocks() - mem_base);
9061: test_ret++;
9062: printf(" %d", n_handler);
9063: printf("\n");
9064: }
9065: }
9066: function_tests++;
9067:
9068: return(test_ret);
9069: }
9070:
9071: static int
9072: test_encoding(void) {
9073: int test_ret = 0;
9074:
9075: if (quiet == 0) printf("Testing encoding : 16 of 19 functions ...\n");
9076: test_ret += test_UTF8Toisolat1();
9077: test_ret += test_isolat1ToUTF8();
9078: test_ret += test_xmlAddEncodingAlias();
9079: test_ret += test_xmlCharEncCloseFunc();
9080: test_ret += test_xmlCharEncFirstLine();
9081: test_ret += test_xmlCharEncInFunc();
9082: test_ret += test_xmlCharEncOutFunc();
9083: test_ret += test_xmlCleanupCharEncodingHandlers();
9084: test_ret += test_xmlCleanupEncodingAliases();
9085: test_ret += test_xmlDelEncodingAlias();
9086: test_ret += test_xmlDetectCharEncoding();
9087: test_ret += test_xmlFindCharEncodingHandler();
9088: test_ret += test_xmlGetCharEncodingHandler();
9089: test_ret += test_xmlGetCharEncodingName();
9090: test_ret += test_xmlGetEncodingAlias();
9091: test_ret += test_xmlInitCharEncodingHandlers();
9092: test_ret += test_xmlNewCharEncodingHandler();
9093: test_ret += test_xmlParseCharEncoding();
9094: test_ret += test_xmlRegisterCharEncodingHandler();
9095:
9096: if (test_ret != 0)
9097: printf("Module encoding: %d errors\n", test_ret);
9098: return(test_ret);
9099: }
9100:
9101: static int
9102: test_xmlAddDocEntity(void) {
9103: int test_ret = 0;
9104:
9105: int mem_base;
9106: xmlEntityPtr ret_val;
9107: xmlDocPtr doc; /* the document */
9108: int n_doc;
9109: xmlChar * name; /* the entity name */
9110: int n_name;
9111: int type; /* the entity type XML_xxx_yyy_ENTITY */
9112: int n_type;
9113: xmlChar * ExternalID; /* the entity external ID if available */
9114: int n_ExternalID;
9115: xmlChar * SystemID; /* the entity system ID if available */
9116: int n_SystemID;
9117: xmlChar * content; /* the entity content */
9118: int n_content;
9119:
9120: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
9121: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9122: for (n_type = 0;n_type < gen_nb_int;n_type++) {
9123: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
9124: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
9125: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
9126: mem_base = xmlMemBlocks();
9127: doc = gen_xmlDocPtr(n_doc, 0);
9128: name = gen_const_xmlChar_ptr(n_name, 1);
9129: type = gen_int(n_type, 2);
9130: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 3);
9131: SystemID = gen_const_xmlChar_ptr(n_SystemID, 4);
9132: content = gen_const_xmlChar_ptr(n_content, 5);
9133:
9134: ret_val = xmlAddDocEntity(doc, (const xmlChar *)name, type, (const xmlChar *)ExternalID, (const xmlChar *)SystemID, (const xmlChar *)content);
9135: desret_xmlEntityPtr(ret_val);
9136: call_tests++;
9137: des_xmlDocPtr(n_doc, doc, 0);
9138: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9139: des_int(n_type, type, 2);
9140: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 3);
9141: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 4);
9142: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 5);
9143: xmlResetLastError();
9144: if (mem_base != xmlMemBlocks()) {
9145: printf("Leak of %d blocks found in xmlAddDocEntity",
9146: xmlMemBlocks() - mem_base);
9147: test_ret++;
9148: printf(" %d", n_doc);
9149: printf(" %d", n_name);
9150: printf(" %d", n_type);
9151: printf(" %d", n_ExternalID);
9152: printf(" %d", n_SystemID);
9153: printf(" %d", n_content);
9154: printf("\n");
9155: }
9156: }
9157: }
9158: }
9159: }
9160: }
9161: }
9162: function_tests++;
9163:
9164: return(test_ret);
9165: }
9166:
9167:
9168: static int
9169: test_xmlAddDtdEntity(void) {
9170: int test_ret = 0;
9171:
9172: int mem_base;
9173: xmlEntityPtr ret_val;
9174: xmlDocPtr doc; /* the document */
9175: int n_doc;
9176: xmlChar * name; /* the entity name */
9177: int n_name;
9178: int type; /* the entity type XML_xxx_yyy_ENTITY */
9179: int n_type;
9180: xmlChar * ExternalID; /* the entity external ID if available */
9181: int n_ExternalID;
9182: xmlChar * SystemID; /* the entity system ID if available */
9183: int n_SystemID;
9184: xmlChar * content; /* the entity content */
9185: int n_content;
9186:
9187: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
9188: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9189: for (n_type = 0;n_type < gen_nb_int;n_type++) {
9190: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
9191: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
9192: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
9193: mem_base = xmlMemBlocks();
9194: doc = gen_xmlDocPtr(n_doc, 0);
9195: name = gen_const_xmlChar_ptr(n_name, 1);
9196: type = gen_int(n_type, 2);
9197: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 3);
9198: SystemID = gen_const_xmlChar_ptr(n_SystemID, 4);
9199: content = gen_const_xmlChar_ptr(n_content, 5);
9200:
9201: ret_val = xmlAddDtdEntity(doc, (const xmlChar *)name, type, (const xmlChar *)ExternalID, (const xmlChar *)SystemID, (const xmlChar *)content);
9202: desret_xmlEntityPtr(ret_val);
9203: call_tests++;
9204: des_xmlDocPtr(n_doc, doc, 0);
9205: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9206: des_int(n_type, type, 2);
9207: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 3);
9208: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 4);
9209: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 5);
9210: xmlResetLastError();
9211: if (mem_base != xmlMemBlocks()) {
9212: printf("Leak of %d blocks found in xmlAddDtdEntity",
9213: xmlMemBlocks() - mem_base);
9214: test_ret++;
9215: printf(" %d", n_doc);
9216: printf(" %d", n_name);
9217: printf(" %d", n_type);
9218: printf(" %d", n_ExternalID);
9219: printf(" %d", n_SystemID);
9220: printf(" %d", n_content);
9221: printf("\n");
9222: }
9223: }
9224: }
9225: }
9226: }
9227: }
9228: }
9229: function_tests++;
9230:
9231: return(test_ret);
9232: }
9233:
9234:
9235: static int
9236: test_xmlCleanupPredefinedEntities(void) {
9237: int test_ret = 0;
9238:
9239: #if defined(LIBXML_LEGACY_ENABLED)
9240: #ifdef LIBXML_LEGACY_ENABLED
9241: int mem_base;
9242:
9243: mem_base = xmlMemBlocks();
9244:
9245: xmlCleanupPredefinedEntities();
9246: call_tests++;
9247: xmlResetLastError();
9248: if (mem_base != xmlMemBlocks()) {
9249: printf("Leak of %d blocks found in xmlCleanupPredefinedEntities",
9250: xmlMemBlocks() - mem_base);
9251: test_ret++;
9252: printf("\n");
9253: }
9254: function_tests++;
9255: #endif
9256: #endif
9257:
9258: return(test_ret);
9259: }
9260:
9261:
9262: #define gen_nb_xmlEntitiesTablePtr 1
9263: static xmlEntitiesTablePtr gen_xmlEntitiesTablePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
9264: return(NULL);
9265: }
9266: static void des_xmlEntitiesTablePtr(int no ATTRIBUTE_UNUSED, xmlEntitiesTablePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
9267: }
9268:
9269: static int
9270: test_xmlCopyEntitiesTable(void) {
9271: int test_ret = 0;
9272:
9273:
9274: /* missing type support */
9275: return(test_ret);
9276: }
9277:
9278:
9279: static int
9280: test_xmlCreateEntitiesTable(void) {
9281: int test_ret = 0;
9282:
9283:
9284: /* missing type support */
9285: return(test_ret);
9286: }
9287:
9288:
9289: static int
9290: test_xmlDumpEntitiesTable(void) {
9291: int test_ret = 0;
9292:
9293: #if defined(LIBXML_OUTPUT_ENABLED)
9294: int mem_base;
9295: xmlBufferPtr buf; /* An XML buffer. */
9296: int n_buf;
9297: xmlEntitiesTablePtr table; /* An entity table */
9298: int n_table;
9299:
9300: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
9301: for (n_table = 0;n_table < gen_nb_xmlEntitiesTablePtr;n_table++) {
9302: mem_base = xmlMemBlocks();
9303: buf = gen_xmlBufferPtr(n_buf, 0);
9304: table = gen_xmlEntitiesTablePtr(n_table, 1);
9305:
9306: xmlDumpEntitiesTable(buf, table);
9307: call_tests++;
9308: des_xmlBufferPtr(n_buf, buf, 0);
9309: des_xmlEntitiesTablePtr(n_table, table, 1);
9310: xmlResetLastError();
9311: if (mem_base != xmlMemBlocks()) {
9312: printf("Leak of %d blocks found in xmlDumpEntitiesTable",
9313: xmlMemBlocks() - mem_base);
9314: test_ret++;
9315: printf(" %d", n_buf);
9316: printf(" %d", n_table);
9317: printf("\n");
9318: }
9319: }
9320: }
9321: function_tests++;
9322: #endif
9323:
9324: return(test_ret);
9325: }
9326:
9327:
9328: #define gen_nb_xmlEntityPtr 1
9329: static xmlEntityPtr gen_xmlEntityPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
9330: return(NULL);
9331: }
9332: static void des_xmlEntityPtr(int no ATTRIBUTE_UNUSED, xmlEntityPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
9333: }
9334:
9335: static int
9336: test_xmlDumpEntityDecl(void) {
9337: int test_ret = 0;
9338:
9339: #if defined(LIBXML_OUTPUT_ENABLED)
9340: int mem_base;
9341: xmlBufferPtr buf; /* An XML buffer. */
9342: int n_buf;
9343: xmlEntityPtr ent; /* An entity table */
9344: int n_ent;
9345:
9346: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
9347: for (n_ent = 0;n_ent < gen_nb_xmlEntityPtr;n_ent++) {
9348: mem_base = xmlMemBlocks();
9349: buf = gen_xmlBufferPtr(n_buf, 0);
9350: ent = gen_xmlEntityPtr(n_ent, 1);
9351:
9352: xmlDumpEntityDecl(buf, ent);
9353: call_tests++;
9354: des_xmlBufferPtr(n_buf, buf, 0);
9355: des_xmlEntityPtr(n_ent, ent, 1);
9356: xmlResetLastError();
9357: if (mem_base != xmlMemBlocks()) {
9358: printf("Leak of %d blocks found in xmlDumpEntityDecl",
9359: xmlMemBlocks() - mem_base);
9360: test_ret++;
9361: printf(" %d", n_buf);
9362: printf(" %d", n_ent);
9363: printf("\n");
9364: }
9365: }
9366: }
9367: function_tests++;
9368: #endif
9369:
9370: return(test_ret);
9371: }
9372:
9373:
9374: static int
9375: test_xmlEncodeEntitiesReentrant(void) {
9376: int test_ret = 0;
9377:
9378: int mem_base;
9379: xmlChar * ret_val;
9380: xmlDocPtr doc; /* the document containing the string */
9381: int n_doc;
9382: xmlChar * input; /* A string to convert to XML. */
9383: int n_input;
9384:
9385: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
9386: for (n_input = 0;n_input < gen_nb_const_xmlChar_ptr;n_input++) {
9387: mem_base = xmlMemBlocks();
9388: doc = gen_xmlDocPtr(n_doc, 0);
9389: input = gen_const_xmlChar_ptr(n_input, 1);
9390:
9391: ret_val = xmlEncodeEntitiesReentrant(doc, (const xmlChar *)input);
9392: desret_xmlChar_ptr(ret_val);
9393: call_tests++;
9394: des_xmlDocPtr(n_doc, doc, 0);
9395: des_const_xmlChar_ptr(n_input, (const xmlChar *)input, 1);
9396: xmlResetLastError();
9397: if (mem_base != xmlMemBlocks()) {
9398: printf("Leak of %d blocks found in xmlEncodeEntitiesReentrant",
9399: xmlMemBlocks() - mem_base);
9400: test_ret++;
9401: printf(" %d", n_doc);
9402: printf(" %d", n_input);
9403: printf("\n");
9404: }
9405: }
9406: }
9407: function_tests++;
9408:
9409: return(test_ret);
9410: }
9411:
9412:
9413: static int
9414: test_xmlEncodeSpecialChars(void) {
9415: int test_ret = 0;
9416:
9417: int mem_base;
9418: xmlChar * ret_val;
9419: xmlDocPtr doc; /* the document containing the string */
9420: int n_doc;
9421: xmlChar * input; /* A string to convert to XML. */
9422: int n_input;
9423:
9424: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
9425: for (n_input = 0;n_input < gen_nb_const_xmlChar_ptr;n_input++) {
9426: mem_base = xmlMemBlocks();
9427: doc = gen_xmlDocPtr(n_doc, 0);
9428: input = gen_const_xmlChar_ptr(n_input, 1);
9429:
9430: ret_val = xmlEncodeSpecialChars(doc, (const xmlChar *)input);
9431: desret_xmlChar_ptr(ret_val);
9432: call_tests++;
9433: des_xmlDocPtr(n_doc, doc, 0);
9434: des_const_xmlChar_ptr(n_input, (const xmlChar *)input, 1);
9435: xmlResetLastError();
9436: if (mem_base != xmlMemBlocks()) {
9437: printf("Leak of %d blocks found in xmlEncodeSpecialChars",
9438: xmlMemBlocks() - mem_base);
9439: test_ret++;
9440: printf(" %d", n_doc);
9441: printf(" %d", n_input);
9442: printf("\n");
9443: }
9444: }
9445: }
9446: function_tests++;
9447:
9448: return(test_ret);
9449: }
9450:
9451:
9452: static int
9453: test_xmlGetDocEntity(void) {
9454: int test_ret = 0;
9455:
9456: int mem_base;
9457: xmlEntityPtr ret_val;
9458: xmlDocPtr doc; /* the document referencing the entity */
9459: int n_doc;
9460: xmlChar * name; /* the entity name */
9461: int n_name;
9462:
9463: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
9464: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9465: mem_base = xmlMemBlocks();
9466: doc = gen_xmlDocPtr(n_doc, 0);
9467: name = gen_const_xmlChar_ptr(n_name, 1);
9468:
9469: ret_val = xmlGetDocEntity(doc, (const xmlChar *)name);
9470: desret_xmlEntityPtr(ret_val);
9471: call_tests++;
9472: des_xmlDocPtr(n_doc, doc, 0);
9473: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9474: xmlResetLastError();
9475: if (mem_base != xmlMemBlocks()) {
9476: printf("Leak of %d blocks found in xmlGetDocEntity",
9477: xmlMemBlocks() - mem_base);
9478: test_ret++;
9479: printf(" %d", n_doc);
9480: printf(" %d", n_name);
9481: printf("\n");
9482: }
9483: }
9484: }
9485: function_tests++;
9486:
9487: return(test_ret);
9488: }
9489:
9490:
9491: static int
9492: test_xmlGetDtdEntity(void) {
9493: int test_ret = 0;
9494:
9495: int mem_base;
9496: xmlEntityPtr ret_val;
9497: xmlDocPtr doc; /* the document referencing the entity */
9498: int n_doc;
9499: xmlChar * name; /* the entity name */
9500: int n_name;
9501:
9502: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
9503: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9504: mem_base = xmlMemBlocks();
9505: doc = gen_xmlDocPtr(n_doc, 0);
9506: name = gen_const_xmlChar_ptr(n_name, 1);
9507:
9508: ret_val = xmlGetDtdEntity(doc, (const xmlChar *)name);
9509: desret_xmlEntityPtr(ret_val);
9510: call_tests++;
9511: des_xmlDocPtr(n_doc, doc, 0);
9512: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9513: xmlResetLastError();
9514: if (mem_base != xmlMemBlocks()) {
9515: printf("Leak of %d blocks found in xmlGetDtdEntity",
9516: xmlMemBlocks() - mem_base);
9517: test_ret++;
9518: printf(" %d", n_doc);
9519: printf(" %d", n_name);
9520: printf("\n");
9521: }
9522: }
9523: }
9524: function_tests++;
9525:
9526: return(test_ret);
9527: }
9528:
9529:
9530: static int
9531: test_xmlGetParameterEntity(void) {
9532: int test_ret = 0;
9533:
9534: int mem_base;
9535: xmlEntityPtr ret_val;
9536: xmlDocPtr doc; /* the document referencing the entity */
9537: int n_doc;
9538: xmlChar * name; /* the entity name */
9539: int n_name;
9540:
9541: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
9542: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9543: mem_base = xmlMemBlocks();
9544: doc = gen_xmlDocPtr(n_doc, 0);
9545: name = gen_const_xmlChar_ptr(n_name, 1);
9546:
9547: ret_val = xmlGetParameterEntity(doc, (const xmlChar *)name);
9548: desret_xmlEntityPtr(ret_val);
9549: call_tests++;
9550: des_xmlDocPtr(n_doc, doc, 0);
9551: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9552: xmlResetLastError();
9553: if (mem_base != xmlMemBlocks()) {
9554: printf("Leak of %d blocks found in xmlGetParameterEntity",
9555: xmlMemBlocks() - mem_base);
9556: test_ret++;
9557: printf(" %d", n_doc);
9558: printf(" %d", n_name);
9559: printf("\n");
9560: }
9561: }
9562: }
9563: function_tests++;
9564:
9565: return(test_ret);
9566: }
9567:
9568:
9569: static int
9570: test_xmlGetPredefinedEntity(void) {
9571: int test_ret = 0;
9572:
9573: int mem_base;
9574: xmlEntityPtr ret_val;
9575: xmlChar * name; /* the entity name */
9576: int n_name;
9577:
9578: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9579: mem_base = xmlMemBlocks();
9580: name = gen_const_xmlChar_ptr(n_name, 0);
9581:
9582: ret_val = xmlGetPredefinedEntity((const xmlChar *)name);
9583: desret_xmlEntityPtr(ret_val);
9584: call_tests++;
9585: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
9586: xmlResetLastError();
9587: if (mem_base != xmlMemBlocks()) {
9588: printf("Leak of %d blocks found in xmlGetPredefinedEntity",
9589: xmlMemBlocks() - mem_base);
9590: test_ret++;
9591: printf(" %d", n_name);
9592: printf("\n");
9593: }
9594: }
9595: function_tests++;
9596:
9597: return(test_ret);
9598: }
9599:
9600:
9601: static int
9602: test_xmlInitializePredefinedEntities(void) {
9603: int test_ret = 0;
9604:
9605: #if defined(LIBXML_LEGACY_ENABLED)
9606: #ifdef LIBXML_LEGACY_ENABLED
9607: int mem_base;
9608:
9609: mem_base = xmlMemBlocks();
9610:
9611: xmlInitializePredefinedEntities();
9612: call_tests++;
9613: xmlResetLastError();
9614: if (mem_base != xmlMemBlocks()) {
9615: printf("Leak of %d blocks found in xmlInitializePredefinedEntities",
9616: xmlMemBlocks() - mem_base);
9617: test_ret++;
9618: printf("\n");
9619: }
9620: function_tests++;
9621: #endif
9622: #endif
9623:
9624: return(test_ret);
9625: }
9626:
9627:
9628: static int
9629: test_xmlNewEntity(void) {
9630: int test_ret = 0;
9631:
9632: int mem_base;
9633: xmlEntityPtr ret_val;
9634: xmlDocPtr doc; /* the document */
9635: int n_doc;
9636: xmlChar * name; /* the entity name */
9637: int n_name;
9638: int type; /* the entity type XML_xxx_yyy_ENTITY */
9639: int n_type;
9640: xmlChar * ExternalID; /* the entity external ID if available */
9641: int n_ExternalID;
9642: xmlChar * SystemID; /* the entity system ID if available */
9643: int n_SystemID;
9644: xmlChar * content; /* the entity content */
9645: int n_content;
9646:
9647: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
9648: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9649: for (n_type = 0;n_type < gen_nb_int;n_type++) {
9650: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
9651: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
9652: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
9653: mem_base = xmlMemBlocks();
9654: doc = gen_xmlDocPtr(n_doc, 0);
9655: name = gen_const_xmlChar_ptr(n_name, 1);
9656: type = gen_int(n_type, 2);
9657: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 3);
9658: SystemID = gen_const_xmlChar_ptr(n_SystemID, 4);
9659: content = gen_const_xmlChar_ptr(n_content, 5);
9660:
9661: ret_val = xmlNewEntity(doc, (const xmlChar *)name, type, (const xmlChar *)ExternalID, (const xmlChar *)SystemID, (const xmlChar *)content);
9662: desret_xmlEntityPtr(ret_val);
9663: call_tests++;
9664: des_xmlDocPtr(n_doc, doc, 0);
9665: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9666: des_int(n_type, type, 2);
9667: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 3);
9668: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 4);
9669: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 5);
9670: xmlResetLastError();
9671: if (mem_base != xmlMemBlocks()) {
9672: printf("Leak of %d blocks found in xmlNewEntity",
9673: xmlMemBlocks() - mem_base);
9674: test_ret++;
9675: printf(" %d", n_doc);
9676: printf(" %d", n_name);
9677: printf(" %d", n_type);
9678: printf(" %d", n_ExternalID);
9679: printf(" %d", n_SystemID);
9680: printf(" %d", n_content);
9681: printf("\n");
9682: }
9683: }
9684: }
9685: }
9686: }
9687: }
9688: }
9689: function_tests++;
9690:
9691: return(test_ret);
9692: }
9693:
9694: static int
9695: test_entities(void) {
9696: int test_ret = 0;
9697:
9698: if (quiet == 0) printf("Testing entities : 13 of 17 functions ...\n");
9699: test_ret += test_xmlAddDocEntity();
9700: test_ret += test_xmlAddDtdEntity();
9701: test_ret += test_xmlCleanupPredefinedEntities();
9702: test_ret += test_xmlCopyEntitiesTable();
9703: test_ret += test_xmlCreateEntitiesTable();
9704: test_ret += test_xmlDumpEntitiesTable();
9705: test_ret += test_xmlDumpEntityDecl();
9706: test_ret += test_xmlEncodeEntitiesReentrant();
9707: test_ret += test_xmlEncodeSpecialChars();
9708: test_ret += test_xmlGetDocEntity();
9709: test_ret += test_xmlGetDtdEntity();
9710: test_ret += test_xmlGetParameterEntity();
9711: test_ret += test_xmlGetPredefinedEntity();
9712: test_ret += test_xmlInitializePredefinedEntities();
9713: test_ret += test_xmlNewEntity();
9714:
9715: if (test_ret != 0)
9716: printf("Module entities: %d errors\n", test_ret);
9717: return(test_ret);
9718: }
9719:
9720: static int
9721: test_xmlHashAddEntry(void) {
9722: int test_ret = 0;
9723:
9724: int mem_base;
9725: int ret_val;
9726: xmlHashTablePtr table; /* the hash table */
9727: int n_table;
9728: xmlChar * name; /* the name of the userdata */
9729: int n_name;
9730: void * userdata; /* a pointer to the userdata */
9731: int n_userdata;
9732:
9733: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
9734: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9735: for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) {
9736: mem_base = xmlMemBlocks();
9737: table = gen_xmlHashTablePtr(n_table, 0);
9738: name = gen_const_xmlChar_ptr(n_name, 1);
9739: userdata = gen_userdata(n_userdata, 2);
9740:
9741: ret_val = xmlHashAddEntry(table, (const xmlChar *)name, userdata);
9742: desret_int(ret_val);
9743: call_tests++;
9744: des_xmlHashTablePtr(n_table, table, 0);
9745: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9746: des_userdata(n_userdata, userdata, 2);
9747: xmlResetLastError();
9748: if (mem_base != xmlMemBlocks()) {
9749: printf("Leak of %d blocks found in xmlHashAddEntry",
9750: xmlMemBlocks() - mem_base);
9751: test_ret++;
9752: printf(" %d", n_table);
9753: printf(" %d", n_name);
9754: printf(" %d", n_userdata);
9755: printf("\n");
9756: }
9757: }
9758: }
9759: }
9760: function_tests++;
9761:
9762: return(test_ret);
9763: }
9764:
9765:
9766: static int
9767: test_xmlHashAddEntry2(void) {
9768: int test_ret = 0;
9769:
9770: int mem_base;
9771: int ret_val;
9772: xmlHashTablePtr table; /* the hash table */
9773: int n_table;
9774: xmlChar * name; /* the name of the userdata */
9775: int n_name;
9776: xmlChar * name2; /* a second name of the userdata */
9777: int n_name2;
9778: void * userdata; /* a pointer to the userdata */
9779: int n_userdata;
9780:
9781: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
9782: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9783: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
9784: for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) {
9785: mem_base = xmlMemBlocks();
9786: table = gen_xmlHashTablePtr(n_table, 0);
9787: name = gen_const_xmlChar_ptr(n_name, 1);
9788: name2 = gen_const_xmlChar_ptr(n_name2, 2);
9789: userdata = gen_userdata(n_userdata, 3);
9790:
9791: ret_val = xmlHashAddEntry2(table, (const xmlChar *)name, (const xmlChar *)name2, userdata);
9792: desret_int(ret_val);
9793: call_tests++;
9794: des_xmlHashTablePtr(n_table, table, 0);
9795: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9796: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
9797: des_userdata(n_userdata, userdata, 3);
9798: xmlResetLastError();
9799: if (mem_base != xmlMemBlocks()) {
9800: printf("Leak of %d blocks found in xmlHashAddEntry2",
9801: xmlMemBlocks() - mem_base);
9802: test_ret++;
9803: printf(" %d", n_table);
9804: printf(" %d", n_name);
9805: printf(" %d", n_name2);
9806: printf(" %d", n_userdata);
9807: printf("\n");
9808: }
9809: }
9810: }
9811: }
9812: }
9813: function_tests++;
9814:
9815: return(test_ret);
9816: }
9817:
9818:
9819: static int
9820: test_xmlHashAddEntry3(void) {
9821: int test_ret = 0;
9822:
9823: int mem_base;
9824: int ret_val;
9825: xmlHashTablePtr table; /* the hash table */
9826: int n_table;
9827: xmlChar * name; /* the name of the userdata */
9828: int n_name;
9829: xmlChar * name2; /* a second name of the userdata */
9830: int n_name2;
9831: xmlChar * name3; /* a third name of the userdata */
9832: int n_name3;
9833: void * userdata; /* a pointer to the userdata */
9834: int n_userdata;
9835:
9836: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
9837: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9838: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
9839: for (n_name3 = 0;n_name3 < gen_nb_const_xmlChar_ptr;n_name3++) {
9840: for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) {
9841: mem_base = xmlMemBlocks();
9842: table = gen_xmlHashTablePtr(n_table, 0);
9843: name = gen_const_xmlChar_ptr(n_name, 1);
9844: name2 = gen_const_xmlChar_ptr(n_name2, 2);
9845: name3 = gen_const_xmlChar_ptr(n_name3, 3);
9846: userdata = gen_userdata(n_userdata, 4);
9847:
9848: ret_val = xmlHashAddEntry3(table, (const xmlChar *)name, (const xmlChar *)name2, (const xmlChar *)name3, userdata);
9849: desret_int(ret_val);
9850: call_tests++;
9851: des_xmlHashTablePtr(n_table, table, 0);
9852: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9853: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
9854: des_const_xmlChar_ptr(n_name3, (const xmlChar *)name3, 3);
9855: des_userdata(n_userdata, userdata, 4);
9856: xmlResetLastError();
9857: if (mem_base != xmlMemBlocks()) {
9858: printf("Leak of %d blocks found in xmlHashAddEntry3",
9859: xmlMemBlocks() - mem_base);
9860: test_ret++;
9861: printf(" %d", n_table);
9862: printf(" %d", n_name);
9863: printf(" %d", n_name2);
9864: printf(" %d", n_name3);
9865: printf(" %d", n_userdata);
9866: printf("\n");
9867: }
9868: }
9869: }
9870: }
9871: }
9872: }
9873: function_tests++;
9874:
9875: return(test_ret);
9876: }
9877:
9878:
9879: static int
9880: test_xmlHashCopy(void) {
9881: int test_ret = 0;
9882:
9883:
9884: /* missing type support */
9885: return(test_ret);
9886: }
9887:
9888:
9889: static int
9890: test_xmlHashCreate(void) {
9891: int test_ret = 0;
9892:
9893:
9894: /* missing type support */
9895: return(test_ret);
9896: }
9897:
9898:
9899: static int
9900: test_xmlHashCreateDict(void) {
9901: int test_ret = 0;
9902:
9903:
9904: /* missing type support */
9905: return(test_ret);
9906: }
9907:
9908:
9909: static int
9910: test_xmlHashLookup(void) {
9911: int test_ret = 0;
9912:
9913: int mem_base;
9914: void * ret_val;
9915: xmlHashTablePtr table; /* the hash table */
9916: int n_table;
9917: xmlChar * name; /* the name of the userdata */
9918: int n_name;
9919:
9920: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
9921: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9922: mem_base = xmlMemBlocks();
9923: table = gen_xmlHashTablePtr(n_table, 0);
9924: name = gen_const_xmlChar_ptr(n_name, 1);
9925:
9926: ret_val = xmlHashLookup(table, (const xmlChar *)name);
9927: desret_void_ptr(ret_val);
9928: call_tests++;
9929: des_xmlHashTablePtr(n_table, table, 0);
9930: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9931: xmlResetLastError();
9932: if (mem_base != xmlMemBlocks()) {
9933: printf("Leak of %d blocks found in xmlHashLookup",
9934: xmlMemBlocks() - mem_base);
9935: test_ret++;
9936: printf(" %d", n_table);
9937: printf(" %d", n_name);
9938: printf("\n");
9939: }
9940: }
9941: }
9942: function_tests++;
9943:
9944: return(test_ret);
9945: }
9946:
9947:
9948: static int
9949: test_xmlHashLookup2(void) {
9950: int test_ret = 0;
9951:
9952: int mem_base;
9953: void * ret_val;
9954: xmlHashTablePtr table; /* the hash table */
9955: int n_table;
9956: xmlChar * name; /* the name of the userdata */
9957: int n_name;
9958: xmlChar * name2; /* a second name of the userdata */
9959: int n_name2;
9960:
9961: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
9962: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9963: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
9964: mem_base = xmlMemBlocks();
9965: table = gen_xmlHashTablePtr(n_table, 0);
9966: name = gen_const_xmlChar_ptr(n_name, 1);
9967: name2 = gen_const_xmlChar_ptr(n_name2, 2);
9968:
9969: ret_val = xmlHashLookup2(table, (const xmlChar *)name, (const xmlChar *)name2);
9970: desret_void_ptr(ret_val);
9971: call_tests++;
9972: des_xmlHashTablePtr(n_table, table, 0);
9973: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9974: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
9975: xmlResetLastError();
9976: if (mem_base != xmlMemBlocks()) {
9977: printf("Leak of %d blocks found in xmlHashLookup2",
9978: xmlMemBlocks() - mem_base);
9979: test_ret++;
9980: printf(" %d", n_table);
9981: printf(" %d", n_name);
9982: printf(" %d", n_name2);
9983: printf("\n");
9984: }
9985: }
9986: }
9987: }
9988: function_tests++;
9989:
9990: return(test_ret);
9991: }
9992:
9993:
9994: static int
9995: test_xmlHashLookup3(void) {
9996: int test_ret = 0;
9997:
9998: int mem_base;
9999: void * ret_val;
10000: xmlHashTablePtr table; /* the hash table */
10001: int n_table;
10002: xmlChar * name; /* the name of the userdata */
10003: int n_name;
10004: xmlChar * name2; /* a second name of the userdata */
10005: int n_name2;
10006: xmlChar * name3; /* a third name of the userdata */
10007: int n_name3;
10008:
10009: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10010: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10011: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
10012: for (n_name3 = 0;n_name3 < gen_nb_const_xmlChar_ptr;n_name3++) {
10013: mem_base = xmlMemBlocks();
10014: table = gen_xmlHashTablePtr(n_table, 0);
10015: name = gen_const_xmlChar_ptr(n_name, 1);
10016: name2 = gen_const_xmlChar_ptr(n_name2, 2);
10017: name3 = gen_const_xmlChar_ptr(n_name3, 3);
10018:
10019: ret_val = xmlHashLookup3(table, (const xmlChar *)name, (const xmlChar *)name2, (const xmlChar *)name3);
10020: desret_void_ptr(ret_val);
10021: call_tests++;
10022: des_xmlHashTablePtr(n_table, table, 0);
10023: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
10024: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
10025: des_const_xmlChar_ptr(n_name3, (const xmlChar *)name3, 3);
10026: xmlResetLastError();
10027: if (mem_base != xmlMemBlocks()) {
10028: printf("Leak of %d blocks found in xmlHashLookup3",
10029: xmlMemBlocks() - mem_base);
10030: test_ret++;
10031: printf(" %d", n_table);
10032: printf(" %d", n_name);
10033: printf(" %d", n_name2);
10034: printf(" %d", n_name3);
10035: printf("\n");
10036: }
10037: }
10038: }
10039: }
10040: }
10041: function_tests++;
10042:
10043: return(test_ret);
10044: }
10045:
10046:
10047: static int
10048: test_xmlHashQLookup(void) {
10049: int test_ret = 0;
10050:
10051: int mem_base;
10052: void * ret_val;
10053: xmlHashTablePtr table; /* the hash table */
10054: int n_table;
10055: xmlChar * prefix; /* the prefix of the userdata */
10056: int n_prefix;
10057: xmlChar * name; /* the name of the userdata */
10058: int n_name;
10059:
10060: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10061: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
10062: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10063: mem_base = xmlMemBlocks();
10064: table = gen_xmlHashTablePtr(n_table, 0);
10065: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
10066: name = gen_const_xmlChar_ptr(n_name, 2);
10067:
10068: ret_val = xmlHashQLookup(table, (const xmlChar *)prefix, (const xmlChar *)name);
10069: desret_void_ptr(ret_val);
10070: call_tests++;
10071: des_xmlHashTablePtr(n_table, table, 0);
10072: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
10073: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
10074: xmlResetLastError();
10075: if (mem_base != xmlMemBlocks()) {
10076: printf("Leak of %d blocks found in xmlHashQLookup",
10077: xmlMemBlocks() - mem_base);
10078: test_ret++;
10079: printf(" %d", n_table);
10080: printf(" %d", n_prefix);
10081: printf(" %d", n_name);
10082: printf("\n");
10083: }
10084: }
10085: }
10086: }
10087: function_tests++;
10088:
10089: return(test_ret);
10090: }
10091:
10092:
10093: static int
10094: test_xmlHashQLookup2(void) {
10095: int test_ret = 0;
10096:
10097: int mem_base;
10098: void * ret_val;
10099: xmlHashTablePtr table; /* the hash table */
10100: int n_table;
10101: xmlChar * prefix; /* the prefix of the userdata */
10102: int n_prefix;
10103: xmlChar * name; /* the name of the userdata */
10104: int n_name;
10105: xmlChar * prefix2; /* the second prefix of the userdata */
10106: int n_prefix2;
10107: xmlChar * name2; /* a second name of the userdata */
10108: int n_name2;
10109:
10110: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10111: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
10112: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10113: for (n_prefix2 = 0;n_prefix2 < gen_nb_const_xmlChar_ptr;n_prefix2++) {
10114: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
10115: mem_base = xmlMemBlocks();
10116: table = gen_xmlHashTablePtr(n_table, 0);
10117: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
10118: name = gen_const_xmlChar_ptr(n_name, 2);
10119: prefix2 = gen_const_xmlChar_ptr(n_prefix2, 3);
10120: name2 = gen_const_xmlChar_ptr(n_name2, 4);
10121:
10122: ret_val = xmlHashQLookup2(table, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)prefix2, (const xmlChar *)name2);
10123: desret_void_ptr(ret_val);
10124: call_tests++;
10125: des_xmlHashTablePtr(n_table, table, 0);
10126: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
10127: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
10128: des_const_xmlChar_ptr(n_prefix2, (const xmlChar *)prefix2, 3);
10129: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 4);
10130: xmlResetLastError();
10131: if (mem_base != xmlMemBlocks()) {
10132: printf("Leak of %d blocks found in xmlHashQLookup2",
10133: xmlMemBlocks() - mem_base);
10134: test_ret++;
10135: printf(" %d", n_table);
10136: printf(" %d", n_prefix);
10137: printf(" %d", n_name);
10138: printf(" %d", n_prefix2);
10139: printf(" %d", n_name2);
10140: printf("\n");
10141: }
10142: }
10143: }
10144: }
10145: }
10146: }
10147: function_tests++;
10148:
10149: return(test_ret);
10150: }
10151:
10152:
10153: static int
10154: test_xmlHashQLookup3(void) {
10155: int test_ret = 0;
10156:
10157: int mem_base;
10158: void * ret_val;
10159: xmlHashTablePtr table; /* the hash table */
10160: int n_table;
10161: xmlChar * prefix; /* the prefix of the userdata */
10162: int n_prefix;
10163: xmlChar * name; /* the name of the userdata */
10164: int n_name;
10165: xmlChar * prefix2; /* the second prefix of the userdata */
10166: int n_prefix2;
10167: xmlChar * name2; /* a second name of the userdata */
10168: int n_name2;
10169: xmlChar * prefix3; /* the third prefix of the userdata */
10170: int n_prefix3;
10171: xmlChar * name3; /* a third name of the userdata */
10172: int n_name3;
10173:
10174: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10175: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
10176: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10177: for (n_prefix2 = 0;n_prefix2 < gen_nb_const_xmlChar_ptr;n_prefix2++) {
10178: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
10179: for (n_prefix3 = 0;n_prefix3 < gen_nb_const_xmlChar_ptr;n_prefix3++) {
10180: for (n_name3 = 0;n_name3 < gen_nb_const_xmlChar_ptr;n_name3++) {
10181: mem_base = xmlMemBlocks();
10182: table = gen_xmlHashTablePtr(n_table, 0);
10183: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
10184: name = gen_const_xmlChar_ptr(n_name, 2);
10185: prefix2 = gen_const_xmlChar_ptr(n_prefix2, 3);
10186: name2 = gen_const_xmlChar_ptr(n_name2, 4);
10187: prefix3 = gen_const_xmlChar_ptr(n_prefix3, 5);
10188: name3 = gen_const_xmlChar_ptr(n_name3, 6);
10189:
10190: ret_val = xmlHashQLookup3(table, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)prefix2, (const xmlChar *)name2, (const xmlChar *)prefix3, (const xmlChar *)name3);
10191: desret_void_ptr(ret_val);
10192: call_tests++;
10193: des_xmlHashTablePtr(n_table, table, 0);
10194: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
10195: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
10196: des_const_xmlChar_ptr(n_prefix2, (const xmlChar *)prefix2, 3);
10197: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 4);
10198: des_const_xmlChar_ptr(n_prefix3, (const xmlChar *)prefix3, 5);
10199: des_const_xmlChar_ptr(n_name3, (const xmlChar *)name3, 6);
10200: xmlResetLastError();
10201: if (mem_base != xmlMemBlocks()) {
10202: printf("Leak of %d blocks found in xmlHashQLookup3",
10203: xmlMemBlocks() - mem_base);
10204: test_ret++;
10205: printf(" %d", n_table);
10206: printf(" %d", n_prefix);
10207: printf(" %d", n_name);
10208: printf(" %d", n_prefix2);
10209: printf(" %d", n_name2);
10210: printf(" %d", n_prefix3);
10211: printf(" %d", n_name3);
10212: printf("\n");
10213: }
10214: }
10215: }
10216: }
10217: }
10218: }
10219: }
10220: }
10221: function_tests++;
10222:
10223: return(test_ret);
10224: }
10225:
10226:
10227: static int
10228: test_xmlHashRemoveEntry(void) {
10229: int test_ret = 0;
10230:
10231: int mem_base;
10232: int ret_val;
10233: xmlHashTablePtr table; /* the hash table */
10234: int n_table;
10235: xmlChar * name; /* the name of the userdata */
10236: int n_name;
10237: xmlHashDeallocator f; /* the deallocator function for removed item (if any) */
10238: int n_f;
10239:
10240: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10241: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10242: for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) {
10243: mem_base = xmlMemBlocks();
10244: table = gen_xmlHashTablePtr(n_table, 0);
10245: name = gen_const_xmlChar_ptr(n_name, 1);
10246: f = gen_xmlHashDeallocator(n_f, 2);
10247:
10248: ret_val = xmlHashRemoveEntry(table, (const xmlChar *)name, f);
10249: desret_int(ret_val);
10250: call_tests++;
10251: des_xmlHashTablePtr(n_table, table, 0);
10252: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
10253: des_xmlHashDeallocator(n_f, f, 2);
10254: xmlResetLastError();
10255: if (mem_base != xmlMemBlocks()) {
10256: printf("Leak of %d blocks found in xmlHashRemoveEntry",
10257: xmlMemBlocks() - mem_base);
10258: test_ret++;
10259: printf(" %d", n_table);
10260: printf(" %d", n_name);
10261: printf(" %d", n_f);
10262: printf("\n");
10263: }
10264: }
10265: }
10266: }
10267: function_tests++;
10268:
10269: return(test_ret);
10270: }
10271:
10272:
10273: static int
10274: test_xmlHashRemoveEntry2(void) {
10275: int test_ret = 0;
10276:
10277: int mem_base;
10278: int ret_val;
10279: xmlHashTablePtr table; /* the hash table */
10280: int n_table;
10281: xmlChar * name; /* the name of the userdata */
10282: int n_name;
10283: xmlChar * name2; /* a second name of the userdata */
10284: int n_name2;
10285: xmlHashDeallocator f; /* the deallocator function for removed item (if any) */
10286: int n_f;
10287:
10288: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10289: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10290: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
10291: for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) {
10292: mem_base = xmlMemBlocks();
10293: table = gen_xmlHashTablePtr(n_table, 0);
10294: name = gen_const_xmlChar_ptr(n_name, 1);
10295: name2 = gen_const_xmlChar_ptr(n_name2, 2);
10296: f = gen_xmlHashDeallocator(n_f, 3);
10297:
10298: ret_val = xmlHashRemoveEntry2(table, (const xmlChar *)name, (const xmlChar *)name2, f);
10299: desret_int(ret_val);
10300: call_tests++;
10301: des_xmlHashTablePtr(n_table, table, 0);
10302: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
10303: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
10304: des_xmlHashDeallocator(n_f, f, 3);
10305: xmlResetLastError();
10306: if (mem_base != xmlMemBlocks()) {
10307: printf("Leak of %d blocks found in xmlHashRemoveEntry2",
10308: xmlMemBlocks() - mem_base);
10309: test_ret++;
10310: printf(" %d", n_table);
10311: printf(" %d", n_name);
10312: printf(" %d", n_name2);
10313: printf(" %d", n_f);
10314: printf("\n");
10315: }
10316: }
10317: }
10318: }
10319: }
10320: function_tests++;
10321:
10322: return(test_ret);
10323: }
10324:
10325:
10326: static int
10327: test_xmlHashRemoveEntry3(void) {
10328: int test_ret = 0;
10329:
10330: int mem_base;
10331: int ret_val;
10332: xmlHashTablePtr table; /* the hash table */
10333: int n_table;
10334: xmlChar * name; /* the name of the userdata */
10335: int n_name;
10336: xmlChar * name2; /* a second name of the userdata */
10337: int n_name2;
10338: xmlChar * name3; /* a third name of the userdata */
10339: int n_name3;
10340: xmlHashDeallocator f; /* the deallocator function for removed item (if any) */
10341: int n_f;
10342:
10343: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10344: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10345: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
10346: for (n_name3 = 0;n_name3 < gen_nb_const_xmlChar_ptr;n_name3++) {
10347: for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) {
10348: mem_base = xmlMemBlocks();
10349: table = gen_xmlHashTablePtr(n_table, 0);
10350: name = gen_const_xmlChar_ptr(n_name, 1);
10351: name2 = gen_const_xmlChar_ptr(n_name2, 2);
10352: name3 = gen_const_xmlChar_ptr(n_name3, 3);
10353: f = gen_xmlHashDeallocator(n_f, 4);
10354:
10355: ret_val = xmlHashRemoveEntry3(table, (const xmlChar *)name, (const xmlChar *)name2, (const xmlChar *)name3, f);
10356: desret_int(ret_val);
10357: call_tests++;
10358: des_xmlHashTablePtr(n_table, table, 0);
10359: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
10360: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
10361: des_const_xmlChar_ptr(n_name3, (const xmlChar *)name3, 3);
10362: des_xmlHashDeallocator(n_f, f, 4);
10363: xmlResetLastError();
10364: if (mem_base != xmlMemBlocks()) {
10365: printf("Leak of %d blocks found in xmlHashRemoveEntry3",
10366: xmlMemBlocks() - mem_base);
10367: test_ret++;
10368: printf(" %d", n_table);
10369: printf(" %d", n_name);
10370: printf(" %d", n_name2);
10371: printf(" %d", n_name3);
10372: printf(" %d", n_f);
10373: printf("\n");
10374: }
10375: }
10376: }
10377: }
10378: }
10379: }
10380: function_tests++;
10381:
10382: return(test_ret);
10383: }
10384:
10385:
10386: static int
10387: test_xmlHashScan(void) {
10388: int test_ret = 0;
10389:
10390:
10391: /* missing type support */
10392: return(test_ret);
10393: }
10394:
10395:
10396: static int
10397: test_xmlHashScan3(void) {
10398: int test_ret = 0;
10399:
10400:
10401: /* missing type support */
10402: return(test_ret);
10403: }
10404:
10405:
10406: static int
10407: test_xmlHashScanFull(void) {
10408: int test_ret = 0;
10409:
10410:
10411: /* missing type support */
10412: return(test_ret);
10413: }
10414:
10415:
10416: static int
10417: test_xmlHashScanFull3(void) {
10418: int test_ret = 0;
10419:
10420:
10421: /* missing type support */
10422: return(test_ret);
10423: }
10424:
10425:
10426: static int
10427: test_xmlHashSize(void) {
10428: int test_ret = 0;
10429:
10430: int mem_base;
10431: int ret_val;
10432: xmlHashTablePtr table; /* the hash table */
10433: int n_table;
10434:
10435: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10436: mem_base = xmlMemBlocks();
10437: table = gen_xmlHashTablePtr(n_table, 0);
10438:
10439: ret_val = xmlHashSize(table);
10440: desret_int(ret_val);
10441: call_tests++;
10442: des_xmlHashTablePtr(n_table, table, 0);
10443: xmlResetLastError();
10444: if (mem_base != xmlMemBlocks()) {
10445: printf("Leak of %d blocks found in xmlHashSize",
10446: xmlMemBlocks() - mem_base);
10447: test_ret++;
10448: printf(" %d", n_table);
10449: printf("\n");
10450: }
10451: }
10452: function_tests++;
10453:
10454: return(test_ret);
10455: }
10456:
10457:
10458: static int
10459: test_xmlHashUpdateEntry(void) {
10460: int test_ret = 0;
10461:
10462: int mem_base;
10463: int ret_val;
10464: xmlHashTablePtr table; /* the hash table */
10465: int n_table;
10466: xmlChar * name; /* the name of the userdata */
10467: int n_name;
10468: void * userdata; /* a pointer to the userdata */
10469: int n_userdata;
10470: xmlHashDeallocator f; /* the deallocator function for replaced item (if any) */
10471: int n_f;
10472:
10473: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10474: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10475: for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) {
10476: for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) {
10477: mem_base = xmlMemBlocks();
10478: table = gen_xmlHashTablePtr(n_table, 0);
10479: name = gen_const_xmlChar_ptr(n_name, 1);
10480: userdata = gen_userdata(n_userdata, 2);
10481: f = gen_xmlHashDeallocator(n_f, 3);
10482:
10483: ret_val = xmlHashUpdateEntry(table, (const xmlChar *)name, userdata, f);
10484: desret_int(ret_val);
10485: call_tests++;
10486: des_xmlHashTablePtr(n_table, table, 0);
10487: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
10488: des_userdata(n_userdata, userdata, 2);
10489: des_xmlHashDeallocator(n_f, f, 3);
10490: xmlResetLastError();
10491: if (mem_base != xmlMemBlocks()) {
10492: printf("Leak of %d blocks found in xmlHashUpdateEntry",
10493: xmlMemBlocks() - mem_base);
10494: test_ret++;
10495: printf(" %d", n_table);
10496: printf(" %d", n_name);
10497: printf(" %d", n_userdata);
10498: printf(" %d", n_f);
10499: printf("\n");
10500: }
10501: }
10502: }
10503: }
10504: }
10505: function_tests++;
10506:
10507: return(test_ret);
10508: }
10509:
10510:
10511: static int
10512: test_xmlHashUpdateEntry2(void) {
10513: int test_ret = 0;
10514:
10515: int mem_base;
10516: int ret_val;
10517: xmlHashTablePtr table; /* the hash table */
10518: int n_table;
10519: xmlChar * name; /* the name of the userdata */
10520: int n_name;
10521: xmlChar * name2; /* a second name of the userdata */
10522: int n_name2;
10523: void * userdata; /* a pointer to the userdata */
10524: int n_userdata;
10525: xmlHashDeallocator f; /* the deallocator function for replaced item (if any) */
10526: int n_f;
10527:
10528: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10529: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10530: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
10531: for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) {
10532: for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) {
10533: mem_base = xmlMemBlocks();
10534: table = gen_xmlHashTablePtr(n_table, 0);
10535: name = gen_const_xmlChar_ptr(n_name, 1);
10536: name2 = gen_const_xmlChar_ptr(n_name2, 2);
10537: userdata = gen_userdata(n_userdata, 3);
10538: f = gen_xmlHashDeallocator(n_f, 4);
10539:
10540: ret_val = xmlHashUpdateEntry2(table, (const xmlChar *)name, (const xmlChar *)name2, userdata, f);
10541: desret_int(ret_val);
10542: call_tests++;
10543: des_xmlHashTablePtr(n_table, table, 0);
10544: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
10545: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
10546: des_userdata(n_userdata, userdata, 3);
10547: des_xmlHashDeallocator(n_f, f, 4);
10548: xmlResetLastError();
10549: if (mem_base != xmlMemBlocks()) {
10550: printf("Leak of %d blocks found in xmlHashUpdateEntry2",
10551: xmlMemBlocks() - mem_base);
10552: test_ret++;
10553: printf(" %d", n_table);
10554: printf(" %d", n_name);
10555: printf(" %d", n_name2);
10556: printf(" %d", n_userdata);
10557: printf(" %d", n_f);
10558: printf("\n");
10559: }
10560: }
10561: }
10562: }
10563: }
10564: }
10565: function_tests++;
10566:
10567: return(test_ret);
10568: }
10569:
10570:
10571: static int
10572: test_xmlHashUpdateEntry3(void) {
10573: int test_ret = 0;
10574:
10575: int mem_base;
10576: int ret_val;
10577: xmlHashTablePtr table; /* the hash table */
10578: int n_table;
10579: xmlChar * name; /* the name of the userdata */
10580: int n_name;
10581: xmlChar * name2; /* a second name of the userdata */
10582: int n_name2;
10583: xmlChar * name3; /* a third name of the userdata */
10584: int n_name3;
10585: void * userdata; /* a pointer to the userdata */
10586: int n_userdata;
10587: xmlHashDeallocator f; /* the deallocator function for replaced item (if any) */
10588: int n_f;
10589:
10590: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10591: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10592: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
10593: for (n_name3 = 0;n_name3 < gen_nb_const_xmlChar_ptr;n_name3++) {
10594: for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) {
10595: for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) {
10596: mem_base = xmlMemBlocks();
10597: table = gen_xmlHashTablePtr(n_table, 0);
10598: name = gen_const_xmlChar_ptr(n_name, 1);
10599: name2 = gen_const_xmlChar_ptr(n_name2, 2);
10600: name3 = gen_const_xmlChar_ptr(n_name3, 3);
10601: userdata = gen_userdata(n_userdata, 4);
10602: f = gen_xmlHashDeallocator(n_f, 5);
10603:
10604: ret_val = xmlHashUpdateEntry3(table, (const xmlChar *)name, (const xmlChar *)name2, (const xmlChar *)name3, userdata, f);
10605: desret_int(ret_val);
10606: call_tests++;
10607: des_xmlHashTablePtr(n_table, table, 0);
10608: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
10609: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
10610: des_const_xmlChar_ptr(n_name3, (const xmlChar *)name3, 3);
10611: des_userdata(n_userdata, userdata, 4);
10612: des_xmlHashDeallocator(n_f, f, 5);
10613: xmlResetLastError();
10614: if (mem_base != xmlMemBlocks()) {
10615: printf("Leak of %d blocks found in xmlHashUpdateEntry3",
10616: xmlMemBlocks() - mem_base);
10617: test_ret++;
10618: printf(" %d", n_table);
10619: printf(" %d", n_name);
10620: printf(" %d", n_name2);
10621: printf(" %d", n_name3);
10622: printf(" %d", n_userdata);
10623: printf(" %d", n_f);
10624: printf("\n");
10625: }
10626: }
10627: }
10628: }
10629: }
10630: }
10631: }
10632: function_tests++;
10633:
10634: return(test_ret);
10635: }
10636:
10637: static int
10638: test_hash(void) {
10639: int test_ret = 0;
10640:
10641: if (quiet == 0) printf("Testing hash : 16 of 24 functions ...\n");
10642: test_ret += test_xmlHashAddEntry();
10643: test_ret += test_xmlHashAddEntry2();
10644: test_ret += test_xmlHashAddEntry3();
10645: test_ret += test_xmlHashCopy();
10646: test_ret += test_xmlHashCreate();
10647: test_ret += test_xmlHashCreateDict();
10648: test_ret += test_xmlHashLookup();
10649: test_ret += test_xmlHashLookup2();
10650: test_ret += test_xmlHashLookup3();
10651: test_ret += test_xmlHashQLookup();
10652: test_ret += test_xmlHashQLookup2();
10653: test_ret += test_xmlHashQLookup3();
10654: test_ret += test_xmlHashRemoveEntry();
10655: test_ret += test_xmlHashRemoveEntry2();
10656: test_ret += test_xmlHashRemoveEntry3();
10657: test_ret += test_xmlHashScan();
10658: test_ret += test_xmlHashScan3();
10659: test_ret += test_xmlHashScanFull();
10660: test_ret += test_xmlHashScanFull3();
10661: test_ret += test_xmlHashSize();
10662: test_ret += test_xmlHashUpdateEntry();
10663: test_ret += test_xmlHashUpdateEntry2();
10664: test_ret += test_xmlHashUpdateEntry3();
10665:
10666: if (test_ret != 0)
10667: printf("Module hash: %d errors\n", test_ret);
10668: return(test_ret);
10669: }
10670:
10671: #define gen_nb_xmlLinkPtr 1
10672: static xmlLinkPtr gen_xmlLinkPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
10673: return(NULL);
10674: }
10675: static void des_xmlLinkPtr(int no ATTRIBUTE_UNUSED, xmlLinkPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
10676: }
10677:
10678: static int
10679: test_xmlLinkGetData(void) {
10680: int test_ret = 0;
10681:
10682: int mem_base;
10683: void * ret_val;
10684: xmlLinkPtr lk; /* a link */
10685: int n_lk;
10686:
10687: for (n_lk = 0;n_lk < gen_nb_xmlLinkPtr;n_lk++) {
10688: mem_base = xmlMemBlocks();
10689: lk = gen_xmlLinkPtr(n_lk, 0);
10690:
10691: ret_val = xmlLinkGetData(lk);
10692: desret_void_ptr(ret_val);
10693: call_tests++;
10694: des_xmlLinkPtr(n_lk, lk, 0);
10695: xmlResetLastError();
10696: if (mem_base != xmlMemBlocks()) {
10697: printf("Leak of %d blocks found in xmlLinkGetData",
10698: xmlMemBlocks() - mem_base);
10699: test_ret++;
10700: printf(" %d", n_lk);
10701: printf("\n");
10702: }
10703: }
10704: function_tests++;
10705:
10706: return(test_ret);
10707: }
10708:
10709:
10710: static int
10711: test_xmlListAppend(void) {
10712: int test_ret = 0;
10713:
10714: int mem_base;
10715: int ret_val;
10716: xmlListPtr l; /* a list */
10717: int n_l;
10718: void * data; /* the data */
10719: int n_data;
10720:
10721: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
10722: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
10723: mem_base = xmlMemBlocks();
10724: l = gen_xmlListPtr(n_l, 0);
10725: data = gen_userdata(n_data, 1);
10726:
10727: ret_val = xmlListAppend(l, data);
10728: desret_int(ret_val);
10729: call_tests++;
10730: des_xmlListPtr(n_l, l, 0);
10731: des_userdata(n_data, data, 1);
10732: xmlResetLastError();
10733: if (mem_base != xmlMemBlocks()) {
10734: printf("Leak of %d blocks found in xmlListAppend",
10735: xmlMemBlocks() - mem_base);
10736: test_ret++;
10737: printf(" %d", n_l);
10738: printf(" %d", n_data);
10739: printf("\n");
10740: }
10741: }
10742: }
10743: function_tests++;
10744:
10745: return(test_ret);
10746: }
10747:
10748:
10749: static int
10750: test_xmlListClear(void) {
10751: int test_ret = 0;
10752:
10753: int mem_base;
10754: xmlListPtr l; /* a list */
10755: int n_l;
10756:
10757: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
10758: mem_base = xmlMemBlocks();
10759: l = gen_xmlListPtr(n_l, 0);
10760:
10761: xmlListClear(l);
10762: call_tests++;
10763: des_xmlListPtr(n_l, l, 0);
10764: xmlResetLastError();
10765: if (mem_base != xmlMemBlocks()) {
10766: printf("Leak of %d blocks found in xmlListClear",
10767: xmlMemBlocks() - mem_base);
10768: test_ret++;
10769: printf(" %d", n_l);
10770: printf("\n");
10771: }
10772: }
10773: function_tests++;
10774:
10775: return(test_ret);
10776: }
10777:
10778:
10779: #define gen_nb_const_xmlListPtr 1
10780: static xmlListPtr gen_const_xmlListPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
10781: return(NULL);
10782: }
10783: static void des_const_xmlListPtr(int no ATTRIBUTE_UNUSED, const xmlListPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
10784: }
10785:
10786: static int
10787: test_xmlListCopy(void) {
10788: int test_ret = 0;
10789:
10790: int mem_base;
10791: int ret_val;
10792: xmlListPtr cur; /* the new list */
10793: int n_cur;
10794: xmlListPtr old; /* the old list */
10795: int n_old;
10796:
10797: for (n_cur = 0;n_cur < gen_nb_xmlListPtr;n_cur++) {
10798: for (n_old = 0;n_old < gen_nb_const_xmlListPtr;n_old++) {
10799: mem_base = xmlMemBlocks();
10800: cur = gen_xmlListPtr(n_cur, 0);
10801: old = gen_const_xmlListPtr(n_old, 1);
10802:
10803: ret_val = xmlListCopy(cur, (const xmlListPtr)old);
10804: desret_int(ret_val);
10805: call_tests++;
10806: des_xmlListPtr(n_cur, cur, 0);
10807: des_const_xmlListPtr(n_old, (const xmlListPtr)old, 1);
10808: xmlResetLastError();
10809: if (mem_base != xmlMemBlocks()) {
10810: printf("Leak of %d blocks found in xmlListCopy",
10811: xmlMemBlocks() - mem_base);
10812: test_ret++;
10813: printf(" %d", n_cur);
10814: printf(" %d", n_old);
10815: printf("\n");
10816: }
10817: }
10818: }
10819: function_tests++;
10820:
10821: return(test_ret);
10822: }
10823:
10824:
10825: static int
10826: test_xmlListCreate(void) {
10827: int test_ret = 0;
10828:
10829:
10830: /* missing type support */
10831: return(test_ret);
10832: }
10833:
10834:
10835: static int
10836: test_xmlListDup(void) {
10837: int test_ret = 0;
10838:
10839:
10840: /* missing type support */
10841: return(test_ret);
10842: }
10843:
10844:
10845: static int
10846: test_xmlListEmpty(void) {
10847: int test_ret = 0;
10848:
10849: int mem_base;
10850: int ret_val;
10851: xmlListPtr l; /* a list */
10852: int n_l;
10853:
10854: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
10855: mem_base = xmlMemBlocks();
10856: l = gen_xmlListPtr(n_l, 0);
10857:
10858: ret_val = xmlListEmpty(l);
10859: desret_int(ret_val);
10860: call_tests++;
10861: des_xmlListPtr(n_l, l, 0);
10862: xmlResetLastError();
10863: if (mem_base != xmlMemBlocks()) {
10864: printf("Leak of %d blocks found in xmlListEmpty",
10865: xmlMemBlocks() - mem_base);
10866: test_ret++;
10867: printf(" %d", n_l);
10868: printf("\n");
10869: }
10870: }
10871: function_tests++;
10872:
10873: return(test_ret);
10874: }
10875:
10876:
10877: static int
10878: test_xmlListEnd(void) {
10879: int test_ret = 0;
10880:
10881:
10882: /* missing type support */
10883: return(test_ret);
10884: }
10885:
10886:
10887: static int
10888: test_xmlListFront(void) {
10889: int test_ret = 0;
10890:
10891:
10892: /* missing type support */
10893: return(test_ret);
10894: }
10895:
10896:
10897: static int
10898: test_xmlListInsert(void) {
10899: int test_ret = 0;
10900:
10901: int mem_base;
10902: int ret_val;
10903: xmlListPtr l; /* a list */
10904: int n_l;
10905: void * data; /* the data */
10906: int n_data;
10907:
10908: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
10909: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
10910: mem_base = xmlMemBlocks();
10911: l = gen_xmlListPtr(n_l, 0);
10912: data = gen_userdata(n_data, 1);
10913:
10914: ret_val = xmlListInsert(l, data);
10915: desret_int(ret_val);
10916: call_tests++;
10917: des_xmlListPtr(n_l, l, 0);
10918: des_userdata(n_data, data, 1);
10919: xmlResetLastError();
10920: if (mem_base != xmlMemBlocks()) {
10921: printf("Leak of %d blocks found in xmlListInsert",
10922: xmlMemBlocks() - mem_base);
10923: test_ret++;
10924: printf(" %d", n_l);
10925: printf(" %d", n_data);
10926: printf("\n");
10927: }
10928: }
10929: }
10930: function_tests++;
10931:
10932: return(test_ret);
10933: }
10934:
10935:
10936: static int
10937: test_xmlListMerge(void) {
10938: int test_ret = 0;
10939:
10940: int mem_base;
10941: xmlListPtr l1; /* the original list */
10942: int n_l1;
10943: xmlListPtr l2; /* the new list */
10944: int n_l2;
10945:
10946: for (n_l1 = 0;n_l1 < gen_nb_xmlListPtr;n_l1++) {
10947: for (n_l2 = 0;n_l2 < gen_nb_xmlListPtr;n_l2++) {
10948: mem_base = xmlMemBlocks();
10949: l1 = gen_xmlListPtr(n_l1, 0);
10950: l2 = gen_xmlListPtr(n_l2, 1);
10951:
10952: xmlListMerge(l1, l2);
10953: call_tests++;
10954: des_xmlListPtr(n_l1, l1, 0);
10955: des_xmlListPtr(n_l2, l2, 1);
10956: xmlResetLastError();
10957: if (mem_base != xmlMemBlocks()) {
10958: printf("Leak of %d blocks found in xmlListMerge",
10959: xmlMemBlocks() - mem_base);
10960: test_ret++;
10961: printf(" %d", n_l1);
10962: printf(" %d", n_l2);
10963: printf("\n");
10964: }
10965: }
10966: }
10967: function_tests++;
10968:
10969: return(test_ret);
10970: }
10971:
10972:
10973: static int
10974: test_xmlListPopBack(void) {
10975: int test_ret = 0;
10976:
10977: int mem_base;
10978: xmlListPtr l; /* a list */
10979: int n_l;
10980:
10981: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
10982: mem_base = xmlMemBlocks();
10983: l = gen_xmlListPtr(n_l, 0);
10984:
10985: xmlListPopBack(l);
10986: call_tests++;
10987: des_xmlListPtr(n_l, l, 0);
10988: xmlResetLastError();
10989: if (mem_base != xmlMemBlocks()) {
10990: printf("Leak of %d blocks found in xmlListPopBack",
10991: xmlMemBlocks() - mem_base);
10992: test_ret++;
10993: printf(" %d", n_l);
10994: printf("\n");
10995: }
10996: }
10997: function_tests++;
10998:
10999: return(test_ret);
11000: }
11001:
11002:
11003: static int
11004: test_xmlListPopFront(void) {
11005: int test_ret = 0;
11006:
11007: int mem_base;
11008: xmlListPtr l; /* a list */
11009: int n_l;
11010:
11011: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11012: mem_base = xmlMemBlocks();
11013: l = gen_xmlListPtr(n_l, 0);
11014:
11015: xmlListPopFront(l);
11016: call_tests++;
11017: des_xmlListPtr(n_l, l, 0);
11018: xmlResetLastError();
11019: if (mem_base != xmlMemBlocks()) {
11020: printf("Leak of %d blocks found in xmlListPopFront",
11021: xmlMemBlocks() - mem_base);
11022: test_ret++;
11023: printf(" %d", n_l);
11024: printf("\n");
11025: }
11026: }
11027: function_tests++;
11028:
11029: return(test_ret);
11030: }
11031:
11032:
11033: static int
11034: test_xmlListPushBack(void) {
11035: int test_ret = 0;
11036:
11037: int mem_base;
11038: int ret_val;
11039: xmlListPtr l; /* a list */
11040: int n_l;
11041: void * data; /* new data */
11042: int n_data;
11043:
11044: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11045: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
11046: mem_base = xmlMemBlocks();
11047: l = gen_xmlListPtr(n_l, 0);
11048: data = gen_userdata(n_data, 1);
11049:
11050: ret_val = xmlListPushBack(l, data);
11051: desret_int(ret_val);
11052: call_tests++;
11053: des_xmlListPtr(n_l, l, 0);
11054: des_userdata(n_data, data, 1);
11055: xmlResetLastError();
11056: if (mem_base != xmlMemBlocks()) {
11057: printf("Leak of %d blocks found in xmlListPushBack",
11058: xmlMemBlocks() - mem_base);
11059: test_ret++;
11060: printf(" %d", n_l);
11061: printf(" %d", n_data);
11062: printf("\n");
11063: }
11064: }
11065: }
11066: function_tests++;
11067:
11068: return(test_ret);
11069: }
11070:
11071:
11072: static int
11073: test_xmlListPushFront(void) {
11074: int test_ret = 0;
11075:
11076: int mem_base;
11077: int ret_val;
11078: xmlListPtr l; /* a list */
11079: int n_l;
11080: void * data; /* new data */
11081: int n_data;
11082:
11083: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11084: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
11085: mem_base = xmlMemBlocks();
11086: l = gen_xmlListPtr(n_l, 0);
11087: data = gen_userdata(n_data, 1);
11088:
11089: ret_val = xmlListPushFront(l, data);
11090: desret_int(ret_val);
11091: call_tests++;
11092: des_xmlListPtr(n_l, l, 0);
11093: des_userdata(n_data, data, 1);
11094: xmlResetLastError();
11095: if (mem_base != xmlMemBlocks()) {
11096: printf("Leak of %d blocks found in xmlListPushFront",
11097: xmlMemBlocks() - mem_base);
11098: test_ret++;
11099: printf(" %d", n_l);
11100: printf(" %d", n_data);
11101: printf("\n");
11102: }
11103: }
11104: }
11105: function_tests++;
11106:
11107: return(test_ret);
11108: }
11109:
11110:
11111: static int
11112: test_xmlListRemoveAll(void) {
11113: int test_ret = 0;
11114:
11115: int mem_base;
11116: int ret_val;
11117: xmlListPtr l; /* a list */
11118: int n_l;
11119: void * data; /* list data */
11120: int n_data;
11121:
11122: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11123: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
11124: mem_base = xmlMemBlocks();
11125: l = gen_xmlListPtr(n_l, 0);
11126: data = gen_userdata(n_data, 1);
11127:
11128: ret_val = xmlListRemoveAll(l, data);
11129: desret_int(ret_val);
11130: call_tests++;
11131: des_xmlListPtr(n_l, l, 0);
11132: des_userdata(n_data, data, 1);
11133: xmlResetLastError();
11134: if (mem_base != xmlMemBlocks()) {
11135: printf("Leak of %d blocks found in xmlListRemoveAll",
11136: xmlMemBlocks() - mem_base);
11137: test_ret++;
11138: printf(" %d", n_l);
11139: printf(" %d", n_data);
11140: printf("\n");
11141: }
11142: }
11143: }
11144: function_tests++;
11145:
11146: return(test_ret);
11147: }
11148:
11149:
11150: static int
11151: test_xmlListRemoveFirst(void) {
11152: int test_ret = 0;
11153:
11154: int mem_base;
11155: int ret_val;
11156: xmlListPtr l; /* a list */
11157: int n_l;
11158: void * data; /* list data */
11159: int n_data;
11160:
11161: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11162: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
11163: mem_base = xmlMemBlocks();
11164: l = gen_xmlListPtr(n_l, 0);
11165: data = gen_userdata(n_data, 1);
11166:
11167: ret_val = xmlListRemoveFirst(l, data);
11168: desret_int(ret_val);
11169: call_tests++;
11170: des_xmlListPtr(n_l, l, 0);
11171: des_userdata(n_data, data, 1);
11172: xmlResetLastError();
11173: if (mem_base != xmlMemBlocks()) {
11174: printf("Leak of %d blocks found in xmlListRemoveFirst",
11175: xmlMemBlocks() - mem_base);
11176: test_ret++;
11177: printf(" %d", n_l);
11178: printf(" %d", n_data);
11179: printf("\n");
11180: }
11181: }
11182: }
11183: function_tests++;
11184:
11185: return(test_ret);
11186: }
11187:
11188:
11189: static int
11190: test_xmlListRemoveLast(void) {
11191: int test_ret = 0;
11192:
11193: int mem_base;
11194: int ret_val;
11195: xmlListPtr l; /* a list */
11196: int n_l;
11197: void * data; /* list data */
11198: int n_data;
11199:
11200: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11201: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
11202: mem_base = xmlMemBlocks();
11203: l = gen_xmlListPtr(n_l, 0);
11204: data = gen_userdata(n_data, 1);
11205:
11206: ret_val = xmlListRemoveLast(l, data);
11207: desret_int(ret_val);
11208: call_tests++;
11209: des_xmlListPtr(n_l, l, 0);
11210: des_userdata(n_data, data, 1);
11211: xmlResetLastError();
11212: if (mem_base != xmlMemBlocks()) {
11213: printf("Leak of %d blocks found in xmlListRemoveLast",
11214: xmlMemBlocks() - mem_base);
11215: test_ret++;
11216: printf(" %d", n_l);
11217: printf(" %d", n_data);
11218: printf("\n");
11219: }
11220: }
11221: }
11222: function_tests++;
11223:
11224: return(test_ret);
11225: }
11226:
11227:
11228: static int
11229: test_xmlListReverse(void) {
11230: int test_ret = 0;
11231:
11232: int mem_base;
11233: xmlListPtr l; /* a list */
11234: int n_l;
11235:
11236: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11237: mem_base = xmlMemBlocks();
11238: l = gen_xmlListPtr(n_l, 0);
11239:
11240: xmlListReverse(l);
11241: call_tests++;
11242: des_xmlListPtr(n_l, l, 0);
11243: xmlResetLastError();
11244: if (mem_base != xmlMemBlocks()) {
11245: printf("Leak of %d blocks found in xmlListReverse",
11246: xmlMemBlocks() - mem_base);
11247: test_ret++;
11248: printf(" %d", n_l);
11249: printf("\n");
11250: }
11251: }
11252: function_tests++;
11253:
11254: return(test_ret);
11255: }
11256:
11257:
11258: static int
11259: test_xmlListReverseSearch(void) {
11260: int test_ret = 0;
11261:
11262: int mem_base;
11263: void * ret_val;
11264: xmlListPtr l; /* a list */
11265: int n_l;
11266: void * data; /* a search value */
11267: int n_data;
11268:
11269: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11270: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
11271: mem_base = xmlMemBlocks();
11272: l = gen_xmlListPtr(n_l, 0);
11273: data = gen_userdata(n_data, 1);
11274:
11275: ret_val = xmlListReverseSearch(l, data);
11276: desret_void_ptr(ret_val);
11277: call_tests++;
11278: des_xmlListPtr(n_l, l, 0);
11279: des_userdata(n_data, data, 1);
11280: xmlResetLastError();
11281: if (mem_base != xmlMemBlocks()) {
11282: printf("Leak of %d blocks found in xmlListReverseSearch",
11283: xmlMemBlocks() - mem_base);
11284: test_ret++;
11285: printf(" %d", n_l);
11286: printf(" %d", n_data);
11287: printf("\n");
11288: }
11289: }
11290: }
11291: function_tests++;
11292:
11293: return(test_ret);
11294: }
11295:
11296:
11297: static int
11298: test_xmlListReverseWalk(void) {
11299: int test_ret = 0;
11300:
11301:
11302: /* missing type support */
11303: return(test_ret);
11304: }
11305:
11306:
11307: static int
11308: test_xmlListSearch(void) {
11309: int test_ret = 0;
11310:
11311: int mem_base;
11312: void * ret_val;
11313: xmlListPtr l; /* a list */
11314: int n_l;
11315: void * data; /* a search value */
11316: int n_data;
11317:
11318: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11319: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
11320: mem_base = xmlMemBlocks();
11321: l = gen_xmlListPtr(n_l, 0);
11322: data = gen_userdata(n_data, 1);
11323:
11324: ret_val = xmlListSearch(l, data);
11325: desret_void_ptr(ret_val);
11326: call_tests++;
11327: des_xmlListPtr(n_l, l, 0);
11328: des_userdata(n_data, data, 1);
11329: xmlResetLastError();
11330: if (mem_base != xmlMemBlocks()) {
11331: printf("Leak of %d blocks found in xmlListSearch",
11332: xmlMemBlocks() - mem_base);
11333: test_ret++;
11334: printf(" %d", n_l);
11335: printf(" %d", n_data);
11336: printf("\n");
11337: }
11338: }
11339: }
11340: function_tests++;
11341:
11342: return(test_ret);
11343: }
11344:
11345:
11346: static int
11347: test_xmlListSize(void) {
11348: int test_ret = 0;
11349:
11350: int mem_base;
11351: int ret_val;
11352: xmlListPtr l; /* a list */
11353: int n_l;
11354:
11355: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11356: mem_base = xmlMemBlocks();
11357: l = gen_xmlListPtr(n_l, 0);
11358:
11359: ret_val = xmlListSize(l);
11360: desret_int(ret_val);
11361: call_tests++;
11362: des_xmlListPtr(n_l, l, 0);
11363: xmlResetLastError();
11364: if (mem_base != xmlMemBlocks()) {
11365: printf("Leak of %d blocks found in xmlListSize",
11366: xmlMemBlocks() - mem_base);
11367: test_ret++;
11368: printf(" %d", n_l);
11369: printf("\n");
11370: }
11371: }
11372: function_tests++;
11373:
11374: return(test_ret);
11375: }
11376:
11377:
11378: static int
11379: test_xmlListSort(void) {
11380: int test_ret = 0;
11381:
11382: int mem_base;
11383: xmlListPtr l; /* a list */
11384: int n_l;
11385:
11386: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11387: mem_base = xmlMemBlocks();
11388: l = gen_xmlListPtr(n_l, 0);
11389:
11390: xmlListSort(l);
11391: call_tests++;
11392: des_xmlListPtr(n_l, l, 0);
11393: xmlResetLastError();
11394: if (mem_base != xmlMemBlocks()) {
11395: printf("Leak of %d blocks found in xmlListSort",
11396: xmlMemBlocks() - mem_base);
11397: test_ret++;
11398: printf(" %d", n_l);
11399: printf("\n");
11400: }
11401: }
11402: function_tests++;
11403:
11404: return(test_ret);
11405: }
11406:
11407:
11408: static int
11409: test_xmlListWalk(void) {
11410: int test_ret = 0;
11411:
11412:
11413: /* missing type support */
11414: return(test_ret);
11415: }
11416:
11417: static int
11418: test_list(void) {
11419: int test_ret = 0;
11420:
11421: if (quiet == 0) printf("Testing list : 19 of 26 functions ...\n");
11422: test_ret += test_xmlLinkGetData();
11423: test_ret += test_xmlListAppend();
11424: test_ret += test_xmlListClear();
11425: test_ret += test_xmlListCopy();
11426: test_ret += test_xmlListCreate();
11427: test_ret += test_xmlListDup();
11428: test_ret += test_xmlListEmpty();
11429: test_ret += test_xmlListEnd();
11430: test_ret += test_xmlListFront();
11431: test_ret += test_xmlListInsert();
11432: test_ret += test_xmlListMerge();
11433: test_ret += test_xmlListPopBack();
11434: test_ret += test_xmlListPopFront();
11435: test_ret += test_xmlListPushBack();
11436: test_ret += test_xmlListPushFront();
11437: test_ret += test_xmlListRemoveAll();
11438: test_ret += test_xmlListRemoveFirst();
11439: test_ret += test_xmlListRemoveLast();
11440: test_ret += test_xmlListReverse();
11441: test_ret += test_xmlListReverseSearch();
11442: test_ret += test_xmlListReverseWalk();
11443: test_ret += test_xmlListSearch();
11444: test_ret += test_xmlListSize();
11445: test_ret += test_xmlListSort();
11446: test_ret += test_xmlListWalk();
11447:
11448: if (test_ret != 0)
11449: printf("Module list: %d errors\n", test_ret);
11450: return(test_ret);
11451: }
11452:
11453: static int
11454: test_xmlNanoFTPCheckResponse(void) {
11455: int test_ret = 0;
11456:
11457: #if defined(LIBXML_FTP_ENABLED)
11458: int mem_base;
11459: int ret_val;
11460: void * ctx; /* an FTP context */
11461: int n_ctx;
11462:
11463: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
11464: mem_base = xmlMemBlocks();
11465: ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
11466:
11467: ret_val = xmlNanoFTPCheckResponse(ctx);
11468: desret_int(ret_val);
11469: call_tests++;
11470: des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
11471: xmlResetLastError();
11472: if (mem_base != xmlMemBlocks()) {
11473: printf("Leak of %d blocks found in xmlNanoFTPCheckResponse",
11474: xmlMemBlocks() - mem_base);
11475: test_ret++;
11476: printf(" %d", n_ctx);
11477: printf("\n");
11478: }
11479: }
11480: function_tests++;
11481: #endif
11482:
11483: return(test_ret);
11484: }
11485:
11486:
11487: static int
11488: test_xmlNanoFTPCleanup(void) {
11489: int test_ret = 0;
11490:
11491: #if defined(LIBXML_FTP_ENABLED)
11492: int mem_base;
11493:
11494: mem_base = xmlMemBlocks();
11495:
11496: xmlNanoFTPCleanup();
11497: call_tests++;
11498: xmlResetLastError();
11499: if (mem_base != xmlMemBlocks()) {
11500: printf("Leak of %d blocks found in xmlNanoFTPCleanup",
11501: xmlMemBlocks() - mem_base);
11502: test_ret++;
11503: printf("\n");
11504: }
11505: function_tests++;
11506: #endif
11507:
11508: return(test_ret);
11509: }
11510:
11511:
11512: static int
11513: test_xmlNanoFTPCloseConnection(void) {
11514: int test_ret = 0;
11515:
11516: #if defined(LIBXML_FTP_ENABLED)
11517: int mem_base;
11518: int ret_val;
11519: void * ctx; /* an FTP context */
11520: int n_ctx;
11521:
11522: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
11523: mem_base = xmlMemBlocks();
11524: ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
11525:
11526: ret_val = xmlNanoFTPCloseConnection(ctx);
11527: desret_int(ret_val);
11528: call_tests++;
11529: des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
11530: xmlResetLastError();
11531: if (mem_base != xmlMemBlocks()) {
11532: printf("Leak of %d blocks found in xmlNanoFTPCloseConnection",
11533: xmlMemBlocks() - mem_base);
11534: test_ret++;
11535: printf(" %d", n_ctx);
11536: printf("\n");
11537: }
11538: }
11539: function_tests++;
11540: #endif
11541:
11542: return(test_ret);
11543: }
11544:
11545:
11546: static int
11547: test_xmlNanoFTPCwd(void) {
11548: int test_ret = 0;
11549:
11550: #if defined(LIBXML_FTP_ENABLED)
11551: int mem_base;
11552: int ret_val;
11553: void * ctx; /* an FTP context */
11554: int n_ctx;
11555: char * directory; /* a directory on the server */
11556: int n_directory;
11557:
11558: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
11559: for (n_directory = 0;n_directory < gen_nb_const_char_ptr;n_directory++) {
11560: mem_base = xmlMemBlocks();
11561: ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
11562: directory = gen_const_char_ptr(n_directory, 1);
11563:
11564: ret_val = xmlNanoFTPCwd(ctx, (const char *)directory);
11565: desret_int(ret_val);
11566: call_tests++;
11567: des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
11568: des_const_char_ptr(n_directory, (const char *)directory, 1);
11569: xmlResetLastError();
11570: if (mem_base != xmlMemBlocks()) {
11571: printf("Leak of %d blocks found in xmlNanoFTPCwd",
11572: xmlMemBlocks() - mem_base);
11573: test_ret++;
11574: printf(" %d", n_ctx);
11575: printf(" %d", n_directory);
11576: printf("\n");
11577: }
11578: }
11579: }
11580: function_tests++;
11581: #endif
11582:
11583: return(test_ret);
11584: }
11585:
11586:
11587: static int
11588: test_xmlNanoFTPDele(void) {
11589: int test_ret = 0;
11590:
11591: #if defined(LIBXML_FTP_ENABLED)
11592: int mem_base;
11593: int ret_val;
11594: void * ctx; /* an FTP context */
11595: int n_ctx;
11596: const char * file; /* a file or directory on the server */
11597: int n_file;
11598:
11599: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
11600: for (n_file = 0;n_file < gen_nb_filepath;n_file++) {
11601: mem_base = xmlMemBlocks();
11602: ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
11603: file = gen_filepath(n_file, 1);
11604:
11605: ret_val = xmlNanoFTPDele(ctx, file);
11606: desret_int(ret_val);
11607: call_tests++;
11608: des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
11609: des_filepath(n_file, file, 1);
11610: xmlResetLastError();
11611: if (mem_base != xmlMemBlocks()) {
11612: printf("Leak of %d blocks found in xmlNanoFTPDele",
11613: xmlMemBlocks() - mem_base);
11614: test_ret++;
11615: printf(" %d", n_ctx);
11616: printf(" %d", n_file);
11617: printf("\n");
11618: }
11619: }
11620: }
11621: function_tests++;
11622: #endif
11623:
11624: return(test_ret);
11625: }
11626:
11627:
11628: static int
11629: test_xmlNanoFTPGet(void) {
11630: int test_ret = 0;
11631:
11632:
11633: /* missing type support */
11634: return(test_ret);
11635: }
11636:
11637:
11638: static int
11639: test_xmlNanoFTPGetConnection(void) {
11640: int test_ret = 0;
11641:
11642:
11643: /* missing type support */
11644: return(test_ret);
11645: }
11646:
11647:
11648: static int
11649: test_xmlNanoFTPGetResponse(void) {
11650: int test_ret = 0;
11651:
11652: #if defined(LIBXML_FTP_ENABLED)
11653: int mem_base;
11654: int ret_val;
11655: void * ctx; /* an FTP context */
11656: int n_ctx;
11657:
11658: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
11659: mem_base = xmlMemBlocks();
11660: ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
11661:
11662: ret_val = xmlNanoFTPGetResponse(ctx);
11663: desret_int(ret_val);
11664: call_tests++;
11665: des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
11666: xmlResetLastError();
11667: if (mem_base != xmlMemBlocks()) {
11668: printf("Leak of %d blocks found in xmlNanoFTPGetResponse",
11669: xmlMemBlocks() - mem_base);
11670: test_ret++;
11671: printf(" %d", n_ctx);
11672: printf("\n");
11673: }
11674: }
11675: function_tests++;
11676: #endif
11677:
11678: return(test_ret);
11679: }
11680:
11681:
11682: static int
11683: test_xmlNanoFTPGetSocket(void) {
11684: int test_ret = 0;
11685:
11686:
11687: /* missing type support */
11688: return(test_ret);
11689: }
11690:
11691:
11692: static int
11693: test_xmlNanoFTPInit(void) {
11694: int test_ret = 0;
11695:
11696: #if defined(LIBXML_FTP_ENABLED)
11697: int mem_base;
11698:
11699: mem_base = xmlMemBlocks();
11700:
11701: xmlNanoFTPInit();
11702: call_tests++;
11703: xmlResetLastError();
11704: if (mem_base != xmlMemBlocks()) {
11705: printf("Leak of %d blocks found in xmlNanoFTPInit",
11706: xmlMemBlocks() - mem_base);
11707: test_ret++;
11708: printf("\n");
11709: }
11710: function_tests++;
11711: #endif
11712:
11713: return(test_ret);
11714: }
11715:
11716:
11717: static int
11718: test_xmlNanoFTPList(void) {
11719: int test_ret = 0;
11720:
11721:
11722: /* missing type support */
11723: return(test_ret);
11724: }
11725:
11726:
11727: static int
11728: test_xmlNanoFTPNewCtxt(void) {
11729: int test_ret = 0;
11730:
11731: #if defined(LIBXML_FTP_ENABLED)
11732: int mem_base;
11733: void * ret_val;
11734: const char * URL; /* The URL used to initialize the context */
11735: int n_URL;
11736:
11737: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
11738: mem_base = xmlMemBlocks();
11739: URL = gen_filepath(n_URL, 0);
11740:
11741: ret_val = xmlNanoFTPNewCtxt(URL);
11742: desret_xmlNanoFTPCtxtPtr(ret_val);
11743: call_tests++;
11744: des_filepath(n_URL, URL, 0);
11745: xmlResetLastError();
11746: if (mem_base != xmlMemBlocks()) {
11747: printf("Leak of %d blocks found in xmlNanoFTPNewCtxt",
11748: xmlMemBlocks() - mem_base);
11749: test_ret++;
11750: printf(" %d", n_URL);
11751: printf("\n");
11752: }
11753: }
11754: function_tests++;
11755: #endif
11756:
11757: return(test_ret);
11758: }
11759:
11760:
11761: static int
11762: test_xmlNanoFTPOpen(void) {
11763: int test_ret = 0;
11764:
11765: #if defined(LIBXML_FTP_ENABLED)
11766: int mem_base;
11767: void * ret_val;
11768: const char * URL; /* the URL to the resource */
11769: int n_URL;
11770:
11771: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
11772: mem_base = xmlMemBlocks();
11773: URL = gen_filepath(n_URL, 0);
11774:
11775: ret_val = xmlNanoFTPOpen(URL);
11776: desret_xmlNanoFTPCtxtPtr(ret_val);
11777: call_tests++;
11778: des_filepath(n_URL, URL, 0);
11779: xmlResetLastError();
11780: if (mem_base != xmlMemBlocks()) {
11781: printf("Leak of %d blocks found in xmlNanoFTPOpen",
11782: xmlMemBlocks() - mem_base);
11783: test_ret++;
11784: printf(" %d", n_URL);
11785: printf("\n");
11786: }
11787: }
11788: function_tests++;
11789: #endif
11790:
11791: return(test_ret);
11792: }
11793:
11794:
11795: static int
11796: test_xmlNanoFTPProxy(void) {
11797: int test_ret = 0;
11798:
11799: #if defined(LIBXML_FTP_ENABLED)
11800: char * host; /* the proxy host name */
11801: int n_host;
11802: int port; /* the proxy port */
11803: int n_port;
11804: char * user; /* the proxy user name */
11805: int n_user;
11806: char * passwd; /* the proxy password */
11807: int n_passwd;
11808: int type; /* the type of proxy 1 for using SITE, 2 for USER a@b */
11809: int n_type;
11810:
11811: for (n_host = 0;n_host < gen_nb_const_char_ptr;n_host++) {
11812: for (n_port = 0;n_port < gen_nb_int;n_port++) {
11813: for (n_user = 0;n_user < gen_nb_const_char_ptr;n_user++) {
11814: for (n_passwd = 0;n_passwd < gen_nb_const_char_ptr;n_passwd++) {
11815: for (n_type = 0;n_type < gen_nb_int;n_type++) {
11816: host = gen_const_char_ptr(n_host, 0);
11817: port = gen_int(n_port, 1);
11818: user = gen_const_char_ptr(n_user, 2);
11819: passwd = gen_const_char_ptr(n_passwd, 3);
11820: type = gen_int(n_type, 4);
11821:
11822: xmlNanoFTPProxy((const char *)host, port, (const char *)user, (const char *)passwd, type);
11823: call_tests++;
11824: des_const_char_ptr(n_host, (const char *)host, 0);
11825: des_int(n_port, port, 1);
11826: des_const_char_ptr(n_user, (const char *)user, 2);
11827: des_const_char_ptr(n_passwd, (const char *)passwd, 3);
11828: des_int(n_type, type, 4);
11829: xmlResetLastError();
11830: }
11831: }
11832: }
11833: }
11834: }
11835: function_tests++;
11836: #endif
11837:
11838: return(test_ret);
11839: }
11840:
11841:
11842: static int
11843: test_xmlNanoFTPQuit(void) {
11844: int test_ret = 0;
11845:
11846: #if defined(LIBXML_FTP_ENABLED)
11847: int mem_base;
11848: int ret_val;
11849: void * ctx; /* an FTP context */
11850: int n_ctx;
11851:
11852: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
11853: mem_base = xmlMemBlocks();
11854: ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
11855:
11856: ret_val = xmlNanoFTPQuit(ctx);
11857: desret_int(ret_val);
11858: call_tests++;
11859: des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
11860: xmlResetLastError();
11861: if (mem_base != xmlMemBlocks()) {
11862: printf("Leak of %d blocks found in xmlNanoFTPQuit",
11863: xmlMemBlocks() - mem_base);
11864: test_ret++;
11865: printf(" %d", n_ctx);
11866: printf("\n");
11867: }
11868: }
11869: function_tests++;
11870: #endif
11871:
11872: return(test_ret);
11873: }
11874:
11875:
11876: static int
11877: test_xmlNanoFTPRead(void) {
11878: int test_ret = 0;
11879:
11880: #if defined(LIBXML_FTP_ENABLED)
11881: int mem_base;
11882: int ret_val;
11883: void * ctx; /* the FTP context */
11884: int n_ctx;
11885: void * dest; /* a buffer */
11886: int n_dest;
11887: int len; /* the buffer length */
11888: int n_len;
11889:
11890: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
11891: for (n_dest = 0;n_dest < gen_nb_void_ptr;n_dest++) {
11892: for (n_len = 0;n_len < gen_nb_int;n_len++) {
11893: mem_base = xmlMemBlocks();
11894: ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
11895: dest = gen_void_ptr(n_dest, 1);
11896: len = gen_int(n_len, 2);
11897:
11898: ret_val = xmlNanoFTPRead(ctx, dest, len);
11899: desret_int(ret_val);
11900: call_tests++;
11901: des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
11902: des_void_ptr(n_dest, dest, 1);
11903: des_int(n_len, len, 2);
11904: xmlResetLastError();
11905: if (mem_base != xmlMemBlocks()) {
11906: printf("Leak of %d blocks found in xmlNanoFTPRead",
11907: xmlMemBlocks() - mem_base);
11908: test_ret++;
11909: printf(" %d", n_ctx);
11910: printf(" %d", n_dest);
11911: printf(" %d", n_len);
11912: printf("\n");
11913: }
11914: }
11915: }
11916: }
11917: function_tests++;
11918: #endif
11919:
11920: return(test_ret);
11921: }
11922:
11923:
11924: static int
11925: test_xmlNanoFTPScanProxy(void) {
11926: int test_ret = 0;
11927:
11928: #if defined(LIBXML_FTP_ENABLED)
11929: const char * URL; /* The proxy URL used to initialize the proxy context */
11930: int n_URL;
11931:
11932: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
11933: URL = gen_filepath(n_URL, 0);
11934:
11935: xmlNanoFTPScanProxy(URL);
11936: call_tests++;
11937: des_filepath(n_URL, URL, 0);
11938: xmlResetLastError();
11939: }
11940: function_tests++;
11941: #endif
11942:
11943: return(test_ret);
11944: }
11945:
11946:
11947: static int
11948: test_xmlNanoFTPUpdateURL(void) {
11949: int test_ret = 0;
11950:
11951: #if defined(LIBXML_FTP_ENABLED)
11952: int mem_base;
11953: int ret_val;
11954: void * ctx; /* an FTP context */
11955: int n_ctx;
11956: const char * URL; /* The URL used to update the context */
11957: int n_URL;
11958:
11959: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
11960: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
11961: mem_base = xmlMemBlocks();
11962: ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
11963: URL = gen_filepath(n_URL, 1);
11964:
11965: ret_val = xmlNanoFTPUpdateURL(ctx, URL);
11966: desret_int(ret_val);
11967: call_tests++;
11968: des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
11969: des_filepath(n_URL, URL, 1);
11970: xmlResetLastError();
11971: if (mem_base != xmlMemBlocks()) {
11972: printf("Leak of %d blocks found in xmlNanoFTPUpdateURL",
11973: xmlMemBlocks() - mem_base);
11974: test_ret++;
11975: printf(" %d", n_ctx);
11976: printf(" %d", n_URL);
11977: printf("\n");
11978: }
11979: }
11980: }
11981: function_tests++;
11982: #endif
11983:
11984: return(test_ret);
11985: }
11986:
11987: static int
11988: test_nanoftp(void) {
11989: int test_ret = 0;
11990:
11991: if (quiet == 0) printf("Testing nanoftp : 14 of 22 functions ...\n");
11992: test_ret += test_xmlNanoFTPCheckResponse();
11993: test_ret += test_xmlNanoFTPCleanup();
11994: test_ret += test_xmlNanoFTPCloseConnection();
11995: test_ret += test_xmlNanoFTPCwd();
11996: test_ret += test_xmlNanoFTPDele();
11997: test_ret += test_xmlNanoFTPGet();
11998: test_ret += test_xmlNanoFTPGetConnection();
11999: test_ret += test_xmlNanoFTPGetResponse();
12000: test_ret += test_xmlNanoFTPGetSocket();
12001: test_ret += test_xmlNanoFTPInit();
12002: test_ret += test_xmlNanoFTPList();
12003: test_ret += test_xmlNanoFTPNewCtxt();
12004: test_ret += test_xmlNanoFTPOpen();
12005: test_ret += test_xmlNanoFTPProxy();
12006: test_ret += test_xmlNanoFTPQuit();
12007: test_ret += test_xmlNanoFTPRead();
12008: test_ret += test_xmlNanoFTPScanProxy();
12009: test_ret += test_xmlNanoFTPUpdateURL();
12010:
12011: if (test_ret != 0)
12012: printf("Module nanoftp: %d errors\n", test_ret);
12013: return(test_ret);
12014: }
12015:
12016: static int
12017: test_xmlNanoHTTPAuthHeader(void) {
12018: int test_ret = 0;
12019:
12020: #if defined(LIBXML_HTTP_ENABLED)
12021: int mem_base;
12022: const char * ret_val;
12023: void * ctx; /* the HTTP context */
12024: int n_ctx;
12025:
12026: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
12027: mem_base = xmlMemBlocks();
12028: ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
12029:
12030: ret_val = xmlNanoHTTPAuthHeader(ctx);
12031: desret_const_char_ptr(ret_val);
12032: call_tests++;
12033: des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
12034: xmlResetLastError();
12035: if (mem_base != xmlMemBlocks()) {
12036: printf("Leak of %d blocks found in xmlNanoHTTPAuthHeader",
12037: xmlMemBlocks() - mem_base);
12038: test_ret++;
12039: printf(" %d", n_ctx);
12040: printf("\n");
12041: }
12042: }
12043: function_tests++;
12044: #endif
12045:
12046: return(test_ret);
12047: }
12048:
12049:
12050: static int
12051: test_xmlNanoHTTPCleanup(void) {
12052: int test_ret = 0;
12053:
12054: #if defined(LIBXML_HTTP_ENABLED)
12055: int mem_base;
12056:
12057: mem_base = xmlMemBlocks();
12058:
12059: xmlNanoHTTPCleanup();
12060: call_tests++;
12061: xmlResetLastError();
12062: if (mem_base != xmlMemBlocks()) {
12063: printf("Leak of %d blocks found in xmlNanoHTTPCleanup",
12064: xmlMemBlocks() - mem_base);
12065: test_ret++;
12066: printf("\n");
12067: }
12068: function_tests++;
12069: #endif
12070:
12071: return(test_ret);
12072: }
12073:
12074:
12075: static int
12076: test_xmlNanoHTTPContentLength(void) {
12077: int test_ret = 0;
12078:
12079: #if defined(LIBXML_HTTP_ENABLED)
12080: int mem_base;
12081: int ret_val;
12082: void * ctx; /* the HTTP context */
12083: int n_ctx;
12084:
12085: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
12086: mem_base = xmlMemBlocks();
12087: ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
12088:
12089: ret_val = xmlNanoHTTPContentLength(ctx);
12090: desret_int(ret_val);
12091: call_tests++;
12092: des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
12093: xmlResetLastError();
12094: if (mem_base != xmlMemBlocks()) {
12095: printf("Leak of %d blocks found in xmlNanoHTTPContentLength",
12096: xmlMemBlocks() - mem_base);
12097: test_ret++;
12098: printf(" %d", n_ctx);
12099: printf("\n");
12100: }
12101: }
12102: function_tests++;
12103: #endif
12104:
12105: return(test_ret);
12106: }
12107:
12108:
12109: static int
12110: test_xmlNanoHTTPEncoding(void) {
12111: int test_ret = 0;
12112:
12113: #if defined(LIBXML_HTTP_ENABLED)
12114: int mem_base;
12115: const char * ret_val;
12116: void * ctx; /* the HTTP context */
12117: int n_ctx;
12118:
12119: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
12120: mem_base = xmlMemBlocks();
12121: ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
12122:
12123: ret_val = xmlNanoHTTPEncoding(ctx);
12124: desret_const_char_ptr(ret_val);
12125: call_tests++;
12126: des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
12127: xmlResetLastError();
12128: if (mem_base != xmlMemBlocks()) {
12129: printf("Leak of %d blocks found in xmlNanoHTTPEncoding",
12130: xmlMemBlocks() - mem_base);
12131: test_ret++;
12132: printf(" %d", n_ctx);
12133: printf("\n");
12134: }
12135: }
12136: function_tests++;
12137: #endif
12138:
12139: return(test_ret);
12140: }
12141:
12142:
12143: #define gen_nb_char_ptr_ptr 1
12144: static char ** gen_char_ptr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
12145: return(NULL);
12146: }
12147: static void des_char_ptr_ptr(int no ATTRIBUTE_UNUSED, char ** val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
12148: }
12149:
12150: static int
12151: test_xmlNanoHTTPFetch(void) {
12152: int test_ret = 0;
12153:
12154: #if defined(LIBXML_HTTP_ENABLED)
12155: int mem_base;
12156: int ret_val;
12157: const char * URL; /* The URL to load */
12158: int n_URL;
12159: const char * filename; /* the filename where the content should be saved */
12160: int n_filename;
12161: char ** contentType; /* if available the Content-Type information will be returned at that location */
12162: int n_contentType;
12163:
12164: for (n_URL = 0;n_URL < gen_nb_fileoutput;n_URL++) {
12165: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
12166: for (n_contentType = 0;n_contentType < gen_nb_char_ptr_ptr;n_contentType++) {
12167: mem_base = xmlMemBlocks();
12168: URL = gen_fileoutput(n_URL, 0);
12169: filename = gen_fileoutput(n_filename, 1);
12170: contentType = gen_char_ptr_ptr(n_contentType, 2);
12171:
12172: ret_val = xmlNanoHTTPFetch(URL, filename, contentType);
12173: desret_int(ret_val);
12174: call_tests++;
12175: des_fileoutput(n_URL, URL, 0);
12176: des_fileoutput(n_filename, filename, 1);
12177: des_char_ptr_ptr(n_contentType, contentType, 2);
12178: xmlResetLastError();
12179: if (mem_base != xmlMemBlocks()) {
12180: printf("Leak of %d blocks found in xmlNanoHTTPFetch",
12181: xmlMemBlocks() - mem_base);
12182: test_ret++;
12183: printf(" %d", n_URL);
12184: printf(" %d", n_filename);
12185: printf(" %d", n_contentType);
12186: printf("\n");
12187: }
12188: }
12189: }
12190: }
12191: function_tests++;
12192: #endif
12193:
12194: return(test_ret);
12195: }
12196:
12197:
12198: static int
12199: test_xmlNanoHTTPInit(void) {
12200: int test_ret = 0;
12201:
12202: #if defined(LIBXML_HTTP_ENABLED)
12203: int mem_base;
12204:
12205: mem_base = xmlMemBlocks();
12206:
12207: xmlNanoHTTPInit();
12208: call_tests++;
12209: xmlResetLastError();
12210: if (mem_base != xmlMemBlocks()) {
12211: printf("Leak of %d blocks found in xmlNanoHTTPInit",
12212: xmlMemBlocks() - mem_base);
12213: test_ret++;
12214: printf("\n");
12215: }
12216: function_tests++;
12217: #endif
12218:
12219: return(test_ret);
12220: }
12221:
12222:
12223: static int
12224: test_xmlNanoHTTPMimeType(void) {
12225: int test_ret = 0;
12226:
12227: #if defined(LIBXML_HTTP_ENABLED)
12228: int mem_base;
12229: const char * ret_val;
12230: void * ctx; /* the HTTP context */
12231: int n_ctx;
12232:
12233: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
12234: mem_base = xmlMemBlocks();
12235: ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
12236:
12237: ret_val = xmlNanoHTTPMimeType(ctx);
12238: desret_const_char_ptr(ret_val);
12239: call_tests++;
12240: des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
12241: xmlResetLastError();
12242: if (mem_base != xmlMemBlocks()) {
12243: printf("Leak of %d blocks found in xmlNanoHTTPMimeType",
12244: xmlMemBlocks() - mem_base);
12245: test_ret++;
12246: printf(" %d", n_ctx);
12247: printf("\n");
12248: }
12249: }
12250: function_tests++;
12251: #endif
12252:
12253: return(test_ret);
12254: }
12255:
12256:
12257: static int
12258: test_xmlNanoHTTPOpen(void) {
12259: int test_ret = 0;
12260:
12261: #if defined(LIBXML_HTTP_ENABLED)
12262: int mem_base;
12263: void * ret_val;
12264: const char * URL; /* The URL to load */
12265: int n_URL;
12266: char ** contentType; /* if available the Content-Type information will be returned at that location */
12267: int n_contentType;
12268:
12269: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
12270: for (n_contentType = 0;n_contentType < gen_nb_char_ptr_ptr;n_contentType++) {
12271: mem_base = xmlMemBlocks();
12272: URL = gen_filepath(n_URL, 0);
12273: contentType = gen_char_ptr_ptr(n_contentType, 1);
12274:
12275: ret_val = xmlNanoHTTPOpen(URL, contentType);
12276: desret_xmlNanoHTTPCtxtPtr(ret_val);
12277: call_tests++;
12278: des_filepath(n_URL, URL, 0);
12279: des_char_ptr_ptr(n_contentType, contentType, 1);
12280: xmlResetLastError();
12281: if (mem_base != xmlMemBlocks()) {
12282: printf("Leak of %d blocks found in xmlNanoHTTPOpen",
12283: xmlMemBlocks() - mem_base);
12284: test_ret++;
12285: printf(" %d", n_URL);
12286: printf(" %d", n_contentType);
12287: printf("\n");
12288: }
12289: }
12290: }
12291: function_tests++;
12292: #endif
12293:
12294: return(test_ret);
12295: }
12296:
12297:
12298: static int
12299: test_xmlNanoHTTPOpenRedir(void) {
12300: int test_ret = 0;
12301:
12302: #if defined(LIBXML_HTTP_ENABLED)
12303: int mem_base;
12304: void * ret_val;
12305: const char * URL; /* The URL to load */
12306: int n_URL;
12307: char ** contentType; /* if available the Content-Type information will be returned at that location */
12308: int n_contentType;
12309: char ** redir; /* if available the redirected URL will be returned */
12310: int n_redir;
12311:
12312: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
12313: for (n_contentType = 0;n_contentType < gen_nb_char_ptr_ptr;n_contentType++) {
12314: for (n_redir = 0;n_redir < gen_nb_char_ptr_ptr;n_redir++) {
12315: mem_base = xmlMemBlocks();
12316: URL = gen_filepath(n_URL, 0);
12317: contentType = gen_char_ptr_ptr(n_contentType, 1);
12318: redir = gen_char_ptr_ptr(n_redir, 2);
12319:
12320: ret_val = xmlNanoHTTPOpenRedir(URL, contentType, redir);
12321: desret_xmlNanoHTTPCtxtPtr(ret_val);
12322: call_tests++;
12323: des_filepath(n_URL, URL, 0);
12324: des_char_ptr_ptr(n_contentType, contentType, 1);
12325: des_char_ptr_ptr(n_redir, redir, 2);
12326: xmlResetLastError();
12327: if (mem_base != xmlMemBlocks()) {
12328: printf("Leak of %d blocks found in xmlNanoHTTPOpenRedir",
12329: xmlMemBlocks() - mem_base);
12330: test_ret++;
12331: printf(" %d", n_URL);
12332: printf(" %d", n_contentType);
12333: printf(" %d", n_redir);
12334: printf("\n");
12335: }
12336: }
12337: }
12338: }
12339: function_tests++;
12340: #endif
12341:
12342: return(test_ret);
12343: }
12344:
12345:
12346: static int
12347: test_xmlNanoHTTPRead(void) {
12348: int test_ret = 0;
12349:
12350: #if defined(LIBXML_HTTP_ENABLED)
12351: int mem_base;
12352: int ret_val;
12353: void * ctx; /* the HTTP context */
12354: int n_ctx;
12355: void * dest; /* a buffer */
12356: int n_dest;
12357: int len; /* the buffer length */
12358: int n_len;
12359:
12360: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
12361: for (n_dest = 0;n_dest < gen_nb_void_ptr;n_dest++) {
12362: for (n_len = 0;n_len < gen_nb_int;n_len++) {
12363: mem_base = xmlMemBlocks();
12364: ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
12365: dest = gen_void_ptr(n_dest, 1);
12366: len = gen_int(n_len, 2);
12367:
12368: ret_val = xmlNanoHTTPRead(ctx, dest, len);
12369: desret_int(ret_val);
12370: call_tests++;
12371: des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
12372: des_void_ptr(n_dest, dest, 1);
12373: des_int(n_len, len, 2);
12374: xmlResetLastError();
12375: if (mem_base != xmlMemBlocks()) {
12376: printf("Leak of %d blocks found in xmlNanoHTTPRead",
12377: xmlMemBlocks() - mem_base);
12378: test_ret++;
12379: printf(" %d", n_ctx);
12380: printf(" %d", n_dest);
12381: printf(" %d", n_len);
12382: printf("\n");
12383: }
12384: }
12385: }
12386: }
12387: function_tests++;
12388: #endif
12389:
12390: return(test_ret);
12391: }
12392:
12393:
12394: static int
12395: test_xmlNanoHTTPRedir(void) {
12396: int test_ret = 0;
12397:
12398:
12399: /* missing type support */
12400: return(test_ret);
12401: }
12402:
12403:
12404: static int
12405: test_xmlNanoHTTPReturnCode(void) {
12406: int test_ret = 0;
12407:
12408: #if defined(LIBXML_HTTP_ENABLED)
12409: int mem_base;
12410: int ret_val;
12411: void * ctx; /* the HTTP context */
12412: int n_ctx;
12413:
12414: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
12415: mem_base = xmlMemBlocks();
12416: ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
12417:
12418: ret_val = xmlNanoHTTPReturnCode(ctx);
12419: desret_int(ret_val);
12420: call_tests++;
12421: des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
12422: xmlResetLastError();
12423: if (mem_base != xmlMemBlocks()) {
12424: printf("Leak of %d blocks found in xmlNanoHTTPReturnCode",
12425: xmlMemBlocks() - mem_base);
12426: test_ret++;
12427: printf(" %d", n_ctx);
12428: printf("\n");
12429: }
12430: }
12431: function_tests++;
12432: #endif
12433:
12434: return(test_ret);
12435: }
12436:
12437:
12438: static int
12439: test_xmlNanoHTTPSave(void) {
12440: int test_ret = 0;
12441:
12442: #if defined(LIBXML_HTTP_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
12443: int mem_base;
12444: int ret_val;
12445: void * ctxt; /* the HTTP context */
12446: int n_ctxt;
12447: const char * filename; /* the filename where the content should be saved */
12448: int n_filename;
12449:
12450: for (n_ctxt = 0;n_ctxt < gen_nb_void_ptr;n_ctxt++) {
12451: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
12452: mem_base = xmlMemBlocks();
12453: ctxt = gen_void_ptr(n_ctxt, 0);
12454: filename = gen_fileoutput(n_filename, 1);
12455:
12456: ret_val = xmlNanoHTTPSave(ctxt, filename);
12457: desret_int(ret_val);
12458: call_tests++;
12459: des_void_ptr(n_ctxt, ctxt, 0);
12460: des_fileoutput(n_filename, filename, 1);
12461: xmlResetLastError();
12462: if (mem_base != xmlMemBlocks()) {
12463: printf("Leak of %d blocks found in xmlNanoHTTPSave",
12464: xmlMemBlocks() - mem_base);
12465: test_ret++;
12466: printf(" %d", n_ctxt);
12467: printf(" %d", n_filename);
12468: printf("\n");
12469: }
12470: }
12471: }
12472: function_tests++;
12473: #endif
12474:
12475: return(test_ret);
12476: }
12477:
12478:
12479: static int
12480: test_xmlNanoHTTPScanProxy(void) {
12481: int test_ret = 0;
12482:
12483: #if defined(LIBXML_HTTP_ENABLED)
12484: const char * URL; /* The proxy URL used to initialize the proxy context */
12485: int n_URL;
12486:
12487: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
12488: URL = gen_filepath(n_URL, 0);
12489:
12490: xmlNanoHTTPScanProxy(URL);
12491: call_tests++;
12492: des_filepath(n_URL, URL, 0);
12493: xmlResetLastError();
12494: }
12495: function_tests++;
12496: #endif
12497:
12498: return(test_ret);
12499: }
12500:
12501: static int
12502: test_nanohttp(void) {
12503: int test_ret = 0;
12504:
12505: if (quiet == 0) printf("Testing nanohttp : 13 of 17 functions ...\n");
12506: test_ret += test_xmlNanoHTTPAuthHeader();
12507: test_ret += test_xmlNanoHTTPCleanup();
12508: test_ret += test_xmlNanoHTTPContentLength();
12509: test_ret += test_xmlNanoHTTPEncoding();
12510: test_ret += test_xmlNanoHTTPFetch();
12511: test_ret += test_xmlNanoHTTPInit();
12512: test_ret += test_xmlNanoHTTPMimeType();
12513: test_ret += test_xmlNanoHTTPOpen();
12514: test_ret += test_xmlNanoHTTPOpenRedir();
12515: test_ret += test_xmlNanoHTTPRead();
12516: test_ret += test_xmlNanoHTTPRedir();
12517: test_ret += test_xmlNanoHTTPReturnCode();
12518: test_ret += test_xmlNanoHTTPSave();
12519: test_ret += test_xmlNanoHTTPScanProxy();
12520:
12521: if (test_ret != 0)
12522: printf("Module nanohttp: %d errors\n", test_ret);
12523: return(test_ret);
12524: }
12525:
12526: static int
12527: test_xmlByteConsumed(void) {
12528: int test_ret = 0;
12529:
12530: int mem_base;
12531: long ret_val;
12532: xmlParserCtxtPtr ctxt; /* an XML parser context */
12533: int n_ctxt;
12534:
12535: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
12536: mem_base = xmlMemBlocks();
12537: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
12538:
12539: ret_val = xmlByteConsumed(ctxt);
12540: desret_long(ret_val);
12541: call_tests++;
12542: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
12543: xmlResetLastError();
12544: if (mem_base != xmlMemBlocks()) {
12545: printf("Leak of %d blocks found in xmlByteConsumed",
12546: xmlMemBlocks() - mem_base);
12547: test_ret++;
12548: printf(" %d", n_ctxt);
12549: printf("\n");
12550: }
12551: }
12552: function_tests++;
12553:
12554: return(test_ret);
12555: }
12556:
12557:
12558: static int
12559: test_xmlClearNodeInfoSeq(void) {
12560: int test_ret = 0;
12561:
12562: int mem_base;
12563: xmlParserNodeInfoSeqPtr seq; /* a node info sequence pointer */
12564: int n_seq;
12565:
12566: for (n_seq = 0;n_seq < gen_nb_xmlParserNodeInfoSeqPtr;n_seq++) {
12567: mem_base = xmlMemBlocks();
12568: seq = gen_xmlParserNodeInfoSeqPtr(n_seq, 0);
12569:
12570: xmlClearNodeInfoSeq(seq);
12571: call_tests++;
12572: des_xmlParserNodeInfoSeqPtr(n_seq, seq, 0);
12573: xmlResetLastError();
12574: if (mem_base != xmlMemBlocks()) {
12575: printf("Leak of %d blocks found in xmlClearNodeInfoSeq",
12576: xmlMemBlocks() - mem_base);
12577: test_ret++;
12578: printf(" %d", n_seq);
12579: printf("\n");
12580: }
12581: }
12582: function_tests++;
12583:
12584: return(test_ret);
12585: }
12586:
12587:
12588: static int
12589: test_xmlClearParserCtxt(void) {
12590: int test_ret = 0;
12591:
12592: int mem_base;
12593: xmlParserCtxtPtr ctxt; /* an XML parser context */
12594: int n_ctxt;
12595:
12596: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
12597: mem_base = xmlMemBlocks();
12598: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
12599:
12600: xmlClearParserCtxt(ctxt);
12601: call_tests++;
12602: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
12603: xmlResetLastError();
12604: if (mem_base != xmlMemBlocks()) {
12605: printf("Leak of %d blocks found in xmlClearParserCtxt",
12606: xmlMemBlocks() - mem_base);
12607: test_ret++;
12608: printf(" %d", n_ctxt);
12609: printf("\n");
12610: }
12611: }
12612: function_tests++;
12613:
12614: return(test_ret);
12615: }
12616:
12617:
12618: static int
12619: test_xmlCreateDocParserCtxt(void) {
12620: int test_ret = 0;
12621:
12622: int mem_base;
12623: xmlParserCtxtPtr ret_val;
12624: xmlChar * cur; /* a pointer to an array of xmlChar */
12625: int n_cur;
12626:
12627: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
12628: mem_base = xmlMemBlocks();
12629: cur = gen_const_xmlChar_ptr(n_cur, 0);
12630:
12631: ret_val = xmlCreateDocParserCtxt((const xmlChar *)cur);
12632: desret_xmlParserCtxtPtr(ret_val);
12633: call_tests++;
12634: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
12635: xmlResetLastError();
12636: if (mem_base != xmlMemBlocks()) {
12637: printf("Leak of %d blocks found in xmlCreateDocParserCtxt",
12638: xmlMemBlocks() - mem_base);
12639: test_ret++;
12640: printf(" %d", n_cur);
12641: printf("\n");
12642: }
12643: }
12644: function_tests++;
12645:
12646: return(test_ret);
12647: }
12648:
12649:
12650: static int
12651: test_xmlCreatePushParserCtxt(void) {
12652: int test_ret = 0;
12653:
12654: #if defined(LIBXML_PUSH_ENABLED)
12655: int mem_base;
12656: xmlParserCtxtPtr ret_val;
12657: xmlSAXHandlerPtr sax; /* a SAX handler */
12658: int n_sax;
12659: void * user_data; /* The user data returned on SAX callbacks */
12660: int n_user_data;
12661: char * chunk; /* a pointer to an array of chars */
12662: int n_chunk;
12663: int size; /* number of chars in the array */
12664: int n_size;
12665: const char * filename; /* an optional file name or URI */
12666: int n_filename;
12667:
12668: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
12669: for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
12670: for (n_chunk = 0;n_chunk < gen_nb_const_char_ptr;n_chunk++) {
12671: for (n_size = 0;n_size < gen_nb_int;n_size++) {
12672: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
12673: mem_base = xmlMemBlocks();
12674: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
12675: user_data = gen_userdata(n_user_data, 1);
12676: chunk = gen_const_char_ptr(n_chunk, 2);
12677: size = gen_int(n_size, 3);
12678: filename = gen_fileoutput(n_filename, 4);
12679:
12680: ret_val = xmlCreatePushParserCtxt(sax, user_data, (const char *)chunk, size, filename);
12681: desret_xmlParserCtxtPtr(ret_val);
12682: call_tests++;
12683: des_xmlSAXHandlerPtr(n_sax, sax, 0);
12684: des_userdata(n_user_data, user_data, 1);
12685: des_const_char_ptr(n_chunk, (const char *)chunk, 2);
12686: des_int(n_size, size, 3);
12687: des_fileoutput(n_filename, filename, 4);
12688: xmlResetLastError();
12689: if (mem_base != xmlMemBlocks()) {
12690: printf("Leak of %d blocks found in xmlCreatePushParserCtxt",
12691: xmlMemBlocks() - mem_base);
12692: test_ret++;
12693: printf(" %d", n_sax);
12694: printf(" %d", n_user_data);
12695: printf(" %d", n_chunk);
12696: printf(" %d", n_size);
12697: printf(" %d", n_filename);
12698: printf("\n");
12699: }
12700: }
12701: }
12702: }
12703: }
12704: }
12705: function_tests++;
12706: #endif
12707:
12708: return(test_ret);
12709: }
12710:
12711:
12712: static int
12713: test_xmlCtxtReadDoc(void) {
12714: int test_ret = 0;
12715:
12716: int mem_base;
12717: xmlDocPtr ret_val;
12718: xmlParserCtxtPtr ctxt; /* an XML parser context */
12719: int n_ctxt;
12720: xmlChar * cur; /* a pointer to a zero terminated string */
12721: int n_cur;
12722: const char * URL; /* the base URL to use for the document */
12723: int n_URL;
12724: char * encoding; /* the document encoding, or NULL */
12725: int n_encoding;
12726: int options; /* a combination of xmlParserOption */
12727: int n_options;
12728:
12729: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
12730: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
12731: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
12732: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
12733: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
12734: mem_base = xmlMemBlocks();
12735: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
12736: cur = gen_const_xmlChar_ptr(n_cur, 1);
12737: URL = gen_filepath(n_URL, 2);
12738: encoding = gen_const_char_ptr(n_encoding, 3);
12739: options = gen_parseroptions(n_options, 4);
12740:
12741: ret_val = xmlCtxtReadDoc(ctxt, (const xmlChar *)cur, URL, (const char *)encoding, options);
12742: desret_xmlDocPtr(ret_val);
12743: call_tests++;
12744: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
12745: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 1);
12746: des_filepath(n_URL, URL, 2);
12747: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
12748: des_parseroptions(n_options, options, 4);
12749: xmlResetLastError();
12750: if (mem_base != xmlMemBlocks()) {
12751: printf("Leak of %d blocks found in xmlCtxtReadDoc",
12752: xmlMemBlocks() - mem_base);
12753: test_ret++;
12754: printf(" %d", n_ctxt);
12755: printf(" %d", n_cur);
12756: printf(" %d", n_URL);
12757: printf(" %d", n_encoding);
12758: printf(" %d", n_options);
12759: printf("\n");
12760: }
12761: }
12762: }
12763: }
12764: }
12765: }
12766: function_tests++;
12767:
12768: return(test_ret);
12769: }
12770:
12771:
12772: static int
12773: test_xmlCtxtReadFile(void) {
12774: int test_ret = 0;
12775:
12776: int mem_base;
12777: xmlDocPtr ret_val;
12778: xmlParserCtxtPtr ctxt; /* an XML parser context */
12779: int n_ctxt;
12780: const char * filename; /* a file or URL */
12781: int n_filename;
12782: char * encoding; /* the document encoding, or NULL */
12783: int n_encoding;
12784: int options; /* a combination of xmlParserOption */
12785: int n_options;
12786:
12787: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
12788: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
12789: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
12790: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
12791: mem_base = xmlMemBlocks();
12792: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
12793: filename = gen_filepath(n_filename, 1);
12794: encoding = gen_const_char_ptr(n_encoding, 2);
12795: options = gen_parseroptions(n_options, 3);
12796:
12797: ret_val = xmlCtxtReadFile(ctxt, filename, (const char *)encoding, options);
12798: desret_xmlDocPtr(ret_val);
12799: call_tests++;
12800: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
12801: des_filepath(n_filename, filename, 1);
12802: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
12803: des_parseroptions(n_options, options, 3);
12804: xmlResetLastError();
12805: if (mem_base != xmlMemBlocks()) {
12806: printf("Leak of %d blocks found in xmlCtxtReadFile",
12807: xmlMemBlocks() - mem_base);
12808: test_ret++;
12809: printf(" %d", n_ctxt);
12810: printf(" %d", n_filename);
12811: printf(" %d", n_encoding);
12812: printf(" %d", n_options);
12813: printf("\n");
12814: }
12815: }
12816: }
12817: }
12818: }
12819: function_tests++;
12820:
12821: return(test_ret);
12822: }
12823:
12824:
12825: static int
12826: test_xmlCtxtReadMemory(void) {
12827: int test_ret = 0;
12828:
12829: int mem_base;
12830: xmlDocPtr ret_val;
12831: xmlParserCtxtPtr ctxt; /* an XML parser context */
12832: int n_ctxt;
12833: char * buffer; /* a pointer to a char array */
12834: int n_buffer;
12835: int size; /* the size of the array */
12836: int n_size;
12837: const char * URL; /* the base URL to use for the document */
12838: int n_URL;
12839: char * encoding; /* the document encoding, or NULL */
12840: int n_encoding;
12841: int options; /* a combination of xmlParserOption */
12842: int n_options;
12843:
12844: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
12845: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
12846: for (n_size = 0;n_size < gen_nb_int;n_size++) {
12847: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
12848: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
12849: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
12850: mem_base = xmlMemBlocks();
12851: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
12852: buffer = gen_const_char_ptr(n_buffer, 1);
12853: size = gen_int(n_size, 2);
12854: URL = gen_filepath(n_URL, 3);
12855: encoding = gen_const_char_ptr(n_encoding, 4);
12856: options = gen_parseroptions(n_options, 5);
12857:
12858: ret_val = xmlCtxtReadMemory(ctxt, (const char *)buffer, size, URL, (const char *)encoding, options);
12859: desret_xmlDocPtr(ret_val);
12860: call_tests++;
12861: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
12862: des_const_char_ptr(n_buffer, (const char *)buffer, 1);
12863: des_int(n_size, size, 2);
12864: des_filepath(n_URL, URL, 3);
12865: des_const_char_ptr(n_encoding, (const char *)encoding, 4);
12866: des_parseroptions(n_options, options, 5);
12867: xmlResetLastError();
12868: if (mem_base != xmlMemBlocks()) {
12869: printf("Leak of %d blocks found in xmlCtxtReadMemory",
12870: xmlMemBlocks() - mem_base);
12871: test_ret++;
12872: printf(" %d", n_ctxt);
12873: printf(" %d", n_buffer);
12874: printf(" %d", n_size);
12875: printf(" %d", n_URL);
12876: printf(" %d", n_encoding);
12877: printf(" %d", n_options);
12878: printf("\n");
12879: }
12880: }
12881: }
12882: }
12883: }
12884: }
12885: }
12886: function_tests++;
12887:
12888: return(test_ret);
12889: }
12890:
12891:
12892: static int
12893: test_xmlCtxtReset(void) {
12894: int test_ret = 0;
12895:
12896: int mem_base;
12897: xmlParserCtxtPtr ctxt; /* an XML parser context */
12898: int n_ctxt;
12899:
12900: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
12901: mem_base = xmlMemBlocks();
12902: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
12903:
12904: xmlCtxtReset(ctxt);
12905: call_tests++;
12906: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
12907: xmlResetLastError();
12908: if (mem_base != xmlMemBlocks()) {
12909: printf("Leak of %d blocks found in xmlCtxtReset",
12910: xmlMemBlocks() - mem_base);
12911: test_ret++;
12912: printf(" %d", n_ctxt);
12913: printf("\n");
12914: }
12915: }
12916: function_tests++;
12917:
12918: return(test_ret);
12919: }
12920:
12921:
12922: static int
12923: test_xmlCtxtResetPush(void) {
12924: int test_ret = 0;
12925:
12926: int mem_base;
12927: int ret_val;
12928: xmlParserCtxtPtr ctxt; /* an XML parser context */
12929: int n_ctxt;
12930: char * chunk; /* a pointer to an array of chars */
12931: int n_chunk;
12932: int size; /* number of chars in the array */
12933: int n_size;
12934: const char * filename; /* an optional file name or URI */
12935: int n_filename;
12936: char * encoding; /* the document encoding, or NULL */
12937: int n_encoding;
12938:
12939: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
12940: for (n_chunk = 0;n_chunk < gen_nb_const_char_ptr;n_chunk++) {
12941: for (n_size = 0;n_size < gen_nb_int;n_size++) {
12942: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
12943: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
12944: mem_base = xmlMemBlocks();
12945: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
12946: chunk = gen_const_char_ptr(n_chunk, 1);
12947: size = gen_int(n_size, 2);
12948: filename = gen_filepath(n_filename, 3);
12949: encoding = gen_const_char_ptr(n_encoding, 4);
12950:
12951: ret_val = xmlCtxtResetPush(ctxt, (const char *)chunk, size, filename, (const char *)encoding);
12952: desret_int(ret_val);
12953: call_tests++;
12954: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
12955: des_const_char_ptr(n_chunk, (const char *)chunk, 1);
12956: des_int(n_size, size, 2);
12957: des_filepath(n_filename, filename, 3);
12958: des_const_char_ptr(n_encoding, (const char *)encoding, 4);
12959: xmlResetLastError();
12960: if (mem_base != xmlMemBlocks()) {
12961: printf("Leak of %d blocks found in xmlCtxtResetPush",
12962: xmlMemBlocks() - mem_base);
12963: test_ret++;
12964: printf(" %d", n_ctxt);
12965: printf(" %d", n_chunk);
12966: printf(" %d", n_size);
12967: printf(" %d", n_filename);
12968: printf(" %d", n_encoding);
12969: printf("\n");
12970: }
12971: }
12972: }
12973: }
12974: }
12975: }
12976: function_tests++;
12977:
12978: return(test_ret);
12979: }
12980:
12981:
12982: static int
12983: test_xmlCtxtUseOptions(void) {
12984: int test_ret = 0;
12985:
12986: int mem_base;
12987: int ret_val;
12988: xmlParserCtxtPtr ctxt; /* an XML parser context */
12989: int n_ctxt;
12990: int options; /* a combination of xmlParserOption */
12991: int n_options;
12992:
12993: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
12994: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
12995: mem_base = xmlMemBlocks();
12996: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
12997: options = gen_parseroptions(n_options, 1);
12998:
12999: ret_val = xmlCtxtUseOptions(ctxt, options);
13000: desret_int(ret_val);
13001: call_tests++;
13002: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
13003: des_parseroptions(n_options, options, 1);
13004: xmlResetLastError();
13005: if (mem_base != xmlMemBlocks()) {
13006: printf("Leak of %d blocks found in xmlCtxtUseOptions",
13007: xmlMemBlocks() - mem_base);
13008: test_ret++;
13009: printf(" %d", n_ctxt);
13010: printf(" %d", n_options);
13011: printf("\n");
13012: }
13013: }
13014: }
13015: function_tests++;
13016:
13017: return(test_ret);
13018: }
13019:
13020:
13021: static int
13022: test_xmlGetExternalEntityLoader(void) {
13023: int test_ret = 0;
13024:
13025:
13026: /* missing type support */
13027: return(test_ret);
13028: }
13029:
13030:
13031: static int
13032: test_xmlGetFeature(void) {
13033: int test_ret = 0;
13034:
13035: #if defined(LIBXML_LEGACY_ENABLED)
13036: #ifdef LIBXML_LEGACY_ENABLED
13037: int mem_base;
13038: int ret_val;
13039: xmlParserCtxtPtr ctxt; /* an XML/HTML parser context */
13040: int n_ctxt;
13041: char * name; /* the feature name */
13042: int n_name;
13043: void * result; /* location to store the result */
13044: int n_result;
13045:
13046: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
13047: for (n_name = 0;n_name < gen_nb_const_char_ptr;n_name++) {
13048: for (n_result = 0;n_result < gen_nb_void_ptr;n_result++) {
13049: mem_base = xmlMemBlocks();
13050: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
13051: name = gen_const_char_ptr(n_name, 1);
13052: result = gen_void_ptr(n_result, 2);
13053:
13054: ret_val = xmlGetFeature(ctxt, (const char *)name, result);
13055: desret_int(ret_val);
13056: call_tests++;
13057: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
13058: des_const_char_ptr(n_name, (const char *)name, 1);
13059: des_void_ptr(n_result, result, 2);
13060: xmlResetLastError();
13061: if (mem_base != xmlMemBlocks()) {
13062: printf("Leak of %d blocks found in xmlGetFeature",
13063: xmlMemBlocks() - mem_base);
13064: test_ret++;
13065: printf(" %d", n_ctxt);
13066: printf(" %d", n_name);
13067: printf(" %d", n_result);
13068: printf("\n");
13069: }
13070: }
13071: }
13072: }
13073: function_tests++;
13074: #endif
13075: #endif
13076:
13077: return(test_ret);
13078: }
13079:
13080:
13081: #define gen_nb_const_char_ptr_ptr 1
13082: static char ** gen_const_char_ptr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
13083: return(NULL);
13084: }
13085: static void des_const_char_ptr_ptr(int no ATTRIBUTE_UNUSED, const char ** val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
13086: }
13087:
13088: static int
13089: test_xmlGetFeaturesList(void) {
13090: int test_ret = 0;
13091:
13092: #if defined(LIBXML_LEGACY_ENABLED)
13093: #ifdef LIBXML_LEGACY_ENABLED
13094: int mem_base;
13095: int ret_val;
13096: int * len; /* the length of the features name array (input/output) */
13097: int n_len;
13098: char ** result; /* an array of string to be filled with the features name. */
13099: int n_result;
13100:
13101: for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
13102: for (n_result = 0;n_result < gen_nb_const_char_ptr_ptr;n_result++) {
13103: mem_base = xmlMemBlocks();
13104: len = gen_int_ptr(n_len, 0);
13105: result = gen_const_char_ptr_ptr(n_result, 1);
13106:
13107: ret_val = xmlGetFeaturesList(len, (const char **)result);
13108: desret_int(ret_val);
13109: call_tests++;
13110: des_int_ptr(n_len, len, 0);
13111: des_const_char_ptr_ptr(n_result, (const char **)result, 1);
13112: xmlResetLastError();
13113: if (mem_base != xmlMemBlocks()) {
13114: printf("Leak of %d blocks found in xmlGetFeaturesList",
13115: xmlMemBlocks() - mem_base);
13116: test_ret++;
13117: printf(" %d", n_len);
13118: printf(" %d", n_result);
13119: printf("\n");
13120: }
13121: }
13122: }
13123: function_tests++;
13124: #endif
13125: #endif
13126:
13127: return(test_ret);
13128: }
13129:
13130:
13131: static int
13132: test_xmlHasFeature(void) {
13133: int test_ret = 0;
13134:
13135: int mem_base;
13136: int ret_val;
13137: xmlFeature feature; /* the feature to be examined */
13138: int n_feature;
13139:
13140: for (n_feature = 0;n_feature < gen_nb_xmlFeature;n_feature++) {
13141: mem_base = xmlMemBlocks();
13142: feature = gen_xmlFeature(n_feature, 0);
13143:
13144: ret_val = xmlHasFeature(feature);
13145: desret_int(ret_val);
13146: call_tests++;
13147: des_xmlFeature(n_feature, feature, 0);
13148: xmlResetLastError();
13149: if (mem_base != xmlMemBlocks()) {
13150: printf("Leak of %d blocks found in xmlHasFeature",
13151: xmlMemBlocks() - mem_base);
13152: test_ret++;
13153: printf(" %d", n_feature);
13154: printf("\n");
13155: }
13156: }
13157: function_tests++;
13158:
13159: return(test_ret);
13160: }
13161:
13162:
13163: static int
13164: test_xmlIOParseDTD(void) {
13165: int test_ret = 0;
13166:
13167: #if defined(LIBXML_VALID_ENABLED)
13168: #ifdef LIBXML_VALID_ENABLED
13169: xmlDtdPtr ret_val;
13170: xmlSAXHandlerPtr sax; /* the SAX handler block or NULL */
13171: int n_sax;
13172: xmlParserInputBufferPtr input; /* an Input Buffer */
13173: int n_input;
13174: xmlCharEncoding enc; /* the charset encoding if known */
13175: int n_enc;
13176:
13177: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
13178: for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) {
13179: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
13180: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
13181: input = gen_xmlParserInputBufferPtr(n_input, 1);
13182: enc = gen_xmlCharEncoding(n_enc, 2);
13183:
13184: ret_val = xmlIOParseDTD(sax, input, enc);
13185: input = NULL;
13186: desret_xmlDtdPtr(ret_val);
13187: call_tests++;
13188: des_xmlSAXHandlerPtr(n_sax, sax, 0);
13189: des_xmlParserInputBufferPtr(n_input, input, 1);
13190: des_xmlCharEncoding(n_enc, enc, 2);
13191: xmlResetLastError();
13192: }
13193: }
13194: }
13195: function_tests++;
13196: #endif
13197: #endif
13198:
13199: return(test_ret);
13200: }
13201:
13202:
13203: static int
13204: test_xmlInitNodeInfoSeq(void) {
13205: int test_ret = 0;
13206:
13207: int mem_base;
13208: xmlParserNodeInfoSeqPtr seq; /* a node info sequence pointer */
13209: int n_seq;
13210:
13211: for (n_seq = 0;n_seq < gen_nb_xmlParserNodeInfoSeqPtr;n_seq++) {
13212: mem_base = xmlMemBlocks();
13213: seq = gen_xmlParserNodeInfoSeqPtr(n_seq, 0);
13214:
13215: xmlInitNodeInfoSeq(seq);
13216: call_tests++;
13217: des_xmlParserNodeInfoSeqPtr(n_seq, seq, 0);
13218: xmlResetLastError();
13219: if (mem_base != xmlMemBlocks()) {
13220: printf("Leak of %d blocks found in xmlInitNodeInfoSeq",
13221: xmlMemBlocks() - mem_base);
13222: test_ret++;
13223: printf(" %d", n_seq);
13224: printf("\n");
13225: }
13226: }
13227: function_tests++;
13228:
13229: return(test_ret);
13230: }
13231:
13232:
13233: static int
13234: test_xmlInitParser(void) {
13235: int test_ret = 0;
13236:
13237: int mem_base;
13238:
13239: mem_base = xmlMemBlocks();
13240:
13241: xmlInitParser();
13242: call_tests++;
13243: xmlResetLastError();
13244: if (mem_base != xmlMemBlocks()) {
13245: printf("Leak of %d blocks found in xmlInitParser",
13246: xmlMemBlocks() - mem_base);
13247: test_ret++;
13248: printf("\n");
13249: }
13250: function_tests++;
13251:
13252: return(test_ret);
13253: }
13254:
13255:
13256: static int
13257: test_xmlInitParserCtxt(void) {
13258: int test_ret = 0;
13259:
13260: int mem_base;
13261: int ret_val;
13262: xmlParserCtxtPtr ctxt; /* an XML parser context */
13263: int n_ctxt;
13264:
13265: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
13266: mem_base = xmlMemBlocks();
13267: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
13268:
13269: ret_val = xmlInitParserCtxt(ctxt);
13270: desret_int(ret_val);
13271: call_tests++;
13272: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
13273: xmlResetLastError();
13274: if (mem_base != xmlMemBlocks()) {
13275: printf("Leak of %d blocks found in xmlInitParserCtxt",
13276: xmlMemBlocks() - mem_base);
13277: test_ret++;
13278: printf(" %d", n_ctxt);
13279: printf("\n");
13280: }
13281: }
13282: function_tests++;
13283:
13284: return(test_ret);
13285: }
13286:
13287:
13288: static int
13289: test_xmlKeepBlanksDefault(void) {
13290: int test_ret = 0;
13291:
13292: int mem_base;
13293: int ret_val;
13294: int val; /* int 0 or 1 */
13295: int n_val;
13296:
13297: for (n_val = 0;n_val < gen_nb_int;n_val++) {
13298: mem_base = xmlMemBlocks();
13299: val = gen_int(n_val, 0);
13300:
13301: ret_val = xmlKeepBlanksDefault(val);
13302: desret_int(ret_val);
13303: call_tests++;
13304: des_int(n_val, val, 0);
13305: xmlResetLastError();
13306: if (mem_base != xmlMemBlocks()) {
13307: printf("Leak of %d blocks found in xmlKeepBlanksDefault",
13308: xmlMemBlocks() - mem_base);
13309: test_ret++;
13310: printf(" %d", n_val);
13311: printf("\n");
13312: }
13313: }
13314: function_tests++;
13315:
13316: return(test_ret);
13317: }
13318:
13319:
13320: static int
13321: test_xmlLineNumbersDefault(void) {
13322: int test_ret = 0;
13323:
13324: int mem_base;
13325: int ret_val;
13326: int val; /* int 0 or 1 */
13327: int n_val;
13328:
13329: for (n_val = 0;n_val < gen_nb_int;n_val++) {
13330: mem_base = xmlMemBlocks();
13331: val = gen_int(n_val, 0);
13332:
13333: ret_val = xmlLineNumbersDefault(val);
13334: desret_int(ret_val);
13335: call_tests++;
13336: des_int(n_val, val, 0);
13337: xmlResetLastError();
13338: if (mem_base != xmlMemBlocks()) {
13339: printf("Leak of %d blocks found in xmlLineNumbersDefault",
13340: xmlMemBlocks() - mem_base);
13341: test_ret++;
13342: printf(" %d", n_val);
13343: printf("\n");
13344: }
13345: }
13346: function_tests++;
13347:
13348: return(test_ret);
13349: }
13350:
13351:
13352: static int
13353: test_xmlLoadExternalEntity(void) {
13354: int test_ret = 0;
13355:
13356: int mem_base;
13357: xmlParserInputPtr ret_val;
13358: const char * URL; /* the URL for the entity to load */
13359: int n_URL;
13360: char * ID; /* the Public ID for the entity to load */
13361: int n_ID;
13362: xmlParserCtxtPtr ctxt; /* the context in which the entity is called or NULL */
13363: int n_ctxt;
13364:
13365: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
13366: for (n_ID = 0;n_ID < gen_nb_const_char_ptr;n_ID++) {
13367: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
13368: mem_base = xmlMemBlocks();
13369: URL = gen_filepath(n_URL, 0);
13370: ID = gen_const_char_ptr(n_ID, 1);
13371: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 2);
13372:
13373: ret_val = xmlLoadExternalEntity(URL, (const char *)ID, ctxt);
13374: desret_xmlParserInputPtr(ret_val);
13375: call_tests++;
13376: des_filepath(n_URL, URL, 0);
13377: des_const_char_ptr(n_ID, (const char *)ID, 1);
13378: des_xmlParserCtxtPtr(n_ctxt, ctxt, 2);
13379: xmlResetLastError();
13380: if (mem_base != xmlMemBlocks()) {
13381: printf("Leak of %d blocks found in xmlLoadExternalEntity",
13382: xmlMemBlocks() - mem_base);
13383: test_ret++;
13384: printf(" %d", n_URL);
13385: printf(" %d", n_ID);
13386: printf(" %d", n_ctxt);
13387: printf("\n");
13388: }
13389: }
13390: }
13391: }
13392: function_tests++;
13393:
13394: return(test_ret);
13395: }
13396:
13397:
13398: static int
13399: test_xmlNewIOInputStream(void) {
13400: int test_ret = 0;
13401:
13402: int mem_base;
13403: xmlParserInputPtr ret_val;
13404: xmlParserCtxtPtr ctxt; /* an XML parser context */
13405: int n_ctxt;
13406: xmlParserInputBufferPtr input; /* an I/O Input */
13407: int n_input;
13408: xmlCharEncoding enc; /* the charset encoding if known */
13409: int n_enc;
13410:
13411: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
13412: for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) {
13413: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
13414: mem_base = xmlMemBlocks();
13415: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
13416: input = gen_xmlParserInputBufferPtr(n_input, 1);
13417: enc = gen_xmlCharEncoding(n_enc, 2);
13418:
13419: ret_val = xmlNewIOInputStream(ctxt, input, enc);
13420: if (ret_val != NULL) input = NULL;
13421: desret_xmlParserInputPtr(ret_val);
13422: call_tests++;
13423: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
13424: des_xmlParserInputBufferPtr(n_input, input, 1);
13425: des_xmlCharEncoding(n_enc, enc, 2);
13426: xmlResetLastError();
13427: if (mem_base != xmlMemBlocks()) {
13428: printf("Leak of %d blocks found in xmlNewIOInputStream",
13429: xmlMemBlocks() - mem_base);
13430: test_ret++;
13431: printf(" %d", n_ctxt);
13432: printf(" %d", n_input);
13433: printf(" %d", n_enc);
13434: printf("\n");
13435: }
13436: }
13437: }
13438: }
13439: function_tests++;
13440:
13441: return(test_ret);
13442: }
13443:
13444:
13445: static int
13446: test_xmlNewParserCtxt(void) {
13447: int test_ret = 0;
13448:
13449: int mem_base;
13450: xmlParserCtxtPtr ret_val;
13451:
13452: mem_base = xmlMemBlocks();
13453:
13454: ret_val = xmlNewParserCtxt();
13455: desret_xmlParserCtxtPtr(ret_val);
13456: call_tests++;
13457: xmlResetLastError();
13458: if (mem_base != xmlMemBlocks()) {
13459: printf("Leak of %d blocks found in xmlNewParserCtxt",
13460: xmlMemBlocks() - mem_base);
13461: test_ret++;
13462: printf("\n");
13463: }
13464: function_tests++;
13465:
13466: return(test_ret);
13467: }
13468:
13469:
13470: #define gen_nb_xmlNodePtr_ptr 1
13471: static xmlNodePtr * gen_xmlNodePtr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
13472: return(NULL);
13473: }
13474: static void des_xmlNodePtr_ptr(int no ATTRIBUTE_UNUSED, xmlNodePtr * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
13475: }
13476:
13477: static int
13478: test_xmlParseBalancedChunkMemory(void) {
13479: int test_ret = 0;
13480:
13481: #if defined(LIBXML_SAX1_ENABLED)
13482: #ifdef LIBXML_SAX1_ENABLED
13483: int mem_base;
13484: int ret_val;
13485: xmlDocPtr doc; /* the document the chunk pertains to */
13486: int n_doc;
13487: xmlSAXHandlerPtr sax; /* the SAX handler bloc (possibly NULL) */
13488: int n_sax;
13489: void * user_data; /* The user data returned on SAX callbacks (possibly NULL) */
13490: int n_user_data;
13491: int depth; /* Used for loop detection, use 0 */
13492: int n_depth;
13493: xmlChar * string; /* the input string in UTF8 or ISO-Latin (zero terminated) */
13494: int n_string;
13495: xmlNodePtr * lst; /* the return value for the set of parsed nodes */
13496: int n_lst;
13497:
13498: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
13499: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
13500: for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
13501: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
13502: for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) {
13503: for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) {
13504: mem_base = xmlMemBlocks();
13505: doc = gen_xmlDocPtr(n_doc, 0);
13506: sax = gen_xmlSAXHandlerPtr(n_sax, 1);
13507: user_data = gen_userdata(n_user_data, 2);
13508: depth = gen_int(n_depth, 3);
13509: string = gen_const_xmlChar_ptr(n_string, 4);
13510: lst = gen_xmlNodePtr_ptr(n_lst, 5);
13511:
13512: #ifdef LIBXML_SAX1_ENABLED
13513: if (sax == (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) user_data = NULL;
13514: #endif
13515:
13516:
13517: ret_val = xmlParseBalancedChunkMemory(doc, sax, user_data, depth, (const xmlChar *)string, lst);
13518: desret_int(ret_val);
13519: call_tests++;
13520: des_xmlDocPtr(n_doc, doc, 0);
13521: des_xmlSAXHandlerPtr(n_sax, sax, 1);
13522: des_userdata(n_user_data, user_data, 2);
13523: des_int(n_depth, depth, 3);
13524: des_const_xmlChar_ptr(n_string, (const xmlChar *)string, 4);
13525: des_xmlNodePtr_ptr(n_lst, lst, 5);
13526: xmlResetLastError();
13527: if (mem_base != xmlMemBlocks()) {
13528: printf("Leak of %d blocks found in xmlParseBalancedChunkMemory",
13529: xmlMemBlocks() - mem_base);
13530: test_ret++;
13531: printf(" %d", n_doc);
13532: printf(" %d", n_sax);
13533: printf(" %d", n_user_data);
13534: printf(" %d", n_depth);
13535: printf(" %d", n_string);
13536: printf(" %d", n_lst);
13537: printf("\n");
13538: }
13539: }
13540: }
13541: }
13542: }
13543: }
13544: }
13545: function_tests++;
13546: #endif
13547: #endif
13548:
13549: return(test_ret);
13550: }
13551:
13552:
13553: static int
13554: test_xmlParseBalancedChunkMemoryRecover(void) {
13555: int test_ret = 0;
13556:
13557: #if defined(LIBXML_SAX1_ENABLED)
13558: #ifdef LIBXML_SAX1_ENABLED
13559: int mem_base;
13560: int ret_val;
13561: xmlDocPtr doc; /* the document the chunk pertains to */
13562: int n_doc;
13563: xmlSAXHandlerPtr sax; /* the SAX handler bloc (possibly NULL) */
13564: int n_sax;
13565: void * user_data; /* The user data returned on SAX callbacks (possibly NULL) */
13566: int n_user_data;
13567: int depth; /* Used for loop detection, use 0 */
13568: int n_depth;
13569: xmlChar * string; /* the input string in UTF8 or ISO-Latin (zero terminated) */
13570: int n_string;
13571: xmlNodePtr * lst; /* the return value for the set of parsed nodes */
13572: int n_lst;
13573: int recover; /* return nodes even if the data is broken (use 0) */
13574: int n_recover;
13575:
13576: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
13577: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
13578: for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
13579: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
13580: for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) {
13581: for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) {
13582: for (n_recover = 0;n_recover < gen_nb_int;n_recover++) {
13583: mem_base = xmlMemBlocks();
13584: doc = gen_xmlDocPtr(n_doc, 0);
13585: sax = gen_xmlSAXHandlerPtr(n_sax, 1);
13586: user_data = gen_userdata(n_user_data, 2);
13587: depth = gen_int(n_depth, 3);
13588: string = gen_const_xmlChar_ptr(n_string, 4);
13589: lst = gen_xmlNodePtr_ptr(n_lst, 5);
13590: recover = gen_int(n_recover, 6);
13591:
13592: #ifdef LIBXML_SAX1_ENABLED
13593: if (sax == (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) user_data = NULL;
13594: #endif
13595:
13596:
13597: ret_val = xmlParseBalancedChunkMemoryRecover(doc, sax, user_data, depth, (const xmlChar *)string, lst, recover);
13598: desret_int(ret_val);
13599: call_tests++;
13600: des_xmlDocPtr(n_doc, doc, 0);
13601: des_xmlSAXHandlerPtr(n_sax, sax, 1);
13602: des_userdata(n_user_data, user_data, 2);
13603: des_int(n_depth, depth, 3);
13604: des_const_xmlChar_ptr(n_string, (const xmlChar *)string, 4);
13605: des_xmlNodePtr_ptr(n_lst, lst, 5);
13606: des_int(n_recover, recover, 6);
13607: xmlResetLastError();
13608: if (mem_base != xmlMemBlocks()) {
13609: printf("Leak of %d blocks found in xmlParseBalancedChunkMemoryRecover",
13610: xmlMemBlocks() - mem_base);
13611: test_ret++;
13612: printf(" %d", n_doc);
13613: printf(" %d", n_sax);
13614: printf(" %d", n_user_data);
13615: printf(" %d", n_depth);
13616: printf(" %d", n_string);
13617: printf(" %d", n_lst);
13618: printf(" %d", n_recover);
13619: printf("\n");
13620: }
13621: }
13622: }
13623: }
13624: }
13625: }
13626: }
13627: }
13628: function_tests++;
13629: #endif
13630: #endif
13631:
13632: return(test_ret);
13633: }
13634:
13635:
13636: static int
13637: test_xmlParseChunk(void) {
13638: int test_ret = 0;
13639:
13640: #if defined(LIBXML_PUSH_ENABLED)
13641: int mem_base;
13642: int ret_val;
13643: xmlParserCtxtPtr ctxt; /* an XML parser context */
13644: int n_ctxt;
13645: char * chunk; /* an char array */
13646: int n_chunk;
13647: int size; /* the size in byte of the chunk */
13648: int n_size;
13649: int terminate; /* last chunk indicator */
13650: int n_terminate;
13651:
13652: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
13653: for (n_chunk = 0;n_chunk < gen_nb_const_char_ptr;n_chunk++) {
13654: for (n_size = 0;n_size < gen_nb_int;n_size++) {
13655: for (n_terminate = 0;n_terminate < gen_nb_int;n_terminate++) {
13656: mem_base = xmlMemBlocks();
13657: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
13658: chunk = gen_const_char_ptr(n_chunk, 1);
13659: size = gen_int(n_size, 2);
13660: terminate = gen_int(n_terminate, 3);
13661:
13662: ret_val = xmlParseChunk(ctxt, (const char *)chunk, size, terminate);
13663: if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;}
13664: desret_int(ret_val);
13665: call_tests++;
13666: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
13667: des_const_char_ptr(n_chunk, (const char *)chunk, 1);
13668: des_int(n_size, size, 2);
13669: des_int(n_terminate, terminate, 3);
13670: xmlResetLastError();
13671: if (mem_base != xmlMemBlocks()) {
13672: printf("Leak of %d blocks found in xmlParseChunk",
13673: xmlMemBlocks() - mem_base);
13674: test_ret++;
13675: printf(" %d", n_ctxt);
13676: printf(" %d", n_chunk);
13677: printf(" %d", n_size);
13678: printf(" %d", n_terminate);
13679: printf("\n");
13680: }
13681: }
13682: }
13683: }
13684: }
13685: function_tests++;
13686: #endif
13687:
13688: return(test_ret);
13689: }
13690:
13691:
13692: static int
13693: test_xmlParseCtxtExternalEntity(void) {
13694: int test_ret = 0;
13695:
13696: int mem_base;
13697: int ret_val;
13698: xmlParserCtxtPtr ctx; /* the existing parsing context */
13699: int n_ctx;
13700: xmlChar * URL; /* the URL for the entity to load */
13701: int n_URL;
13702: xmlChar * ID; /* the System ID for the entity to load */
13703: int n_ID;
13704: xmlNodePtr * lst; /* the return value for the set of parsed nodes */
13705: int n_lst;
13706:
13707: for (n_ctx = 0;n_ctx < gen_nb_xmlParserCtxtPtr;n_ctx++) {
13708: for (n_URL = 0;n_URL < gen_nb_const_xmlChar_ptr;n_URL++) {
13709: for (n_ID = 0;n_ID < gen_nb_const_xmlChar_ptr;n_ID++) {
13710: for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) {
13711: mem_base = xmlMemBlocks();
13712: ctx = gen_xmlParserCtxtPtr(n_ctx, 0);
13713: URL = gen_const_xmlChar_ptr(n_URL, 1);
13714: ID = gen_const_xmlChar_ptr(n_ID, 2);
13715: lst = gen_xmlNodePtr_ptr(n_lst, 3);
13716:
13717: ret_val = xmlParseCtxtExternalEntity(ctx, (const xmlChar *)URL, (const xmlChar *)ID, lst);
13718: desret_int(ret_val);
13719: call_tests++;
13720: des_xmlParserCtxtPtr(n_ctx, ctx, 0);
13721: des_const_xmlChar_ptr(n_URL, (const xmlChar *)URL, 1);
13722: des_const_xmlChar_ptr(n_ID, (const xmlChar *)ID, 2);
13723: des_xmlNodePtr_ptr(n_lst, lst, 3);
13724: xmlResetLastError();
13725: if (mem_base != xmlMemBlocks()) {
13726: printf("Leak of %d blocks found in xmlParseCtxtExternalEntity",
13727: xmlMemBlocks() - mem_base);
13728: test_ret++;
13729: printf(" %d", n_ctx);
13730: printf(" %d", n_URL);
13731: printf(" %d", n_ID);
13732: printf(" %d", n_lst);
13733: printf("\n");
13734: }
13735: }
13736: }
13737: }
13738: }
13739: function_tests++;
13740:
13741: return(test_ret);
13742: }
13743:
13744:
13745: static int
13746: test_xmlParseDTD(void) {
13747: int test_ret = 0;
13748:
13749: #if defined(LIBXML_VALID_ENABLED)
13750: #ifdef LIBXML_VALID_ENABLED
13751: int mem_base;
13752: xmlDtdPtr ret_val;
13753: xmlChar * ExternalID; /* a NAME* containing the External ID of the DTD */
13754: int n_ExternalID;
13755: xmlChar * SystemID; /* a NAME* containing the URL to the DTD */
13756: int n_SystemID;
13757:
13758: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
13759: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
13760: mem_base = xmlMemBlocks();
13761: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 0);
13762: SystemID = gen_const_xmlChar_ptr(n_SystemID, 1);
13763:
13764: ret_val = xmlParseDTD((const xmlChar *)ExternalID, (const xmlChar *)SystemID);
13765: desret_xmlDtdPtr(ret_val);
13766: call_tests++;
13767: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 0);
13768: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 1);
13769: xmlResetLastError();
13770: if (mem_base != xmlMemBlocks()) {
13771: printf("Leak of %d blocks found in xmlParseDTD",
13772: xmlMemBlocks() - mem_base);
13773: test_ret++;
13774: printf(" %d", n_ExternalID);
13775: printf(" %d", n_SystemID);
13776: printf("\n");
13777: }
13778: }
13779: }
13780: function_tests++;
13781: #endif
13782: #endif
13783:
13784: return(test_ret);
13785: }
13786:
13787:
13788: static int
13789: test_xmlParseDoc(void) {
13790: int test_ret = 0;
13791:
13792: #if defined(LIBXML_SAX1_ENABLED)
13793: #ifdef LIBXML_SAX1_ENABLED
13794: int mem_base;
13795: xmlDocPtr ret_val;
13796: xmlChar * cur; /* a pointer to an array of xmlChar */
13797: int n_cur;
13798:
13799: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
13800: mem_base = xmlMemBlocks();
13801: cur = gen_const_xmlChar_ptr(n_cur, 0);
13802:
13803: ret_val = xmlParseDoc((const xmlChar *)cur);
13804: desret_xmlDocPtr(ret_val);
13805: call_tests++;
13806: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
13807: xmlResetLastError();
13808: if (mem_base != xmlMemBlocks()) {
13809: printf("Leak of %d blocks found in xmlParseDoc",
13810: xmlMemBlocks() - mem_base);
13811: test_ret++;
13812: printf(" %d", n_cur);
13813: printf("\n");
13814: }
13815: }
13816: function_tests++;
13817: #endif
13818: #endif
13819:
13820: return(test_ret);
13821: }
13822:
13823:
13824: static int
13825: test_xmlParseDocument(void) {
13826: int test_ret = 0;
13827:
13828: int mem_base;
13829: int ret_val;
13830: xmlParserCtxtPtr ctxt; /* an XML parser context */
13831: int n_ctxt;
13832:
13833: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
13834: mem_base = xmlMemBlocks();
13835: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
13836:
13837: ret_val = xmlParseDocument(ctxt);
13838: if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;}
13839: desret_int(ret_val);
13840: call_tests++;
13841: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
13842: xmlResetLastError();
13843: if (mem_base != xmlMemBlocks()) {
13844: printf("Leak of %d blocks found in xmlParseDocument",
13845: xmlMemBlocks() - mem_base);
13846: test_ret++;
13847: printf(" %d", n_ctxt);
13848: printf("\n");
13849: }
13850: }
13851: function_tests++;
13852:
13853: return(test_ret);
13854: }
13855:
13856:
13857: static int
13858: test_xmlParseEntity(void) {
13859: int test_ret = 0;
13860:
13861: #if defined(LIBXML_SAX1_ENABLED)
13862: #ifdef LIBXML_SAX1_ENABLED
13863: int mem_base;
13864: xmlDocPtr ret_val;
13865: const char * filename; /* the filename */
13866: int n_filename;
13867:
13868: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
13869: mem_base = xmlMemBlocks();
13870: filename = gen_filepath(n_filename, 0);
13871:
13872: ret_val = xmlParseEntity(filename);
13873: desret_xmlDocPtr(ret_val);
13874: call_tests++;
13875: des_filepath(n_filename, filename, 0);
13876: xmlResetLastError();
13877: if (mem_base != xmlMemBlocks()) {
13878: printf("Leak of %d blocks found in xmlParseEntity",
13879: xmlMemBlocks() - mem_base);
13880: test_ret++;
13881: printf(" %d", n_filename);
13882: printf("\n");
13883: }
13884: }
13885: function_tests++;
13886: #endif
13887: #endif
13888:
13889: return(test_ret);
13890: }
13891:
13892:
13893: static int
13894: test_xmlParseExtParsedEnt(void) {
13895: int test_ret = 0;
13896:
13897: int mem_base;
13898: int ret_val;
13899: xmlParserCtxtPtr ctxt; /* an XML parser context */
13900: int n_ctxt;
13901:
13902: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
13903: mem_base = xmlMemBlocks();
13904: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
13905:
13906: ret_val = xmlParseExtParsedEnt(ctxt);
13907: if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;}
13908: desret_int(ret_val);
13909: call_tests++;
13910: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
13911: xmlResetLastError();
13912: if (mem_base != xmlMemBlocks()) {
13913: printf("Leak of %d blocks found in xmlParseExtParsedEnt",
13914: xmlMemBlocks() - mem_base);
13915: test_ret++;
13916: printf(" %d", n_ctxt);
13917: printf("\n");
13918: }
13919: }
13920: function_tests++;
13921:
13922: return(test_ret);
13923: }
13924:
13925:
13926: static int
13927: test_xmlParseExternalEntity(void) {
13928: int test_ret = 0;
13929:
13930: #if defined(LIBXML_SAX1_ENABLED)
13931: #ifdef LIBXML_SAX1_ENABLED
13932: int mem_base;
13933: int ret_val;
13934: xmlDocPtr doc; /* the document the chunk pertains to */
13935: int n_doc;
13936: xmlSAXHandlerPtr sax; /* the SAX handler bloc (possibly NULL) */
13937: int n_sax;
13938: void * user_data; /* The user data returned on SAX callbacks (possibly NULL) */
13939: int n_user_data;
13940: int depth; /* Used for loop detection, use 0 */
13941: int n_depth;
13942: xmlChar * URL; /* the URL for the entity to load */
13943: int n_URL;
13944: xmlChar * ID; /* the System ID for the entity to load */
13945: int n_ID;
13946: xmlNodePtr * lst; /* the return value for the set of parsed nodes */
13947: int n_lst;
13948:
13949: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
13950: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
13951: for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
13952: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
13953: for (n_URL = 0;n_URL < gen_nb_const_xmlChar_ptr;n_URL++) {
13954: for (n_ID = 0;n_ID < gen_nb_const_xmlChar_ptr;n_ID++) {
13955: for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) {
13956: mem_base = xmlMemBlocks();
13957: doc = gen_xmlDocPtr(n_doc, 0);
13958: sax = gen_xmlSAXHandlerPtr(n_sax, 1);
13959: user_data = gen_userdata(n_user_data, 2);
13960: depth = gen_int(n_depth, 3);
13961: URL = gen_const_xmlChar_ptr(n_URL, 4);
13962: ID = gen_const_xmlChar_ptr(n_ID, 5);
13963: lst = gen_xmlNodePtr_ptr(n_lst, 6);
13964:
13965: ret_val = xmlParseExternalEntity(doc, sax, user_data, depth, (const xmlChar *)URL, (const xmlChar *)ID, lst);
13966: desret_int(ret_val);
13967: call_tests++;
13968: des_xmlDocPtr(n_doc, doc, 0);
13969: des_xmlSAXHandlerPtr(n_sax, sax, 1);
13970: des_userdata(n_user_data, user_data, 2);
13971: des_int(n_depth, depth, 3);
13972: des_const_xmlChar_ptr(n_URL, (const xmlChar *)URL, 4);
13973: des_const_xmlChar_ptr(n_ID, (const xmlChar *)ID, 5);
13974: des_xmlNodePtr_ptr(n_lst, lst, 6);
13975: xmlResetLastError();
13976: if (mem_base != xmlMemBlocks()) {
13977: printf("Leak of %d blocks found in xmlParseExternalEntity",
13978: xmlMemBlocks() - mem_base);
13979: test_ret++;
13980: printf(" %d", n_doc);
13981: printf(" %d", n_sax);
13982: printf(" %d", n_user_data);
13983: printf(" %d", n_depth);
13984: printf(" %d", n_URL);
13985: printf(" %d", n_ID);
13986: printf(" %d", n_lst);
13987: printf("\n");
13988: }
13989: }
13990: }
13991: }
13992: }
13993: }
13994: }
13995: }
13996: function_tests++;
13997: #endif
13998: #endif
13999:
14000: return(test_ret);
14001: }
14002:
14003:
14004: static int
14005: test_xmlParseFile(void) {
14006: int test_ret = 0;
14007:
14008: #if defined(LIBXML_SAX1_ENABLED)
14009: #ifdef LIBXML_SAX1_ENABLED
14010: int mem_base;
14011: xmlDocPtr ret_val;
14012: const char * filename; /* the filename */
14013: int n_filename;
14014:
14015: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
14016: mem_base = xmlMemBlocks();
14017: filename = gen_filepath(n_filename, 0);
14018:
14019: ret_val = xmlParseFile(filename);
14020: desret_xmlDocPtr(ret_val);
14021: call_tests++;
14022: des_filepath(n_filename, filename, 0);
14023: xmlResetLastError();
14024: if (mem_base != xmlMemBlocks()) {
14025: printf("Leak of %d blocks found in xmlParseFile",
14026: xmlMemBlocks() - mem_base);
14027: test_ret++;
14028: printf(" %d", n_filename);
14029: printf("\n");
14030: }
14031: }
14032: function_tests++;
14033: #endif
14034: #endif
14035:
14036: return(test_ret);
14037: }
14038:
14039:
14040: static int
14041: test_xmlParseInNodeContext(void) {
14042: int test_ret = 0;
14043:
14044: int mem_base;
14045: xmlParserErrors ret_val;
14046: xmlNodePtr node; /* the context node */
14047: int n_node;
14048: char * data; /* the input string */
14049: int n_data;
14050: int datalen; /* the input string length in bytes */
14051: int n_datalen;
14052: int options; /* a combination of xmlParserOption */
14053: int n_options;
14054: xmlNodePtr * lst; /* the return value for the set of parsed nodes */
14055: int n_lst;
14056:
14057: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
14058: for (n_data = 0;n_data < gen_nb_const_char_ptr;n_data++) {
14059: for (n_datalen = 0;n_datalen < gen_nb_int;n_datalen++) {
14060: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
14061: for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) {
14062: mem_base = xmlMemBlocks();
14063: node = gen_xmlNodePtr(n_node, 0);
14064: data = gen_const_char_ptr(n_data, 1);
14065: datalen = gen_int(n_datalen, 2);
14066: options = gen_parseroptions(n_options, 3);
14067: lst = gen_xmlNodePtr_ptr(n_lst, 4);
14068:
14069: ret_val = xmlParseInNodeContext(node, (const char *)data, datalen, options, lst);
14070: desret_xmlParserErrors(ret_val);
14071: call_tests++;
14072: des_xmlNodePtr(n_node, node, 0);
14073: des_const_char_ptr(n_data, (const char *)data, 1);
14074: des_int(n_datalen, datalen, 2);
14075: des_parseroptions(n_options, options, 3);
14076: des_xmlNodePtr_ptr(n_lst, lst, 4);
14077: xmlResetLastError();
14078: if (mem_base != xmlMemBlocks()) {
14079: printf("Leak of %d blocks found in xmlParseInNodeContext",
14080: xmlMemBlocks() - mem_base);
14081: test_ret++;
14082: printf(" %d", n_node);
14083: printf(" %d", n_data);
14084: printf(" %d", n_datalen);
14085: printf(" %d", n_options);
14086: printf(" %d", n_lst);
14087: printf("\n");
14088: }
14089: }
14090: }
14091: }
14092: }
14093: }
14094: function_tests++;
14095:
14096: return(test_ret);
14097: }
14098:
14099:
14100: static int
14101: test_xmlParseMemory(void) {
14102: int test_ret = 0;
14103:
14104: #if defined(LIBXML_SAX1_ENABLED)
14105: #ifdef LIBXML_SAX1_ENABLED
14106: int mem_base;
14107: xmlDocPtr ret_val;
14108: char * buffer; /* an pointer to a char array */
14109: int n_buffer;
14110: int size; /* the size of the array */
14111: int n_size;
14112:
14113: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
14114: for (n_size = 0;n_size < gen_nb_int;n_size++) {
14115: mem_base = xmlMemBlocks();
14116: buffer = gen_const_char_ptr(n_buffer, 0);
14117: size = gen_int(n_size, 1);
14118:
14119: ret_val = xmlParseMemory((const char *)buffer, size);
14120: desret_xmlDocPtr(ret_val);
14121: call_tests++;
14122: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
14123: des_int(n_size, size, 1);
14124: xmlResetLastError();
14125: if (mem_base != xmlMemBlocks()) {
14126: printf("Leak of %d blocks found in xmlParseMemory",
14127: xmlMemBlocks() - mem_base);
14128: test_ret++;
14129: printf(" %d", n_buffer);
14130: printf(" %d", n_size);
14131: printf("\n");
14132: }
14133: }
14134: }
14135: function_tests++;
14136: #endif
14137: #endif
14138:
14139: return(test_ret);
14140: }
14141:
14142:
14143: #define gen_nb_const_xmlParserNodeInfoPtr 1
14144: static xmlParserNodeInfoPtr gen_const_xmlParserNodeInfoPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14145: return(NULL);
14146: }
14147: static void des_const_xmlParserNodeInfoPtr(int no ATTRIBUTE_UNUSED, const xmlParserNodeInfoPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14148: }
14149:
14150: static int
14151: test_xmlParserAddNodeInfo(void) {
14152: int test_ret = 0;
14153:
14154: int mem_base;
14155: xmlParserCtxtPtr ctxt; /* an XML parser context */
14156: int n_ctxt;
14157: xmlParserNodeInfoPtr info; /* a node info sequence pointer */
14158: int n_info;
14159:
14160: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
14161: for (n_info = 0;n_info < gen_nb_const_xmlParserNodeInfoPtr;n_info++) {
14162: mem_base = xmlMemBlocks();
14163: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
14164: info = gen_const_xmlParserNodeInfoPtr(n_info, 1);
14165:
14166: xmlParserAddNodeInfo(ctxt, (const xmlParserNodeInfoPtr)info);
14167: call_tests++;
14168: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
14169: des_const_xmlParserNodeInfoPtr(n_info, (const xmlParserNodeInfoPtr)info, 1);
14170: xmlResetLastError();
14171: if (mem_base != xmlMemBlocks()) {
14172: printf("Leak of %d blocks found in xmlParserAddNodeInfo",
14173: xmlMemBlocks() - mem_base);
14174: test_ret++;
14175: printf(" %d", n_ctxt);
14176: printf(" %d", n_info);
14177: printf("\n");
14178: }
14179: }
14180: }
14181: function_tests++;
14182:
14183: return(test_ret);
14184: }
14185:
14186:
14187: #define gen_nb_const_xmlParserCtxtPtr 1
14188: static xmlParserCtxtPtr gen_const_xmlParserCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14189: return(NULL);
14190: }
14191: static void des_const_xmlParserCtxtPtr(int no ATTRIBUTE_UNUSED, const xmlParserCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14192: }
14193:
14194: #define gen_nb_const_xmlNodePtr 1
14195: static xmlNodePtr gen_const_xmlNodePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14196: return(NULL);
14197: }
14198: static void des_const_xmlNodePtr(int no ATTRIBUTE_UNUSED, const xmlNodePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14199: }
14200:
14201: static int
14202: test_xmlParserFindNodeInfo(void) {
14203: int test_ret = 0;
14204:
14205: int mem_base;
14206: const xmlParserNodeInfo * ret_val;
14207: xmlParserCtxtPtr ctx; /* an XML parser context */
14208: int n_ctx;
14209: xmlNodePtr node; /* an XML node within the tree */
14210: int n_node;
14211:
14212: for (n_ctx = 0;n_ctx < gen_nb_const_xmlParserCtxtPtr;n_ctx++) {
14213: for (n_node = 0;n_node < gen_nb_const_xmlNodePtr;n_node++) {
14214: mem_base = xmlMemBlocks();
14215: ctx = gen_const_xmlParserCtxtPtr(n_ctx, 0);
14216: node = gen_const_xmlNodePtr(n_node, 1);
14217:
14218: ret_val = xmlParserFindNodeInfo((const xmlParserCtxtPtr)ctx, (const xmlNodePtr)node);
14219: desret_const_xmlParserNodeInfo_ptr(ret_val);
14220: call_tests++;
14221: des_const_xmlParserCtxtPtr(n_ctx, (const xmlParserCtxtPtr)ctx, 0);
14222: des_const_xmlNodePtr(n_node, (const xmlNodePtr)node, 1);
14223: xmlResetLastError();
14224: if (mem_base != xmlMemBlocks()) {
14225: printf("Leak of %d blocks found in xmlParserFindNodeInfo",
14226: xmlMemBlocks() - mem_base);
14227: test_ret++;
14228: printf(" %d", n_ctx);
14229: printf(" %d", n_node);
14230: printf("\n");
14231: }
14232: }
14233: }
14234: function_tests++;
14235:
14236: return(test_ret);
14237: }
14238:
14239:
14240: #define gen_nb_const_xmlParserNodeInfoSeqPtr 1
14241: static xmlParserNodeInfoSeqPtr gen_const_xmlParserNodeInfoSeqPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14242: return(NULL);
14243: }
14244: static void des_const_xmlParserNodeInfoSeqPtr(int no ATTRIBUTE_UNUSED, const xmlParserNodeInfoSeqPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14245: }
14246:
14247: static int
14248: test_xmlParserFindNodeInfoIndex(void) {
14249: int test_ret = 0;
14250:
14251: int mem_base;
14252: unsigned long ret_val;
14253: xmlParserNodeInfoSeqPtr seq; /* a node info sequence pointer */
14254: int n_seq;
14255: xmlNodePtr node; /* an XML node pointer */
14256: int n_node;
14257:
14258: for (n_seq = 0;n_seq < gen_nb_const_xmlParserNodeInfoSeqPtr;n_seq++) {
14259: for (n_node = 0;n_node < gen_nb_const_xmlNodePtr;n_node++) {
14260: mem_base = xmlMemBlocks();
14261: seq = gen_const_xmlParserNodeInfoSeqPtr(n_seq, 0);
14262: node = gen_const_xmlNodePtr(n_node, 1);
14263:
14264: ret_val = xmlParserFindNodeInfoIndex((const xmlParserNodeInfoSeqPtr)seq, (const xmlNodePtr)node);
14265: desret_unsigned_long(ret_val);
14266: call_tests++;
14267: des_const_xmlParserNodeInfoSeqPtr(n_seq, (const xmlParserNodeInfoSeqPtr)seq, 0);
14268: des_const_xmlNodePtr(n_node, (const xmlNodePtr)node, 1);
14269: xmlResetLastError();
14270: if (mem_base != xmlMemBlocks()) {
14271: printf("Leak of %d blocks found in xmlParserFindNodeInfoIndex",
14272: xmlMemBlocks() - mem_base);
14273: test_ret++;
14274: printf(" %d", n_seq);
14275: printf(" %d", n_node);
14276: printf("\n");
14277: }
14278: }
14279: }
14280: function_tests++;
14281:
14282: return(test_ret);
14283: }
14284:
14285:
14286: #define gen_nb_xmlParserInputPtr 1
14287: static xmlParserInputPtr gen_xmlParserInputPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14288: return(NULL);
14289: }
14290: static void des_xmlParserInputPtr(int no ATTRIBUTE_UNUSED, xmlParserInputPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14291: }
14292:
14293: static int
14294: test_xmlParserInputGrow(void) {
14295: int test_ret = 0;
14296:
14297: int mem_base;
14298: int ret_val;
14299: xmlParserInputPtr in; /* an XML parser input */
14300: int n_in;
14301: int len; /* an indicative size for the lookahead */
14302: int n_len;
14303:
14304: for (n_in = 0;n_in < gen_nb_xmlParserInputPtr;n_in++) {
14305: for (n_len = 0;n_len < gen_nb_int;n_len++) {
14306: mem_base = xmlMemBlocks();
14307: in = gen_xmlParserInputPtr(n_in, 0);
14308: len = gen_int(n_len, 1);
14309:
14310: ret_val = xmlParserInputGrow(in, len);
14311: desret_int(ret_val);
14312: call_tests++;
14313: des_xmlParserInputPtr(n_in, in, 0);
14314: des_int(n_len, len, 1);
14315: xmlResetLastError();
14316: if (mem_base != xmlMemBlocks()) {
14317: printf("Leak of %d blocks found in xmlParserInputGrow",
14318: xmlMemBlocks() - mem_base);
14319: test_ret++;
14320: printf(" %d", n_in);
14321: printf(" %d", n_len);
14322: printf("\n");
14323: }
14324: }
14325: }
14326: function_tests++;
14327:
14328: return(test_ret);
14329: }
14330:
14331:
14332: static int
14333: test_xmlParserInputRead(void) {
14334: int test_ret = 0;
14335:
14336: int mem_base;
14337: int ret_val;
14338: xmlParserInputPtr in; /* an XML parser input */
14339: int n_in;
14340: int len; /* an indicative size for the lookahead */
14341: int n_len;
14342:
14343: for (n_in = 0;n_in < gen_nb_xmlParserInputPtr;n_in++) {
14344: for (n_len = 0;n_len < gen_nb_int;n_len++) {
14345: mem_base = xmlMemBlocks();
14346: in = gen_xmlParserInputPtr(n_in, 0);
14347: len = gen_int(n_len, 1);
14348:
14349: ret_val = xmlParserInputRead(in, len);
14350: desret_int(ret_val);
14351: call_tests++;
14352: des_xmlParserInputPtr(n_in, in, 0);
14353: des_int(n_len, len, 1);
14354: xmlResetLastError();
14355: if (mem_base != xmlMemBlocks()) {
14356: printf("Leak of %d blocks found in xmlParserInputRead",
14357: xmlMemBlocks() - mem_base);
14358: test_ret++;
14359: printf(" %d", n_in);
14360: printf(" %d", n_len);
14361: printf("\n");
14362: }
14363: }
14364: }
14365: function_tests++;
14366:
14367: return(test_ret);
14368: }
14369:
14370:
14371: static int
14372: test_xmlPedanticParserDefault(void) {
14373: int test_ret = 0;
14374:
14375: int mem_base;
14376: int ret_val;
14377: int val; /* int 0 or 1 */
14378: int n_val;
14379:
14380: for (n_val = 0;n_val < gen_nb_int;n_val++) {
14381: mem_base = xmlMemBlocks();
14382: val = gen_int(n_val, 0);
14383:
14384: ret_val = xmlPedanticParserDefault(val);
14385: desret_int(ret_val);
14386: call_tests++;
14387: des_int(n_val, val, 0);
14388: xmlResetLastError();
14389: if (mem_base != xmlMemBlocks()) {
14390: printf("Leak of %d blocks found in xmlPedanticParserDefault",
14391: xmlMemBlocks() - mem_base);
14392: test_ret++;
14393: printf(" %d", n_val);
14394: printf("\n");
14395: }
14396: }
14397: function_tests++;
14398:
14399: return(test_ret);
14400: }
14401:
14402:
14403: static int
14404: test_xmlReadDoc(void) {
14405: int test_ret = 0;
14406:
14407: int mem_base;
14408: xmlDocPtr ret_val;
14409: xmlChar * cur; /* a pointer to a zero terminated string */
14410: int n_cur;
14411: const char * URL; /* the base URL to use for the document */
14412: int n_URL;
14413: char * encoding; /* the document encoding, or NULL */
14414: int n_encoding;
14415: int options; /* a combination of xmlParserOption */
14416: int n_options;
14417:
14418: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
14419: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
14420: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
14421: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
14422: mem_base = xmlMemBlocks();
14423: cur = gen_const_xmlChar_ptr(n_cur, 0);
14424: URL = gen_filepath(n_URL, 1);
14425: encoding = gen_const_char_ptr(n_encoding, 2);
14426: options = gen_parseroptions(n_options, 3);
14427:
14428: ret_val = xmlReadDoc((const xmlChar *)cur, URL, (const char *)encoding, options);
14429: desret_xmlDocPtr(ret_val);
14430: call_tests++;
14431: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
14432: des_filepath(n_URL, URL, 1);
14433: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
14434: des_parseroptions(n_options, options, 3);
14435: xmlResetLastError();
14436: if (mem_base != xmlMemBlocks()) {
14437: printf("Leak of %d blocks found in xmlReadDoc",
14438: xmlMemBlocks() - mem_base);
14439: test_ret++;
14440: printf(" %d", n_cur);
14441: printf(" %d", n_URL);
14442: printf(" %d", n_encoding);
14443: printf(" %d", n_options);
14444: printf("\n");
14445: }
14446: }
14447: }
14448: }
14449: }
14450: function_tests++;
14451:
14452: return(test_ret);
14453: }
14454:
14455:
14456: static int
14457: test_xmlReadFile(void) {
14458: int test_ret = 0;
14459:
14460: int mem_base;
14461: xmlDocPtr ret_val;
14462: const char * filename; /* a file or URL */
14463: int n_filename;
14464: char * encoding; /* the document encoding, or NULL */
14465: int n_encoding;
14466: int options; /* a combination of xmlParserOption */
14467: int n_options;
14468:
14469: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
14470: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
14471: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
14472: mem_base = xmlMemBlocks();
14473: filename = gen_filepath(n_filename, 0);
14474: encoding = gen_const_char_ptr(n_encoding, 1);
14475: options = gen_parseroptions(n_options, 2);
14476:
14477: ret_val = xmlReadFile(filename, (const char *)encoding, options);
14478: desret_xmlDocPtr(ret_val);
14479: call_tests++;
14480: des_filepath(n_filename, filename, 0);
14481: des_const_char_ptr(n_encoding, (const char *)encoding, 1);
14482: des_parseroptions(n_options, options, 2);
14483: xmlResetLastError();
14484: if (mem_base != xmlMemBlocks()) {
14485: printf("Leak of %d blocks found in xmlReadFile",
14486: xmlMemBlocks() - mem_base);
14487: test_ret++;
14488: printf(" %d", n_filename);
14489: printf(" %d", n_encoding);
14490: printf(" %d", n_options);
14491: printf("\n");
14492: }
14493: }
14494: }
14495: }
14496: function_tests++;
14497:
14498: return(test_ret);
14499: }
14500:
14501:
14502: static int
14503: test_xmlReadMemory(void) {
14504: int test_ret = 0;
14505:
14506: int mem_base;
14507: xmlDocPtr ret_val;
14508: char * buffer; /* a pointer to a char array */
14509: int n_buffer;
14510: int size; /* the size of the array */
14511: int n_size;
14512: const char * URL; /* the base URL to use for the document */
14513: int n_URL;
14514: char * encoding; /* the document encoding, or NULL */
14515: int n_encoding;
14516: int options; /* a combination of xmlParserOption */
14517: int n_options;
14518:
14519: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
14520: for (n_size = 0;n_size < gen_nb_int;n_size++) {
14521: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
14522: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
14523: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
14524: mem_base = xmlMemBlocks();
14525: buffer = gen_const_char_ptr(n_buffer, 0);
14526: size = gen_int(n_size, 1);
14527: URL = gen_filepath(n_URL, 2);
14528: encoding = gen_const_char_ptr(n_encoding, 3);
14529: options = gen_parseroptions(n_options, 4);
14530:
14531: ret_val = xmlReadMemory((const char *)buffer, size, URL, (const char *)encoding, options);
14532: desret_xmlDocPtr(ret_val);
14533: call_tests++;
14534: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
14535: des_int(n_size, size, 1);
14536: des_filepath(n_URL, URL, 2);
14537: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
14538: des_parseroptions(n_options, options, 4);
14539: xmlResetLastError();
14540: if (mem_base != xmlMemBlocks()) {
14541: printf("Leak of %d blocks found in xmlReadMemory",
14542: xmlMemBlocks() - mem_base);
14543: test_ret++;
14544: printf(" %d", n_buffer);
14545: printf(" %d", n_size);
14546: printf(" %d", n_URL);
14547: printf(" %d", n_encoding);
14548: printf(" %d", n_options);
14549: printf("\n");
14550: }
14551: }
14552: }
14553: }
14554: }
14555: }
14556: function_tests++;
14557:
14558: return(test_ret);
14559: }
14560:
14561:
14562: static int
14563: test_xmlRecoverDoc(void) {
14564: int test_ret = 0;
14565:
14566: #if defined(LIBXML_SAX1_ENABLED)
14567: #ifdef LIBXML_SAX1_ENABLED
14568: int mem_base;
14569: xmlDocPtr ret_val;
14570: xmlChar * cur; /* a pointer to an array of xmlChar */
14571: int n_cur;
14572:
14573: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
14574: mem_base = xmlMemBlocks();
14575: cur = gen_const_xmlChar_ptr(n_cur, 0);
14576:
14577: ret_val = xmlRecoverDoc((const xmlChar *)cur);
14578: desret_xmlDocPtr(ret_val);
14579: call_tests++;
14580: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
14581: xmlResetLastError();
14582: if (mem_base != xmlMemBlocks()) {
14583: printf("Leak of %d blocks found in xmlRecoverDoc",
14584: xmlMemBlocks() - mem_base);
14585: test_ret++;
14586: printf(" %d", n_cur);
14587: printf("\n");
14588: }
14589: }
14590: function_tests++;
14591: #endif
14592: #endif
14593:
14594: return(test_ret);
14595: }
14596:
14597:
14598: static int
14599: test_xmlRecoverFile(void) {
14600: int test_ret = 0;
14601:
14602: #if defined(LIBXML_SAX1_ENABLED)
14603: #ifdef LIBXML_SAX1_ENABLED
14604: int mem_base;
14605: xmlDocPtr ret_val;
14606: const char * filename; /* the filename */
14607: int n_filename;
14608:
14609: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
14610: mem_base = xmlMemBlocks();
14611: filename = gen_filepath(n_filename, 0);
14612:
14613: ret_val = xmlRecoverFile(filename);
14614: desret_xmlDocPtr(ret_val);
14615: call_tests++;
14616: des_filepath(n_filename, filename, 0);
14617: xmlResetLastError();
14618: if (mem_base != xmlMemBlocks()) {
14619: printf("Leak of %d blocks found in xmlRecoverFile",
14620: xmlMemBlocks() - mem_base);
14621: test_ret++;
14622: printf(" %d", n_filename);
14623: printf("\n");
14624: }
14625: }
14626: function_tests++;
14627: #endif
14628: #endif
14629:
14630: return(test_ret);
14631: }
14632:
14633:
14634: static int
14635: test_xmlRecoverMemory(void) {
14636: int test_ret = 0;
14637:
14638: #if defined(LIBXML_SAX1_ENABLED)
14639: #ifdef LIBXML_SAX1_ENABLED
14640: int mem_base;
14641: xmlDocPtr ret_val;
14642: char * buffer; /* an pointer to a char array */
14643: int n_buffer;
14644: int size; /* the size of the array */
14645: int n_size;
14646:
14647: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
14648: for (n_size = 0;n_size < gen_nb_int;n_size++) {
14649: mem_base = xmlMemBlocks();
14650: buffer = gen_const_char_ptr(n_buffer, 0);
14651: size = gen_int(n_size, 1);
14652:
14653: ret_val = xmlRecoverMemory((const char *)buffer, size);
14654: desret_xmlDocPtr(ret_val);
14655: call_tests++;
14656: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
14657: des_int(n_size, size, 1);
14658: xmlResetLastError();
14659: if (mem_base != xmlMemBlocks()) {
14660: printf("Leak of %d blocks found in xmlRecoverMemory",
14661: xmlMemBlocks() - mem_base);
14662: test_ret++;
14663: printf(" %d", n_buffer);
14664: printf(" %d", n_size);
14665: printf("\n");
14666: }
14667: }
14668: }
14669: function_tests++;
14670: #endif
14671: #endif
14672:
14673: return(test_ret);
14674: }
14675:
14676:
14677: static int
14678: test_xmlSAXParseDTD(void) {
14679: int test_ret = 0;
14680:
14681: #if defined(LIBXML_VALID_ENABLED)
14682: #ifdef LIBXML_SAX1_ENABLED
14683: int mem_base;
14684: xmlDtdPtr ret_val;
14685: xmlSAXHandlerPtr sax; /* the SAX handler block */
14686: int n_sax;
14687: xmlChar * ExternalID; /* a NAME* containing the External ID of the DTD */
14688: int n_ExternalID;
14689: xmlChar * SystemID; /* a NAME* containing the URL to the DTD */
14690: int n_SystemID;
14691:
14692: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
14693: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
14694: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
14695: mem_base = xmlMemBlocks();
14696: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
14697: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 1);
14698: SystemID = gen_const_xmlChar_ptr(n_SystemID, 2);
14699:
14700: ret_val = xmlSAXParseDTD(sax, (const xmlChar *)ExternalID, (const xmlChar *)SystemID);
14701: desret_xmlDtdPtr(ret_val);
14702: call_tests++;
14703: des_xmlSAXHandlerPtr(n_sax, sax, 0);
14704: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 1);
14705: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 2);
14706: xmlResetLastError();
14707: if (mem_base != xmlMemBlocks()) {
14708: printf("Leak of %d blocks found in xmlSAXParseDTD",
14709: xmlMemBlocks() - mem_base);
14710: test_ret++;
14711: printf(" %d", n_sax);
14712: printf(" %d", n_ExternalID);
14713: printf(" %d", n_SystemID);
14714: printf("\n");
14715: }
14716: }
14717: }
14718: }
14719: function_tests++;
14720: #endif
14721: #endif
14722:
14723: return(test_ret);
14724: }
14725:
14726:
14727: static int
14728: test_xmlSAXParseDoc(void) {
14729: int test_ret = 0;
14730:
14731: #if defined(LIBXML_SAX1_ENABLED)
14732: #ifdef LIBXML_SAX1_ENABLED
14733: int mem_base;
14734: xmlDocPtr ret_val;
14735: xmlSAXHandlerPtr sax; /* the SAX handler block */
14736: int n_sax;
14737: xmlChar * cur; /* a pointer to an array of xmlChar */
14738: int n_cur;
14739: int recovery; /* work in recovery mode, i.e. tries to read no Well Formed documents */
14740: int n_recovery;
14741:
14742: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
14743: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
14744: for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) {
14745: mem_base = xmlMemBlocks();
14746: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
14747: cur = gen_const_xmlChar_ptr(n_cur, 1);
14748: recovery = gen_int(n_recovery, 2);
14749:
14750: ret_val = xmlSAXParseDoc(sax, (const xmlChar *)cur, recovery);
14751: desret_xmlDocPtr(ret_val);
14752: call_tests++;
14753: des_xmlSAXHandlerPtr(n_sax, sax, 0);
14754: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 1);
14755: des_int(n_recovery, recovery, 2);
14756: xmlResetLastError();
14757: if (mem_base != xmlMemBlocks()) {
14758: printf("Leak of %d blocks found in xmlSAXParseDoc",
14759: xmlMemBlocks() - mem_base);
14760: test_ret++;
14761: printf(" %d", n_sax);
14762: printf(" %d", n_cur);
14763: printf(" %d", n_recovery);
14764: printf("\n");
14765: }
14766: }
14767: }
14768: }
14769: function_tests++;
14770: #endif
14771: #endif
14772:
14773: return(test_ret);
14774: }
14775:
14776:
14777: static int
14778: test_xmlSAXParseEntity(void) {
14779: int test_ret = 0;
14780:
14781: #if defined(LIBXML_SAX1_ENABLED)
14782: #ifdef LIBXML_SAX1_ENABLED
14783: int mem_base;
14784: xmlDocPtr ret_val;
14785: xmlSAXHandlerPtr sax; /* the SAX handler block */
14786: int n_sax;
14787: const char * filename; /* the filename */
14788: int n_filename;
14789:
14790: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
14791: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
14792: mem_base = xmlMemBlocks();
14793: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
14794: filename = gen_filepath(n_filename, 1);
14795:
14796: ret_val = xmlSAXParseEntity(sax, filename);
14797: desret_xmlDocPtr(ret_val);
14798: call_tests++;
14799: des_xmlSAXHandlerPtr(n_sax, sax, 0);
14800: des_filepath(n_filename, filename, 1);
14801: xmlResetLastError();
14802: if (mem_base != xmlMemBlocks()) {
14803: printf("Leak of %d blocks found in xmlSAXParseEntity",
14804: xmlMemBlocks() - mem_base);
14805: test_ret++;
14806: printf(" %d", n_sax);
14807: printf(" %d", n_filename);
14808: printf("\n");
14809: }
14810: }
14811: }
14812: function_tests++;
14813: #endif
14814: #endif
14815:
14816: return(test_ret);
14817: }
14818:
14819:
14820: static int
14821: test_xmlSAXParseFile(void) {
14822: int test_ret = 0;
14823:
14824: #if defined(LIBXML_SAX1_ENABLED)
14825: #ifdef LIBXML_SAX1_ENABLED
14826: int mem_base;
14827: xmlDocPtr ret_val;
14828: xmlSAXHandlerPtr sax; /* the SAX handler block */
14829: int n_sax;
14830: const char * filename; /* the filename */
14831: int n_filename;
14832: int recovery; /* work in recovery mode, i.e. tries to read no Well Formed documents */
14833: int n_recovery;
14834:
14835: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
14836: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
14837: for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) {
14838: mem_base = xmlMemBlocks();
14839: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
14840: filename = gen_filepath(n_filename, 1);
14841: recovery = gen_int(n_recovery, 2);
14842:
14843: ret_val = xmlSAXParseFile(sax, filename, recovery);
14844: desret_xmlDocPtr(ret_val);
14845: call_tests++;
14846: des_xmlSAXHandlerPtr(n_sax, sax, 0);
14847: des_filepath(n_filename, filename, 1);
14848: des_int(n_recovery, recovery, 2);
14849: xmlResetLastError();
14850: if (mem_base != xmlMemBlocks()) {
14851: printf("Leak of %d blocks found in xmlSAXParseFile",
14852: xmlMemBlocks() - mem_base);
14853: test_ret++;
14854: printf(" %d", n_sax);
14855: printf(" %d", n_filename);
14856: printf(" %d", n_recovery);
14857: printf("\n");
14858: }
14859: }
14860: }
14861: }
14862: function_tests++;
14863: #endif
14864: #endif
14865:
14866: return(test_ret);
14867: }
14868:
14869:
14870: static int
14871: test_xmlSAXParseFileWithData(void) {
14872: int test_ret = 0;
14873:
14874: #if defined(LIBXML_SAX1_ENABLED)
14875: #ifdef LIBXML_SAX1_ENABLED
14876: int mem_base;
14877: xmlDocPtr ret_val;
14878: xmlSAXHandlerPtr sax; /* the SAX handler block */
14879: int n_sax;
14880: const char * filename; /* the filename */
14881: int n_filename;
14882: int recovery; /* work in recovery mode, i.e. tries to read no Well Formed documents */
14883: int n_recovery;
14884: void * data; /* the userdata */
14885: int n_data;
14886:
14887: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
14888: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
14889: for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) {
14890: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
14891: mem_base = xmlMemBlocks();
14892: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
14893: filename = gen_filepath(n_filename, 1);
14894: recovery = gen_int(n_recovery, 2);
14895: data = gen_userdata(n_data, 3);
14896:
14897: ret_val = xmlSAXParseFileWithData(sax, filename, recovery, data);
14898: desret_xmlDocPtr(ret_val);
14899: call_tests++;
14900: des_xmlSAXHandlerPtr(n_sax, sax, 0);
14901: des_filepath(n_filename, filename, 1);
14902: des_int(n_recovery, recovery, 2);
14903: des_userdata(n_data, data, 3);
14904: xmlResetLastError();
14905: if (mem_base != xmlMemBlocks()) {
14906: printf("Leak of %d blocks found in xmlSAXParseFileWithData",
14907: xmlMemBlocks() - mem_base);
14908: test_ret++;
14909: printf(" %d", n_sax);
14910: printf(" %d", n_filename);
14911: printf(" %d", n_recovery);
14912: printf(" %d", n_data);
14913: printf("\n");
14914: }
14915: }
14916: }
14917: }
14918: }
14919: function_tests++;
14920: #endif
14921: #endif
14922:
14923: return(test_ret);
14924: }
14925:
14926:
14927: static int
14928: test_xmlSAXParseMemory(void) {
14929: int test_ret = 0;
14930:
14931: #if defined(LIBXML_SAX1_ENABLED)
14932: #ifdef LIBXML_SAX1_ENABLED
14933: int mem_base;
14934: xmlDocPtr ret_val;
14935: xmlSAXHandlerPtr sax; /* the SAX handler block */
14936: int n_sax;
14937: char * buffer; /* an pointer to a char array */
14938: int n_buffer;
14939: int size; /* the size of the array */
14940: int n_size;
14941: int recovery; /* work in recovery mode, i.e. tries to read not Well Formed documents */
14942: int n_recovery;
14943:
14944: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
14945: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
14946: for (n_size = 0;n_size < gen_nb_int;n_size++) {
14947: for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) {
14948: mem_base = xmlMemBlocks();
14949: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
14950: buffer = gen_const_char_ptr(n_buffer, 1);
14951: size = gen_int(n_size, 2);
14952: recovery = gen_int(n_recovery, 3);
14953:
14954: ret_val = xmlSAXParseMemory(sax, (const char *)buffer, size, recovery);
14955: desret_xmlDocPtr(ret_val);
14956: call_tests++;
14957: des_xmlSAXHandlerPtr(n_sax, sax, 0);
14958: des_const_char_ptr(n_buffer, (const char *)buffer, 1);
14959: des_int(n_size, size, 2);
14960: des_int(n_recovery, recovery, 3);
14961: xmlResetLastError();
14962: if (mem_base != xmlMemBlocks()) {
14963: printf("Leak of %d blocks found in xmlSAXParseMemory",
14964: xmlMemBlocks() - mem_base);
14965: test_ret++;
14966: printf(" %d", n_sax);
14967: printf(" %d", n_buffer);
14968: printf(" %d", n_size);
14969: printf(" %d", n_recovery);
14970: printf("\n");
14971: }
14972: }
14973: }
14974: }
14975: }
14976: function_tests++;
14977: #endif
14978: #endif
14979:
14980: return(test_ret);
14981: }
14982:
14983:
14984: static int
14985: test_xmlSAXParseMemoryWithData(void) {
14986: int test_ret = 0;
14987:
14988: #if defined(LIBXML_SAX1_ENABLED)
14989: #ifdef LIBXML_SAX1_ENABLED
14990: int mem_base;
14991: xmlDocPtr ret_val;
14992: xmlSAXHandlerPtr sax; /* the SAX handler block */
14993: int n_sax;
14994: char * buffer; /* an pointer to a char array */
14995: int n_buffer;
14996: int size; /* the size of the array */
14997: int n_size;
14998: int recovery; /* work in recovery mode, i.e. tries to read no Well Formed documents */
14999: int n_recovery;
15000: void * data; /* the userdata */
15001: int n_data;
15002:
15003: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
15004: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
15005: for (n_size = 0;n_size < gen_nb_int;n_size++) {
15006: for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) {
15007: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
15008: mem_base = xmlMemBlocks();
15009: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
15010: buffer = gen_const_char_ptr(n_buffer, 1);
15011: size = gen_int(n_size, 2);
15012: recovery = gen_int(n_recovery, 3);
15013: data = gen_userdata(n_data, 4);
15014:
15015: ret_val = xmlSAXParseMemoryWithData(sax, (const char *)buffer, size, recovery, data);
15016: desret_xmlDocPtr(ret_val);
15017: call_tests++;
15018: des_xmlSAXHandlerPtr(n_sax, sax, 0);
15019: des_const_char_ptr(n_buffer, (const char *)buffer, 1);
15020: des_int(n_size, size, 2);
15021: des_int(n_recovery, recovery, 3);
15022: des_userdata(n_data, data, 4);
15023: xmlResetLastError();
15024: if (mem_base != xmlMemBlocks()) {
15025: printf("Leak of %d blocks found in xmlSAXParseMemoryWithData",
15026: xmlMemBlocks() - mem_base);
15027: test_ret++;
15028: printf(" %d", n_sax);
15029: printf(" %d", n_buffer);
15030: printf(" %d", n_size);
15031: printf(" %d", n_recovery);
15032: printf(" %d", n_data);
15033: printf("\n");
15034: }
15035: }
15036: }
15037: }
15038: }
15039: }
15040: function_tests++;
15041: #endif
15042: #endif
15043:
15044: return(test_ret);
15045: }
15046:
15047:
15048: static int
15049: test_xmlSAXUserParseFile(void) {
15050: int test_ret = 0;
15051:
15052: #if defined(LIBXML_SAX1_ENABLED)
15053: #ifdef LIBXML_SAX1_ENABLED
15054: int mem_base;
15055: int ret_val;
15056: xmlSAXHandlerPtr sax; /* a SAX handler */
15057: int n_sax;
15058: void * user_data; /* The user data returned on SAX callbacks */
15059: int n_user_data;
15060: const char * filename; /* a file name */
15061: int n_filename;
15062:
15063: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
15064: for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
15065: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
15066: mem_base = xmlMemBlocks();
15067: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
15068: user_data = gen_userdata(n_user_data, 1);
15069: filename = gen_filepath(n_filename, 2);
15070:
15071: #ifdef LIBXML_SAX1_ENABLED
15072: if (sax == (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) user_data = NULL;
15073: #endif
15074:
15075:
15076: ret_val = xmlSAXUserParseFile(sax, user_data, filename);
15077: desret_int(ret_val);
15078: call_tests++;
15079: des_xmlSAXHandlerPtr(n_sax, sax, 0);
15080: des_userdata(n_user_data, user_data, 1);
15081: des_filepath(n_filename, filename, 2);
15082: xmlResetLastError();
15083: if (mem_base != xmlMemBlocks()) {
15084: printf("Leak of %d blocks found in xmlSAXUserParseFile",
15085: xmlMemBlocks() - mem_base);
15086: test_ret++;
15087: printf(" %d", n_sax);
15088: printf(" %d", n_user_data);
15089: printf(" %d", n_filename);
15090: printf("\n");
15091: }
15092: }
15093: }
15094: }
15095: function_tests++;
15096: #endif
15097: #endif
15098:
15099: return(test_ret);
15100: }
15101:
15102:
15103: static int
15104: test_xmlSAXUserParseMemory(void) {
15105: int test_ret = 0;
15106:
15107: #if defined(LIBXML_SAX1_ENABLED)
15108: #ifdef LIBXML_SAX1_ENABLED
15109: int mem_base;
15110: int ret_val;
15111: xmlSAXHandlerPtr sax; /* a SAX handler */
15112: int n_sax;
15113: void * user_data; /* The user data returned on SAX callbacks */
15114: int n_user_data;
15115: char * buffer; /* an in-memory XML document input */
15116: int n_buffer;
15117: int size; /* the length of the XML document in bytes */
15118: int n_size;
15119:
15120: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
15121: for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
15122: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
15123: for (n_size = 0;n_size < gen_nb_int;n_size++) {
15124: mem_base = xmlMemBlocks();
15125: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
15126: user_data = gen_userdata(n_user_data, 1);
15127: buffer = gen_const_char_ptr(n_buffer, 2);
15128: size = gen_int(n_size, 3);
15129:
15130: #ifdef LIBXML_SAX1_ENABLED
15131: if (sax == (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) user_data = NULL;
15132: #endif
15133:
15134:
15135: ret_val = xmlSAXUserParseMemory(sax, user_data, (const char *)buffer, size);
15136: desret_int(ret_val);
15137: call_tests++;
15138: des_xmlSAXHandlerPtr(n_sax, sax, 0);
15139: des_userdata(n_user_data, user_data, 1);
15140: des_const_char_ptr(n_buffer, (const char *)buffer, 2);
15141: des_int(n_size, size, 3);
15142: xmlResetLastError();
15143: if (mem_base != xmlMemBlocks()) {
15144: printf("Leak of %d blocks found in xmlSAXUserParseMemory",
15145: xmlMemBlocks() - mem_base);
15146: test_ret++;
15147: printf(" %d", n_sax);
15148: printf(" %d", n_user_data);
15149: printf(" %d", n_buffer);
15150: printf(" %d", n_size);
15151: printf("\n");
15152: }
15153: }
15154: }
15155: }
15156: }
15157: function_tests++;
15158: #endif
15159: #endif
15160:
15161: return(test_ret);
15162: }
15163:
15164:
15165: static int
15166: test_xmlSetExternalEntityLoader(void) {
15167: int test_ret = 0;
15168:
15169:
15170: /* missing type support */
15171: return(test_ret);
15172: }
15173:
15174:
15175: static int
15176: test_xmlSetFeature(void) {
15177: int test_ret = 0;
15178:
15179: #if defined(LIBXML_LEGACY_ENABLED)
15180: #ifdef LIBXML_LEGACY_ENABLED
15181: int mem_base;
15182: int ret_val;
15183: xmlParserCtxtPtr ctxt; /* an XML/HTML parser context */
15184: int n_ctxt;
15185: char * name; /* the feature name */
15186: int n_name;
15187: void * value; /* pointer to the location of the new value */
15188: int n_value;
15189:
15190: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15191: for (n_name = 0;n_name < gen_nb_const_char_ptr;n_name++) {
15192: for (n_value = 0;n_value < gen_nb_void_ptr;n_value++) {
15193: mem_base = xmlMemBlocks();
15194: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15195: name = gen_const_char_ptr(n_name, 1);
15196: value = gen_void_ptr(n_value, 2);
15197:
15198: ret_val = xmlSetFeature(ctxt, (const char *)name, value);
15199: desret_int(ret_val);
15200: call_tests++;
15201: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15202: des_const_char_ptr(n_name, (const char *)name, 1);
15203: des_void_ptr(n_value, value, 2);
15204: xmlResetLastError();
15205: if (mem_base != xmlMemBlocks()) {
15206: printf("Leak of %d blocks found in xmlSetFeature",
15207: xmlMemBlocks() - mem_base);
15208: test_ret++;
15209: printf(" %d", n_ctxt);
15210: printf(" %d", n_name);
15211: printf(" %d", n_value);
15212: printf("\n");
15213: }
15214: }
15215: }
15216: }
15217: function_tests++;
15218: #endif
15219: #endif
15220:
15221: return(test_ret);
15222: }
15223:
15224:
15225: static int
15226: test_xmlSetupParserForBuffer(void) {
15227: int test_ret = 0;
15228:
15229: #if defined(LIBXML_SAX1_ENABLED)
15230: #ifdef LIBXML_SAX1_ENABLED
15231: int mem_base;
15232: xmlParserCtxtPtr ctxt; /* an XML parser context */
15233: int n_ctxt;
15234: xmlChar * buffer; /* a xmlChar * buffer */
15235: int n_buffer;
15236: const char * filename; /* a file name */
15237: int n_filename;
15238:
15239: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15240: for (n_buffer = 0;n_buffer < gen_nb_const_xmlChar_ptr;n_buffer++) {
15241: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
15242: mem_base = xmlMemBlocks();
15243: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15244: buffer = gen_const_xmlChar_ptr(n_buffer, 1);
15245: filename = gen_filepath(n_filename, 2);
15246:
15247: xmlSetupParserForBuffer(ctxt, (const xmlChar *)buffer, filename);
15248: call_tests++;
15249: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15250: des_const_xmlChar_ptr(n_buffer, (const xmlChar *)buffer, 1);
15251: des_filepath(n_filename, filename, 2);
15252: xmlResetLastError();
15253: if (mem_base != xmlMemBlocks()) {
15254: printf("Leak of %d blocks found in xmlSetupParserForBuffer",
15255: xmlMemBlocks() - mem_base);
15256: test_ret++;
15257: printf(" %d", n_ctxt);
15258: printf(" %d", n_buffer);
15259: printf(" %d", n_filename);
15260: printf("\n");
15261: }
15262: }
15263: }
15264: }
15265: function_tests++;
15266: #endif
15267: #endif
15268:
15269: return(test_ret);
15270: }
15271:
15272:
15273: static int
15274: test_xmlStopParser(void) {
15275: int test_ret = 0;
15276:
15277: #ifdef LIBXML_PUSH_ENABLED
15278: int mem_base;
15279: xmlParserCtxtPtr ctxt; /* an XML parser context */
15280: int n_ctxt;
15281:
15282: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15283: mem_base = xmlMemBlocks();
15284: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15285:
15286: xmlStopParser(ctxt);
15287: call_tests++;
15288: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15289: xmlResetLastError();
15290: if (mem_base != xmlMemBlocks()) {
15291: printf("Leak of %d blocks found in xmlStopParser",
15292: xmlMemBlocks() - mem_base);
15293: test_ret++;
15294: printf(" %d", n_ctxt);
15295: printf("\n");
15296: }
15297: }
15298: function_tests++;
15299: #endif
15300:
15301: return(test_ret);
15302: }
15303:
15304:
15305: static int
15306: test_xmlSubstituteEntitiesDefault(void) {
15307: int test_ret = 0;
15308:
15309: int mem_base;
15310: int ret_val;
15311: int val; /* int 0 or 1 */
15312: int n_val;
15313:
15314: for (n_val = 0;n_val < gen_nb_int;n_val++) {
15315: mem_base = xmlMemBlocks();
15316: val = gen_int(n_val, 0);
15317:
15318: ret_val = xmlSubstituteEntitiesDefault(val);
15319: desret_int(ret_val);
15320: call_tests++;
15321: des_int(n_val, val, 0);
15322: xmlResetLastError();
15323: if (mem_base != xmlMemBlocks()) {
15324: printf("Leak of %d blocks found in xmlSubstituteEntitiesDefault",
15325: xmlMemBlocks() - mem_base);
15326: test_ret++;
15327: printf(" %d", n_val);
15328: printf("\n");
15329: }
15330: }
15331: function_tests++;
15332:
15333: return(test_ret);
15334: }
15335:
15336: static int
15337: test_parser(void) {
15338: int test_ret = 0;
15339:
15340: if (quiet == 0) printf("Testing parser : 61 of 70 functions ...\n");
15341: test_ret += test_xmlByteConsumed();
15342: test_ret += test_xmlClearNodeInfoSeq();
15343: test_ret += test_xmlClearParserCtxt();
15344: test_ret += test_xmlCreateDocParserCtxt();
15345: test_ret += test_xmlCreatePushParserCtxt();
15346: test_ret += test_xmlCtxtReadDoc();
15347: test_ret += test_xmlCtxtReadFile();
15348: test_ret += test_xmlCtxtReadMemory();
15349: test_ret += test_xmlCtxtReset();
15350: test_ret += test_xmlCtxtResetPush();
15351: test_ret += test_xmlCtxtUseOptions();
15352: test_ret += test_xmlGetExternalEntityLoader();
15353: test_ret += test_xmlGetFeature();
15354: test_ret += test_xmlGetFeaturesList();
15355: test_ret += test_xmlHasFeature();
15356: test_ret += test_xmlIOParseDTD();
15357: test_ret += test_xmlInitNodeInfoSeq();
15358: test_ret += test_xmlInitParser();
15359: test_ret += test_xmlInitParserCtxt();
15360: test_ret += test_xmlKeepBlanksDefault();
15361: test_ret += test_xmlLineNumbersDefault();
15362: test_ret += test_xmlLoadExternalEntity();
15363: test_ret += test_xmlNewIOInputStream();
15364: test_ret += test_xmlNewParserCtxt();
15365: test_ret += test_xmlParseBalancedChunkMemory();
15366: test_ret += test_xmlParseBalancedChunkMemoryRecover();
15367: test_ret += test_xmlParseChunk();
15368: test_ret += test_xmlParseCtxtExternalEntity();
15369: test_ret += test_xmlParseDTD();
15370: test_ret += test_xmlParseDoc();
15371: test_ret += test_xmlParseDocument();
15372: test_ret += test_xmlParseEntity();
15373: test_ret += test_xmlParseExtParsedEnt();
15374: test_ret += test_xmlParseExternalEntity();
15375: test_ret += test_xmlParseFile();
15376: test_ret += test_xmlParseInNodeContext();
15377: test_ret += test_xmlParseMemory();
15378: test_ret += test_xmlParserAddNodeInfo();
15379: test_ret += test_xmlParserFindNodeInfo();
15380: test_ret += test_xmlParserFindNodeInfoIndex();
15381: test_ret += test_xmlParserInputGrow();
15382: test_ret += test_xmlParserInputRead();
15383: test_ret += test_xmlPedanticParserDefault();
15384: test_ret += test_xmlReadDoc();
15385: test_ret += test_xmlReadFile();
15386: test_ret += test_xmlReadMemory();
15387: test_ret += test_xmlRecoverDoc();
15388: test_ret += test_xmlRecoverFile();
15389: test_ret += test_xmlRecoverMemory();
15390: test_ret += test_xmlSAXParseDTD();
15391: test_ret += test_xmlSAXParseDoc();
15392: test_ret += test_xmlSAXParseEntity();
15393: test_ret += test_xmlSAXParseFile();
15394: test_ret += test_xmlSAXParseFileWithData();
15395: test_ret += test_xmlSAXParseMemory();
15396: test_ret += test_xmlSAXParseMemoryWithData();
15397: test_ret += test_xmlSAXUserParseFile();
15398: test_ret += test_xmlSAXUserParseMemory();
15399: test_ret += test_xmlSetExternalEntityLoader();
15400: test_ret += test_xmlSetFeature();
15401: test_ret += test_xmlSetupParserForBuffer();
15402: test_ret += test_xmlStopParser();
15403: test_ret += test_xmlSubstituteEntitiesDefault();
15404:
15405: if (test_ret != 0)
15406: printf("Module parser: %d errors\n", test_ret);
15407: return(test_ret);
15408: }
15409:
15410: static int
15411: test_htmlCreateFileParserCtxt(void) {
15412: int test_ret = 0;
15413:
15414: #if defined(LIBXML_HTML_ENABLED)
15415: int mem_base;
15416: htmlParserCtxtPtr ret_val;
15417: const char * filename; /* the filename */
15418: int n_filename;
15419: char * encoding; /* a free form C string describing the HTML document encoding, or NULL */
15420: int n_encoding;
15421:
15422: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
15423: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
15424: mem_base = xmlMemBlocks();
15425: filename = gen_fileoutput(n_filename, 0);
15426: encoding = gen_const_char_ptr(n_encoding, 1);
15427:
15428: ret_val = htmlCreateFileParserCtxt(filename, (const char *)encoding);
15429: desret_htmlParserCtxtPtr(ret_val);
15430: call_tests++;
15431: des_fileoutput(n_filename, filename, 0);
15432: des_const_char_ptr(n_encoding, (const char *)encoding, 1);
15433: xmlResetLastError();
15434: if (mem_base != xmlMemBlocks()) {
15435: printf("Leak of %d blocks found in htmlCreateFileParserCtxt",
15436: xmlMemBlocks() - mem_base);
15437: test_ret++;
15438: printf(" %d", n_filename);
15439: printf(" %d", n_encoding);
15440: printf("\n");
15441: }
15442: }
15443: }
15444: function_tests++;
15445: #endif
15446:
15447: return(test_ret);
15448: }
15449:
15450:
15451: static int
15452: test_htmlInitAutoClose(void) {
15453: int test_ret = 0;
15454:
15455: #if defined(LIBXML_HTML_ENABLED)
15456: int mem_base;
15457:
15458: mem_base = xmlMemBlocks();
15459:
15460: htmlInitAutoClose();
15461: call_tests++;
15462: xmlResetLastError();
15463: if (mem_base != xmlMemBlocks()) {
15464: printf("Leak of %d blocks found in htmlInitAutoClose",
15465: xmlMemBlocks() - mem_base);
15466: test_ret++;
15467: printf("\n");
15468: }
15469: function_tests++;
15470: #endif
15471:
15472: return(test_ret);
15473: }
15474:
15475:
15476: static int
15477: test_inputPop(void) {
15478: int test_ret = 0;
15479:
15480: int mem_base;
15481: xmlParserInputPtr ret_val;
15482: xmlParserCtxtPtr ctxt; /* an XML parser context */
15483: int n_ctxt;
15484:
15485: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15486: mem_base = xmlMemBlocks();
15487: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15488:
15489: ret_val = inputPop(ctxt);
15490: desret_xmlParserInputPtr(ret_val);
15491: call_tests++;
15492: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15493: xmlResetLastError();
15494: if (mem_base != xmlMemBlocks()) {
15495: printf("Leak of %d blocks found in inputPop",
15496: xmlMemBlocks() - mem_base);
15497: test_ret++;
15498: printf(" %d", n_ctxt);
15499: printf("\n");
15500: }
15501: }
15502: function_tests++;
15503:
15504: return(test_ret);
15505: }
15506:
15507:
15508: static int
15509: test_inputPush(void) {
15510: int test_ret = 0;
15511:
15512: int mem_base;
15513: int ret_val;
15514: xmlParserCtxtPtr ctxt; /* an XML parser context */
15515: int n_ctxt;
15516: xmlParserInputPtr value; /* the parser input */
15517: int n_value;
15518:
15519: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15520: for (n_value = 0;n_value < gen_nb_xmlParserInputPtr;n_value++) {
15521: mem_base = xmlMemBlocks();
15522: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15523: value = gen_xmlParserInputPtr(n_value, 1);
15524:
15525: ret_val = inputPush(ctxt, value);
15526: desret_int(ret_val);
15527: call_tests++;
15528: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15529: des_xmlParserInputPtr(n_value, value, 1);
15530: xmlResetLastError();
15531: if (mem_base != xmlMemBlocks()) {
15532: printf("Leak of %d blocks found in inputPush",
15533: xmlMemBlocks() - mem_base);
15534: test_ret++;
15535: printf(" %d", n_ctxt);
15536: printf(" %d", n_value);
15537: printf("\n");
15538: }
15539: }
15540: }
15541: function_tests++;
15542:
15543: return(test_ret);
15544: }
15545:
15546:
15547: static int
15548: test_namePop(void) {
15549: int test_ret = 0;
15550:
15551: int mem_base;
15552: const xmlChar * ret_val;
15553: xmlParserCtxtPtr ctxt; /* an XML parser context */
15554: int n_ctxt;
15555:
15556: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15557: mem_base = xmlMemBlocks();
15558: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15559:
15560: ret_val = namePop(ctxt);
15561: desret_const_xmlChar_ptr(ret_val);
15562: call_tests++;
15563: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15564: xmlResetLastError();
15565: if (mem_base != xmlMemBlocks()) {
15566: printf("Leak of %d blocks found in namePop",
15567: xmlMemBlocks() - mem_base);
15568: test_ret++;
15569: printf(" %d", n_ctxt);
15570: printf("\n");
15571: }
15572: }
15573: function_tests++;
15574:
15575: return(test_ret);
15576: }
15577:
15578:
15579: static int
15580: test_namePush(void) {
15581: int test_ret = 0;
15582:
15583: int mem_base;
15584: int ret_val;
15585: xmlParserCtxtPtr ctxt; /* an XML parser context */
15586: int n_ctxt;
15587: xmlChar * value; /* the element name */
15588: int n_value;
15589:
15590: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15591: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
15592: mem_base = xmlMemBlocks();
15593: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15594: value = gen_const_xmlChar_ptr(n_value, 1);
15595:
15596: ret_val = namePush(ctxt, (const xmlChar *)value);
15597: desret_int(ret_val);
15598: call_tests++;
15599: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15600: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
15601: xmlResetLastError();
15602: if (mem_base != xmlMemBlocks()) {
15603: printf("Leak of %d blocks found in namePush",
15604: xmlMemBlocks() - mem_base);
15605: test_ret++;
15606: printf(" %d", n_ctxt);
15607: printf(" %d", n_value);
15608: printf("\n");
15609: }
15610: }
15611: }
15612: function_tests++;
15613:
15614: return(test_ret);
15615: }
15616:
15617:
15618: static int
15619: test_nodePop(void) {
15620: int test_ret = 0;
15621:
15622: int mem_base;
15623: xmlNodePtr ret_val;
15624: xmlParserCtxtPtr ctxt; /* an XML parser context */
15625: int n_ctxt;
15626:
15627: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15628: mem_base = xmlMemBlocks();
15629: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15630:
15631: ret_val = nodePop(ctxt);
15632: desret_xmlNodePtr(ret_val);
15633: call_tests++;
15634: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15635: xmlResetLastError();
15636: if (mem_base != xmlMemBlocks()) {
15637: printf("Leak of %d blocks found in nodePop",
15638: xmlMemBlocks() - mem_base);
15639: test_ret++;
15640: printf(" %d", n_ctxt);
15641: printf("\n");
15642: }
15643: }
15644: function_tests++;
15645:
15646: return(test_ret);
15647: }
15648:
15649:
15650: static int
15651: test_nodePush(void) {
15652: int test_ret = 0;
15653:
15654: int mem_base;
15655: int ret_val;
15656: xmlParserCtxtPtr ctxt; /* an XML parser context */
15657: int n_ctxt;
15658: xmlNodePtr value; /* the element node */
15659: int n_value;
15660:
15661: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15662: for (n_value = 0;n_value < gen_nb_xmlNodePtr;n_value++) {
15663: mem_base = xmlMemBlocks();
15664: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15665: value = gen_xmlNodePtr(n_value, 1);
15666:
15667: ret_val = nodePush(ctxt, value);
15668: desret_int(ret_val);
15669: call_tests++;
15670: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15671: des_xmlNodePtr(n_value, value, 1);
15672: xmlResetLastError();
15673: if (mem_base != xmlMemBlocks()) {
15674: printf("Leak of %d blocks found in nodePush",
15675: xmlMemBlocks() - mem_base);
15676: test_ret++;
15677: printf(" %d", n_ctxt);
15678: printf(" %d", n_value);
15679: printf("\n");
15680: }
15681: }
15682: }
15683: function_tests++;
15684:
15685: return(test_ret);
15686: }
15687:
15688:
15689: static int
15690: test_xmlCheckLanguageID(void) {
15691: int test_ret = 0;
15692:
15693: int mem_base;
15694: int ret_val;
15695: xmlChar * lang; /* pointer to the string value */
15696: int n_lang;
15697:
15698: for (n_lang = 0;n_lang < gen_nb_const_xmlChar_ptr;n_lang++) {
15699: mem_base = xmlMemBlocks();
15700: lang = gen_const_xmlChar_ptr(n_lang, 0);
15701:
15702: ret_val = xmlCheckLanguageID((const xmlChar *)lang);
15703: desret_int(ret_val);
15704: call_tests++;
15705: des_const_xmlChar_ptr(n_lang, (const xmlChar *)lang, 0);
15706: xmlResetLastError();
15707: if (mem_base != xmlMemBlocks()) {
15708: printf("Leak of %d blocks found in xmlCheckLanguageID",
15709: xmlMemBlocks() - mem_base);
15710: test_ret++;
15711: printf(" %d", n_lang);
15712: printf("\n");
15713: }
15714: }
15715: function_tests++;
15716:
15717: return(test_ret);
15718: }
15719:
15720:
15721: static int
15722: test_xmlCopyChar(void) {
15723: int test_ret = 0;
15724:
15725: int mem_base;
15726: int ret_val;
15727: int len; /* Ignored, compatibility */
15728: int n_len;
15729: xmlChar * out; /* pointer to an array of xmlChar */
15730: int n_out;
15731: int val; /* the char value */
15732: int n_val;
15733:
15734: for (n_len = 0;n_len < gen_nb_int;n_len++) {
15735: for (n_out = 0;n_out < gen_nb_xmlChar_ptr;n_out++) {
15736: for (n_val = 0;n_val < gen_nb_int;n_val++) {
15737: mem_base = xmlMemBlocks();
15738: len = gen_int(n_len, 0);
15739: out = gen_xmlChar_ptr(n_out, 1);
15740: val = gen_int(n_val, 2);
15741:
15742: ret_val = xmlCopyChar(len, out, val);
15743: desret_int(ret_val);
15744: call_tests++;
15745: des_int(n_len, len, 0);
15746: des_xmlChar_ptr(n_out, out, 1);
15747: des_int(n_val, val, 2);
15748: xmlResetLastError();
15749: if (mem_base != xmlMemBlocks()) {
15750: printf("Leak of %d blocks found in xmlCopyChar",
15751: xmlMemBlocks() - mem_base);
15752: test_ret++;
15753: printf(" %d", n_len);
15754: printf(" %d", n_out);
15755: printf(" %d", n_val);
15756: printf("\n");
15757: }
15758: }
15759: }
15760: }
15761: function_tests++;
15762:
15763: return(test_ret);
15764: }
15765:
15766:
15767: static int
15768: test_xmlCopyCharMultiByte(void) {
15769: int test_ret = 0;
15770:
15771: int mem_base;
15772: int ret_val;
15773: xmlChar * out; /* pointer to an array of xmlChar */
15774: int n_out;
15775: int val; /* the char value */
15776: int n_val;
15777:
15778: for (n_out = 0;n_out < gen_nb_xmlChar_ptr;n_out++) {
15779: for (n_val = 0;n_val < gen_nb_int;n_val++) {
15780: mem_base = xmlMemBlocks();
15781: out = gen_xmlChar_ptr(n_out, 0);
15782: val = gen_int(n_val, 1);
15783:
15784: ret_val = xmlCopyCharMultiByte(out, val);
15785: desret_int(ret_val);
15786: call_tests++;
15787: des_xmlChar_ptr(n_out, out, 0);
15788: des_int(n_val, val, 1);
15789: xmlResetLastError();
15790: if (mem_base != xmlMemBlocks()) {
15791: printf("Leak of %d blocks found in xmlCopyCharMultiByte",
15792: xmlMemBlocks() - mem_base);
15793: test_ret++;
15794: printf(" %d", n_out);
15795: printf(" %d", n_val);
15796: printf("\n");
15797: }
15798: }
15799: }
15800: function_tests++;
15801:
15802: return(test_ret);
15803: }
15804:
15805:
15806: static int
15807: test_xmlCreateEntityParserCtxt(void) {
15808: int test_ret = 0;
15809:
15810: int mem_base;
15811: xmlParserCtxtPtr ret_val;
15812: xmlChar * URL; /* the entity URL */
15813: int n_URL;
15814: xmlChar * ID; /* the entity PUBLIC ID */
15815: int n_ID;
15816: xmlChar * base; /* a possible base for the target URI */
15817: int n_base;
15818:
15819: for (n_URL = 0;n_URL < gen_nb_const_xmlChar_ptr;n_URL++) {
15820: for (n_ID = 0;n_ID < gen_nb_const_xmlChar_ptr;n_ID++) {
15821: for (n_base = 0;n_base < gen_nb_const_xmlChar_ptr;n_base++) {
15822: mem_base = xmlMemBlocks();
15823: URL = gen_const_xmlChar_ptr(n_URL, 0);
15824: ID = gen_const_xmlChar_ptr(n_ID, 1);
15825: base = gen_const_xmlChar_ptr(n_base, 2);
15826:
15827: ret_val = xmlCreateEntityParserCtxt((const xmlChar *)URL, (const xmlChar *)ID, (const xmlChar *)base);
15828: desret_xmlParserCtxtPtr(ret_val);
15829: call_tests++;
15830: des_const_xmlChar_ptr(n_URL, (const xmlChar *)URL, 0);
15831: des_const_xmlChar_ptr(n_ID, (const xmlChar *)ID, 1);
15832: des_const_xmlChar_ptr(n_base, (const xmlChar *)base, 2);
15833: xmlResetLastError();
15834: if (mem_base != xmlMemBlocks()) {
15835: printf("Leak of %d blocks found in xmlCreateEntityParserCtxt",
15836: xmlMemBlocks() - mem_base);
15837: test_ret++;
15838: printf(" %d", n_URL);
15839: printf(" %d", n_ID);
15840: printf(" %d", n_base);
15841: printf("\n");
15842: }
15843: }
15844: }
15845: }
15846: function_tests++;
15847:
15848: return(test_ret);
15849: }
15850:
15851:
15852: static int
15853: test_xmlCreateFileParserCtxt(void) {
15854: int test_ret = 0;
15855:
15856: int mem_base;
15857: xmlParserCtxtPtr ret_val;
15858: const char * filename; /* the filename */
15859: int n_filename;
15860:
15861: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
15862: mem_base = xmlMemBlocks();
15863: filename = gen_fileoutput(n_filename, 0);
15864:
15865: ret_val = xmlCreateFileParserCtxt(filename);
15866: desret_xmlParserCtxtPtr(ret_val);
15867: call_tests++;
15868: des_fileoutput(n_filename, filename, 0);
15869: xmlResetLastError();
15870: if (mem_base != xmlMemBlocks()) {
15871: printf("Leak of %d blocks found in xmlCreateFileParserCtxt",
15872: xmlMemBlocks() - mem_base);
15873: test_ret++;
15874: printf(" %d", n_filename);
15875: printf("\n");
15876: }
15877: }
15878: function_tests++;
15879:
15880: return(test_ret);
15881: }
15882:
15883:
15884: static int
15885: test_xmlCreateMemoryParserCtxt(void) {
15886: int test_ret = 0;
15887:
15888: int mem_base;
15889: xmlParserCtxtPtr ret_val;
15890: char * buffer; /* a pointer to a char array */
15891: int n_buffer;
15892: int size; /* the size of the array */
15893: int n_size;
15894:
15895: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
15896: for (n_size = 0;n_size < gen_nb_int;n_size++) {
15897: mem_base = xmlMemBlocks();
15898: buffer = gen_const_char_ptr(n_buffer, 0);
15899: size = gen_int(n_size, 1);
15900:
15901: ret_val = xmlCreateMemoryParserCtxt((const char *)buffer, size);
15902: desret_xmlParserCtxtPtr(ret_val);
15903: call_tests++;
15904: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
15905: des_int(n_size, size, 1);
15906: xmlResetLastError();
15907: if (mem_base != xmlMemBlocks()) {
15908: printf("Leak of %d blocks found in xmlCreateMemoryParserCtxt",
15909: xmlMemBlocks() - mem_base);
15910: test_ret++;
15911: printf(" %d", n_buffer);
15912: printf(" %d", n_size);
15913: printf("\n");
15914: }
15915: }
15916: }
15917: function_tests++;
15918:
15919: return(test_ret);
15920: }
15921:
15922:
15923: static int
15924: test_xmlCreateURLParserCtxt(void) {
15925: int test_ret = 0;
15926:
15927: int mem_base;
15928: xmlParserCtxtPtr ret_val;
15929: const char * filename; /* the filename or URL */
15930: int n_filename;
15931: int options; /* a combination of xmlParserOption */
15932: int n_options;
15933:
15934: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
15935: for (n_options = 0;n_options < gen_nb_int;n_options++) {
15936: mem_base = xmlMemBlocks();
15937: filename = gen_fileoutput(n_filename, 0);
15938: options = gen_int(n_options, 1);
15939:
15940: ret_val = xmlCreateURLParserCtxt(filename, options);
15941: desret_xmlParserCtxtPtr(ret_val);
15942: call_tests++;
15943: des_fileoutput(n_filename, filename, 0);
15944: des_int(n_options, options, 1);
15945: xmlResetLastError();
15946: if (mem_base != xmlMemBlocks()) {
15947: printf("Leak of %d blocks found in xmlCreateURLParserCtxt",
15948: xmlMemBlocks() - mem_base);
15949: test_ret++;
15950: printf(" %d", n_filename);
15951: printf(" %d", n_options);
15952: printf("\n");
15953: }
15954: }
15955: }
15956: function_tests++;
15957:
15958: return(test_ret);
15959: }
15960:
15961:
15962: static int
15963: test_xmlCurrentChar(void) {
15964: int test_ret = 0;
15965:
15966: int mem_base;
15967: int ret_val;
15968: xmlParserCtxtPtr ctxt; /* the XML parser context */
15969: int n_ctxt;
15970: int * len; /* pointer to the length of the char read */
15971: int n_len;
15972:
15973: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15974: for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
15975: mem_base = xmlMemBlocks();
15976: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15977: len = gen_int_ptr(n_len, 1);
15978:
15979: ret_val = xmlCurrentChar(ctxt, len);
15980: desret_int(ret_val);
15981: call_tests++;
15982: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15983: des_int_ptr(n_len, len, 1);
15984: xmlResetLastError();
15985: if (mem_base != xmlMemBlocks()) {
15986: printf("Leak of %d blocks found in xmlCurrentChar",
15987: xmlMemBlocks() - mem_base);
15988: test_ret++;
15989: printf(" %d", n_ctxt);
15990: printf(" %d", n_len);
15991: printf("\n");
15992: }
15993: }
15994: }
15995: function_tests++;
15996:
15997: return(test_ret);
15998: }
15999:
16000:
16001: static int
16002: test_xmlErrMemory(void) {
16003: int test_ret = 0;
16004:
16005: int mem_base;
16006: xmlParserCtxtPtr ctxt; /* an XML parser context */
16007: int n_ctxt;
16008: char * extra; /* extra informations */
16009: int n_extra;
16010:
16011: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16012: for (n_extra = 0;n_extra < gen_nb_const_char_ptr;n_extra++) {
16013: mem_base = xmlMemBlocks();
16014: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16015: extra = gen_const_char_ptr(n_extra, 1);
16016:
16017: xmlErrMemory(ctxt, (const char *)extra);
16018: call_tests++;
16019: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16020: des_const_char_ptr(n_extra, (const char *)extra, 1);
16021: xmlResetLastError();
16022: if (mem_base != xmlMemBlocks()) {
16023: printf("Leak of %d blocks found in xmlErrMemory",
16024: xmlMemBlocks() - mem_base);
16025: test_ret++;
16026: printf(" %d", n_ctxt);
16027: printf(" %d", n_extra);
16028: printf("\n");
16029: }
16030: }
16031: }
16032: function_tests++;
16033:
16034: return(test_ret);
16035: }
16036:
16037:
16038: static int
16039: test_xmlIsLetter(void) {
16040: int test_ret = 0;
16041:
16042: int mem_base;
16043: int ret_val;
16044: int c; /* an unicode character (int) */
16045: int n_c;
16046:
16047: for (n_c = 0;n_c < gen_nb_int;n_c++) {
16048: mem_base = xmlMemBlocks();
16049: c = gen_int(n_c, 0);
16050:
16051: ret_val = xmlIsLetter(c);
16052: desret_int(ret_val);
16053: call_tests++;
16054: des_int(n_c, c, 0);
16055: xmlResetLastError();
16056: if (mem_base != xmlMemBlocks()) {
16057: printf("Leak of %d blocks found in xmlIsLetter",
16058: xmlMemBlocks() - mem_base);
16059: test_ret++;
16060: printf(" %d", n_c);
16061: printf("\n");
16062: }
16063: }
16064: function_tests++;
16065:
16066: return(test_ret);
16067: }
16068:
16069:
16070: static int
16071: test_xmlNewEntityInputStream(void) {
16072: int test_ret = 0;
16073:
16074: int mem_base;
16075: xmlParserInputPtr ret_val;
16076: xmlParserCtxtPtr ctxt; /* an XML parser context */
16077: int n_ctxt;
16078: xmlEntityPtr entity; /* an Entity pointer */
16079: int n_entity;
16080:
16081: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16082: for (n_entity = 0;n_entity < gen_nb_xmlEntityPtr;n_entity++) {
16083: mem_base = xmlMemBlocks();
16084: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16085: entity = gen_xmlEntityPtr(n_entity, 1);
16086:
16087: ret_val = xmlNewEntityInputStream(ctxt, entity);
16088: desret_xmlParserInputPtr(ret_val);
16089: call_tests++;
16090: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16091: des_xmlEntityPtr(n_entity, entity, 1);
16092: xmlResetLastError();
16093: if (mem_base != xmlMemBlocks()) {
16094: printf("Leak of %d blocks found in xmlNewEntityInputStream",
16095: xmlMemBlocks() - mem_base);
16096: test_ret++;
16097: printf(" %d", n_ctxt);
16098: printf(" %d", n_entity);
16099: printf("\n");
16100: }
16101: }
16102: }
16103: function_tests++;
16104:
16105: return(test_ret);
16106: }
16107:
16108:
16109: static int
16110: test_xmlNewInputFromFile(void) {
16111: int test_ret = 0;
16112:
16113: int mem_base;
16114: xmlParserInputPtr ret_val;
16115: xmlParserCtxtPtr ctxt; /* an XML parser context */
16116: int n_ctxt;
16117: const char * filename; /* the filename to use as entity */
16118: int n_filename;
16119:
16120: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16121: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
16122: mem_base = xmlMemBlocks();
16123: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16124: filename = gen_filepath(n_filename, 1);
16125:
16126: ret_val = xmlNewInputFromFile(ctxt, filename);
16127: desret_xmlParserInputPtr(ret_val);
16128: call_tests++;
16129: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16130: des_filepath(n_filename, filename, 1);
16131: xmlResetLastError();
16132: if (mem_base != xmlMemBlocks()) {
16133: printf("Leak of %d blocks found in xmlNewInputFromFile",
16134: xmlMemBlocks() - mem_base);
16135: test_ret++;
16136: printf(" %d", n_ctxt);
16137: printf(" %d", n_filename);
16138: printf("\n");
16139: }
16140: }
16141: }
16142: function_tests++;
16143:
16144: return(test_ret);
16145: }
16146:
16147:
16148: static int
16149: test_xmlNewInputStream(void) {
16150: int test_ret = 0;
16151:
16152: int mem_base;
16153: xmlParserInputPtr ret_val;
16154: xmlParserCtxtPtr ctxt; /* an XML parser context */
16155: int n_ctxt;
16156:
16157: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16158: mem_base = xmlMemBlocks();
16159: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16160:
16161: ret_val = xmlNewInputStream(ctxt);
16162: desret_xmlParserInputPtr(ret_val);
16163: call_tests++;
16164: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16165: xmlResetLastError();
16166: if (mem_base != xmlMemBlocks()) {
16167: printf("Leak of %d blocks found in xmlNewInputStream",
16168: xmlMemBlocks() - mem_base);
16169: test_ret++;
16170: printf(" %d", n_ctxt);
16171: printf("\n");
16172: }
16173: }
16174: function_tests++;
16175:
16176: return(test_ret);
16177: }
16178:
16179:
16180: static int
16181: test_xmlNewStringInputStream(void) {
16182: int test_ret = 0;
16183:
16184: int mem_base;
16185: xmlParserInputPtr ret_val;
16186: xmlParserCtxtPtr ctxt; /* an XML parser context */
16187: int n_ctxt;
16188: xmlChar * buffer; /* an memory buffer */
16189: int n_buffer;
16190:
16191: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16192: for (n_buffer = 0;n_buffer < gen_nb_const_xmlChar_ptr;n_buffer++) {
16193: mem_base = xmlMemBlocks();
16194: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16195: buffer = gen_const_xmlChar_ptr(n_buffer, 1);
16196:
16197: ret_val = xmlNewStringInputStream(ctxt, (const xmlChar *)buffer);
16198: desret_xmlParserInputPtr(ret_val);
16199: call_tests++;
16200: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16201: des_const_xmlChar_ptr(n_buffer, (const xmlChar *)buffer, 1);
16202: xmlResetLastError();
16203: if (mem_base != xmlMemBlocks()) {
16204: printf("Leak of %d blocks found in xmlNewStringInputStream",
16205: xmlMemBlocks() - mem_base);
16206: test_ret++;
16207: printf(" %d", n_ctxt);
16208: printf(" %d", n_buffer);
16209: printf("\n");
16210: }
16211: }
16212: }
16213: function_tests++;
16214:
16215: return(test_ret);
16216: }
16217:
16218:
16219: static int
16220: test_xmlNextChar(void) {
16221: int test_ret = 0;
16222:
16223: int mem_base;
16224: xmlParserCtxtPtr ctxt; /* the XML parser context */
16225: int n_ctxt;
16226:
16227: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16228: mem_base = xmlMemBlocks();
16229: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16230:
16231: xmlNextChar(ctxt);
16232: call_tests++;
16233: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16234: xmlResetLastError();
16235: if (mem_base != xmlMemBlocks()) {
16236: printf("Leak of %d blocks found in xmlNextChar",
16237: xmlMemBlocks() - mem_base);
16238: test_ret++;
16239: printf(" %d", n_ctxt);
16240: printf("\n");
16241: }
16242: }
16243: function_tests++;
16244:
16245: return(test_ret);
16246: }
16247:
16248:
16249: static int
16250: test_xmlParserInputShrink(void) {
16251: int test_ret = 0;
16252:
16253: int mem_base;
16254: xmlParserInputPtr in; /* an XML parser input */
16255: int n_in;
16256:
16257: for (n_in = 0;n_in < gen_nb_xmlParserInputPtr;n_in++) {
16258: mem_base = xmlMemBlocks();
16259: in = gen_xmlParserInputPtr(n_in, 0);
16260:
16261: xmlParserInputShrink(in);
16262: call_tests++;
16263: des_xmlParserInputPtr(n_in, in, 0);
16264: xmlResetLastError();
16265: if (mem_base != xmlMemBlocks()) {
16266: printf("Leak of %d blocks found in xmlParserInputShrink",
16267: xmlMemBlocks() - mem_base);
16268: test_ret++;
16269: printf(" %d", n_in);
16270: printf("\n");
16271: }
16272: }
16273: function_tests++;
16274:
16275: return(test_ret);
16276: }
16277:
16278:
16279: static int
16280: test_xmlPopInput(void) {
16281: int test_ret = 0;
16282:
16283: int mem_base;
16284: xmlChar ret_val;
16285: xmlParserCtxtPtr ctxt; /* an XML parser context */
16286: int n_ctxt;
16287:
16288: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16289: mem_base = xmlMemBlocks();
16290: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16291:
16292: ret_val = xmlPopInput(ctxt);
16293: desret_xmlChar(ret_val);
16294: call_tests++;
16295: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16296: xmlResetLastError();
16297: if (mem_base != xmlMemBlocks()) {
16298: printf("Leak of %d blocks found in xmlPopInput",
16299: xmlMemBlocks() - mem_base);
16300: test_ret++;
16301: printf(" %d", n_ctxt);
16302: printf("\n");
16303: }
16304: }
16305: function_tests++;
16306:
16307: return(test_ret);
16308: }
16309:
16310:
16311: static int
16312: test_xmlPushInput(void) {
16313: int test_ret = 0;
16314:
16315: int mem_base;
16316: int ret_val;
16317: xmlParserCtxtPtr ctxt; /* an XML parser context */
16318: int n_ctxt;
16319: xmlParserInputPtr input; /* an XML parser input fragment (entity, XML fragment ...). */
16320: int n_input;
16321:
16322: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16323: for (n_input = 0;n_input < gen_nb_xmlParserInputPtr;n_input++) {
16324: mem_base = xmlMemBlocks();
16325: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16326: input = gen_xmlParserInputPtr(n_input, 1);
16327:
16328: ret_val = xmlPushInput(ctxt, input);
16329: desret_int(ret_val);
16330: call_tests++;
16331: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16332: des_xmlParserInputPtr(n_input, input, 1);
16333: xmlResetLastError();
16334: if (mem_base != xmlMemBlocks()) {
16335: printf("Leak of %d blocks found in xmlPushInput",
16336: xmlMemBlocks() - mem_base);
16337: test_ret++;
16338: printf(" %d", n_ctxt);
16339: printf(" %d", n_input);
16340: printf("\n");
16341: }
16342: }
16343: }
16344: function_tests++;
16345:
16346: return(test_ret);
16347: }
16348:
16349:
16350: static int
16351: test_xmlSetEntityReferenceFunc(void) {
16352: int test_ret = 0;
16353:
16354:
16355: /* missing type support */
16356: return(test_ret);
16357: }
16358:
16359:
16360: static int
16361: test_xmlSplitQName(void) {
16362: int test_ret = 0;
16363:
16364: int mem_base;
16365: xmlChar * ret_val;
16366: xmlParserCtxtPtr ctxt; /* an XML parser context */
16367: int n_ctxt;
16368: xmlChar * name; /* an XML parser context */
16369: int n_name;
16370: xmlChar ** prefix; /* a xmlChar ** */
16371: int n_prefix;
16372:
16373: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16374: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
16375: for (n_prefix = 0;n_prefix < gen_nb_xmlChar_ptr_ptr;n_prefix++) {
16376: mem_base = xmlMemBlocks();
16377: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16378: name = gen_const_xmlChar_ptr(n_name, 1);
16379: prefix = gen_xmlChar_ptr_ptr(n_prefix, 2);
16380:
16381: ret_val = xmlSplitQName(ctxt, (const xmlChar *)name, prefix);
16382: desret_xmlChar_ptr(ret_val);
16383: call_tests++;
16384: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16385: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
16386: des_xmlChar_ptr_ptr(n_prefix, prefix, 2);
16387: xmlResetLastError();
16388: if (mem_base != xmlMemBlocks()) {
16389: printf("Leak of %d blocks found in xmlSplitQName",
16390: xmlMemBlocks() - mem_base);
16391: test_ret++;
16392: printf(" %d", n_ctxt);
16393: printf(" %d", n_name);
16394: printf(" %d", n_prefix);
16395: printf("\n");
16396: }
16397: }
16398: }
16399: }
16400: function_tests++;
16401:
16402: return(test_ret);
16403: }
16404:
16405:
16406: static int
16407: test_xmlStringCurrentChar(void) {
16408: int test_ret = 0;
16409:
16410: int mem_base;
16411: int ret_val;
16412: xmlParserCtxtPtr ctxt; /* the XML parser context */
16413: int n_ctxt;
16414: xmlChar * cur; /* pointer to the beginning of the char */
16415: int n_cur;
16416: int * len; /* pointer to the length of the char read */
16417: int n_len;
16418:
16419: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16420: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
16421: for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
16422: mem_base = xmlMemBlocks();
16423: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16424: cur = gen_const_xmlChar_ptr(n_cur, 1);
16425: len = gen_int_ptr(n_len, 2);
16426:
16427: ret_val = xmlStringCurrentChar(ctxt, (const xmlChar *)cur, len);
16428: desret_int(ret_val);
16429: call_tests++;
16430: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16431: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 1);
16432: des_int_ptr(n_len, len, 2);
16433: xmlResetLastError();
16434: if (mem_base != xmlMemBlocks()) {
16435: printf("Leak of %d blocks found in xmlStringCurrentChar",
16436: xmlMemBlocks() - mem_base);
16437: test_ret++;
16438: printf(" %d", n_ctxt);
16439: printf(" %d", n_cur);
16440: printf(" %d", n_len);
16441: printf("\n");
16442: }
16443: }
16444: }
16445: }
16446: function_tests++;
16447:
16448: return(test_ret);
16449: }
16450:
16451:
16452: static int
16453: test_xmlStringDecodeEntities(void) {
16454: int test_ret = 0;
16455:
16456: int mem_base;
16457: xmlChar * ret_val;
16458: xmlParserCtxtPtr ctxt; /* the parser context */
16459: int n_ctxt;
16460: xmlChar * str; /* the input string */
16461: int n_str;
16462: int what; /* combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF */
16463: int n_what;
16464: xmlChar end; /* an end marker xmlChar, 0 if none */
16465: int n_end;
16466: xmlChar end2; /* an end marker xmlChar, 0 if none */
16467: int n_end2;
16468: xmlChar end3; /* an end marker xmlChar, 0 if none */
16469: int n_end3;
16470:
16471: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16472: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
16473: for (n_what = 0;n_what < gen_nb_int;n_what++) {
16474: for (n_end = 0;n_end < gen_nb_xmlChar;n_end++) {
16475: for (n_end2 = 0;n_end2 < gen_nb_xmlChar;n_end2++) {
16476: for (n_end3 = 0;n_end3 < gen_nb_xmlChar;n_end3++) {
16477: mem_base = xmlMemBlocks();
16478: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16479: str = gen_const_xmlChar_ptr(n_str, 1);
16480: what = gen_int(n_what, 2);
16481: end = gen_xmlChar(n_end, 3);
16482: end2 = gen_xmlChar(n_end2, 4);
16483: end3 = gen_xmlChar(n_end3, 5);
16484:
16485: ret_val = xmlStringDecodeEntities(ctxt, (const xmlChar *)str, what, end, end2, end3);
16486: desret_xmlChar_ptr(ret_val);
16487: call_tests++;
16488: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16489: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
16490: des_int(n_what, what, 2);
16491: des_xmlChar(n_end, end, 3);
16492: des_xmlChar(n_end2, end2, 4);
16493: des_xmlChar(n_end3, end3, 5);
16494: xmlResetLastError();
16495: if (mem_base != xmlMemBlocks()) {
16496: printf("Leak of %d blocks found in xmlStringDecodeEntities",
16497: xmlMemBlocks() - mem_base);
16498: test_ret++;
16499: printf(" %d", n_ctxt);
16500: printf(" %d", n_str);
16501: printf(" %d", n_what);
16502: printf(" %d", n_end);
16503: printf(" %d", n_end2);
16504: printf(" %d", n_end3);
16505: printf("\n");
16506: }
16507: }
16508: }
16509: }
16510: }
16511: }
16512: }
16513: function_tests++;
16514:
16515: return(test_ret);
16516: }
16517:
16518:
16519: static int
16520: test_xmlStringLenDecodeEntities(void) {
16521: int test_ret = 0;
16522:
16523: int mem_base;
16524: xmlChar * ret_val;
16525: xmlParserCtxtPtr ctxt; /* the parser context */
16526: int n_ctxt;
16527: xmlChar * str; /* the input string */
16528: int n_str;
16529: int len; /* the string length */
16530: int n_len;
16531: int what; /* combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF */
16532: int n_what;
16533: xmlChar end; /* an end marker xmlChar, 0 if none */
16534: int n_end;
16535: xmlChar end2; /* an end marker xmlChar, 0 if none */
16536: int n_end2;
16537: xmlChar end3; /* an end marker xmlChar, 0 if none */
16538: int n_end3;
16539:
16540: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16541: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
16542: for (n_len = 0;n_len < gen_nb_int;n_len++) {
16543: for (n_what = 0;n_what < gen_nb_int;n_what++) {
16544: for (n_end = 0;n_end < gen_nb_xmlChar;n_end++) {
16545: for (n_end2 = 0;n_end2 < gen_nb_xmlChar;n_end2++) {
16546: for (n_end3 = 0;n_end3 < gen_nb_xmlChar;n_end3++) {
16547: mem_base = xmlMemBlocks();
16548: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16549: str = gen_const_xmlChar_ptr(n_str, 1);
16550: len = gen_int(n_len, 2);
16551: what = gen_int(n_what, 3);
16552: end = gen_xmlChar(n_end, 4);
16553: end2 = gen_xmlChar(n_end2, 5);
16554: end3 = gen_xmlChar(n_end3, 6);
16555:
16556: ret_val = xmlStringLenDecodeEntities(ctxt, (const xmlChar *)str, len, what, end, end2, end3);
16557: desret_xmlChar_ptr(ret_val);
16558: call_tests++;
16559: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16560: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
16561: des_int(n_len, len, 2);
16562: des_int(n_what, what, 3);
16563: des_xmlChar(n_end, end, 4);
16564: des_xmlChar(n_end2, end2, 5);
16565: des_xmlChar(n_end3, end3, 6);
16566: xmlResetLastError();
16567: if (mem_base != xmlMemBlocks()) {
16568: printf("Leak of %d blocks found in xmlStringLenDecodeEntities",
16569: xmlMemBlocks() - mem_base);
16570: test_ret++;
16571: printf(" %d", n_ctxt);
16572: printf(" %d", n_str);
16573: printf(" %d", n_len);
16574: printf(" %d", n_what);
16575: printf(" %d", n_end);
16576: printf(" %d", n_end2);
16577: printf(" %d", n_end3);
16578: printf("\n");
16579: }
16580: }
16581: }
16582: }
16583: }
16584: }
16585: }
16586: }
16587: function_tests++;
16588:
16589: return(test_ret);
16590: }
16591:
16592:
16593: static int
16594: test_xmlSwitchEncoding(void) {
16595: int test_ret = 0;
16596:
16597: int mem_base;
16598: int ret_val;
16599: xmlParserCtxtPtr ctxt; /* the parser context */
16600: int n_ctxt;
16601: xmlCharEncoding enc; /* the encoding value (number) */
16602: int n_enc;
16603:
16604: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16605: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
16606: mem_base = xmlMemBlocks();
16607: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16608: enc = gen_xmlCharEncoding(n_enc, 1);
16609:
16610: ret_val = xmlSwitchEncoding(ctxt, enc);
16611: desret_int(ret_val);
16612: call_tests++;
16613: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16614: des_xmlCharEncoding(n_enc, enc, 1);
16615: xmlResetLastError();
16616: if (mem_base != xmlMemBlocks()) {
16617: printf("Leak of %d blocks found in xmlSwitchEncoding",
16618: xmlMemBlocks() - mem_base);
16619: test_ret++;
16620: printf(" %d", n_ctxt);
16621: printf(" %d", n_enc);
16622: printf("\n");
16623: }
16624: }
16625: }
16626: function_tests++;
16627:
16628: return(test_ret);
16629: }
16630:
16631:
16632: static int
16633: test_xmlSwitchInputEncoding(void) {
16634: int test_ret = 0;
16635:
16636: int mem_base;
16637: int ret_val;
16638: xmlParserCtxtPtr ctxt; /* the parser context */
16639: int n_ctxt;
16640: xmlParserInputPtr input; /* the input stream */
16641: int n_input;
16642: xmlCharEncodingHandlerPtr handler; /* the encoding handler */
16643: int n_handler;
16644:
16645: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16646: for (n_input = 0;n_input < gen_nb_xmlParserInputPtr;n_input++) {
16647: for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandlerPtr;n_handler++) {
16648: mem_base = xmlMemBlocks();
16649: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16650: input = gen_xmlParserInputPtr(n_input, 1);
16651: handler = gen_xmlCharEncodingHandlerPtr(n_handler, 2);
16652:
16653: ret_val = xmlSwitchInputEncoding(ctxt, input, handler);
16654: desret_int(ret_val);
16655: call_tests++;
16656: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16657: des_xmlParserInputPtr(n_input, input, 1);
16658: des_xmlCharEncodingHandlerPtr(n_handler, handler, 2);
16659: xmlResetLastError();
16660: if (mem_base != xmlMemBlocks()) {
16661: printf("Leak of %d blocks found in xmlSwitchInputEncoding",
16662: xmlMemBlocks() - mem_base);
16663: test_ret++;
16664: printf(" %d", n_ctxt);
16665: printf(" %d", n_input);
16666: printf(" %d", n_handler);
16667: printf("\n");
16668: }
16669: }
16670: }
16671: }
16672: function_tests++;
16673:
16674: return(test_ret);
16675: }
16676:
16677:
16678: static int
16679: test_xmlSwitchToEncoding(void) {
16680: int test_ret = 0;
16681:
16682: int mem_base;
16683: int ret_val;
16684: xmlParserCtxtPtr ctxt; /* the parser context */
16685: int n_ctxt;
16686: xmlCharEncodingHandlerPtr handler; /* the encoding handler */
16687: int n_handler;
16688:
16689: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16690: for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandlerPtr;n_handler++) {
16691: mem_base = xmlMemBlocks();
16692: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16693: handler = gen_xmlCharEncodingHandlerPtr(n_handler, 1);
16694:
16695: ret_val = xmlSwitchToEncoding(ctxt, handler);
16696: desret_int(ret_val);
16697: call_tests++;
16698: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16699: des_xmlCharEncodingHandlerPtr(n_handler, handler, 1);
16700: xmlResetLastError();
16701: if (mem_base != xmlMemBlocks()) {
16702: printf("Leak of %d blocks found in xmlSwitchToEncoding",
16703: xmlMemBlocks() - mem_base);
16704: test_ret++;
16705: printf(" %d", n_ctxt);
16706: printf(" %d", n_handler);
16707: printf("\n");
16708: }
16709: }
16710: }
16711: function_tests++;
16712:
16713: return(test_ret);
16714: }
16715:
16716: static int
16717: test_parserInternals(void) {
16718: int test_ret = 0;
16719:
16720: if (quiet == 0) printf("Testing parserInternals : 33 of 90 functions ...\n");
16721: test_ret += test_htmlCreateFileParserCtxt();
16722: test_ret += test_htmlInitAutoClose();
16723: test_ret += test_inputPop();
16724: test_ret += test_inputPush();
16725: test_ret += test_namePop();
16726: test_ret += test_namePush();
16727: test_ret += test_nodePop();
16728: test_ret += test_nodePush();
16729: test_ret += test_xmlCheckLanguageID();
16730: test_ret += test_xmlCopyChar();
16731: test_ret += test_xmlCopyCharMultiByte();
16732: test_ret += test_xmlCreateEntityParserCtxt();
16733: test_ret += test_xmlCreateFileParserCtxt();
16734: test_ret += test_xmlCreateMemoryParserCtxt();
16735: test_ret += test_xmlCreateURLParserCtxt();
16736: test_ret += test_xmlCurrentChar();
16737: test_ret += test_xmlErrMemory();
16738: test_ret += test_xmlIsLetter();
16739: test_ret += test_xmlNewEntityInputStream();
16740: test_ret += test_xmlNewInputFromFile();
16741: test_ret += test_xmlNewInputStream();
16742: test_ret += test_xmlNewStringInputStream();
16743: test_ret += test_xmlNextChar();
16744: test_ret += test_xmlParserInputShrink();
16745: test_ret += test_xmlPopInput();
16746: test_ret += test_xmlPushInput();
16747: test_ret += test_xmlSetEntityReferenceFunc();
16748: test_ret += test_xmlSplitQName();
16749: test_ret += test_xmlStringCurrentChar();
16750: test_ret += test_xmlStringDecodeEntities();
16751: test_ret += test_xmlStringLenDecodeEntities();
16752: test_ret += test_xmlSwitchEncoding();
16753: test_ret += test_xmlSwitchInputEncoding();
16754: test_ret += test_xmlSwitchToEncoding();
16755:
16756: if (test_ret != 0)
16757: printf("Module parserInternals: %d errors\n", test_ret);
16758: return(test_ret);
16759: }
16760:
16761: static int
16762: test_xmlPatternFromRoot(void) {
16763: int test_ret = 0;
16764:
16765: #if defined(LIBXML_PATTERN_ENABLED)
16766: int mem_base;
16767: int ret_val;
16768: xmlPatternPtr comp; /* the precompiled pattern */
16769: int n_comp;
16770:
16771: for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) {
16772: mem_base = xmlMemBlocks();
16773: comp = gen_xmlPatternPtr(n_comp, 0);
16774:
16775: ret_val = xmlPatternFromRoot(comp);
16776: desret_int(ret_val);
16777: call_tests++;
16778: des_xmlPatternPtr(n_comp, comp, 0);
16779: xmlResetLastError();
16780: if (mem_base != xmlMemBlocks()) {
16781: printf("Leak of %d blocks found in xmlPatternFromRoot",
16782: xmlMemBlocks() - mem_base);
16783: test_ret++;
16784: printf(" %d", n_comp);
16785: printf("\n");
16786: }
16787: }
16788: function_tests++;
16789: #endif
16790:
16791: return(test_ret);
16792: }
16793:
16794:
16795: static int
16796: test_xmlPatternGetStreamCtxt(void) {
16797: int test_ret = 0;
16798:
16799:
16800: /* missing type support */
16801: return(test_ret);
16802: }
16803:
16804:
16805: static int
16806: test_xmlPatternMatch(void) {
16807: int test_ret = 0;
16808:
16809: #if defined(LIBXML_PATTERN_ENABLED)
16810: int mem_base;
16811: int ret_val;
16812: xmlPatternPtr comp; /* the precompiled pattern */
16813: int n_comp;
16814: xmlNodePtr node; /* a node */
16815: int n_node;
16816:
16817: for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) {
16818: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
16819: mem_base = xmlMemBlocks();
16820: comp = gen_xmlPatternPtr(n_comp, 0);
16821: node = gen_xmlNodePtr(n_node, 1);
16822:
16823: ret_val = xmlPatternMatch(comp, node);
16824: desret_int(ret_val);
16825: call_tests++;
16826: des_xmlPatternPtr(n_comp, comp, 0);
16827: des_xmlNodePtr(n_node, node, 1);
16828: xmlResetLastError();
16829: if (mem_base != xmlMemBlocks()) {
16830: printf("Leak of %d blocks found in xmlPatternMatch",
16831: xmlMemBlocks() - mem_base);
16832: test_ret++;
16833: printf(" %d", n_comp);
16834: printf(" %d", n_node);
16835: printf("\n");
16836: }
16837: }
16838: }
16839: function_tests++;
16840: #endif
16841:
16842: return(test_ret);
16843: }
16844:
16845:
16846: static int
16847: test_xmlPatternMaxDepth(void) {
16848: int test_ret = 0;
16849:
16850: #if defined(LIBXML_PATTERN_ENABLED)
16851: int mem_base;
16852: int ret_val;
16853: xmlPatternPtr comp; /* the precompiled pattern */
16854: int n_comp;
16855:
16856: for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) {
16857: mem_base = xmlMemBlocks();
16858: comp = gen_xmlPatternPtr(n_comp, 0);
16859:
16860: ret_val = xmlPatternMaxDepth(comp);
16861: desret_int(ret_val);
16862: call_tests++;
16863: des_xmlPatternPtr(n_comp, comp, 0);
16864: xmlResetLastError();
16865: if (mem_base != xmlMemBlocks()) {
16866: printf("Leak of %d blocks found in xmlPatternMaxDepth",
16867: xmlMemBlocks() - mem_base);
16868: test_ret++;
16869: printf(" %d", n_comp);
16870: printf("\n");
16871: }
16872: }
16873: function_tests++;
16874: #endif
16875:
16876: return(test_ret);
16877: }
16878:
16879:
16880: static int
16881: test_xmlPatternMinDepth(void) {
16882: int test_ret = 0;
16883:
16884: #if defined(LIBXML_PATTERN_ENABLED)
16885: int mem_base;
16886: int ret_val;
16887: xmlPatternPtr comp; /* the precompiled pattern */
16888: int n_comp;
16889:
16890: for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) {
16891: mem_base = xmlMemBlocks();
16892: comp = gen_xmlPatternPtr(n_comp, 0);
16893:
16894: ret_val = xmlPatternMinDepth(comp);
16895: desret_int(ret_val);
16896: call_tests++;
16897: des_xmlPatternPtr(n_comp, comp, 0);
16898: xmlResetLastError();
16899: if (mem_base != xmlMemBlocks()) {
16900: printf("Leak of %d blocks found in xmlPatternMinDepth",
16901: xmlMemBlocks() - mem_base);
16902: test_ret++;
16903: printf(" %d", n_comp);
16904: printf("\n");
16905: }
16906: }
16907: function_tests++;
16908: #endif
16909:
16910: return(test_ret);
16911: }
16912:
16913:
16914: static int
16915: test_xmlPatternStreamable(void) {
16916: int test_ret = 0;
16917:
16918: #if defined(LIBXML_PATTERN_ENABLED)
16919: int mem_base;
16920: int ret_val;
16921: xmlPatternPtr comp; /* the precompiled pattern */
16922: int n_comp;
16923:
16924: for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) {
16925: mem_base = xmlMemBlocks();
16926: comp = gen_xmlPatternPtr(n_comp, 0);
16927:
16928: ret_val = xmlPatternStreamable(comp);
16929: desret_int(ret_val);
16930: call_tests++;
16931: des_xmlPatternPtr(n_comp, comp, 0);
16932: xmlResetLastError();
16933: if (mem_base != xmlMemBlocks()) {
16934: printf("Leak of %d blocks found in xmlPatternStreamable",
16935: xmlMemBlocks() - mem_base);
16936: test_ret++;
16937: printf(" %d", n_comp);
16938: printf("\n");
16939: }
16940: }
16941: function_tests++;
16942: #endif
16943:
16944: return(test_ret);
16945: }
16946:
16947:
16948: static int
16949: test_xmlPatterncompile(void) {
16950: int test_ret = 0;
16951:
16952:
16953: /* missing type support */
16954: return(test_ret);
16955: }
16956:
16957: #ifdef LIBXML_PATTERN_ENABLED
16958:
16959: #define gen_nb_xmlStreamCtxtPtr 1
16960: static xmlStreamCtxtPtr gen_xmlStreamCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
16961: return(NULL);
16962: }
16963: static void des_xmlStreamCtxtPtr(int no ATTRIBUTE_UNUSED, xmlStreamCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
16964: }
16965: #endif
16966:
16967:
16968: static int
16969: test_xmlStreamPop(void) {
16970: int test_ret = 0;
16971:
16972: #if defined(LIBXML_PATTERN_ENABLED)
16973: int mem_base;
16974: int ret_val;
16975: xmlStreamCtxtPtr stream; /* the stream context */
16976: int n_stream;
16977:
16978: for (n_stream = 0;n_stream < gen_nb_xmlStreamCtxtPtr;n_stream++) {
16979: mem_base = xmlMemBlocks();
16980: stream = gen_xmlStreamCtxtPtr(n_stream, 0);
16981:
16982: ret_val = xmlStreamPop(stream);
16983: desret_int(ret_val);
16984: call_tests++;
16985: des_xmlStreamCtxtPtr(n_stream, stream, 0);
16986: xmlResetLastError();
16987: if (mem_base != xmlMemBlocks()) {
16988: printf("Leak of %d blocks found in xmlStreamPop",
16989: xmlMemBlocks() - mem_base);
16990: test_ret++;
16991: printf(" %d", n_stream);
16992: printf("\n");
16993: }
16994: }
16995: function_tests++;
16996: #endif
16997:
16998: return(test_ret);
16999: }
17000:
17001:
17002: static int
17003: test_xmlStreamPush(void) {
17004: int test_ret = 0;
17005:
17006: #if defined(LIBXML_PATTERN_ENABLED)
17007: int mem_base;
17008: int ret_val;
17009: xmlStreamCtxtPtr stream; /* the stream context */
17010: int n_stream;
17011: xmlChar * name; /* the current name */
17012: int n_name;
17013: xmlChar * ns; /* the namespace name */
17014: int n_ns;
17015:
17016: for (n_stream = 0;n_stream < gen_nb_xmlStreamCtxtPtr;n_stream++) {
17017: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
17018: for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) {
17019: mem_base = xmlMemBlocks();
17020: stream = gen_xmlStreamCtxtPtr(n_stream, 0);
17021: name = gen_const_xmlChar_ptr(n_name, 1);
17022: ns = gen_const_xmlChar_ptr(n_ns, 2);
17023:
17024: ret_val = xmlStreamPush(stream, (const xmlChar *)name, (const xmlChar *)ns);
17025: desret_int(ret_val);
17026: call_tests++;
17027: des_xmlStreamCtxtPtr(n_stream, stream, 0);
17028: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
17029: des_const_xmlChar_ptr(n_ns, (const xmlChar *)ns, 2);
17030: xmlResetLastError();
17031: if (mem_base != xmlMemBlocks()) {
17032: printf("Leak of %d blocks found in xmlStreamPush",
17033: xmlMemBlocks() - mem_base);
17034: test_ret++;
17035: printf(" %d", n_stream);
17036: printf(" %d", n_name);
17037: printf(" %d", n_ns);
17038: printf("\n");
17039: }
17040: }
17041: }
17042: }
17043: function_tests++;
17044: #endif
17045:
17046: return(test_ret);
17047: }
17048:
17049:
17050: static int
17051: test_xmlStreamPushAttr(void) {
17052: int test_ret = 0;
17053:
17054: #if defined(LIBXML_PATTERN_ENABLED)
17055: int mem_base;
17056: int ret_val;
17057: xmlStreamCtxtPtr stream; /* the stream context */
17058: int n_stream;
17059: xmlChar * name; /* the current name */
17060: int n_name;
17061: xmlChar * ns; /* the namespace name */
17062: int n_ns;
17063:
17064: for (n_stream = 0;n_stream < gen_nb_xmlStreamCtxtPtr;n_stream++) {
17065: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
17066: for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) {
17067: mem_base = xmlMemBlocks();
17068: stream = gen_xmlStreamCtxtPtr(n_stream, 0);
17069: name = gen_const_xmlChar_ptr(n_name, 1);
17070: ns = gen_const_xmlChar_ptr(n_ns, 2);
17071:
17072: ret_val = xmlStreamPushAttr(stream, (const xmlChar *)name, (const xmlChar *)ns);
17073: desret_int(ret_val);
17074: call_tests++;
17075: des_xmlStreamCtxtPtr(n_stream, stream, 0);
17076: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
17077: des_const_xmlChar_ptr(n_ns, (const xmlChar *)ns, 2);
17078: xmlResetLastError();
17079: if (mem_base != xmlMemBlocks()) {
17080: printf("Leak of %d blocks found in xmlStreamPushAttr",
17081: xmlMemBlocks() - mem_base);
17082: test_ret++;
17083: printf(" %d", n_stream);
17084: printf(" %d", n_name);
17085: printf(" %d", n_ns);
17086: printf("\n");
17087: }
17088: }
17089: }
17090: }
17091: function_tests++;
17092: #endif
17093:
17094: return(test_ret);
17095: }
17096:
17097:
17098: static int
17099: test_xmlStreamPushNode(void) {
17100: int test_ret = 0;
17101:
17102: #if defined(LIBXML_PATTERN_ENABLED)
17103: int mem_base;
17104: int ret_val;
17105: xmlStreamCtxtPtr stream; /* the stream context */
17106: int n_stream;
17107: xmlChar * name; /* the current name */
17108: int n_name;
17109: xmlChar * ns; /* the namespace name */
17110: int n_ns;
17111: int nodeType; /* the type of the node being pushed */
17112: int n_nodeType;
17113:
17114: for (n_stream = 0;n_stream < gen_nb_xmlStreamCtxtPtr;n_stream++) {
17115: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
17116: for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) {
17117: for (n_nodeType = 0;n_nodeType < gen_nb_int;n_nodeType++) {
17118: mem_base = xmlMemBlocks();
17119: stream = gen_xmlStreamCtxtPtr(n_stream, 0);
17120: name = gen_const_xmlChar_ptr(n_name, 1);
17121: ns = gen_const_xmlChar_ptr(n_ns, 2);
17122: nodeType = gen_int(n_nodeType, 3);
17123:
17124: ret_val = xmlStreamPushNode(stream, (const xmlChar *)name, (const xmlChar *)ns, nodeType);
17125: desret_int(ret_val);
17126: call_tests++;
17127: des_xmlStreamCtxtPtr(n_stream, stream, 0);
17128: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
17129: des_const_xmlChar_ptr(n_ns, (const xmlChar *)ns, 2);
17130: des_int(n_nodeType, nodeType, 3);
17131: xmlResetLastError();
17132: if (mem_base != xmlMemBlocks()) {
17133: printf("Leak of %d blocks found in xmlStreamPushNode",
17134: xmlMemBlocks() - mem_base);
17135: test_ret++;
17136: printf(" %d", n_stream);
17137: printf(" %d", n_name);
17138: printf(" %d", n_ns);
17139: printf(" %d", n_nodeType);
17140: printf("\n");
17141: }
17142: }
17143: }
17144: }
17145: }
17146: function_tests++;
17147: #endif
17148:
17149: return(test_ret);
17150: }
17151:
17152:
17153: static int
17154: test_xmlStreamWantsAnyNode(void) {
17155: int test_ret = 0;
17156:
17157: #if defined(LIBXML_PATTERN_ENABLED)
17158: int mem_base;
17159: int ret_val;
17160: xmlStreamCtxtPtr streamCtxt; /* the stream context */
17161: int n_streamCtxt;
17162:
17163: for (n_streamCtxt = 0;n_streamCtxt < gen_nb_xmlStreamCtxtPtr;n_streamCtxt++) {
17164: mem_base = xmlMemBlocks();
17165: streamCtxt = gen_xmlStreamCtxtPtr(n_streamCtxt, 0);
17166:
17167: ret_val = xmlStreamWantsAnyNode(streamCtxt);
17168: desret_int(ret_val);
17169: call_tests++;
17170: des_xmlStreamCtxtPtr(n_streamCtxt, streamCtxt, 0);
17171: xmlResetLastError();
17172: if (mem_base != xmlMemBlocks()) {
17173: printf("Leak of %d blocks found in xmlStreamWantsAnyNode",
17174: xmlMemBlocks() - mem_base);
17175: test_ret++;
17176: printf(" %d", n_streamCtxt);
17177: printf("\n");
17178: }
17179: }
17180: function_tests++;
17181: #endif
17182:
17183: return(test_ret);
17184: }
17185:
17186: static int
17187: test_pattern(void) {
17188: int test_ret = 0;
17189:
17190: if (quiet == 0) printf("Testing pattern : 10 of 15 functions ...\n");
17191: test_ret += test_xmlPatternFromRoot();
17192: test_ret += test_xmlPatternGetStreamCtxt();
17193: test_ret += test_xmlPatternMatch();
17194: test_ret += test_xmlPatternMaxDepth();
17195: test_ret += test_xmlPatternMinDepth();
17196: test_ret += test_xmlPatternStreamable();
17197: test_ret += test_xmlPatterncompile();
17198: test_ret += test_xmlStreamPop();
17199: test_ret += test_xmlStreamPush();
17200: test_ret += test_xmlStreamPushAttr();
17201: test_ret += test_xmlStreamPushNode();
17202: test_ret += test_xmlStreamWantsAnyNode();
17203:
17204: if (test_ret != 0)
17205: printf("Module pattern: %d errors\n", test_ret);
17206: return(test_ret);
17207: }
17208: #ifdef LIBXML_SCHEMAS_ENABLED
17209:
17210: #define gen_nb_xmlRelaxNGPtr 1
17211: static xmlRelaxNGPtr gen_xmlRelaxNGPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17212: return(NULL);
17213: }
17214: static void des_xmlRelaxNGPtr(int no ATTRIBUTE_UNUSED, xmlRelaxNGPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17215: }
17216: #endif
17217:
17218:
17219: static int
17220: test_xmlRelaxNGDump(void) {
17221: int test_ret = 0;
17222:
17223: #if defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
17224: int mem_base;
17225: FILE * output; /* the file output */
17226: int n_output;
17227: xmlRelaxNGPtr schema; /* a schema structure */
17228: int n_schema;
17229:
17230: for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
17231: for (n_schema = 0;n_schema < gen_nb_xmlRelaxNGPtr;n_schema++) {
17232: mem_base = xmlMemBlocks();
17233: output = gen_FILE_ptr(n_output, 0);
17234: schema = gen_xmlRelaxNGPtr(n_schema, 1);
17235:
17236: xmlRelaxNGDump(output, schema);
17237: call_tests++;
17238: des_FILE_ptr(n_output, output, 0);
17239: des_xmlRelaxNGPtr(n_schema, schema, 1);
17240: xmlResetLastError();
17241: if (mem_base != xmlMemBlocks()) {
17242: printf("Leak of %d blocks found in xmlRelaxNGDump",
17243: xmlMemBlocks() - mem_base);
17244: test_ret++;
17245: printf(" %d", n_output);
17246: printf(" %d", n_schema);
17247: printf("\n");
17248: }
17249: }
17250: }
17251: function_tests++;
17252: #endif
17253:
17254: return(test_ret);
17255: }
17256:
17257:
17258: static int
17259: test_xmlRelaxNGDumpTree(void) {
17260: int test_ret = 0;
17261:
17262: #if defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
17263: int mem_base;
17264: FILE * output; /* the file output */
17265: int n_output;
17266: xmlRelaxNGPtr schema; /* a schema structure */
17267: int n_schema;
17268:
17269: for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
17270: for (n_schema = 0;n_schema < gen_nb_xmlRelaxNGPtr;n_schema++) {
17271: mem_base = xmlMemBlocks();
17272: output = gen_FILE_ptr(n_output, 0);
17273: schema = gen_xmlRelaxNGPtr(n_schema, 1);
17274:
17275: xmlRelaxNGDumpTree(output, schema);
17276: call_tests++;
17277: des_FILE_ptr(n_output, output, 0);
17278: des_xmlRelaxNGPtr(n_schema, schema, 1);
17279: xmlResetLastError();
17280: if (mem_base != xmlMemBlocks()) {
17281: printf("Leak of %d blocks found in xmlRelaxNGDumpTree",
17282: xmlMemBlocks() - mem_base);
17283: test_ret++;
17284: printf(" %d", n_output);
17285: printf(" %d", n_schema);
17286: printf("\n");
17287: }
17288: }
17289: }
17290: function_tests++;
17291: #endif
17292:
17293: return(test_ret);
17294: }
17295:
17296: #ifdef LIBXML_SCHEMAS_ENABLED
17297:
17298: #define gen_nb_xmlRelaxNGParserCtxtPtr 1
17299: static xmlRelaxNGParserCtxtPtr gen_xmlRelaxNGParserCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17300: return(NULL);
17301: }
17302: static void des_xmlRelaxNGParserCtxtPtr(int no ATTRIBUTE_UNUSED, xmlRelaxNGParserCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17303: }
17304: #endif
17305:
17306: #ifdef LIBXML_SCHEMAS_ENABLED
17307:
17308: #define gen_nb_xmlRelaxNGValidityErrorFunc_ptr 1
17309: static xmlRelaxNGValidityErrorFunc * gen_xmlRelaxNGValidityErrorFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17310: return(NULL);
17311: }
17312: static void des_xmlRelaxNGValidityErrorFunc_ptr(int no ATTRIBUTE_UNUSED, xmlRelaxNGValidityErrorFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17313: }
17314: #endif
17315:
17316: #ifdef LIBXML_SCHEMAS_ENABLED
17317:
17318: #define gen_nb_xmlRelaxNGValidityWarningFunc_ptr 1
17319: static xmlRelaxNGValidityWarningFunc * gen_xmlRelaxNGValidityWarningFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17320: return(NULL);
17321: }
17322: static void des_xmlRelaxNGValidityWarningFunc_ptr(int no ATTRIBUTE_UNUSED, xmlRelaxNGValidityWarningFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17323: }
17324: #endif
17325:
17326:
17327: static int
17328: test_xmlRelaxNGGetParserErrors(void) {
17329: int test_ret = 0;
17330:
17331: #if defined(LIBXML_SCHEMAS_ENABLED)
17332: int mem_base;
17333: int ret_val;
17334: xmlRelaxNGParserCtxtPtr ctxt; /* a Relax-NG validation context */
17335: int n_ctxt;
17336: xmlRelaxNGValidityErrorFunc * err; /* the error callback result */
17337: int n_err;
17338: xmlRelaxNGValidityWarningFunc * warn; /* the warning callback result */
17339: int n_warn;
17340: void ** ctx; /* contextual data for the callbacks result */
17341: int n_ctx;
17342:
17343: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGParserCtxtPtr;n_ctxt++) {
17344: for (n_err = 0;n_err < gen_nb_xmlRelaxNGValidityErrorFunc_ptr;n_err++) {
17345: for (n_warn = 0;n_warn < gen_nb_xmlRelaxNGValidityWarningFunc_ptr;n_warn++) {
17346: for (n_ctx = 0;n_ctx < gen_nb_void_ptr_ptr;n_ctx++) {
17347: mem_base = xmlMemBlocks();
17348: ctxt = gen_xmlRelaxNGParserCtxtPtr(n_ctxt, 0);
17349: err = gen_xmlRelaxNGValidityErrorFunc_ptr(n_err, 1);
17350: warn = gen_xmlRelaxNGValidityWarningFunc_ptr(n_warn, 2);
17351: ctx = gen_void_ptr_ptr(n_ctx, 3);
17352:
17353: ret_val = xmlRelaxNGGetParserErrors(ctxt, err, warn, ctx);
17354: desret_int(ret_val);
17355: call_tests++;
17356: des_xmlRelaxNGParserCtxtPtr(n_ctxt, ctxt, 0);
17357: des_xmlRelaxNGValidityErrorFunc_ptr(n_err, err, 1);
17358: des_xmlRelaxNGValidityWarningFunc_ptr(n_warn, warn, 2);
17359: des_void_ptr_ptr(n_ctx, ctx, 3);
17360: xmlResetLastError();
17361: if (mem_base != xmlMemBlocks()) {
17362: printf("Leak of %d blocks found in xmlRelaxNGGetParserErrors",
17363: xmlMemBlocks() - mem_base);
17364: test_ret++;
17365: printf(" %d", n_ctxt);
17366: printf(" %d", n_err);
17367: printf(" %d", n_warn);
17368: printf(" %d", n_ctx);
17369: printf("\n");
17370: }
17371: }
17372: }
17373: }
17374: }
17375: function_tests++;
17376: #endif
17377:
17378: return(test_ret);
17379: }
17380:
17381: #ifdef LIBXML_SCHEMAS_ENABLED
17382:
17383: #define gen_nb_xmlRelaxNGValidCtxtPtr 1
17384: static xmlRelaxNGValidCtxtPtr gen_xmlRelaxNGValidCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17385: return(NULL);
17386: }
17387: static void des_xmlRelaxNGValidCtxtPtr(int no ATTRIBUTE_UNUSED, xmlRelaxNGValidCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17388: }
17389: #endif
17390:
17391:
17392: static int
17393: test_xmlRelaxNGGetValidErrors(void) {
17394: int test_ret = 0;
17395:
17396: #if defined(LIBXML_SCHEMAS_ENABLED)
17397: int mem_base;
17398: int ret_val;
17399: xmlRelaxNGValidCtxtPtr ctxt; /* a Relax-NG validation context */
17400: int n_ctxt;
17401: xmlRelaxNGValidityErrorFunc * err; /* the error function result */
17402: int n_err;
17403: xmlRelaxNGValidityWarningFunc * warn; /* the warning function result */
17404: int n_warn;
17405: void ** ctx; /* the functions context result */
17406: int n_ctx;
17407:
17408: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
17409: for (n_err = 0;n_err < gen_nb_xmlRelaxNGValidityErrorFunc_ptr;n_err++) {
17410: for (n_warn = 0;n_warn < gen_nb_xmlRelaxNGValidityWarningFunc_ptr;n_warn++) {
17411: for (n_ctx = 0;n_ctx < gen_nb_void_ptr_ptr;n_ctx++) {
17412: mem_base = xmlMemBlocks();
17413: ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
17414: err = gen_xmlRelaxNGValidityErrorFunc_ptr(n_err, 1);
17415: warn = gen_xmlRelaxNGValidityWarningFunc_ptr(n_warn, 2);
17416: ctx = gen_void_ptr_ptr(n_ctx, 3);
17417:
17418: ret_val = xmlRelaxNGGetValidErrors(ctxt, err, warn, ctx);
17419: desret_int(ret_val);
17420: call_tests++;
17421: des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
17422: des_xmlRelaxNGValidityErrorFunc_ptr(n_err, err, 1);
17423: des_xmlRelaxNGValidityWarningFunc_ptr(n_warn, warn, 2);
17424: des_void_ptr_ptr(n_ctx, ctx, 3);
17425: xmlResetLastError();
17426: if (mem_base != xmlMemBlocks()) {
17427: printf("Leak of %d blocks found in xmlRelaxNGGetValidErrors",
17428: xmlMemBlocks() - mem_base);
17429: test_ret++;
17430: printf(" %d", n_ctxt);
17431: printf(" %d", n_err);
17432: printf(" %d", n_warn);
17433: printf(" %d", n_ctx);
17434: printf("\n");
17435: }
17436: }
17437: }
17438: }
17439: }
17440: function_tests++;
17441: #endif
17442:
17443: return(test_ret);
17444: }
17445:
17446:
17447: static int
17448: test_xmlRelaxNGInitTypes(void) {
17449: int test_ret = 0;
17450:
17451: #if defined(LIBXML_SCHEMAS_ENABLED)
17452: int mem_base;
17453: int ret_val;
17454:
17455: mem_base = xmlMemBlocks();
17456:
17457: ret_val = xmlRelaxNGInitTypes();
17458: desret_int(ret_val);
17459: call_tests++;
17460: xmlResetLastError();
17461: if (mem_base != xmlMemBlocks()) {
17462: printf("Leak of %d blocks found in xmlRelaxNGInitTypes",
17463: xmlMemBlocks() - mem_base);
17464: test_ret++;
17465: printf("\n");
17466: }
17467: function_tests++;
17468: #endif
17469:
17470: return(test_ret);
17471: }
17472:
17473:
17474: static int
17475: test_xmlRelaxNGNewDocParserCtxt(void) {
17476: int test_ret = 0;
17477:
17478: #if defined(LIBXML_SCHEMAS_ENABLED)
17479: int mem_base;
17480: xmlRelaxNGParserCtxtPtr ret_val;
17481: xmlDocPtr doc; /* a preparsed document tree */
17482: int n_doc;
17483:
17484: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
17485: mem_base = xmlMemBlocks();
17486: doc = gen_xmlDocPtr(n_doc, 0);
17487:
17488: ret_val = xmlRelaxNGNewDocParserCtxt(doc);
17489: desret_xmlRelaxNGParserCtxtPtr(ret_val);
17490: call_tests++;
17491: des_xmlDocPtr(n_doc, doc, 0);
17492: xmlResetLastError();
17493: if (mem_base != xmlMemBlocks()) {
17494: printf("Leak of %d blocks found in xmlRelaxNGNewDocParserCtxt",
17495: xmlMemBlocks() - mem_base);
17496: test_ret++;
17497: printf(" %d", n_doc);
17498: printf("\n");
17499: }
17500: }
17501: function_tests++;
17502: #endif
17503:
17504: return(test_ret);
17505: }
17506:
17507:
17508: static int
17509: test_xmlRelaxNGNewMemParserCtxt(void) {
17510: int test_ret = 0;
17511:
17512: #if defined(LIBXML_SCHEMAS_ENABLED)
17513: int mem_base;
17514: xmlRelaxNGParserCtxtPtr ret_val;
17515: char * buffer; /* a pointer to a char array containing the schemas */
17516: int n_buffer;
17517: int size; /* the size of the array */
17518: int n_size;
17519:
17520: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
17521: for (n_size = 0;n_size < gen_nb_int;n_size++) {
17522: mem_base = xmlMemBlocks();
17523: buffer = gen_const_char_ptr(n_buffer, 0);
17524: size = gen_int(n_size, 1);
17525:
17526: ret_val = xmlRelaxNGNewMemParserCtxt((const char *)buffer, size);
17527: desret_xmlRelaxNGParserCtxtPtr(ret_val);
17528: call_tests++;
17529: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
17530: des_int(n_size, size, 1);
17531: xmlResetLastError();
17532: if (mem_base != xmlMemBlocks()) {
17533: printf("Leak of %d blocks found in xmlRelaxNGNewMemParserCtxt",
17534: xmlMemBlocks() - mem_base);
17535: test_ret++;
17536: printf(" %d", n_buffer);
17537: printf(" %d", n_size);
17538: printf("\n");
17539: }
17540: }
17541: }
17542: function_tests++;
17543: #endif
17544:
17545: return(test_ret);
17546: }
17547:
17548:
17549: static int
17550: test_xmlRelaxNGNewParserCtxt(void) {
17551: int test_ret = 0;
17552:
17553: #if defined(LIBXML_SCHEMAS_ENABLED)
17554: int mem_base;
17555: xmlRelaxNGParserCtxtPtr ret_val;
17556: char * URL; /* the location of the schema */
17557: int n_URL;
17558:
17559: for (n_URL = 0;n_URL < gen_nb_const_char_ptr;n_URL++) {
17560: mem_base = xmlMemBlocks();
17561: URL = gen_const_char_ptr(n_URL, 0);
17562:
17563: ret_val = xmlRelaxNGNewParserCtxt((const char *)URL);
17564: desret_xmlRelaxNGParserCtxtPtr(ret_val);
17565: call_tests++;
17566: des_const_char_ptr(n_URL, (const char *)URL, 0);
17567: xmlResetLastError();
17568: if (mem_base != xmlMemBlocks()) {
17569: printf("Leak of %d blocks found in xmlRelaxNGNewParserCtxt",
17570: xmlMemBlocks() - mem_base);
17571: test_ret++;
17572: printf(" %d", n_URL);
17573: printf("\n");
17574: }
17575: }
17576: function_tests++;
17577: #endif
17578:
17579: return(test_ret);
17580: }
17581:
17582:
17583: static int
17584: test_xmlRelaxNGNewValidCtxt(void) {
17585: int test_ret = 0;
17586:
17587:
17588: /* missing type support */
17589: return(test_ret);
17590: }
17591:
17592:
17593: static int
17594: test_xmlRelaxNGParse(void) {
17595: int test_ret = 0;
17596:
17597:
17598: /* missing type support */
17599: return(test_ret);
17600: }
17601:
17602:
17603: static int
17604: test_xmlRelaxNGSetParserErrors(void) {
17605: int test_ret = 0;
17606:
17607:
17608: /* missing type support */
17609: return(test_ret);
17610: }
17611:
17612:
17613: static int
17614: test_xmlRelaxNGSetParserStructuredErrors(void) {
17615: int test_ret = 0;
17616:
17617:
17618: /* missing type support */
17619: return(test_ret);
17620: }
17621:
17622:
17623: static int
17624: test_xmlRelaxNGSetValidErrors(void) {
17625: int test_ret = 0;
17626:
17627:
17628: /* missing type support */
17629: return(test_ret);
17630: }
17631:
17632:
17633: static int
17634: test_xmlRelaxNGSetValidStructuredErrors(void) {
17635: int test_ret = 0;
17636:
17637:
17638: /* missing type support */
17639: return(test_ret);
17640: }
17641:
17642:
17643: static int
17644: test_xmlRelaxNGValidateDoc(void) {
17645: int test_ret = 0;
17646:
17647: #if defined(LIBXML_SCHEMAS_ENABLED)
17648: int mem_base;
17649: int ret_val;
17650: xmlRelaxNGValidCtxtPtr ctxt; /* a Relax-NG validation context */
17651: int n_ctxt;
17652: xmlDocPtr doc; /* a parsed document tree */
17653: int n_doc;
17654:
17655: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
17656: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
17657: mem_base = xmlMemBlocks();
17658: ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
17659: doc = gen_xmlDocPtr(n_doc, 1);
17660:
17661: ret_val = xmlRelaxNGValidateDoc(ctxt, doc);
17662: desret_int(ret_val);
17663: call_tests++;
17664: des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
17665: des_xmlDocPtr(n_doc, doc, 1);
17666: xmlResetLastError();
17667: if (mem_base != xmlMemBlocks()) {
17668: printf("Leak of %d blocks found in xmlRelaxNGValidateDoc",
17669: xmlMemBlocks() - mem_base);
17670: test_ret++;
17671: printf(" %d", n_ctxt);
17672: printf(" %d", n_doc);
17673: printf("\n");
17674: }
17675: }
17676: }
17677: function_tests++;
17678: #endif
17679:
17680: return(test_ret);
17681: }
17682:
17683:
17684: static int
17685: test_xmlRelaxNGValidateFullElement(void) {
17686: int test_ret = 0;
17687:
17688: #if defined(LIBXML_SCHEMAS_ENABLED)
17689: int mem_base;
17690: int ret_val;
17691: xmlRelaxNGValidCtxtPtr ctxt; /* the validation context */
17692: int n_ctxt;
17693: xmlDocPtr doc; /* a document instance */
17694: int n_doc;
17695: xmlNodePtr elem; /* an element instance */
17696: int n_elem;
17697:
17698: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
17699: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
17700: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
17701: mem_base = xmlMemBlocks();
17702: ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
17703: doc = gen_xmlDocPtr(n_doc, 1);
17704: elem = gen_xmlNodePtr(n_elem, 2);
17705:
17706: ret_val = xmlRelaxNGValidateFullElement(ctxt, doc, elem);
17707: desret_int(ret_val);
17708: call_tests++;
17709: des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
17710: des_xmlDocPtr(n_doc, doc, 1);
17711: des_xmlNodePtr(n_elem, elem, 2);
17712: xmlResetLastError();
17713: if (mem_base != xmlMemBlocks()) {
17714: printf("Leak of %d blocks found in xmlRelaxNGValidateFullElement",
17715: xmlMemBlocks() - mem_base);
17716: test_ret++;
17717: printf(" %d", n_ctxt);
17718: printf(" %d", n_doc);
17719: printf(" %d", n_elem);
17720: printf("\n");
17721: }
17722: }
17723: }
17724: }
17725: function_tests++;
17726: #endif
17727:
17728: return(test_ret);
17729: }
17730:
17731:
17732: static int
17733: test_xmlRelaxNGValidatePopElement(void) {
17734: int test_ret = 0;
17735:
17736: #if defined(LIBXML_SCHEMAS_ENABLED)
17737: int mem_base;
17738: int ret_val;
17739: xmlRelaxNGValidCtxtPtr ctxt; /* the RelaxNG validation context */
17740: int n_ctxt;
17741: xmlDocPtr doc; /* a document instance */
17742: int n_doc;
17743: xmlNodePtr elem; /* an element instance */
17744: int n_elem;
17745:
17746: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
17747: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
17748: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
17749: mem_base = xmlMemBlocks();
17750: ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
17751: doc = gen_xmlDocPtr(n_doc, 1);
17752: elem = gen_xmlNodePtr(n_elem, 2);
17753:
17754: ret_val = xmlRelaxNGValidatePopElement(ctxt, doc, elem);
17755: desret_int(ret_val);
17756: call_tests++;
17757: des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
17758: des_xmlDocPtr(n_doc, doc, 1);
17759: des_xmlNodePtr(n_elem, elem, 2);
17760: xmlResetLastError();
17761: if (mem_base != xmlMemBlocks()) {
17762: printf("Leak of %d blocks found in xmlRelaxNGValidatePopElement",
17763: xmlMemBlocks() - mem_base);
17764: test_ret++;
17765: printf(" %d", n_ctxt);
17766: printf(" %d", n_doc);
17767: printf(" %d", n_elem);
17768: printf("\n");
17769: }
17770: }
17771: }
17772: }
17773: function_tests++;
17774: #endif
17775:
17776: return(test_ret);
17777: }
17778:
17779:
17780: static int
17781: test_xmlRelaxNGValidatePushCData(void) {
17782: int test_ret = 0;
17783:
17784: #if defined(LIBXML_SCHEMAS_ENABLED)
17785: int mem_base;
17786: int ret_val;
17787: xmlRelaxNGValidCtxtPtr ctxt; /* the RelaxNG validation context */
17788: int n_ctxt;
17789: xmlChar * data; /* some character data read */
17790: int n_data;
17791: int len; /* the lenght of the data */
17792: int n_len;
17793:
17794: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
17795: for (n_data = 0;n_data < gen_nb_const_xmlChar_ptr;n_data++) {
17796: for (n_len = 0;n_len < gen_nb_int;n_len++) {
17797: mem_base = xmlMemBlocks();
17798: ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
17799: data = gen_const_xmlChar_ptr(n_data, 1);
17800: len = gen_int(n_len, 2);
17801:
17802: ret_val = xmlRelaxNGValidatePushCData(ctxt, (const xmlChar *)data, len);
17803: desret_int(ret_val);
17804: call_tests++;
17805: des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
17806: des_const_xmlChar_ptr(n_data, (const xmlChar *)data, 1);
17807: des_int(n_len, len, 2);
17808: xmlResetLastError();
17809: if (mem_base != xmlMemBlocks()) {
17810: printf("Leak of %d blocks found in xmlRelaxNGValidatePushCData",
17811: xmlMemBlocks() - mem_base);
17812: test_ret++;
17813: printf(" %d", n_ctxt);
17814: printf(" %d", n_data);
17815: printf(" %d", n_len);
17816: printf("\n");
17817: }
17818: }
17819: }
17820: }
17821: function_tests++;
17822: #endif
17823:
17824: return(test_ret);
17825: }
17826:
17827:
17828: static int
17829: test_xmlRelaxNGValidatePushElement(void) {
17830: int test_ret = 0;
17831:
17832: #if defined(LIBXML_SCHEMAS_ENABLED)
17833: int mem_base;
17834: int ret_val;
17835: xmlRelaxNGValidCtxtPtr ctxt; /* the validation context */
17836: int n_ctxt;
17837: xmlDocPtr doc; /* a document instance */
17838: int n_doc;
17839: xmlNodePtr elem; /* an element instance */
17840: int n_elem;
17841:
17842: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
17843: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
17844: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
17845: mem_base = xmlMemBlocks();
17846: ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
17847: doc = gen_xmlDocPtr(n_doc, 1);
17848: elem = gen_xmlNodePtr(n_elem, 2);
17849:
17850: ret_val = xmlRelaxNGValidatePushElement(ctxt, doc, elem);
17851: desret_int(ret_val);
17852: call_tests++;
17853: des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
17854: des_xmlDocPtr(n_doc, doc, 1);
17855: des_xmlNodePtr(n_elem, elem, 2);
17856: xmlResetLastError();
17857: if (mem_base != xmlMemBlocks()) {
17858: printf("Leak of %d blocks found in xmlRelaxNGValidatePushElement",
17859: xmlMemBlocks() - mem_base);
17860: test_ret++;
17861: printf(" %d", n_ctxt);
17862: printf(" %d", n_doc);
17863: printf(" %d", n_elem);
17864: printf("\n");
17865: }
17866: }
17867: }
17868: }
17869: function_tests++;
17870: #endif
17871:
17872: return(test_ret);
17873: }
17874:
17875:
17876: static int
17877: test_xmlRelaxParserSetFlag(void) {
17878: int test_ret = 0;
17879:
17880: #if defined(LIBXML_SCHEMAS_ENABLED)
17881: int mem_base;
17882: int ret_val;
17883: xmlRelaxNGParserCtxtPtr ctxt; /* a RelaxNG parser context */
17884: int n_ctxt;
17885: int flags; /* a set of flags values */
17886: int n_flags;
17887:
17888: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGParserCtxtPtr;n_ctxt++) {
17889: for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
17890: mem_base = xmlMemBlocks();
17891: ctxt = gen_xmlRelaxNGParserCtxtPtr(n_ctxt, 0);
17892: flags = gen_int(n_flags, 1);
17893:
17894: ret_val = xmlRelaxParserSetFlag(ctxt, flags);
17895: desret_int(ret_val);
17896: call_tests++;
17897: des_xmlRelaxNGParserCtxtPtr(n_ctxt, ctxt, 0);
17898: des_int(n_flags, flags, 1);
17899: xmlResetLastError();
17900: if (mem_base != xmlMemBlocks()) {
17901: printf("Leak of %d blocks found in xmlRelaxParserSetFlag",
17902: xmlMemBlocks() - mem_base);
17903: test_ret++;
17904: printf(" %d", n_ctxt);
17905: printf(" %d", n_flags);
17906: printf("\n");
17907: }
17908: }
17909: }
17910: function_tests++;
17911: #endif
17912:
17913: return(test_ret);
17914: }
17915:
17916: static int
17917: test_relaxng(void) {
17918: int test_ret = 0;
17919:
17920: if (quiet == 0) printf("Testing relaxng : 14 of 24 functions ...\n");
17921: test_ret += test_xmlRelaxNGDump();
17922: test_ret += test_xmlRelaxNGDumpTree();
17923: test_ret += test_xmlRelaxNGGetParserErrors();
17924: test_ret += test_xmlRelaxNGGetValidErrors();
17925: test_ret += test_xmlRelaxNGInitTypes();
17926: test_ret += test_xmlRelaxNGNewDocParserCtxt();
17927: test_ret += test_xmlRelaxNGNewMemParserCtxt();
17928: test_ret += test_xmlRelaxNGNewParserCtxt();
17929: test_ret += test_xmlRelaxNGNewValidCtxt();
17930: test_ret += test_xmlRelaxNGParse();
17931: test_ret += test_xmlRelaxNGSetParserErrors();
17932: test_ret += test_xmlRelaxNGSetParserStructuredErrors();
17933: test_ret += test_xmlRelaxNGSetValidErrors();
17934: test_ret += test_xmlRelaxNGSetValidStructuredErrors();
17935: test_ret += test_xmlRelaxNGValidateDoc();
17936: test_ret += test_xmlRelaxNGValidateFullElement();
17937: test_ret += test_xmlRelaxNGValidatePopElement();
17938: test_ret += test_xmlRelaxNGValidatePushCData();
17939: test_ret += test_xmlRelaxNGValidatePushElement();
17940: test_ret += test_xmlRelaxParserSetFlag();
17941:
17942: if (test_ret != 0)
17943: printf("Module relaxng: %d errors\n", test_ret);
17944: return(test_ret);
17945: }
17946: static int
17947: test_schemasInternals(void) {
17948: int test_ret = 0;
17949:
17950: if (quiet == 0) printf("Testing schemasInternals : 0 of 2 functions ...\n");
17951:
17952: if (test_ret != 0)
17953: printf("Module schemasInternals: %d errors\n", test_ret);
17954: return(test_ret);
17955: }
17956:
17957: static int
17958: test_xmlSchematronNewDocParserCtxt(void) {
17959: int test_ret = 0;
17960:
17961:
17962: /* missing type support */
17963: return(test_ret);
17964: }
17965:
17966:
17967: static int
17968: test_xmlSchematronNewMemParserCtxt(void) {
17969: int test_ret = 0;
17970:
17971:
17972: /* missing type support */
17973: return(test_ret);
17974: }
17975:
17976:
17977: static int
17978: test_xmlSchematronNewParserCtxt(void) {
17979: int test_ret = 0;
17980:
17981:
17982: /* missing type support */
17983: return(test_ret);
17984: }
17985:
17986: #ifdef LIBXML_SCHEMATRON_ENABLED
17987:
17988: #define gen_nb_xmlSchematronPtr 1
17989: static xmlSchematronPtr gen_xmlSchematronPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17990: return(NULL);
17991: }
17992: static void des_xmlSchematronPtr(int no ATTRIBUTE_UNUSED, xmlSchematronPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17993: }
17994: #endif
17995:
17996:
17997: static int
17998: test_xmlSchematronNewValidCtxt(void) {
17999: int test_ret = 0;
18000:
18001:
18002: /* missing type support */
18003: return(test_ret);
18004: }
18005:
18006: #ifdef LIBXML_SCHEMATRON_ENABLED
18007:
18008: #define gen_nb_xmlSchematronParserCtxtPtr 1
18009: static xmlSchematronParserCtxtPtr gen_xmlSchematronParserCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
18010: return(NULL);
18011: }
18012: static void des_xmlSchematronParserCtxtPtr(int no ATTRIBUTE_UNUSED, xmlSchematronParserCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
18013: }
18014: #endif
18015:
18016:
18017: static int
18018: test_xmlSchematronParse(void) {
18019: int test_ret = 0;
18020:
18021:
18022: /* missing type support */
18023: return(test_ret);
18024: }
18025:
18026: #ifdef LIBXML_SCHEMATRON_ENABLED
18027:
18028: #define gen_nb_xmlSchematronValidCtxtPtr 1
18029: static xmlSchematronValidCtxtPtr gen_xmlSchematronValidCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
18030: return(NULL);
18031: }
18032: static void des_xmlSchematronValidCtxtPtr(int no ATTRIBUTE_UNUSED, xmlSchematronValidCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
18033: }
18034: #endif
18035:
18036:
18037: static int
18038: test_xmlSchematronSetValidStructuredErrors(void) {
18039: int test_ret = 0;
18040:
18041:
18042: /* missing type support */
18043: return(test_ret);
18044: }
18045:
18046:
18047: static int
18048: test_xmlSchematronValidateDoc(void) {
18049: int test_ret = 0;
18050:
18051: #if defined(LIBXML_SCHEMATRON_ENABLED)
18052: int mem_base;
18053: int ret_val;
18054: xmlSchematronValidCtxtPtr ctxt; /* the schema validation context */
18055: int n_ctxt;
18056: xmlDocPtr instance; /* the document instace tree */
18057: int n_instance;
18058:
18059: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchematronValidCtxtPtr;n_ctxt++) {
18060: for (n_instance = 0;n_instance < gen_nb_xmlDocPtr;n_instance++) {
18061: mem_base = xmlMemBlocks();
18062: ctxt = gen_xmlSchematronValidCtxtPtr(n_ctxt, 0);
18063: instance = gen_xmlDocPtr(n_instance, 1);
18064:
18065: ret_val = xmlSchematronValidateDoc(ctxt, instance);
18066: desret_int(ret_val);
18067: call_tests++;
18068: des_xmlSchematronValidCtxtPtr(n_ctxt, ctxt, 0);
18069: des_xmlDocPtr(n_instance, instance, 1);
18070: xmlResetLastError();
18071: if (mem_base != xmlMemBlocks()) {
18072: printf("Leak of %d blocks found in xmlSchematronValidateDoc",
18073: xmlMemBlocks() - mem_base);
18074: test_ret++;
18075: printf(" %d", n_ctxt);
18076: printf(" %d", n_instance);
18077: printf("\n");
18078: }
18079: }
18080: }
18081: function_tests++;
18082: #endif
18083:
18084: return(test_ret);
18085: }
18086:
18087: static int
18088: test_schematron(void) {
18089: int test_ret = 0;
18090:
18091: if (quiet == 0) printf("Testing schematron : 1 of 10 functions ...\n");
18092: test_ret += test_xmlSchematronNewDocParserCtxt();
18093: test_ret += test_xmlSchematronNewMemParserCtxt();
18094: test_ret += test_xmlSchematronNewParserCtxt();
18095: test_ret += test_xmlSchematronNewValidCtxt();
18096: test_ret += test_xmlSchematronParse();
18097: test_ret += test_xmlSchematronSetValidStructuredErrors();
18098: test_ret += test_xmlSchematronValidateDoc();
18099:
18100: if (test_ret != 0)
18101: printf("Module schematron: %d errors\n", test_ret);
18102: return(test_ret);
18103: }
18104:
18105: static int
18106: test_xmlAddChild(void) {
18107: int test_ret = 0;
18108:
18109: int mem_base;
18110: xmlNodePtr ret_val;
18111: xmlNodePtr parent; /* the parent node */
18112: int n_parent;
18113: xmlNodePtr cur; /* the child node */
18114: int n_cur;
18115:
18116: for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
18117: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr_in;n_cur++) {
18118: mem_base = xmlMemBlocks();
18119: parent = gen_xmlNodePtr(n_parent, 0);
18120: cur = gen_xmlNodePtr_in(n_cur, 1);
18121:
18122: ret_val = xmlAddChild(parent, cur);
18123: if (ret_val == NULL) { xmlFreeNode(cur) ; cur = NULL ; }
18124: desret_xmlNodePtr(ret_val);
18125: call_tests++;
18126: des_xmlNodePtr(n_parent, parent, 0);
18127: des_xmlNodePtr_in(n_cur, cur, 1);
18128: xmlResetLastError();
18129: if (mem_base != xmlMemBlocks()) {
18130: printf("Leak of %d blocks found in xmlAddChild",
18131: xmlMemBlocks() - mem_base);
18132: test_ret++;
18133: printf(" %d", n_parent);
18134: printf(" %d", n_cur);
18135: printf("\n");
18136: }
18137: }
18138: }
18139: function_tests++;
18140:
18141: return(test_ret);
18142: }
18143:
18144:
18145: static int
18146: test_xmlAddChildList(void) {
18147: int test_ret = 0;
18148:
18149: int mem_base;
18150: xmlNodePtr ret_val;
18151: xmlNodePtr parent; /* the parent node */
18152: int n_parent;
18153: xmlNodePtr cur; /* the first node in the list */
18154: int n_cur;
18155:
18156: for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
18157: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr_in;n_cur++) {
18158: mem_base = xmlMemBlocks();
18159: parent = gen_xmlNodePtr(n_parent, 0);
18160: cur = gen_xmlNodePtr_in(n_cur, 1);
18161:
18162: ret_val = xmlAddChildList(parent, cur);
18163: if (ret_val == NULL) { xmlFreeNodeList(cur) ; cur = NULL ; }
18164: desret_xmlNodePtr(ret_val);
18165: call_tests++;
18166: des_xmlNodePtr(n_parent, parent, 0);
18167: des_xmlNodePtr_in(n_cur, cur, 1);
18168: xmlResetLastError();
18169: if (mem_base != xmlMemBlocks()) {
18170: printf("Leak of %d blocks found in xmlAddChildList",
18171: xmlMemBlocks() - mem_base);
18172: test_ret++;
18173: printf(" %d", n_parent);
18174: printf(" %d", n_cur);
18175: printf("\n");
18176: }
18177: }
18178: }
18179: function_tests++;
18180:
18181: return(test_ret);
18182: }
18183:
18184:
18185: static int
18186: test_xmlAddNextSibling(void) {
18187: int test_ret = 0;
18188:
18189: int mem_base;
18190: xmlNodePtr ret_val;
18191: xmlNodePtr cur; /* the child node */
18192: int n_cur;
18193: xmlNodePtr elem; /* the new node */
18194: int n_elem;
18195:
18196: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
18197: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr_in;n_elem++) {
18198: mem_base = xmlMemBlocks();
18199: cur = gen_xmlNodePtr(n_cur, 0);
18200: elem = gen_xmlNodePtr_in(n_elem, 1);
18201:
18202: ret_val = xmlAddNextSibling(cur, elem);
18203: if (ret_val == NULL) { xmlFreeNode(elem) ; elem = NULL ; }
18204: desret_xmlNodePtr(ret_val);
18205: call_tests++;
18206: des_xmlNodePtr(n_cur, cur, 0);
18207: des_xmlNodePtr_in(n_elem, elem, 1);
18208: xmlResetLastError();
18209: if (mem_base != xmlMemBlocks()) {
18210: printf("Leak of %d blocks found in xmlAddNextSibling",
18211: xmlMemBlocks() - mem_base);
18212: test_ret++;
18213: printf(" %d", n_cur);
18214: printf(" %d", n_elem);
18215: printf("\n");
18216: }
18217: }
18218: }
18219: function_tests++;
18220:
18221: return(test_ret);
18222: }
18223:
18224:
18225: static int
18226: test_xmlAddPrevSibling(void) {
18227: int test_ret = 0;
18228:
18229: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
18230: int mem_base;
18231: xmlNodePtr ret_val;
18232: xmlNodePtr cur; /* the child node */
18233: int n_cur;
18234: xmlNodePtr elem; /* the new node */
18235: int n_elem;
18236:
18237: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
18238: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr_in;n_elem++) {
18239: mem_base = xmlMemBlocks();
18240: cur = gen_xmlNodePtr(n_cur, 0);
18241: elem = gen_xmlNodePtr_in(n_elem, 1);
18242:
18243: ret_val = xmlAddPrevSibling(cur, elem);
18244: if (ret_val == NULL) { xmlFreeNode(elem) ; elem = NULL ; }
18245: desret_xmlNodePtr(ret_val);
18246: call_tests++;
18247: des_xmlNodePtr(n_cur, cur, 0);
18248: des_xmlNodePtr_in(n_elem, elem, 1);
18249: xmlResetLastError();
18250: if (mem_base != xmlMemBlocks()) {
18251: printf("Leak of %d blocks found in xmlAddPrevSibling",
18252: xmlMemBlocks() - mem_base);
18253: test_ret++;
18254: printf(" %d", n_cur);
18255: printf(" %d", n_elem);
18256: printf("\n");
18257: }
18258: }
18259: }
18260: function_tests++;
18261: #endif
18262:
18263: return(test_ret);
18264: }
18265:
18266:
18267: static int
18268: test_xmlAddSibling(void) {
18269: int test_ret = 0;
18270:
18271: int mem_base;
18272: xmlNodePtr ret_val;
18273: xmlNodePtr cur; /* the child node */
18274: int n_cur;
18275: xmlNodePtr elem; /* the new node */
18276: int n_elem;
18277:
18278: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
18279: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr_in;n_elem++) {
18280: mem_base = xmlMemBlocks();
18281: cur = gen_xmlNodePtr(n_cur, 0);
18282: elem = gen_xmlNodePtr_in(n_elem, 1);
18283:
18284: ret_val = xmlAddSibling(cur, elem);
18285: if (ret_val == NULL) { xmlFreeNode(elem) ; elem = NULL ; }
18286: desret_xmlNodePtr(ret_val);
18287: call_tests++;
18288: des_xmlNodePtr(n_cur, cur, 0);
18289: des_xmlNodePtr_in(n_elem, elem, 1);
18290: xmlResetLastError();
18291: if (mem_base != xmlMemBlocks()) {
18292: printf("Leak of %d blocks found in xmlAddSibling",
18293: xmlMemBlocks() - mem_base);
18294: test_ret++;
18295: printf(" %d", n_cur);
18296: printf(" %d", n_elem);
18297: printf("\n");
18298: }
18299: }
18300: }
18301: function_tests++;
18302:
18303: return(test_ret);
18304: }
18305:
18306:
18307: static int
18308: test_xmlAttrSerializeTxtContent(void) {
18309: int test_ret = 0;
18310:
18311: #if defined(LIBXML_OUTPUT_ENABLED)
18312: #ifdef LIBXML_OUTPUT_ENABLED
18313: int mem_base;
18314: xmlBufferPtr buf; /* the XML buffer output */
18315: int n_buf;
18316: xmlDocPtr doc; /* the document */
18317: int n_doc;
18318: xmlAttrPtr attr; /* the attribute node */
18319: int n_attr;
18320: xmlChar * string; /* the text content */
18321: int n_string;
18322:
18323: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18324: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
18325: for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
18326: for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) {
18327: mem_base = xmlMemBlocks();
18328: buf = gen_xmlBufferPtr(n_buf, 0);
18329: doc = gen_xmlDocPtr(n_doc, 1);
18330: attr = gen_xmlAttrPtr(n_attr, 2);
18331: string = gen_const_xmlChar_ptr(n_string, 3);
18332:
18333: xmlAttrSerializeTxtContent(buf, doc, attr, (const xmlChar *)string);
18334: call_tests++;
18335: des_xmlBufferPtr(n_buf, buf, 0);
18336: des_xmlDocPtr(n_doc, doc, 1);
18337: des_xmlAttrPtr(n_attr, attr, 2);
18338: des_const_xmlChar_ptr(n_string, (const xmlChar *)string, 3);
18339: xmlResetLastError();
18340: if (mem_base != xmlMemBlocks()) {
18341: printf("Leak of %d blocks found in xmlAttrSerializeTxtContent",
18342: xmlMemBlocks() - mem_base);
18343: test_ret++;
18344: printf(" %d", n_buf);
18345: printf(" %d", n_doc);
18346: printf(" %d", n_attr);
18347: printf(" %d", n_string);
18348: printf("\n");
18349: }
18350: }
18351: }
18352: }
18353: }
18354: function_tests++;
18355: #endif
18356: #endif
18357:
18358: return(test_ret);
18359: }
18360:
18361:
18362: static int
18363: test_xmlBufferAdd(void) {
18364: int test_ret = 0;
18365:
18366: int mem_base;
18367: int ret_val;
18368: xmlBufferPtr buf; /* the buffer to dump */
18369: int n_buf;
18370: xmlChar * str; /* the #xmlChar string */
18371: int n_str;
18372: int len; /* the number of #xmlChar to add */
18373: int n_len;
18374:
18375: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18376: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
18377: for (n_len = 0;n_len < gen_nb_int;n_len++) {
18378: mem_base = xmlMemBlocks();
18379: buf = gen_xmlBufferPtr(n_buf, 0);
18380: str = gen_const_xmlChar_ptr(n_str, 1);
18381: len = gen_int(n_len, 2);
18382:
18383: ret_val = xmlBufferAdd(buf, (const xmlChar *)str, len);
18384: desret_int(ret_val);
18385: call_tests++;
18386: des_xmlBufferPtr(n_buf, buf, 0);
18387: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
18388: des_int(n_len, len, 2);
18389: xmlResetLastError();
18390: if (mem_base != xmlMemBlocks()) {
18391: printf("Leak of %d blocks found in xmlBufferAdd",
18392: xmlMemBlocks() - mem_base);
18393: test_ret++;
18394: printf(" %d", n_buf);
18395: printf(" %d", n_str);
18396: printf(" %d", n_len);
18397: printf("\n");
18398: }
18399: }
18400: }
18401: }
18402: function_tests++;
18403:
18404: return(test_ret);
18405: }
18406:
18407:
18408: static int
18409: test_xmlBufferAddHead(void) {
18410: int test_ret = 0;
18411:
18412: int mem_base;
18413: int ret_val;
18414: xmlBufferPtr buf; /* the buffer */
18415: int n_buf;
18416: xmlChar * str; /* the #xmlChar string */
18417: int n_str;
18418: int len; /* the number of #xmlChar to add */
18419: int n_len;
18420:
18421: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18422: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
18423: for (n_len = 0;n_len < gen_nb_int;n_len++) {
18424: mem_base = xmlMemBlocks();
18425: buf = gen_xmlBufferPtr(n_buf, 0);
18426: str = gen_const_xmlChar_ptr(n_str, 1);
18427: len = gen_int(n_len, 2);
18428:
18429: ret_val = xmlBufferAddHead(buf, (const xmlChar *)str, len);
18430: desret_int(ret_val);
18431: call_tests++;
18432: des_xmlBufferPtr(n_buf, buf, 0);
18433: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
18434: des_int(n_len, len, 2);
18435: xmlResetLastError();
18436: if (mem_base != xmlMemBlocks()) {
18437: printf("Leak of %d blocks found in xmlBufferAddHead",
18438: xmlMemBlocks() - mem_base);
18439: test_ret++;
18440: printf(" %d", n_buf);
18441: printf(" %d", n_str);
18442: printf(" %d", n_len);
18443: printf("\n");
18444: }
18445: }
18446: }
18447: }
18448: function_tests++;
18449:
18450: return(test_ret);
18451: }
18452:
18453:
18454: static int
18455: test_xmlBufferCCat(void) {
18456: int test_ret = 0;
18457:
18458: int mem_base;
18459: int ret_val;
18460: xmlBufferPtr buf; /* the buffer to dump */
18461: int n_buf;
18462: char * str; /* the C char string */
18463: int n_str;
18464:
18465: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18466: for (n_str = 0;n_str < gen_nb_const_char_ptr;n_str++) {
18467: mem_base = xmlMemBlocks();
18468: buf = gen_xmlBufferPtr(n_buf, 0);
18469: str = gen_const_char_ptr(n_str, 1);
18470:
18471: ret_val = xmlBufferCCat(buf, (const char *)str);
18472: desret_int(ret_val);
18473: call_tests++;
18474: des_xmlBufferPtr(n_buf, buf, 0);
18475: des_const_char_ptr(n_str, (const char *)str, 1);
18476: xmlResetLastError();
18477: if (mem_base != xmlMemBlocks()) {
18478: printf("Leak of %d blocks found in xmlBufferCCat",
18479: xmlMemBlocks() - mem_base);
18480: test_ret++;
18481: printf(" %d", n_buf);
18482: printf(" %d", n_str);
18483: printf("\n");
18484: }
18485: }
18486: }
18487: function_tests++;
18488:
18489: return(test_ret);
18490: }
18491:
18492:
18493: static int
18494: test_xmlBufferCat(void) {
18495: int test_ret = 0;
18496:
18497: int mem_base;
18498: int ret_val;
18499: xmlBufferPtr buf; /* the buffer to add to */
18500: int n_buf;
18501: xmlChar * str; /* the #xmlChar string */
18502: int n_str;
18503:
18504: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18505: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
18506: mem_base = xmlMemBlocks();
18507: buf = gen_xmlBufferPtr(n_buf, 0);
18508: str = gen_const_xmlChar_ptr(n_str, 1);
18509:
18510: ret_val = xmlBufferCat(buf, (const xmlChar *)str);
18511: desret_int(ret_val);
18512: call_tests++;
18513: des_xmlBufferPtr(n_buf, buf, 0);
18514: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
18515: xmlResetLastError();
18516: if (mem_base != xmlMemBlocks()) {
18517: printf("Leak of %d blocks found in xmlBufferCat",
18518: xmlMemBlocks() - mem_base);
18519: test_ret++;
18520: printf(" %d", n_buf);
18521: printf(" %d", n_str);
18522: printf("\n");
18523: }
18524: }
18525: }
18526: function_tests++;
18527:
18528: return(test_ret);
18529: }
18530:
18531:
18532: #define gen_nb_const_xmlBufferPtr 1
18533: static xmlBufferPtr gen_const_xmlBufferPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
18534: return(NULL);
18535: }
18536: static void des_const_xmlBufferPtr(int no ATTRIBUTE_UNUSED, const xmlBufferPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
18537: }
18538:
18539: static int
18540: test_xmlBufferContent(void) {
18541: int test_ret = 0;
18542:
18543: int mem_base;
18544: const xmlChar * ret_val;
18545: xmlBufferPtr buf; /* the buffer */
18546: int n_buf;
18547:
18548: for (n_buf = 0;n_buf < gen_nb_const_xmlBufferPtr;n_buf++) {
18549: mem_base = xmlMemBlocks();
18550: buf = gen_const_xmlBufferPtr(n_buf, 0);
18551:
18552: ret_val = xmlBufferContent((const xmlBufferPtr)buf);
18553: desret_const_xmlChar_ptr(ret_val);
18554: call_tests++;
18555: des_const_xmlBufferPtr(n_buf, (const xmlBufferPtr)buf, 0);
18556: xmlResetLastError();
18557: if (mem_base != xmlMemBlocks()) {
18558: printf("Leak of %d blocks found in xmlBufferContent",
18559: xmlMemBlocks() - mem_base);
18560: test_ret++;
18561: printf(" %d", n_buf);
18562: printf("\n");
18563: }
18564: }
18565: function_tests++;
18566:
18567: return(test_ret);
18568: }
18569:
18570:
18571: static int
18572: test_xmlBufferCreate(void) {
18573: int test_ret = 0;
18574:
18575: int mem_base;
18576: xmlBufferPtr ret_val;
18577:
18578: mem_base = xmlMemBlocks();
18579:
18580: ret_val = xmlBufferCreate();
18581: desret_xmlBufferPtr(ret_val);
18582: call_tests++;
18583: xmlResetLastError();
18584: if (mem_base != xmlMemBlocks()) {
18585: printf("Leak of %d blocks found in xmlBufferCreate",
18586: xmlMemBlocks() - mem_base);
18587: test_ret++;
18588: printf("\n");
18589: }
18590: function_tests++;
18591:
18592: return(test_ret);
18593: }
18594:
18595:
18596: static int
18597: test_xmlBufferCreateSize(void) {
18598: int test_ret = 0;
18599:
18600:
18601: /* missing type support */
18602: return(test_ret);
18603: }
18604:
18605:
18606: static int
18607: test_xmlBufferCreateStatic(void) {
18608: int test_ret = 0;
18609:
18610:
18611: /* missing type support */
18612: return(test_ret);
18613: }
18614:
18615:
18616: static int
18617: test_xmlBufferEmpty(void) {
18618: int test_ret = 0;
18619:
18620: int mem_base;
18621: xmlBufferPtr buf; /* the buffer */
18622: int n_buf;
18623:
18624: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18625: mem_base = xmlMemBlocks();
18626: buf = gen_xmlBufferPtr(n_buf, 0);
18627:
18628: xmlBufferEmpty(buf);
18629: call_tests++;
18630: des_xmlBufferPtr(n_buf, buf, 0);
18631: xmlResetLastError();
18632: if (mem_base != xmlMemBlocks()) {
18633: printf("Leak of %d blocks found in xmlBufferEmpty",
18634: xmlMemBlocks() - mem_base);
18635: test_ret++;
18636: printf(" %d", n_buf);
18637: printf("\n");
18638: }
18639: }
18640: function_tests++;
18641:
18642: return(test_ret);
18643: }
18644:
18645:
18646: static int
18647: test_xmlBufferGrow(void) {
18648: int test_ret = 0;
18649:
18650: int mem_base;
18651: int ret_val;
18652: xmlBufferPtr buf; /* the buffer */
18653: int n_buf;
18654: unsigned int len; /* the minimum free size to allocate */
18655: int n_len;
18656:
18657: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18658: for (n_len = 0;n_len < gen_nb_unsigned_int;n_len++) {
18659: mem_base = xmlMemBlocks();
18660: buf = gen_xmlBufferPtr(n_buf, 0);
18661: len = gen_unsigned_int(n_len, 1);
18662:
18663: ret_val = xmlBufferGrow(buf, len);
18664: desret_int(ret_val);
18665: call_tests++;
18666: des_xmlBufferPtr(n_buf, buf, 0);
18667: des_unsigned_int(n_len, len, 1);
18668: xmlResetLastError();
18669: if (mem_base != xmlMemBlocks()) {
18670: printf("Leak of %d blocks found in xmlBufferGrow",
18671: xmlMemBlocks() - mem_base);
18672: test_ret++;
18673: printf(" %d", n_buf);
18674: printf(" %d", n_len);
18675: printf("\n");
18676: }
18677: }
18678: }
18679: function_tests++;
18680:
18681: return(test_ret);
18682: }
18683:
18684:
18685: static int
18686: test_xmlBufferLength(void) {
18687: int test_ret = 0;
18688:
18689: int mem_base;
18690: int ret_val;
18691: xmlBufferPtr buf; /* the buffer */
18692: int n_buf;
18693:
18694: for (n_buf = 0;n_buf < gen_nb_const_xmlBufferPtr;n_buf++) {
18695: mem_base = xmlMemBlocks();
18696: buf = gen_const_xmlBufferPtr(n_buf, 0);
18697:
18698: ret_val = xmlBufferLength((const xmlBufferPtr)buf);
18699: desret_int(ret_val);
18700: call_tests++;
18701: des_const_xmlBufferPtr(n_buf, (const xmlBufferPtr)buf, 0);
18702: xmlResetLastError();
18703: if (mem_base != xmlMemBlocks()) {
18704: printf("Leak of %d blocks found in xmlBufferLength",
18705: xmlMemBlocks() - mem_base);
18706: test_ret++;
18707: printf(" %d", n_buf);
18708: printf("\n");
18709: }
18710: }
18711: function_tests++;
18712:
18713: return(test_ret);
18714: }
18715:
18716:
18717: static int
18718: test_xmlBufferResize(void) {
18719: int test_ret = 0;
18720:
18721: int mem_base;
18722: int ret_val;
18723: xmlBufferPtr buf; /* the buffer to resize */
18724: int n_buf;
18725: unsigned int size; /* the desired size */
18726: int n_size;
18727:
18728: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18729: for (n_size = 0;n_size < gen_nb_unsigned_int;n_size++) {
18730: mem_base = xmlMemBlocks();
18731: buf = gen_xmlBufferPtr(n_buf, 0);
18732: size = gen_unsigned_int(n_size, 1);
18733:
18734: ret_val = xmlBufferResize(buf, size);
18735: desret_int(ret_val);
18736: call_tests++;
18737: des_xmlBufferPtr(n_buf, buf, 0);
18738: des_unsigned_int(n_size, size, 1);
18739: xmlResetLastError();
18740: if (mem_base != xmlMemBlocks()) {
18741: printf("Leak of %d blocks found in xmlBufferResize",
18742: xmlMemBlocks() - mem_base);
18743: test_ret++;
18744: printf(" %d", n_buf);
18745: printf(" %d", n_size);
18746: printf("\n");
18747: }
18748: }
18749: }
18750: function_tests++;
18751:
18752: return(test_ret);
18753: }
18754:
18755:
18756: static int
18757: test_xmlBufferSetAllocationScheme(void) {
18758: int test_ret = 0;
18759:
18760: int mem_base;
18761: xmlBufferPtr buf; /* the buffer to tune */
18762: int n_buf;
18763: xmlBufferAllocationScheme scheme; /* allocation scheme to use */
18764: int n_scheme;
18765:
18766: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18767: for (n_scheme = 0;n_scheme < gen_nb_xmlBufferAllocationScheme;n_scheme++) {
18768: mem_base = xmlMemBlocks();
18769: buf = gen_xmlBufferPtr(n_buf, 0);
18770: scheme = gen_xmlBufferAllocationScheme(n_scheme, 1);
18771:
18772: xmlBufferSetAllocationScheme(buf, scheme);
18773: if ((buf != NULL) && (scheme == XML_BUFFER_ALLOC_IMMUTABLE) && (buf->content != NULL) && (buf->content != static_buf_content)) { xmlFree(buf->content); buf->content = NULL;}
18774: call_tests++;
18775: des_xmlBufferPtr(n_buf, buf, 0);
18776: des_xmlBufferAllocationScheme(n_scheme, scheme, 1);
18777: xmlResetLastError();
18778: if (mem_base != xmlMemBlocks()) {
18779: printf("Leak of %d blocks found in xmlBufferSetAllocationScheme",
18780: xmlMemBlocks() - mem_base);
18781: test_ret++;
18782: printf(" %d", n_buf);
18783: printf(" %d", n_scheme);
18784: printf("\n");
18785: }
18786: }
18787: }
18788: function_tests++;
18789:
18790: return(test_ret);
18791: }
18792:
18793:
18794: static int
18795: test_xmlBufferShrink(void) {
18796: int test_ret = 0;
18797:
18798: int mem_base;
18799: int ret_val;
18800: xmlBufferPtr buf; /* the buffer to dump */
18801: int n_buf;
18802: unsigned int len; /* the number of xmlChar to remove */
18803: int n_len;
18804:
18805: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18806: for (n_len = 0;n_len < gen_nb_unsigned_int;n_len++) {
18807: mem_base = xmlMemBlocks();
18808: buf = gen_xmlBufferPtr(n_buf, 0);
18809: len = gen_unsigned_int(n_len, 1);
18810:
18811: ret_val = xmlBufferShrink(buf, len);
18812: desret_int(ret_val);
18813: call_tests++;
18814: des_xmlBufferPtr(n_buf, buf, 0);
18815: des_unsigned_int(n_len, len, 1);
18816: xmlResetLastError();
18817: if (mem_base != xmlMemBlocks()) {
18818: printf("Leak of %d blocks found in xmlBufferShrink",
18819: xmlMemBlocks() - mem_base);
18820: test_ret++;
18821: printf(" %d", n_buf);
18822: printf(" %d", n_len);
18823: printf("\n");
18824: }
18825: }
18826: }
18827: function_tests++;
18828:
18829: return(test_ret);
18830: }
18831:
18832:
18833: static int
18834: test_xmlBufferWriteCHAR(void) {
18835: int test_ret = 0;
18836:
18837: int mem_base;
18838: xmlBufferPtr buf; /* the XML buffer */
18839: int n_buf;
18840: xmlChar * string; /* the string to add */
18841: int n_string;
18842:
18843: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18844: for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) {
18845: mem_base = xmlMemBlocks();
18846: buf = gen_xmlBufferPtr(n_buf, 0);
18847: string = gen_const_xmlChar_ptr(n_string, 1);
18848:
18849: xmlBufferWriteCHAR(buf, (const xmlChar *)string);
18850: call_tests++;
18851: des_xmlBufferPtr(n_buf, buf, 0);
18852: des_const_xmlChar_ptr(n_string, (const xmlChar *)string, 1);
18853: xmlResetLastError();
18854: if (mem_base != xmlMemBlocks()) {
18855: printf("Leak of %d blocks found in xmlBufferWriteCHAR",
18856: xmlMemBlocks() - mem_base);
18857: test_ret++;
18858: printf(" %d", n_buf);
18859: printf(" %d", n_string);
18860: printf("\n");
18861: }
18862: }
18863: }
18864: function_tests++;
18865:
18866: return(test_ret);
18867: }
18868:
18869:
18870: static int
18871: test_xmlBufferWriteChar(void) {
18872: int test_ret = 0;
18873:
18874: int mem_base;
18875: xmlBufferPtr buf; /* the XML buffer output */
18876: int n_buf;
18877: char * string; /* the string to add */
18878: int n_string;
18879:
18880: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18881: for (n_string = 0;n_string < gen_nb_const_char_ptr;n_string++) {
18882: mem_base = xmlMemBlocks();
18883: buf = gen_xmlBufferPtr(n_buf, 0);
18884: string = gen_const_char_ptr(n_string, 1);
18885:
18886: xmlBufferWriteChar(buf, (const char *)string);
18887: call_tests++;
18888: des_xmlBufferPtr(n_buf, buf, 0);
18889: des_const_char_ptr(n_string, (const char *)string, 1);
18890: xmlResetLastError();
18891: if (mem_base != xmlMemBlocks()) {
18892: printf("Leak of %d blocks found in xmlBufferWriteChar",
18893: xmlMemBlocks() - mem_base);
18894: test_ret++;
18895: printf(" %d", n_buf);
18896: printf(" %d", n_string);
18897: printf("\n");
18898: }
18899: }
18900: }
18901: function_tests++;
18902:
18903: return(test_ret);
18904: }
18905:
18906:
18907: static int
18908: test_xmlBufferWriteQuotedString(void) {
18909: int test_ret = 0;
18910:
18911: int mem_base;
18912: xmlBufferPtr buf; /* the XML buffer output */
18913: int n_buf;
18914: xmlChar * string; /* the string to add */
18915: int n_string;
18916:
18917: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18918: for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) {
18919: mem_base = xmlMemBlocks();
18920: buf = gen_xmlBufferPtr(n_buf, 0);
18921: string = gen_const_xmlChar_ptr(n_string, 1);
18922:
18923: xmlBufferWriteQuotedString(buf, (const xmlChar *)string);
18924: call_tests++;
18925: des_xmlBufferPtr(n_buf, buf, 0);
18926: des_const_xmlChar_ptr(n_string, (const xmlChar *)string, 1);
18927: xmlResetLastError();
18928: if (mem_base != xmlMemBlocks()) {
18929: printf("Leak of %d blocks found in xmlBufferWriteQuotedString",
18930: xmlMemBlocks() - mem_base);
18931: test_ret++;
18932: printf(" %d", n_buf);
18933: printf(" %d", n_string);
18934: printf("\n");
18935: }
18936: }
18937: }
18938: function_tests++;
18939:
18940: return(test_ret);
18941: }
18942:
18943:
18944: static int
18945: test_xmlBuildQName(void) {
18946: int test_ret = 0;
18947:
18948: int mem_base;
18949: xmlChar * ret_val;
18950: xmlChar * ncname; /* the Name */
18951: int n_ncname;
18952: xmlChar * prefix; /* the prefix */
18953: int n_prefix;
18954: xmlChar * memory; /* preallocated memory */
18955: int n_memory;
18956: int len; /* preallocated memory length */
18957: int n_len;
18958:
18959: for (n_ncname = 0;n_ncname < gen_nb_const_xmlChar_ptr;n_ncname++) {
18960: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
18961: for (n_memory = 0;n_memory < gen_nb_xmlChar_ptr;n_memory++) {
18962: for (n_len = 0;n_len < gen_nb_int;n_len++) {
18963: mem_base = xmlMemBlocks();
18964: ncname = gen_const_xmlChar_ptr(n_ncname, 0);
18965: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
18966: memory = gen_xmlChar_ptr(n_memory, 2);
18967: len = gen_int(n_len, 3);
18968:
18969: ret_val = xmlBuildQName((const xmlChar *)ncname, (const xmlChar *)prefix, memory, len);
18970: if ((ret_val != NULL) && (ret_val != ncname) &&
18971: (ret_val != prefix) && (ret_val != memory))
18972: xmlFree(ret_val);
18973: ret_val = NULL;
18974: desret_xmlChar_ptr(ret_val);
18975: call_tests++;
18976: des_const_xmlChar_ptr(n_ncname, (const xmlChar *)ncname, 0);
18977: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
18978: des_xmlChar_ptr(n_memory, memory, 2);
18979: des_int(n_len, len, 3);
18980: xmlResetLastError();
18981: if (mem_base != xmlMemBlocks()) {
18982: printf("Leak of %d blocks found in xmlBuildQName",
18983: xmlMemBlocks() - mem_base);
18984: test_ret++;
18985: printf(" %d", n_ncname);
18986: printf(" %d", n_prefix);
18987: printf(" %d", n_memory);
18988: printf(" %d", n_len);
18989: printf("\n");
18990: }
18991: }
18992: }
18993: }
18994: }
18995: function_tests++;
18996:
18997: return(test_ret);
18998: }
18999:
19000:
19001: static int
19002: test_xmlChildElementCount(void) {
19003: int test_ret = 0;
19004:
19005: #if defined(LIBXML_TREE_ENABLED)
19006: int mem_base;
19007: unsigned long ret_val;
19008: xmlNodePtr parent; /* the parent node */
19009: int n_parent;
19010:
19011: for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
19012: mem_base = xmlMemBlocks();
19013: parent = gen_xmlNodePtr(n_parent, 0);
19014:
19015: ret_val = xmlChildElementCount(parent);
19016: desret_unsigned_long(ret_val);
19017: call_tests++;
19018: des_xmlNodePtr(n_parent, parent, 0);
19019: xmlResetLastError();
19020: if (mem_base != xmlMemBlocks()) {
19021: printf("Leak of %d blocks found in xmlChildElementCount",
19022: xmlMemBlocks() - mem_base);
19023: test_ret++;
19024: printf(" %d", n_parent);
19025: printf("\n");
19026: }
19027: }
19028: function_tests++;
19029: #endif
19030:
19031: return(test_ret);
19032: }
19033:
19034:
19035: static int
19036: test_xmlCopyDoc(void) {
19037: int test_ret = 0;
19038:
19039: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
19040: int mem_base;
19041: xmlDocPtr ret_val;
19042: xmlDocPtr doc; /* the document */
19043: int n_doc;
19044: int recursive; /* if not zero do a recursive copy. */
19045: int n_recursive;
19046:
19047: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
19048: for (n_recursive = 0;n_recursive < gen_nb_int;n_recursive++) {
19049: mem_base = xmlMemBlocks();
19050: doc = gen_xmlDocPtr(n_doc, 0);
19051: recursive = gen_int(n_recursive, 1);
19052:
19053: ret_val = xmlCopyDoc(doc, recursive);
19054: desret_xmlDocPtr(ret_val);
19055: call_tests++;
19056: des_xmlDocPtr(n_doc, doc, 0);
19057: des_int(n_recursive, recursive, 1);
19058: xmlResetLastError();
19059: if (mem_base != xmlMemBlocks()) {
19060: printf("Leak of %d blocks found in xmlCopyDoc",
19061: xmlMemBlocks() - mem_base);
19062: test_ret++;
19063: printf(" %d", n_doc);
19064: printf(" %d", n_recursive);
19065: printf("\n");
19066: }
19067: }
19068: }
19069: function_tests++;
19070: #endif
19071:
19072: return(test_ret);
19073: }
19074:
19075:
19076: static int
19077: test_xmlCopyDtd(void) {
19078: int test_ret = 0;
19079:
19080: #if defined(LIBXML_TREE_ENABLED)
19081: int mem_base;
19082: xmlDtdPtr ret_val;
19083: xmlDtdPtr dtd; /* the dtd */
19084: int n_dtd;
19085:
19086: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
19087: mem_base = xmlMemBlocks();
19088: dtd = gen_xmlDtdPtr(n_dtd, 0);
19089:
19090: ret_val = xmlCopyDtd(dtd);
19091: desret_xmlDtdPtr(ret_val);
19092: call_tests++;
19093: des_xmlDtdPtr(n_dtd, dtd, 0);
19094: xmlResetLastError();
19095: if (mem_base != xmlMemBlocks()) {
19096: printf("Leak of %d blocks found in xmlCopyDtd",
19097: xmlMemBlocks() - mem_base);
19098: test_ret++;
19099: printf(" %d", n_dtd);
19100: printf("\n");
19101: }
19102: }
19103: function_tests++;
19104: #endif
19105:
19106: return(test_ret);
19107: }
19108:
19109:
19110: static int
19111: test_xmlCopyNamespace(void) {
19112: int test_ret = 0;
19113:
19114: int mem_base;
19115: xmlNsPtr ret_val;
19116: xmlNsPtr cur; /* the namespace */
19117: int n_cur;
19118:
19119: for (n_cur = 0;n_cur < gen_nb_xmlNsPtr;n_cur++) {
19120: mem_base = xmlMemBlocks();
19121: cur = gen_xmlNsPtr(n_cur, 0);
19122:
19123: ret_val = xmlCopyNamespace(cur);
19124: if (ret_val != NULL) xmlFreeNs(ret_val);
19125: desret_xmlNsPtr(ret_val);
19126: call_tests++;
19127: des_xmlNsPtr(n_cur, cur, 0);
19128: xmlResetLastError();
19129: if (mem_base != xmlMemBlocks()) {
19130: printf("Leak of %d blocks found in xmlCopyNamespace",
19131: xmlMemBlocks() - mem_base);
19132: test_ret++;
19133: printf(" %d", n_cur);
19134: printf("\n");
19135: }
19136: }
19137: function_tests++;
19138:
19139: return(test_ret);
19140: }
19141:
19142:
19143: static int
19144: test_xmlCopyNamespaceList(void) {
19145: int test_ret = 0;
19146:
19147: int mem_base;
19148: xmlNsPtr ret_val;
19149: xmlNsPtr cur; /* the first namespace */
19150: int n_cur;
19151:
19152: for (n_cur = 0;n_cur < gen_nb_xmlNsPtr;n_cur++) {
19153: mem_base = xmlMemBlocks();
19154: cur = gen_xmlNsPtr(n_cur, 0);
19155:
19156: ret_val = xmlCopyNamespaceList(cur);
19157: if (ret_val != NULL) xmlFreeNsList(ret_val);
19158: desret_xmlNsPtr(ret_val);
19159: call_tests++;
19160: des_xmlNsPtr(n_cur, cur, 0);
19161: xmlResetLastError();
19162: if (mem_base != xmlMemBlocks()) {
19163: printf("Leak of %d blocks found in xmlCopyNamespaceList",
19164: xmlMemBlocks() - mem_base);
19165: test_ret++;
19166: printf(" %d", n_cur);
19167: printf("\n");
19168: }
19169: }
19170: function_tests++;
19171:
19172: return(test_ret);
19173: }
19174:
19175:
19176: static int
19177: test_xmlCopyNode(void) {
19178: int test_ret = 0;
19179:
19180: int mem_base;
19181: xmlNodePtr ret_val;
19182: xmlNodePtr node; /* the node */
19183: int n_node;
19184: int extended; /* if 1 do a recursive copy (properties, namespaces and children when applicable) if 2 copy properties and namespaces (when applicable) */
19185: int n_extended;
19186:
19187: for (n_node = 0;n_node < gen_nb_const_xmlNodePtr;n_node++) {
19188: for (n_extended = 0;n_extended < gen_nb_int;n_extended++) {
19189: mem_base = xmlMemBlocks();
19190: node = gen_const_xmlNodePtr(n_node, 0);
19191: extended = gen_int(n_extended, 1);
19192:
19193: ret_val = xmlCopyNode((const xmlNodePtr)node, extended);
19194: desret_xmlNodePtr(ret_val);
19195: call_tests++;
19196: des_const_xmlNodePtr(n_node, (const xmlNodePtr)node, 0);
19197: des_int(n_extended, extended, 1);
19198: xmlResetLastError();
19199: if (mem_base != xmlMemBlocks()) {
19200: printf("Leak of %d blocks found in xmlCopyNode",
19201: xmlMemBlocks() - mem_base);
19202: test_ret++;
19203: printf(" %d", n_node);
19204: printf(" %d", n_extended);
19205: printf("\n");
19206: }
19207: }
19208: }
19209: function_tests++;
19210:
19211: return(test_ret);
19212: }
19213:
19214:
19215: static int
19216: test_xmlCopyNodeList(void) {
19217: int test_ret = 0;
19218:
19219: int mem_base;
19220: xmlNodePtr ret_val;
19221: xmlNodePtr node; /* the first node in the list. */
19222: int n_node;
19223:
19224: for (n_node = 0;n_node < gen_nb_const_xmlNodePtr;n_node++) {
19225: mem_base = xmlMemBlocks();
19226: node = gen_const_xmlNodePtr(n_node, 0);
19227:
19228: ret_val = xmlCopyNodeList((const xmlNodePtr)node);
19229: desret_xmlNodePtr(ret_val);
19230: call_tests++;
19231: des_const_xmlNodePtr(n_node, (const xmlNodePtr)node, 0);
19232: xmlResetLastError();
19233: if (mem_base != xmlMemBlocks()) {
19234: printf("Leak of %d blocks found in xmlCopyNodeList",
19235: xmlMemBlocks() - mem_base);
19236: test_ret++;
19237: printf(" %d", n_node);
19238: printf("\n");
19239: }
19240: }
19241: function_tests++;
19242:
19243: return(test_ret);
19244: }
19245:
19246:
19247: static int
19248: test_xmlCopyProp(void) {
19249: int test_ret = 0;
19250:
19251: int mem_base;
19252: xmlAttrPtr ret_val;
19253: xmlNodePtr target; /* the element where the attribute will be grafted */
19254: int n_target;
19255: xmlAttrPtr cur; /* the attribute */
19256: int n_cur;
19257:
19258: for (n_target = 0;n_target < gen_nb_xmlNodePtr;n_target++) {
19259: for (n_cur = 0;n_cur < gen_nb_xmlAttrPtr;n_cur++) {
19260: mem_base = xmlMemBlocks();
19261: target = gen_xmlNodePtr(n_target, 0);
19262: cur = gen_xmlAttrPtr(n_cur, 1);
19263:
19264: ret_val = xmlCopyProp(target, cur);
19265: desret_xmlAttrPtr(ret_val);
19266: call_tests++;
19267: des_xmlNodePtr(n_target, target, 0);
19268: des_xmlAttrPtr(n_cur, cur, 1);
19269: xmlResetLastError();
19270: if (mem_base != xmlMemBlocks()) {
19271: printf("Leak of %d blocks found in xmlCopyProp",
19272: xmlMemBlocks() - mem_base);
19273: test_ret++;
19274: printf(" %d", n_target);
19275: printf(" %d", n_cur);
19276: printf("\n");
19277: }
19278: }
19279: }
19280: function_tests++;
19281:
19282: return(test_ret);
19283: }
19284:
19285:
19286: static int
19287: test_xmlCopyPropList(void) {
19288: int test_ret = 0;
19289:
19290: int mem_base;
19291: xmlAttrPtr ret_val;
19292: xmlNodePtr target; /* the element where the attributes will be grafted */
19293: int n_target;
19294: xmlAttrPtr cur; /* the first attribute */
19295: int n_cur;
19296:
19297: for (n_target = 0;n_target < gen_nb_xmlNodePtr;n_target++) {
19298: for (n_cur = 0;n_cur < gen_nb_xmlAttrPtr;n_cur++) {
19299: mem_base = xmlMemBlocks();
19300: target = gen_xmlNodePtr(n_target, 0);
19301: cur = gen_xmlAttrPtr(n_cur, 1);
19302:
19303: ret_val = xmlCopyPropList(target, cur);
19304: desret_xmlAttrPtr(ret_val);
19305: call_tests++;
19306: des_xmlNodePtr(n_target, target, 0);
19307: des_xmlAttrPtr(n_cur, cur, 1);
19308: xmlResetLastError();
19309: if (mem_base != xmlMemBlocks()) {
19310: printf("Leak of %d blocks found in xmlCopyPropList",
19311: xmlMemBlocks() - mem_base);
19312: test_ret++;
19313: printf(" %d", n_target);
19314: printf(" %d", n_cur);
19315: printf("\n");
19316: }
19317: }
19318: }
19319: function_tests++;
19320:
19321: return(test_ret);
19322: }
19323:
19324:
19325: static int
19326: test_xmlCreateIntSubset(void) {
19327: int test_ret = 0;
19328:
19329: int mem_base;
19330: xmlDtdPtr ret_val;
19331: xmlDocPtr doc; /* the document pointer */
19332: int n_doc;
19333: xmlChar * name; /* the DTD name */
19334: int n_name;
19335: xmlChar * ExternalID; /* the external (PUBLIC) ID */
19336: int n_ExternalID;
19337: xmlChar * SystemID; /* the system ID */
19338: int n_SystemID;
19339:
19340: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
19341: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
19342: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
19343: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
19344: mem_base = xmlMemBlocks();
19345: doc = gen_xmlDocPtr(n_doc, 0);
19346: name = gen_const_xmlChar_ptr(n_name, 1);
19347: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 2);
19348: SystemID = gen_const_xmlChar_ptr(n_SystemID, 3);
19349:
19350: ret_val = xmlCreateIntSubset(doc, (const xmlChar *)name, (const xmlChar *)ExternalID, (const xmlChar *)SystemID);
19351: desret_xmlDtdPtr(ret_val);
19352: call_tests++;
19353: des_xmlDocPtr(n_doc, doc, 0);
19354: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
19355: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 2);
19356: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 3);
19357: xmlResetLastError();
19358: if (mem_base != xmlMemBlocks()) {
19359: printf("Leak of %d blocks found in xmlCreateIntSubset",
19360: xmlMemBlocks() - mem_base);
19361: test_ret++;
19362: printf(" %d", n_doc);
19363: printf(" %d", n_name);
19364: printf(" %d", n_ExternalID);
19365: printf(" %d", n_SystemID);
19366: printf("\n");
19367: }
19368: }
19369: }
19370: }
19371: }
19372: function_tests++;
19373:
19374: return(test_ret);
19375: }
19376:
19377:
19378: #define gen_nb_xmlDOMWrapCtxtPtr 1
19379: static xmlDOMWrapCtxtPtr gen_xmlDOMWrapCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
19380: return(NULL);
19381: }
19382: static void des_xmlDOMWrapCtxtPtr(int no ATTRIBUTE_UNUSED, xmlDOMWrapCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
19383: }
19384:
19385: static int
19386: test_xmlDOMWrapAdoptNode(void) {
19387: int test_ret = 0;
19388:
19389: int mem_base;
19390: int ret_val;
19391: xmlDOMWrapCtxtPtr ctxt; /* the optional context for custom processing */
19392: int n_ctxt;
19393: xmlDocPtr sourceDoc; /* the optional sourceDoc */
19394: int n_sourceDoc;
19395: xmlNodePtr node; /* the node to start with */
19396: int n_node;
19397: xmlDocPtr destDoc; /* the destination doc */
19398: int n_destDoc;
19399: xmlNodePtr destParent; /* the optional new parent of @node in @destDoc */
19400: int n_destParent;
19401: int options; /* option flags */
19402: int n_options;
19403:
19404: for (n_ctxt = 0;n_ctxt < gen_nb_xmlDOMWrapCtxtPtr;n_ctxt++) {
19405: for (n_sourceDoc = 0;n_sourceDoc < gen_nb_xmlDocPtr;n_sourceDoc++) {
19406: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
19407: for (n_destDoc = 0;n_destDoc < gen_nb_xmlDocPtr;n_destDoc++) {
19408: for (n_destParent = 0;n_destParent < gen_nb_xmlNodePtr;n_destParent++) {
19409: for (n_options = 0;n_options < gen_nb_int;n_options++) {
19410: mem_base = xmlMemBlocks();
19411: ctxt = gen_xmlDOMWrapCtxtPtr(n_ctxt, 0);
19412: sourceDoc = gen_xmlDocPtr(n_sourceDoc, 1);
19413: node = gen_xmlNodePtr(n_node, 2);
19414: destDoc = gen_xmlDocPtr(n_destDoc, 3);
19415: destParent = gen_xmlNodePtr(n_destParent, 4);
19416: options = gen_int(n_options, 5);
19417:
19418: ret_val = xmlDOMWrapAdoptNode(ctxt, sourceDoc, node, destDoc, destParent, options);
19419: if ((node != NULL) && (node->parent == NULL)) {xmlUnlinkNode(node);xmlFreeNode(node);node = NULL;}
19420: desret_int(ret_val);
19421: call_tests++;
19422: des_xmlDOMWrapCtxtPtr(n_ctxt, ctxt, 0);
19423: des_xmlDocPtr(n_sourceDoc, sourceDoc, 1);
19424: des_xmlNodePtr(n_node, node, 2);
19425: des_xmlDocPtr(n_destDoc, destDoc, 3);
19426: des_xmlNodePtr(n_destParent, destParent, 4);
19427: des_int(n_options, options, 5);
19428: xmlResetLastError();
19429: if (mem_base != xmlMemBlocks()) {
19430: printf("Leak of %d blocks found in xmlDOMWrapAdoptNode",
19431: xmlMemBlocks() - mem_base);
19432: test_ret++;
19433: printf(" %d", n_ctxt);
19434: printf(" %d", n_sourceDoc);
19435: printf(" %d", n_node);
19436: printf(" %d", n_destDoc);
19437: printf(" %d", n_destParent);
19438: printf(" %d", n_options);
19439: printf("\n");
19440: }
19441: }
19442: }
19443: }
19444: }
19445: }
19446: }
19447: function_tests++;
19448:
19449: return(test_ret);
19450: }
19451:
19452:
19453: static int
19454: test_xmlDOMWrapCloneNode(void) {
19455: int test_ret = 0;
19456:
19457: int mem_base;
19458: int ret_val;
19459: xmlDOMWrapCtxtPtr ctxt; /* the optional context for custom processing */
19460: int n_ctxt;
19461: xmlDocPtr sourceDoc; /* the optional sourceDoc */
19462: int n_sourceDoc;
19463: xmlNodePtr node; /* the node to start with */
19464: int n_node;
19465: xmlNodePtr * resNode; /* the clone of the given @node */
19466: int n_resNode;
19467: xmlDocPtr destDoc; /* the destination doc */
19468: int n_destDoc;
19469: xmlNodePtr destParent; /* the optional new parent of @node in @destDoc */
19470: int n_destParent;
19471: int deep; /* descend into child if set */
19472: int n_deep;
19473: int options; /* option flags */
19474: int n_options;
19475:
19476: for (n_ctxt = 0;n_ctxt < gen_nb_xmlDOMWrapCtxtPtr;n_ctxt++) {
19477: for (n_sourceDoc = 0;n_sourceDoc < gen_nb_xmlDocPtr;n_sourceDoc++) {
19478: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
19479: for (n_resNode = 0;n_resNode < gen_nb_xmlNodePtr_ptr;n_resNode++) {
19480: for (n_destDoc = 0;n_destDoc < gen_nb_xmlDocPtr;n_destDoc++) {
19481: for (n_destParent = 0;n_destParent < gen_nb_xmlNodePtr;n_destParent++) {
19482: for (n_deep = 0;n_deep < gen_nb_int;n_deep++) {
19483: for (n_options = 0;n_options < gen_nb_int;n_options++) {
19484: mem_base = xmlMemBlocks();
19485: ctxt = gen_xmlDOMWrapCtxtPtr(n_ctxt, 0);
19486: sourceDoc = gen_xmlDocPtr(n_sourceDoc, 1);
19487: node = gen_xmlNodePtr(n_node, 2);
19488: resNode = gen_xmlNodePtr_ptr(n_resNode, 3);
19489: destDoc = gen_xmlDocPtr(n_destDoc, 4);
19490: destParent = gen_xmlNodePtr(n_destParent, 5);
19491: deep = gen_int(n_deep, 6);
19492: options = gen_int(n_options, 7);
19493:
19494: ret_val = xmlDOMWrapCloneNode(ctxt, sourceDoc, node, resNode, destDoc, destParent, deep, options);
19495: desret_int(ret_val);
19496: call_tests++;
19497: des_xmlDOMWrapCtxtPtr(n_ctxt, ctxt, 0);
19498: des_xmlDocPtr(n_sourceDoc, sourceDoc, 1);
19499: des_xmlNodePtr(n_node, node, 2);
19500: des_xmlNodePtr_ptr(n_resNode, resNode, 3);
19501: des_xmlDocPtr(n_destDoc, destDoc, 4);
19502: des_xmlNodePtr(n_destParent, destParent, 5);
19503: des_int(n_deep, deep, 6);
19504: des_int(n_options, options, 7);
19505: xmlResetLastError();
19506: if (mem_base != xmlMemBlocks()) {
19507: printf("Leak of %d blocks found in xmlDOMWrapCloneNode",
19508: xmlMemBlocks() - mem_base);
19509: test_ret++;
19510: printf(" %d", n_ctxt);
19511: printf(" %d", n_sourceDoc);
19512: printf(" %d", n_node);
19513: printf(" %d", n_resNode);
19514: printf(" %d", n_destDoc);
19515: printf(" %d", n_destParent);
19516: printf(" %d", n_deep);
19517: printf(" %d", n_options);
19518: printf("\n");
19519: }
19520: }
19521: }
19522: }
19523: }
19524: }
19525: }
19526: }
19527: }
19528: function_tests++;
19529:
19530: return(test_ret);
19531: }
19532:
19533:
19534: static int
19535: test_xmlDOMWrapNewCtxt(void) {
19536: int test_ret = 0;
19537:
19538:
19539: /* missing type support */
19540: return(test_ret);
19541: }
19542:
19543:
19544: static int
19545: test_xmlDOMWrapReconcileNamespaces(void) {
19546: int test_ret = 0;
19547:
19548: int mem_base;
19549: int ret_val;
19550: xmlDOMWrapCtxtPtr ctxt; /* DOM wrapper context, unused at the moment */
19551: int n_ctxt;
19552: xmlNodePtr elem; /* the element-node */
19553: int n_elem;
19554: int options; /* option flags */
19555: int n_options;
19556:
19557: for (n_ctxt = 0;n_ctxt < gen_nb_xmlDOMWrapCtxtPtr;n_ctxt++) {
19558: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
19559: for (n_options = 0;n_options < gen_nb_int;n_options++) {
19560: mem_base = xmlMemBlocks();
19561: ctxt = gen_xmlDOMWrapCtxtPtr(n_ctxt, 0);
19562: elem = gen_xmlNodePtr(n_elem, 1);
19563: options = gen_int(n_options, 2);
19564:
19565: ret_val = xmlDOMWrapReconcileNamespaces(ctxt, elem, options);
19566: desret_int(ret_val);
19567: call_tests++;
19568: des_xmlDOMWrapCtxtPtr(n_ctxt, ctxt, 0);
19569: des_xmlNodePtr(n_elem, elem, 1);
19570: des_int(n_options, options, 2);
19571: xmlResetLastError();
19572: if (mem_base != xmlMemBlocks()) {
19573: printf("Leak of %d blocks found in xmlDOMWrapReconcileNamespaces",
19574: xmlMemBlocks() - mem_base);
19575: test_ret++;
19576: printf(" %d", n_ctxt);
19577: printf(" %d", n_elem);
19578: printf(" %d", n_options);
19579: printf("\n");
19580: }
19581: }
19582: }
19583: }
19584: function_tests++;
19585:
19586: return(test_ret);
19587: }
19588:
19589:
19590: static int
19591: test_xmlDOMWrapRemoveNode(void) {
19592: int test_ret = 0;
19593:
19594: int mem_base;
19595: int ret_val;
19596: xmlDOMWrapCtxtPtr ctxt; /* a DOM wrapper context */
19597: int n_ctxt;
19598: xmlDocPtr doc; /* the doc */
19599: int n_doc;
19600: xmlNodePtr node; /* the node to be removed. */
19601: int n_node;
19602: int options; /* set of options, unused at the moment */
19603: int n_options;
19604:
19605: for (n_ctxt = 0;n_ctxt < gen_nb_xmlDOMWrapCtxtPtr;n_ctxt++) {
19606: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
19607: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
19608: for (n_options = 0;n_options < gen_nb_int;n_options++) {
19609: mem_base = xmlMemBlocks();
19610: ctxt = gen_xmlDOMWrapCtxtPtr(n_ctxt, 0);
19611: doc = gen_xmlDocPtr(n_doc, 1);
19612: node = gen_xmlNodePtr(n_node, 2);
19613: options = gen_int(n_options, 3);
19614:
19615: ret_val = xmlDOMWrapRemoveNode(ctxt, doc, node, options);
19616: desret_int(ret_val);
19617: call_tests++;
19618: des_xmlDOMWrapCtxtPtr(n_ctxt, ctxt, 0);
19619: des_xmlDocPtr(n_doc, doc, 1);
19620: des_xmlNodePtr(n_node, node, 2);
19621: des_int(n_options, options, 3);
19622: xmlResetLastError();
19623: if (mem_base != xmlMemBlocks()) {
19624: printf("Leak of %d blocks found in xmlDOMWrapRemoveNode",
19625: xmlMemBlocks() - mem_base);
19626: test_ret++;
19627: printf(" %d", n_ctxt);
19628: printf(" %d", n_doc);
19629: printf(" %d", n_node);
19630: printf(" %d", n_options);
19631: printf("\n");
19632: }
19633: }
19634: }
19635: }
19636: }
19637: function_tests++;
19638:
19639: return(test_ret);
19640: }
19641:
19642:
19643: static int
19644: test_xmlDocCopyNode(void) {
19645: int test_ret = 0;
19646:
19647: int mem_base;
19648: xmlNodePtr ret_val;
19649: xmlNodePtr node; /* the node */
19650: int n_node;
19651: xmlDocPtr doc; /* the document */
19652: int n_doc;
19653: int extended; /* if 1 do a recursive copy (properties, namespaces and children when applicable) if 2 copy properties and namespaces (when applicable) */
19654: int n_extended;
19655:
19656: for (n_node = 0;n_node < gen_nb_const_xmlNodePtr;n_node++) {
19657: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
19658: for (n_extended = 0;n_extended < gen_nb_int;n_extended++) {
19659: mem_base = xmlMemBlocks();
19660: node = gen_const_xmlNodePtr(n_node, 0);
19661: doc = gen_xmlDocPtr(n_doc, 1);
19662: extended = gen_int(n_extended, 2);
19663:
19664: ret_val = xmlDocCopyNode((const xmlNodePtr)node, doc, extended);
19665: desret_xmlNodePtr(ret_val);
19666: call_tests++;
19667: des_const_xmlNodePtr(n_node, (const xmlNodePtr)node, 0);
19668: des_xmlDocPtr(n_doc, doc, 1);
19669: des_int(n_extended, extended, 2);
19670: xmlResetLastError();
19671: if (mem_base != xmlMemBlocks()) {
19672: printf("Leak of %d blocks found in xmlDocCopyNode",
19673: xmlMemBlocks() - mem_base);
19674: test_ret++;
19675: printf(" %d", n_node);
19676: printf(" %d", n_doc);
19677: printf(" %d", n_extended);
19678: printf("\n");
19679: }
19680: }
19681: }
19682: }
19683: function_tests++;
19684:
19685: return(test_ret);
19686: }
19687:
19688:
19689: static int
19690: test_xmlDocCopyNodeList(void) {
19691: int test_ret = 0;
19692:
19693: int mem_base;
19694: xmlNodePtr ret_val;
19695: xmlDocPtr doc; /* the target document */
19696: int n_doc;
19697: xmlNodePtr node; /* the first node in the list. */
19698: int n_node;
19699:
19700: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
19701: for (n_node = 0;n_node < gen_nb_const_xmlNodePtr;n_node++) {
19702: mem_base = xmlMemBlocks();
19703: doc = gen_xmlDocPtr(n_doc, 0);
19704: node = gen_const_xmlNodePtr(n_node, 1);
19705:
19706: ret_val = xmlDocCopyNodeList(doc, (const xmlNodePtr)node);
19707: desret_xmlNodePtr(ret_val);
19708: call_tests++;
19709: des_xmlDocPtr(n_doc, doc, 0);
19710: des_const_xmlNodePtr(n_node, (const xmlNodePtr)node, 1);
19711: xmlResetLastError();
19712: if (mem_base != xmlMemBlocks()) {
19713: printf("Leak of %d blocks found in xmlDocCopyNodeList",
19714: xmlMemBlocks() - mem_base);
19715: test_ret++;
19716: printf(" %d", n_doc);
19717: printf(" %d", n_node);
19718: printf("\n");
19719: }
19720: }
19721: }
19722: function_tests++;
19723:
19724: return(test_ret);
19725: }
19726:
19727:
19728: static int
19729: test_xmlDocDump(void) {
19730: int test_ret = 0;
19731:
19732: #if defined(LIBXML_OUTPUT_ENABLED)
19733: int mem_base;
19734: int ret_val;
19735: FILE * f; /* the FILE* */
19736: int n_f;
19737: xmlDocPtr cur; /* the document */
19738: int n_cur;
19739:
19740: for (n_f = 0;n_f < gen_nb_FILE_ptr;n_f++) {
19741: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
19742: mem_base = xmlMemBlocks();
19743: f = gen_FILE_ptr(n_f, 0);
19744: cur = gen_xmlDocPtr(n_cur, 1);
19745:
19746: ret_val = xmlDocDump(f, cur);
19747: desret_int(ret_val);
19748: call_tests++;
19749: des_FILE_ptr(n_f, f, 0);
19750: des_xmlDocPtr(n_cur, cur, 1);
19751: xmlResetLastError();
19752: if (mem_base != xmlMemBlocks()) {
19753: printf("Leak of %d blocks found in xmlDocDump",
19754: xmlMemBlocks() - mem_base);
19755: test_ret++;
19756: printf(" %d", n_f);
19757: printf(" %d", n_cur);
19758: printf("\n");
19759: }
19760: }
19761: }
19762: function_tests++;
19763: #endif
19764:
19765: return(test_ret);
19766: }
19767:
19768:
19769: static int
19770: test_xmlDocDumpFormatMemory(void) {
19771: int test_ret = 0;
19772:
19773: #if defined(LIBXML_OUTPUT_ENABLED)
19774: int mem_base;
19775: xmlDocPtr cur; /* the document */
19776: int n_cur;
19777: xmlChar ** mem; /* OUT: the memory pointer */
19778: int n_mem;
19779: int * size; /* OUT: the memory length */
19780: int n_size;
19781: int format; /* should formatting spaces been added */
19782: int n_format;
19783:
19784: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
19785: for (n_mem = 0;n_mem < gen_nb_xmlChar_ptr_ptr;n_mem++) {
19786: for (n_size = 0;n_size < gen_nb_int_ptr;n_size++) {
19787: for (n_format = 0;n_format < gen_nb_int;n_format++) {
19788: mem_base = xmlMemBlocks();
19789: cur = gen_xmlDocPtr(n_cur, 0);
19790: mem = gen_xmlChar_ptr_ptr(n_mem, 1);
19791: size = gen_int_ptr(n_size, 2);
19792: format = gen_int(n_format, 3);
19793:
19794: xmlDocDumpFormatMemory(cur, mem, size, format);
19795: call_tests++;
19796: des_xmlDocPtr(n_cur, cur, 0);
19797: des_xmlChar_ptr_ptr(n_mem, mem, 1);
19798: des_int_ptr(n_size, size, 2);
19799: des_int(n_format, format, 3);
19800: xmlResetLastError();
19801: if (mem_base != xmlMemBlocks()) {
19802: printf("Leak of %d blocks found in xmlDocDumpFormatMemory",
19803: xmlMemBlocks() - mem_base);
19804: test_ret++;
19805: printf(" %d", n_cur);
19806: printf(" %d", n_mem);
19807: printf(" %d", n_size);
19808: printf(" %d", n_format);
19809: printf("\n");
19810: }
19811: }
19812: }
19813: }
19814: }
19815: function_tests++;
19816: #endif
19817:
19818: return(test_ret);
19819: }
19820:
19821:
19822: static int
19823: test_xmlDocDumpFormatMemoryEnc(void) {
19824: int test_ret = 0;
19825:
19826: #if defined(LIBXML_OUTPUT_ENABLED)
19827: int mem_base;
19828: xmlDocPtr out_doc; /* Document to generate XML text from */
19829: int n_out_doc;
19830: xmlChar ** doc_txt_ptr; /* Memory pointer for allocated XML text */
19831: int n_doc_txt_ptr;
19832: int * doc_txt_len; /* Length of the generated XML text */
19833: int n_doc_txt_len;
19834: char * txt_encoding; /* Character encoding to use when generating XML text */
19835: int n_txt_encoding;
19836: int format; /* should formatting spaces been added */
19837: int n_format;
19838:
19839: for (n_out_doc = 0;n_out_doc < gen_nb_xmlDocPtr;n_out_doc++) {
19840: for (n_doc_txt_ptr = 0;n_doc_txt_ptr < gen_nb_xmlChar_ptr_ptr;n_doc_txt_ptr++) {
19841: for (n_doc_txt_len = 0;n_doc_txt_len < gen_nb_int_ptr;n_doc_txt_len++) {
19842: for (n_txt_encoding = 0;n_txt_encoding < gen_nb_const_char_ptr;n_txt_encoding++) {
19843: for (n_format = 0;n_format < gen_nb_int;n_format++) {
19844: mem_base = xmlMemBlocks();
19845: out_doc = gen_xmlDocPtr(n_out_doc, 0);
19846: doc_txt_ptr = gen_xmlChar_ptr_ptr(n_doc_txt_ptr, 1);
19847: doc_txt_len = gen_int_ptr(n_doc_txt_len, 2);
19848: txt_encoding = gen_const_char_ptr(n_txt_encoding, 3);
19849: format = gen_int(n_format, 4);
19850:
19851: xmlDocDumpFormatMemoryEnc(out_doc, doc_txt_ptr, doc_txt_len, (const char *)txt_encoding, format);
19852: call_tests++;
19853: des_xmlDocPtr(n_out_doc, out_doc, 0);
19854: des_xmlChar_ptr_ptr(n_doc_txt_ptr, doc_txt_ptr, 1);
19855: des_int_ptr(n_doc_txt_len, doc_txt_len, 2);
19856: des_const_char_ptr(n_txt_encoding, (const char *)txt_encoding, 3);
19857: des_int(n_format, format, 4);
19858: xmlResetLastError();
19859: if (mem_base != xmlMemBlocks()) {
19860: printf("Leak of %d blocks found in xmlDocDumpFormatMemoryEnc",
19861: xmlMemBlocks() - mem_base);
19862: test_ret++;
19863: printf(" %d", n_out_doc);
19864: printf(" %d", n_doc_txt_ptr);
19865: printf(" %d", n_doc_txt_len);
19866: printf(" %d", n_txt_encoding);
19867: printf(" %d", n_format);
19868: printf("\n");
19869: }
19870: }
19871: }
19872: }
19873: }
19874: }
19875: function_tests++;
19876: #endif
19877:
19878: return(test_ret);
19879: }
19880:
19881:
19882: static int
19883: test_xmlDocDumpMemory(void) {
19884: int test_ret = 0;
19885:
19886: #if defined(LIBXML_OUTPUT_ENABLED)
19887: int mem_base;
19888: xmlDocPtr cur; /* the document */
19889: int n_cur;
19890: xmlChar ** mem; /* OUT: the memory pointer */
19891: int n_mem;
19892: int * size; /* OUT: the memory length */
19893: int n_size;
19894:
19895: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
19896: for (n_mem = 0;n_mem < gen_nb_xmlChar_ptr_ptr;n_mem++) {
19897: for (n_size = 0;n_size < gen_nb_int_ptr;n_size++) {
19898: mem_base = xmlMemBlocks();
19899: cur = gen_xmlDocPtr(n_cur, 0);
19900: mem = gen_xmlChar_ptr_ptr(n_mem, 1);
19901: size = gen_int_ptr(n_size, 2);
19902:
19903: xmlDocDumpMemory(cur, mem, size);
19904: call_tests++;
19905: des_xmlDocPtr(n_cur, cur, 0);
19906: des_xmlChar_ptr_ptr(n_mem, mem, 1);
19907: des_int_ptr(n_size, size, 2);
19908: xmlResetLastError();
19909: if (mem_base != xmlMemBlocks()) {
19910: printf("Leak of %d blocks found in xmlDocDumpMemory",
19911: xmlMemBlocks() - mem_base);
19912: test_ret++;
19913: printf(" %d", n_cur);
19914: printf(" %d", n_mem);
19915: printf(" %d", n_size);
19916: printf("\n");
19917: }
19918: }
19919: }
19920: }
19921: function_tests++;
19922: #endif
19923:
19924: return(test_ret);
19925: }
19926:
19927:
19928: static int
19929: test_xmlDocDumpMemoryEnc(void) {
19930: int test_ret = 0;
19931:
19932: #if defined(LIBXML_OUTPUT_ENABLED)
19933: int mem_base;
19934: xmlDocPtr out_doc; /* Document to generate XML text from */
19935: int n_out_doc;
19936: xmlChar ** doc_txt_ptr; /* Memory pointer for allocated XML text */
19937: int n_doc_txt_ptr;
19938: int * doc_txt_len; /* Length of the generated XML text */
19939: int n_doc_txt_len;
19940: char * txt_encoding; /* Character encoding to use when generating XML text */
19941: int n_txt_encoding;
19942:
19943: for (n_out_doc = 0;n_out_doc < gen_nb_xmlDocPtr;n_out_doc++) {
19944: for (n_doc_txt_ptr = 0;n_doc_txt_ptr < gen_nb_xmlChar_ptr_ptr;n_doc_txt_ptr++) {
19945: for (n_doc_txt_len = 0;n_doc_txt_len < gen_nb_int_ptr;n_doc_txt_len++) {
19946: for (n_txt_encoding = 0;n_txt_encoding < gen_nb_const_char_ptr;n_txt_encoding++) {
19947: mem_base = xmlMemBlocks();
19948: out_doc = gen_xmlDocPtr(n_out_doc, 0);
19949: doc_txt_ptr = gen_xmlChar_ptr_ptr(n_doc_txt_ptr, 1);
19950: doc_txt_len = gen_int_ptr(n_doc_txt_len, 2);
19951: txt_encoding = gen_const_char_ptr(n_txt_encoding, 3);
19952:
19953: xmlDocDumpMemoryEnc(out_doc, doc_txt_ptr, doc_txt_len, (const char *)txt_encoding);
19954: call_tests++;
19955: des_xmlDocPtr(n_out_doc, out_doc, 0);
19956: des_xmlChar_ptr_ptr(n_doc_txt_ptr, doc_txt_ptr, 1);
19957: des_int_ptr(n_doc_txt_len, doc_txt_len, 2);
19958: des_const_char_ptr(n_txt_encoding, (const char *)txt_encoding, 3);
19959: xmlResetLastError();
19960: if (mem_base != xmlMemBlocks()) {
19961: printf("Leak of %d blocks found in xmlDocDumpMemoryEnc",
19962: xmlMemBlocks() - mem_base);
19963: test_ret++;
19964: printf(" %d", n_out_doc);
19965: printf(" %d", n_doc_txt_ptr);
19966: printf(" %d", n_doc_txt_len);
19967: printf(" %d", n_txt_encoding);
19968: printf("\n");
19969: }
19970: }
19971: }
19972: }
19973: }
19974: function_tests++;
19975: #endif
19976:
19977: return(test_ret);
19978: }
19979:
19980:
19981: static int
19982: test_xmlDocFormatDump(void) {
19983: int test_ret = 0;
19984:
19985: #if defined(LIBXML_OUTPUT_ENABLED)
19986: int mem_base;
19987: int ret_val;
19988: FILE * f; /* the FILE* */
19989: int n_f;
19990: xmlDocPtr cur; /* the document */
19991: int n_cur;
19992: int format; /* should formatting spaces been added */
19993: int n_format;
19994:
19995: for (n_f = 0;n_f < gen_nb_FILE_ptr;n_f++) {
19996: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
19997: for (n_format = 0;n_format < gen_nb_int;n_format++) {
19998: mem_base = xmlMemBlocks();
19999: f = gen_FILE_ptr(n_f, 0);
20000: cur = gen_xmlDocPtr(n_cur, 1);
20001: format = gen_int(n_format, 2);
20002:
20003: ret_val = xmlDocFormatDump(f, cur, format);
20004: desret_int(ret_val);
20005: call_tests++;
20006: des_FILE_ptr(n_f, f, 0);
20007: des_xmlDocPtr(n_cur, cur, 1);
20008: des_int(n_format, format, 2);
20009: xmlResetLastError();
20010: if (mem_base != xmlMemBlocks()) {
20011: printf("Leak of %d blocks found in xmlDocFormatDump",
20012: xmlMemBlocks() - mem_base);
20013: test_ret++;
20014: printf(" %d", n_f);
20015: printf(" %d", n_cur);
20016: printf(" %d", n_format);
20017: printf("\n");
20018: }
20019: }
20020: }
20021: }
20022: function_tests++;
20023: #endif
20024:
20025: return(test_ret);
20026: }
20027:
20028:
20029: static int
20030: test_xmlDocGetRootElement(void) {
20031: int test_ret = 0;
20032:
20033: int mem_base;
20034: xmlNodePtr ret_val;
20035: xmlDocPtr doc; /* the document */
20036: int n_doc;
20037:
20038: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
20039: mem_base = xmlMemBlocks();
20040: doc = gen_xmlDocPtr(n_doc, 0);
20041:
20042: ret_val = xmlDocGetRootElement(doc);
20043: desret_xmlNodePtr(ret_val);
20044: call_tests++;
20045: des_xmlDocPtr(n_doc, doc, 0);
20046: xmlResetLastError();
20047: if (mem_base != xmlMemBlocks()) {
20048: printf("Leak of %d blocks found in xmlDocGetRootElement",
20049: xmlMemBlocks() - mem_base);
20050: test_ret++;
20051: printf(" %d", n_doc);
20052: printf("\n");
20053: }
20054: }
20055: function_tests++;
20056:
20057: return(test_ret);
20058: }
20059:
20060:
20061: static int
20062: test_xmlDocSetRootElement(void) {
20063: int test_ret = 0;
20064:
20065: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
20066: int mem_base;
20067: xmlNodePtr ret_val;
20068: xmlDocPtr doc; /* the document */
20069: int n_doc;
20070: xmlNodePtr root; /* the new document root element, if root is NULL no action is taken, to remove a node from a document use xmlUnlinkNode(root) instead. */
20071: int n_root;
20072:
20073: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
20074: for (n_root = 0;n_root < gen_nb_xmlNodePtr_in;n_root++) {
20075: mem_base = xmlMemBlocks();
20076: doc = gen_xmlDocPtr(n_doc, 0);
20077: root = gen_xmlNodePtr_in(n_root, 1);
20078:
20079: ret_val = xmlDocSetRootElement(doc, root);
20080: if (doc == NULL) { xmlFreeNode(root) ; root = NULL ; }
20081: desret_xmlNodePtr(ret_val);
20082: call_tests++;
20083: des_xmlDocPtr(n_doc, doc, 0);
20084: des_xmlNodePtr_in(n_root, root, 1);
20085: xmlResetLastError();
20086: if (mem_base != xmlMemBlocks()) {
20087: printf("Leak of %d blocks found in xmlDocSetRootElement",
20088: xmlMemBlocks() - mem_base);
20089: test_ret++;
20090: printf(" %d", n_doc);
20091: printf(" %d", n_root);
20092: printf("\n");
20093: }
20094: }
20095: }
20096: function_tests++;
20097: #endif
20098:
20099: return(test_ret);
20100: }
20101:
20102:
20103: static int
20104: test_xmlElemDump(void) {
20105: int test_ret = 0;
20106:
20107: #if defined(LIBXML_OUTPUT_ENABLED)
20108: int mem_base;
20109: FILE * f; /* the FILE * for the output */
20110: int n_f;
20111: xmlDocPtr doc; /* the document */
20112: int n_doc;
20113: xmlNodePtr cur; /* the current node */
20114: int n_cur;
20115:
20116: for (n_f = 0;n_f < gen_nb_FILE_ptr;n_f++) {
20117: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
20118: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
20119: mem_base = xmlMemBlocks();
20120: f = gen_FILE_ptr(n_f, 0);
20121: doc = gen_xmlDocPtr(n_doc, 1);
20122: cur = gen_xmlNodePtr(n_cur, 2);
20123:
20124: xmlElemDump(f, doc, cur);
20125: call_tests++;
20126: des_FILE_ptr(n_f, f, 0);
20127: des_xmlDocPtr(n_doc, doc, 1);
20128: des_xmlNodePtr(n_cur, cur, 2);
20129: xmlResetLastError();
20130: if (mem_base != xmlMemBlocks()) {
20131: printf("Leak of %d blocks found in xmlElemDump",
20132: xmlMemBlocks() - mem_base);
20133: test_ret++;
20134: printf(" %d", n_f);
20135: printf(" %d", n_doc);
20136: printf(" %d", n_cur);
20137: printf("\n");
20138: }
20139: }
20140: }
20141: }
20142: function_tests++;
20143: #endif
20144:
20145: return(test_ret);
20146: }
20147:
20148:
20149: static int
20150: test_xmlFirstElementChild(void) {
20151: int test_ret = 0;
20152:
20153: #if defined(LIBXML_TREE_ENABLED)
20154: int mem_base;
20155: xmlNodePtr ret_val;
20156: xmlNodePtr parent; /* the parent node */
20157: int n_parent;
20158:
20159: for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
20160: mem_base = xmlMemBlocks();
20161: parent = gen_xmlNodePtr(n_parent, 0);
20162:
20163: ret_val = xmlFirstElementChild(parent);
20164: desret_xmlNodePtr(ret_val);
20165: call_tests++;
20166: des_xmlNodePtr(n_parent, parent, 0);
20167: xmlResetLastError();
20168: if (mem_base != xmlMemBlocks()) {
20169: printf("Leak of %d blocks found in xmlFirstElementChild",
20170: xmlMemBlocks() - mem_base);
20171: test_ret++;
20172: printf(" %d", n_parent);
20173: printf("\n");
20174: }
20175: }
20176: function_tests++;
20177: #endif
20178:
20179: return(test_ret);
20180: }
20181:
20182:
20183: static int
20184: test_xmlGetBufferAllocationScheme(void) {
20185: int test_ret = 0;
20186:
20187: int mem_base;
20188: xmlBufferAllocationScheme ret_val;
20189:
20190: mem_base = xmlMemBlocks();
20191:
20192: ret_val = xmlGetBufferAllocationScheme();
20193: desret_xmlBufferAllocationScheme(ret_val);
20194: call_tests++;
20195: xmlResetLastError();
20196: if (mem_base != xmlMemBlocks()) {
20197: printf("Leak of %d blocks found in xmlGetBufferAllocationScheme",
20198: xmlMemBlocks() - mem_base);
20199: test_ret++;
20200: printf("\n");
20201: }
20202: function_tests++;
20203:
20204: return(test_ret);
20205: }
20206:
20207:
20208: static int
20209: test_xmlGetCompressMode(void) {
20210: int test_ret = 0;
20211:
20212: int mem_base;
20213: int ret_val;
20214:
20215: mem_base = xmlMemBlocks();
20216:
20217: ret_val = xmlGetCompressMode();
20218: desret_int(ret_val);
20219: call_tests++;
20220: xmlResetLastError();
20221: if (mem_base != xmlMemBlocks()) {
20222: printf("Leak of %d blocks found in xmlGetCompressMode",
20223: xmlMemBlocks() - mem_base);
20224: test_ret++;
20225: printf("\n");
20226: }
20227: function_tests++;
20228:
20229: return(test_ret);
20230: }
20231:
20232:
20233: static int
20234: test_xmlGetDocCompressMode(void) {
20235: int test_ret = 0;
20236:
20237: int mem_base;
20238: int ret_val;
20239: xmlDocPtr doc; /* the document */
20240: int n_doc;
20241:
20242: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
20243: mem_base = xmlMemBlocks();
20244: doc = gen_xmlDocPtr(n_doc, 0);
20245:
20246: ret_val = xmlGetDocCompressMode(doc);
20247: desret_int(ret_val);
20248: call_tests++;
20249: des_xmlDocPtr(n_doc, doc, 0);
20250: xmlResetLastError();
20251: if (mem_base != xmlMemBlocks()) {
20252: printf("Leak of %d blocks found in xmlGetDocCompressMode",
20253: xmlMemBlocks() - mem_base);
20254: test_ret++;
20255: printf(" %d", n_doc);
20256: printf("\n");
20257: }
20258: }
20259: function_tests++;
20260:
20261: return(test_ret);
20262: }
20263:
20264:
20265: static int
20266: test_xmlGetIntSubset(void) {
20267: int test_ret = 0;
20268:
20269: int mem_base;
20270: xmlDtdPtr ret_val;
20271: xmlDocPtr doc; /* the document pointer */
20272: int n_doc;
20273:
20274: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
20275: mem_base = xmlMemBlocks();
20276: doc = gen_xmlDocPtr(n_doc, 0);
20277:
20278: ret_val = xmlGetIntSubset(doc);
20279: desret_xmlDtdPtr(ret_val);
20280: call_tests++;
20281: des_xmlDocPtr(n_doc, doc, 0);
20282: xmlResetLastError();
20283: if (mem_base != xmlMemBlocks()) {
20284: printf("Leak of %d blocks found in xmlGetIntSubset",
20285: xmlMemBlocks() - mem_base);
20286: test_ret++;
20287: printf(" %d", n_doc);
20288: printf("\n");
20289: }
20290: }
20291: function_tests++;
20292:
20293: return(test_ret);
20294: }
20295:
20296:
20297: static int
20298: test_xmlGetLastChild(void) {
20299: int test_ret = 0;
20300:
20301: int mem_base;
20302: xmlNodePtr ret_val;
20303: xmlNodePtr parent; /* the parent node */
20304: int n_parent;
20305:
20306: for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
20307: mem_base = xmlMemBlocks();
20308: parent = gen_xmlNodePtr(n_parent, 0);
20309:
20310: ret_val = xmlGetLastChild(parent);
20311: desret_xmlNodePtr(ret_val);
20312: call_tests++;
20313: des_xmlNodePtr(n_parent, parent, 0);
20314: xmlResetLastError();
20315: if (mem_base != xmlMemBlocks()) {
20316: printf("Leak of %d blocks found in xmlGetLastChild",
20317: xmlMemBlocks() - mem_base);
20318: test_ret++;
20319: printf(" %d", n_parent);
20320: printf("\n");
20321: }
20322: }
20323: function_tests++;
20324:
20325: return(test_ret);
20326: }
20327:
20328:
20329: static int
20330: test_xmlGetLineNo(void) {
20331: int test_ret = 0;
20332:
20333: int mem_base;
20334: long ret_val;
20335: xmlNodePtr node; /* valid node */
20336: int n_node;
20337:
20338: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
20339: mem_base = xmlMemBlocks();
20340: node = gen_xmlNodePtr(n_node, 0);
20341:
20342: ret_val = xmlGetLineNo(node);
20343: desret_long(ret_val);
20344: call_tests++;
20345: des_xmlNodePtr(n_node, node, 0);
20346: xmlResetLastError();
20347: if (mem_base != xmlMemBlocks()) {
20348: printf("Leak of %d blocks found in xmlGetLineNo",
20349: xmlMemBlocks() - mem_base);
20350: test_ret++;
20351: printf(" %d", n_node);
20352: printf("\n");
20353: }
20354: }
20355: function_tests++;
20356:
20357: return(test_ret);
20358: }
20359:
20360:
20361: static int
20362: test_xmlGetNoNsProp(void) {
20363: int test_ret = 0;
20364:
20365: int mem_base;
20366: xmlChar * ret_val;
20367: xmlNodePtr node; /* the node */
20368: int n_node;
20369: xmlChar * name; /* the attribute name */
20370: int n_name;
20371:
20372: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
20373: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
20374: mem_base = xmlMemBlocks();
20375: node = gen_xmlNodePtr(n_node, 0);
20376: name = gen_const_xmlChar_ptr(n_name, 1);
20377:
20378: ret_val = xmlGetNoNsProp(node, (const xmlChar *)name);
20379: desret_xmlChar_ptr(ret_val);
20380: call_tests++;
20381: des_xmlNodePtr(n_node, node, 0);
20382: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
20383: xmlResetLastError();
20384: if (mem_base != xmlMemBlocks()) {
20385: printf("Leak of %d blocks found in xmlGetNoNsProp",
20386: xmlMemBlocks() - mem_base);
20387: test_ret++;
20388: printf(" %d", n_node);
20389: printf(" %d", n_name);
20390: printf("\n");
20391: }
20392: }
20393: }
20394: function_tests++;
20395:
20396: return(test_ret);
20397: }
20398:
20399:
20400: static int
20401: test_xmlGetNodePath(void) {
20402: int test_ret = 0;
20403:
20404: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED)
20405: int mem_base;
20406: xmlChar * ret_val;
20407: xmlNodePtr node; /* a node */
20408: int n_node;
20409:
20410: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
20411: mem_base = xmlMemBlocks();
20412: node = gen_xmlNodePtr(n_node, 0);
20413:
20414: ret_val = xmlGetNodePath(node);
20415: desret_xmlChar_ptr(ret_val);
20416: call_tests++;
20417: des_xmlNodePtr(n_node, node, 0);
20418: xmlResetLastError();
20419: if (mem_base != xmlMemBlocks()) {
20420: printf("Leak of %d blocks found in xmlGetNodePath",
20421: xmlMemBlocks() - mem_base);
20422: test_ret++;
20423: printf(" %d", n_node);
20424: printf("\n");
20425: }
20426: }
20427: function_tests++;
20428: #endif
20429:
20430: return(test_ret);
20431: }
20432:
20433:
20434: static int
20435: test_xmlGetNsList(void) {
20436: int test_ret = 0;
20437:
20438:
20439: /* missing type support */
20440: return(test_ret);
20441: }
20442:
20443:
20444: static int
20445: test_xmlGetNsProp(void) {
20446: int test_ret = 0;
20447:
20448: int mem_base;
20449: xmlChar * ret_val;
20450: xmlNodePtr node; /* the node */
20451: int n_node;
20452: xmlChar * name; /* the attribute name */
20453: int n_name;
20454: xmlChar * nameSpace; /* the URI of the namespace */
20455: int n_nameSpace;
20456:
20457: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
20458: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
20459: for (n_nameSpace = 0;n_nameSpace < gen_nb_const_xmlChar_ptr;n_nameSpace++) {
20460: mem_base = xmlMemBlocks();
20461: node = gen_xmlNodePtr(n_node, 0);
20462: name = gen_const_xmlChar_ptr(n_name, 1);
20463: nameSpace = gen_const_xmlChar_ptr(n_nameSpace, 2);
20464:
20465: ret_val = xmlGetNsProp(node, (const xmlChar *)name, (const xmlChar *)nameSpace);
20466: desret_xmlChar_ptr(ret_val);
20467: call_tests++;
20468: des_xmlNodePtr(n_node, node, 0);
20469: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
20470: des_const_xmlChar_ptr(n_nameSpace, (const xmlChar *)nameSpace, 2);
20471: xmlResetLastError();
20472: if (mem_base != xmlMemBlocks()) {
20473: printf("Leak of %d blocks found in xmlGetNsProp",
20474: xmlMemBlocks() - mem_base);
20475: test_ret++;
20476: printf(" %d", n_node);
20477: printf(" %d", n_name);
20478: printf(" %d", n_nameSpace);
20479: printf("\n");
20480: }
20481: }
20482: }
20483: }
20484: function_tests++;
20485:
20486: return(test_ret);
20487: }
20488:
20489:
20490: static int
20491: test_xmlGetProp(void) {
20492: int test_ret = 0;
20493:
20494: int mem_base;
20495: xmlChar * ret_val;
20496: xmlNodePtr node; /* the node */
20497: int n_node;
20498: xmlChar * name; /* the attribute name */
20499: int n_name;
20500:
20501: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
20502: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
20503: mem_base = xmlMemBlocks();
20504: node = gen_xmlNodePtr(n_node, 0);
20505: name = gen_const_xmlChar_ptr(n_name, 1);
20506:
20507: ret_val = xmlGetProp(node, (const xmlChar *)name);
20508: desret_xmlChar_ptr(ret_val);
20509: call_tests++;
20510: des_xmlNodePtr(n_node, node, 0);
20511: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
20512: xmlResetLastError();
20513: if (mem_base != xmlMemBlocks()) {
20514: printf("Leak of %d blocks found in xmlGetProp",
20515: xmlMemBlocks() - mem_base);
20516: test_ret++;
20517: printf(" %d", n_node);
20518: printf(" %d", n_name);
20519: printf("\n");
20520: }
20521: }
20522: }
20523: function_tests++;
20524:
20525: return(test_ret);
20526: }
20527:
20528:
20529: static int
20530: test_xmlHasNsProp(void) {
20531: int test_ret = 0;
20532:
20533: int mem_base;
20534: xmlAttrPtr ret_val;
20535: xmlNodePtr node; /* the node */
20536: int n_node;
20537: xmlChar * name; /* the attribute name */
20538: int n_name;
20539: xmlChar * nameSpace; /* the URI of the namespace */
20540: int n_nameSpace;
20541:
20542: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
20543: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
20544: for (n_nameSpace = 0;n_nameSpace < gen_nb_const_xmlChar_ptr;n_nameSpace++) {
20545: mem_base = xmlMemBlocks();
20546: node = gen_xmlNodePtr(n_node, 0);
20547: name = gen_const_xmlChar_ptr(n_name, 1);
20548: nameSpace = gen_const_xmlChar_ptr(n_nameSpace, 2);
20549:
20550: ret_val = xmlHasNsProp(node, (const xmlChar *)name, (const xmlChar *)nameSpace);
20551: desret_xmlAttrPtr(ret_val);
20552: call_tests++;
20553: des_xmlNodePtr(n_node, node, 0);
20554: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
20555: des_const_xmlChar_ptr(n_nameSpace, (const xmlChar *)nameSpace, 2);
20556: xmlResetLastError();
20557: if (mem_base != xmlMemBlocks()) {
20558: printf("Leak of %d blocks found in xmlHasNsProp",
20559: xmlMemBlocks() - mem_base);
20560: test_ret++;
20561: printf(" %d", n_node);
20562: printf(" %d", n_name);
20563: printf(" %d", n_nameSpace);
20564: printf("\n");
20565: }
20566: }
20567: }
20568: }
20569: function_tests++;
20570:
20571: return(test_ret);
20572: }
20573:
20574:
20575: static int
20576: test_xmlHasProp(void) {
20577: int test_ret = 0;
20578:
20579: int mem_base;
20580: xmlAttrPtr ret_val;
20581: xmlNodePtr node; /* the node */
20582: int n_node;
20583: xmlChar * name; /* the attribute name */
20584: int n_name;
20585:
20586: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
20587: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
20588: mem_base = xmlMemBlocks();
20589: node = gen_xmlNodePtr(n_node, 0);
20590: name = gen_const_xmlChar_ptr(n_name, 1);
20591:
20592: ret_val = xmlHasProp(node, (const xmlChar *)name);
20593: desret_xmlAttrPtr(ret_val);
20594: call_tests++;
20595: des_xmlNodePtr(n_node, node, 0);
20596: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
20597: xmlResetLastError();
20598: if (mem_base != xmlMemBlocks()) {
20599: printf("Leak of %d blocks found in xmlHasProp",
20600: xmlMemBlocks() - mem_base);
20601: test_ret++;
20602: printf(" %d", n_node);
20603: printf(" %d", n_name);
20604: printf("\n");
20605: }
20606: }
20607: }
20608: function_tests++;
20609:
20610: return(test_ret);
20611: }
20612:
20613:
20614: static int
20615: test_xmlIsBlankNode(void) {
20616: int test_ret = 0;
20617:
20618: int mem_base;
20619: int ret_val;
20620: xmlNodePtr node; /* the node */
20621: int n_node;
20622:
20623: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
20624: mem_base = xmlMemBlocks();
20625: node = gen_xmlNodePtr(n_node, 0);
20626:
20627: ret_val = xmlIsBlankNode(node);
20628: desret_int(ret_val);
20629: call_tests++;
20630: des_xmlNodePtr(n_node, node, 0);
20631: xmlResetLastError();
20632: if (mem_base != xmlMemBlocks()) {
20633: printf("Leak of %d blocks found in xmlIsBlankNode",
20634: xmlMemBlocks() - mem_base);
20635: test_ret++;
20636: printf(" %d", n_node);
20637: printf("\n");
20638: }
20639: }
20640: function_tests++;
20641:
20642: return(test_ret);
20643: }
20644:
20645:
20646: static int
20647: test_xmlIsXHTML(void) {
20648: int test_ret = 0;
20649:
20650: int mem_base;
20651: int ret_val;
20652: xmlChar * systemID; /* the system identifier */
20653: int n_systemID;
20654: xmlChar * publicID; /* the public identifier */
20655: int n_publicID;
20656:
20657: for (n_systemID = 0;n_systemID < gen_nb_const_xmlChar_ptr;n_systemID++) {
20658: for (n_publicID = 0;n_publicID < gen_nb_const_xmlChar_ptr;n_publicID++) {
20659: mem_base = xmlMemBlocks();
20660: systemID = gen_const_xmlChar_ptr(n_systemID, 0);
20661: publicID = gen_const_xmlChar_ptr(n_publicID, 1);
20662:
20663: ret_val = xmlIsXHTML((const xmlChar *)systemID, (const xmlChar *)publicID);
20664: desret_int(ret_val);
20665: call_tests++;
20666: des_const_xmlChar_ptr(n_systemID, (const xmlChar *)systemID, 0);
20667: des_const_xmlChar_ptr(n_publicID, (const xmlChar *)publicID, 1);
20668: xmlResetLastError();
20669: if (mem_base != xmlMemBlocks()) {
20670: printf("Leak of %d blocks found in xmlIsXHTML",
20671: xmlMemBlocks() - mem_base);
20672: test_ret++;
20673: printf(" %d", n_systemID);
20674: printf(" %d", n_publicID);
20675: printf("\n");
20676: }
20677: }
20678: }
20679: function_tests++;
20680:
20681: return(test_ret);
20682: }
20683:
20684:
20685: static int
20686: test_xmlLastElementChild(void) {
20687: int test_ret = 0;
20688:
20689: #if defined(LIBXML_TREE_ENABLED)
20690: int mem_base;
20691: xmlNodePtr ret_val;
20692: xmlNodePtr parent; /* the parent node */
20693: int n_parent;
20694:
20695: for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
20696: mem_base = xmlMemBlocks();
20697: parent = gen_xmlNodePtr(n_parent, 0);
20698:
20699: ret_val = xmlLastElementChild(parent);
20700: desret_xmlNodePtr(ret_val);
20701: call_tests++;
20702: des_xmlNodePtr(n_parent, parent, 0);
20703: xmlResetLastError();
20704: if (mem_base != xmlMemBlocks()) {
20705: printf("Leak of %d blocks found in xmlLastElementChild",
20706: xmlMemBlocks() - mem_base);
20707: test_ret++;
20708: printf(" %d", n_parent);
20709: printf("\n");
20710: }
20711: }
20712: function_tests++;
20713: #endif
20714:
20715: return(test_ret);
20716: }
20717:
20718:
20719: static int
20720: test_xmlNewCDataBlock(void) {
20721: int test_ret = 0;
20722:
20723: int mem_base;
20724: xmlNodePtr ret_val;
20725: xmlDocPtr doc; /* the document */
20726: int n_doc;
20727: xmlChar * content; /* the CDATA block content content */
20728: int n_content;
20729: int len; /* the length of the block */
20730: int n_len;
20731:
20732: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
20733: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
20734: for (n_len = 0;n_len < gen_nb_int;n_len++) {
20735: mem_base = xmlMemBlocks();
20736: doc = gen_xmlDocPtr(n_doc, 0);
20737: content = gen_const_xmlChar_ptr(n_content, 1);
20738: len = gen_int(n_len, 2);
20739:
20740: ret_val = xmlNewCDataBlock(doc, (const xmlChar *)content, len);
20741: desret_xmlNodePtr(ret_val);
20742: call_tests++;
20743: des_xmlDocPtr(n_doc, doc, 0);
20744: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
20745: des_int(n_len, len, 2);
20746: xmlResetLastError();
20747: if (mem_base != xmlMemBlocks()) {
20748: printf("Leak of %d blocks found in xmlNewCDataBlock",
20749: xmlMemBlocks() - mem_base);
20750: test_ret++;
20751: printf(" %d", n_doc);
20752: printf(" %d", n_content);
20753: printf(" %d", n_len);
20754: printf("\n");
20755: }
20756: }
20757: }
20758: }
20759: function_tests++;
20760:
20761: return(test_ret);
20762: }
20763:
20764:
20765: static int
20766: test_xmlNewCharRef(void) {
20767: int test_ret = 0;
20768:
20769: int mem_base;
20770: xmlNodePtr ret_val;
20771: xmlDocPtr doc; /* the document */
20772: int n_doc;
20773: xmlChar * name; /* the char ref string, starting with # or "&# ... ;" */
20774: int n_name;
20775:
20776: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
20777: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
20778: mem_base = xmlMemBlocks();
20779: doc = gen_xmlDocPtr(n_doc, 0);
20780: name = gen_const_xmlChar_ptr(n_name, 1);
20781:
20782: ret_val = xmlNewCharRef(doc, (const xmlChar *)name);
20783: desret_xmlNodePtr(ret_val);
20784: call_tests++;
20785: des_xmlDocPtr(n_doc, doc, 0);
20786: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
20787: xmlResetLastError();
20788: if (mem_base != xmlMemBlocks()) {
20789: printf("Leak of %d blocks found in xmlNewCharRef",
20790: xmlMemBlocks() - mem_base);
20791: test_ret++;
20792: printf(" %d", n_doc);
20793: printf(" %d", n_name);
20794: printf("\n");
20795: }
20796: }
20797: }
20798: function_tests++;
20799:
20800: return(test_ret);
20801: }
20802:
20803:
20804: static int
20805: test_xmlNewChild(void) {
20806: int test_ret = 0;
20807:
20808: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
20809: #ifdef LIBXML_TREE_ENABLED
20810: int mem_base;
20811: xmlNodePtr ret_val;
20812: xmlNodePtr parent; /* the parent node */
20813: int n_parent;
20814: xmlNsPtr ns; /* a namespace if any */
20815: int n_ns;
20816: xmlChar * name; /* the name of the child */
20817: int n_name;
20818: xmlChar * content; /* the XML content of the child if any. */
20819: int n_content;
20820:
20821: for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
20822: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
20823: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
20824: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
20825: mem_base = xmlMemBlocks();
20826: parent = gen_xmlNodePtr(n_parent, 0);
20827: ns = gen_xmlNsPtr(n_ns, 1);
20828: name = gen_const_xmlChar_ptr(n_name, 2);
20829: content = gen_const_xmlChar_ptr(n_content, 3);
20830:
20831: ret_val = xmlNewChild(parent, ns, (const xmlChar *)name, (const xmlChar *)content);
20832: desret_xmlNodePtr(ret_val);
20833: call_tests++;
20834: des_xmlNodePtr(n_parent, parent, 0);
20835: des_xmlNsPtr(n_ns, ns, 1);
20836: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
20837: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3);
20838: xmlResetLastError();
20839: if (mem_base != xmlMemBlocks()) {
20840: printf("Leak of %d blocks found in xmlNewChild",
20841: xmlMemBlocks() - mem_base);
20842: test_ret++;
20843: printf(" %d", n_parent);
20844: printf(" %d", n_ns);
20845: printf(" %d", n_name);
20846: printf(" %d", n_content);
20847: printf("\n");
20848: }
20849: }
20850: }
20851: }
20852: }
20853: function_tests++;
20854: #endif
20855: #endif
20856:
20857: return(test_ret);
20858: }
20859:
20860:
20861: static int
20862: test_xmlNewComment(void) {
20863: int test_ret = 0;
20864:
20865: int mem_base;
20866: xmlNodePtr ret_val;
20867: xmlChar * content; /* the comment content */
20868: int n_content;
20869:
20870: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
20871: mem_base = xmlMemBlocks();
20872: content = gen_const_xmlChar_ptr(n_content, 0);
20873:
20874: ret_val = xmlNewComment((const xmlChar *)content);
20875: desret_xmlNodePtr(ret_val);
20876: call_tests++;
20877: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 0);
20878: xmlResetLastError();
20879: if (mem_base != xmlMemBlocks()) {
20880: printf("Leak of %d blocks found in xmlNewComment",
20881: xmlMemBlocks() - mem_base);
20882: test_ret++;
20883: printf(" %d", n_content);
20884: printf("\n");
20885: }
20886: }
20887: function_tests++;
20888:
20889: return(test_ret);
20890: }
20891:
20892:
20893: static int
20894: test_xmlNewDoc(void) {
20895: int test_ret = 0;
20896:
20897: int mem_base;
20898: xmlDocPtr ret_val;
20899: xmlChar * version; /* xmlChar string giving the version of XML "1.0" */
20900: int n_version;
20901:
20902: for (n_version = 0;n_version < gen_nb_const_xmlChar_ptr;n_version++) {
20903: mem_base = xmlMemBlocks();
20904: version = gen_const_xmlChar_ptr(n_version, 0);
20905:
20906: ret_val = xmlNewDoc((const xmlChar *)version);
20907: desret_xmlDocPtr(ret_val);
20908: call_tests++;
20909: des_const_xmlChar_ptr(n_version, (const xmlChar *)version, 0);
20910: xmlResetLastError();
20911: if (mem_base != xmlMemBlocks()) {
20912: printf("Leak of %d blocks found in xmlNewDoc",
20913: xmlMemBlocks() - mem_base);
20914: test_ret++;
20915: printf(" %d", n_version);
20916: printf("\n");
20917: }
20918: }
20919: function_tests++;
20920:
20921: return(test_ret);
20922: }
20923:
20924:
20925: static int
20926: test_xmlNewDocComment(void) {
20927: int test_ret = 0;
20928:
20929: int mem_base;
20930: xmlNodePtr ret_val;
20931: xmlDocPtr doc; /* the document */
20932: int n_doc;
20933: xmlChar * content; /* the comment content */
20934: int n_content;
20935:
20936: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
20937: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
20938: mem_base = xmlMemBlocks();
20939: doc = gen_xmlDocPtr(n_doc, 0);
20940: content = gen_const_xmlChar_ptr(n_content, 1);
20941:
20942: ret_val = xmlNewDocComment(doc, (const xmlChar *)content);
20943: desret_xmlNodePtr(ret_val);
20944: call_tests++;
20945: des_xmlDocPtr(n_doc, doc, 0);
20946: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
20947: xmlResetLastError();
20948: if (mem_base != xmlMemBlocks()) {
20949: printf("Leak of %d blocks found in xmlNewDocComment",
20950: xmlMemBlocks() - mem_base);
20951: test_ret++;
20952: printf(" %d", n_doc);
20953: printf(" %d", n_content);
20954: printf("\n");
20955: }
20956: }
20957: }
20958: function_tests++;
20959:
20960: return(test_ret);
20961: }
20962:
20963:
20964: static int
20965: test_xmlNewDocFragment(void) {
20966: int test_ret = 0;
20967:
20968: #if defined(LIBXML_TREE_ENABLED)
20969: int mem_base;
20970: xmlNodePtr ret_val;
20971: xmlDocPtr doc; /* the document owning the fragment */
20972: int n_doc;
20973:
20974: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
20975: mem_base = xmlMemBlocks();
20976: doc = gen_xmlDocPtr(n_doc, 0);
20977:
20978: ret_val = xmlNewDocFragment(doc);
20979: desret_xmlNodePtr(ret_val);
20980: call_tests++;
20981: des_xmlDocPtr(n_doc, doc, 0);
20982: xmlResetLastError();
20983: if (mem_base != xmlMemBlocks()) {
20984: printf("Leak of %d blocks found in xmlNewDocFragment",
20985: xmlMemBlocks() - mem_base);
20986: test_ret++;
20987: printf(" %d", n_doc);
20988: printf("\n");
20989: }
20990: }
20991: function_tests++;
20992: #endif
20993:
20994: return(test_ret);
20995: }
20996:
20997:
20998: static int
20999: test_xmlNewDocNode(void) {
21000: int test_ret = 0;
21001:
21002: int mem_base;
21003: xmlNodePtr ret_val;
21004: xmlDocPtr doc; /* the document */
21005: int n_doc;
21006: xmlNsPtr ns; /* namespace if any */
21007: int n_ns;
21008: xmlChar * name; /* the node name */
21009: int n_name;
21010: xmlChar * content; /* the XML text content if any */
21011: int n_content;
21012:
21013: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21014: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
21015: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21016: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21017: mem_base = xmlMemBlocks();
21018: doc = gen_xmlDocPtr(n_doc, 0);
21019: ns = gen_xmlNsPtr(n_ns, 1);
21020: name = gen_const_xmlChar_ptr(n_name, 2);
21021: content = gen_const_xmlChar_ptr(n_content, 3);
21022:
21023: ret_val = xmlNewDocNode(doc, ns, (const xmlChar *)name, (const xmlChar *)content);
21024: desret_xmlNodePtr(ret_val);
21025: call_tests++;
21026: des_xmlDocPtr(n_doc, doc, 0);
21027: des_xmlNsPtr(n_ns, ns, 1);
21028: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
21029: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3);
21030: xmlResetLastError();
21031: if (mem_base != xmlMemBlocks()) {
21032: printf("Leak of %d blocks found in xmlNewDocNode",
21033: xmlMemBlocks() - mem_base);
21034: test_ret++;
21035: printf(" %d", n_doc);
21036: printf(" %d", n_ns);
21037: printf(" %d", n_name);
21038: printf(" %d", n_content);
21039: printf("\n");
21040: }
21041: }
21042: }
21043: }
21044: }
21045: function_tests++;
21046:
21047: return(test_ret);
21048: }
21049:
21050:
21051: static int
21052: test_xmlNewDocNodeEatName(void) {
21053: int test_ret = 0;
21054:
21055: int mem_base;
21056: xmlNodePtr ret_val;
21057: xmlDocPtr doc; /* the document */
21058: int n_doc;
21059: xmlNsPtr ns; /* namespace if any */
21060: int n_ns;
21061: xmlChar * name; /* the node name */
21062: int n_name;
21063: xmlChar * content; /* the XML text content if any */
21064: int n_content;
21065:
21066: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21067: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
21068: for (n_name = 0;n_name < gen_nb_eaten_name;n_name++) {
21069: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21070: mem_base = xmlMemBlocks();
21071: doc = gen_xmlDocPtr(n_doc, 0);
21072: ns = gen_xmlNsPtr(n_ns, 1);
21073: name = gen_eaten_name(n_name, 2);
21074: content = gen_const_xmlChar_ptr(n_content, 3);
21075:
21076: ret_val = xmlNewDocNodeEatName(doc, ns, name, (const xmlChar *)content);
21077: desret_xmlNodePtr(ret_val);
21078: call_tests++;
21079: des_xmlDocPtr(n_doc, doc, 0);
21080: des_xmlNsPtr(n_ns, ns, 1);
21081: des_eaten_name(n_name, name, 2);
21082: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3);
21083: xmlResetLastError();
21084: if (mem_base != xmlMemBlocks()) {
21085: printf("Leak of %d blocks found in xmlNewDocNodeEatName",
21086: xmlMemBlocks() - mem_base);
21087: test_ret++;
21088: printf(" %d", n_doc);
21089: printf(" %d", n_ns);
21090: printf(" %d", n_name);
21091: printf(" %d", n_content);
21092: printf("\n");
21093: }
21094: }
21095: }
21096: }
21097: }
21098: function_tests++;
21099:
21100: return(test_ret);
21101: }
21102:
21103:
21104: static int
21105: test_xmlNewDocPI(void) {
21106: int test_ret = 0;
21107:
21108: int mem_base;
21109: xmlNodePtr ret_val;
21110: xmlDocPtr doc; /* the target document */
21111: int n_doc;
21112: xmlChar * name; /* the processing instruction name */
21113: int n_name;
21114: xmlChar * content; /* the PI content */
21115: int n_content;
21116:
21117: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21118: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21119: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21120: mem_base = xmlMemBlocks();
21121: doc = gen_xmlDocPtr(n_doc, 0);
21122: name = gen_const_xmlChar_ptr(n_name, 1);
21123: content = gen_const_xmlChar_ptr(n_content, 2);
21124:
21125: ret_val = xmlNewDocPI(doc, (const xmlChar *)name, (const xmlChar *)content);
21126: desret_xmlNodePtr(ret_val);
21127: call_tests++;
21128: des_xmlDocPtr(n_doc, doc, 0);
21129: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
21130: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2);
21131: xmlResetLastError();
21132: if (mem_base != xmlMemBlocks()) {
21133: printf("Leak of %d blocks found in xmlNewDocPI",
21134: xmlMemBlocks() - mem_base);
21135: test_ret++;
21136: printf(" %d", n_doc);
21137: printf(" %d", n_name);
21138: printf(" %d", n_content);
21139: printf("\n");
21140: }
21141: }
21142: }
21143: }
21144: function_tests++;
21145:
21146: return(test_ret);
21147: }
21148:
21149:
21150: static int
21151: test_xmlNewDocProp(void) {
21152: int test_ret = 0;
21153:
21154: int mem_base;
21155: xmlAttrPtr ret_val;
21156: xmlDocPtr doc; /* the document */
21157: int n_doc;
21158: xmlChar * name; /* the name of the attribute */
21159: int n_name;
21160: xmlChar * value; /* the value of the attribute */
21161: int n_value;
21162:
21163: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21164: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21165: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
21166: mem_base = xmlMemBlocks();
21167: doc = gen_xmlDocPtr(n_doc, 0);
21168: name = gen_const_xmlChar_ptr(n_name, 1);
21169: value = gen_const_xmlChar_ptr(n_value, 2);
21170:
21171: ret_val = xmlNewDocProp(doc, (const xmlChar *)name, (const xmlChar *)value);
21172: desret_xmlAttrPtr(ret_val);
21173: call_tests++;
21174: des_xmlDocPtr(n_doc, doc, 0);
21175: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
21176: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2);
21177: xmlResetLastError();
21178: if (mem_base != xmlMemBlocks()) {
21179: printf("Leak of %d blocks found in xmlNewDocProp",
21180: xmlMemBlocks() - mem_base);
21181: test_ret++;
21182: printf(" %d", n_doc);
21183: printf(" %d", n_name);
21184: printf(" %d", n_value);
21185: printf("\n");
21186: }
21187: }
21188: }
21189: }
21190: function_tests++;
21191:
21192: return(test_ret);
21193: }
21194:
21195:
21196: static int
21197: test_xmlNewDocRawNode(void) {
21198: int test_ret = 0;
21199:
21200: #if defined(LIBXML_TREE_ENABLED)
21201: #ifdef LIBXML_TREE_ENABLED
21202: int mem_base;
21203: xmlNodePtr ret_val;
21204: xmlDocPtr doc; /* the document */
21205: int n_doc;
21206: xmlNsPtr ns; /* namespace if any */
21207: int n_ns;
21208: xmlChar * name; /* the node name */
21209: int n_name;
21210: xmlChar * content; /* the text content if any */
21211: int n_content;
21212:
21213: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21214: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
21215: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21216: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21217: mem_base = xmlMemBlocks();
21218: doc = gen_xmlDocPtr(n_doc, 0);
21219: ns = gen_xmlNsPtr(n_ns, 1);
21220: name = gen_const_xmlChar_ptr(n_name, 2);
21221: content = gen_const_xmlChar_ptr(n_content, 3);
21222:
21223: ret_val = xmlNewDocRawNode(doc, ns, (const xmlChar *)name, (const xmlChar *)content);
21224: desret_xmlNodePtr(ret_val);
21225: call_tests++;
21226: des_xmlDocPtr(n_doc, doc, 0);
21227: des_xmlNsPtr(n_ns, ns, 1);
21228: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
21229: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3);
21230: xmlResetLastError();
21231: if (mem_base != xmlMemBlocks()) {
21232: printf("Leak of %d blocks found in xmlNewDocRawNode",
21233: xmlMemBlocks() - mem_base);
21234: test_ret++;
21235: printf(" %d", n_doc);
21236: printf(" %d", n_ns);
21237: printf(" %d", n_name);
21238: printf(" %d", n_content);
21239: printf("\n");
21240: }
21241: }
21242: }
21243: }
21244: }
21245: function_tests++;
21246: #endif
21247: #endif
21248:
21249: return(test_ret);
21250: }
21251:
21252:
21253: static int
21254: test_xmlNewDocText(void) {
21255: int test_ret = 0;
21256:
21257: int mem_base;
21258: xmlNodePtr ret_val;
21259: xmlDocPtr doc; /* the document */
21260: int n_doc;
21261: xmlChar * content; /* the text content */
21262: int n_content;
21263:
21264: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21265: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21266: mem_base = xmlMemBlocks();
21267: doc = gen_xmlDocPtr(n_doc, 0);
21268: content = gen_const_xmlChar_ptr(n_content, 1);
21269:
21270: ret_val = xmlNewDocText(doc, (const xmlChar *)content);
21271: desret_xmlNodePtr(ret_val);
21272: call_tests++;
21273: des_xmlDocPtr(n_doc, doc, 0);
21274: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
21275: xmlResetLastError();
21276: if (mem_base != xmlMemBlocks()) {
21277: printf("Leak of %d blocks found in xmlNewDocText",
21278: xmlMemBlocks() - mem_base);
21279: test_ret++;
21280: printf(" %d", n_doc);
21281: printf(" %d", n_content);
21282: printf("\n");
21283: }
21284: }
21285: }
21286: function_tests++;
21287:
21288: return(test_ret);
21289: }
21290:
21291:
21292: static int
21293: test_xmlNewDocTextLen(void) {
21294: int test_ret = 0;
21295:
21296: int mem_base;
21297: xmlNodePtr ret_val;
21298: xmlDocPtr doc; /* the document */
21299: int n_doc;
21300: xmlChar * content; /* the text content */
21301: int n_content;
21302: int len; /* the text len. */
21303: int n_len;
21304:
21305: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21306: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21307: for (n_len = 0;n_len < gen_nb_int;n_len++) {
21308: mem_base = xmlMemBlocks();
21309: doc = gen_xmlDocPtr(n_doc, 0);
21310: content = gen_const_xmlChar_ptr(n_content, 1);
21311: len = gen_int(n_len, 2);
21312:
21313: ret_val = xmlNewDocTextLen(doc, (const xmlChar *)content, len);
21314: desret_xmlNodePtr(ret_val);
21315: call_tests++;
21316: des_xmlDocPtr(n_doc, doc, 0);
21317: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
21318: des_int(n_len, len, 2);
21319: xmlResetLastError();
21320: if (mem_base != xmlMemBlocks()) {
21321: printf("Leak of %d blocks found in xmlNewDocTextLen",
21322: xmlMemBlocks() - mem_base);
21323: test_ret++;
21324: printf(" %d", n_doc);
21325: printf(" %d", n_content);
21326: printf(" %d", n_len);
21327: printf("\n");
21328: }
21329: }
21330: }
21331: }
21332: function_tests++;
21333:
21334: return(test_ret);
21335: }
21336:
21337:
21338: static int
21339: test_xmlNewDtd(void) {
21340: int test_ret = 0;
21341:
21342: int mem_base;
21343: xmlDtdPtr ret_val;
21344: xmlDocPtr doc; /* the document pointer */
21345: int n_doc;
21346: xmlChar * name; /* the DTD name */
21347: int n_name;
21348: xmlChar * ExternalID; /* the external ID */
21349: int n_ExternalID;
21350: xmlChar * SystemID; /* the system ID */
21351: int n_SystemID;
21352:
21353: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21354: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21355: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
21356: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
21357: mem_base = xmlMemBlocks();
21358: doc = gen_xmlDocPtr(n_doc, 0);
21359: name = gen_const_xmlChar_ptr(n_name, 1);
21360: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 2);
21361: SystemID = gen_const_xmlChar_ptr(n_SystemID, 3);
21362:
21363: ret_val = xmlNewDtd(doc, (const xmlChar *)name, (const xmlChar *)ExternalID, (const xmlChar *)SystemID);
21364: desret_xmlDtdPtr(ret_val);
21365: call_tests++;
21366: des_xmlDocPtr(n_doc, doc, 0);
21367: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
21368: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 2);
21369: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 3);
21370: xmlResetLastError();
21371: if (mem_base != xmlMemBlocks()) {
21372: printf("Leak of %d blocks found in xmlNewDtd",
21373: xmlMemBlocks() - mem_base);
21374: test_ret++;
21375: printf(" %d", n_doc);
21376: printf(" %d", n_name);
21377: printf(" %d", n_ExternalID);
21378: printf(" %d", n_SystemID);
21379: printf("\n");
21380: }
21381: }
21382: }
21383: }
21384: }
21385: function_tests++;
21386:
21387: return(test_ret);
21388: }
21389:
21390:
21391: static int
21392: test_xmlNewNode(void) {
21393: int test_ret = 0;
21394:
21395: int mem_base;
21396: xmlNodePtr ret_val;
21397: xmlNsPtr ns; /* namespace if any */
21398: int n_ns;
21399: xmlChar * name; /* the node name */
21400: int n_name;
21401:
21402: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
21403: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21404: mem_base = xmlMemBlocks();
21405: ns = gen_xmlNsPtr(n_ns, 0);
21406: name = gen_const_xmlChar_ptr(n_name, 1);
21407:
21408: ret_val = xmlNewNode(ns, (const xmlChar *)name);
21409: desret_xmlNodePtr(ret_val);
21410: call_tests++;
21411: des_xmlNsPtr(n_ns, ns, 0);
21412: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
21413: xmlResetLastError();
21414: if (mem_base != xmlMemBlocks()) {
21415: printf("Leak of %d blocks found in xmlNewNode",
21416: xmlMemBlocks() - mem_base);
21417: test_ret++;
21418: printf(" %d", n_ns);
21419: printf(" %d", n_name);
21420: printf("\n");
21421: }
21422: }
21423: }
21424: function_tests++;
21425:
21426: return(test_ret);
21427: }
21428:
21429:
21430: static int
21431: test_xmlNewNodeEatName(void) {
21432: int test_ret = 0;
21433:
21434: int mem_base;
21435: xmlNodePtr ret_val;
21436: xmlNsPtr ns; /* namespace if any */
21437: int n_ns;
21438: xmlChar * name; /* the node name */
21439: int n_name;
21440:
21441: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
21442: for (n_name = 0;n_name < gen_nb_eaten_name;n_name++) {
21443: mem_base = xmlMemBlocks();
21444: ns = gen_xmlNsPtr(n_ns, 0);
21445: name = gen_eaten_name(n_name, 1);
21446:
21447: ret_val = xmlNewNodeEatName(ns, name);
21448: desret_xmlNodePtr(ret_val);
21449: call_tests++;
21450: des_xmlNsPtr(n_ns, ns, 0);
21451: des_eaten_name(n_name, name, 1);
21452: xmlResetLastError();
21453: if (mem_base != xmlMemBlocks()) {
21454: printf("Leak of %d blocks found in xmlNewNodeEatName",
21455: xmlMemBlocks() - mem_base);
21456: test_ret++;
21457: printf(" %d", n_ns);
21458: printf(" %d", n_name);
21459: printf("\n");
21460: }
21461: }
21462: }
21463: function_tests++;
21464:
21465: return(test_ret);
21466: }
21467:
21468:
21469: static int
21470: test_xmlNewNs(void) {
21471: int test_ret = 0;
21472:
21473: int mem_base;
21474: xmlNsPtr ret_val;
21475: xmlNodePtr node; /* the element carrying the namespace */
21476: int n_node;
21477: xmlChar * href; /* the URI associated */
21478: int n_href;
21479: xmlChar * prefix; /* the prefix for the namespace */
21480: int n_prefix;
21481:
21482: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
21483: for (n_href = 0;n_href < gen_nb_const_xmlChar_ptr;n_href++) {
21484: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
21485: mem_base = xmlMemBlocks();
21486: node = gen_xmlNodePtr(n_node, 0);
21487: href = gen_const_xmlChar_ptr(n_href, 1);
21488: prefix = gen_const_xmlChar_ptr(n_prefix, 2);
21489:
21490: ret_val = xmlNewNs(node, (const xmlChar *)href, (const xmlChar *)prefix);
21491: if ((node == NULL) && (ret_val != NULL)) xmlFreeNs(ret_val);
21492: desret_xmlNsPtr(ret_val);
21493: call_tests++;
21494: des_xmlNodePtr(n_node, node, 0);
21495: des_const_xmlChar_ptr(n_href, (const xmlChar *)href, 1);
21496: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 2);
21497: xmlResetLastError();
21498: if (mem_base != xmlMemBlocks()) {
21499: printf("Leak of %d blocks found in xmlNewNs",
21500: xmlMemBlocks() - mem_base);
21501: test_ret++;
21502: printf(" %d", n_node);
21503: printf(" %d", n_href);
21504: printf(" %d", n_prefix);
21505: printf("\n");
21506: }
21507: }
21508: }
21509: }
21510: function_tests++;
21511:
21512: return(test_ret);
21513: }
21514:
21515:
21516: static int
21517: test_xmlNewNsProp(void) {
21518: int test_ret = 0;
21519:
21520: int mem_base;
21521: xmlAttrPtr ret_val;
21522: xmlNodePtr node; /* the holding node */
21523: int n_node;
21524: xmlNsPtr ns; /* the namespace */
21525: int n_ns;
21526: xmlChar * name; /* the name of the attribute */
21527: int n_name;
21528: xmlChar * value; /* the value of the attribute */
21529: int n_value;
21530:
21531: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
21532: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
21533: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21534: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
21535: mem_base = xmlMemBlocks();
21536: node = gen_xmlNodePtr(n_node, 0);
21537: ns = gen_xmlNsPtr(n_ns, 1);
21538: name = gen_const_xmlChar_ptr(n_name, 2);
21539: value = gen_const_xmlChar_ptr(n_value, 3);
21540:
21541: ret_val = xmlNewNsProp(node, ns, (const xmlChar *)name, (const xmlChar *)value);
21542: desret_xmlAttrPtr(ret_val);
21543: call_tests++;
21544: des_xmlNodePtr(n_node, node, 0);
21545: des_xmlNsPtr(n_ns, ns, 1);
21546: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
21547: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 3);
21548: xmlResetLastError();
21549: if (mem_base != xmlMemBlocks()) {
21550: printf("Leak of %d blocks found in xmlNewNsProp",
21551: xmlMemBlocks() - mem_base);
21552: test_ret++;
21553: printf(" %d", n_node);
21554: printf(" %d", n_ns);
21555: printf(" %d", n_name);
21556: printf(" %d", n_value);
21557: printf("\n");
21558: }
21559: }
21560: }
21561: }
21562: }
21563: function_tests++;
21564:
21565: return(test_ret);
21566: }
21567:
21568:
21569: static int
21570: test_xmlNewNsPropEatName(void) {
21571: int test_ret = 0;
21572:
21573: int mem_base;
21574: xmlAttrPtr ret_val;
21575: xmlNodePtr node; /* the holding node */
21576: int n_node;
21577: xmlNsPtr ns; /* the namespace */
21578: int n_ns;
21579: xmlChar * name; /* the name of the attribute */
21580: int n_name;
21581: xmlChar * value; /* the value of the attribute */
21582: int n_value;
21583:
21584: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
21585: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
21586: for (n_name = 0;n_name < gen_nb_eaten_name;n_name++) {
21587: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
21588: mem_base = xmlMemBlocks();
21589: node = gen_xmlNodePtr(n_node, 0);
21590: ns = gen_xmlNsPtr(n_ns, 1);
21591: name = gen_eaten_name(n_name, 2);
21592: value = gen_const_xmlChar_ptr(n_value, 3);
21593:
21594: ret_val = xmlNewNsPropEatName(node, ns, name, (const xmlChar *)value);
21595: desret_xmlAttrPtr(ret_val);
21596: call_tests++;
21597: des_xmlNodePtr(n_node, node, 0);
21598: des_xmlNsPtr(n_ns, ns, 1);
21599: des_eaten_name(n_name, name, 2);
21600: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 3);
21601: xmlResetLastError();
21602: if (mem_base != xmlMemBlocks()) {
21603: printf("Leak of %d blocks found in xmlNewNsPropEatName",
21604: xmlMemBlocks() - mem_base);
21605: test_ret++;
21606: printf(" %d", n_node);
21607: printf(" %d", n_ns);
21608: printf(" %d", n_name);
21609: printf(" %d", n_value);
21610: printf("\n");
21611: }
21612: }
21613: }
21614: }
21615: }
21616: function_tests++;
21617:
21618: return(test_ret);
21619: }
21620:
21621:
21622: static int
21623: test_xmlNewPI(void) {
21624: int test_ret = 0;
21625:
21626: int mem_base;
21627: xmlNodePtr ret_val;
21628: xmlChar * name; /* the processing instruction name */
21629: int n_name;
21630: xmlChar * content; /* the PI content */
21631: int n_content;
21632:
21633: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21634: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21635: mem_base = xmlMemBlocks();
21636: name = gen_const_xmlChar_ptr(n_name, 0);
21637: content = gen_const_xmlChar_ptr(n_content, 1);
21638:
21639: ret_val = xmlNewPI((const xmlChar *)name, (const xmlChar *)content);
21640: desret_xmlNodePtr(ret_val);
21641: call_tests++;
21642: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
21643: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
21644: xmlResetLastError();
21645: if (mem_base != xmlMemBlocks()) {
21646: printf("Leak of %d blocks found in xmlNewPI",
21647: xmlMemBlocks() - mem_base);
21648: test_ret++;
21649: printf(" %d", n_name);
21650: printf(" %d", n_content);
21651: printf("\n");
21652: }
21653: }
21654: }
21655: function_tests++;
21656:
21657: return(test_ret);
21658: }
21659:
21660:
21661: static int
21662: test_xmlNewProp(void) {
21663: int test_ret = 0;
21664:
21665: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
21666: #ifdef LIBXML_TREE_ENABLED
21667: int mem_base;
21668: xmlAttrPtr ret_val;
21669: xmlNodePtr node; /* the holding node */
21670: int n_node;
21671: xmlChar * name; /* the name of the attribute */
21672: int n_name;
21673: xmlChar * value; /* the value of the attribute */
21674: int n_value;
21675:
21676: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
21677: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21678: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
21679: mem_base = xmlMemBlocks();
21680: node = gen_xmlNodePtr(n_node, 0);
21681: name = gen_const_xmlChar_ptr(n_name, 1);
21682: value = gen_const_xmlChar_ptr(n_value, 2);
21683:
21684: ret_val = xmlNewProp(node, (const xmlChar *)name, (const xmlChar *)value);
21685: desret_xmlAttrPtr(ret_val);
21686: call_tests++;
21687: des_xmlNodePtr(n_node, node, 0);
21688: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
21689: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2);
21690: xmlResetLastError();
21691: if (mem_base != xmlMemBlocks()) {
21692: printf("Leak of %d blocks found in xmlNewProp",
21693: xmlMemBlocks() - mem_base);
21694: test_ret++;
21695: printf(" %d", n_node);
21696: printf(" %d", n_name);
21697: printf(" %d", n_value);
21698: printf("\n");
21699: }
21700: }
21701: }
21702: }
21703: function_tests++;
21704: #endif
21705: #endif
21706:
21707: return(test_ret);
21708: }
21709:
21710:
21711: static int
21712: test_xmlNewReference(void) {
21713: int test_ret = 0;
21714:
21715: int mem_base;
21716: xmlNodePtr ret_val;
21717: xmlDocPtr doc; /* the document */
21718: int n_doc;
21719: xmlChar * name; /* the reference name, or the reference string with & and ; */
21720: int n_name;
21721:
21722: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21723: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21724: mem_base = xmlMemBlocks();
21725: doc = gen_xmlDocPtr(n_doc, 0);
21726: name = gen_const_xmlChar_ptr(n_name, 1);
21727:
21728: ret_val = xmlNewReference(doc, (const xmlChar *)name);
21729: desret_xmlNodePtr(ret_val);
21730: call_tests++;
21731: des_xmlDocPtr(n_doc, doc, 0);
21732: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
21733: xmlResetLastError();
21734: if (mem_base != xmlMemBlocks()) {
21735: printf("Leak of %d blocks found in xmlNewReference",
21736: xmlMemBlocks() - mem_base);
21737: test_ret++;
21738: printf(" %d", n_doc);
21739: printf(" %d", n_name);
21740: printf("\n");
21741: }
21742: }
21743: }
21744: function_tests++;
21745:
21746: return(test_ret);
21747: }
21748:
21749:
21750: static int
21751: test_xmlNewText(void) {
21752: int test_ret = 0;
21753:
21754: int mem_base;
21755: xmlNodePtr ret_val;
21756: xmlChar * content; /* the text content */
21757: int n_content;
21758:
21759: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21760: mem_base = xmlMemBlocks();
21761: content = gen_const_xmlChar_ptr(n_content, 0);
21762:
21763: ret_val = xmlNewText((const xmlChar *)content);
21764: desret_xmlNodePtr(ret_val);
21765: call_tests++;
21766: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 0);
21767: xmlResetLastError();
21768: if (mem_base != xmlMemBlocks()) {
21769: printf("Leak of %d blocks found in xmlNewText",
21770: xmlMemBlocks() - mem_base);
21771: test_ret++;
21772: printf(" %d", n_content);
21773: printf("\n");
21774: }
21775: }
21776: function_tests++;
21777:
21778: return(test_ret);
21779: }
21780:
21781:
21782: static int
21783: test_xmlNewTextChild(void) {
21784: int test_ret = 0;
21785:
21786: #if defined(LIBXML_TREE_ENABLED)
21787: #ifdef LIBXML_TREE_ENABLED
21788: int mem_base;
21789: xmlNodePtr ret_val;
21790: xmlNodePtr parent; /* the parent node */
21791: int n_parent;
21792: xmlNsPtr ns; /* a namespace if any */
21793: int n_ns;
21794: xmlChar * name; /* the name of the child */
21795: int n_name;
21796: xmlChar * content; /* the text content of the child if any. */
21797: int n_content;
21798:
21799: for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
21800: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
21801: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21802: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21803: mem_base = xmlMemBlocks();
21804: parent = gen_xmlNodePtr(n_parent, 0);
21805: ns = gen_xmlNsPtr(n_ns, 1);
21806: name = gen_const_xmlChar_ptr(n_name, 2);
21807: content = gen_const_xmlChar_ptr(n_content, 3);
21808:
21809: ret_val = xmlNewTextChild(parent, ns, (const xmlChar *)name, (const xmlChar *)content);
21810: desret_xmlNodePtr(ret_val);
21811: call_tests++;
21812: des_xmlNodePtr(n_parent, parent, 0);
21813: des_xmlNsPtr(n_ns, ns, 1);
21814: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
21815: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3);
21816: xmlResetLastError();
21817: if (mem_base != xmlMemBlocks()) {
21818: printf("Leak of %d blocks found in xmlNewTextChild",
21819: xmlMemBlocks() - mem_base);
21820: test_ret++;
21821: printf(" %d", n_parent);
21822: printf(" %d", n_ns);
21823: printf(" %d", n_name);
21824: printf(" %d", n_content);
21825: printf("\n");
21826: }
21827: }
21828: }
21829: }
21830: }
21831: function_tests++;
21832: #endif
21833: #endif
21834:
21835: return(test_ret);
21836: }
21837:
21838:
21839: static int
21840: test_xmlNewTextLen(void) {
21841: int test_ret = 0;
21842:
21843: int mem_base;
21844: xmlNodePtr ret_val;
21845: xmlChar * content; /* the text content */
21846: int n_content;
21847: int len; /* the text len. */
21848: int n_len;
21849:
21850: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21851: for (n_len = 0;n_len < gen_nb_int;n_len++) {
21852: mem_base = xmlMemBlocks();
21853: content = gen_const_xmlChar_ptr(n_content, 0);
21854: len = gen_int(n_len, 1);
21855:
21856: ret_val = xmlNewTextLen((const xmlChar *)content, len);
21857: desret_xmlNodePtr(ret_val);
21858: call_tests++;
21859: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 0);
21860: des_int(n_len, len, 1);
21861: xmlResetLastError();
21862: if (mem_base != xmlMemBlocks()) {
21863: printf("Leak of %d blocks found in xmlNewTextLen",
21864: xmlMemBlocks() - mem_base);
21865: test_ret++;
21866: printf(" %d", n_content);
21867: printf(" %d", n_len);
21868: printf("\n");
21869: }
21870: }
21871: }
21872: function_tests++;
21873:
21874: return(test_ret);
21875: }
21876:
21877:
21878: static int
21879: test_xmlNextElementSibling(void) {
21880: int test_ret = 0;
21881:
21882: #if defined(LIBXML_TREE_ENABLED)
21883: int mem_base;
21884: xmlNodePtr ret_val;
21885: xmlNodePtr node; /* the current node */
21886: int n_node;
21887:
21888: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
21889: mem_base = xmlMemBlocks();
21890: node = gen_xmlNodePtr(n_node, 0);
21891:
21892: ret_val = xmlNextElementSibling(node);
21893: desret_xmlNodePtr(ret_val);
21894: call_tests++;
21895: des_xmlNodePtr(n_node, node, 0);
21896: xmlResetLastError();
21897: if (mem_base != xmlMemBlocks()) {
21898: printf("Leak of %d blocks found in xmlNextElementSibling",
21899: xmlMemBlocks() - mem_base);
21900: test_ret++;
21901: printf(" %d", n_node);
21902: printf("\n");
21903: }
21904: }
21905: function_tests++;
21906: #endif
21907:
21908: return(test_ret);
21909: }
21910:
21911:
21912: static int
21913: test_xmlNodeAddContent(void) {
21914: int test_ret = 0;
21915:
21916: int mem_base;
21917: xmlNodePtr cur; /* the node being modified */
21918: int n_cur;
21919: xmlChar * content; /* extra content */
21920: int n_content;
21921:
21922: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
21923: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21924: mem_base = xmlMemBlocks();
21925: cur = gen_xmlNodePtr(n_cur, 0);
21926: content = gen_const_xmlChar_ptr(n_content, 1);
21927:
21928: xmlNodeAddContent(cur, (const xmlChar *)content);
21929: call_tests++;
21930: des_xmlNodePtr(n_cur, cur, 0);
21931: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
21932: xmlResetLastError();
21933: if (mem_base != xmlMemBlocks()) {
21934: printf("Leak of %d blocks found in xmlNodeAddContent",
21935: xmlMemBlocks() - mem_base);
21936: test_ret++;
21937: printf(" %d", n_cur);
21938: printf(" %d", n_content);
21939: printf("\n");
21940: }
21941: }
21942: }
21943: function_tests++;
21944:
21945: return(test_ret);
21946: }
21947:
21948:
21949: static int
21950: test_xmlNodeAddContentLen(void) {
21951: int test_ret = 0;
21952:
21953: int mem_base;
21954: xmlNodePtr cur; /* the node being modified */
21955: int n_cur;
21956: xmlChar * content; /* extra content */
21957: int n_content;
21958: int len; /* the size of @content */
21959: int n_len;
21960:
21961: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
21962: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21963: for (n_len = 0;n_len < gen_nb_int;n_len++) {
21964: mem_base = xmlMemBlocks();
21965: cur = gen_xmlNodePtr(n_cur, 0);
21966: content = gen_const_xmlChar_ptr(n_content, 1);
21967: len = gen_int(n_len, 2);
21968:
21969: xmlNodeAddContentLen(cur, (const xmlChar *)content, len);
21970: call_tests++;
21971: des_xmlNodePtr(n_cur, cur, 0);
21972: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
21973: des_int(n_len, len, 2);
21974: xmlResetLastError();
21975: if (mem_base != xmlMemBlocks()) {
21976: printf("Leak of %d blocks found in xmlNodeAddContentLen",
21977: xmlMemBlocks() - mem_base);
21978: test_ret++;
21979: printf(" %d", n_cur);
21980: printf(" %d", n_content);
21981: printf(" %d", n_len);
21982: printf("\n");
21983: }
21984: }
21985: }
21986: }
21987: function_tests++;
21988:
21989: return(test_ret);
21990: }
21991:
21992:
21993: static int
21994: test_xmlNodeBufGetContent(void) {
21995: int test_ret = 0;
21996:
21997: int mem_base;
21998: int ret_val;
21999: xmlBufferPtr buffer; /* a buffer */
22000: int n_buffer;
22001: xmlNodePtr cur; /* the node being read */
22002: int n_cur;
22003:
22004: for (n_buffer = 0;n_buffer < gen_nb_xmlBufferPtr;n_buffer++) {
22005: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22006: mem_base = xmlMemBlocks();
22007: buffer = gen_xmlBufferPtr(n_buffer, 0);
22008: cur = gen_xmlNodePtr(n_cur, 1);
22009:
22010: ret_val = xmlNodeBufGetContent(buffer, cur);
22011: desret_int(ret_val);
22012: call_tests++;
22013: des_xmlBufferPtr(n_buffer, buffer, 0);
22014: des_xmlNodePtr(n_cur, cur, 1);
22015: xmlResetLastError();
22016: if (mem_base != xmlMemBlocks()) {
22017: printf("Leak of %d blocks found in xmlNodeBufGetContent",
22018: xmlMemBlocks() - mem_base);
22019: test_ret++;
22020: printf(" %d", n_buffer);
22021: printf(" %d", n_cur);
22022: printf("\n");
22023: }
22024: }
22025: }
22026: function_tests++;
22027:
22028: return(test_ret);
22029: }
22030:
22031:
22032: static int
22033: test_xmlNodeDump(void) {
22034: int test_ret = 0;
22035:
22036: #if defined(LIBXML_OUTPUT_ENABLED)
22037: int mem_base;
22038: int ret_val;
22039: xmlBufferPtr buf; /* the XML buffer output */
22040: int n_buf;
22041: xmlDocPtr doc; /* the document */
22042: int n_doc;
22043: xmlNodePtr cur; /* the current node */
22044: int n_cur;
22045: int level; /* the imbrication level for indenting */
22046: int n_level;
22047: int format; /* is formatting allowed */
22048: int n_format;
22049:
22050: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
22051: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
22052: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22053: for (n_level = 0;n_level < gen_nb_int;n_level++) {
22054: for (n_format = 0;n_format < gen_nb_int;n_format++) {
22055: mem_base = xmlMemBlocks();
22056: buf = gen_xmlBufferPtr(n_buf, 0);
22057: doc = gen_xmlDocPtr(n_doc, 1);
22058: cur = gen_xmlNodePtr(n_cur, 2);
22059: level = gen_int(n_level, 3);
22060: format = gen_int(n_format, 4);
22061:
22062: ret_val = xmlNodeDump(buf, doc, cur, level, format);
22063: desret_int(ret_val);
22064: call_tests++;
22065: des_xmlBufferPtr(n_buf, buf, 0);
22066: des_xmlDocPtr(n_doc, doc, 1);
22067: des_xmlNodePtr(n_cur, cur, 2);
22068: des_int(n_level, level, 3);
22069: des_int(n_format, format, 4);
22070: xmlResetLastError();
22071: if (mem_base != xmlMemBlocks()) {
22072: printf("Leak of %d blocks found in xmlNodeDump",
22073: xmlMemBlocks() - mem_base);
22074: test_ret++;
22075: printf(" %d", n_buf);
22076: printf(" %d", n_doc);
22077: printf(" %d", n_cur);
22078: printf(" %d", n_level);
22079: printf(" %d", n_format);
22080: printf("\n");
22081: }
22082: }
22083: }
22084: }
22085: }
22086: }
22087: function_tests++;
22088: #endif
22089:
22090: return(test_ret);
22091: }
22092:
22093:
22094: static int
22095: test_xmlNodeDumpOutput(void) {
22096: int test_ret = 0;
22097:
22098: #if defined(LIBXML_OUTPUT_ENABLED)
22099: int mem_base;
22100: xmlOutputBufferPtr buf; /* the XML buffer output */
22101: int n_buf;
22102: xmlDocPtr doc; /* the document */
22103: int n_doc;
22104: xmlNodePtr cur; /* the current node */
22105: int n_cur;
22106: int level; /* the imbrication level for indenting */
22107: int n_level;
22108: int format; /* is formatting allowed */
22109: int n_format;
22110: char * encoding; /* an optional encoding string */
22111: int n_encoding;
22112:
22113: for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
22114: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
22115: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22116: for (n_level = 0;n_level < gen_nb_int;n_level++) {
22117: for (n_format = 0;n_format < gen_nb_int;n_format++) {
22118: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
22119: mem_base = xmlMemBlocks();
22120: buf = gen_xmlOutputBufferPtr(n_buf, 0);
22121: doc = gen_xmlDocPtr(n_doc, 1);
22122: cur = gen_xmlNodePtr(n_cur, 2);
22123: level = gen_int(n_level, 3);
22124: format = gen_int(n_format, 4);
22125: encoding = gen_const_char_ptr(n_encoding, 5);
22126:
22127: xmlNodeDumpOutput(buf, doc, cur, level, format, (const char *)encoding);
22128: call_tests++;
22129: des_xmlOutputBufferPtr(n_buf, buf, 0);
22130: des_xmlDocPtr(n_doc, doc, 1);
22131: des_xmlNodePtr(n_cur, cur, 2);
22132: des_int(n_level, level, 3);
22133: des_int(n_format, format, 4);
22134: des_const_char_ptr(n_encoding, (const char *)encoding, 5);
22135: xmlResetLastError();
22136: if (mem_base != xmlMemBlocks()) {
22137: printf("Leak of %d blocks found in xmlNodeDumpOutput",
22138: xmlMemBlocks() - mem_base);
22139: test_ret++;
22140: printf(" %d", n_buf);
22141: printf(" %d", n_doc);
22142: printf(" %d", n_cur);
22143: printf(" %d", n_level);
22144: printf(" %d", n_format);
22145: printf(" %d", n_encoding);
22146: printf("\n");
22147: }
22148: }
22149: }
22150: }
22151: }
22152: }
22153: }
22154: function_tests++;
22155: #endif
22156:
22157: return(test_ret);
22158: }
22159:
22160:
22161: static int
22162: test_xmlNodeGetBase(void) {
22163: int test_ret = 0;
22164:
22165: int mem_base;
22166: xmlChar * ret_val;
22167: xmlDocPtr doc; /* the document the node pertains to */
22168: int n_doc;
22169: xmlNodePtr cur; /* the node being checked */
22170: int n_cur;
22171:
22172: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
22173: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22174: mem_base = xmlMemBlocks();
22175: doc = gen_xmlDocPtr(n_doc, 0);
22176: cur = gen_xmlNodePtr(n_cur, 1);
22177:
22178: ret_val = xmlNodeGetBase(doc, cur);
22179: desret_xmlChar_ptr(ret_val);
22180: call_tests++;
22181: des_xmlDocPtr(n_doc, doc, 0);
22182: des_xmlNodePtr(n_cur, cur, 1);
22183: xmlResetLastError();
22184: if (mem_base != xmlMemBlocks()) {
22185: printf("Leak of %d blocks found in xmlNodeGetBase",
22186: xmlMemBlocks() - mem_base);
22187: test_ret++;
22188: printf(" %d", n_doc);
22189: printf(" %d", n_cur);
22190: printf("\n");
22191: }
22192: }
22193: }
22194: function_tests++;
22195:
22196: return(test_ret);
22197: }
22198:
22199:
22200: static int
22201: test_xmlNodeGetContent(void) {
22202: int test_ret = 0;
22203:
22204: int mem_base;
22205: xmlChar * ret_val;
22206: xmlNodePtr cur; /* the node being read */
22207: int n_cur;
22208:
22209: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22210: mem_base = xmlMemBlocks();
22211: cur = gen_xmlNodePtr(n_cur, 0);
22212:
22213: ret_val = xmlNodeGetContent(cur);
22214: desret_xmlChar_ptr(ret_val);
22215: call_tests++;
22216: des_xmlNodePtr(n_cur, cur, 0);
22217: xmlResetLastError();
22218: if (mem_base != xmlMemBlocks()) {
22219: printf("Leak of %d blocks found in xmlNodeGetContent",
22220: xmlMemBlocks() - mem_base);
22221: test_ret++;
22222: printf(" %d", n_cur);
22223: printf("\n");
22224: }
22225: }
22226: function_tests++;
22227:
22228: return(test_ret);
22229: }
22230:
22231:
22232: static int
22233: test_xmlNodeGetLang(void) {
22234: int test_ret = 0;
22235:
22236: int mem_base;
22237: xmlChar * ret_val;
22238: xmlNodePtr cur; /* the node being checked */
22239: int n_cur;
22240:
22241: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22242: mem_base = xmlMemBlocks();
22243: cur = gen_xmlNodePtr(n_cur, 0);
22244:
22245: ret_val = xmlNodeGetLang(cur);
22246: desret_xmlChar_ptr(ret_val);
22247: call_tests++;
22248: des_xmlNodePtr(n_cur, cur, 0);
22249: xmlResetLastError();
22250: if (mem_base != xmlMemBlocks()) {
22251: printf("Leak of %d blocks found in xmlNodeGetLang",
22252: xmlMemBlocks() - mem_base);
22253: test_ret++;
22254: printf(" %d", n_cur);
22255: printf("\n");
22256: }
22257: }
22258: function_tests++;
22259:
22260: return(test_ret);
22261: }
22262:
22263:
22264: static int
22265: test_xmlNodeGetSpacePreserve(void) {
22266: int test_ret = 0;
22267:
22268: int mem_base;
22269: int ret_val;
22270: xmlNodePtr cur; /* the node being checked */
22271: int n_cur;
22272:
22273: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22274: mem_base = xmlMemBlocks();
22275: cur = gen_xmlNodePtr(n_cur, 0);
22276:
22277: ret_val = xmlNodeGetSpacePreserve(cur);
22278: desret_int(ret_val);
22279: call_tests++;
22280: des_xmlNodePtr(n_cur, cur, 0);
22281: xmlResetLastError();
22282: if (mem_base != xmlMemBlocks()) {
22283: printf("Leak of %d blocks found in xmlNodeGetSpacePreserve",
22284: xmlMemBlocks() - mem_base);
22285: test_ret++;
22286: printf(" %d", n_cur);
22287: printf("\n");
22288: }
22289: }
22290: function_tests++;
22291:
22292: return(test_ret);
22293: }
22294:
22295:
22296: static int
22297: test_xmlNodeIsText(void) {
22298: int test_ret = 0;
22299:
22300: int mem_base;
22301: int ret_val;
22302: xmlNodePtr node; /* the node */
22303: int n_node;
22304:
22305: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
22306: mem_base = xmlMemBlocks();
22307: node = gen_xmlNodePtr(n_node, 0);
22308:
22309: ret_val = xmlNodeIsText(node);
22310: desret_int(ret_val);
22311: call_tests++;
22312: des_xmlNodePtr(n_node, node, 0);
22313: xmlResetLastError();
22314: if (mem_base != xmlMemBlocks()) {
22315: printf("Leak of %d blocks found in xmlNodeIsText",
22316: xmlMemBlocks() - mem_base);
22317: test_ret++;
22318: printf(" %d", n_node);
22319: printf("\n");
22320: }
22321: }
22322: function_tests++;
22323:
22324: return(test_ret);
22325: }
22326:
22327:
22328: static int
22329: test_xmlNodeListGetRawString(void) {
22330: int test_ret = 0;
22331:
22332: #if defined(LIBXML_TREE_ENABLED)
22333: int mem_base;
22334: xmlChar * ret_val;
22335: xmlDocPtr doc; /* the document */
22336: int n_doc;
22337: xmlNodePtr list; /* a Node list */
22338: int n_list;
22339: int inLine; /* should we replace entity contents or show their external form */
22340: int n_inLine;
22341:
22342: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
22343: for (n_list = 0;n_list < gen_nb_xmlNodePtr;n_list++) {
22344: for (n_inLine = 0;n_inLine < gen_nb_int;n_inLine++) {
22345: mem_base = xmlMemBlocks();
22346: doc = gen_xmlDocPtr(n_doc, 0);
22347: list = gen_xmlNodePtr(n_list, 1);
22348: inLine = gen_int(n_inLine, 2);
22349:
22350: ret_val = xmlNodeListGetRawString(doc, list, inLine);
22351: desret_xmlChar_ptr(ret_val);
22352: call_tests++;
22353: des_xmlDocPtr(n_doc, doc, 0);
22354: des_xmlNodePtr(n_list, list, 1);
22355: des_int(n_inLine, inLine, 2);
22356: xmlResetLastError();
22357: if (mem_base != xmlMemBlocks()) {
22358: printf("Leak of %d blocks found in xmlNodeListGetRawString",
22359: xmlMemBlocks() - mem_base);
22360: test_ret++;
22361: printf(" %d", n_doc);
22362: printf(" %d", n_list);
22363: printf(" %d", n_inLine);
22364: printf("\n");
22365: }
22366: }
22367: }
22368: }
22369: function_tests++;
22370: #endif
22371:
22372: return(test_ret);
22373: }
22374:
22375:
22376: static int
22377: test_xmlNodeListGetString(void) {
22378: int test_ret = 0;
22379:
22380: int mem_base;
22381: xmlChar * ret_val;
22382: xmlDocPtr doc; /* the document */
22383: int n_doc;
22384: xmlNodePtr list; /* a Node list */
22385: int n_list;
22386: int inLine; /* should we replace entity contents or show their external form */
22387: int n_inLine;
22388:
22389: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
22390: for (n_list = 0;n_list < gen_nb_xmlNodePtr;n_list++) {
22391: for (n_inLine = 0;n_inLine < gen_nb_int;n_inLine++) {
22392: mem_base = xmlMemBlocks();
22393: doc = gen_xmlDocPtr(n_doc, 0);
22394: list = gen_xmlNodePtr(n_list, 1);
22395: inLine = gen_int(n_inLine, 2);
22396:
22397: ret_val = xmlNodeListGetString(doc, list, inLine);
22398: desret_xmlChar_ptr(ret_val);
22399: call_tests++;
22400: des_xmlDocPtr(n_doc, doc, 0);
22401: des_xmlNodePtr(n_list, list, 1);
22402: des_int(n_inLine, inLine, 2);
22403: xmlResetLastError();
22404: if (mem_base != xmlMemBlocks()) {
22405: printf("Leak of %d blocks found in xmlNodeListGetString",
22406: xmlMemBlocks() - mem_base);
22407: test_ret++;
22408: printf(" %d", n_doc);
22409: printf(" %d", n_list);
22410: printf(" %d", n_inLine);
22411: printf("\n");
22412: }
22413: }
22414: }
22415: }
22416: function_tests++;
22417:
22418: return(test_ret);
22419: }
22420:
22421:
22422: static int
22423: test_xmlNodeSetBase(void) {
22424: int test_ret = 0;
22425:
22426: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED)
22427: int mem_base;
22428: xmlNodePtr cur; /* the node being changed */
22429: int n_cur;
22430: xmlChar * uri; /* the new base URI */
22431: int n_uri;
22432:
22433: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22434: for (n_uri = 0;n_uri < gen_nb_const_xmlChar_ptr;n_uri++) {
22435: mem_base = xmlMemBlocks();
22436: cur = gen_xmlNodePtr(n_cur, 0);
22437: uri = gen_const_xmlChar_ptr(n_uri, 1);
22438:
22439: xmlNodeSetBase(cur, (const xmlChar *)uri);
22440: call_tests++;
22441: des_xmlNodePtr(n_cur, cur, 0);
22442: des_const_xmlChar_ptr(n_uri, (const xmlChar *)uri, 1);
22443: xmlResetLastError();
22444: if (mem_base != xmlMemBlocks()) {
22445: printf("Leak of %d blocks found in xmlNodeSetBase",
22446: xmlMemBlocks() - mem_base);
22447: test_ret++;
22448: printf(" %d", n_cur);
22449: printf(" %d", n_uri);
22450: printf("\n");
22451: }
22452: }
22453: }
22454: function_tests++;
22455: #endif
22456:
22457: return(test_ret);
22458: }
22459:
22460:
22461: static int
22462: test_xmlNodeSetContent(void) {
22463: int test_ret = 0;
22464:
22465: int mem_base;
22466: xmlNodePtr cur; /* the node being modified */
22467: int n_cur;
22468: xmlChar * content; /* the new value of the content */
22469: int n_content;
22470:
22471: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22472: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
22473: mem_base = xmlMemBlocks();
22474: cur = gen_xmlNodePtr(n_cur, 0);
22475: content = gen_const_xmlChar_ptr(n_content, 1);
22476:
22477: xmlNodeSetContent(cur, (const xmlChar *)content);
22478: call_tests++;
22479: des_xmlNodePtr(n_cur, cur, 0);
22480: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
22481: xmlResetLastError();
22482: if (mem_base != xmlMemBlocks()) {
22483: printf("Leak of %d blocks found in xmlNodeSetContent",
22484: xmlMemBlocks() - mem_base);
22485: test_ret++;
22486: printf(" %d", n_cur);
22487: printf(" %d", n_content);
22488: printf("\n");
22489: }
22490: }
22491: }
22492: function_tests++;
22493:
22494: return(test_ret);
22495: }
22496:
22497:
22498: static int
22499: test_xmlNodeSetContentLen(void) {
22500: int test_ret = 0;
22501:
22502: #if defined(LIBXML_TREE_ENABLED)
22503: int mem_base;
22504: xmlNodePtr cur; /* the node being modified */
22505: int n_cur;
22506: xmlChar * content; /* the new value of the content */
22507: int n_content;
22508: int len; /* the size of @content */
22509: int n_len;
22510:
22511: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22512: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
22513: for (n_len = 0;n_len < gen_nb_int;n_len++) {
22514: mem_base = xmlMemBlocks();
22515: cur = gen_xmlNodePtr(n_cur, 0);
22516: content = gen_const_xmlChar_ptr(n_content, 1);
22517: len = gen_int(n_len, 2);
22518:
22519: xmlNodeSetContentLen(cur, (const xmlChar *)content, len);
22520: call_tests++;
22521: des_xmlNodePtr(n_cur, cur, 0);
22522: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
22523: des_int(n_len, len, 2);
22524: xmlResetLastError();
22525: if (mem_base != xmlMemBlocks()) {
22526: printf("Leak of %d blocks found in xmlNodeSetContentLen",
22527: xmlMemBlocks() - mem_base);
22528: test_ret++;
22529: printf(" %d", n_cur);
22530: printf(" %d", n_content);
22531: printf(" %d", n_len);
22532: printf("\n");
22533: }
22534: }
22535: }
22536: }
22537: function_tests++;
22538: #endif
22539:
22540: return(test_ret);
22541: }
22542:
22543:
22544: static int
22545: test_xmlNodeSetLang(void) {
22546: int test_ret = 0;
22547:
22548: #if defined(LIBXML_TREE_ENABLED)
22549: int mem_base;
22550: xmlNodePtr cur; /* the node being changed */
22551: int n_cur;
22552: xmlChar * lang; /* the language description */
22553: int n_lang;
22554:
22555: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22556: for (n_lang = 0;n_lang < gen_nb_const_xmlChar_ptr;n_lang++) {
22557: mem_base = xmlMemBlocks();
22558: cur = gen_xmlNodePtr(n_cur, 0);
22559: lang = gen_const_xmlChar_ptr(n_lang, 1);
22560:
22561: xmlNodeSetLang(cur, (const xmlChar *)lang);
22562: call_tests++;
22563: des_xmlNodePtr(n_cur, cur, 0);
22564: des_const_xmlChar_ptr(n_lang, (const xmlChar *)lang, 1);
22565: xmlResetLastError();
22566: if (mem_base != xmlMemBlocks()) {
22567: printf("Leak of %d blocks found in xmlNodeSetLang",
22568: xmlMemBlocks() - mem_base);
22569: test_ret++;
22570: printf(" %d", n_cur);
22571: printf(" %d", n_lang);
22572: printf("\n");
22573: }
22574: }
22575: }
22576: function_tests++;
22577: #endif
22578:
22579: return(test_ret);
22580: }
22581:
22582:
22583: static int
22584: test_xmlNodeSetName(void) {
22585: int test_ret = 0;
22586:
22587: #if defined(LIBXML_TREE_ENABLED)
22588: int mem_base;
22589: xmlNodePtr cur; /* the node being changed */
22590: int n_cur;
22591: xmlChar * name; /* the new tag name */
22592: int n_name;
22593:
22594: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22595: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
22596: mem_base = xmlMemBlocks();
22597: cur = gen_xmlNodePtr(n_cur, 0);
22598: name = gen_const_xmlChar_ptr(n_name, 1);
22599:
22600: xmlNodeSetName(cur, (const xmlChar *)name);
22601: call_tests++;
22602: des_xmlNodePtr(n_cur, cur, 0);
22603: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
22604: xmlResetLastError();
22605: if (mem_base != xmlMemBlocks()) {
22606: printf("Leak of %d blocks found in xmlNodeSetName",
22607: xmlMemBlocks() - mem_base);
22608: test_ret++;
22609: printf(" %d", n_cur);
22610: printf(" %d", n_name);
22611: printf("\n");
22612: }
22613: }
22614: }
22615: function_tests++;
22616: #endif
22617:
22618: return(test_ret);
22619: }
22620:
22621:
22622: static int
22623: test_xmlNodeSetSpacePreserve(void) {
22624: int test_ret = 0;
22625:
22626: #if defined(LIBXML_TREE_ENABLED)
22627: int mem_base;
22628: xmlNodePtr cur; /* the node being changed */
22629: int n_cur;
22630: int val; /* the xml:space value ("0": default, 1: "preserve") */
22631: int n_val;
22632:
22633: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22634: for (n_val = 0;n_val < gen_nb_int;n_val++) {
22635: mem_base = xmlMemBlocks();
22636: cur = gen_xmlNodePtr(n_cur, 0);
22637: val = gen_int(n_val, 1);
22638:
22639: xmlNodeSetSpacePreserve(cur, val);
22640: call_tests++;
22641: des_xmlNodePtr(n_cur, cur, 0);
22642: des_int(n_val, val, 1);
22643: xmlResetLastError();
22644: if (mem_base != xmlMemBlocks()) {
22645: printf("Leak of %d blocks found in xmlNodeSetSpacePreserve",
22646: xmlMemBlocks() - mem_base);
22647: test_ret++;
22648: printf(" %d", n_cur);
22649: printf(" %d", n_val);
22650: printf("\n");
22651: }
22652: }
22653: }
22654: function_tests++;
22655: #endif
22656:
22657: return(test_ret);
22658: }
22659:
22660:
22661: static int
22662: test_xmlPreviousElementSibling(void) {
22663: int test_ret = 0;
22664:
22665: #if defined(LIBXML_TREE_ENABLED)
22666: int mem_base;
22667: xmlNodePtr ret_val;
22668: xmlNodePtr node; /* the current node */
22669: int n_node;
22670:
22671: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
22672: mem_base = xmlMemBlocks();
22673: node = gen_xmlNodePtr(n_node, 0);
22674:
22675: ret_val = xmlPreviousElementSibling(node);
22676: desret_xmlNodePtr(ret_val);
22677: call_tests++;
22678: des_xmlNodePtr(n_node, node, 0);
22679: xmlResetLastError();
22680: if (mem_base != xmlMemBlocks()) {
22681: printf("Leak of %d blocks found in xmlPreviousElementSibling",
22682: xmlMemBlocks() - mem_base);
22683: test_ret++;
22684: printf(" %d", n_node);
22685: printf("\n");
22686: }
22687: }
22688: function_tests++;
22689: #endif
22690:
22691: return(test_ret);
22692: }
22693:
22694:
22695: static int
22696: test_xmlReconciliateNs(void) {
22697: int test_ret = 0;
22698:
22699: #if defined(LIBXML_TREE_ENABLED)
22700: #ifdef LIBXML_TREE_ENABLED
22701: int mem_base;
22702: int ret_val;
22703: xmlDocPtr doc; /* the document */
22704: int n_doc;
22705: xmlNodePtr tree; /* a node defining the subtree to reconciliate */
22706: int n_tree;
22707:
22708: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
22709: for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) {
22710: mem_base = xmlMemBlocks();
22711: doc = gen_xmlDocPtr(n_doc, 0);
22712: tree = gen_xmlNodePtr(n_tree, 1);
22713:
22714: ret_val = xmlReconciliateNs(doc, tree);
22715: desret_int(ret_val);
22716: call_tests++;
22717: des_xmlDocPtr(n_doc, doc, 0);
22718: des_xmlNodePtr(n_tree, tree, 1);
22719: xmlResetLastError();
22720: if (mem_base != xmlMemBlocks()) {
22721: printf("Leak of %d blocks found in xmlReconciliateNs",
22722: xmlMemBlocks() - mem_base);
22723: test_ret++;
22724: printf(" %d", n_doc);
22725: printf(" %d", n_tree);
22726: printf("\n");
22727: }
22728: }
22729: }
22730: function_tests++;
22731: #endif
22732: #endif
22733:
22734: return(test_ret);
22735: }
22736:
22737:
22738: static int
22739: test_xmlRemoveProp(void) {
22740: int test_ret = 0;
22741:
22742: int mem_base;
22743: int ret_val;
22744: xmlAttrPtr cur; /* an attribute */
22745: int n_cur;
22746:
22747: for (n_cur = 0;n_cur < gen_nb_xmlAttrPtr;n_cur++) {
22748: mem_base = xmlMemBlocks();
22749: cur = gen_xmlAttrPtr(n_cur, 0);
22750:
22751: ret_val = xmlRemoveProp(cur);
22752: cur = NULL;
22753: desret_int(ret_val);
22754: call_tests++;
22755: des_xmlAttrPtr(n_cur, cur, 0);
22756: xmlResetLastError();
22757: if (mem_base != xmlMemBlocks()) {
22758: printf("Leak of %d blocks found in xmlRemoveProp",
22759: xmlMemBlocks() - mem_base);
22760: test_ret++;
22761: printf(" %d", n_cur);
22762: printf("\n");
22763: }
22764: }
22765: function_tests++;
22766:
22767: return(test_ret);
22768: }
22769:
22770:
22771: static int
22772: test_xmlReplaceNode(void) {
22773: int test_ret = 0;
22774:
22775: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
22776: int mem_base;
22777: xmlNodePtr ret_val;
22778: xmlNodePtr old; /* the old node */
22779: int n_old;
22780: xmlNodePtr cur; /* the node */
22781: int n_cur;
22782:
22783: for (n_old = 0;n_old < gen_nb_xmlNodePtr;n_old++) {
22784: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr_in;n_cur++) {
22785: mem_base = xmlMemBlocks();
22786: old = gen_xmlNodePtr(n_old, 0);
22787: cur = gen_xmlNodePtr_in(n_cur, 1);
22788:
22789: ret_val = xmlReplaceNode(old, cur);
22790: if (cur != NULL) {
22791: xmlUnlinkNode(cur);
22792: xmlFreeNode(cur) ; cur = NULL ; }
22793: if (old != NULL) {
22794: xmlUnlinkNode(old);
22795: xmlFreeNode(old) ; old = NULL ; }
22796: ret_val = NULL;
22797: desret_xmlNodePtr(ret_val);
22798: call_tests++;
22799: des_xmlNodePtr(n_old, old, 0);
22800: des_xmlNodePtr_in(n_cur, cur, 1);
22801: xmlResetLastError();
22802: if (mem_base != xmlMemBlocks()) {
22803: printf("Leak of %d blocks found in xmlReplaceNode",
22804: xmlMemBlocks() - mem_base);
22805: test_ret++;
22806: printf(" %d", n_old);
22807: printf(" %d", n_cur);
22808: printf("\n");
22809: }
22810: }
22811: }
22812: function_tests++;
22813: #endif
22814:
22815: return(test_ret);
22816: }
22817:
22818:
22819: static int
22820: test_xmlSaveFile(void) {
22821: int test_ret = 0;
22822:
22823: #if defined(LIBXML_OUTPUT_ENABLED)
22824: int mem_base;
22825: int ret_val;
22826: const char * filename; /* the filename (or URL) */
22827: int n_filename;
22828: xmlDocPtr cur; /* the document */
22829: int n_cur;
22830:
22831: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
22832: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
22833: mem_base = xmlMemBlocks();
22834: filename = gen_fileoutput(n_filename, 0);
22835: cur = gen_xmlDocPtr(n_cur, 1);
22836:
22837: ret_val = xmlSaveFile(filename, cur);
22838: desret_int(ret_val);
22839: call_tests++;
22840: des_fileoutput(n_filename, filename, 0);
22841: des_xmlDocPtr(n_cur, cur, 1);
22842: xmlResetLastError();
22843: if (mem_base != xmlMemBlocks()) {
22844: printf("Leak of %d blocks found in xmlSaveFile",
22845: xmlMemBlocks() - mem_base);
22846: test_ret++;
22847: printf(" %d", n_filename);
22848: printf(" %d", n_cur);
22849: printf("\n");
22850: }
22851: }
22852: }
22853: function_tests++;
22854: #endif
22855:
22856: return(test_ret);
22857: }
22858:
22859:
22860: static int
22861: test_xmlSaveFileEnc(void) {
22862: int test_ret = 0;
22863:
22864: #if defined(LIBXML_OUTPUT_ENABLED)
22865: int mem_base;
22866: int ret_val;
22867: const char * filename; /* the filename (or URL) */
22868: int n_filename;
22869: xmlDocPtr cur; /* the document */
22870: int n_cur;
22871: char * encoding; /* the name of an encoding (or NULL) */
22872: int n_encoding;
22873:
22874: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
22875: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
22876: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
22877: mem_base = xmlMemBlocks();
22878: filename = gen_fileoutput(n_filename, 0);
22879: cur = gen_xmlDocPtr(n_cur, 1);
22880: encoding = gen_const_char_ptr(n_encoding, 2);
22881:
22882: ret_val = xmlSaveFileEnc(filename, cur, (const char *)encoding);
22883: desret_int(ret_val);
22884: call_tests++;
22885: des_fileoutput(n_filename, filename, 0);
22886: des_xmlDocPtr(n_cur, cur, 1);
22887: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
22888: xmlResetLastError();
22889: if (mem_base != xmlMemBlocks()) {
22890: printf("Leak of %d blocks found in xmlSaveFileEnc",
22891: xmlMemBlocks() - mem_base);
22892: test_ret++;
22893: printf(" %d", n_filename);
22894: printf(" %d", n_cur);
22895: printf(" %d", n_encoding);
22896: printf("\n");
22897: }
22898: }
22899: }
22900: }
22901: function_tests++;
22902: #endif
22903:
22904: return(test_ret);
22905: }
22906:
22907:
22908: static int
22909: test_xmlSaveFileTo(void) {
22910: int test_ret = 0;
22911:
22912: #if defined(LIBXML_OUTPUT_ENABLED)
22913: int mem_base;
22914: int ret_val;
22915: xmlOutputBufferPtr buf; /* an output I/O buffer */
22916: int n_buf;
22917: xmlDocPtr cur; /* the document */
22918: int n_cur;
22919: char * encoding; /* the encoding if any assuming the I/O layer handles the trancoding */
22920: int n_encoding;
22921:
22922: for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
22923: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
22924: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
22925: mem_base = xmlMemBlocks();
22926: buf = gen_xmlOutputBufferPtr(n_buf, 0);
22927: cur = gen_xmlDocPtr(n_cur, 1);
22928: encoding = gen_const_char_ptr(n_encoding, 2);
22929:
22930: ret_val = xmlSaveFileTo(buf, cur, (const char *)encoding);
22931: buf = NULL;
22932: desret_int(ret_val);
22933: call_tests++;
22934: des_xmlOutputBufferPtr(n_buf, buf, 0);
22935: des_xmlDocPtr(n_cur, cur, 1);
22936: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
22937: xmlResetLastError();
22938: if (mem_base != xmlMemBlocks()) {
22939: printf("Leak of %d blocks found in xmlSaveFileTo",
22940: xmlMemBlocks() - mem_base);
22941: test_ret++;
22942: printf(" %d", n_buf);
22943: printf(" %d", n_cur);
22944: printf(" %d", n_encoding);
22945: printf("\n");
22946: }
22947: }
22948: }
22949: }
22950: function_tests++;
22951: #endif
22952:
22953: return(test_ret);
22954: }
22955:
22956:
22957: static int
22958: test_xmlSaveFormatFile(void) {
22959: int test_ret = 0;
22960:
22961: #if defined(LIBXML_OUTPUT_ENABLED)
22962: int mem_base;
22963: int ret_val;
22964: const char * filename; /* the filename (or URL) */
22965: int n_filename;
22966: xmlDocPtr cur; /* the document */
22967: int n_cur;
22968: int format; /* should formatting spaces been added */
22969: int n_format;
22970:
22971: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
22972: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
22973: for (n_format = 0;n_format < gen_nb_int;n_format++) {
22974: mem_base = xmlMemBlocks();
22975: filename = gen_fileoutput(n_filename, 0);
22976: cur = gen_xmlDocPtr(n_cur, 1);
22977: format = gen_int(n_format, 2);
22978:
22979: ret_val = xmlSaveFormatFile(filename, cur, format);
22980: desret_int(ret_val);
22981: call_tests++;
22982: des_fileoutput(n_filename, filename, 0);
22983: des_xmlDocPtr(n_cur, cur, 1);
22984: des_int(n_format, format, 2);
22985: xmlResetLastError();
22986: if (mem_base != xmlMemBlocks()) {
22987: printf("Leak of %d blocks found in xmlSaveFormatFile",
22988: xmlMemBlocks() - mem_base);
22989: test_ret++;
22990: printf(" %d", n_filename);
22991: printf(" %d", n_cur);
22992: printf(" %d", n_format);
22993: printf("\n");
22994: }
22995: }
22996: }
22997: }
22998: function_tests++;
22999: #endif
23000:
23001: return(test_ret);
23002: }
23003:
23004:
23005: static int
23006: test_xmlSaveFormatFileEnc(void) {
23007: int test_ret = 0;
23008:
23009: #if defined(LIBXML_OUTPUT_ENABLED)
23010: int mem_base;
23011: int ret_val;
23012: const char * filename; /* the filename or URL to output */
23013: int n_filename;
23014: xmlDocPtr cur; /* the document being saved */
23015: int n_cur;
23016: char * encoding; /* the name of the encoding to use or NULL. */
23017: int n_encoding;
23018: int format; /* should formatting spaces be added. */
23019: int n_format;
23020:
23021: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
23022: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
23023: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
23024: for (n_format = 0;n_format < gen_nb_int;n_format++) {
23025: mem_base = xmlMemBlocks();
23026: filename = gen_fileoutput(n_filename, 0);
23027: cur = gen_xmlDocPtr(n_cur, 1);
23028: encoding = gen_const_char_ptr(n_encoding, 2);
23029: format = gen_int(n_format, 3);
23030:
23031: ret_val = xmlSaveFormatFileEnc(filename, cur, (const char *)encoding, format);
23032: desret_int(ret_val);
23033: call_tests++;
23034: des_fileoutput(n_filename, filename, 0);
23035: des_xmlDocPtr(n_cur, cur, 1);
23036: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
23037: des_int(n_format, format, 3);
23038: xmlResetLastError();
23039: if (mem_base != xmlMemBlocks()) {
23040: printf("Leak of %d blocks found in xmlSaveFormatFileEnc",
23041: xmlMemBlocks() - mem_base);
23042: test_ret++;
23043: printf(" %d", n_filename);
23044: printf(" %d", n_cur);
23045: printf(" %d", n_encoding);
23046: printf(" %d", n_format);
23047: printf("\n");
23048: }
23049: }
23050: }
23051: }
23052: }
23053: function_tests++;
23054: #endif
23055:
23056: return(test_ret);
23057: }
23058:
23059:
23060: static int
23061: test_xmlSaveFormatFileTo(void) {
23062: int test_ret = 0;
23063:
23064: #if defined(LIBXML_OUTPUT_ENABLED)
23065: int mem_base;
23066: int ret_val;
23067: xmlOutputBufferPtr buf; /* an output I/O buffer */
23068: int n_buf;
23069: xmlDocPtr cur; /* the document */
23070: int n_cur;
23071: char * encoding; /* the encoding if any assuming the I/O layer handles the trancoding */
23072: int n_encoding;
23073: int format; /* should formatting spaces been added */
23074: int n_format;
23075:
23076: for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
23077: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
23078: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
23079: for (n_format = 0;n_format < gen_nb_int;n_format++) {
23080: mem_base = xmlMemBlocks();
23081: buf = gen_xmlOutputBufferPtr(n_buf, 0);
23082: cur = gen_xmlDocPtr(n_cur, 1);
23083: encoding = gen_const_char_ptr(n_encoding, 2);
23084: format = gen_int(n_format, 3);
23085:
23086: ret_val = xmlSaveFormatFileTo(buf, cur, (const char *)encoding, format);
23087: buf = NULL;
23088: desret_int(ret_val);
23089: call_tests++;
23090: des_xmlOutputBufferPtr(n_buf, buf, 0);
23091: des_xmlDocPtr(n_cur, cur, 1);
23092: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
23093: des_int(n_format, format, 3);
23094: xmlResetLastError();
23095: if (mem_base != xmlMemBlocks()) {
23096: printf("Leak of %d blocks found in xmlSaveFormatFileTo",
23097: xmlMemBlocks() - mem_base);
23098: test_ret++;
23099: printf(" %d", n_buf);
23100: printf(" %d", n_cur);
23101: printf(" %d", n_encoding);
23102: printf(" %d", n_format);
23103: printf("\n");
23104: }
23105: }
23106: }
23107: }
23108: }
23109: function_tests++;
23110: #endif
23111:
23112: return(test_ret);
23113: }
23114:
23115:
23116: static int
23117: test_xmlSearchNs(void) {
23118: int test_ret = 0;
23119:
23120: int mem_base;
23121: xmlNsPtr ret_val;
23122: xmlDocPtr doc; /* the document */
23123: int n_doc;
23124: xmlNodePtr node; /* the current node */
23125: int n_node;
23126: xmlChar * nameSpace; /* the namespace prefix */
23127: int n_nameSpace;
23128:
23129: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
23130: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
23131: for (n_nameSpace = 0;n_nameSpace < gen_nb_const_xmlChar_ptr;n_nameSpace++) {
23132: mem_base = xmlMemBlocks();
23133: doc = gen_xmlDocPtr(n_doc, 0);
23134: node = gen_xmlNodePtr(n_node, 1);
23135: nameSpace = gen_const_xmlChar_ptr(n_nameSpace, 2);
23136:
23137: ret_val = xmlSearchNs(doc, node, (const xmlChar *)nameSpace);
23138: desret_xmlNsPtr(ret_val);
23139: call_tests++;
23140: des_xmlDocPtr(n_doc, doc, 0);
23141: des_xmlNodePtr(n_node, node, 1);
23142: des_const_xmlChar_ptr(n_nameSpace, (const xmlChar *)nameSpace, 2);
23143: xmlResetLastError();
23144: if (mem_base != xmlMemBlocks()) {
23145: printf("Leak of %d blocks found in xmlSearchNs",
23146: xmlMemBlocks() - mem_base);
23147: test_ret++;
23148: printf(" %d", n_doc);
23149: printf(" %d", n_node);
23150: printf(" %d", n_nameSpace);
23151: printf("\n");
23152: }
23153: }
23154: }
23155: }
23156: function_tests++;
23157:
23158: return(test_ret);
23159: }
23160:
23161:
23162: static int
23163: test_xmlSearchNsByHref(void) {
23164: int test_ret = 0;
23165:
23166: int mem_base;
23167: xmlNsPtr ret_val;
23168: xmlDocPtr doc; /* the document */
23169: int n_doc;
23170: xmlNodePtr node; /* the current node */
23171: int n_node;
23172: xmlChar * href; /* the namespace value */
23173: int n_href;
23174:
23175: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
23176: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
23177: for (n_href = 0;n_href < gen_nb_const_xmlChar_ptr;n_href++) {
23178: mem_base = xmlMemBlocks();
23179: doc = gen_xmlDocPtr(n_doc, 0);
23180: node = gen_xmlNodePtr(n_node, 1);
23181: href = gen_const_xmlChar_ptr(n_href, 2);
23182:
23183: ret_val = xmlSearchNsByHref(doc, node, (const xmlChar *)href);
23184: desret_xmlNsPtr(ret_val);
23185: call_tests++;
23186: des_xmlDocPtr(n_doc, doc, 0);
23187: des_xmlNodePtr(n_node, node, 1);
23188: des_const_xmlChar_ptr(n_href, (const xmlChar *)href, 2);
23189: xmlResetLastError();
23190: if (mem_base != xmlMemBlocks()) {
23191: printf("Leak of %d blocks found in xmlSearchNsByHref",
23192: xmlMemBlocks() - mem_base);
23193: test_ret++;
23194: printf(" %d", n_doc);
23195: printf(" %d", n_node);
23196: printf(" %d", n_href);
23197: printf("\n");
23198: }
23199: }
23200: }
23201: }
23202: function_tests++;
23203:
23204: return(test_ret);
23205: }
23206:
23207:
23208: static int
23209: test_xmlSetBufferAllocationScheme(void) {
23210: int test_ret = 0;
23211:
23212: int mem_base;
23213: xmlBufferAllocationScheme scheme; /* allocation method to use */
23214: int n_scheme;
23215:
23216: for (n_scheme = 0;n_scheme < gen_nb_xmlBufferAllocationScheme;n_scheme++) {
23217: mem_base = xmlMemBlocks();
23218: scheme = gen_xmlBufferAllocationScheme(n_scheme, 0);
23219:
23220: xmlSetBufferAllocationScheme(scheme);
23221: call_tests++;
23222: des_xmlBufferAllocationScheme(n_scheme, scheme, 0);
23223: xmlResetLastError();
23224: if (mem_base != xmlMemBlocks()) {
23225: printf("Leak of %d blocks found in xmlSetBufferAllocationScheme",
23226: xmlMemBlocks() - mem_base);
23227: test_ret++;
23228: printf(" %d", n_scheme);
23229: printf("\n");
23230: }
23231: }
23232: function_tests++;
23233:
23234: return(test_ret);
23235: }
23236:
23237:
23238: static int
23239: test_xmlSetCompressMode(void) {
23240: int test_ret = 0;
23241:
23242: int mem_base;
23243: int mode; /* the compression ratio */
23244: int n_mode;
23245:
23246: for (n_mode = 0;n_mode < gen_nb_int;n_mode++) {
23247: mem_base = xmlMemBlocks();
23248: mode = gen_int(n_mode, 0);
23249:
23250: xmlSetCompressMode(mode);
23251: call_tests++;
23252: des_int(n_mode, mode, 0);
23253: xmlResetLastError();
23254: if (mem_base != xmlMemBlocks()) {
23255: printf("Leak of %d blocks found in xmlSetCompressMode",
23256: xmlMemBlocks() - mem_base);
23257: test_ret++;
23258: printf(" %d", n_mode);
23259: printf("\n");
23260: }
23261: }
23262: function_tests++;
23263:
23264: return(test_ret);
23265: }
23266:
23267:
23268: static int
23269: test_xmlSetDocCompressMode(void) {
23270: int test_ret = 0;
23271:
23272: int mem_base;
23273: xmlDocPtr doc; /* the document */
23274: int n_doc;
23275: int mode; /* the compression ratio */
23276: int n_mode;
23277:
23278: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
23279: for (n_mode = 0;n_mode < gen_nb_int;n_mode++) {
23280: mem_base = xmlMemBlocks();
23281: doc = gen_xmlDocPtr(n_doc, 0);
23282: mode = gen_int(n_mode, 1);
23283:
23284: xmlSetDocCompressMode(doc, mode);
23285: call_tests++;
23286: des_xmlDocPtr(n_doc, doc, 0);
23287: des_int(n_mode, mode, 1);
23288: xmlResetLastError();
23289: if (mem_base != xmlMemBlocks()) {
23290: printf("Leak of %d blocks found in xmlSetDocCompressMode",
23291: xmlMemBlocks() - mem_base);
23292: test_ret++;
23293: printf(" %d", n_doc);
23294: printf(" %d", n_mode);
23295: printf("\n");
23296: }
23297: }
23298: }
23299: function_tests++;
23300:
23301: return(test_ret);
23302: }
23303:
23304:
23305: static int
23306: test_xmlSetNs(void) {
23307: int test_ret = 0;
23308:
23309: int mem_base;
23310: xmlNodePtr node; /* a node in the document */
23311: int n_node;
23312: xmlNsPtr ns; /* a namespace pointer */
23313: int n_ns;
23314:
23315: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
23316: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
23317: mem_base = xmlMemBlocks();
23318: node = gen_xmlNodePtr(n_node, 0);
23319: ns = gen_xmlNsPtr(n_ns, 1);
23320:
23321: xmlSetNs(node, ns);
23322: call_tests++;
23323: des_xmlNodePtr(n_node, node, 0);
23324: des_xmlNsPtr(n_ns, ns, 1);
23325: xmlResetLastError();
23326: if (mem_base != xmlMemBlocks()) {
23327: printf("Leak of %d blocks found in xmlSetNs",
23328: xmlMemBlocks() - mem_base);
23329: test_ret++;
23330: printf(" %d", n_node);
23331: printf(" %d", n_ns);
23332: printf("\n");
23333: }
23334: }
23335: }
23336: function_tests++;
23337:
23338: return(test_ret);
23339: }
23340:
23341:
23342: static int
23343: test_xmlSetNsProp(void) {
23344: int test_ret = 0;
23345:
23346: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
23347: int mem_base;
23348: xmlAttrPtr ret_val;
23349: xmlNodePtr node; /* the node */
23350: int n_node;
23351: xmlNsPtr ns; /* the namespace definition */
23352: int n_ns;
23353: xmlChar * name; /* the attribute name */
23354: int n_name;
23355: xmlChar * value; /* the attribute value */
23356: int n_value;
23357:
23358: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
23359: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
23360: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
23361: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
23362: mem_base = xmlMemBlocks();
23363: node = gen_xmlNodePtr(n_node, 0);
23364: ns = gen_xmlNsPtr(n_ns, 1);
23365: name = gen_const_xmlChar_ptr(n_name, 2);
23366: value = gen_const_xmlChar_ptr(n_value, 3);
23367:
23368: ret_val = xmlSetNsProp(node, ns, (const xmlChar *)name, (const xmlChar *)value);
23369: desret_xmlAttrPtr(ret_val);
23370: call_tests++;
23371: des_xmlNodePtr(n_node, node, 0);
23372: des_xmlNsPtr(n_ns, ns, 1);
23373: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
23374: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 3);
23375: xmlResetLastError();
23376: if (mem_base != xmlMemBlocks()) {
23377: printf("Leak of %d blocks found in xmlSetNsProp",
23378: xmlMemBlocks() - mem_base);
23379: test_ret++;
23380: printf(" %d", n_node);
23381: printf(" %d", n_ns);
23382: printf(" %d", n_name);
23383: printf(" %d", n_value);
23384: printf("\n");
23385: }
23386: }
23387: }
23388: }
23389: }
23390: function_tests++;
23391: #endif
23392:
23393: return(test_ret);
23394: }
23395:
23396:
23397: static int
23398: test_xmlSetProp(void) {
23399: int test_ret = 0;
23400:
23401: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
23402: int mem_base;
23403: xmlAttrPtr ret_val;
23404: xmlNodePtr node; /* the node */
23405: int n_node;
23406: xmlChar * name; /* the attribute name (a QName) */
23407: int n_name;
23408: xmlChar * value; /* the attribute value */
23409: int n_value;
23410:
23411: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
23412: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
23413: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
23414: mem_base = xmlMemBlocks();
23415: node = gen_xmlNodePtr(n_node, 0);
23416: name = gen_const_xmlChar_ptr(n_name, 1);
23417: value = gen_const_xmlChar_ptr(n_value, 2);
23418:
23419: ret_val = xmlSetProp(node, (const xmlChar *)name, (const xmlChar *)value);
23420: desret_xmlAttrPtr(ret_val);
23421: call_tests++;
23422: des_xmlNodePtr(n_node, node, 0);
23423: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
23424: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2);
23425: xmlResetLastError();
23426: if (mem_base != xmlMemBlocks()) {
23427: printf("Leak of %d blocks found in xmlSetProp",
23428: xmlMemBlocks() - mem_base);
23429: test_ret++;
23430: printf(" %d", n_node);
23431: printf(" %d", n_name);
23432: printf(" %d", n_value);
23433: printf("\n");
23434: }
23435: }
23436: }
23437: }
23438: function_tests++;
23439: #endif
23440:
23441: return(test_ret);
23442: }
23443:
23444:
23445: static int
23446: test_xmlSplitQName2(void) {
23447: int test_ret = 0;
23448:
23449: int mem_base;
23450: xmlChar * ret_val;
23451: xmlChar * name; /* the full QName */
23452: int n_name;
23453: xmlChar ** prefix; /* a xmlChar ** */
23454: int n_prefix;
23455:
23456: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
23457: for (n_prefix = 0;n_prefix < gen_nb_xmlChar_ptr_ptr;n_prefix++) {
23458: mem_base = xmlMemBlocks();
23459: name = gen_const_xmlChar_ptr(n_name, 0);
23460: prefix = gen_xmlChar_ptr_ptr(n_prefix, 1);
23461:
23462: ret_val = xmlSplitQName2((const xmlChar *)name, prefix);
23463: desret_xmlChar_ptr(ret_val);
23464: call_tests++;
23465: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
23466: des_xmlChar_ptr_ptr(n_prefix, prefix, 1);
23467: xmlResetLastError();
23468: if (mem_base != xmlMemBlocks()) {
23469: printf("Leak of %d blocks found in xmlSplitQName2",
23470: xmlMemBlocks() - mem_base);
23471: test_ret++;
23472: printf(" %d", n_name);
23473: printf(" %d", n_prefix);
23474: printf("\n");
23475: }
23476: }
23477: }
23478: function_tests++;
23479:
23480: return(test_ret);
23481: }
23482:
23483:
23484: static int
23485: test_xmlSplitQName3(void) {
23486: int test_ret = 0;
23487:
23488: int mem_base;
23489: const xmlChar * ret_val;
23490: xmlChar * name; /* the full QName */
23491: int n_name;
23492: int * len; /* an int * */
23493: int n_len;
23494:
23495: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
23496: for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
23497: mem_base = xmlMemBlocks();
23498: name = gen_const_xmlChar_ptr(n_name, 0);
23499: len = gen_int_ptr(n_len, 1);
23500:
23501: ret_val = xmlSplitQName3((const xmlChar *)name, len);
23502: desret_const_xmlChar_ptr(ret_val);
23503: call_tests++;
23504: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
23505: des_int_ptr(n_len, len, 1);
23506: xmlResetLastError();
23507: if (mem_base != xmlMemBlocks()) {
23508: printf("Leak of %d blocks found in xmlSplitQName3",
23509: xmlMemBlocks() - mem_base);
23510: test_ret++;
23511: printf(" %d", n_name);
23512: printf(" %d", n_len);
23513: printf("\n");
23514: }
23515: }
23516: }
23517: function_tests++;
23518:
23519: return(test_ret);
23520: }
23521:
23522:
23523: static int
23524: test_xmlStringGetNodeList(void) {
23525: int test_ret = 0;
23526:
23527: int mem_base;
23528: xmlNodePtr ret_val;
23529: xmlDocPtr doc; /* the document */
23530: int n_doc;
23531: xmlChar * value; /* the value of the attribute */
23532: int n_value;
23533:
23534: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
23535: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
23536: mem_base = xmlMemBlocks();
23537: doc = gen_xmlDocPtr(n_doc, 0);
23538: value = gen_const_xmlChar_ptr(n_value, 1);
23539:
23540: ret_val = xmlStringGetNodeList(doc, (const xmlChar *)value);
23541: desret_xmlNodePtr(ret_val);
23542: call_tests++;
23543: des_xmlDocPtr(n_doc, doc, 0);
23544: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
23545: xmlResetLastError();
23546: if (mem_base != xmlMemBlocks()) {
23547: printf("Leak of %d blocks found in xmlStringGetNodeList",
23548: xmlMemBlocks() - mem_base);
23549: test_ret++;
23550: printf(" %d", n_doc);
23551: printf(" %d", n_value);
23552: printf("\n");
23553: }
23554: }
23555: }
23556: function_tests++;
23557:
23558: return(test_ret);
23559: }
23560:
23561:
23562: static int
23563: test_xmlStringLenGetNodeList(void) {
23564: int test_ret = 0;
23565:
23566: int mem_base;
23567: xmlNodePtr ret_val;
23568: xmlDocPtr doc; /* the document */
23569: int n_doc;
23570: xmlChar * value; /* the value of the text */
23571: int n_value;
23572: int len; /* the length of the string value */
23573: int n_len;
23574:
23575: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
23576: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
23577: for (n_len = 0;n_len < gen_nb_int;n_len++) {
23578: mem_base = xmlMemBlocks();
23579: doc = gen_xmlDocPtr(n_doc, 0);
23580: value = gen_const_xmlChar_ptr(n_value, 1);
23581: len = gen_int(n_len, 2);
23582:
23583: ret_val = xmlStringLenGetNodeList(doc, (const xmlChar *)value, len);
23584: desret_xmlNodePtr(ret_val);
23585: call_tests++;
23586: des_xmlDocPtr(n_doc, doc, 0);
23587: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
23588: des_int(n_len, len, 2);
23589: xmlResetLastError();
23590: if (mem_base != xmlMemBlocks()) {
23591: printf("Leak of %d blocks found in xmlStringLenGetNodeList",
23592: xmlMemBlocks() - mem_base);
23593: test_ret++;
23594: printf(" %d", n_doc);
23595: printf(" %d", n_value);
23596: printf(" %d", n_len);
23597: printf("\n");
23598: }
23599: }
23600: }
23601: }
23602: function_tests++;
23603:
23604: return(test_ret);
23605: }
23606:
23607:
23608: static int
23609: test_xmlTextConcat(void) {
23610: int test_ret = 0;
23611:
23612: int mem_base;
23613: int ret_val;
23614: xmlNodePtr node; /* the node */
23615: int n_node;
23616: xmlChar * content; /* the content */
23617: int n_content;
23618: int len; /* @content length */
23619: int n_len;
23620:
23621: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
23622: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
23623: for (n_len = 0;n_len < gen_nb_int;n_len++) {
23624: mem_base = xmlMemBlocks();
23625: node = gen_xmlNodePtr(n_node, 0);
23626: content = gen_const_xmlChar_ptr(n_content, 1);
23627: len = gen_int(n_len, 2);
23628:
23629: ret_val = xmlTextConcat(node, (const xmlChar *)content, len);
23630: desret_int(ret_val);
23631: call_tests++;
23632: des_xmlNodePtr(n_node, node, 0);
23633: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
23634: des_int(n_len, len, 2);
23635: xmlResetLastError();
23636: if (mem_base != xmlMemBlocks()) {
23637: printf("Leak of %d blocks found in xmlTextConcat",
23638: xmlMemBlocks() - mem_base);
23639: test_ret++;
23640: printf(" %d", n_node);
23641: printf(" %d", n_content);
23642: printf(" %d", n_len);
23643: printf("\n");
23644: }
23645: }
23646: }
23647: }
23648: function_tests++;
23649:
23650: return(test_ret);
23651: }
23652:
23653:
23654: static int
23655: test_xmlTextMerge(void) {
23656: int test_ret = 0;
23657:
23658: int mem_base;
23659: xmlNodePtr ret_val;
23660: xmlNodePtr first; /* the first text node */
23661: int n_first;
23662: xmlNodePtr second; /* the second text node being merged */
23663: int n_second;
23664:
23665: for (n_first = 0;n_first < gen_nb_xmlNodePtr_in;n_first++) {
23666: for (n_second = 0;n_second < gen_nb_xmlNodePtr_in;n_second++) {
23667: mem_base = xmlMemBlocks();
23668: first = gen_xmlNodePtr_in(n_first, 0);
23669: second = gen_xmlNodePtr_in(n_second, 1);
23670:
23671: ret_val = xmlTextMerge(first, second);
23672: if ((first != NULL) && (first->type != XML_TEXT_NODE)) {
23673: xmlUnlinkNode(second);
23674: xmlFreeNode(second) ; second = NULL ; }
23675: desret_xmlNodePtr(ret_val);
23676: call_tests++;
23677: des_xmlNodePtr_in(n_first, first, 0);
23678: des_xmlNodePtr_in(n_second, second, 1);
23679: xmlResetLastError();
23680: if (mem_base != xmlMemBlocks()) {
23681: printf("Leak of %d blocks found in xmlTextMerge",
23682: xmlMemBlocks() - mem_base);
23683: test_ret++;
23684: printf(" %d", n_first);
23685: printf(" %d", n_second);
23686: printf("\n");
23687: }
23688: }
23689: }
23690: function_tests++;
23691:
23692: return(test_ret);
23693: }
23694:
23695:
23696: static int
23697: test_xmlUnsetNsProp(void) {
23698: int test_ret = 0;
23699:
23700: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
23701: int mem_base;
23702: int ret_val;
23703: xmlNodePtr node; /* the node */
23704: int n_node;
23705: xmlNsPtr ns; /* the namespace definition */
23706: int n_ns;
23707: xmlChar * name; /* the attribute name */
23708: int n_name;
23709:
23710: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
23711: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
23712: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
23713: mem_base = xmlMemBlocks();
23714: node = gen_xmlNodePtr(n_node, 0);
23715: ns = gen_xmlNsPtr(n_ns, 1);
23716: name = gen_const_xmlChar_ptr(n_name, 2);
23717:
23718: ret_val = xmlUnsetNsProp(node, ns, (const xmlChar *)name);
23719: desret_int(ret_val);
23720: call_tests++;
23721: des_xmlNodePtr(n_node, node, 0);
23722: des_xmlNsPtr(n_ns, ns, 1);
23723: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
23724: xmlResetLastError();
23725: if (mem_base != xmlMemBlocks()) {
23726: printf("Leak of %d blocks found in xmlUnsetNsProp",
23727: xmlMemBlocks() - mem_base);
23728: test_ret++;
23729: printf(" %d", n_node);
23730: printf(" %d", n_ns);
23731: printf(" %d", n_name);
23732: printf("\n");
23733: }
23734: }
23735: }
23736: }
23737: function_tests++;
23738: #endif
23739:
23740: return(test_ret);
23741: }
23742:
23743:
23744: static int
23745: test_xmlUnsetProp(void) {
23746: int test_ret = 0;
23747:
23748: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
23749: int mem_base;
23750: int ret_val;
23751: xmlNodePtr node; /* the node */
23752: int n_node;
23753: xmlChar * name; /* the attribute name */
23754: int n_name;
23755:
23756: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
23757: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
23758: mem_base = xmlMemBlocks();
23759: node = gen_xmlNodePtr(n_node, 0);
23760: name = gen_const_xmlChar_ptr(n_name, 1);
23761:
23762: ret_val = xmlUnsetProp(node, (const xmlChar *)name);
23763: desret_int(ret_val);
23764: call_tests++;
23765: des_xmlNodePtr(n_node, node, 0);
23766: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
23767: xmlResetLastError();
23768: if (mem_base != xmlMemBlocks()) {
23769: printf("Leak of %d blocks found in xmlUnsetProp",
23770: xmlMemBlocks() - mem_base);
23771: test_ret++;
23772: printf(" %d", n_node);
23773: printf(" %d", n_name);
23774: printf("\n");
23775: }
23776: }
23777: }
23778: function_tests++;
23779: #endif
23780:
23781: return(test_ret);
23782: }
23783:
23784:
23785: static int
23786: test_xmlValidateNCName(void) {
23787: int test_ret = 0;
23788:
23789: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_DEBUG_ENABLED) || defined (LIBXML_HTML_ENABLED) || defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_DOCB_ENABLED)
23790: #ifdef LIBXML_TREE_ENABLED
23791: int mem_base;
23792: int ret_val;
23793: xmlChar * value; /* the value to check */
23794: int n_value;
23795: int space; /* allow spaces in front and end of the string */
23796: int n_space;
23797:
23798: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
23799: for (n_space = 0;n_space < gen_nb_int;n_space++) {
23800: mem_base = xmlMemBlocks();
23801: value = gen_const_xmlChar_ptr(n_value, 0);
23802: space = gen_int(n_space, 1);
23803:
23804: ret_val = xmlValidateNCName((const xmlChar *)value, space);
23805: desret_int(ret_val);
23806: call_tests++;
23807: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
23808: des_int(n_space, space, 1);
23809: xmlResetLastError();
23810: if (mem_base != xmlMemBlocks()) {
23811: printf("Leak of %d blocks found in xmlValidateNCName",
23812: xmlMemBlocks() - mem_base);
23813: test_ret++;
23814: printf(" %d", n_value);
23815: printf(" %d", n_space);
23816: printf("\n");
23817: }
23818: }
23819: }
23820: function_tests++;
23821: #endif
23822: #endif
23823:
23824: return(test_ret);
23825: }
23826:
23827:
23828: static int
23829: test_xmlValidateNMToken(void) {
23830: int test_ret = 0;
23831:
23832: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
23833: #ifdef LIBXML_TREE_ENABLED
23834: int mem_base;
23835: int ret_val;
23836: xmlChar * value; /* the value to check */
23837: int n_value;
23838: int space; /* allow spaces in front and end of the string */
23839: int n_space;
23840:
23841: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
23842: for (n_space = 0;n_space < gen_nb_int;n_space++) {
23843: mem_base = xmlMemBlocks();
23844: value = gen_const_xmlChar_ptr(n_value, 0);
23845: space = gen_int(n_space, 1);
23846:
23847: ret_val = xmlValidateNMToken((const xmlChar *)value, space);
23848: desret_int(ret_val);
23849: call_tests++;
23850: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
23851: des_int(n_space, space, 1);
23852: xmlResetLastError();
23853: if (mem_base != xmlMemBlocks()) {
23854: printf("Leak of %d blocks found in xmlValidateNMToken",
23855: xmlMemBlocks() - mem_base);
23856: test_ret++;
23857: printf(" %d", n_value);
23858: printf(" %d", n_space);
23859: printf("\n");
23860: }
23861: }
23862: }
23863: function_tests++;
23864: #endif
23865: #endif
23866:
23867: return(test_ret);
23868: }
23869:
23870:
23871: static int
23872: test_xmlValidateName(void) {
23873: int test_ret = 0;
23874:
23875: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
23876: #ifdef LIBXML_TREE_ENABLED
23877: int mem_base;
23878: int ret_val;
23879: xmlChar * value; /* the value to check */
23880: int n_value;
23881: int space; /* allow spaces in front and end of the string */
23882: int n_space;
23883:
23884: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
23885: for (n_space = 0;n_space < gen_nb_int;n_space++) {
23886: mem_base = xmlMemBlocks();
23887: value = gen_const_xmlChar_ptr(n_value, 0);
23888: space = gen_int(n_space, 1);
23889:
23890: ret_val = xmlValidateName((const xmlChar *)value, space);
23891: desret_int(ret_val);
23892: call_tests++;
23893: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
23894: des_int(n_space, space, 1);
23895: xmlResetLastError();
23896: if (mem_base != xmlMemBlocks()) {
23897: printf("Leak of %d blocks found in xmlValidateName",
23898: xmlMemBlocks() - mem_base);
23899: test_ret++;
23900: printf(" %d", n_value);
23901: printf(" %d", n_space);
23902: printf("\n");
23903: }
23904: }
23905: }
23906: function_tests++;
23907: #endif
23908: #endif
23909:
23910: return(test_ret);
23911: }
23912:
23913:
23914: static int
23915: test_xmlValidateQName(void) {
23916: int test_ret = 0;
23917:
23918: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
23919: #ifdef LIBXML_TREE_ENABLED
23920: int mem_base;
23921: int ret_val;
23922: xmlChar * value; /* the value to check */
23923: int n_value;
23924: int space; /* allow spaces in front and end of the string */
23925: int n_space;
23926:
23927: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
23928: for (n_space = 0;n_space < gen_nb_int;n_space++) {
23929: mem_base = xmlMemBlocks();
23930: value = gen_const_xmlChar_ptr(n_value, 0);
23931: space = gen_int(n_space, 1);
23932:
23933: ret_val = xmlValidateQName((const xmlChar *)value, space);
23934: desret_int(ret_val);
23935: call_tests++;
23936: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
23937: des_int(n_space, space, 1);
23938: xmlResetLastError();
23939: if (mem_base != xmlMemBlocks()) {
23940: printf("Leak of %d blocks found in xmlValidateQName",
23941: xmlMemBlocks() - mem_base);
23942: test_ret++;
23943: printf(" %d", n_value);
23944: printf(" %d", n_space);
23945: printf("\n");
23946: }
23947: }
23948: }
23949: function_tests++;
23950: #endif
23951: #endif
23952:
23953: return(test_ret);
23954: }
23955:
23956: static int
23957: test_tree(void) {
23958: int test_ret = 0;
23959:
23960: if (quiet == 0) printf("Testing tree : 138 of 157 functions ...\n");
23961: test_ret += test_xmlAddChild();
23962: test_ret += test_xmlAddChildList();
23963: test_ret += test_xmlAddNextSibling();
23964: test_ret += test_xmlAddPrevSibling();
23965: test_ret += test_xmlAddSibling();
23966: test_ret += test_xmlAttrSerializeTxtContent();
23967: test_ret += test_xmlBufferAdd();
23968: test_ret += test_xmlBufferAddHead();
23969: test_ret += test_xmlBufferCCat();
23970: test_ret += test_xmlBufferCat();
23971: test_ret += test_xmlBufferContent();
23972: test_ret += test_xmlBufferCreate();
23973: test_ret += test_xmlBufferCreateSize();
23974: test_ret += test_xmlBufferCreateStatic();
23975: test_ret += test_xmlBufferEmpty();
23976: test_ret += test_xmlBufferGrow();
23977: test_ret += test_xmlBufferLength();
23978: test_ret += test_xmlBufferResize();
23979: test_ret += test_xmlBufferSetAllocationScheme();
23980: test_ret += test_xmlBufferShrink();
23981: test_ret += test_xmlBufferWriteCHAR();
23982: test_ret += test_xmlBufferWriteChar();
23983: test_ret += test_xmlBufferWriteQuotedString();
23984: test_ret += test_xmlBuildQName();
23985: test_ret += test_xmlChildElementCount();
23986: test_ret += test_xmlCopyDoc();
23987: test_ret += test_xmlCopyDtd();
23988: test_ret += test_xmlCopyNamespace();
23989: test_ret += test_xmlCopyNamespaceList();
23990: test_ret += test_xmlCopyNode();
23991: test_ret += test_xmlCopyNodeList();
23992: test_ret += test_xmlCopyProp();
23993: test_ret += test_xmlCopyPropList();
23994: test_ret += test_xmlCreateIntSubset();
23995: test_ret += test_xmlDOMWrapAdoptNode();
23996: test_ret += test_xmlDOMWrapCloneNode();
23997: test_ret += test_xmlDOMWrapNewCtxt();
23998: test_ret += test_xmlDOMWrapReconcileNamespaces();
23999: test_ret += test_xmlDOMWrapRemoveNode();
24000: test_ret += test_xmlDocCopyNode();
24001: test_ret += test_xmlDocCopyNodeList();
24002: test_ret += test_xmlDocDump();
24003: test_ret += test_xmlDocDumpFormatMemory();
24004: test_ret += test_xmlDocDumpFormatMemoryEnc();
24005: test_ret += test_xmlDocDumpMemory();
24006: test_ret += test_xmlDocDumpMemoryEnc();
24007: test_ret += test_xmlDocFormatDump();
24008: test_ret += test_xmlDocGetRootElement();
24009: test_ret += test_xmlDocSetRootElement();
24010: test_ret += test_xmlElemDump();
24011: test_ret += test_xmlFirstElementChild();
24012: test_ret += test_xmlGetBufferAllocationScheme();
24013: test_ret += test_xmlGetCompressMode();
24014: test_ret += test_xmlGetDocCompressMode();
24015: test_ret += test_xmlGetIntSubset();
24016: test_ret += test_xmlGetLastChild();
24017: test_ret += test_xmlGetLineNo();
24018: test_ret += test_xmlGetNoNsProp();
24019: test_ret += test_xmlGetNodePath();
24020: test_ret += test_xmlGetNsList();
24021: test_ret += test_xmlGetNsProp();
24022: test_ret += test_xmlGetProp();
24023: test_ret += test_xmlHasNsProp();
24024: test_ret += test_xmlHasProp();
24025: test_ret += test_xmlIsBlankNode();
24026: test_ret += test_xmlIsXHTML();
24027: test_ret += test_xmlLastElementChild();
24028: test_ret += test_xmlNewCDataBlock();
24029: test_ret += test_xmlNewCharRef();
24030: test_ret += test_xmlNewChild();
24031: test_ret += test_xmlNewComment();
24032: test_ret += test_xmlNewDoc();
24033: test_ret += test_xmlNewDocComment();
24034: test_ret += test_xmlNewDocFragment();
24035: test_ret += test_xmlNewDocNode();
24036: test_ret += test_xmlNewDocNodeEatName();
24037: test_ret += test_xmlNewDocPI();
24038: test_ret += test_xmlNewDocProp();
24039: test_ret += test_xmlNewDocRawNode();
24040: test_ret += test_xmlNewDocText();
24041: test_ret += test_xmlNewDocTextLen();
24042: test_ret += test_xmlNewDtd();
24043: test_ret += test_xmlNewNode();
24044: test_ret += test_xmlNewNodeEatName();
24045: test_ret += test_xmlNewNs();
24046: test_ret += test_xmlNewNsProp();
24047: test_ret += test_xmlNewNsPropEatName();
24048: test_ret += test_xmlNewPI();
24049: test_ret += test_xmlNewProp();
24050: test_ret += test_xmlNewReference();
24051: test_ret += test_xmlNewText();
24052: test_ret += test_xmlNewTextChild();
24053: test_ret += test_xmlNewTextLen();
24054: test_ret += test_xmlNextElementSibling();
24055: test_ret += test_xmlNodeAddContent();
24056: test_ret += test_xmlNodeAddContentLen();
24057: test_ret += test_xmlNodeBufGetContent();
24058: test_ret += test_xmlNodeDump();
24059: test_ret += test_xmlNodeDumpOutput();
24060: test_ret += test_xmlNodeGetBase();
24061: test_ret += test_xmlNodeGetContent();
24062: test_ret += test_xmlNodeGetLang();
24063: test_ret += test_xmlNodeGetSpacePreserve();
24064: test_ret += test_xmlNodeIsText();
24065: test_ret += test_xmlNodeListGetRawString();
24066: test_ret += test_xmlNodeListGetString();
24067: test_ret += test_xmlNodeSetBase();
24068: test_ret += test_xmlNodeSetContent();
24069: test_ret += test_xmlNodeSetContentLen();
24070: test_ret += test_xmlNodeSetLang();
24071: test_ret += test_xmlNodeSetName();
24072: test_ret += test_xmlNodeSetSpacePreserve();
24073: test_ret += test_xmlPreviousElementSibling();
24074: test_ret += test_xmlReconciliateNs();
24075: test_ret += test_xmlRemoveProp();
24076: test_ret += test_xmlReplaceNode();
24077: test_ret += test_xmlSaveFile();
24078: test_ret += test_xmlSaveFileEnc();
24079: test_ret += test_xmlSaveFileTo();
24080: test_ret += test_xmlSaveFormatFile();
24081: test_ret += test_xmlSaveFormatFileEnc();
24082: test_ret += test_xmlSaveFormatFileTo();
24083: test_ret += test_xmlSearchNs();
24084: test_ret += test_xmlSearchNsByHref();
24085: test_ret += test_xmlSetBufferAllocationScheme();
24086: test_ret += test_xmlSetCompressMode();
24087: test_ret += test_xmlSetDocCompressMode();
24088: test_ret += test_xmlSetNs();
24089: test_ret += test_xmlSetNsProp();
24090: test_ret += test_xmlSetProp();
24091: test_ret += test_xmlSplitQName2();
24092: test_ret += test_xmlSplitQName3();
24093: test_ret += test_xmlStringGetNodeList();
24094: test_ret += test_xmlStringLenGetNodeList();
24095: test_ret += test_xmlTextConcat();
24096: test_ret += test_xmlTextMerge();
24097: test_ret += test_xmlUnsetNsProp();
24098: test_ret += test_xmlUnsetProp();
24099: test_ret += test_xmlValidateNCName();
24100: test_ret += test_xmlValidateNMToken();
24101: test_ret += test_xmlValidateName();
24102: test_ret += test_xmlValidateQName();
24103:
24104: if (test_ret != 0)
24105: printf("Module tree: %d errors\n", test_ret);
24106: return(test_ret);
24107: }
24108:
24109: static int
24110: test_xmlBuildRelativeURI(void) {
24111: int test_ret = 0;
24112:
24113: int mem_base;
24114: xmlChar * ret_val;
24115: xmlChar * URI; /* the URI reference under consideration */
24116: int n_URI;
24117: xmlChar * base; /* the base value */
24118: int n_base;
24119:
24120: for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
24121: for (n_base = 0;n_base < gen_nb_const_xmlChar_ptr;n_base++) {
24122: mem_base = xmlMemBlocks();
24123: URI = gen_const_xmlChar_ptr(n_URI, 0);
24124: base = gen_const_xmlChar_ptr(n_base, 1);
24125:
24126: ret_val = xmlBuildRelativeURI((const xmlChar *)URI, (const xmlChar *)base);
24127: desret_xmlChar_ptr(ret_val);
24128: call_tests++;
24129: des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 0);
24130: des_const_xmlChar_ptr(n_base, (const xmlChar *)base, 1);
24131: xmlResetLastError();
24132: if (mem_base != xmlMemBlocks()) {
24133: printf("Leak of %d blocks found in xmlBuildRelativeURI",
24134: xmlMemBlocks() - mem_base);
24135: test_ret++;
24136: printf(" %d", n_URI);
24137: printf(" %d", n_base);
24138: printf("\n");
24139: }
24140: }
24141: }
24142: function_tests++;
24143:
24144: return(test_ret);
24145: }
24146:
24147:
24148: static int
24149: test_xmlBuildURI(void) {
24150: int test_ret = 0;
24151:
24152: int mem_base;
24153: xmlChar * ret_val;
24154: xmlChar * URI; /* the URI instance found in the document */
24155: int n_URI;
24156: xmlChar * base; /* the base value */
24157: int n_base;
24158:
24159: for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
24160: for (n_base = 0;n_base < gen_nb_const_xmlChar_ptr;n_base++) {
24161: mem_base = xmlMemBlocks();
24162: URI = gen_const_xmlChar_ptr(n_URI, 0);
24163: base = gen_const_xmlChar_ptr(n_base, 1);
24164:
24165: ret_val = xmlBuildURI((const xmlChar *)URI, (const xmlChar *)base);
24166: desret_xmlChar_ptr(ret_val);
24167: call_tests++;
24168: des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 0);
24169: des_const_xmlChar_ptr(n_base, (const xmlChar *)base, 1);
24170: xmlResetLastError();
24171: if (mem_base != xmlMemBlocks()) {
24172: printf("Leak of %d blocks found in xmlBuildURI",
24173: xmlMemBlocks() - mem_base);
24174: test_ret++;
24175: printf(" %d", n_URI);
24176: printf(" %d", n_base);
24177: printf("\n");
24178: }
24179: }
24180: }
24181: function_tests++;
24182:
24183: return(test_ret);
24184: }
24185:
24186:
24187: static int
24188: test_xmlCanonicPath(void) {
24189: int test_ret = 0;
24190:
24191: int mem_base;
24192: xmlChar * ret_val;
24193: xmlChar * path; /* the resource locator in a filesystem notation */
24194: int n_path;
24195:
24196: for (n_path = 0;n_path < gen_nb_const_xmlChar_ptr;n_path++) {
24197: mem_base = xmlMemBlocks();
24198: path = gen_const_xmlChar_ptr(n_path, 0);
24199:
24200: ret_val = xmlCanonicPath((const xmlChar *)path);
24201: desret_xmlChar_ptr(ret_val);
24202: call_tests++;
24203: des_const_xmlChar_ptr(n_path, (const xmlChar *)path, 0);
24204: xmlResetLastError();
24205: if (mem_base != xmlMemBlocks()) {
24206: printf("Leak of %d blocks found in xmlCanonicPath",
24207: xmlMemBlocks() - mem_base);
24208: test_ret++;
24209: printf(" %d", n_path);
24210: printf("\n");
24211: }
24212: }
24213: function_tests++;
24214:
24215: return(test_ret);
24216: }
24217:
24218:
24219: static int
24220: test_xmlCreateURI(void) {
24221: int test_ret = 0;
24222:
24223:
24224: /* missing type support */
24225: return(test_ret);
24226: }
24227:
24228:
24229: static int
24230: test_xmlNormalizeURIPath(void) {
24231: int test_ret = 0;
24232:
24233: int mem_base;
24234: int ret_val;
24235: char * path; /* pointer to the path string */
24236: int n_path;
24237:
24238: for (n_path = 0;n_path < gen_nb_char_ptr;n_path++) {
24239: mem_base = xmlMemBlocks();
24240: path = gen_char_ptr(n_path, 0);
24241:
24242: ret_val = xmlNormalizeURIPath(path);
24243: desret_int(ret_val);
24244: call_tests++;
24245: des_char_ptr(n_path, path, 0);
24246: xmlResetLastError();
24247: if (mem_base != xmlMemBlocks()) {
24248: printf("Leak of %d blocks found in xmlNormalizeURIPath",
24249: xmlMemBlocks() - mem_base);
24250: test_ret++;
24251: printf(" %d", n_path);
24252: printf("\n");
24253: }
24254: }
24255: function_tests++;
24256:
24257: return(test_ret);
24258: }
24259:
24260:
24261: static int
24262: test_xmlParseURI(void) {
24263: int test_ret = 0;
24264:
24265:
24266: /* missing type support */
24267: return(test_ret);
24268: }
24269:
24270:
24271: static int
24272: test_xmlParseURIRaw(void) {
24273: int test_ret = 0;
24274:
24275:
24276: /* missing type support */
24277: return(test_ret);
24278: }
24279:
24280:
24281: #define gen_nb_xmlURIPtr 1
24282: static xmlURIPtr gen_xmlURIPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24283: return(NULL);
24284: }
24285: static void des_xmlURIPtr(int no ATTRIBUTE_UNUSED, xmlURIPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24286: }
24287:
24288: static int
24289: test_xmlParseURIReference(void) {
24290: int test_ret = 0;
24291:
24292: int mem_base;
24293: int ret_val;
24294: xmlURIPtr uri; /* pointer to an URI structure */
24295: int n_uri;
24296: char * str; /* the string to analyze */
24297: int n_str;
24298:
24299: for (n_uri = 0;n_uri < gen_nb_xmlURIPtr;n_uri++) {
24300: for (n_str = 0;n_str < gen_nb_const_char_ptr;n_str++) {
24301: mem_base = xmlMemBlocks();
24302: uri = gen_xmlURIPtr(n_uri, 0);
24303: str = gen_const_char_ptr(n_str, 1);
24304:
24305: ret_val = xmlParseURIReference(uri, (const char *)str);
24306: desret_int(ret_val);
24307: call_tests++;
24308: des_xmlURIPtr(n_uri, uri, 0);
24309: des_const_char_ptr(n_str, (const char *)str, 1);
24310: xmlResetLastError();
24311: if (mem_base != xmlMemBlocks()) {
24312: printf("Leak of %d blocks found in xmlParseURIReference",
24313: xmlMemBlocks() - mem_base);
24314: test_ret++;
24315: printf(" %d", n_uri);
24316: printf(" %d", n_str);
24317: printf("\n");
24318: }
24319: }
24320: }
24321: function_tests++;
24322:
24323: return(test_ret);
24324: }
24325:
24326:
24327: static int
24328: test_xmlPathToURI(void) {
24329: int test_ret = 0;
24330:
24331: int mem_base;
24332: xmlChar * ret_val;
24333: xmlChar * path; /* the resource locator in a filesystem notation */
24334: int n_path;
24335:
24336: for (n_path = 0;n_path < gen_nb_const_xmlChar_ptr;n_path++) {
24337: mem_base = xmlMemBlocks();
24338: path = gen_const_xmlChar_ptr(n_path, 0);
24339:
24340: ret_val = xmlPathToURI((const xmlChar *)path);
24341: desret_xmlChar_ptr(ret_val);
24342: call_tests++;
24343: des_const_xmlChar_ptr(n_path, (const xmlChar *)path, 0);
24344: xmlResetLastError();
24345: if (mem_base != xmlMemBlocks()) {
24346: printf("Leak of %d blocks found in xmlPathToURI",
24347: xmlMemBlocks() - mem_base);
24348: test_ret++;
24349: printf(" %d", n_path);
24350: printf("\n");
24351: }
24352: }
24353: function_tests++;
24354:
24355: return(test_ret);
24356: }
24357:
24358:
24359: static int
24360: test_xmlPrintURI(void) {
24361: int test_ret = 0;
24362:
24363: int mem_base;
24364: FILE * stream; /* a FILE* for the output */
24365: int n_stream;
24366: xmlURIPtr uri; /* pointer to an xmlURI */
24367: int n_uri;
24368:
24369: for (n_stream = 0;n_stream < gen_nb_FILE_ptr;n_stream++) {
24370: for (n_uri = 0;n_uri < gen_nb_xmlURIPtr;n_uri++) {
24371: mem_base = xmlMemBlocks();
24372: stream = gen_FILE_ptr(n_stream, 0);
24373: uri = gen_xmlURIPtr(n_uri, 1);
24374:
24375: xmlPrintURI(stream, uri);
24376: call_tests++;
24377: des_FILE_ptr(n_stream, stream, 0);
24378: des_xmlURIPtr(n_uri, uri, 1);
24379: xmlResetLastError();
24380: if (mem_base != xmlMemBlocks()) {
24381: printf("Leak of %d blocks found in xmlPrintURI",
24382: xmlMemBlocks() - mem_base);
24383: test_ret++;
24384: printf(" %d", n_stream);
24385: printf(" %d", n_uri);
24386: printf("\n");
24387: }
24388: }
24389: }
24390: function_tests++;
24391:
24392: return(test_ret);
24393: }
24394:
24395:
24396: static int
24397: test_xmlSaveUri(void) {
24398: int test_ret = 0;
24399:
24400: int mem_base;
24401: xmlChar * ret_val;
24402: xmlURIPtr uri; /* pointer to an xmlURI */
24403: int n_uri;
24404:
24405: for (n_uri = 0;n_uri < gen_nb_xmlURIPtr;n_uri++) {
24406: mem_base = xmlMemBlocks();
24407: uri = gen_xmlURIPtr(n_uri, 0);
24408:
24409: ret_val = xmlSaveUri(uri);
24410: desret_xmlChar_ptr(ret_val);
24411: call_tests++;
24412: des_xmlURIPtr(n_uri, uri, 0);
24413: xmlResetLastError();
24414: if (mem_base != xmlMemBlocks()) {
24415: printf("Leak of %d blocks found in xmlSaveUri",
24416: xmlMemBlocks() - mem_base);
24417: test_ret++;
24418: printf(" %d", n_uri);
24419: printf("\n");
24420: }
24421: }
24422: function_tests++;
24423:
24424: return(test_ret);
24425: }
24426:
24427:
24428: static int
24429: test_xmlURIEscape(void) {
24430: int test_ret = 0;
24431:
24432: int mem_base;
24433: xmlChar * ret_val;
24434: xmlChar * str; /* the string of the URI to escape */
24435: int n_str;
24436:
24437: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
24438: mem_base = xmlMemBlocks();
24439: str = gen_const_xmlChar_ptr(n_str, 0);
24440:
24441: ret_val = xmlURIEscape((const xmlChar *)str);
24442: desret_xmlChar_ptr(ret_val);
24443: call_tests++;
24444: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
24445: xmlResetLastError();
24446: if (mem_base != xmlMemBlocks()) {
24447: printf("Leak of %d blocks found in xmlURIEscape",
24448: xmlMemBlocks() - mem_base);
24449: test_ret++;
24450: printf(" %d", n_str);
24451: printf("\n");
24452: }
24453: }
24454: function_tests++;
24455:
24456: return(test_ret);
24457: }
24458:
24459:
24460: static int
24461: test_xmlURIEscapeStr(void) {
24462: int test_ret = 0;
24463:
24464: int mem_base;
24465: xmlChar * ret_val;
24466: xmlChar * str; /* string to escape */
24467: int n_str;
24468: xmlChar * list; /* exception list string of chars not to escape */
24469: int n_list;
24470:
24471: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
24472: for (n_list = 0;n_list < gen_nb_const_xmlChar_ptr;n_list++) {
24473: mem_base = xmlMemBlocks();
24474: str = gen_const_xmlChar_ptr(n_str, 0);
24475: list = gen_const_xmlChar_ptr(n_list, 1);
24476:
24477: ret_val = xmlURIEscapeStr((const xmlChar *)str, (const xmlChar *)list);
24478: desret_xmlChar_ptr(ret_val);
24479: call_tests++;
24480: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
24481: des_const_xmlChar_ptr(n_list, (const xmlChar *)list, 1);
24482: xmlResetLastError();
24483: if (mem_base != xmlMemBlocks()) {
24484: printf("Leak of %d blocks found in xmlURIEscapeStr",
24485: xmlMemBlocks() - mem_base);
24486: test_ret++;
24487: printf(" %d", n_str);
24488: printf(" %d", n_list);
24489: printf("\n");
24490: }
24491: }
24492: }
24493: function_tests++;
24494:
24495: return(test_ret);
24496: }
24497:
24498:
24499: static int
24500: test_xmlURIUnescapeString(void) {
24501: int test_ret = 0;
24502:
24503:
24504: /* missing type support */
24505: return(test_ret);
24506: }
24507:
24508: static int
24509: test_uri(void) {
24510: int test_ret = 0;
24511:
24512: if (quiet == 0) printf("Testing uri : 10 of 15 functions ...\n");
24513: test_ret += test_xmlBuildRelativeURI();
24514: test_ret += test_xmlBuildURI();
24515: test_ret += test_xmlCanonicPath();
24516: test_ret += test_xmlCreateURI();
24517: test_ret += test_xmlNormalizeURIPath();
24518: test_ret += test_xmlParseURI();
24519: test_ret += test_xmlParseURIRaw();
24520: test_ret += test_xmlParseURIReference();
24521: test_ret += test_xmlPathToURI();
24522: test_ret += test_xmlPrintURI();
24523: test_ret += test_xmlSaveUri();
24524: test_ret += test_xmlURIEscape();
24525: test_ret += test_xmlURIEscapeStr();
24526: test_ret += test_xmlURIUnescapeString();
24527:
24528: if (test_ret != 0)
24529: printf("Module uri: %d errors\n", test_ret);
24530: return(test_ret);
24531: }
24532:
24533: static int
24534: test_xmlAddAttributeDecl(void) {
24535: int test_ret = 0;
24536:
24537: int mem_base;
24538: xmlAttributePtr ret_val;
24539: xmlValidCtxtPtr ctxt; /* the validation context */
24540: int n_ctxt;
24541: xmlDtdPtr dtd; /* pointer to the DTD */
24542: int n_dtd;
24543: xmlChar * elem; /* the element name */
24544: int n_elem;
24545: xmlChar * name; /* the attribute name */
24546: int n_name;
24547: xmlChar * ns; /* the attribute namespace prefix */
24548: int n_ns;
24549: xmlAttributeType type; /* the attribute type */
24550: int n_type;
24551: xmlAttributeDefault def; /* the attribute default type */
24552: int n_def;
24553: xmlChar * defaultValue; /* the attribute default value */
24554: int n_defaultValue;
24555: xmlEnumerationPtr tree; /* if it's an enumeration, the associated list */
24556: int n_tree;
24557:
24558: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
24559: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
24560: for (n_elem = 0;n_elem < gen_nb_const_xmlChar_ptr;n_elem++) {
24561: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
24562: for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) {
24563: for (n_type = 0;n_type < gen_nb_xmlAttributeType;n_type++) {
24564: for (n_def = 0;n_def < gen_nb_xmlAttributeDefault;n_def++) {
24565: for (n_defaultValue = 0;n_defaultValue < gen_nb_const_xmlChar_ptr;n_defaultValue++) {
24566: for (n_tree = 0;n_tree < gen_nb_xmlEnumerationPtr;n_tree++) {
24567: mem_base = xmlMemBlocks();
24568: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
24569: dtd = gen_xmlDtdPtr(n_dtd, 1);
24570: elem = gen_const_xmlChar_ptr(n_elem, 2);
24571: name = gen_const_xmlChar_ptr(n_name, 3);
24572: ns = gen_const_xmlChar_ptr(n_ns, 4);
24573: type = gen_xmlAttributeType(n_type, 5);
24574: def = gen_xmlAttributeDefault(n_def, 6);
24575: defaultValue = gen_const_xmlChar_ptr(n_defaultValue, 7);
24576: tree = gen_xmlEnumerationPtr(n_tree, 8);
24577:
24578: ret_val = xmlAddAttributeDecl(ctxt, dtd, (const xmlChar *)elem, (const xmlChar *)name, (const xmlChar *)ns, type, def, (const xmlChar *)defaultValue, tree);
24579: desret_xmlAttributePtr(ret_val);
24580: call_tests++;
24581: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
24582: des_xmlDtdPtr(n_dtd, dtd, 1);
24583: des_const_xmlChar_ptr(n_elem, (const xmlChar *)elem, 2);
24584: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 3);
24585: des_const_xmlChar_ptr(n_ns, (const xmlChar *)ns, 4);
24586: des_xmlAttributeType(n_type, type, 5);
24587: des_xmlAttributeDefault(n_def, def, 6);
24588: des_const_xmlChar_ptr(n_defaultValue, (const xmlChar *)defaultValue, 7);
24589: des_xmlEnumerationPtr(n_tree, tree, 8);
24590: xmlResetLastError();
24591: if (mem_base != xmlMemBlocks()) {
24592: printf("Leak of %d blocks found in xmlAddAttributeDecl",
24593: xmlMemBlocks() - mem_base);
24594: test_ret++;
24595: printf(" %d", n_ctxt);
24596: printf(" %d", n_dtd);
24597: printf(" %d", n_elem);
24598: printf(" %d", n_name);
24599: printf(" %d", n_ns);
24600: printf(" %d", n_type);
24601: printf(" %d", n_def);
24602: printf(" %d", n_defaultValue);
24603: printf(" %d", n_tree);
24604: printf("\n");
24605: }
24606: }
24607: }
24608: }
24609: }
24610: }
24611: }
24612: }
24613: }
24614: }
24615: function_tests++;
24616:
24617: return(test_ret);
24618: }
24619:
24620:
24621: static int
24622: test_xmlAddElementDecl(void) {
24623: int test_ret = 0;
24624:
24625: int mem_base;
24626: xmlElementPtr ret_val;
24627: xmlValidCtxtPtr ctxt; /* the validation context */
24628: int n_ctxt;
24629: xmlDtdPtr dtd; /* pointer to the DTD */
24630: int n_dtd;
24631: xmlChar * name; /* the entity name */
24632: int n_name;
24633: xmlElementTypeVal type; /* the element type */
24634: int n_type;
24635: xmlElementContentPtr content; /* the element content tree or NULL */
24636: int n_content;
24637:
24638: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
24639: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
24640: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
24641: for (n_type = 0;n_type < gen_nb_xmlElementTypeVal;n_type++) {
24642: for (n_content = 0;n_content < gen_nb_xmlElementContentPtr;n_content++) {
24643: mem_base = xmlMemBlocks();
24644: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
24645: dtd = gen_xmlDtdPtr(n_dtd, 1);
24646: name = gen_const_xmlChar_ptr(n_name, 2);
24647: type = gen_xmlElementTypeVal(n_type, 3);
24648: content = gen_xmlElementContentPtr(n_content, 4);
24649:
24650: ret_val = xmlAddElementDecl(ctxt, dtd, (const xmlChar *)name, type, content);
24651: desret_xmlElementPtr(ret_val);
24652: call_tests++;
24653: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
24654: des_xmlDtdPtr(n_dtd, dtd, 1);
24655: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
24656: des_xmlElementTypeVal(n_type, type, 3);
24657: des_xmlElementContentPtr(n_content, content, 4);
24658: xmlResetLastError();
24659: if (mem_base != xmlMemBlocks()) {
24660: printf("Leak of %d blocks found in xmlAddElementDecl",
24661: xmlMemBlocks() - mem_base);
24662: test_ret++;
24663: printf(" %d", n_ctxt);
24664: printf(" %d", n_dtd);
24665: printf(" %d", n_name);
24666: printf(" %d", n_type);
24667: printf(" %d", n_content);
24668: printf("\n");
24669: }
24670: }
24671: }
24672: }
24673: }
24674: }
24675: function_tests++;
24676:
24677: return(test_ret);
24678: }
24679:
24680:
24681: static int
24682: test_xmlAddID(void) {
24683: int test_ret = 0;
24684:
24685:
24686: /* missing type support */
24687: return(test_ret);
24688: }
24689:
24690:
24691: static int
24692: test_xmlAddNotationDecl(void) {
24693: int test_ret = 0;
24694:
24695:
24696: /* missing type support */
24697: return(test_ret);
24698: }
24699:
24700:
24701: static int
24702: test_xmlAddRef(void) {
24703: int test_ret = 0;
24704:
24705:
24706: /* missing type support */
24707: return(test_ret);
24708: }
24709:
24710:
24711: #define gen_nb_xmlAttributeTablePtr 1
24712: static xmlAttributeTablePtr gen_xmlAttributeTablePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24713: return(NULL);
24714: }
24715: static void des_xmlAttributeTablePtr(int no ATTRIBUTE_UNUSED, xmlAttributeTablePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24716: }
24717:
24718: static int
24719: test_xmlCopyAttributeTable(void) {
24720: int test_ret = 0;
24721:
24722:
24723: /* missing type support */
24724: return(test_ret);
24725: }
24726:
24727:
24728: static int
24729: test_xmlCopyDocElementContent(void) {
24730: int test_ret = 0;
24731:
24732: int mem_base;
24733: xmlElementContentPtr ret_val;
24734: xmlDocPtr doc; /* the document owning the element declaration */
24735: int n_doc;
24736: xmlElementContentPtr cur; /* An element content pointer. */
24737: int n_cur;
24738:
24739: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
24740: for (n_cur = 0;n_cur < gen_nb_xmlElementContentPtr;n_cur++) {
24741: mem_base = xmlMemBlocks();
24742: doc = gen_xmlDocPtr(n_doc, 0);
24743: cur = gen_xmlElementContentPtr(n_cur, 1);
24744:
24745: ret_val = xmlCopyDocElementContent(doc, cur);
24746: desret_xmlElementContentPtr(ret_val);
24747: call_tests++;
24748: des_xmlDocPtr(n_doc, doc, 0);
24749: des_xmlElementContentPtr(n_cur, cur, 1);
24750: xmlResetLastError();
24751: if (mem_base != xmlMemBlocks()) {
24752: printf("Leak of %d blocks found in xmlCopyDocElementContent",
24753: xmlMemBlocks() - mem_base);
24754: test_ret++;
24755: printf(" %d", n_doc);
24756: printf(" %d", n_cur);
24757: printf("\n");
24758: }
24759: }
24760: }
24761: function_tests++;
24762:
24763: return(test_ret);
24764: }
24765:
24766:
24767: static int
24768: test_xmlCopyElementContent(void) {
24769: int test_ret = 0;
24770:
24771: int mem_base;
24772: xmlElementContentPtr ret_val;
24773: xmlElementContentPtr cur; /* An element content pointer. */
24774: int n_cur;
24775:
24776: for (n_cur = 0;n_cur < gen_nb_xmlElementContentPtr;n_cur++) {
24777: mem_base = xmlMemBlocks();
24778: cur = gen_xmlElementContentPtr(n_cur, 0);
24779:
24780: ret_val = xmlCopyElementContent(cur);
24781: desret_xmlElementContentPtr(ret_val);
24782: call_tests++;
24783: des_xmlElementContentPtr(n_cur, cur, 0);
24784: xmlResetLastError();
24785: if (mem_base != xmlMemBlocks()) {
24786: printf("Leak of %d blocks found in xmlCopyElementContent",
24787: xmlMemBlocks() - mem_base);
24788: test_ret++;
24789: printf(" %d", n_cur);
24790: printf("\n");
24791: }
24792: }
24793: function_tests++;
24794:
24795: return(test_ret);
24796: }
24797:
24798:
24799: #define gen_nb_xmlElementTablePtr 1
24800: static xmlElementTablePtr gen_xmlElementTablePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24801: return(NULL);
24802: }
24803: static void des_xmlElementTablePtr(int no ATTRIBUTE_UNUSED, xmlElementTablePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24804: }
24805:
24806: static int
24807: test_xmlCopyElementTable(void) {
24808: int test_ret = 0;
24809:
24810:
24811: /* missing type support */
24812: return(test_ret);
24813: }
24814:
24815:
24816: static int
24817: test_xmlCopyEnumeration(void) {
24818: int test_ret = 0;
24819:
24820:
24821: /* missing type support */
24822: return(test_ret);
24823: }
24824:
24825:
24826: #define gen_nb_xmlNotationTablePtr 1
24827: static xmlNotationTablePtr gen_xmlNotationTablePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24828: return(NULL);
24829: }
24830: static void des_xmlNotationTablePtr(int no ATTRIBUTE_UNUSED, xmlNotationTablePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24831: }
24832:
24833: static int
24834: test_xmlCopyNotationTable(void) {
24835: int test_ret = 0;
24836:
24837:
24838: /* missing type support */
24839: return(test_ret);
24840: }
24841:
24842:
24843: static int
24844: test_xmlCreateEnumeration(void) {
24845: int test_ret = 0;
24846:
24847:
24848: /* missing type support */
24849: return(test_ret);
24850: }
24851:
24852:
24853: #define gen_nb_xmlAttributePtr 1
24854: static xmlAttributePtr gen_xmlAttributePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24855: return(NULL);
24856: }
24857: static void des_xmlAttributePtr(int no ATTRIBUTE_UNUSED, xmlAttributePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24858: }
24859:
24860: static int
24861: test_xmlDumpAttributeDecl(void) {
24862: int test_ret = 0;
24863:
24864: #if defined(LIBXML_OUTPUT_ENABLED)
24865: int mem_base;
24866: xmlBufferPtr buf; /* the XML buffer output */
24867: int n_buf;
24868: xmlAttributePtr attr; /* An attribute declaration */
24869: int n_attr;
24870:
24871: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
24872: for (n_attr = 0;n_attr < gen_nb_xmlAttributePtr;n_attr++) {
24873: mem_base = xmlMemBlocks();
24874: buf = gen_xmlBufferPtr(n_buf, 0);
24875: attr = gen_xmlAttributePtr(n_attr, 1);
24876:
24877: xmlDumpAttributeDecl(buf, attr);
24878: call_tests++;
24879: des_xmlBufferPtr(n_buf, buf, 0);
24880: des_xmlAttributePtr(n_attr, attr, 1);
24881: xmlResetLastError();
24882: if (mem_base != xmlMemBlocks()) {
24883: printf("Leak of %d blocks found in xmlDumpAttributeDecl",
24884: xmlMemBlocks() - mem_base);
24885: test_ret++;
24886: printf(" %d", n_buf);
24887: printf(" %d", n_attr);
24888: printf("\n");
24889: }
24890: }
24891: }
24892: function_tests++;
24893: #endif
24894:
24895: return(test_ret);
24896: }
24897:
24898:
24899: static int
24900: test_xmlDumpAttributeTable(void) {
24901: int test_ret = 0;
24902:
24903: #if defined(LIBXML_OUTPUT_ENABLED)
24904: int mem_base;
24905: xmlBufferPtr buf; /* the XML buffer output */
24906: int n_buf;
24907: xmlAttributeTablePtr table; /* An attribute table */
24908: int n_table;
24909:
24910: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
24911: for (n_table = 0;n_table < gen_nb_xmlAttributeTablePtr;n_table++) {
24912: mem_base = xmlMemBlocks();
24913: buf = gen_xmlBufferPtr(n_buf, 0);
24914: table = gen_xmlAttributeTablePtr(n_table, 1);
24915:
24916: xmlDumpAttributeTable(buf, table);
24917: call_tests++;
24918: des_xmlBufferPtr(n_buf, buf, 0);
24919: des_xmlAttributeTablePtr(n_table, table, 1);
24920: xmlResetLastError();
24921: if (mem_base != xmlMemBlocks()) {
24922: printf("Leak of %d blocks found in xmlDumpAttributeTable",
24923: xmlMemBlocks() - mem_base);
24924: test_ret++;
24925: printf(" %d", n_buf);
24926: printf(" %d", n_table);
24927: printf("\n");
24928: }
24929: }
24930: }
24931: function_tests++;
24932: #endif
24933:
24934: return(test_ret);
24935: }
24936:
24937:
24938: #define gen_nb_xmlElementPtr 1
24939: static xmlElementPtr gen_xmlElementPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24940: return(NULL);
24941: }
24942: static void des_xmlElementPtr(int no ATTRIBUTE_UNUSED, xmlElementPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24943: }
24944:
24945: static int
24946: test_xmlDumpElementDecl(void) {
24947: int test_ret = 0;
24948:
24949: #if defined(LIBXML_OUTPUT_ENABLED)
24950: int mem_base;
24951: xmlBufferPtr buf; /* the XML buffer output */
24952: int n_buf;
24953: xmlElementPtr elem; /* An element table */
24954: int n_elem;
24955:
24956: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
24957: for (n_elem = 0;n_elem < gen_nb_xmlElementPtr;n_elem++) {
24958: mem_base = xmlMemBlocks();
24959: buf = gen_xmlBufferPtr(n_buf, 0);
24960: elem = gen_xmlElementPtr(n_elem, 1);
24961:
24962: xmlDumpElementDecl(buf, elem);
24963: call_tests++;
24964: des_xmlBufferPtr(n_buf, buf, 0);
24965: des_xmlElementPtr(n_elem, elem, 1);
24966: xmlResetLastError();
24967: if (mem_base != xmlMemBlocks()) {
24968: printf("Leak of %d blocks found in xmlDumpElementDecl",
24969: xmlMemBlocks() - mem_base);
24970: test_ret++;
24971: printf(" %d", n_buf);
24972: printf(" %d", n_elem);
24973: printf("\n");
24974: }
24975: }
24976: }
24977: function_tests++;
24978: #endif
24979:
24980: return(test_ret);
24981: }
24982:
24983:
24984: static int
24985: test_xmlDumpElementTable(void) {
24986: int test_ret = 0;
24987:
24988: #if defined(LIBXML_OUTPUT_ENABLED)
24989: int mem_base;
24990: xmlBufferPtr buf; /* the XML buffer output */
24991: int n_buf;
24992: xmlElementTablePtr table; /* An element table */
24993: int n_table;
24994:
24995: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
24996: for (n_table = 0;n_table < gen_nb_xmlElementTablePtr;n_table++) {
24997: mem_base = xmlMemBlocks();
24998: buf = gen_xmlBufferPtr(n_buf, 0);
24999: table = gen_xmlElementTablePtr(n_table, 1);
25000:
25001: xmlDumpElementTable(buf, table);
25002: call_tests++;
25003: des_xmlBufferPtr(n_buf, buf, 0);
25004: des_xmlElementTablePtr(n_table, table, 1);
25005: xmlResetLastError();
25006: if (mem_base != xmlMemBlocks()) {
25007: printf("Leak of %d blocks found in xmlDumpElementTable",
25008: xmlMemBlocks() - mem_base);
25009: test_ret++;
25010: printf(" %d", n_buf);
25011: printf(" %d", n_table);
25012: printf("\n");
25013: }
25014: }
25015: }
25016: function_tests++;
25017: #endif
25018:
25019: return(test_ret);
25020: }
25021:
25022:
25023: #define gen_nb_xmlNotationPtr 1
25024: static xmlNotationPtr gen_xmlNotationPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
25025: return(NULL);
25026: }
25027: static void des_xmlNotationPtr(int no ATTRIBUTE_UNUSED, xmlNotationPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
25028: }
25029:
25030: static int
25031: test_xmlDumpNotationDecl(void) {
25032: int test_ret = 0;
25033:
25034: #if defined(LIBXML_OUTPUT_ENABLED)
25035: int mem_base;
25036: xmlBufferPtr buf; /* the XML buffer output */
25037: int n_buf;
25038: xmlNotationPtr nota; /* A notation declaration */
25039: int n_nota;
25040:
25041: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
25042: for (n_nota = 0;n_nota < gen_nb_xmlNotationPtr;n_nota++) {
25043: mem_base = xmlMemBlocks();
25044: buf = gen_xmlBufferPtr(n_buf, 0);
25045: nota = gen_xmlNotationPtr(n_nota, 1);
25046:
25047: xmlDumpNotationDecl(buf, nota);
25048: call_tests++;
25049: des_xmlBufferPtr(n_buf, buf, 0);
25050: des_xmlNotationPtr(n_nota, nota, 1);
25051: xmlResetLastError();
25052: if (mem_base != xmlMemBlocks()) {
25053: printf("Leak of %d blocks found in xmlDumpNotationDecl",
25054: xmlMemBlocks() - mem_base);
25055: test_ret++;
25056: printf(" %d", n_buf);
25057: printf(" %d", n_nota);
25058: printf("\n");
25059: }
25060: }
25061: }
25062: function_tests++;
25063: #endif
25064:
25065: return(test_ret);
25066: }
25067:
25068:
25069: static int
25070: test_xmlDumpNotationTable(void) {
25071: int test_ret = 0;
25072:
25073: #if defined(LIBXML_OUTPUT_ENABLED)
25074: int mem_base;
25075: xmlBufferPtr buf; /* the XML buffer output */
25076: int n_buf;
25077: xmlNotationTablePtr table; /* A notation table */
25078: int n_table;
25079:
25080: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
25081: for (n_table = 0;n_table < gen_nb_xmlNotationTablePtr;n_table++) {
25082: mem_base = xmlMemBlocks();
25083: buf = gen_xmlBufferPtr(n_buf, 0);
25084: table = gen_xmlNotationTablePtr(n_table, 1);
25085:
25086: xmlDumpNotationTable(buf, table);
25087: call_tests++;
25088: des_xmlBufferPtr(n_buf, buf, 0);
25089: des_xmlNotationTablePtr(n_table, table, 1);
25090: xmlResetLastError();
25091: if (mem_base != xmlMemBlocks()) {
25092: printf("Leak of %d blocks found in xmlDumpNotationTable",
25093: xmlMemBlocks() - mem_base);
25094: test_ret++;
25095: printf(" %d", n_buf);
25096: printf(" %d", n_table);
25097: printf("\n");
25098: }
25099: }
25100: }
25101: function_tests++;
25102: #endif
25103:
25104: return(test_ret);
25105: }
25106:
25107:
25108: static int
25109: test_xmlGetDtdAttrDesc(void) {
25110: int test_ret = 0;
25111:
25112: int mem_base;
25113: xmlAttributePtr ret_val;
25114: xmlDtdPtr dtd; /* a pointer to the DtD to search */
25115: int n_dtd;
25116: xmlChar * elem; /* the element name */
25117: int n_elem;
25118: xmlChar * name; /* the attribute name */
25119: int n_name;
25120:
25121: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
25122: for (n_elem = 0;n_elem < gen_nb_const_xmlChar_ptr;n_elem++) {
25123: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
25124: mem_base = xmlMemBlocks();
25125: dtd = gen_xmlDtdPtr(n_dtd, 0);
25126: elem = gen_const_xmlChar_ptr(n_elem, 1);
25127: name = gen_const_xmlChar_ptr(n_name, 2);
25128:
25129: ret_val = xmlGetDtdAttrDesc(dtd, (const xmlChar *)elem, (const xmlChar *)name);
25130: desret_xmlAttributePtr(ret_val);
25131: call_tests++;
25132: des_xmlDtdPtr(n_dtd, dtd, 0);
25133: des_const_xmlChar_ptr(n_elem, (const xmlChar *)elem, 1);
25134: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
25135: xmlResetLastError();
25136: if (mem_base != xmlMemBlocks()) {
25137: printf("Leak of %d blocks found in xmlGetDtdAttrDesc",
25138: xmlMemBlocks() - mem_base);
25139: test_ret++;
25140: printf(" %d", n_dtd);
25141: printf(" %d", n_elem);
25142: printf(" %d", n_name);
25143: printf("\n");
25144: }
25145: }
25146: }
25147: }
25148: function_tests++;
25149:
25150: return(test_ret);
25151: }
25152:
25153:
25154: static int
25155: test_xmlGetDtdElementDesc(void) {
25156: int test_ret = 0;
25157:
25158: int mem_base;
25159: xmlElementPtr ret_val;
25160: xmlDtdPtr dtd; /* a pointer to the DtD to search */
25161: int n_dtd;
25162: xmlChar * name; /* the element name */
25163: int n_name;
25164:
25165: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
25166: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
25167: mem_base = xmlMemBlocks();
25168: dtd = gen_xmlDtdPtr(n_dtd, 0);
25169: name = gen_const_xmlChar_ptr(n_name, 1);
25170:
25171: ret_val = xmlGetDtdElementDesc(dtd, (const xmlChar *)name);
25172: desret_xmlElementPtr(ret_val);
25173: call_tests++;
25174: des_xmlDtdPtr(n_dtd, dtd, 0);
25175: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
25176: xmlResetLastError();
25177: if (mem_base != xmlMemBlocks()) {
25178: printf("Leak of %d blocks found in xmlGetDtdElementDesc",
25179: xmlMemBlocks() - mem_base);
25180: test_ret++;
25181: printf(" %d", n_dtd);
25182: printf(" %d", n_name);
25183: printf("\n");
25184: }
25185: }
25186: }
25187: function_tests++;
25188:
25189: return(test_ret);
25190: }
25191:
25192:
25193: static int
25194: test_xmlGetDtdNotationDesc(void) {
25195: int test_ret = 0;
25196:
25197:
25198: /* missing type support */
25199: return(test_ret);
25200: }
25201:
25202:
25203: static int
25204: test_xmlGetDtdQAttrDesc(void) {
25205: int test_ret = 0;
25206:
25207: int mem_base;
25208: xmlAttributePtr ret_val;
25209: xmlDtdPtr dtd; /* a pointer to the DtD to search */
25210: int n_dtd;
25211: xmlChar * elem; /* the element name */
25212: int n_elem;
25213: xmlChar * name; /* the attribute name */
25214: int n_name;
25215: xmlChar * prefix; /* the attribute namespace prefix */
25216: int n_prefix;
25217:
25218: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
25219: for (n_elem = 0;n_elem < gen_nb_const_xmlChar_ptr;n_elem++) {
25220: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
25221: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
25222: mem_base = xmlMemBlocks();
25223: dtd = gen_xmlDtdPtr(n_dtd, 0);
25224: elem = gen_const_xmlChar_ptr(n_elem, 1);
25225: name = gen_const_xmlChar_ptr(n_name, 2);
25226: prefix = gen_const_xmlChar_ptr(n_prefix, 3);
25227:
25228: ret_val = xmlGetDtdQAttrDesc(dtd, (const xmlChar *)elem, (const xmlChar *)name, (const xmlChar *)prefix);
25229: desret_xmlAttributePtr(ret_val);
25230: call_tests++;
25231: des_xmlDtdPtr(n_dtd, dtd, 0);
25232: des_const_xmlChar_ptr(n_elem, (const xmlChar *)elem, 1);
25233: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
25234: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 3);
25235: xmlResetLastError();
25236: if (mem_base != xmlMemBlocks()) {
25237: printf("Leak of %d blocks found in xmlGetDtdQAttrDesc",
25238: xmlMemBlocks() - mem_base);
25239: test_ret++;
25240: printf(" %d", n_dtd);
25241: printf(" %d", n_elem);
25242: printf(" %d", n_name);
25243: printf(" %d", n_prefix);
25244: printf("\n");
25245: }
25246: }
25247: }
25248: }
25249: }
25250: function_tests++;
25251:
25252: return(test_ret);
25253: }
25254:
25255:
25256: static int
25257: test_xmlGetDtdQElementDesc(void) {
25258: int test_ret = 0;
25259:
25260: int mem_base;
25261: xmlElementPtr ret_val;
25262: xmlDtdPtr dtd; /* a pointer to the DtD to search */
25263: int n_dtd;
25264: xmlChar * name; /* the element name */
25265: int n_name;
25266: xmlChar * prefix; /* the element namespace prefix */
25267: int n_prefix;
25268:
25269: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
25270: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
25271: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
25272: mem_base = xmlMemBlocks();
25273: dtd = gen_xmlDtdPtr(n_dtd, 0);
25274: name = gen_const_xmlChar_ptr(n_name, 1);
25275: prefix = gen_const_xmlChar_ptr(n_prefix, 2);
25276:
25277: ret_val = xmlGetDtdQElementDesc(dtd, (const xmlChar *)name, (const xmlChar *)prefix);
25278: desret_xmlElementPtr(ret_val);
25279: call_tests++;
25280: des_xmlDtdPtr(n_dtd, dtd, 0);
25281: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
25282: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 2);
25283: xmlResetLastError();
25284: if (mem_base != xmlMemBlocks()) {
25285: printf("Leak of %d blocks found in xmlGetDtdQElementDesc",
25286: xmlMemBlocks() - mem_base);
25287: test_ret++;
25288: printf(" %d", n_dtd);
25289: printf(" %d", n_name);
25290: printf(" %d", n_prefix);
25291: printf("\n");
25292: }
25293: }
25294: }
25295: }
25296: function_tests++;
25297:
25298: return(test_ret);
25299: }
25300:
25301:
25302: static int
25303: test_xmlGetID(void) {
25304: int test_ret = 0;
25305:
25306: int mem_base;
25307: xmlAttrPtr ret_val;
25308: xmlDocPtr doc; /* pointer to the document */
25309: int n_doc;
25310: xmlChar * ID; /* the ID value */
25311: int n_ID;
25312:
25313: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
25314: for (n_ID = 0;n_ID < gen_nb_const_xmlChar_ptr;n_ID++) {
25315: mem_base = xmlMemBlocks();
25316: doc = gen_xmlDocPtr(n_doc, 0);
25317: ID = gen_const_xmlChar_ptr(n_ID, 1);
25318:
25319: ret_val = xmlGetID(doc, (const xmlChar *)ID);
25320: desret_xmlAttrPtr(ret_val);
25321: call_tests++;
25322: des_xmlDocPtr(n_doc, doc, 0);
25323: des_const_xmlChar_ptr(n_ID, (const xmlChar *)ID, 1);
25324: xmlResetLastError();
25325: if (mem_base != xmlMemBlocks()) {
25326: printf("Leak of %d blocks found in xmlGetID",
25327: xmlMemBlocks() - mem_base);
25328: test_ret++;
25329: printf(" %d", n_doc);
25330: printf(" %d", n_ID);
25331: printf("\n");
25332: }
25333: }
25334: }
25335: function_tests++;
25336:
25337: return(test_ret);
25338: }
25339:
25340:
25341: static int
25342: test_xmlGetRefs(void) {
25343: int test_ret = 0;
25344:
25345:
25346: /* missing type support */
25347: return(test_ret);
25348: }
25349:
25350:
25351: static int
25352: test_xmlIsID(void) {
25353: int test_ret = 0;
25354:
25355: int mem_base;
25356: int ret_val;
25357: xmlDocPtr doc; /* the document */
25358: int n_doc;
25359: xmlNodePtr elem; /* the element carrying the attribute */
25360: int n_elem;
25361: xmlAttrPtr attr; /* the attribute */
25362: int n_attr;
25363:
25364: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
25365: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
25366: for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
25367: mem_base = xmlMemBlocks();
25368: doc = gen_xmlDocPtr(n_doc, 0);
25369: elem = gen_xmlNodePtr(n_elem, 1);
25370: attr = gen_xmlAttrPtr(n_attr, 2);
25371:
25372: ret_val = xmlIsID(doc, elem, attr);
25373: desret_int(ret_val);
25374: call_tests++;
25375: des_xmlDocPtr(n_doc, doc, 0);
25376: des_xmlNodePtr(n_elem, elem, 1);
25377: des_xmlAttrPtr(n_attr, attr, 2);
25378: xmlResetLastError();
25379: if (mem_base != xmlMemBlocks()) {
25380: printf("Leak of %d blocks found in xmlIsID",
25381: xmlMemBlocks() - mem_base);
25382: test_ret++;
25383: printf(" %d", n_doc);
25384: printf(" %d", n_elem);
25385: printf(" %d", n_attr);
25386: printf("\n");
25387: }
25388: }
25389: }
25390: }
25391: function_tests++;
25392:
25393: return(test_ret);
25394: }
25395:
25396:
25397: static int
25398: test_xmlIsMixedElement(void) {
25399: int test_ret = 0;
25400:
25401: int mem_base;
25402: int ret_val;
25403: xmlDocPtr doc; /* the document */
25404: int n_doc;
25405: xmlChar * name; /* the element name */
25406: int n_name;
25407:
25408: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
25409: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
25410: mem_base = xmlMemBlocks();
25411: doc = gen_xmlDocPtr(n_doc, 0);
25412: name = gen_const_xmlChar_ptr(n_name, 1);
25413:
25414: ret_val = xmlIsMixedElement(doc, (const xmlChar *)name);
25415: desret_int(ret_val);
25416: call_tests++;
25417: des_xmlDocPtr(n_doc, doc, 0);
25418: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
25419: xmlResetLastError();
25420: if (mem_base != xmlMemBlocks()) {
25421: printf("Leak of %d blocks found in xmlIsMixedElement",
25422: xmlMemBlocks() - mem_base);
25423: test_ret++;
25424: printf(" %d", n_doc);
25425: printf(" %d", n_name);
25426: printf("\n");
25427: }
25428: }
25429: }
25430: function_tests++;
25431:
25432: return(test_ret);
25433: }
25434:
25435:
25436: static int
25437: test_xmlIsRef(void) {
25438: int test_ret = 0;
25439:
25440: int mem_base;
25441: int ret_val;
25442: xmlDocPtr doc; /* the document */
25443: int n_doc;
25444: xmlNodePtr elem; /* the element carrying the attribute */
25445: int n_elem;
25446: xmlAttrPtr attr; /* the attribute */
25447: int n_attr;
25448:
25449: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
25450: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
25451: for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
25452: mem_base = xmlMemBlocks();
25453: doc = gen_xmlDocPtr(n_doc, 0);
25454: elem = gen_xmlNodePtr(n_elem, 1);
25455: attr = gen_xmlAttrPtr(n_attr, 2);
25456:
25457: ret_val = xmlIsRef(doc, elem, attr);
25458: desret_int(ret_val);
25459: call_tests++;
25460: des_xmlDocPtr(n_doc, doc, 0);
25461: des_xmlNodePtr(n_elem, elem, 1);
25462: des_xmlAttrPtr(n_attr, attr, 2);
25463: xmlResetLastError();
25464: if (mem_base != xmlMemBlocks()) {
25465: printf("Leak of %d blocks found in xmlIsRef",
25466: xmlMemBlocks() - mem_base);
25467: test_ret++;
25468: printf(" %d", n_doc);
25469: printf(" %d", n_elem);
25470: printf(" %d", n_attr);
25471: printf("\n");
25472: }
25473: }
25474: }
25475: }
25476: function_tests++;
25477:
25478: return(test_ret);
25479: }
25480:
25481:
25482: static int
25483: test_xmlNewDocElementContent(void) {
25484: int test_ret = 0;
25485:
25486: int mem_base;
25487: xmlElementContentPtr ret_val;
25488: xmlDocPtr doc; /* the document */
25489: int n_doc;
25490: xmlChar * name; /* the subelement name or NULL */
25491: int n_name;
25492: xmlElementContentType type; /* the type of element content decl */
25493: int n_type;
25494:
25495: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
25496: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
25497: for (n_type = 0;n_type < gen_nb_xmlElementContentType;n_type++) {
25498: mem_base = xmlMemBlocks();
25499: doc = gen_xmlDocPtr(n_doc, 0);
25500: name = gen_const_xmlChar_ptr(n_name, 1);
25501: type = gen_xmlElementContentType(n_type, 2);
25502:
25503: ret_val = xmlNewDocElementContent(doc, (const xmlChar *)name, type);
25504: xmlFreeDocElementContent(doc, ret_val); ret_val = NULL;
25505: desret_xmlElementContentPtr(ret_val);
25506: call_tests++;
25507: des_xmlDocPtr(n_doc, doc, 0);
25508: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
25509: des_xmlElementContentType(n_type, type, 2);
25510: xmlResetLastError();
25511: if (mem_base != xmlMemBlocks()) {
25512: printf("Leak of %d blocks found in xmlNewDocElementContent",
25513: xmlMemBlocks() - mem_base);
25514: test_ret++;
25515: printf(" %d", n_doc);
25516: printf(" %d", n_name);
25517: printf(" %d", n_type);
25518: printf("\n");
25519: }
25520: }
25521: }
25522: }
25523: function_tests++;
25524:
25525: return(test_ret);
25526: }
25527:
25528:
25529: static int
25530: test_xmlNewElementContent(void) {
25531: int test_ret = 0;
25532:
25533: int mem_base;
25534: xmlElementContentPtr ret_val;
25535: xmlChar * name; /* the subelement name or NULL */
25536: int n_name;
25537: xmlElementContentType type; /* the type of element content decl */
25538: int n_type;
25539:
25540: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
25541: for (n_type = 0;n_type < gen_nb_xmlElementContentType;n_type++) {
25542: mem_base = xmlMemBlocks();
25543: name = gen_const_xmlChar_ptr(n_name, 0);
25544: type = gen_xmlElementContentType(n_type, 1);
25545:
25546: ret_val = xmlNewElementContent((const xmlChar *)name, type);
25547: desret_xmlElementContentPtr(ret_val);
25548: call_tests++;
25549: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
25550: des_xmlElementContentType(n_type, type, 1);
25551: xmlResetLastError();
25552: if (mem_base != xmlMemBlocks()) {
25553: printf("Leak of %d blocks found in xmlNewElementContent",
25554: xmlMemBlocks() - mem_base);
25555: test_ret++;
25556: printf(" %d", n_name);
25557: printf(" %d", n_type);
25558: printf("\n");
25559: }
25560: }
25561: }
25562: function_tests++;
25563:
25564: return(test_ret);
25565: }
25566:
25567:
25568: static int
25569: test_xmlNewValidCtxt(void) {
25570: int test_ret = 0;
25571:
25572:
25573: /* missing type support */
25574: return(test_ret);
25575: }
25576:
25577:
25578: static int
25579: test_xmlRemoveID(void) {
25580: int test_ret = 0;
25581:
25582: int mem_base;
25583: int ret_val;
25584: xmlDocPtr doc; /* the document */
25585: int n_doc;
25586: xmlAttrPtr attr; /* the attribute */
25587: int n_attr;
25588:
25589: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
25590: for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
25591: mem_base = xmlMemBlocks();
25592: doc = gen_xmlDocPtr(n_doc, 0);
25593: attr = gen_xmlAttrPtr(n_attr, 1);
25594:
25595: ret_val = xmlRemoveID(doc, attr);
25596: desret_int(ret_val);
25597: call_tests++;
25598: des_xmlDocPtr(n_doc, doc, 0);
25599: des_xmlAttrPtr(n_attr, attr, 1);
25600: xmlResetLastError();
25601: if (mem_base != xmlMemBlocks()) {
25602: printf("Leak of %d blocks found in xmlRemoveID",
25603: xmlMemBlocks() - mem_base);
25604: test_ret++;
25605: printf(" %d", n_doc);
25606: printf(" %d", n_attr);
25607: printf("\n");
25608: }
25609: }
25610: }
25611: function_tests++;
25612:
25613: return(test_ret);
25614: }
25615:
25616:
25617: static int
25618: test_xmlRemoveRef(void) {
25619: int test_ret = 0;
25620:
25621: int mem_base;
25622: int ret_val;
25623: xmlDocPtr doc; /* the document */
25624: int n_doc;
25625: xmlAttrPtr attr; /* the attribute */
25626: int n_attr;
25627:
25628: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
25629: for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
25630: mem_base = xmlMemBlocks();
25631: doc = gen_xmlDocPtr(n_doc, 0);
25632: attr = gen_xmlAttrPtr(n_attr, 1);
25633:
25634: ret_val = xmlRemoveRef(doc, attr);
25635: desret_int(ret_val);
25636: call_tests++;
25637: des_xmlDocPtr(n_doc, doc, 0);
25638: des_xmlAttrPtr(n_attr, attr, 1);
25639: xmlResetLastError();
25640: if (mem_base != xmlMemBlocks()) {
25641: printf("Leak of %d blocks found in xmlRemoveRef",
25642: xmlMemBlocks() - mem_base);
25643: test_ret++;
25644: printf(" %d", n_doc);
25645: printf(" %d", n_attr);
25646: printf("\n");
25647: }
25648: }
25649: }
25650: function_tests++;
25651:
25652: return(test_ret);
25653: }
25654:
25655:
25656: static int
25657: test_xmlSnprintfElementContent(void) {
25658: int test_ret = 0;
25659:
25660: int mem_base;
25661: char * buf; /* an output buffer */
25662: int n_buf;
25663: int size; /* the buffer size */
25664: int n_size;
25665: xmlElementContentPtr content; /* An element table */
25666: int n_content;
25667: int englob; /* 1 if one must print the englobing parenthesis, 0 otherwise */
25668: int n_englob;
25669:
25670: for (n_buf = 0;n_buf < gen_nb_char_ptr;n_buf++) {
25671: for (n_size = 0;n_size < gen_nb_int;n_size++) {
25672: for (n_content = 0;n_content < gen_nb_xmlElementContentPtr;n_content++) {
25673: for (n_englob = 0;n_englob < gen_nb_int;n_englob++) {
25674: mem_base = xmlMemBlocks();
25675: buf = gen_char_ptr(n_buf, 0);
25676: size = gen_int(n_size, 1);
25677: content = gen_xmlElementContentPtr(n_content, 2);
25678: englob = gen_int(n_englob, 3);
25679:
25680: xmlSnprintfElementContent(buf, size, content, englob);
25681: call_tests++;
25682: des_char_ptr(n_buf, buf, 0);
25683: des_int(n_size, size, 1);
25684: des_xmlElementContentPtr(n_content, content, 2);
25685: des_int(n_englob, englob, 3);
25686: xmlResetLastError();
25687: if (mem_base != xmlMemBlocks()) {
25688: printf("Leak of %d blocks found in xmlSnprintfElementContent",
25689: xmlMemBlocks() - mem_base);
25690: test_ret++;
25691: printf(" %d", n_buf);
25692: printf(" %d", n_size);
25693: printf(" %d", n_content);
25694: printf(" %d", n_englob);
25695: printf("\n");
25696: }
25697: }
25698: }
25699: }
25700: }
25701: function_tests++;
25702:
25703: return(test_ret);
25704: }
25705:
25706:
25707: static int
25708: test_xmlSprintfElementContent(void) {
25709: int test_ret = 0;
25710:
25711: #if defined(LIBXML_OUTPUT_ENABLED)
25712: #ifdef LIBXML_OUTPUT_ENABLED
25713: int mem_base;
25714: char * buf; /* an output buffer */
25715: int n_buf;
25716: xmlElementContentPtr content; /* An element table */
25717: int n_content;
25718: int englob; /* 1 if one must print the englobing parenthesis, 0 otherwise */
25719: int n_englob;
25720:
25721: for (n_buf = 0;n_buf < gen_nb_char_ptr;n_buf++) {
25722: for (n_content = 0;n_content < gen_nb_xmlElementContentPtr;n_content++) {
25723: for (n_englob = 0;n_englob < gen_nb_int;n_englob++) {
25724: mem_base = xmlMemBlocks();
25725: buf = gen_char_ptr(n_buf, 0);
25726: content = gen_xmlElementContentPtr(n_content, 1);
25727: englob = gen_int(n_englob, 2);
25728:
25729: xmlSprintfElementContent(buf, content, englob);
25730: call_tests++;
25731: des_char_ptr(n_buf, buf, 0);
25732: des_xmlElementContentPtr(n_content, content, 1);
25733: des_int(n_englob, englob, 2);
25734: xmlResetLastError();
25735: if (mem_base != xmlMemBlocks()) {
25736: printf("Leak of %d blocks found in xmlSprintfElementContent",
25737: xmlMemBlocks() - mem_base);
25738: test_ret++;
25739: printf(" %d", n_buf);
25740: printf(" %d", n_content);
25741: printf(" %d", n_englob);
25742: printf("\n");
25743: }
25744: }
25745: }
25746: }
25747: function_tests++;
25748: #endif
25749: #endif
25750:
25751: return(test_ret);
25752: }
25753:
25754:
25755: static int
25756: test_xmlValidBuildContentModel(void) {
25757: int test_ret = 0;
25758:
25759: #if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED)
25760: int mem_base;
25761: int ret_val;
25762: xmlValidCtxtPtr ctxt; /* a validation context */
25763: int n_ctxt;
25764: xmlElementPtr elem; /* an element declaration node */
25765: int n_elem;
25766:
25767: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
25768: for (n_elem = 0;n_elem < gen_nb_xmlElementPtr;n_elem++) {
25769: mem_base = xmlMemBlocks();
25770: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
25771: elem = gen_xmlElementPtr(n_elem, 1);
25772:
25773: ret_val = xmlValidBuildContentModel(ctxt, elem);
25774: desret_int(ret_val);
25775: call_tests++;
25776: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
25777: des_xmlElementPtr(n_elem, elem, 1);
25778: xmlResetLastError();
25779: if (mem_base != xmlMemBlocks()) {
25780: printf("Leak of %d blocks found in xmlValidBuildContentModel",
25781: xmlMemBlocks() - mem_base);
25782: test_ret++;
25783: printf(" %d", n_ctxt);
25784: printf(" %d", n_elem);
25785: printf("\n");
25786: }
25787: }
25788: }
25789: function_tests++;
25790: #endif
25791:
25792: return(test_ret);
25793: }
25794:
25795:
25796: static int
25797: test_xmlValidCtxtNormalizeAttributeValue(void) {
25798: int test_ret = 0;
25799:
25800: #if defined(LIBXML_VALID_ENABLED)
25801: int mem_base;
25802: xmlChar * ret_val;
25803: xmlValidCtxtPtr ctxt; /* the validation context or NULL */
25804: int n_ctxt;
25805: xmlDocPtr doc; /* the document */
25806: int n_doc;
25807: xmlNodePtr elem; /* the parent */
25808: int n_elem;
25809: xmlChar * name; /* the attribute name */
25810: int n_name;
25811: xmlChar * value; /* the attribute value */
25812: int n_value;
25813:
25814: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
25815: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
25816: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
25817: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
25818: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
25819: mem_base = xmlMemBlocks();
25820: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
25821: doc = gen_xmlDocPtr(n_doc, 1);
25822: elem = gen_xmlNodePtr(n_elem, 2);
25823: name = gen_const_xmlChar_ptr(n_name, 3);
25824: value = gen_const_xmlChar_ptr(n_value, 4);
25825:
25826: ret_val = xmlValidCtxtNormalizeAttributeValue(ctxt, doc, elem, (const xmlChar *)name, (const xmlChar *)value);
25827: desret_xmlChar_ptr(ret_val);
25828: call_tests++;
25829: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
25830: des_xmlDocPtr(n_doc, doc, 1);
25831: des_xmlNodePtr(n_elem, elem, 2);
25832: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 3);
25833: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 4);
25834: xmlResetLastError();
25835: if (mem_base != xmlMemBlocks()) {
25836: printf("Leak of %d blocks found in xmlValidCtxtNormalizeAttributeValue",
25837: xmlMemBlocks() - mem_base);
25838: test_ret++;
25839: printf(" %d", n_ctxt);
25840: printf(" %d", n_doc);
25841: printf(" %d", n_elem);
25842: printf(" %d", n_name);
25843: printf(" %d", n_value);
25844: printf("\n");
25845: }
25846: }
25847: }
25848: }
25849: }
25850: }
25851: function_tests++;
25852: #endif
25853:
25854: return(test_ret);
25855: }
25856:
25857:
25858: #define gen_nb_xmlElementContent_ptr 1
25859: static xmlElementContent * gen_xmlElementContent_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
25860: return(NULL);
25861: }
25862: static void des_xmlElementContent_ptr(int no ATTRIBUTE_UNUSED, xmlElementContent * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
25863: }
25864:
25865: static int
25866: test_xmlValidGetPotentialChildren(void) {
25867: int test_ret = 0;
25868:
25869: #if defined(LIBXML_VALID_ENABLED)
25870: #ifdef LIBXML_VALID_ENABLED
25871: int mem_base;
25872: int ret_val;
25873: xmlElementContent * ctree; /* an element content tree */
25874: int n_ctree;
25875: xmlChar ** names; /* an array to store the list of child names */
25876: int n_names;
25877: int * len; /* a pointer to the number of element in the list */
25878: int n_len;
25879: int max; /* the size of the array */
25880: int n_max;
25881:
25882: for (n_ctree = 0;n_ctree < gen_nb_xmlElementContent_ptr;n_ctree++) {
25883: for (n_names = 0;n_names < gen_nb_const_xmlChar_ptr_ptr;n_names++) {
25884: for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
25885: for (n_max = 0;n_max < gen_nb_int;n_max++) {
25886: mem_base = xmlMemBlocks();
25887: ctree = gen_xmlElementContent_ptr(n_ctree, 0);
25888: names = gen_const_xmlChar_ptr_ptr(n_names, 1);
25889: len = gen_int_ptr(n_len, 2);
25890: max = gen_int(n_max, 3);
25891:
25892: ret_val = xmlValidGetPotentialChildren(ctree, (const xmlChar **)names, len, max);
25893: desret_int(ret_val);
25894: call_tests++;
25895: des_xmlElementContent_ptr(n_ctree, ctree, 0);
25896: des_const_xmlChar_ptr_ptr(n_names, (const xmlChar **)names, 1);
25897: des_int_ptr(n_len, len, 2);
25898: des_int(n_max, max, 3);
25899: xmlResetLastError();
25900: if (mem_base != xmlMemBlocks()) {
25901: printf("Leak of %d blocks found in xmlValidGetPotentialChildren",
25902: xmlMemBlocks() - mem_base);
25903: test_ret++;
25904: printf(" %d", n_ctree);
25905: printf(" %d", n_names);
25906: printf(" %d", n_len);
25907: printf(" %d", n_max);
25908: printf("\n");
25909: }
25910: }
25911: }
25912: }
25913: }
25914: function_tests++;
25915: #endif
25916: #endif
25917:
25918: return(test_ret);
25919: }
25920:
25921:
25922: static int
25923: test_xmlValidGetValidElements(void) {
25924: int test_ret = 0;
25925:
25926: #if defined(LIBXML_VALID_ENABLED)
25927: #ifdef LIBXML_VALID_ENABLED
25928: int mem_base;
25929: int ret_val;
25930: xmlNode * prev; /* an element to insert after */
25931: int n_prev;
25932: xmlNode * next; /* an element to insert next */
25933: int n_next;
25934: xmlChar ** names; /* an array to store the list of child names */
25935: int n_names;
25936: int max; /* the size of the array */
25937: int n_max;
25938:
25939: for (n_prev = 0;n_prev < gen_nb_xmlNodePtr;n_prev++) {
25940: for (n_next = 0;n_next < gen_nb_xmlNodePtr;n_next++) {
25941: for (n_names = 0;n_names < gen_nb_const_xmlChar_ptr_ptr;n_names++) {
25942: for (n_max = 0;n_max < gen_nb_int;n_max++) {
25943: mem_base = xmlMemBlocks();
25944: prev = gen_xmlNodePtr(n_prev, 0);
25945: next = gen_xmlNodePtr(n_next, 1);
25946: names = gen_const_xmlChar_ptr_ptr(n_names, 2);
25947: max = gen_int(n_max, 3);
25948:
25949: ret_val = xmlValidGetValidElements(prev, next, (const xmlChar **)names, max);
25950: desret_int(ret_val);
25951: call_tests++;
25952: des_xmlNodePtr(n_prev, prev, 0);
25953: des_xmlNodePtr(n_next, next, 1);
25954: des_const_xmlChar_ptr_ptr(n_names, (const xmlChar **)names, 2);
25955: des_int(n_max, max, 3);
25956: xmlResetLastError();
25957: if (mem_base != xmlMemBlocks()) {
25958: printf("Leak of %d blocks found in xmlValidGetValidElements",
25959: xmlMemBlocks() - mem_base);
25960: test_ret++;
25961: printf(" %d", n_prev);
25962: printf(" %d", n_next);
25963: printf(" %d", n_names);
25964: printf(" %d", n_max);
25965: printf("\n");
25966: }
25967: }
25968: }
25969: }
25970: }
25971: function_tests++;
25972: #endif
25973: #endif
25974:
25975: return(test_ret);
25976: }
25977:
25978:
25979: static int
25980: test_xmlValidNormalizeAttributeValue(void) {
25981: int test_ret = 0;
25982:
25983: #if defined(LIBXML_VALID_ENABLED)
25984: int mem_base;
25985: xmlChar * ret_val;
25986: xmlDocPtr doc; /* the document */
25987: int n_doc;
25988: xmlNodePtr elem; /* the parent */
25989: int n_elem;
25990: xmlChar * name; /* the attribute name */
25991: int n_name;
25992: xmlChar * value; /* the attribute value */
25993: int n_value;
25994:
25995: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
25996: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
25997: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
25998: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
25999: mem_base = xmlMemBlocks();
26000: doc = gen_xmlDocPtr(n_doc, 0);
26001: elem = gen_xmlNodePtr(n_elem, 1);
26002: name = gen_const_xmlChar_ptr(n_name, 2);
26003: value = gen_const_xmlChar_ptr(n_value, 3);
26004:
26005: ret_val = xmlValidNormalizeAttributeValue(doc, elem, (const xmlChar *)name, (const xmlChar *)value);
26006: desret_xmlChar_ptr(ret_val);
26007: call_tests++;
26008: des_xmlDocPtr(n_doc, doc, 0);
26009: des_xmlNodePtr(n_elem, elem, 1);
26010: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
26011: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 3);
26012: xmlResetLastError();
26013: if (mem_base != xmlMemBlocks()) {
26014: printf("Leak of %d blocks found in xmlValidNormalizeAttributeValue",
26015: xmlMemBlocks() - mem_base);
26016: test_ret++;
26017: printf(" %d", n_doc);
26018: printf(" %d", n_elem);
26019: printf(" %d", n_name);
26020: printf(" %d", n_value);
26021: printf("\n");
26022: }
26023: }
26024: }
26025: }
26026: }
26027: function_tests++;
26028: #endif
26029:
26030: return(test_ret);
26031: }
26032:
26033:
26034: static int
26035: test_xmlValidateAttributeDecl(void) {
26036: int test_ret = 0;
26037:
26038: #if defined(LIBXML_VALID_ENABLED)
26039: int mem_base;
26040: int ret_val;
26041: xmlValidCtxtPtr ctxt; /* the validation context */
26042: int n_ctxt;
26043: xmlDocPtr doc; /* a document instance */
26044: int n_doc;
26045: xmlAttributePtr attr; /* an attribute definition */
26046: int n_attr;
26047:
26048: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26049: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26050: for (n_attr = 0;n_attr < gen_nb_xmlAttributePtr;n_attr++) {
26051: mem_base = xmlMemBlocks();
26052: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26053: doc = gen_xmlDocPtr(n_doc, 1);
26054: attr = gen_xmlAttributePtr(n_attr, 2);
26055:
26056: ret_val = xmlValidateAttributeDecl(ctxt, doc, attr);
26057: desret_int(ret_val);
26058: call_tests++;
26059: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26060: des_xmlDocPtr(n_doc, doc, 1);
26061: des_xmlAttributePtr(n_attr, attr, 2);
26062: xmlResetLastError();
26063: if (mem_base != xmlMemBlocks()) {
26064: printf("Leak of %d blocks found in xmlValidateAttributeDecl",
26065: xmlMemBlocks() - mem_base);
26066: test_ret++;
26067: printf(" %d", n_ctxt);
26068: printf(" %d", n_doc);
26069: printf(" %d", n_attr);
26070: printf("\n");
26071: }
26072: }
26073: }
26074: }
26075: function_tests++;
26076: #endif
26077:
26078: return(test_ret);
26079: }
26080:
26081:
26082: static int
26083: test_xmlValidateAttributeValue(void) {
26084: int test_ret = 0;
26085:
26086: #if defined(LIBXML_VALID_ENABLED)
26087: int mem_base;
26088: int ret_val;
26089: xmlAttributeType type; /* an attribute type */
26090: int n_type;
26091: xmlChar * value; /* an attribute value */
26092: int n_value;
26093:
26094: for (n_type = 0;n_type < gen_nb_xmlAttributeType;n_type++) {
26095: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
26096: mem_base = xmlMemBlocks();
26097: type = gen_xmlAttributeType(n_type, 0);
26098: value = gen_const_xmlChar_ptr(n_value, 1);
26099:
26100: ret_val = xmlValidateAttributeValue(type, (const xmlChar *)value);
26101: desret_int(ret_val);
26102: call_tests++;
26103: des_xmlAttributeType(n_type, type, 0);
26104: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
26105: xmlResetLastError();
26106: if (mem_base != xmlMemBlocks()) {
26107: printf("Leak of %d blocks found in xmlValidateAttributeValue",
26108: xmlMemBlocks() - mem_base);
26109: test_ret++;
26110: printf(" %d", n_type);
26111: printf(" %d", n_value);
26112: printf("\n");
26113: }
26114: }
26115: }
26116: function_tests++;
26117: #endif
26118:
26119: return(test_ret);
26120: }
26121:
26122:
26123: static int
26124: test_xmlValidateDocument(void) {
26125: int test_ret = 0;
26126:
26127: #if defined(LIBXML_VALID_ENABLED)
26128: int mem_base;
26129: int ret_val;
26130: xmlValidCtxtPtr ctxt; /* the validation context */
26131: int n_ctxt;
26132: xmlDocPtr doc; /* a document instance */
26133: int n_doc;
26134:
26135: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26136: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26137: mem_base = xmlMemBlocks();
26138: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26139: doc = gen_xmlDocPtr(n_doc, 1);
26140:
26141: ret_val = xmlValidateDocument(ctxt, doc);
26142: desret_int(ret_val);
26143: call_tests++;
26144: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26145: des_xmlDocPtr(n_doc, doc, 1);
26146: xmlResetLastError();
26147: if (mem_base != xmlMemBlocks()) {
26148: printf("Leak of %d blocks found in xmlValidateDocument",
26149: xmlMemBlocks() - mem_base);
26150: test_ret++;
26151: printf(" %d", n_ctxt);
26152: printf(" %d", n_doc);
26153: printf("\n");
26154: }
26155: }
26156: }
26157: function_tests++;
26158: #endif
26159:
26160: return(test_ret);
26161: }
26162:
26163:
26164: static int
26165: test_xmlValidateDocumentFinal(void) {
26166: int test_ret = 0;
26167:
26168: #if defined(LIBXML_VALID_ENABLED)
26169: int mem_base;
26170: int ret_val;
26171: xmlValidCtxtPtr ctxt; /* the validation context */
26172: int n_ctxt;
26173: xmlDocPtr doc; /* a document instance */
26174: int n_doc;
26175:
26176: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26177: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26178: mem_base = xmlMemBlocks();
26179: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26180: doc = gen_xmlDocPtr(n_doc, 1);
26181:
26182: ret_val = xmlValidateDocumentFinal(ctxt, doc);
26183: desret_int(ret_val);
26184: call_tests++;
26185: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26186: des_xmlDocPtr(n_doc, doc, 1);
26187: xmlResetLastError();
26188: if (mem_base != xmlMemBlocks()) {
26189: printf("Leak of %d blocks found in xmlValidateDocumentFinal",
26190: xmlMemBlocks() - mem_base);
26191: test_ret++;
26192: printf(" %d", n_ctxt);
26193: printf(" %d", n_doc);
26194: printf("\n");
26195: }
26196: }
26197: }
26198: function_tests++;
26199: #endif
26200:
26201: return(test_ret);
26202: }
26203:
26204:
26205: static int
26206: test_xmlValidateDtd(void) {
26207: int test_ret = 0;
26208:
26209: #if defined(LIBXML_VALID_ENABLED)
26210: int mem_base;
26211: int ret_val;
26212: xmlValidCtxtPtr ctxt; /* the validation context */
26213: int n_ctxt;
26214: xmlDocPtr doc; /* a document instance */
26215: int n_doc;
26216: xmlDtdPtr dtd; /* a dtd instance */
26217: int n_dtd;
26218:
26219: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26220: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26221: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
26222: mem_base = xmlMemBlocks();
26223: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26224: doc = gen_xmlDocPtr(n_doc, 1);
26225: dtd = gen_xmlDtdPtr(n_dtd, 2);
26226:
26227: ret_val = xmlValidateDtd(ctxt, doc, dtd);
26228: desret_int(ret_val);
26229: call_tests++;
26230: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26231: des_xmlDocPtr(n_doc, doc, 1);
26232: des_xmlDtdPtr(n_dtd, dtd, 2);
26233: xmlResetLastError();
26234: if (mem_base != xmlMemBlocks()) {
26235: printf("Leak of %d blocks found in xmlValidateDtd",
26236: xmlMemBlocks() - mem_base);
26237: test_ret++;
26238: printf(" %d", n_ctxt);
26239: printf(" %d", n_doc);
26240: printf(" %d", n_dtd);
26241: printf("\n");
26242: }
26243: }
26244: }
26245: }
26246: function_tests++;
26247: #endif
26248:
26249: return(test_ret);
26250: }
26251:
26252:
26253: static int
26254: test_xmlValidateDtdFinal(void) {
26255: int test_ret = 0;
26256:
26257: #if defined(LIBXML_VALID_ENABLED)
26258: int mem_base;
26259: int ret_val;
26260: xmlValidCtxtPtr ctxt; /* the validation context */
26261: int n_ctxt;
26262: xmlDocPtr doc; /* a document instance */
26263: int n_doc;
26264:
26265: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26266: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26267: mem_base = xmlMemBlocks();
26268: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26269: doc = gen_xmlDocPtr(n_doc, 1);
26270:
26271: ret_val = xmlValidateDtdFinal(ctxt, doc);
26272: desret_int(ret_val);
26273: call_tests++;
26274: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26275: des_xmlDocPtr(n_doc, doc, 1);
26276: xmlResetLastError();
26277: if (mem_base != xmlMemBlocks()) {
26278: printf("Leak of %d blocks found in xmlValidateDtdFinal",
26279: xmlMemBlocks() - mem_base);
26280: test_ret++;
26281: printf(" %d", n_ctxt);
26282: printf(" %d", n_doc);
26283: printf("\n");
26284: }
26285: }
26286: }
26287: function_tests++;
26288: #endif
26289:
26290: return(test_ret);
26291: }
26292:
26293:
26294: static int
26295: test_xmlValidateElement(void) {
26296: int test_ret = 0;
26297:
26298: #if defined(LIBXML_VALID_ENABLED)
26299: int mem_base;
26300: int ret_val;
26301: xmlValidCtxtPtr ctxt; /* the validation context */
26302: int n_ctxt;
26303: xmlDocPtr doc; /* a document instance */
26304: int n_doc;
26305: xmlNodePtr elem; /* an element instance */
26306: int n_elem;
26307:
26308: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26309: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26310: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
26311: mem_base = xmlMemBlocks();
26312: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26313: doc = gen_xmlDocPtr(n_doc, 1);
26314: elem = gen_xmlNodePtr(n_elem, 2);
26315:
26316: ret_val = xmlValidateElement(ctxt, doc, elem);
26317: desret_int(ret_val);
26318: call_tests++;
26319: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26320: des_xmlDocPtr(n_doc, doc, 1);
26321: des_xmlNodePtr(n_elem, elem, 2);
26322: xmlResetLastError();
26323: if (mem_base != xmlMemBlocks()) {
26324: printf("Leak of %d blocks found in xmlValidateElement",
26325: xmlMemBlocks() - mem_base);
26326: test_ret++;
26327: printf(" %d", n_ctxt);
26328: printf(" %d", n_doc);
26329: printf(" %d", n_elem);
26330: printf("\n");
26331: }
26332: }
26333: }
26334: }
26335: function_tests++;
26336: #endif
26337:
26338: return(test_ret);
26339: }
26340:
26341:
26342: static int
26343: test_xmlValidateElementDecl(void) {
26344: int test_ret = 0;
26345:
26346: #if defined(LIBXML_VALID_ENABLED)
26347: int mem_base;
26348: int ret_val;
26349: xmlValidCtxtPtr ctxt; /* the validation context */
26350: int n_ctxt;
26351: xmlDocPtr doc; /* a document instance */
26352: int n_doc;
26353: xmlElementPtr elem; /* an element definition */
26354: int n_elem;
26355:
26356: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26357: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26358: for (n_elem = 0;n_elem < gen_nb_xmlElementPtr;n_elem++) {
26359: mem_base = xmlMemBlocks();
26360: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26361: doc = gen_xmlDocPtr(n_doc, 1);
26362: elem = gen_xmlElementPtr(n_elem, 2);
26363:
26364: ret_val = xmlValidateElementDecl(ctxt, doc, elem);
26365: desret_int(ret_val);
26366: call_tests++;
26367: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26368: des_xmlDocPtr(n_doc, doc, 1);
26369: des_xmlElementPtr(n_elem, elem, 2);
26370: xmlResetLastError();
26371: if (mem_base != xmlMemBlocks()) {
26372: printf("Leak of %d blocks found in xmlValidateElementDecl",
26373: xmlMemBlocks() - mem_base);
26374: test_ret++;
26375: printf(" %d", n_ctxt);
26376: printf(" %d", n_doc);
26377: printf(" %d", n_elem);
26378: printf("\n");
26379: }
26380: }
26381: }
26382: }
26383: function_tests++;
26384: #endif
26385:
26386: return(test_ret);
26387: }
26388:
26389:
26390: static int
26391: test_xmlValidateNameValue(void) {
26392: int test_ret = 0;
26393:
26394: #if defined(LIBXML_VALID_ENABLED)
26395: int mem_base;
26396: int ret_val;
26397: xmlChar * value; /* an Name value */
26398: int n_value;
26399:
26400: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
26401: mem_base = xmlMemBlocks();
26402: value = gen_const_xmlChar_ptr(n_value, 0);
26403:
26404: ret_val = xmlValidateNameValue((const xmlChar *)value);
26405: desret_int(ret_val);
26406: call_tests++;
26407: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
26408: xmlResetLastError();
26409: if (mem_base != xmlMemBlocks()) {
26410: printf("Leak of %d blocks found in xmlValidateNameValue",
26411: xmlMemBlocks() - mem_base);
26412: test_ret++;
26413: printf(" %d", n_value);
26414: printf("\n");
26415: }
26416: }
26417: function_tests++;
26418: #endif
26419:
26420: return(test_ret);
26421: }
26422:
26423:
26424: static int
26425: test_xmlValidateNamesValue(void) {
26426: int test_ret = 0;
26427:
26428: #if defined(LIBXML_VALID_ENABLED)
26429: int mem_base;
26430: int ret_val;
26431: xmlChar * value; /* an Names value */
26432: int n_value;
26433:
26434: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
26435: mem_base = xmlMemBlocks();
26436: value = gen_const_xmlChar_ptr(n_value, 0);
26437:
26438: ret_val = xmlValidateNamesValue((const xmlChar *)value);
26439: desret_int(ret_val);
26440: call_tests++;
26441: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
26442: xmlResetLastError();
26443: if (mem_base != xmlMemBlocks()) {
26444: printf("Leak of %d blocks found in xmlValidateNamesValue",
26445: xmlMemBlocks() - mem_base);
26446: test_ret++;
26447: printf(" %d", n_value);
26448: printf("\n");
26449: }
26450: }
26451: function_tests++;
26452: #endif
26453:
26454: return(test_ret);
26455: }
26456:
26457:
26458: static int
26459: test_xmlValidateNmtokenValue(void) {
26460: int test_ret = 0;
26461:
26462: #if defined(LIBXML_VALID_ENABLED)
26463: int mem_base;
26464: int ret_val;
26465: xmlChar * value; /* an Nmtoken value */
26466: int n_value;
26467:
26468: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
26469: mem_base = xmlMemBlocks();
26470: value = gen_const_xmlChar_ptr(n_value, 0);
26471:
26472: ret_val = xmlValidateNmtokenValue((const xmlChar *)value);
26473: desret_int(ret_val);
26474: call_tests++;
26475: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
26476: xmlResetLastError();
26477: if (mem_base != xmlMemBlocks()) {
26478: printf("Leak of %d blocks found in xmlValidateNmtokenValue",
26479: xmlMemBlocks() - mem_base);
26480: test_ret++;
26481: printf(" %d", n_value);
26482: printf("\n");
26483: }
26484: }
26485: function_tests++;
26486: #endif
26487:
26488: return(test_ret);
26489: }
26490:
26491:
26492: static int
26493: test_xmlValidateNmtokensValue(void) {
26494: int test_ret = 0;
26495:
26496: #if defined(LIBXML_VALID_ENABLED)
26497: int mem_base;
26498: int ret_val;
26499: xmlChar * value; /* an Nmtokens value */
26500: int n_value;
26501:
26502: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
26503: mem_base = xmlMemBlocks();
26504: value = gen_const_xmlChar_ptr(n_value, 0);
26505:
26506: ret_val = xmlValidateNmtokensValue((const xmlChar *)value);
26507: desret_int(ret_val);
26508: call_tests++;
26509: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
26510: xmlResetLastError();
26511: if (mem_base != xmlMemBlocks()) {
26512: printf("Leak of %d blocks found in xmlValidateNmtokensValue",
26513: xmlMemBlocks() - mem_base);
26514: test_ret++;
26515: printf(" %d", n_value);
26516: printf("\n");
26517: }
26518: }
26519: function_tests++;
26520: #endif
26521:
26522: return(test_ret);
26523: }
26524:
26525:
26526: static int
26527: test_xmlValidateNotationDecl(void) {
26528: int test_ret = 0;
26529:
26530: #if defined(LIBXML_VALID_ENABLED)
26531: int mem_base;
26532: int ret_val;
26533: xmlValidCtxtPtr ctxt; /* the validation context */
26534: int n_ctxt;
26535: xmlDocPtr doc; /* a document instance */
26536: int n_doc;
26537: xmlNotationPtr nota; /* a notation definition */
26538: int n_nota;
26539:
26540: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26541: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26542: for (n_nota = 0;n_nota < gen_nb_xmlNotationPtr;n_nota++) {
26543: mem_base = xmlMemBlocks();
26544: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26545: doc = gen_xmlDocPtr(n_doc, 1);
26546: nota = gen_xmlNotationPtr(n_nota, 2);
26547:
26548: ret_val = xmlValidateNotationDecl(ctxt, doc, nota);
26549: desret_int(ret_val);
26550: call_tests++;
26551: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26552: des_xmlDocPtr(n_doc, doc, 1);
26553: des_xmlNotationPtr(n_nota, nota, 2);
26554: xmlResetLastError();
26555: if (mem_base != xmlMemBlocks()) {
26556: printf("Leak of %d blocks found in xmlValidateNotationDecl",
26557: xmlMemBlocks() - mem_base);
26558: test_ret++;
26559: printf(" %d", n_ctxt);
26560: printf(" %d", n_doc);
26561: printf(" %d", n_nota);
26562: printf("\n");
26563: }
26564: }
26565: }
26566: }
26567: function_tests++;
26568: #endif
26569:
26570: return(test_ret);
26571: }
26572:
26573:
26574: static int
26575: test_xmlValidateNotationUse(void) {
26576: int test_ret = 0;
26577:
26578: #if defined(LIBXML_VALID_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
26579: int mem_base;
26580: int ret_val;
26581: xmlValidCtxtPtr ctxt; /* the validation context */
26582: int n_ctxt;
26583: xmlDocPtr doc; /* the document */
26584: int n_doc;
26585: xmlChar * notationName; /* the notation name to check */
26586: int n_notationName;
26587:
26588: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26589: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26590: for (n_notationName = 0;n_notationName < gen_nb_const_xmlChar_ptr;n_notationName++) {
26591: mem_base = xmlMemBlocks();
26592: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26593: doc = gen_xmlDocPtr(n_doc, 1);
26594: notationName = gen_const_xmlChar_ptr(n_notationName, 2);
26595:
26596: ret_val = xmlValidateNotationUse(ctxt, doc, (const xmlChar *)notationName);
26597: desret_int(ret_val);
26598: call_tests++;
26599: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26600: des_xmlDocPtr(n_doc, doc, 1);
26601: des_const_xmlChar_ptr(n_notationName, (const xmlChar *)notationName, 2);
26602: xmlResetLastError();
26603: if (mem_base != xmlMemBlocks()) {
26604: printf("Leak of %d blocks found in xmlValidateNotationUse",
26605: xmlMemBlocks() - mem_base);
26606: test_ret++;
26607: printf(" %d", n_ctxt);
26608: printf(" %d", n_doc);
26609: printf(" %d", n_notationName);
26610: printf("\n");
26611: }
26612: }
26613: }
26614: }
26615: function_tests++;
26616: #endif
26617:
26618: return(test_ret);
26619: }
26620:
26621:
26622: static int
26623: test_xmlValidateOneAttribute(void) {
26624: int test_ret = 0;
26625:
26626: #if defined(LIBXML_VALID_ENABLED)
26627: int mem_base;
26628: int ret_val;
26629: xmlValidCtxtPtr ctxt; /* the validation context */
26630: int n_ctxt;
26631: xmlDocPtr doc; /* a document instance */
26632: int n_doc;
26633: xmlNodePtr elem; /* an element instance */
26634: int n_elem;
26635: xmlAttrPtr attr; /* an attribute instance */
26636: int n_attr;
26637: xmlChar * value; /* the attribute value (without entities processing) */
26638: int n_value;
26639:
26640: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26641: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26642: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
26643: for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
26644: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
26645: mem_base = xmlMemBlocks();
26646: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26647: doc = gen_xmlDocPtr(n_doc, 1);
26648: elem = gen_xmlNodePtr(n_elem, 2);
26649: attr = gen_xmlAttrPtr(n_attr, 3);
26650: value = gen_const_xmlChar_ptr(n_value, 4);
26651:
26652: ret_val = xmlValidateOneAttribute(ctxt, doc, elem, attr, (const xmlChar *)value);
26653: desret_int(ret_val);
26654: call_tests++;
26655: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26656: des_xmlDocPtr(n_doc, doc, 1);
26657: des_xmlNodePtr(n_elem, elem, 2);
26658: des_xmlAttrPtr(n_attr, attr, 3);
26659: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 4);
26660: xmlResetLastError();
26661: if (mem_base != xmlMemBlocks()) {
26662: printf("Leak of %d blocks found in xmlValidateOneAttribute",
26663: xmlMemBlocks() - mem_base);
26664: test_ret++;
26665: printf(" %d", n_ctxt);
26666: printf(" %d", n_doc);
26667: printf(" %d", n_elem);
26668: printf(" %d", n_attr);
26669: printf(" %d", n_value);
26670: printf("\n");
26671: }
26672: }
26673: }
26674: }
26675: }
26676: }
26677: function_tests++;
26678: #endif
26679:
26680: return(test_ret);
26681: }
26682:
26683:
26684: static int
26685: test_xmlValidateOneElement(void) {
26686: int test_ret = 0;
26687:
26688: #if defined(LIBXML_VALID_ENABLED)
26689: int mem_base;
26690: int ret_val;
26691: xmlValidCtxtPtr ctxt; /* the validation context */
26692: int n_ctxt;
26693: xmlDocPtr doc; /* a document instance */
26694: int n_doc;
26695: xmlNodePtr elem; /* an element instance */
26696: int n_elem;
26697:
26698: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26699: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26700: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
26701: mem_base = xmlMemBlocks();
26702: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26703: doc = gen_xmlDocPtr(n_doc, 1);
26704: elem = gen_xmlNodePtr(n_elem, 2);
26705:
26706: ret_val = xmlValidateOneElement(ctxt, doc, elem);
26707: desret_int(ret_val);
26708: call_tests++;
26709: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26710: des_xmlDocPtr(n_doc, doc, 1);
26711: des_xmlNodePtr(n_elem, elem, 2);
26712: xmlResetLastError();
26713: if (mem_base != xmlMemBlocks()) {
26714: printf("Leak of %d blocks found in xmlValidateOneElement",
26715: xmlMemBlocks() - mem_base);
26716: test_ret++;
26717: printf(" %d", n_ctxt);
26718: printf(" %d", n_doc);
26719: printf(" %d", n_elem);
26720: printf("\n");
26721: }
26722: }
26723: }
26724: }
26725: function_tests++;
26726: #endif
26727:
26728: return(test_ret);
26729: }
26730:
26731:
26732: static int
26733: test_xmlValidateOneNamespace(void) {
26734: int test_ret = 0;
26735:
26736: #if defined(LIBXML_VALID_ENABLED)
26737: int mem_base;
26738: int ret_val;
26739: xmlValidCtxtPtr ctxt; /* the validation context */
26740: int n_ctxt;
26741: xmlDocPtr doc; /* a document instance */
26742: int n_doc;
26743: xmlNodePtr elem; /* an element instance */
26744: int n_elem;
26745: xmlChar * prefix; /* the namespace prefix */
26746: int n_prefix;
26747: xmlNsPtr ns; /* an namespace declaration instance */
26748: int n_ns;
26749: xmlChar * value; /* the attribute value (without entities processing) */
26750: int n_value;
26751:
26752: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26753: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26754: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
26755: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
26756: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
26757: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
26758: mem_base = xmlMemBlocks();
26759: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26760: doc = gen_xmlDocPtr(n_doc, 1);
26761: elem = gen_xmlNodePtr(n_elem, 2);
26762: prefix = gen_const_xmlChar_ptr(n_prefix, 3);
26763: ns = gen_xmlNsPtr(n_ns, 4);
26764: value = gen_const_xmlChar_ptr(n_value, 5);
26765:
26766: ret_val = xmlValidateOneNamespace(ctxt, doc, elem, (const xmlChar *)prefix, ns, (const xmlChar *)value);
26767: desret_int(ret_val);
26768: call_tests++;
26769: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26770: des_xmlDocPtr(n_doc, doc, 1);
26771: des_xmlNodePtr(n_elem, elem, 2);
26772: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 3);
26773: des_xmlNsPtr(n_ns, ns, 4);
26774: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 5);
26775: xmlResetLastError();
26776: if (mem_base != xmlMemBlocks()) {
26777: printf("Leak of %d blocks found in xmlValidateOneNamespace",
26778: xmlMemBlocks() - mem_base);
26779: test_ret++;
26780: printf(" %d", n_ctxt);
26781: printf(" %d", n_doc);
26782: printf(" %d", n_elem);
26783: printf(" %d", n_prefix);
26784: printf(" %d", n_ns);
26785: printf(" %d", n_value);
26786: printf("\n");
26787: }
26788: }
26789: }
26790: }
26791: }
26792: }
26793: }
26794: function_tests++;
26795: #endif
26796:
26797: return(test_ret);
26798: }
26799:
26800:
26801: static int
26802: test_xmlValidatePopElement(void) {
26803: int test_ret = 0;
26804:
26805: #if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED)
26806: int mem_base;
26807: int ret_val;
26808: xmlValidCtxtPtr ctxt; /* the validation context */
26809: int n_ctxt;
26810: xmlDocPtr doc; /* a document instance */
26811: int n_doc;
26812: xmlNodePtr elem; /* an element instance */
26813: int n_elem;
26814: xmlChar * qname; /* the qualified name as appearing in the serialization */
26815: int n_qname;
26816:
26817: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26818: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26819: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
26820: for (n_qname = 0;n_qname < gen_nb_const_xmlChar_ptr;n_qname++) {
26821: mem_base = xmlMemBlocks();
26822: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26823: doc = gen_xmlDocPtr(n_doc, 1);
26824: elem = gen_xmlNodePtr(n_elem, 2);
26825: qname = gen_const_xmlChar_ptr(n_qname, 3);
26826:
26827: ret_val = xmlValidatePopElement(ctxt, doc, elem, (const xmlChar *)qname);
26828: desret_int(ret_val);
26829: call_tests++;
26830: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26831: des_xmlDocPtr(n_doc, doc, 1);
26832: des_xmlNodePtr(n_elem, elem, 2);
26833: des_const_xmlChar_ptr(n_qname, (const xmlChar *)qname, 3);
26834: xmlResetLastError();
26835: if (mem_base != xmlMemBlocks()) {
26836: printf("Leak of %d blocks found in xmlValidatePopElement",
26837: xmlMemBlocks() - mem_base);
26838: test_ret++;
26839: printf(" %d", n_ctxt);
26840: printf(" %d", n_doc);
26841: printf(" %d", n_elem);
26842: printf(" %d", n_qname);
26843: printf("\n");
26844: }
26845: }
26846: }
26847: }
26848: }
26849: function_tests++;
26850: #endif
26851:
26852: return(test_ret);
26853: }
26854:
26855:
26856: static int
26857: test_xmlValidatePushCData(void) {
26858: int test_ret = 0;
26859:
26860: #if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED)
26861: int mem_base;
26862: int ret_val;
26863: xmlValidCtxtPtr ctxt; /* the validation context */
26864: int n_ctxt;
26865: xmlChar * data; /* some character data read */
26866: int n_data;
26867: int len; /* the lenght of the data */
26868: int n_len;
26869:
26870: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26871: for (n_data = 0;n_data < gen_nb_const_xmlChar_ptr;n_data++) {
26872: for (n_len = 0;n_len < gen_nb_int;n_len++) {
26873: mem_base = xmlMemBlocks();
26874: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26875: data = gen_const_xmlChar_ptr(n_data, 1);
26876: len = gen_int(n_len, 2);
26877:
26878: ret_val = xmlValidatePushCData(ctxt, (const xmlChar *)data, len);
26879: desret_int(ret_val);
26880: call_tests++;
26881: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26882: des_const_xmlChar_ptr(n_data, (const xmlChar *)data, 1);
26883: des_int(n_len, len, 2);
26884: xmlResetLastError();
26885: if (mem_base != xmlMemBlocks()) {
26886: printf("Leak of %d blocks found in xmlValidatePushCData",
26887: xmlMemBlocks() - mem_base);
26888: test_ret++;
26889: printf(" %d", n_ctxt);
26890: printf(" %d", n_data);
26891: printf(" %d", n_len);
26892: printf("\n");
26893: }
26894: }
26895: }
26896: }
26897: function_tests++;
26898: #endif
26899:
26900: return(test_ret);
26901: }
26902:
26903:
26904: static int
26905: test_xmlValidatePushElement(void) {
26906: int test_ret = 0;
26907:
26908: #if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED)
26909: int mem_base;
26910: int ret_val;
26911: xmlValidCtxtPtr ctxt; /* the validation context */
26912: int n_ctxt;
26913: xmlDocPtr doc; /* a document instance */
26914: int n_doc;
26915: xmlNodePtr elem; /* an element instance */
26916: int n_elem;
26917: xmlChar * qname; /* the qualified name as appearing in the serialization */
26918: int n_qname;
26919:
26920: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26921: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26922: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
26923: for (n_qname = 0;n_qname < gen_nb_const_xmlChar_ptr;n_qname++) {
26924: mem_base = xmlMemBlocks();
26925: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26926: doc = gen_xmlDocPtr(n_doc, 1);
26927: elem = gen_xmlNodePtr(n_elem, 2);
26928: qname = gen_const_xmlChar_ptr(n_qname, 3);
26929:
26930: ret_val = xmlValidatePushElement(ctxt, doc, elem, (const xmlChar *)qname);
26931: desret_int(ret_val);
26932: call_tests++;
26933: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26934: des_xmlDocPtr(n_doc, doc, 1);
26935: des_xmlNodePtr(n_elem, elem, 2);
26936: des_const_xmlChar_ptr(n_qname, (const xmlChar *)qname, 3);
26937: xmlResetLastError();
26938: if (mem_base != xmlMemBlocks()) {
26939: printf("Leak of %d blocks found in xmlValidatePushElement",
26940: xmlMemBlocks() - mem_base);
26941: test_ret++;
26942: printf(" %d", n_ctxt);
26943: printf(" %d", n_doc);
26944: printf(" %d", n_elem);
26945: printf(" %d", n_qname);
26946: printf("\n");
26947: }
26948: }
26949: }
26950: }
26951: }
26952: function_tests++;
26953: #endif
26954:
26955: return(test_ret);
26956: }
26957:
26958:
26959: static int
26960: test_xmlValidateRoot(void) {
26961: int test_ret = 0;
26962:
26963: #if defined(LIBXML_VALID_ENABLED)
26964: int mem_base;
26965: int ret_val;
26966: xmlValidCtxtPtr ctxt; /* the validation context */
26967: int n_ctxt;
26968: xmlDocPtr doc; /* a document instance */
26969: int n_doc;
26970:
26971: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26972: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26973: mem_base = xmlMemBlocks();
26974: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26975: doc = gen_xmlDocPtr(n_doc, 1);
26976:
26977: ret_val = xmlValidateRoot(ctxt, doc);
26978: desret_int(ret_val);
26979: call_tests++;
26980: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26981: des_xmlDocPtr(n_doc, doc, 1);
26982: xmlResetLastError();
26983: if (mem_base != xmlMemBlocks()) {
26984: printf("Leak of %d blocks found in xmlValidateRoot",
26985: xmlMemBlocks() - mem_base);
26986: test_ret++;
26987: printf(" %d", n_ctxt);
26988: printf(" %d", n_doc);
26989: printf("\n");
26990: }
26991: }
26992: }
26993: function_tests++;
26994: #endif
26995:
26996: return(test_ret);
26997: }
26998:
26999: static int
27000: test_valid(void) {
27001: int test_ret = 0;
27002:
27003: if (quiet == 0) printf("Testing valid : 50 of 70 functions ...\n");
27004: test_ret += test_xmlAddAttributeDecl();
27005: test_ret += test_xmlAddElementDecl();
27006: test_ret += test_xmlAddID();
27007: test_ret += test_xmlAddNotationDecl();
27008: test_ret += test_xmlAddRef();
27009: test_ret += test_xmlCopyAttributeTable();
27010: test_ret += test_xmlCopyDocElementContent();
27011: test_ret += test_xmlCopyElementContent();
27012: test_ret += test_xmlCopyElementTable();
27013: test_ret += test_xmlCopyEnumeration();
27014: test_ret += test_xmlCopyNotationTable();
27015: test_ret += test_xmlCreateEnumeration();
27016: test_ret += test_xmlDumpAttributeDecl();
27017: test_ret += test_xmlDumpAttributeTable();
27018: test_ret += test_xmlDumpElementDecl();
27019: test_ret += test_xmlDumpElementTable();
27020: test_ret += test_xmlDumpNotationDecl();
27021: test_ret += test_xmlDumpNotationTable();
27022: test_ret += test_xmlGetDtdAttrDesc();
27023: test_ret += test_xmlGetDtdElementDesc();
27024: test_ret += test_xmlGetDtdNotationDesc();
27025: test_ret += test_xmlGetDtdQAttrDesc();
27026: test_ret += test_xmlGetDtdQElementDesc();
27027: test_ret += test_xmlGetID();
27028: test_ret += test_xmlGetRefs();
27029: test_ret += test_xmlIsID();
27030: test_ret += test_xmlIsMixedElement();
27031: test_ret += test_xmlIsRef();
27032: test_ret += test_xmlNewDocElementContent();
27033: test_ret += test_xmlNewElementContent();
27034: test_ret += test_xmlNewValidCtxt();
27035: test_ret += test_xmlRemoveID();
27036: test_ret += test_xmlRemoveRef();
27037: test_ret += test_xmlSnprintfElementContent();
27038: test_ret += test_xmlSprintfElementContent();
27039: test_ret += test_xmlValidBuildContentModel();
27040: test_ret += test_xmlValidCtxtNormalizeAttributeValue();
27041: test_ret += test_xmlValidGetPotentialChildren();
27042: test_ret += test_xmlValidGetValidElements();
27043: test_ret += test_xmlValidNormalizeAttributeValue();
27044: test_ret += test_xmlValidateAttributeDecl();
27045: test_ret += test_xmlValidateAttributeValue();
27046: test_ret += test_xmlValidateDocument();
27047: test_ret += test_xmlValidateDocumentFinal();
27048: test_ret += test_xmlValidateDtd();
27049: test_ret += test_xmlValidateDtdFinal();
27050: test_ret += test_xmlValidateElement();
27051: test_ret += test_xmlValidateElementDecl();
27052: test_ret += test_xmlValidateNameValue();
27053: test_ret += test_xmlValidateNamesValue();
27054: test_ret += test_xmlValidateNmtokenValue();
27055: test_ret += test_xmlValidateNmtokensValue();
27056: test_ret += test_xmlValidateNotationDecl();
27057: test_ret += test_xmlValidateNotationUse();
27058: test_ret += test_xmlValidateOneAttribute();
27059: test_ret += test_xmlValidateOneElement();
27060: test_ret += test_xmlValidateOneNamespace();
27061: test_ret += test_xmlValidatePopElement();
27062: test_ret += test_xmlValidatePushCData();
27063: test_ret += test_xmlValidatePushElement();
27064: test_ret += test_xmlValidateRoot();
27065:
27066: if (test_ret != 0)
27067: printf("Module valid: %d errors\n", test_ret);
27068: return(test_ret);
27069: }
27070:
27071: static int
27072: test_xmlXIncludeNewContext(void) {
27073: int test_ret = 0;
27074:
27075:
27076: /* missing type support */
27077: return(test_ret);
27078: }
27079:
27080:
27081: static int
27082: test_xmlXIncludeProcess(void) {
27083: int test_ret = 0;
27084:
27085: #if defined(LIBXML_XINCLUDE_ENABLED)
27086: int mem_base;
27087: int ret_val;
27088: xmlDocPtr doc; /* an XML document */
27089: int n_doc;
27090:
27091: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
27092: mem_base = xmlMemBlocks();
27093: doc = gen_xmlDocPtr(n_doc, 0);
27094:
27095: ret_val = xmlXIncludeProcess(doc);
27096: desret_int(ret_val);
27097: call_tests++;
27098: des_xmlDocPtr(n_doc, doc, 0);
27099: xmlResetLastError();
27100: if (mem_base != xmlMemBlocks()) {
27101: printf("Leak of %d blocks found in xmlXIncludeProcess",
27102: xmlMemBlocks() - mem_base);
27103: test_ret++;
27104: printf(" %d", n_doc);
27105: printf("\n");
27106: }
27107: }
27108: function_tests++;
27109: #endif
27110:
27111: return(test_ret);
27112: }
27113:
27114:
27115: static int
27116: test_xmlXIncludeProcessFlags(void) {
27117: int test_ret = 0;
27118:
27119: #if defined(LIBXML_XINCLUDE_ENABLED)
27120: int mem_base;
27121: int ret_val;
27122: xmlDocPtr doc; /* an XML document */
27123: int n_doc;
27124: int flags; /* a set of xmlParserOption used for parsing XML includes */
27125: int n_flags;
27126:
27127: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
27128: for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
27129: mem_base = xmlMemBlocks();
27130: doc = gen_xmlDocPtr(n_doc, 0);
27131: flags = gen_int(n_flags, 1);
27132:
27133: ret_val = xmlXIncludeProcessFlags(doc, flags);
27134: desret_int(ret_val);
27135: call_tests++;
27136: des_xmlDocPtr(n_doc, doc, 0);
27137: des_int(n_flags, flags, 1);
27138: xmlResetLastError();
27139: if (mem_base != xmlMemBlocks()) {
27140: printf("Leak of %d blocks found in xmlXIncludeProcessFlags",
27141: xmlMemBlocks() - mem_base);
27142: test_ret++;
27143: printf(" %d", n_doc);
27144: printf(" %d", n_flags);
27145: printf("\n");
27146: }
27147: }
27148: }
27149: function_tests++;
27150: #endif
27151:
27152: return(test_ret);
27153: }
27154:
27155:
27156: static int
27157: test_xmlXIncludeProcessFlagsData(void) {
27158: int test_ret = 0;
27159:
27160: #if defined(LIBXML_XINCLUDE_ENABLED)
27161: int mem_base;
27162: int ret_val;
27163: xmlDocPtr doc; /* an XML document */
27164: int n_doc;
27165: int flags; /* a set of xmlParserOption used for parsing XML includes */
27166: int n_flags;
27167: void * data; /* application data that will be passed to the parser context in the _private field of the parser context(s) */
27168: int n_data;
27169:
27170: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
27171: for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
27172: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
27173: mem_base = xmlMemBlocks();
27174: doc = gen_xmlDocPtr(n_doc, 0);
27175: flags = gen_int(n_flags, 1);
27176: data = gen_userdata(n_data, 2);
27177:
27178: ret_val = xmlXIncludeProcessFlagsData(doc, flags, data);
27179: desret_int(ret_val);
27180: call_tests++;
27181: des_xmlDocPtr(n_doc, doc, 0);
27182: des_int(n_flags, flags, 1);
27183: des_userdata(n_data, data, 2);
27184: xmlResetLastError();
27185: if (mem_base != xmlMemBlocks()) {
27186: printf("Leak of %d blocks found in xmlXIncludeProcessFlagsData",
27187: xmlMemBlocks() - mem_base);
27188: test_ret++;
27189: printf(" %d", n_doc);
27190: printf(" %d", n_flags);
27191: printf(" %d", n_data);
27192: printf("\n");
27193: }
27194: }
27195: }
27196: }
27197: function_tests++;
27198: #endif
27199:
27200: return(test_ret);
27201: }
27202:
27203: #ifdef LIBXML_XINCLUDE_ENABLED
27204:
27205: #define gen_nb_xmlXIncludeCtxtPtr 1
27206: static xmlXIncludeCtxtPtr gen_xmlXIncludeCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
27207: return(NULL);
27208: }
27209: static void des_xmlXIncludeCtxtPtr(int no ATTRIBUTE_UNUSED, xmlXIncludeCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
27210: }
27211: #endif
27212:
27213:
27214: static int
27215: test_xmlXIncludeProcessNode(void) {
27216: int test_ret = 0;
27217:
27218: #if defined(LIBXML_XINCLUDE_ENABLED)
27219: int mem_base;
27220: int ret_val;
27221: xmlXIncludeCtxtPtr ctxt; /* an existing XInclude context */
27222: int n_ctxt;
27223: xmlNodePtr node; /* a node in an XML document */
27224: int n_node;
27225:
27226: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXIncludeCtxtPtr;n_ctxt++) {
27227: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
27228: mem_base = xmlMemBlocks();
27229: ctxt = gen_xmlXIncludeCtxtPtr(n_ctxt, 0);
27230: node = gen_xmlNodePtr(n_node, 1);
27231:
27232: ret_val = xmlXIncludeProcessNode(ctxt, node);
27233: desret_int(ret_val);
27234: call_tests++;
27235: des_xmlXIncludeCtxtPtr(n_ctxt, ctxt, 0);
27236: des_xmlNodePtr(n_node, node, 1);
27237: xmlResetLastError();
27238: if (mem_base != xmlMemBlocks()) {
27239: printf("Leak of %d blocks found in xmlXIncludeProcessNode",
27240: xmlMemBlocks() - mem_base);
27241: test_ret++;
27242: printf(" %d", n_ctxt);
27243: printf(" %d", n_node);
27244: printf("\n");
27245: }
27246: }
27247: }
27248: function_tests++;
27249: #endif
27250:
27251: return(test_ret);
27252: }
27253:
27254:
27255: static int
27256: test_xmlXIncludeProcessTree(void) {
27257: int test_ret = 0;
27258:
27259: #if defined(LIBXML_XINCLUDE_ENABLED)
27260: int mem_base;
27261: int ret_val;
27262: xmlNodePtr tree; /* a node in an XML document */
27263: int n_tree;
27264:
27265: for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) {
27266: mem_base = xmlMemBlocks();
27267: tree = gen_xmlNodePtr(n_tree, 0);
27268:
27269: ret_val = xmlXIncludeProcessTree(tree);
27270: desret_int(ret_val);
27271: call_tests++;
27272: des_xmlNodePtr(n_tree, tree, 0);
27273: xmlResetLastError();
27274: if (mem_base != xmlMemBlocks()) {
27275: printf("Leak of %d blocks found in xmlXIncludeProcessTree",
27276: xmlMemBlocks() - mem_base);
27277: test_ret++;
27278: printf(" %d", n_tree);
27279: printf("\n");
27280: }
27281: }
27282: function_tests++;
27283: #endif
27284:
27285: return(test_ret);
27286: }
27287:
27288:
27289: static int
27290: test_xmlXIncludeProcessTreeFlags(void) {
27291: int test_ret = 0;
27292:
27293: #if defined(LIBXML_XINCLUDE_ENABLED)
27294: int mem_base;
27295: int ret_val;
27296: xmlNodePtr tree; /* a node in an XML document */
27297: int n_tree;
27298: int flags; /* a set of xmlParserOption used for parsing XML includes */
27299: int n_flags;
27300:
27301: for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) {
27302: for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
27303: mem_base = xmlMemBlocks();
27304: tree = gen_xmlNodePtr(n_tree, 0);
27305: flags = gen_int(n_flags, 1);
27306:
27307: ret_val = xmlXIncludeProcessTreeFlags(tree, flags);
27308: desret_int(ret_val);
27309: call_tests++;
27310: des_xmlNodePtr(n_tree, tree, 0);
27311: des_int(n_flags, flags, 1);
27312: xmlResetLastError();
27313: if (mem_base != xmlMemBlocks()) {
27314: printf("Leak of %d blocks found in xmlXIncludeProcessTreeFlags",
27315: xmlMemBlocks() - mem_base);
27316: test_ret++;
27317: printf(" %d", n_tree);
27318: printf(" %d", n_flags);
27319: printf("\n");
27320: }
27321: }
27322: }
27323: function_tests++;
27324: #endif
27325:
27326: return(test_ret);
27327: }
27328:
27329:
27330: static int
27331: test_xmlXIncludeProcessTreeFlagsData(void) {
27332: int test_ret = 0;
27333:
27334: #if defined(LIBXML_XINCLUDE_ENABLED)
27335: int mem_base;
27336: int ret_val;
27337: xmlNodePtr tree; /* an XML node */
27338: int n_tree;
27339: int flags; /* a set of xmlParserOption used for parsing XML includes */
27340: int n_flags;
27341: void * data; /* application data that will be passed to the parser context in the _private field of the parser context(s) */
27342: int n_data;
27343:
27344: for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) {
27345: for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
27346: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
27347: mem_base = xmlMemBlocks();
27348: tree = gen_xmlNodePtr(n_tree, 0);
27349: flags = gen_int(n_flags, 1);
27350: data = gen_userdata(n_data, 2);
27351:
27352: ret_val = xmlXIncludeProcessTreeFlagsData(tree, flags, data);
27353: desret_int(ret_val);
27354: call_tests++;
27355: des_xmlNodePtr(n_tree, tree, 0);
27356: des_int(n_flags, flags, 1);
27357: des_userdata(n_data, data, 2);
27358: xmlResetLastError();
27359: if (mem_base != xmlMemBlocks()) {
27360: printf("Leak of %d blocks found in xmlXIncludeProcessTreeFlagsData",
27361: xmlMemBlocks() - mem_base);
27362: test_ret++;
27363: printf(" %d", n_tree);
27364: printf(" %d", n_flags);
27365: printf(" %d", n_data);
27366: printf("\n");
27367: }
27368: }
27369: }
27370: }
27371: function_tests++;
27372: #endif
27373:
27374: return(test_ret);
27375: }
27376:
27377:
27378: static int
27379: test_xmlXIncludeSetFlags(void) {
27380: int test_ret = 0;
27381:
27382: #if defined(LIBXML_XINCLUDE_ENABLED)
27383: int mem_base;
27384: int ret_val;
27385: xmlXIncludeCtxtPtr ctxt; /* an XInclude processing context */
27386: int n_ctxt;
27387: int flags; /* a set of xmlParserOption used for parsing XML includes */
27388: int n_flags;
27389:
27390: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXIncludeCtxtPtr;n_ctxt++) {
27391: for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
27392: mem_base = xmlMemBlocks();
27393: ctxt = gen_xmlXIncludeCtxtPtr(n_ctxt, 0);
27394: flags = gen_int(n_flags, 1);
27395:
27396: ret_val = xmlXIncludeSetFlags(ctxt, flags);
27397: desret_int(ret_val);
27398: call_tests++;
27399: des_xmlXIncludeCtxtPtr(n_ctxt, ctxt, 0);
27400: des_int(n_flags, flags, 1);
27401: xmlResetLastError();
27402: if (mem_base != xmlMemBlocks()) {
27403: printf("Leak of %d blocks found in xmlXIncludeSetFlags",
27404: xmlMemBlocks() - mem_base);
27405: test_ret++;
27406: printf(" %d", n_ctxt);
27407: printf(" %d", n_flags);
27408: printf("\n");
27409: }
27410: }
27411: }
27412: function_tests++;
27413: #endif
27414:
27415: return(test_ret);
27416: }
27417:
27418: static int
27419: test_xinclude(void) {
27420: int test_ret = 0;
27421:
27422: if (quiet == 0) printf("Testing xinclude : 8 of 10 functions ...\n");
27423: test_ret += test_xmlXIncludeNewContext();
27424: test_ret += test_xmlXIncludeProcess();
27425: test_ret += test_xmlXIncludeProcessFlags();
27426: test_ret += test_xmlXIncludeProcessFlagsData();
27427: test_ret += test_xmlXIncludeProcessNode();
27428: test_ret += test_xmlXIncludeProcessTree();
27429: test_ret += test_xmlXIncludeProcessTreeFlags();
27430: test_ret += test_xmlXIncludeProcessTreeFlagsData();
27431: test_ret += test_xmlXIncludeSetFlags();
27432:
27433: if (test_ret != 0)
27434: printf("Module xinclude: %d errors\n", test_ret);
27435: return(test_ret);
27436: }
27437:
27438: static int
27439: test_xmlAllocOutputBuffer(void) {
27440: int test_ret = 0;
27441:
27442: #if defined(LIBXML_OUTPUT_ENABLED)
27443: int mem_base;
27444: xmlOutputBufferPtr ret_val;
27445: xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */
27446: int n_encoder;
27447:
27448: for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) {
27449: mem_base = xmlMemBlocks();
27450: encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 0);
27451:
27452: ret_val = xmlAllocOutputBuffer(encoder);
27453: desret_xmlOutputBufferPtr(ret_val);
27454: call_tests++;
27455: des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 0);
27456: xmlResetLastError();
27457: if (mem_base != xmlMemBlocks()) {
27458: printf("Leak of %d blocks found in xmlAllocOutputBuffer",
27459: xmlMemBlocks() - mem_base);
27460: test_ret++;
27461: printf(" %d", n_encoder);
27462: printf("\n");
27463: }
27464: }
27465: function_tests++;
27466: #endif
27467:
27468: return(test_ret);
27469: }
27470:
27471:
27472: static int
27473: test_xmlAllocParserInputBuffer(void) {
27474: int test_ret = 0;
27475:
27476: int mem_base;
27477: xmlParserInputBufferPtr ret_val;
27478: xmlCharEncoding enc; /* the charset encoding if known */
27479: int n_enc;
27480:
27481: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
27482: mem_base = xmlMemBlocks();
27483: enc = gen_xmlCharEncoding(n_enc, 0);
27484:
27485: ret_val = xmlAllocParserInputBuffer(enc);
27486: desret_xmlParserInputBufferPtr(ret_val);
27487: call_tests++;
27488: des_xmlCharEncoding(n_enc, enc, 0);
27489: xmlResetLastError();
27490: if (mem_base != xmlMemBlocks()) {
27491: printf("Leak of %d blocks found in xmlAllocParserInputBuffer",
27492: xmlMemBlocks() - mem_base);
27493: test_ret++;
27494: printf(" %d", n_enc);
27495: printf("\n");
27496: }
27497: }
27498: function_tests++;
27499:
27500: return(test_ret);
27501: }
27502:
27503:
27504: static int
27505: test_xmlCheckFilename(void) {
27506: int test_ret = 0;
27507:
27508: int mem_base;
27509: int ret_val;
27510: char * path; /* the path to check */
27511: int n_path;
27512:
27513: for (n_path = 0;n_path < gen_nb_const_char_ptr;n_path++) {
27514: mem_base = xmlMemBlocks();
27515: path = gen_const_char_ptr(n_path, 0);
27516:
27517: ret_val = xmlCheckFilename((const char *)path);
27518: desret_int(ret_val);
27519: call_tests++;
27520: des_const_char_ptr(n_path, (const char *)path, 0);
27521: xmlResetLastError();
27522: if (mem_base != xmlMemBlocks()) {
27523: printf("Leak of %d blocks found in xmlCheckFilename",
27524: xmlMemBlocks() - mem_base);
27525: test_ret++;
27526: printf(" %d", n_path);
27527: printf("\n");
27528: }
27529: }
27530: function_tests++;
27531:
27532: return(test_ret);
27533: }
27534:
27535:
27536: static int
27537: test_xmlCheckHTTPInput(void) {
27538: int test_ret = 0;
27539:
27540: int mem_base;
27541: xmlParserInputPtr ret_val;
27542: xmlParserCtxtPtr ctxt; /* an XML parser context */
27543: int n_ctxt;
27544: xmlParserInputPtr ret; /* an XML parser input */
27545: int n_ret;
27546:
27547: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
27548: for (n_ret = 0;n_ret < gen_nb_xmlParserInputPtr;n_ret++) {
27549: mem_base = xmlMemBlocks();
27550: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
27551: ret = gen_xmlParserInputPtr(n_ret, 1);
27552:
27553: ret_val = xmlCheckHTTPInput(ctxt, ret);
27554: desret_xmlParserInputPtr(ret_val);
27555: call_tests++;
27556: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
27557: des_xmlParserInputPtr(n_ret, ret, 1);
27558: xmlResetLastError();
27559: if (mem_base != xmlMemBlocks()) {
27560: printf("Leak of %d blocks found in xmlCheckHTTPInput",
27561: xmlMemBlocks() - mem_base);
27562: test_ret++;
27563: printf(" %d", n_ctxt);
27564: printf(" %d", n_ret);
27565: printf("\n");
27566: }
27567: }
27568: }
27569: function_tests++;
27570:
27571: return(test_ret);
27572: }
27573:
27574:
27575: static int
27576: test_xmlCleanupInputCallbacks(void) {
27577: int test_ret = 0;
27578:
27579: int mem_base;
27580:
27581: mem_base = xmlMemBlocks();
27582:
27583: xmlCleanupInputCallbacks();
27584: call_tests++;
27585: xmlResetLastError();
27586: if (mem_base != xmlMemBlocks()) {
27587: printf("Leak of %d blocks found in xmlCleanupInputCallbacks",
27588: xmlMemBlocks() - mem_base);
27589: test_ret++;
27590: printf("\n");
27591: }
27592: function_tests++;
27593:
27594: return(test_ret);
27595: }
27596:
27597:
27598: static int
27599: test_xmlCleanupOutputCallbacks(void) {
27600: int test_ret = 0;
27601:
27602: #if defined(LIBXML_OUTPUT_ENABLED)
27603: int mem_base;
27604:
27605: mem_base = xmlMemBlocks();
27606:
27607: xmlCleanupOutputCallbacks();
27608: call_tests++;
27609: xmlResetLastError();
27610: if (mem_base != xmlMemBlocks()) {
27611: printf("Leak of %d blocks found in xmlCleanupOutputCallbacks",
27612: xmlMemBlocks() - mem_base);
27613: test_ret++;
27614: printf("\n");
27615: }
27616: function_tests++;
27617: #endif
27618:
27619: return(test_ret);
27620: }
27621:
27622:
27623: static int
27624: test_xmlFileClose(void) {
27625: int test_ret = 0;
27626:
27627: int mem_base;
27628: int ret_val;
27629: void * context; /* the I/O context */
27630: int n_context;
27631:
27632: for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
27633: mem_base = xmlMemBlocks();
27634: context = gen_void_ptr(n_context, 0);
27635:
27636: ret_val = xmlFileClose(context);
27637: desret_int(ret_val);
27638: call_tests++;
27639: des_void_ptr(n_context, context, 0);
27640: xmlResetLastError();
27641: if (mem_base != xmlMemBlocks()) {
27642: printf("Leak of %d blocks found in xmlFileClose",
27643: xmlMemBlocks() - mem_base);
27644: test_ret++;
27645: printf(" %d", n_context);
27646: printf("\n");
27647: }
27648: }
27649: function_tests++;
27650:
27651: return(test_ret);
27652: }
27653:
27654:
27655: static int
27656: test_xmlFileMatch(void) {
27657: int test_ret = 0;
27658:
27659: int mem_base;
27660: int ret_val;
27661: const char * filename; /* the URI for matching */
27662: int n_filename;
27663:
27664: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
27665: mem_base = xmlMemBlocks();
27666: filename = gen_filepath(n_filename, 0);
27667:
27668: ret_val = xmlFileMatch(filename);
27669: desret_int(ret_val);
27670: call_tests++;
27671: des_filepath(n_filename, filename, 0);
27672: xmlResetLastError();
27673: if (mem_base != xmlMemBlocks()) {
27674: printf("Leak of %d blocks found in xmlFileMatch",
27675: xmlMemBlocks() - mem_base);
27676: test_ret++;
27677: printf(" %d", n_filename);
27678: printf("\n");
27679: }
27680: }
27681: function_tests++;
27682:
27683: return(test_ret);
27684: }
27685:
27686:
27687: static int
27688: test_xmlFileOpen(void) {
27689: int test_ret = 0;
27690:
27691: int mem_base;
27692: void * ret_val;
27693: const char * filename; /* the URI for matching */
27694: int n_filename;
27695:
27696: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
27697: mem_base = xmlMemBlocks();
27698: filename = gen_filepath(n_filename, 0);
27699:
27700: ret_val = xmlFileOpen(filename);
27701: desret_void_ptr(ret_val);
27702: call_tests++;
27703: des_filepath(n_filename, filename, 0);
27704: xmlResetLastError();
27705: if (mem_base != xmlMemBlocks()) {
27706: printf("Leak of %d blocks found in xmlFileOpen",
27707: xmlMemBlocks() - mem_base);
27708: test_ret++;
27709: printf(" %d", n_filename);
27710: printf("\n");
27711: }
27712: }
27713: function_tests++;
27714:
27715: return(test_ret);
27716: }
27717:
27718:
27719: static int
27720: test_xmlFileRead(void) {
27721: int test_ret = 0;
27722:
27723: int mem_base;
27724: int ret_val;
27725: void * context; /* the I/O context */
27726: int n_context;
27727: char * buffer; /* where to drop data */
27728: int n_buffer;
27729: int len; /* number of bytes to write */
27730: int n_len;
27731:
27732: for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
27733: for (n_buffer = 0;n_buffer < gen_nb_char_ptr;n_buffer++) {
27734: for (n_len = 0;n_len < gen_nb_int;n_len++) {
27735: mem_base = xmlMemBlocks();
27736: context = gen_void_ptr(n_context, 0);
27737: buffer = gen_char_ptr(n_buffer, 1);
27738: len = gen_int(n_len, 2);
27739:
27740: ret_val = xmlFileRead(context, buffer, len);
27741: desret_int(ret_val);
27742: call_tests++;
27743: des_void_ptr(n_context, context, 0);
27744: des_char_ptr(n_buffer, buffer, 1);
27745: des_int(n_len, len, 2);
27746: xmlResetLastError();
27747: if (mem_base != xmlMemBlocks()) {
27748: printf("Leak of %d blocks found in xmlFileRead",
27749: xmlMemBlocks() - mem_base);
27750: test_ret++;
27751: printf(" %d", n_context);
27752: printf(" %d", n_buffer);
27753: printf(" %d", n_len);
27754: printf("\n");
27755: }
27756: }
27757: }
27758: }
27759: function_tests++;
27760:
27761: return(test_ret);
27762: }
27763:
27764:
27765: static int
27766: test_xmlIOFTPClose(void) {
27767: int test_ret = 0;
27768:
27769: #if defined(LIBXML_FTP_ENABLED)
27770: int mem_base;
27771: int ret_val;
27772: void * context; /* the I/O context */
27773: int n_context;
27774:
27775: for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
27776: mem_base = xmlMemBlocks();
27777: context = gen_void_ptr(n_context, 0);
27778:
27779: ret_val = xmlIOFTPClose(context);
27780: desret_int(ret_val);
27781: call_tests++;
27782: des_void_ptr(n_context, context, 0);
27783: xmlResetLastError();
27784: if (mem_base != xmlMemBlocks()) {
27785: printf("Leak of %d blocks found in xmlIOFTPClose",
27786: xmlMemBlocks() - mem_base);
27787: test_ret++;
27788: printf(" %d", n_context);
27789: printf("\n");
27790: }
27791: }
27792: function_tests++;
27793: #endif
27794:
27795: return(test_ret);
27796: }
27797:
27798:
27799: static int
27800: test_xmlIOFTPMatch(void) {
27801: int test_ret = 0;
27802:
27803: #if defined(LIBXML_FTP_ENABLED)
27804: int mem_base;
27805: int ret_val;
27806: const char * filename; /* the URI for matching */
27807: int n_filename;
27808:
27809: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
27810: mem_base = xmlMemBlocks();
27811: filename = gen_filepath(n_filename, 0);
27812:
27813: ret_val = xmlIOFTPMatch(filename);
27814: desret_int(ret_val);
27815: call_tests++;
27816: des_filepath(n_filename, filename, 0);
27817: xmlResetLastError();
27818: if (mem_base != xmlMemBlocks()) {
27819: printf("Leak of %d blocks found in xmlIOFTPMatch",
27820: xmlMemBlocks() - mem_base);
27821: test_ret++;
27822: printf(" %d", n_filename);
27823: printf("\n");
27824: }
27825: }
27826: function_tests++;
27827: #endif
27828:
27829: return(test_ret);
27830: }
27831:
27832:
27833: static int
27834: test_xmlIOFTPOpen(void) {
27835: int test_ret = 0;
27836:
27837: #if defined(LIBXML_FTP_ENABLED)
27838: int mem_base;
27839: void * ret_val;
27840: const char * filename; /* the URI for matching */
27841: int n_filename;
27842:
27843: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
27844: mem_base = xmlMemBlocks();
27845: filename = gen_filepath(n_filename, 0);
27846:
27847: ret_val = xmlIOFTPOpen(filename);
27848: desret_void_ptr(ret_val);
27849: call_tests++;
27850: des_filepath(n_filename, filename, 0);
27851: xmlResetLastError();
27852: if (mem_base != xmlMemBlocks()) {
27853: printf("Leak of %d blocks found in xmlIOFTPOpen",
27854: xmlMemBlocks() - mem_base);
27855: test_ret++;
27856: printf(" %d", n_filename);
27857: printf("\n");
27858: }
27859: }
27860: function_tests++;
27861: #endif
27862:
27863: return(test_ret);
27864: }
27865:
27866:
27867: static int
27868: test_xmlIOFTPRead(void) {
27869: int test_ret = 0;
27870:
27871: #if defined(LIBXML_FTP_ENABLED)
27872: int mem_base;
27873: int ret_val;
27874: void * context; /* the I/O context */
27875: int n_context;
27876: char * buffer; /* where to drop data */
27877: int n_buffer;
27878: int len; /* number of bytes to write */
27879: int n_len;
27880:
27881: for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
27882: for (n_buffer = 0;n_buffer < gen_nb_char_ptr;n_buffer++) {
27883: for (n_len = 0;n_len < gen_nb_int;n_len++) {
27884: mem_base = xmlMemBlocks();
27885: context = gen_void_ptr(n_context, 0);
27886: buffer = gen_char_ptr(n_buffer, 1);
27887: len = gen_int(n_len, 2);
27888:
27889: ret_val = xmlIOFTPRead(context, buffer, len);
27890: desret_int(ret_val);
27891: call_tests++;
27892: des_void_ptr(n_context, context, 0);
27893: des_char_ptr(n_buffer, buffer, 1);
27894: des_int(n_len, len, 2);
27895: xmlResetLastError();
27896: if (mem_base != xmlMemBlocks()) {
27897: printf("Leak of %d blocks found in xmlIOFTPRead",
27898: xmlMemBlocks() - mem_base);
27899: test_ret++;
27900: printf(" %d", n_context);
27901: printf(" %d", n_buffer);
27902: printf(" %d", n_len);
27903: printf("\n");
27904: }
27905: }
27906: }
27907: }
27908: function_tests++;
27909: #endif
27910:
27911: return(test_ret);
27912: }
27913:
27914:
27915: static int
27916: test_xmlIOHTTPClose(void) {
27917: int test_ret = 0;
27918:
27919: #if defined(LIBXML_HTTP_ENABLED)
27920: int mem_base;
27921: int ret_val;
27922: void * context; /* the I/O context */
27923: int n_context;
27924:
27925: for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
27926: mem_base = xmlMemBlocks();
27927: context = gen_void_ptr(n_context, 0);
27928:
27929: ret_val = xmlIOHTTPClose(context);
27930: desret_int(ret_val);
27931: call_tests++;
27932: des_void_ptr(n_context, context, 0);
27933: xmlResetLastError();
27934: if (mem_base != xmlMemBlocks()) {
27935: printf("Leak of %d blocks found in xmlIOHTTPClose",
27936: xmlMemBlocks() - mem_base);
27937: test_ret++;
27938: printf(" %d", n_context);
27939: printf("\n");
27940: }
27941: }
27942: function_tests++;
27943: #endif
27944:
27945: return(test_ret);
27946: }
27947:
27948:
27949: static int
27950: test_xmlIOHTTPMatch(void) {
27951: int test_ret = 0;
27952:
27953: #if defined(LIBXML_HTTP_ENABLED)
27954: int mem_base;
27955: int ret_val;
27956: const char * filename; /* the URI for matching */
27957: int n_filename;
27958:
27959: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
27960: mem_base = xmlMemBlocks();
27961: filename = gen_filepath(n_filename, 0);
27962:
27963: ret_val = xmlIOHTTPMatch(filename);
27964: desret_int(ret_val);
27965: call_tests++;
27966: des_filepath(n_filename, filename, 0);
27967: xmlResetLastError();
27968: if (mem_base != xmlMemBlocks()) {
27969: printf("Leak of %d blocks found in xmlIOHTTPMatch",
27970: xmlMemBlocks() - mem_base);
27971: test_ret++;
27972: printf(" %d", n_filename);
27973: printf("\n");
27974: }
27975: }
27976: function_tests++;
27977: #endif
27978:
27979: return(test_ret);
27980: }
27981:
27982:
27983: static int
27984: test_xmlIOHTTPOpen(void) {
27985: int test_ret = 0;
27986:
27987: #if defined(LIBXML_HTTP_ENABLED)
27988: int mem_base;
27989: void * ret_val;
27990: const char * filename; /* the URI for matching */
27991: int n_filename;
27992:
27993: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
27994: mem_base = xmlMemBlocks();
27995: filename = gen_filepath(n_filename, 0);
27996:
27997: ret_val = xmlIOHTTPOpen(filename);
27998: desret_xmlNanoHTTPCtxtPtr(ret_val);
27999: call_tests++;
28000: des_filepath(n_filename, filename, 0);
28001: xmlResetLastError();
28002: if (mem_base != xmlMemBlocks()) {
28003: printf("Leak of %d blocks found in xmlIOHTTPOpen",
28004: xmlMemBlocks() - mem_base);
28005: test_ret++;
28006: printf(" %d", n_filename);
28007: printf("\n");
28008: }
28009: }
28010: function_tests++;
28011: #endif
28012:
28013: return(test_ret);
28014: }
28015:
28016:
28017: static int
28018: test_xmlIOHTTPRead(void) {
28019: int test_ret = 0;
28020:
28021: #if defined(LIBXML_HTTP_ENABLED)
28022: int mem_base;
28023: int ret_val;
28024: void * context; /* the I/O context */
28025: int n_context;
28026: char * buffer; /* where to drop data */
28027: int n_buffer;
28028: int len; /* number of bytes to write */
28029: int n_len;
28030:
28031: for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
28032: for (n_buffer = 0;n_buffer < gen_nb_char_ptr;n_buffer++) {
28033: for (n_len = 0;n_len < gen_nb_int;n_len++) {
28034: mem_base = xmlMemBlocks();
28035: context = gen_void_ptr(n_context, 0);
28036: buffer = gen_char_ptr(n_buffer, 1);
28037: len = gen_int(n_len, 2);
28038:
28039: ret_val = xmlIOHTTPRead(context, buffer, len);
28040: desret_int(ret_val);
28041: call_tests++;
28042: des_void_ptr(n_context, context, 0);
28043: des_char_ptr(n_buffer, buffer, 1);
28044: des_int(n_len, len, 2);
28045: xmlResetLastError();
28046: if (mem_base != xmlMemBlocks()) {
28047: printf("Leak of %d blocks found in xmlIOHTTPRead",
28048: xmlMemBlocks() - mem_base);
28049: test_ret++;
28050: printf(" %d", n_context);
28051: printf(" %d", n_buffer);
28052: printf(" %d", n_len);
28053: printf("\n");
28054: }
28055: }
28056: }
28057: }
28058: function_tests++;
28059: #endif
28060:
28061: return(test_ret);
28062: }
28063:
28064:
28065: static int
28066: test_xmlNoNetExternalEntityLoader(void) {
28067: int test_ret = 0;
28068:
28069: int mem_base;
28070: xmlParserInputPtr ret_val;
28071: const char * URL; /* the URL for the entity to load */
28072: int n_URL;
28073: char * ID; /* the System ID for the entity to load */
28074: int n_ID;
28075: xmlParserCtxtPtr ctxt; /* the context in which the entity is called or NULL */
28076: int n_ctxt;
28077:
28078: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
28079: for (n_ID = 0;n_ID < gen_nb_const_char_ptr;n_ID++) {
28080: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
28081: mem_base = xmlMemBlocks();
28082: URL = gen_filepath(n_URL, 0);
28083: ID = gen_const_char_ptr(n_ID, 1);
28084: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 2);
28085:
28086: ret_val = xmlNoNetExternalEntityLoader(URL, (const char *)ID, ctxt);
28087: desret_xmlParserInputPtr(ret_val);
28088: call_tests++;
28089: des_filepath(n_URL, URL, 0);
28090: des_const_char_ptr(n_ID, (const char *)ID, 1);
28091: des_xmlParserCtxtPtr(n_ctxt, ctxt, 2);
28092: xmlResetLastError();
28093: if (mem_base != xmlMemBlocks()) {
28094: printf("Leak of %d blocks found in xmlNoNetExternalEntityLoader",
28095: xmlMemBlocks() - mem_base);
28096: test_ret++;
28097: printf(" %d", n_URL);
28098: printf(" %d", n_ID);
28099: printf(" %d", n_ctxt);
28100: printf("\n");
28101: }
28102: }
28103: }
28104: }
28105: function_tests++;
28106:
28107: return(test_ret);
28108: }
28109:
28110:
28111: static int
28112: test_xmlNormalizeWindowsPath(void) {
28113: int test_ret = 0;
28114:
28115: int mem_base;
28116: xmlChar * ret_val;
28117: xmlChar * path; /* the input file path */
28118: int n_path;
28119:
28120: for (n_path = 0;n_path < gen_nb_const_xmlChar_ptr;n_path++) {
28121: mem_base = xmlMemBlocks();
28122: path = gen_const_xmlChar_ptr(n_path, 0);
28123:
28124: ret_val = xmlNormalizeWindowsPath((const xmlChar *)path);
28125: desret_xmlChar_ptr(ret_val);
28126: call_tests++;
28127: des_const_xmlChar_ptr(n_path, (const xmlChar *)path, 0);
28128: xmlResetLastError();
28129: if (mem_base != xmlMemBlocks()) {
28130: printf("Leak of %d blocks found in xmlNormalizeWindowsPath",
28131: xmlMemBlocks() - mem_base);
28132: test_ret++;
28133: printf(" %d", n_path);
28134: printf("\n");
28135: }
28136: }
28137: function_tests++;
28138:
28139: return(test_ret);
28140: }
28141:
28142:
28143: static int
28144: test_xmlOutputBufferCreateBuffer(void) {
28145: int test_ret = 0;
28146:
28147: #if defined(LIBXML_OUTPUT_ENABLED)
28148: int mem_base;
28149: xmlOutputBufferPtr ret_val;
28150: xmlBufferPtr buffer; /* a xmlBufferPtr */
28151: int n_buffer;
28152: xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */
28153: int n_encoder;
28154:
28155: for (n_buffer = 0;n_buffer < gen_nb_xmlBufferPtr;n_buffer++) {
28156: for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) {
28157: mem_base = xmlMemBlocks();
28158: buffer = gen_xmlBufferPtr(n_buffer, 0);
28159: encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 1);
28160:
28161: ret_val = xmlOutputBufferCreateBuffer(buffer, encoder);
28162: desret_xmlOutputBufferPtr(ret_val);
28163: call_tests++;
28164: des_xmlBufferPtr(n_buffer, buffer, 0);
28165: des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 1);
28166: xmlResetLastError();
28167: if (mem_base != xmlMemBlocks()) {
28168: printf("Leak of %d blocks found in xmlOutputBufferCreateBuffer",
28169: xmlMemBlocks() - mem_base);
28170: test_ret++;
28171: printf(" %d", n_buffer);
28172: printf(" %d", n_encoder);
28173: printf("\n");
28174: }
28175: }
28176: }
28177: function_tests++;
28178: #endif
28179:
28180: return(test_ret);
28181: }
28182:
28183:
28184: static int
28185: test_xmlOutputBufferCreateFd(void) {
28186: int test_ret = 0;
28187:
28188: #if defined(LIBXML_OUTPUT_ENABLED)
28189: int mem_base;
28190: xmlOutputBufferPtr ret_val;
28191: int fd; /* a file descriptor number */
28192: int n_fd;
28193: xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */
28194: int n_encoder;
28195:
28196: for (n_fd = 0;n_fd < gen_nb_int;n_fd++) {
28197: for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) {
28198: mem_base = xmlMemBlocks();
28199: fd = gen_int(n_fd, 0);
28200: encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 1);
28201:
28202: ret_val = xmlOutputBufferCreateFd(fd, encoder);
28203: desret_xmlOutputBufferPtr(ret_val);
28204: call_tests++;
28205: des_int(n_fd, fd, 0);
28206: des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 1);
28207: xmlResetLastError();
28208: if (mem_base != xmlMemBlocks()) {
28209: printf("Leak of %d blocks found in xmlOutputBufferCreateFd",
28210: xmlMemBlocks() - mem_base);
28211: test_ret++;
28212: printf(" %d", n_fd);
28213: printf(" %d", n_encoder);
28214: printf("\n");
28215: }
28216: }
28217: }
28218: function_tests++;
28219: #endif
28220:
28221: return(test_ret);
28222: }
28223:
28224:
28225: static int
28226: test_xmlOutputBufferCreateFile(void) {
28227: int test_ret = 0;
28228:
28229: #if defined(LIBXML_OUTPUT_ENABLED)
28230: int mem_base;
28231: xmlOutputBufferPtr ret_val;
28232: FILE * file; /* a FILE* */
28233: int n_file;
28234: xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */
28235: int n_encoder;
28236:
28237: for (n_file = 0;n_file < gen_nb_FILE_ptr;n_file++) {
28238: for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) {
28239: mem_base = xmlMemBlocks();
28240: file = gen_FILE_ptr(n_file, 0);
28241: encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 1);
28242:
28243: ret_val = xmlOutputBufferCreateFile(file, encoder);
28244: desret_xmlOutputBufferPtr(ret_val);
28245: call_tests++;
28246: des_FILE_ptr(n_file, file, 0);
28247: des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 1);
28248: xmlResetLastError();
28249: if (mem_base != xmlMemBlocks()) {
28250: printf("Leak of %d blocks found in xmlOutputBufferCreateFile",
28251: xmlMemBlocks() - mem_base);
28252: test_ret++;
28253: printf(" %d", n_file);
28254: printf(" %d", n_encoder);
28255: printf("\n");
28256: }
28257: }
28258: }
28259: function_tests++;
28260: #endif
28261:
28262: return(test_ret);
28263: }
28264:
28265:
28266: static int
28267: test_xmlOutputBufferCreateFilename(void) {
28268: int test_ret = 0;
28269:
28270: #if defined(LIBXML_OUTPUT_ENABLED)
28271: int mem_base;
28272: xmlOutputBufferPtr ret_val;
28273: const char * URI; /* a C string containing the URI or filename */
28274: int n_URI;
28275: xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */
28276: int n_encoder;
28277: int compression; /* the compression ration (0 none, 9 max). */
28278: int n_compression;
28279:
28280: for (n_URI = 0;n_URI < gen_nb_fileoutput;n_URI++) {
28281: for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) {
28282: for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
28283: mem_base = xmlMemBlocks();
28284: URI = gen_fileoutput(n_URI, 0);
28285: encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 1);
28286: compression = gen_int(n_compression, 2);
28287:
28288: ret_val = xmlOutputBufferCreateFilename(URI, encoder, compression);
28289: desret_xmlOutputBufferPtr(ret_val);
28290: call_tests++;
28291: des_fileoutput(n_URI, URI, 0);
28292: des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 1);
28293: des_int(n_compression, compression, 2);
28294: xmlResetLastError();
28295: if (mem_base != xmlMemBlocks()) {
28296: printf("Leak of %d blocks found in xmlOutputBufferCreateFilename",
28297: xmlMemBlocks() - mem_base);
28298: test_ret++;
28299: printf(" %d", n_URI);
28300: printf(" %d", n_encoder);
28301: printf(" %d", n_compression);
28302: printf("\n");
28303: }
28304: }
28305: }
28306: }
28307: function_tests++;
28308: #endif
28309:
28310: return(test_ret);
28311: }
28312:
28313:
28314: static int
28315: test_xmlOutputBufferFlush(void) {
28316: int test_ret = 0;
28317:
28318: #if defined(LIBXML_OUTPUT_ENABLED)
28319: int mem_base;
28320: int ret_val;
28321: xmlOutputBufferPtr out; /* a buffered output */
28322: int n_out;
28323:
28324: for (n_out = 0;n_out < gen_nb_xmlOutputBufferPtr;n_out++) {
28325: mem_base = xmlMemBlocks();
28326: out = gen_xmlOutputBufferPtr(n_out, 0);
28327:
28328: ret_val = xmlOutputBufferFlush(out);
28329: desret_int(ret_val);
28330: call_tests++;
28331: des_xmlOutputBufferPtr(n_out, out, 0);
28332: xmlResetLastError();
28333: if (mem_base != xmlMemBlocks()) {
28334: printf("Leak of %d blocks found in xmlOutputBufferFlush",
28335: xmlMemBlocks() - mem_base);
28336: test_ret++;
28337: printf(" %d", n_out);
28338: printf("\n");
28339: }
28340: }
28341: function_tests++;
28342: #endif
28343:
28344: return(test_ret);
28345: }
28346:
28347:
28348: static int
28349: test_xmlOutputBufferWrite(void) {
28350: int test_ret = 0;
28351:
28352: #if defined(LIBXML_OUTPUT_ENABLED)
28353: int mem_base;
28354: int ret_val;
28355: xmlOutputBufferPtr out; /* a buffered parser output */
28356: int n_out;
28357: int len; /* the size in bytes of the array. */
28358: int n_len;
28359: char * buf; /* an char array */
28360: int n_buf;
28361:
28362: for (n_out = 0;n_out < gen_nb_xmlOutputBufferPtr;n_out++) {
28363: for (n_len = 0;n_len < gen_nb_int;n_len++) {
28364: for (n_buf = 0;n_buf < gen_nb_const_char_ptr;n_buf++) {
28365: mem_base = xmlMemBlocks();
28366: out = gen_xmlOutputBufferPtr(n_out, 0);
28367: len = gen_int(n_len, 1);
28368: buf = gen_const_char_ptr(n_buf, 2);
28369:
28370: ret_val = xmlOutputBufferWrite(out, len, (const char *)buf);
28371: desret_int(ret_val);
28372: call_tests++;
28373: des_xmlOutputBufferPtr(n_out, out, 0);
28374: des_int(n_len, len, 1);
28375: des_const_char_ptr(n_buf, (const char *)buf, 2);
28376: xmlResetLastError();
28377: if (mem_base != xmlMemBlocks()) {
28378: printf("Leak of %d blocks found in xmlOutputBufferWrite",
28379: xmlMemBlocks() - mem_base);
28380: test_ret++;
28381: printf(" %d", n_out);
28382: printf(" %d", n_len);
28383: printf(" %d", n_buf);
28384: printf("\n");
28385: }
28386: }
28387: }
28388: }
28389: function_tests++;
28390: #endif
28391:
28392: return(test_ret);
28393: }
28394:
28395:
28396: static int
28397: test_xmlOutputBufferWriteEscape(void) {
28398: int test_ret = 0;
28399:
28400:
28401: /* missing type support */
28402: return(test_ret);
28403: }
28404:
28405:
28406: static int
28407: test_xmlOutputBufferWriteString(void) {
28408: int test_ret = 0;
28409:
28410: #if defined(LIBXML_OUTPUT_ENABLED)
28411: int mem_base;
28412: int ret_val;
28413: xmlOutputBufferPtr out; /* a buffered parser output */
28414: int n_out;
28415: char * str; /* a zero terminated C string */
28416: int n_str;
28417:
28418: for (n_out = 0;n_out < gen_nb_xmlOutputBufferPtr;n_out++) {
28419: for (n_str = 0;n_str < gen_nb_const_char_ptr;n_str++) {
28420: mem_base = xmlMemBlocks();
28421: out = gen_xmlOutputBufferPtr(n_out, 0);
28422: str = gen_const_char_ptr(n_str, 1);
28423:
28424: ret_val = xmlOutputBufferWriteString(out, (const char *)str);
28425: desret_int(ret_val);
28426: call_tests++;
28427: des_xmlOutputBufferPtr(n_out, out, 0);
28428: des_const_char_ptr(n_str, (const char *)str, 1);
28429: xmlResetLastError();
28430: if (mem_base != xmlMemBlocks()) {
28431: printf("Leak of %d blocks found in xmlOutputBufferWriteString",
28432: xmlMemBlocks() - mem_base);
28433: test_ret++;
28434: printf(" %d", n_out);
28435: printf(" %d", n_str);
28436: printf("\n");
28437: }
28438: }
28439: }
28440: function_tests++;
28441: #endif
28442:
28443: return(test_ret);
28444: }
28445:
28446:
28447: static int
28448: test_xmlParserGetDirectory(void) {
28449: int test_ret = 0;
28450:
28451:
28452: /* missing type support */
28453: return(test_ret);
28454: }
28455:
28456:
28457: static int
28458: test_xmlParserInputBufferCreateFd(void) {
28459: int test_ret = 0;
28460:
28461: int mem_base;
28462: xmlParserInputBufferPtr ret_val;
28463: int fd; /* a file descriptor number */
28464: int n_fd;
28465: xmlCharEncoding enc; /* the charset encoding if known */
28466: int n_enc;
28467:
28468: for (n_fd = 0;n_fd < gen_nb_int;n_fd++) {
28469: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
28470: mem_base = xmlMemBlocks();
28471: fd = gen_int(n_fd, 0);
28472: enc = gen_xmlCharEncoding(n_enc, 1);
28473: if (fd >= 0) fd = -1;
28474:
28475: ret_val = xmlParserInputBufferCreateFd(fd, enc);
28476: desret_xmlParserInputBufferPtr(ret_val);
28477: call_tests++;
28478: des_int(n_fd, fd, 0);
28479: des_xmlCharEncoding(n_enc, enc, 1);
28480: xmlResetLastError();
28481: if (mem_base != xmlMemBlocks()) {
28482: printf("Leak of %d blocks found in xmlParserInputBufferCreateFd",
28483: xmlMemBlocks() - mem_base);
28484: test_ret++;
28485: printf(" %d", n_fd);
28486: printf(" %d", n_enc);
28487: printf("\n");
28488: }
28489: }
28490: }
28491: function_tests++;
28492:
28493: return(test_ret);
28494: }
28495:
28496:
28497: static int
28498: test_xmlParserInputBufferCreateFile(void) {
28499: int test_ret = 0;
28500:
28501: int mem_base;
28502: xmlParserInputBufferPtr ret_val;
28503: FILE * file; /* a FILE* */
28504: int n_file;
28505: xmlCharEncoding enc; /* the charset encoding if known */
28506: int n_enc;
28507:
28508: for (n_file = 0;n_file < gen_nb_FILE_ptr;n_file++) {
28509: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
28510: mem_base = xmlMemBlocks();
28511: file = gen_FILE_ptr(n_file, 0);
28512: enc = gen_xmlCharEncoding(n_enc, 1);
28513:
28514: ret_val = xmlParserInputBufferCreateFile(file, enc);
28515: desret_xmlParserInputBufferPtr(ret_val);
28516: call_tests++;
28517: des_FILE_ptr(n_file, file, 0);
28518: des_xmlCharEncoding(n_enc, enc, 1);
28519: xmlResetLastError();
28520: if (mem_base != xmlMemBlocks()) {
28521: printf("Leak of %d blocks found in xmlParserInputBufferCreateFile",
28522: xmlMemBlocks() - mem_base);
28523: test_ret++;
28524: printf(" %d", n_file);
28525: printf(" %d", n_enc);
28526: printf("\n");
28527: }
28528: }
28529: }
28530: function_tests++;
28531:
28532: return(test_ret);
28533: }
28534:
28535:
28536: static int
28537: test_xmlParserInputBufferCreateFilename(void) {
28538: int test_ret = 0;
28539:
28540: int mem_base;
28541: xmlParserInputBufferPtr ret_val;
28542: const char * URI; /* a C string containing the URI or filename */
28543: int n_URI;
28544: xmlCharEncoding enc; /* the charset encoding if known */
28545: int n_enc;
28546:
28547: for (n_URI = 0;n_URI < gen_nb_fileoutput;n_URI++) {
28548: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
28549: mem_base = xmlMemBlocks();
28550: URI = gen_fileoutput(n_URI, 0);
28551: enc = gen_xmlCharEncoding(n_enc, 1);
28552:
28553: ret_val = xmlParserInputBufferCreateFilename(URI, enc);
28554: desret_xmlParserInputBufferPtr(ret_val);
28555: call_tests++;
28556: des_fileoutput(n_URI, URI, 0);
28557: des_xmlCharEncoding(n_enc, enc, 1);
28558: xmlResetLastError();
28559: if (mem_base != xmlMemBlocks()) {
28560: printf("Leak of %d blocks found in xmlParserInputBufferCreateFilename",
28561: xmlMemBlocks() - mem_base);
28562: test_ret++;
28563: printf(" %d", n_URI);
28564: printf(" %d", n_enc);
28565: printf("\n");
28566: }
28567: }
28568: }
28569: function_tests++;
28570:
28571: return(test_ret);
28572: }
28573:
28574:
28575: static int
28576: test_xmlParserInputBufferCreateMem(void) {
28577: int test_ret = 0;
28578:
28579: int mem_base;
28580: xmlParserInputBufferPtr ret_val;
28581: char * mem; /* the memory input */
28582: int n_mem;
28583: int size; /* the length of the memory block */
28584: int n_size;
28585: xmlCharEncoding enc; /* the charset encoding if known */
28586: int n_enc;
28587:
28588: for (n_mem = 0;n_mem < gen_nb_const_char_ptr;n_mem++) {
28589: for (n_size = 0;n_size < gen_nb_int;n_size++) {
28590: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
28591: mem_base = xmlMemBlocks();
28592: mem = gen_const_char_ptr(n_mem, 0);
28593: size = gen_int(n_size, 1);
28594: enc = gen_xmlCharEncoding(n_enc, 2);
28595:
28596: ret_val = xmlParserInputBufferCreateMem((const char *)mem, size, enc);
28597: desret_xmlParserInputBufferPtr(ret_val);
28598: call_tests++;
28599: des_const_char_ptr(n_mem, (const char *)mem, 0);
28600: des_int(n_size, size, 1);
28601: des_xmlCharEncoding(n_enc, enc, 2);
28602: xmlResetLastError();
28603: if (mem_base != xmlMemBlocks()) {
28604: printf("Leak of %d blocks found in xmlParserInputBufferCreateMem",
28605: xmlMemBlocks() - mem_base);
28606: test_ret++;
28607: printf(" %d", n_mem);
28608: printf(" %d", n_size);
28609: printf(" %d", n_enc);
28610: printf("\n");
28611: }
28612: }
28613: }
28614: }
28615: function_tests++;
28616:
28617: return(test_ret);
28618: }
28619:
28620:
28621: static int
28622: test_xmlParserInputBufferCreateStatic(void) {
28623: int test_ret = 0;
28624:
28625: int mem_base;
28626: xmlParserInputBufferPtr ret_val;
28627: char * mem; /* the memory input */
28628: int n_mem;
28629: int size; /* the length of the memory block */
28630: int n_size;
28631: xmlCharEncoding enc; /* the charset encoding if known */
28632: int n_enc;
28633:
28634: for (n_mem = 0;n_mem < gen_nb_const_char_ptr;n_mem++) {
28635: for (n_size = 0;n_size < gen_nb_int;n_size++) {
28636: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
28637: mem_base = xmlMemBlocks();
28638: mem = gen_const_char_ptr(n_mem, 0);
28639: size = gen_int(n_size, 1);
28640: enc = gen_xmlCharEncoding(n_enc, 2);
28641:
28642: ret_val = xmlParserInputBufferCreateStatic((const char *)mem, size, enc);
28643: desret_xmlParserInputBufferPtr(ret_val);
28644: call_tests++;
28645: des_const_char_ptr(n_mem, (const char *)mem, 0);
28646: des_int(n_size, size, 1);
28647: des_xmlCharEncoding(n_enc, enc, 2);
28648: xmlResetLastError();
28649: if (mem_base != xmlMemBlocks()) {
28650: printf("Leak of %d blocks found in xmlParserInputBufferCreateStatic",
28651: xmlMemBlocks() - mem_base);
28652: test_ret++;
28653: printf(" %d", n_mem);
28654: printf(" %d", n_size);
28655: printf(" %d", n_enc);
28656: printf("\n");
28657: }
28658: }
28659: }
28660: }
28661: function_tests++;
28662:
28663: return(test_ret);
28664: }
28665:
28666:
28667: static int
28668: test_xmlParserInputBufferGrow(void) {
28669: int test_ret = 0;
28670:
28671: int mem_base;
28672: int ret_val;
28673: xmlParserInputBufferPtr in; /* a buffered parser input */
28674: int n_in;
28675: int len; /* indicative value of the amount of chars to read */
28676: int n_len;
28677:
28678: for (n_in = 0;n_in < gen_nb_xmlParserInputBufferPtr;n_in++) {
28679: for (n_len = 0;n_len < gen_nb_int;n_len++) {
28680: mem_base = xmlMemBlocks();
28681: in = gen_xmlParserInputBufferPtr(n_in, 0);
28682: len = gen_int(n_len, 1);
28683:
28684: ret_val = xmlParserInputBufferGrow(in, len);
28685: desret_int(ret_val);
28686: call_tests++;
28687: des_xmlParserInputBufferPtr(n_in, in, 0);
28688: des_int(n_len, len, 1);
28689: xmlResetLastError();
28690: if (mem_base != xmlMemBlocks()) {
28691: printf("Leak of %d blocks found in xmlParserInputBufferGrow",
28692: xmlMemBlocks() - mem_base);
28693: test_ret++;
28694: printf(" %d", n_in);
28695: printf(" %d", n_len);
28696: printf("\n");
28697: }
28698: }
28699: }
28700: function_tests++;
28701:
28702: return(test_ret);
28703: }
28704:
28705:
28706: static int
28707: test_xmlParserInputBufferPush(void) {
28708: int test_ret = 0;
28709:
28710: int mem_base;
28711: int ret_val;
28712: xmlParserInputBufferPtr in; /* a buffered parser input */
28713: int n_in;
28714: int len; /* the size in bytes of the array. */
28715: int n_len;
28716: char * buf; /* an char array */
28717: int n_buf;
28718:
28719: for (n_in = 0;n_in < gen_nb_xmlParserInputBufferPtr;n_in++) {
28720: for (n_len = 0;n_len < gen_nb_int;n_len++) {
28721: for (n_buf = 0;n_buf < gen_nb_const_char_ptr;n_buf++) {
28722: mem_base = xmlMemBlocks();
28723: in = gen_xmlParserInputBufferPtr(n_in, 0);
28724: len = gen_int(n_len, 1);
28725: buf = gen_const_char_ptr(n_buf, 2);
28726:
28727: ret_val = xmlParserInputBufferPush(in, len, (const char *)buf);
28728: desret_int(ret_val);
28729: call_tests++;
28730: des_xmlParserInputBufferPtr(n_in, in, 0);
28731: des_int(n_len, len, 1);
28732: des_const_char_ptr(n_buf, (const char *)buf, 2);
28733: xmlResetLastError();
28734: if (mem_base != xmlMemBlocks()) {
28735: printf("Leak of %d blocks found in xmlParserInputBufferPush",
28736: xmlMemBlocks() - mem_base);
28737: test_ret++;
28738: printf(" %d", n_in);
28739: printf(" %d", n_len);
28740: printf(" %d", n_buf);
28741: printf("\n");
28742: }
28743: }
28744: }
28745: }
28746: function_tests++;
28747:
28748: return(test_ret);
28749: }
28750:
28751:
28752: static int
28753: test_xmlParserInputBufferRead(void) {
28754: int test_ret = 0;
28755:
28756: int mem_base;
28757: int ret_val;
28758: xmlParserInputBufferPtr in; /* a buffered parser input */
28759: int n_in;
28760: int len; /* indicative value of the amount of chars to read */
28761: int n_len;
28762:
28763: for (n_in = 0;n_in < gen_nb_xmlParserInputBufferPtr;n_in++) {
28764: for (n_len = 0;n_len < gen_nb_int;n_len++) {
28765: mem_base = xmlMemBlocks();
28766: in = gen_xmlParserInputBufferPtr(n_in, 0);
28767: len = gen_int(n_len, 1);
28768:
28769: ret_val = xmlParserInputBufferRead(in, len);
28770: desret_int(ret_val);
28771: call_tests++;
28772: des_xmlParserInputBufferPtr(n_in, in, 0);
28773: des_int(n_len, len, 1);
28774: xmlResetLastError();
28775: if (mem_base != xmlMemBlocks()) {
28776: printf("Leak of %d blocks found in xmlParserInputBufferRead",
28777: xmlMemBlocks() - mem_base);
28778: test_ret++;
28779: printf(" %d", n_in);
28780: printf(" %d", n_len);
28781: printf("\n");
28782: }
28783: }
28784: }
28785: function_tests++;
28786:
28787: return(test_ret);
28788: }
28789:
28790:
28791: static int
28792: test_xmlPopInputCallbacks(void) {
28793: int test_ret = 0;
28794:
28795: int mem_base;
28796: int ret_val;
28797:
28798: mem_base = xmlMemBlocks();
28799:
28800: ret_val = xmlPopInputCallbacks();
28801: desret_int(ret_val);
28802: call_tests++;
28803: xmlResetLastError();
28804: if (mem_base != xmlMemBlocks()) {
28805: printf("Leak of %d blocks found in xmlPopInputCallbacks",
28806: xmlMemBlocks() - mem_base);
28807: test_ret++;
28808: printf("\n");
28809: }
28810: function_tests++;
28811:
28812: return(test_ret);
28813: }
28814:
28815:
28816: static int
28817: test_xmlRegisterDefaultInputCallbacks(void) {
28818: int test_ret = 0;
28819:
28820: int mem_base;
28821:
28822: mem_base = xmlMemBlocks();
28823:
28824: xmlRegisterDefaultInputCallbacks();
28825: call_tests++;
28826: xmlResetLastError();
28827: if (mem_base != xmlMemBlocks()) {
28828: printf("Leak of %d blocks found in xmlRegisterDefaultInputCallbacks",
28829: xmlMemBlocks() - mem_base);
28830: test_ret++;
28831: printf("\n");
28832: }
28833: function_tests++;
28834:
28835: return(test_ret);
28836: }
28837:
28838:
28839: static int
28840: test_xmlRegisterDefaultOutputCallbacks(void) {
28841: int test_ret = 0;
28842:
28843: #if defined(LIBXML_OUTPUT_ENABLED)
28844: int mem_base;
28845:
28846: mem_base = xmlMemBlocks();
28847:
28848: xmlRegisterDefaultOutputCallbacks();
28849: call_tests++;
28850: xmlResetLastError();
28851: if (mem_base != xmlMemBlocks()) {
28852: printf("Leak of %d blocks found in xmlRegisterDefaultOutputCallbacks",
28853: xmlMemBlocks() - mem_base);
28854: test_ret++;
28855: printf("\n");
28856: }
28857: function_tests++;
28858: #endif
28859:
28860: return(test_ret);
28861: }
28862:
28863:
28864: static int
28865: test_xmlRegisterHTTPPostCallbacks(void) {
28866: int test_ret = 0;
28867:
28868: #if defined(LIBXML_OUTPUT_ENABLED) && defined(LIBXML_HTTP_ENABLED)
28869: int mem_base;
28870:
28871: mem_base = xmlMemBlocks();
28872:
28873: xmlRegisterHTTPPostCallbacks();
28874: call_tests++;
28875: xmlResetLastError();
28876: if (mem_base != xmlMemBlocks()) {
28877: printf("Leak of %d blocks found in xmlRegisterHTTPPostCallbacks",
28878: xmlMemBlocks() - mem_base);
28879: test_ret++;
28880: printf("\n");
28881: }
28882: function_tests++;
28883: #endif
28884:
28885: return(test_ret);
28886: }
28887:
28888: static int
28889: test_xmlIO(void) {
28890: int test_ret = 0;
28891:
28892: if (quiet == 0) printf("Testing xmlIO : 39 of 48 functions ...\n");
28893: test_ret += test_xmlAllocOutputBuffer();
28894: test_ret += test_xmlAllocParserInputBuffer();
28895: test_ret += test_xmlCheckFilename();
28896: test_ret += test_xmlCheckHTTPInput();
28897: test_ret += test_xmlCleanupInputCallbacks();
28898: test_ret += test_xmlCleanupOutputCallbacks();
28899: test_ret += test_xmlFileClose();
28900: test_ret += test_xmlFileMatch();
28901: test_ret += test_xmlFileOpen();
28902: test_ret += test_xmlFileRead();
28903: test_ret += test_xmlIOFTPClose();
28904: test_ret += test_xmlIOFTPMatch();
28905: test_ret += test_xmlIOFTPOpen();
28906: test_ret += test_xmlIOFTPRead();
28907: test_ret += test_xmlIOHTTPClose();
28908: test_ret += test_xmlIOHTTPMatch();
28909: test_ret += test_xmlIOHTTPOpen();
28910: test_ret += test_xmlIOHTTPRead();
28911: test_ret += test_xmlNoNetExternalEntityLoader();
28912: test_ret += test_xmlNormalizeWindowsPath();
28913: test_ret += test_xmlOutputBufferCreateBuffer();
28914: test_ret += test_xmlOutputBufferCreateFd();
28915: test_ret += test_xmlOutputBufferCreateFile();
28916: test_ret += test_xmlOutputBufferCreateFilename();
28917: test_ret += test_xmlOutputBufferFlush();
28918: test_ret += test_xmlOutputBufferWrite();
28919: test_ret += test_xmlOutputBufferWriteEscape();
28920: test_ret += test_xmlOutputBufferWriteString();
28921: test_ret += test_xmlParserGetDirectory();
28922: test_ret += test_xmlParserInputBufferCreateFd();
28923: test_ret += test_xmlParserInputBufferCreateFile();
28924: test_ret += test_xmlParserInputBufferCreateFilename();
28925: test_ret += test_xmlParserInputBufferCreateMem();
28926: test_ret += test_xmlParserInputBufferCreateStatic();
28927: test_ret += test_xmlParserInputBufferGrow();
28928: test_ret += test_xmlParserInputBufferPush();
28929: test_ret += test_xmlParserInputBufferRead();
28930: test_ret += test_xmlPopInputCallbacks();
28931: test_ret += test_xmlRegisterDefaultInputCallbacks();
28932: test_ret += test_xmlRegisterDefaultOutputCallbacks();
28933: test_ret += test_xmlRegisterHTTPPostCallbacks();
28934:
28935: if (test_ret != 0)
28936: printf("Module xmlIO: %d errors\n", test_ret);
28937: return(test_ret);
28938: }
28939: #ifdef LIBXML_AUTOMATA_ENABLED
28940:
28941: #define gen_nb_xmlAutomataPtr 1
28942: static xmlAutomataPtr gen_xmlAutomataPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
28943: return(NULL);
28944: }
28945: static void des_xmlAutomataPtr(int no ATTRIBUTE_UNUSED, xmlAutomataPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
28946: }
28947: #endif
28948:
28949:
28950: static int
28951: test_xmlAutomataCompile(void) {
28952: int test_ret = 0;
28953:
28954:
28955: /* missing type support */
28956: return(test_ret);
28957: }
28958:
28959:
28960: static int
28961: test_xmlAutomataGetInitState(void) {
28962: int test_ret = 0;
28963:
28964:
28965: /* missing type support */
28966: return(test_ret);
28967: }
28968:
28969:
28970: static int
28971: test_xmlAutomataIsDeterminist(void) {
28972: int test_ret = 0;
28973:
28974: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_AUTOMATA_ENABLED)
28975: int mem_base;
28976: int ret_val;
28977: xmlAutomataPtr am; /* an automata */
28978: int n_am;
28979:
28980: for (n_am = 0;n_am < gen_nb_xmlAutomataPtr;n_am++) {
28981: mem_base = xmlMemBlocks();
28982: am = gen_xmlAutomataPtr(n_am, 0);
28983:
28984: ret_val = xmlAutomataIsDeterminist(am);
28985: desret_int(ret_val);
28986: call_tests++;
28987: des_xmlAutomataPtr(n_am, am, 0);
28988: xmlResetLastError();
28989: if (mem_base != xmlMemBlocks()) {
28990: printf("Leak of %d blocks found in xmlAutomataIsDeterminist",
28991: xmlMemBlocks() - mem_base);
28992: test_ret++;
28993: printf(" %d", n_am);
28994: printf("\n");
28995: }
28996: }
28997: function_tests++;
28998: #endif
28999:
29000: return(test_ret);
29001: }
29002:
29003: #ifdef LIBXML_AUTOMATA_ENABLED
29004:
29005: #define gen_nb_xmlAutomataStatePtr 1
29006: static xmlAutomataStatePtr gen_xmlAutomataStatePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29007: return(NULL);
29008: }
29009: static void des_xmlAutomataStatePtr(int no ATTRIBUTE_UNUSED, xmlAutomataStatePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29010: }
29011: #endif
29012:
29013:
29014: static int
29015: test_xmlAutomataNewAllTrans(void) {
29016: int test_ret = 0;
29017:
29018:
29019: /* missing type support */
29020: return(test_ret);
29021: }
29022:
29023:
29024: static int
29025: test_xmlAutomataNewCountTrans(void) {
29026: int test_ret = 0;
29027:
29028:
29029: /* missing type support */
29030: return(test_ret);
29031: }
29032:
29033:
29034: static int
29035: test_xmlAutomataNewCountTrans2(void) {
29036: int test_ret = 0;
29037:
29038:
29039: /* missing type support */
29040: return(test_ret);
29041: }
29042:
29043:
29044: static int
29045: test_xmlAutomataNewCountedTrans(void) {
29046: int test_ret = 0;
29047:
29048:
29049: /* missing type support */
29050: return(test_ret);
29051: }
29052:
29053:
29054: static int
29055: test_xmlAutomataNewCounter(void) {
29056: int test_ret = 0;
29057:
29058: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_AUTOMATA_ENABLED)
29059: int mem_base;
29060: int ret_val;
29061: xmlAutomataPtr am; /* an automata */
29062: int n_am;
29063: int min; /* the minimal value on the counter */
29064: int n_min;
29065: int max; /* the maximal value on the counter */
29066: int n_max;
29067:
29068: for (n_am = 0;n_am < gen_nb_xmlAutomataPtr;n_am++) {
29069: for (n_min = 0;n_min < gen_nb_int;n_min++) {
29070: for (n_max = 0;n_max < gen_nb_int;n_max++) {
29071: mem_base = xmlMemBlocks();
29072: am = gen_xmlAutomataPtr(n_am, 0);
29073: min = gen_int(n_min, 1);
29074: max = gen_int(n_max, 2);
29075:
29076: ret_val = xmlAutomataNewCounter(am, min, max);
29077: desret_int(ret_val);
29078: call_tests++;
29079: des_xmlAutomataPtr(n_am, am, 0);
29080: des_int(n_min, min, 1);
29081: des_int(n_max, max, 2);
29082: xmlResetLastError();
29083: if (mem_base != xmlMemBlocks()) {
29084: printf("Leak of %d blocks found in xmlAutomataNewCounter",
29085: xmlMemBlocks() - mem_base);
29086: test_ret++;
29087: printf(" %d", n_am);
29088: printf(" %d", n_min);
29089: printf(" %d", n_max);
29090: printf("\n");
29091: }
29092: }
29093: }
29094: }
29095: function_tests++;
29096: #endif
29097:
29098: return(test_ret);
29099: }
29100:
29101:
29102: static int
29103: test_xmlAutomataNewCounterTrans(void) {
29104: int test_ret = 0;
29105:
29106:
29107: /* missing type support */
29108: return(test_ret);
29109: }
29110:
29111:
29112: static int
29113: test_xmlAutomataNewEpsilon(void) {
29114: int test_ret = 0;
29115:
29116:
29117: /* missing type support */
29118: return(test_ret);
29119: }
29120:
29121:
29122: static int
29123: test_xmlAutomataNewNegTrans(void) {
29124: int test_ret = 0;
29125:
29126:
29127: /* missing type support */
29128: return(test_ret);
29129: }
29130:
29131:
29132: static int
29133: test_xmlAutomataNewOnceTrans(void) {
29134: int test_ret = 0;
29135:
29136:
29137: /* missing type support */
29138: return(test_ret);
29139: }
29140:
29141:
29142: static int
29143: test_xmlAutomataNewOnceTrans2(void) {
29144: int test_ret = 0;
29145:
29146:
29147: /* missing type support */
29148: return(test_ret);
29149: }
29150:
29151:
29152: static int
29153: test_xmlAutomataNewState(void) {
29154: int test_ret = 0;
29155:
29156:
29157: /* missing type support */
29158: return(test_ret);
29159: }
29160:
29161:
29162: static int
29163: test_xmlAutomataNewTransition(void) {
29164: int test_ret = 0;
29165:
29166:
29167: /* missing type support */
29168: return(test_ret);
29169: }
29170:
29171:
29172: static int
29173: test_xmlAutomataNewTransition2(void) {
29174: int test_ret = 0;
29175:
29176:
29177: /* missing type support */
29178: return(test_ret);
29179: }
29180:
29181:
29182: static int
29183: test_xmlAutomataSetFinalState(void) {
29184: int test_ret = 0;
29185:
29186: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_AUTOMATA_ENABLED)
29187: int mem_base;
29188: int ret_val;
29189: xmlAutomataPtr am; /* an automata */
29190: int n_am;
29191: xmlAutomataStatePtr state; /* a state in this automata */
29192: int n_state;
29193:
29194: for (n_am = 0;n_am < gen_nb_xmlAutomataPtr;n_am++) {
29195: for (n_state = 0;n_state < gen_nb_xmlAutomataStatePtr;n_state++) {
29196: mem_base = xmlMemBlocks();
29197: am = gen_xmlAutomataPtr(n_am, 0);
29198: state = gen_xmlAutomataStatePtr(n_state, 1);
29199:
29200: ret_val = xmlAutomataSetFinalState(am, state);
29201: desret_int(ret_val);
29202: call_tests++;
29203: des_xmlAutomataPtr(n_am, am, 0);
29204: des_xmlAutomataStatePtr(n_state, state, 1);
29205: xmlResetLastError();
29206: if (mem_base != xmlMemBlocks()) {
29207: printf("Leak of %d blocks found in xmlAutomataSetFinalState",
29208: xmlMemBlocks() - mem_base);
29209: test_ret++;
29210: printf(" %d", n_am);
29211: printf(" %d", n_state);
29212: printf("\n");
29213: }
29214: }
29215: }
29216: function_tests++;
29217: #endif
29218:
29219: return(test_ret);
29220: }
29221:
29222:
29223: static int
29224: test_xmlNewAutomata(void) {
29225: int test_ret = 0;
29226:
29227:
29228: /* missing type support */
29229: return(test_ret);
29230: }
29231:
29232: static int
29233: test_xmlautomata(void) {
29234: int test_ret = 0;
29235:
29236: if (quiet == 0) printf("Testing xmlautomata : 3 of 19 functions ...\n");
29237: test_ret += test_xmlAutomataCompile();
29238: test_ret += test_xmlAutomataGetInitState();
29239: test_ret += test_xmlAutomataIsDeterminist();
29240: test_ret += test_xmlAutomataNewAllTrans();
29241: test_ret += test_xmlAutomataNewCountTrans();
29242: test_ret += test_xmlAutomataNewCountTrans2();
29243: test_ret += test_xmlAutomataNewCountedTrans();
29244: test_ret += test_xmlAutomataNewCounter();
29245: test_ret += test_xmlAutomataNewCounterTrans();
29246: test_ret += test_xmlAutomataNewEpsilon();
29247: test_ret += test_xmlAutomataNewNegTrans();
29248: test_ret += test_xmlAutomataNewOnceTrans();
29249: test_ret += test_xmlAutomataNewOnceTrans2();
29250: test_ret += test_xmlAutomataNewState();
29251: test_ret += test_xmlAutomataNewTransition();
29252: test_ret += test_xmlAutomataNewTransition2();
29253: test_ret += test_xmlAutomataSetFinalState();
29254: test_ret += test_xmlNewAutomata();
29255:
29256: if (test_ret != 0)
29257: printf("Module xmlautomata: %d errors\n", test_ret);
29258: return(test_ret);
29259: }
29260:
29261: #define gen_nb_xmlGenericErrorFunc_ptr 1
29262: static xmlGenericErrorFunc * gen_xmlGenericErrorFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29263: return(NULL);
29264: }
29265: static void des_xmlGenericErrorFunc_ptr(int no ATTRIBUTE_UNUSED, xmlGenericErrorFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29266: }
29267:
29268: static int
29269: test_initGenericErrorDefaultFunc(void) {
29270: int test_ret = 0;
29271:
29272: int mem_base;
29273: xmlGenericErrorFunc * handler; /* the handler */
29274: int n_handler;
29275:
29276: for (n_handler = 0;n_handler < gen_nb_xmlGenericErrorFunc_ptr;n_handler++) {
29277: mem_base = xmlMemBlocks();
29278: handler = gen_xmlGenericErrorFunc_ptr(n_handler, 0);
29279:
29280: initGenericErrorDefaultFunc(handler);
29281: call_tests++;
29282: des_xmlGenericErrorFunc_ptr(n_handler, handler, 0);
29283: xmlResetLastError();
29284: if (mem_base != xmlMemBlocks()) {
29285: printf("Leak of %d blocks found in initGenericErrorDefaultFunc",
29286: xmlMemBlocks() - mem_base);
29287: test_ret++;
29288: printf(" %d", n_handler);
29289: printf("\n");
29290: }
29291: }
29292: function_tests++;
29293:
29294: return(test_ret);
29295: }
29296:
29297:
29298: #define gen_nb_xmlErrorPtr 1
29299: static xmlErrorPtr gen_xmlErrorPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29300: return(NULL);
29301: }
29302: static void des_xmlErrorPtr(int no ATTRIBUTE_UNUSED, xmlErrorPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29303: }
29304:
29305: static int
29306: test_xmlCopyError(void) {
29307: int test_ret = 0;
29308:
29309: int mem_base;
29310: int ret_val;
29311: xmlErrorPtr from; /* a source error */
29312: int n_from;
29313: xmlErrorPtr to; /* a target error */
29314: int n_to;
29315:
29316: for (n_from = 0;n_from < gen_nb_xmlErrorPtr;n_from++) {
29317: for (n_to = 0;n_to < gen_nb_xmlErrorPtr;n_to++) {
29318: mem_base = xmlMemBlocks();
29319: from = gen_xmlErrorPtr(n_from, 0);
29320: to = gen_xmlErrorPtr(n_to, 1);
29321:
29322: ret_val = xmlCopyError(from, to);
29323: desret_int(ret_val);
29324: call_tests++;
29325: des_xmlErrorPtr(n_from, from, 0);
29326: des_xmlErrorPtr(n_to, to, 1);
29327: xmlResetLastError();
29328: if (mem_base != xmlMemBlocks()) {
29329: printf("Leak of %d blocks found in xmlCopyError",
29330: xmlMemBlocks() - mem_base);
29331: test_ret++;
29332: printf(" %d", n_from);
29333: printf(" %d", n_to);
29334: printf("\n");
29335: }
29336: }
29337: }
29338: function_tests++;
29339:
29340: return(test_ret);
29341: }
29342:
29343:
29344: static int
29345: test_xmlCtxtGetLastError(void) {
29346: int test_ret = 0;
29347:
29348:
29349: /* missing type support */
29350: return(test_ret);
29351: }
29352:
29353:
29354: static int
29355: test_xmlCtxtResetLastError(void) {
29356: int test_ret = 0;
29357:
29358: int mem_base;
29359: void * ctx; /* an XML parser context */
29360: int n_ctx;
29361:
29362: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
29363: mem_base = xmlMemBlocks();
29364: ctx = gen_void_ptr(n_ctx, 0);
29365:
29366: xmlCtxtResetLastError(ctx);
29367: call_tests++;
29368: des_void_ptr(n_ctx, ctx, 0);
29369: xmlResetLastError();
29370: if (mem_base != xmlMemBlocks()) {
29371: printf("Leak of %d blocks found in xmlCtxtResetLastError",
29372: xmlMemBlocks() - mem_base);
29373: test_ret++;
29374: printf(" %d", n_ctx);
29375: printf("\n");
29376: }
29377: }
29378: function_tests++;
29379:
29380: return(test_ret);
29381: }
29382:
29383:
29384: static int
29385: test_xmlGetLastError(void) {
29386: int test_ret = 0;
29387:
29388:
29389: /* missing type support */
29390: return(test_ret);
29391: }
29392:
29393:
29394: static int
29395: test_xmlParserError(void) {
29396: int test_ret = 0;
29397:
29398:
29399: /* missing type support */
29400: return(test_ret);
29401: }
29402:
29403:
29404: static int
29405: test_xmlParserPrintFileContext(void) {
29406: int test_ret = 0;
29407:
29408: int mem_base;
29409: xmlParserInputPtr input; /* an xmlParserInputPtr input */
29410: int n_input;
29411:
29412: for (n_input = 0;n_input < gen_nb_xmlParserInputPtr;n_input++) {
29413: mem_base = xmlMemBlocks();
29414: input = gen_xmlParserInputPtr(n_input, 0);
29415:
29416: xmlParserPrintFileContext(input);
29417: call_tests++;
29418: des_xmlParserInputPtr(n_input, input, 0);
29419: xmlResetLastError();
29420: if (mem_base != xmlMemBlocks()) {
29421: printf("Leak of %d blocks found in xmlParserPrintFileContext",
29422: xmlMemBlocks() - mem_base);
29423: test_ret++;
29424: printf(" %d", n_input);
29425: printf("\n");
29426: }
29427: }
29428: function_tests++;
29429:
29430: return(test_ret);
29431: }
29432:
29433:
29434: static int
29435: test_xmlParserPrintFileInfo(void) {
29436: int test_ret = 0;
29437:
29438: int mem_base;
29439: xmlParserInputPtr input; /* an xmlParserInputPtr input */
29440: int n_input;
29441:
29442: for (n_input = 0;n_input < gen_nb_xmlParserInputPtr;n_input++) {
29443: mem_base = xmlMemBlocks();
29444: input = gen_xmlParserInputPtr(n_input, 0);
29445:
29446: xmlParserPrintFileInfo(input);
29447: call_tests++;
29448: des_xmlParserInputPtr(n_input, input, 0);
29449: xmlResetLastError();
29450: if (mem_base != xmlMemBlocks()) {
29451: printf("Leak of %d blocks found in xmlParserPrintFileInfo",
29452: xmlMemBlocks() - mem_base);
29453: test_ret++;
29454: printf(" %d", n_input);
29455: printf("\n");
29456: }
29457: }
29458: function_tests++;
29459:
29460: return(test_ret);
29461: }
29462:
29463:
29464: static int
29465: test_xmlParserValidityError(void) {
29466: int test_ret = 0;
29467:
29468:
29469: /* missing type support */
29470: return(test_ret);
29471: }
29472:
29473:
29474: static int
29475: test_xmlParserValidityWarning(void) {
29476: int test_ret = 0;
29477:
29478:
29479: /* missing type support */
29480: return(test_ret);
29481: }
29482:
29483:
29484: static int
29485: test_xmlParserWarning(void) {
29486: int test_ret = 0;
29487:
29488:
29489: /* missing type support */
29490: return(test_ret);
29491: }
29492:
29493:
29494: static int
29495: test_xmlResetError(void) {
29496: int test_ret = 0;
29497:
29498: int mem_base;
29499: xmlErrorPtr err; /* pointer to the error. */
29500: int n_err;
29501:
29502: for (n_err = 0;n_err < gen_nb_xmlErrorPtr;n_err++) {
29503: mem_base = xmlMemBlocks();
29504: err = gen_xmlErrorPtr(n_err, 0);
29505:
29506: xmlResetError(err);
29507: call_tests++;
29508: des_xmlErrorPtr(n_err, err, 0);
29509: xmlResetLastError();
29510: if (mem_base != xmlMemBlocks()) {
29511: printf("Leak of %d blocks found in xmlResetError",
29512: xmlMemBlocks() - mem_base);
29513: test_ret++;
29514: printf(" %d", n_err);
29515: printf("\n");
29516: }
29517: }
29518: function_tests++;
29519:
29520: return(test_ret);
29521: }
29522:
29523:
29524: static int
29525: test_xmlResetLastError(void) {
29526: int test_ret = 0;
29527:
29528:
29529:
29530: xmlResetLastError();
29531: call_tests++;
29532: xmlResetLastError();
29533: function_tests++;
29534:
29535: return(test_ret);
29536: }
29537:
29538:
29539: static int
29540: test_xmlSetGenericErrorFunc(void) {
29541: int test_ret = 0;
29542:
29543:
29544: /* missing type support */
29545: return(test_ret);
29546: }
29547:
29548:
29549: static int
29550: test_xmlSetStructuredErrorFunc(void) {
29551: int test_ret = 0;
29552:
29553:
29554: /* missing type support */
29555: return(test_ret);
29556: }
29557:
29558: static int
29559: test_xmlerror(void) {
29560: int test_ret = 0;
29561:
29562: if (quiet == 0) printf("Testing xmlerror : 7 of 15 functions ...\n");
29563: test_ret += test_initGenericErrorDefaultFunc();
29564: test_ret += test_xmlCopyError();
29565: test_ret += test_xmlCtxtGetLastError();
29566: test_ret += test_xmlCtxtResetLastError();
29567: test_ret += test_xmlGetLastError();
29568: test_ret += test_xmlParserError();
29569: test_ret += test_xmlParserPrintFileContext();
29570: test_ret += test_xmlParserPrintFileInfo();
29571: test_ret += test_xmlParserValidityError();
29572: test_ret += test_xmlParserValidityWarning();
29573: test_ret += test_xmlParserWarning();
29574: test_ret += test_xmlResetError();
29575: test_ret += test_xmlResetLastError();
29576: test_ret += test_xmlSetGenericErrorFunc();
29577: test_ret += test_xmlSetStructuredErrorFunc();
29578:
29579: if (test_ret != 0)
29580: printf("Module xmlerror: %d errors\n", test_ret);
29581: return(test_ret);
29582: }
29583: #ifdef LIBXML_MODULES_ENABLED
29584:
29585: #define gen_nb_xmlModulePtr 1
29586: static xmlModulePtr gen_xmlModulePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29587: return(NULL);
29588: }
29589: static void des_xmlModulePtr(int no ATTRIBUTE_UNUSED, xmlModulePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29590: }
29591: #endif
29592:
29593:
29594: static int
29595: test_xmlModuleClose(void) {
29596: int test_ret = 0;
29597:
29598: #if defined(LIBXML_MODULES_ENABLED)
29599: int mem_base;
29600: int ret_val;
29601: xmlModulePtr module; /* the module handle */
29602: int n_module;
29603:
29604: for (n_module = 0;n_module < gen_nb_xmlModulePtr;n_module++) {
29605: mem_base = xmlMemBlocks();
29606: module = gen_xmlModulePtr(n_module, 0);
29607:
29608: ret_val = xmlModuleClose(module);
29609: desret_int(ret_val);
29610: call_tests++;
29611: des_xmlModulePtr(n_module, module, 0);
29612: xmlResetLastError();
29613: if (mem_base != xmlMemBlocks()) {
29614: printf("Leak of %d blocks found in xmlModuleClose",
29615: xmlMemBlocks() - mem_base);
29616: test_ret++;
29617: printf(" %d", n_module);
29618: printf("\n");
29619: }
29620: }
29621: function_tests++;
29622: #endif
29623:
29624: return(test_ret);
29625: }
29626:
29627:
29628: static int
29629: test_xmlModuleOpen(void) {
29630: int test_ret = 0;
29631:
29632:
29633: /* missing type support */
29634: return(test_ret);
29635: }
29636:
29637:
29638: static int
29639: test_xmlModuleSymbol(void) {
29640: int test_ret = 0;
29641:
29642: #if defined(LIBXML_MODULES_ENABLED)
29643: int mem_base;
29644: int ret_val;
29645: xmlModulePtr module; /* the module */
29646: int n_module;
29647: char * name; /* the name of the symbol */
29648: int n_name;
29649: void ** symbol; /* the resulting symbol address */
29650: int n_symbol;
29651:
29652: for (n_module = 0;n_module < gen_nb_xmlModulePtr;n_module++) {
29653: for (n_name = 0;n_name < gen_nb_const_char_ptr;n_name++) {
29654: for (n_symbol = 0;n_symbol < gen_nb_void_ptr_ptr;n_symbol++) {
29655: mem_base = xmlMemBlocks();
29656: module = gen_xmlModulePtr(n_module, 0);
29657: name = gen_const_char_ptr(n_name, 1);
29658: symbol = gen_void_ptr_ptr(n_symbol, 2);
29659:
29660: ret_val = xmlModuleSymbol(module, (const char *)name, symbol);
29661: desret_int(ret_val);
29662: call_tests++;
29663: des_xmlModulePtr(n_module, module, 0);
29664: des_const_char_ptr(n_name, (const char *)name, 1);
29665: des_void_ptr_ptr(n_symbol, symbol, 2);
29666: xmlResetLastError();
29667: if (mem_base != xmlMemBlocks()) {
29668: printf("Leak of %d blocks found in xmlModuleSymbol",
29669: xmlMemBlocks() - mem_base);
29670: test_ret++;
29671: printf(" %d", n_module);
29672: printf(" %d", n_name);
29673: printf(" %d", n_symbol);
29674: printf("\n");
29675: }
29676: }
29677: }
29678: }
29679: function_tests++;
29680: #endif
29681:
29682: return(test_ret);
29683: }
29684:
29685: static int
29686: test_xmlmodule(void) {
29687: int test_ret = 0;
29688:
29689: if (quiet == 0) printf("Testing xmlmodule : 2 of 4 functions ...\n");
29690: test_ret += test_xmlModuleClose();
29691: test_ret += test_xmlModuleOpen();
29692: test_ret += test_xmlModuleSymbol();
29693:
29694: if (test_ret != 0)
29695: printf("Module xmlmodule: %d errors\n", test_ret);
29696: return(test_ret);
29697: }
29698:
29699: static int
29700: test_xmlNewTextReader(void) {
29701: int test_ret = 0;
29702:
29703: #if defined(LIBXML_READER_ENABLED)
29704: int mem_base;
29705: xmlTextReaderPtr ret_val;
29706: xmlParserInputBufferPtr input; /* the xmlParserInputBufferPtr used to read data */
29707: int n_input;
29708: const char * URI; /* the URI information for the source if available */
29709: int n_URI;
29710:
29711: for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) {
29712: for (n_URI = 0;n_URI < gen_nb_filepath;n_URI++) {
29713: mem_base = xmlMemBlocks();
29714: input = gen_xmlParserInputBufferPtr(n_input, 0);
29715: URI = gen_filepath(n_URI, 1);
29716:
29717: ret_val = xmlNewTextReader(input, URI);
29718: desret_xmlTextReaderPtr(ret_val);
29719: call_tests++;
29720: des_xmlParserInputBufferPtr(n_input, input, 0);
29721: des_filepath(n_URI, URI, 1);
29722: xmlResetLastError();
29723: if (mem_base != xmlMemBlocks()) {
29724: printf("Leak of %d blocks found in xmlNewTextReader",
29725: xmlMemBlocks() - mem_base);
29726: test_ret++;
29727: printf(" %d", n_input);
29728: printf(" %d", n_URI);
29729: printf("\n");
29730: }
29731: }
29732: }
29733: function_tests++;
29734: #endif
29735:
29736: return(test_ret);
29737: }
29738:
29739:
29740: static int
29741: test_xmlNewTextReaderFilename(void) {
29742: int test_ret = 0;
29743:
29744: #if defined(LIBXML_READER_ENABLED)
29745: int mem_base;
29746: xmlTextReaderPtr ret_val;
29747: const char * URI; /* the URI of the resource to process */
29748: int n_URI;
29749:
29750: for (n_URI = 0;n_URI < gen_nb_filepath;n_URI++) {
29751: mem_base = xmlMemBlocks();
29752: URI = gen_filepath(n_URI, 0);
29753:
29754: ret_val = xmlNewTextReaderFilename(URI);
29755: desret_xmlTextReaderPtr(ret_val);
29756: call_tests++;
29757: des_filepath(n_URI, URI, 0);
29758: xmlResetLastError();
29759: if (mem_base != xmlMemBlocks()) {
29760: printf("Leak of %d blocks found in xmlNewTextReaderFilename",
29761: xmlMemBlocks() - mem_base);
29762: test_ret++;
29763: printf(" %d", n_URI);
29764: printf("\n");
29765: }
29766: }
29767: function_tests++;
29768: #endif
29769:
29770: return(test_ret);
29771: }
29772:
29773:
29774: static int
29775: test_xmlReaderForDoc(void) {
29776: int test_ret = 0;
29777:
29778: #if defined(LIBXML_READER_ENABLED)
29779: int mem_base;
29780: xmlTextReaderPtr ret_val;
29781: xmlChar * cur; /* a pointer to a zero terminated string */
29782: int n_cur;
29783: const char * URL; /* the base URL to use for the document */
29784: int n_URL;
29785: char * encoding; /* the document encoding, or NULL */
29786: int n_encoding;
29787: int options; /* a combination of xmlParserOption */
29788: int n_options;
29789:
29790: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
29791: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
29792: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
29793: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
29794: mem_base = xmlMemBlocks();
29795: cur = gen_const_xmlChar_ptr(n_cur, 0);
29796: URL = gen_filepath(n_URL, 1);
29797: encoding = gen_const_char_ptr(n_encoding, 2);
29798: options = gen_parseroptions(n_options, 3);
29799:
29800: ret_val = xmlReaderForDoc((const xmlChar *)cur, URL, (const char *)encoding, options);
29801: desret_xmlTextReaderPtr(ret_val);
29802: call_tests++;
29803: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
29804: des_filepath(n_URL, URL, 1);
29805: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
29806: des_parseroptions(n_options, options, 3);
29807: xmlResetLastError();
29808: if (mem_base != xmlMemBlocks()) {
29809: printf("Leak of %d blocks found in xmlReaderForDoc",
29810: xmlMemBlocks() - mem_base);
29811: test_ret++;
29812: printf(" %d", n_cur);
29813: printf(" %d", n_URL);
29814: printf(" %d", n_encoding);
29815: printf(" %d", n_options);
29816: printf("\n");
29817: }
29818: }
29819: }
29820: }
29821: }
29822: function_tests++;
29823: #endif
29824:
29825: return(test_ret);
29826: }
29827:
29828:
29829: static int
29830: test_xmlReaderForFile(void) {
29831: int test_ret = 0;
29832:
29833: #if defined(LIBXML_READER_ENABLED)
29834: int mem_base;
29835: xmlTextReaderPtr ret_val;
29836: const char * filename; /* a file or URL */
29837: int n_filename;
29838: char * encoding; /* the document encoding, or NULL */
29839: int n_encoding;
29840: int options; /* a combination of xmlParserOption */
29841: int n_options;
29842:
29843: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
29844: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
29845: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
29846: mem_base = xmlMemBlocks();
29847: filename = gen_filepath(n_filename, 0);
29848: encoding = gen_const_char_ptr(n_encoding, 1);
29849: options = gen_parseroptions(n_options, 2);
29850:
29851: ret_val = xmlReaderForFile(filename, (const char *)encoding, options);
29852: desret_xmlTextReaderPtr(ret_val);
29853: call_tests++;
29854: des_filepath(n_filename, filename, 0);
29855: des_const_char_ptr(n_encoding, (const char *)encoding, 1);
29856: des_parseroptions(n_options, options, 2);
29857: xmlResetLastError();
29858: if (mem_base != xmlMemBlocks()) {
29859: printf("Leak of %d blocks found in xmlReaderForFile",
29860: xmlMemBlocks() - mem_base);
29861: test_ret++;
29862: printf(" %d", n_filename);
29863: printf(" %d", n_encoding);
29864: printf(" %d", n_options);
29865: printf("\n");
29866: }
29867: }
29868: }
29869: }
29870: function_tests++;
29871: #endif
29872:
29873: return(test_ret);
29874: }
29875:
29876:
29877: static int
29878: test_xmlReaderForMemory(void) {
29879: int test_ret = 0;
29880:
29881: #if defined(LIBXML_READER_ENABLED)
29882: int mem_base;
29883: xmlTextReaderPtr ret_val;
29884: char * buffer; /* a pointer to a char array */
29885: int n_buffer;
29886: int size; /* the size of the array */
29887: int n_size;
29888: const char * URL; /* the base URL to use for the document */
29889: int n_URL;
29890: char * encoding; /* the document encoding, or NULL */
29891: int n_encoding;
29892: int options; /* a combination of xmlParserOption */
29893: int n_options;
29894:
29895: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
29896: for (n_size = 0;n_size < gen_nb_int;n_size++) {
29897: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
29898: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
29899: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
29900: mem_base = xmlMemBlocks();
29901: buffer = gen_const_char_ptr(n_buffer, 0);
29902: size = gen_int(n_size, 1);
29903: URL = gen_filepath(n_URL, 2);
29904: encoding = gen_const_char_ptr(n_encoding, 3);
29905: options = gen_parseroptions(n_options, 4);
29906:
29907: ret_val = xmlReaderForMemory((const char *)buffer, size, URL, (const char *)encoding, options);
29908: desret_xmlTextReaderPtr(ret_val);
29909: call_tests++;
29910: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
29911: des_int(n_size, size, 1);
29912: des_filepath(n_URL, URL, 2);
29913: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
29914: des_parseroptions(n_options, options, 4);
29915: xmlResetLastError();
29916: if (mem_base != xmlMemBlocks()) {
29917: printf("Leak of %d blocks found in xmlReaderForMemory",
29918: xmlMemBlocks() - mem_base);
29919: test_ret++;
29920: printf(" %d", n_buffer);
29921: printf(" %d", n_size);
29922: printf(" %d", n_URL);
29923: printf(" %d", n_encoding);
29924: printf(" %d", n_options);
29925: printf("\n");
29926: }
29927: }
29928: }
29929: }
29930: }
29931: }
29932: function_tests++;
29933: #endif
29934:
29935: return(test_ret);
29936: }
29937:
29938:
29939: static int
29940: test_xmlReaderNewDoc(void) {
29941: int test_ret = 0;
29942:
29943: #if defined(LIBXML_READER_ENABLED)
29944: int mem_base;
29945: int ret_val;
29946: xmlTextReaderPtr reader; /* an XML reader */
29947: int n_reader;
29948: xmlChar * cur; /* a pointer to a zero terminated string */
29949: int n_cur;
29950: const char * URL; /* the base URL to use for the document */
29951: int n_URL;
29952: char * encoding; /* the document encoding, or NULL */
29953: int n_encoding;
29954: int options; /* a combination of xmlParserOption */
29955: int n_options;
29956:
29957: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
29958: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
29959: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
29960: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
29961: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
29962: mem_base = xmlMemBlocks();
29963: reader = gen_xmlTextReaderPtr(n_reader, 0);
29964: cur = gen_const_xmlChar_ptr(n_cur, 1);
29965: URL = gen_filepath(n_URL, 2);
29966: encoding = gen_const_char_ptr(n_encoding, 3);
29967: options = gen_parseroptions(n_options, 4);
29968:
29969: ret_val = xmlReaderNewDoc(reader, (const xmlChar *)cur, URL, (const char *)encoding, options);
29970: desret_int(ret_val);
29971: call_tests++;
29972: des_xmlTextReaderPtr(n_reader, reader, 0);
29973: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 1);
29974: des_filepath(n_URL, URL, 2);
29975: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
29976: des_parseroptions(n_options, options, 4);
29977: xmlResetLastError();
29978: if (mem_base != xmlMemBlocks()) {
29979: printf("Leak of %d blocks found in xmlReaderNewDoc",
29980: xmlMemBlocks() - mem_base);
29981: test_ret++;
29982: printf(" %d", n_reader);
29983: printf(" %d", n_cur);
29984: printf(" %d", n_URL);
29985: printf(" %d", n_encoding);
29986: printf(" %d", n_options);
29987: printf("\n");
29988: }
29989: }
29990: }
29991: }
29992: }
29993: }
29994: function_tests++;
29995: #endif
29996:
29997: return(test_ret);
29998: }
29999:
30000:
30001: static int
30002: test_xmlReaderNewFile(void) {
30003: int test_ret = 0;
30004:
30005: #if defined(LIBXML_READER_ENABLED)
30006: int mem_base;
30007: int ret_val;
30008: xmlTextReaderPtr reader; /* an XML reader */
30009: int n_reader;
30010: const char * filename; /* a file or URL */
30011: int n_filename;
30012: char * encoding; /* the document encoding, or NULL */
30013: int n_encoding;
30014: int options; /* a combination of xmlParserOption */
30015: int n_options;
30016:
30017: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30018: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
30019: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
30020: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
30021: mem_base = xmlMemBlocks();
30022: reader = gen_xmlTextReaderPtr(n_reader, 0);
30023: filename = gen_filepath(n_filename, 1);
30024: encoding = gen_const_char_ptr(n_encoding, 2);
30025: options = gen_parseroptions(n_options, 3);
30026:
30027: ret_val = xmlReaderNewFile(reader, filename, (const char *)encoding, options);
30028: desret_int(ret_val);
30029: call_tests++;
30030: des_xmlTextReaderPtr(n_reader, reader, 0);
30031: des_filepath(n_filename, filename, 1);
30032: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
30033: des_parseroptions(n_options, options, 3);
30034: xmlResetLastError();
30035: if (mem_base != xmlMemBlocks()) {
30036: printf("Leak of %d blocks found in xmlReaderNewFile",
30037: xmlMemBlocks() - mem_base);
30038: test_ret++;
30039: printf(" %d", n_reader);
30040: printf(" %d", n_filename);
30041: printf(" %d", n_encoding);
30042: printf(" %d", n_options);
30043: printf("\n");
30044: }
30045: }
30046: }
30047: }
30048: }
30049: function_tests++;
30050: #endif
30051:
30052: return(test_ret);
30053: }
30054:
30055:
30056: static int
30057: test_xmlReaderNewMemory(void) {
30058: int test_ret = 0;
30059:
30060: #if defined(LIBXML_READER_ENABLED)
30061: int mem_base;
30062: int ret_val;
30063: xmlTextReaderPtr reader; /* an XML reader */
30064: int n_reader;
30065: char * buffer; /* a pointer to a char array */
30066: int n_buffer;
30067: int size; /* the size of the array */
30068: int n_size;
30069: const char * URL; /* the base URL to use for the document */
30070: int n_URL;
30071: char * encoding; /* the document encoding, or NULL */
30072: int n_encoding;
30073: int options; /* a combination of xmlParserOption */
30074: int n_options;
30075:
30076: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30077: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
30078: for (n_size = 0;n_size < gen_nb_int;n_size++) {
30079: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
30080: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
30081: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
30082: mem_base = xmlMemBlocks();
30083: reader = gen_xmlTextReaderPtr(n_reader, 0);
30084: buffer = gen_const_char_ptr(n_buffer, 1);
30085: size = gen_int(n_size, 2);
30086: URL = gen_filepath(n_URL, 3);
30087: encoding = gen_const_char_ptr(n_encoding, 4);
30088: options = gen_parseroptions(n_options, 5);
30089:
30090: ret_val = xmlReaderNewMemory(reader, (const char *)buffer, size, URL, (const char *)encoding, options);
30091: desret_int(ret_val);
30092: call_tests++;
30093: des_xmlTextReaderPtr(n_reader, reader, 0);
30094: des_const_char_ptr(n_buffer, (const char *)buffer, 1);
30095: des_int(n_size, size, 2);
30096: des_filepath(n_URL, URL, 3);
30097: des_const_char_ptr(n_encoding, (const char *)encoding, 4);
30098: des_parseroptions(n_options, options, 5);
30099: xmlResetLastError();
30100: if (mem_base != xmlMemBlocks()) {
30101: printf("Leak of %d blocks found in xmlReaderNewMemory",
30102: xmlMemBlocks() - mem_base);
30103: test_ret++;
30104: printf(" %d", n_reader);
30105: printf(" %d", n_buffer);
30106: printf(" %d", n_size);
30107: printf(" %d", n_URL);
30108: printf(" %d", n_encoding);
30109: printf(" %d", n_options);
30110: printf("\n");
30111: }
30112: }
30113: }
30114: }
30115: }
30116: }
30117: }
30118: function_tests++;
30119: #endif
30120:
30121: return(test_ret);
30122: }
30123:
30124:
30125: static int
30126: test_xmlReaderNewWalker(void) {
30127: int test_ret = 0;
30128:
30129: #if defined(LIBXML_READER_ENABLED)
30130: int mem_base;
30131: int ret_val;
30132: xmlTextReaderPtr reader; /* an XML reader */
30133: int n_reader;
30134: xmlDocPtr doc; /* a preparsed document */
30135: int n_doc;
30136:
30137: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30138: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
30139: mem_base = xmlMemBlocks();
30140: reader = gen_xmlTextReaderPtr(n_reader, 0);
30141: doc = gen_xmlDocPtr(n_doc, 1);
30142:
30143: ret_val = xmlReaderNewWalker(reader, doc);
30144: desret_int(ret_val);
30145: call_tests++;
30146: des_xmlTextReaderPtr(n_reader, reader, 0);
30147: des_xmlDocPtr(n_doc, doc, 1);
30148: xmlResetLastError();
30149: if (mem_base != xmlMemBlocks()) {
30150: printf("Leak of %d blocks found in xmlReaderNewWalker",
30151: xmlMemBlocks() - mem_base);
30152: test_ret++;
30153: printf(" %d", n_reader);
30154: printf(" %d", n_doc);
30155: printf("\n");
30156: }
30157: }
30158: }
30159: function_tests++;
30160: #endif
30161:
30162: return(test_ret);
30163: }
30164:
30165:
30166: static int
30167: test_xmlReaderWalker(void) {
30168: int test_ret = 0;
30169:
30170: #if defined(LIBXML_READER_ENABLED)
30171: int mem_base;
30172: xmlTextReaderPtr ret_val;
30173: xmlDocPtr doc; /* a preparsed document */
30174: int n_doc;
30175:
30176: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
30177: mem_base = xmlMemBlocks();
30178: doc = gen_xmlDocPtr(n_doc, 0);
30179:
30180: ret_val = xmlReaderWalker(doc);
30181: desret_xmlTextReaderPtr(ret_val);
30182: call_tests++;
30183: des_xmlDocPtr(n_doc, doc, 0);
30184: xmlResetLastError();
30185: if (mem_base != xmlMemBlocks()) {
30186: printf("Leak of %d blocks found in xmlReaderWalker",
30187: xmlMemBlocks() - mem_base);
30188: test_ret++;
30189: printf(" %d", n_doc);
30190: printf("\n");
30191: }
30192: }
30193: function_tests++;
30194: #endif
30195:
30196: return(test_ret);
30197: }
30198:
30199:
30200: static int
30201: test_xmlTextReaderAttributeCount(void) {
30202: int test_ret = 0;
30203:
30204: #if defined(LIBXML_READER_ENABLED)
30205: int mem_base;
30206: int ret_val;
30207: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30208: int n_reader;
30209:
30210: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30211: mem_base = xmlMemBlocks();
30212: reader = gen_xmlTextReaderPtr(n_reader, 0);
30213:
30214: ret_val = xmlTextReaderAttributeCount(reader);
30215: desret_int(ret_val);
30216: call_tests++;
30217: des_xmlTextReaderPtr(n_reader, reader, 0);
30218: xmlResetLastError();
30219: if (mem_base != xmlMemBlocks()) {
30220: printf("Leak of %d blocks found in xmlTextReaderAttributeCount",
30221: xmlMemBlocks() - mem_base);
30222: test_ret++;
30223: printf(" %d", n_reader);
30224: printf("\n");
30225: }
30226: }
30227: function_tests++;
30228: #endif
30229:
30230: return(test_ret);
30231: }
30232:
30233:
30234: static int
30235: test_xmlTextReaderBaseUri(void) {
30236: int test_ret = 0;
30237:
30238: #if defined(LIBXML_READER_ENABLED)
30239: int mem_base;
30240: xmlChar * ret_val;
30241: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30242: int n_reader;
30243:
30244: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30245: mem_base = xmlMemBlocks();
30246: reader = gen_xmlTextReaderPtr(n_reader, 0);
30247:
30248: ret_val = xmlTextReaderBaseUri(reader);
30249: desret_xmlChar_ptr(ret_val);
30250: call_tests++;
30251: des_xmlTextReaderPtr(n_reader, reader, 0);
30252: xmlResetLastError();
30253: if (mem_base != xmlMemBlocks()) {
30254: printf("Leak of %d blocks found in xmlTextReaderBaseUri",
30255: xmlMemBlocks() - mem_base);
30256: test_ret++;
30257: printf(" %d", n_reader);
30258: printf("\n");
30259: }
30260: }
30261: function_tests++;
30262: #endif
30263:
30264: return(test_ret);
30265: }
30266:
30267:
30268: static int
30269: test_xmlTextReaderByteConsumed(void) {
30270: int test_ret = 0;
30271:
30272: #if defined(LIBXML_READER_ENABLED)
30273: int mem_base;
30274: long ret_val;
30275: xmlTextReaderPtr reader; /* an XML reader */
30276: int n_reader;
30277:
30278: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30279: mem_base = xmlMemBlocks();
30280: reader = gen_xmlTextReaderPtr(n_reader, 0);
30281:
30282: ret_val = xmlTextReaderByteConsumed(reader);
30283: desret_long(ret_val);
30284: call_tests++;
30285: des_xmlTextReaderPtr(n_reader, reader, 0);
30286: xmlResetLastError();
30287: if (mem_base != xmlMemBlocks()) {
30288: printf("Leak of %d blocks found in xmlTextReaderByteConsumed",
30289: xmlMemBlocks() - mem_base);
30290: test_ret++;
30291: printf(" %d", n_reader);
30292: printf("\n");
30293: }
30294: }
30295: function_tests++;
30296: #endif
30297:
30298: return(test_ret);
30299: }
30300:
30301:
30302: static int
30303: test_xmlTextReaderClose(void) {
30304: int test_ret = 0;
30305:
30306: #if defined(LIBXML_READER_ENABLED)
30307: int mem_base;
30308: int ret_val;
30309: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30310: int n_reader;
30311:
30312: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30313: mem_base = xmlMemBlocks();
30314: reader = gen_xmlTextReaderPtr(n_reader, 0);
30315:
30316: ret_val = xmlTextReaderClose(reader);
30317: desret_int(ret_val);
30318: call_tests++;
30319: des_xmlTextReaderPtr(n_reader, reader, 0);
30320: xmlResetLastError();
30321: if (mem_base != xmlMemBlocks()) {
30322: printf("Leak of %d blocks found in xmlTextReaderClose",
30323: xmlMemBlocks() - mem_base);
30324: test_ret++;
30325: printf(" %d", n_reader);
30326: printf("\n");
30327: }
30328: }
30329: function_tests++;
30330: #endif
30331:
30332: return(test_ret);
30333: }
30334:
30335:
30336: static int
30337: test_xmlTextReaderConstBaseUri(void) {
30338: int test_ret = 0;
30339:
30340: #if defined(LIBXML_READER_ENABLED)
30341: int mem_base;
30342: const xmlChar * ret_val;
30343: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30344: int n_reader;
30345:
30346: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30347: mem_base = xmlMemBlocks();
30348: reader = gen_xmlTextReaderPtr(n_reader, 0);
30349:
30350: ret_val = xmlTextReaderConstBaseUri(reader);
30351: desret_const_xmlChar_ptr(ret_val);
30352: call_tests++;
30353: des_xmlTextReaderPtr(n_reader, reader, 0);
30354: xmlResetLastError();
30355: if (mem_base != xmlMemBlocks()) {
30356: printf("Leak of %d blocks found in xmlTextReaderConstBaseUri",
30357: xmlMemBlocks() - mem_base);
30358: test_ret++;
30359: printf(" %d", n_reader);
30360: printf("\n");
30361: }
30362: }
30363: function_tests++;
30364: #endif
30365:
30366: return(test_ret);
30367: }
30368:
30369:
30370: static int
30371: test_xmlTextReaderConstEncoding(void) {
30372: int test_ret = 0;
30373:
30374: #if defined(LIBXML_READER_ENABLED)
30375: int mem_base;
30376: const xmlChar * ret_val;
30377: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30378: int n_reader;
30379:
30380: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30381: mem_base = xmlMemBlocks();
30382: reader = gen_xmlTextReaderPtr(n_reader, 0);
30383:
30384: ret_val = xmlTextReaderConstEncoding(reader);
30385: desret_const_xmlChar_ptr(ret_val);
30386: call_tests++;
30387: des_xmlTextReaderPtr(n_reader, reader, 0);
30388: xmlResetLastError();
30389: if (mem_base != xmlMemBlocks()) {
30390: printf("Leak of %d blocks found in xmlTextReaderConstEncoding",
30391: xmlMemBlocks() - mem_base);
30392: test_ret++;
30393: printf(" %d", n_reader);
30394: printf("\n");
30395: }
30396: }
30397: function_tests++;
30398: #endif
30399:
30400: return(test_ret);
30401: }
30402:
30403:
30404: static int
30405: test_xmlTextReaderConstLocalName(void) {
30406: int test_ret = 0;
30407:
30408: #if defined(LIBXML_READER_ENABLED)
30409: int mem_base;
30410: const xmlChar * ret_val;
30411: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30412: int n_reader;
30413:
30414: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30415: mem_base = xmlMemBlocks();
30416: reader = gen_xmlTextReaderPtr(n_reader, 0);
30417:
30418: ret_val = xmlTextReaderConstLocalName(reader);
30419: desret_const_xmlChar_ptr(ret_val);
30420: call_tests++;
30421: des_xmlTextReaderPtr(n_reader, reader, 0);
30422: xmlResetLastError();
30423: if (mem_base != xmlMemBlocks()) {
30424: printf("Leak of %d blocks found in xmlTextReaderConstLocalName",
30425: xmlMemBlocks() - mem_base);
30426: test_ret++;
30427: printf(" %d", n_reader);
30428: printf("\n");
30429: }
30430: }
30431: function_tests++;
30432: #endif
30433:
30434: return(test_ret);
30435: }
30436:
30437:
30438: static int
30439: test_xmlTextReaderConstName(void) {
30440: int test_ret = 0;
30441:
30442: #if defined(LIBXML_READER_ENABLED)
30443: int mem_base;
30444: const xmlChar * ret_val;
30445: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30446: int n_reader;
30447:
30448: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30449: mem_base = xmlMemBlocks();
30450: reader = gen_xmlTextReaderPtr(n_reader, 0);
30451:
30452: ret_val = xmlTextReaderConstName(reader);
30453: desret_const_xmlChar_ptr(ret_val);
30454: call_tests++;
30455: des_xmlTextReaderPtr(n_reader, reader, 0);
30456: xmlResetLastError();
30457: if (mem_base != xmlMemBlocks()) {
30458: printf("Leak of %d blocks found in xmlTextReaderConstName",
30459: xmlMemBlocks() - mem_base);
30460: test_ret++;
30461: printf(" %d", n_reader);
30462: printf("\n");
30463: }
30464: }
30465: function_tests++;
30466: #endif
30467:
30468: return(test_ret);
30469: }
30470:
30471:
30472: static int
30473: test_xmlTextReaderConstNamespaceUri(void) {
30474: int test_ret = 0;
30475:
30476: #if defined(LIBXML_READER_ENABLED)
30477: int mem_base;
30478: const xmlChar * ret_val;
30479: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30480: int n_reader;
30481:
30482: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30483: mem_base = xmlMemBlocks();
30484: reader = gen_xmlTextReaderPtr(n_reader, 0);
30485:
30486: ret_val = xmlTextReaderConstNamespaceUri(reader);
30487: desret_const_xmlChar_ptr(ret_val);
30488: call_tests++;
30489: des_xmlTextReaderPtr(n_reader, reader, 0);
30490: xmlResetLastError();
30491: if (mem_base != xmlMemBlocks()) {
30492: printf("Leak of %d blocks found in xmlTextReaderConstNamespaceUri",
30493: xmlMemBlocks() - mem_base);
30494: test_ret++;
30495: printf(" %d", n_reader);
30496: printf("\n");
30497: }
30498: }
30499: function_tests++;
30500: #endif
30501:
30502: return(test_ret);
30503: }
30504:
30505:
30506: static int
30507: test_xmlTextReaderConstPrefix(void) {
30508: int test_ret = 0;
30509:
30510: #if defined(LIBXML_READER_ENABLED)
30511: int mem_base;
30512: const xmlChar * ret_val;
30513: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30514: int n_reader;
30515:
30516: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30517: mem_base = xmlMemBlocks();
30518: reader = gen_xmlTextReaderPtr(n_reader, 0);
30519:
30520: ret_val = xmlTextReaderConstPrefix(reader);
30521: desret_const_xmlChar_ptr(ret_val);
30522: call_tests++;
30523: des_xmlTextReaderPtr(n_reader, reader, 0);
30524: xmlResetLastError();
30525: if (mem_base != xmlMemBlocks()) {
30526: printf("Leak of %d blocks found in xmlTextReaderConstPrefix",
30527: xmlMemBlocks() - mem_base);
30528: test_ret++;
30529: printf(" %d", n_reader);
30530: printf("\n");
30531: }
30532: }
30533: function_tests++;
30534: #endif
30535:
30536: return(test_ret);
30537: }
30538:
30539:
30540: static int
30541: test_xmlTextReaderConstString(void) {
30542: int test_ret = 0;
30543:
30544: #if defined(LIBXML_READER_ENABLED)
30545: int mem_base;
30546: const xmlChar * ret_val;
30547: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30548: int n_reader;
30549: xmlChar * str; /* the string to intern. */
30550: int n_str;
30551:
30552: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30553: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
30554: mem_base = xmlMemBlocks();
30555: reader = gen_xmlTextReaderPtr(n_reader, 0);
30556: str = gen_const_xmlChar_ptr(n_str, 1);
30557:
30558: ret_val = xmlTextReaderConstString(reader, (const xmlChar *)str);
30559: desret_const_xmlChar_ptr(ret_val);
30560: call_tests++;
30561: des_xmlTextReaderPtr(n_reader, reader, 0);
30562: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
30563: xmlResetLastError();
30564: if (mem_base != xmlMemBlocks()) {
30565: printf("Leak of %d blocks found in xmlTextReaderConstString",
30566: xmlMemBlocks() - mem_base);
30567: test_ret++;
30568: printf(" %d", n_reader);
30569: printf(" %d", n_str);
30570: printf("\n");
30571: }
30572: }
30573: }
30574: function_tests++;
30575: #endif
30576:
30577: return(test_ret);
30578: }
30579:
30580:
30581: static int
30582: test_xmlTextReaderConstValue(void) {
30583: int test_ret = 0;
30584:
30585: #if defined(LIBXML_READER_ENABLED)
30586: int mem_base;
30587: const xmlChar * ret_val;
30588: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30589: int n_reader;
30590:
30591: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30592: mem_base = xmlMemBlocks();
30593: reader = gen_xmlTextReaderPtr(n_reader, 0);
30594:
30595: ret_val = xmlTextReaderConstValue(reader);
30596: desret_const_xmlChar_ptr(ret_val);
30597: call_tests++;
30598: des_xmlTextReaderPtr(n_reader, reader, 0);
30599: xmlResetLastError();
30600: if (mem_base != xmlMemBlocks()) {
30601: printf("Leak of %d blocks found in xmlTextReaderConstValue",
30602: xmlMemBlocks() - mem_base);
30603: test_ret++;
30604: printf(" %d", n_reader);
30605: printf("\n");
30606: }
30607: }
30608: function_tests++;
30609: #endif
30610:
30611: return(test_ret);
30612: }
30613:
30614:
30615: static int
30616: test_xmlTextReaderConstXmlLang(void) {
30617: int test_ret = 0;
30618:
30619: #if defined(LIBXML_READER_ENABLED)
30620: int mem_base;
30621: const xmlChar * ret_val;
30622: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30623: int n_reader;
30624:
30625: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30626: mem_base = xmlMemBlocks();
30627: reader = gen_xmlTextReaderPtr(n_reader, 0);
30628:
30629: ret_val = xmlTextReaderConstXmlLang(reader);
30630: desret_const_xmlChar_ptr(ret_val);
30631: call_tests++;
30632: des_xmlTextReaderPtr(n_reader, reader, 0);
30633: xmlResetLastError();
30634: if (mem_base != xmlMemBlocks()) {
30635: printf("Leak of %d blocks found in xmlTextReaderConstXmlLang",
30636: xmlMemBlocks() - mem_base);
30637: test_ret++;
30638: printf(" %d", n_reader);
30639: printf("\n");
30640: }
30641: }
30642: function_tests++;
30643: #endif
30644:
30645: return(test_ret);
30646: }
30647:
30648:
30649: static int
30650: test_xmlTextReaderConstXmlVersion(void) {
30651: int test_ret = 0;
30652:
30653: #if defined(LIBXML_READER_ENABLED)
30654: int mem_base;
30655: const xmlChar * ret_val;
30656: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30657: int n_reader;
30658:
30659: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30660: mem_base = xmlMemBlocks();
30661: reader = gen_xmlTextReaderPtr(n_reader, 0);
30662:
30663: ret_val = xmlTextReaderConstXmlVersion(reader);
30664: desret_const_xmlChar_ptr(ret_val);
30665: call_tests++;
30666: des_xmlTextReaderPtr(n_reader, reader, 0);
30667: xmlResetLastError();
30668: if (mem_base != xmlMemBlocks()) {
30669: printf("Leak of %d blocks found in xmlTextReaderConstXmlVersion",
30670: xmlMemBlocks() - mem_base);
30671: test_ret++;
30672: printf(" %d", n_reader);
30673: printf("\n");
30674: }
30675: }
30676: function_tests++;
30677: #endif
30678:
30679: return(test_ret);
30680: }
30681:
30682:
30683: static int
30684: test_xmlTextReaderCurrentDoc(void) {
30685: int test_ret = 0;
30686:
30687: #if defined(LIBXML_READER_ENABLED)
30688: int mem_base;
30689: xmlDocPtr ret_val;
30690: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30691: int n_reader;
30692:
30693: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30694: mem_base = xmlMemBlocks();
30695: reader = gen_xmlTextReaderPtr(n_reader, 0);
30696:
30697: ret_val = xmlTextReaderCurrentDoc(reader);
30698: desret_xmlDocPtr(ret_val);
30699: call_tests++;
30700: des_xmlTextReaderPtr(n_reader, reader, 0);
30701: xmlResetLastError();
30702: if (mem_base != xmlMemBlocks()) {
30703: printf("Leak of %d blocks found in xmlTextReaderCurrentDoc",
30704: xmlMemBlocks() - mem_base);
30705: test_ret++;
30706: printf(" %d", n_reader);
30707: printf("\n");
30708: }
30709: }
30710: function_tests++;
30711: #endif
30712:
30713: return(test_ret);
30714: }
30715:
30716:
30717: static int
30718: test_xmlTextReaderCurrentNode(void) {
30719: int test_ret = 0;
30720:
30721: #if defined(LIBXML_READER_ENABLED)
30722: int mem_base;
30723: xmlNodePtr ret_val;
30724: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30725: int n_reader;
30726:
30727: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30728: mem_base = xmlMemBlocks();
30729: reader = gen_xmlTextReaderPtr(n_reader, 0);
30730:
30731: ret_val = xmlTextReaderCurrentNode(reader);
30732: desret_xmlNodePtr(ret_val);
30733: call_tests++;
30734: des_xmlTextReaderPtr(n_reader, reader, 0);
30735: xmlResetLastError();
30736: if (mem_base != xmlMemBlocks()) {
30737: printf("Leak of %d blocks found in xmlTextReaderCurrentNode",
30738: xmlMemBlocks() - mem_base);
30739: test_ret++;
30740: printf(" %d", n_reader);
30741: printf("\n");
30742: }
30743: }
30744: function_tests++;
30745: #endif
30746:
30747: return(test_ret);
30748: }
30749:
30750:
30751: static int
30752: test_xmlTextReaderDepth(void) {
30753: int test_ret = 0;
30754:
30755: #if defined(LIBXML_READER_ENABLED)
30756: int mem_base;
30757: int ret_val;
30758: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30759: int n_reader;
30760:
30761: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30762: mem_base = xmlMemBlocks();
30763: reader = gen_xmlTextReaderPtr(n_reader, 0);
30764:
30765: ret_val = xmlTextReaderDepth(reader);
30766: desret_int(ret_val);
30767: call_tests++;
30768: des_xmlTextReaderPtr(n_reader, reader, 0);
30769: xmlResetLastError();
30770: if (mem_base != xmlMemBlocks()) {
30771: printf("Leak of %d blocks found in xmlTextReaderDepth",
30772: xmlMemBlocks() - mem_base);
30773: test_ret++;
30774: printf(" %d", n_reader);
30775: printf("\n");
30776: }
30777: }
30778: function_tests++;
30779: #endif
30780:
30781: return(test_ret);
30782: }
30783:
30784:
30785: static int
30786: test_xmlTextReaderExpand(void) {
30787: int test_ret = 0;
30788:
30789: #if defined(LIBXML_READER_ENABLED)
30790: int mem_base;
30791: xmlNodePtr ret_val;
30792: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30793: int n_reader;
30794:
30795: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30796: mem_base = xmlMemBlocks();
30797: reader = gen_xmlTextReaderPtr(n_reader, 0);
30798:
30799: ret_val = xmlTextReaderExpand(reader);
30800: desret_xmlNodePtr(ret_val);
30801: call_tests++;
30802: des_xmlTextReaderPtr(n_reader, reader, 0);
30803: xmlResetLastError();
30804: if (mem_base != xmlMemBlocks()) {
30805: printf("Leak of %d blocks found in xmlTextReaderExpand",
30806: xmlMemBlocks() - mem_base);
30807: test_ret++;
30808: printf(" %d", n_reader);
30809: printf("\n");
30810: }
30811: }
30812: function_tests++;
30813: #endif
30814:
30815: return(test_ret);
30816: }
30817:
30818:
30819: static int
30820: test_xmlTextReaderGetAttribute(void) {
30821: int test_ret = 0;
30822:
30823: #if defined(LIBXML_READER_ENABLED)
30824: int mem_base;
30825: xmlChar * ret_val;
30826: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30827: int n_reader;
30828: xmlChar * name; /* the qualified name of the attribute. */
30829: int n_name;
30830:
30831: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30832: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
30833: mem_base = xmlMemBlocks();
30834: reader = gen_xmlTextReaderPtr(n_reader, 0);
30835: name = gen_const_xmlChar_ptr(n_name, 1);
30836:
30837: ret_val = xmlTextReaderGetAttribute(reader, (const xmlChar *)name);
30838: desret_xmlChar_ptr(ret_val);
30839: call_tests++;
30840: des_xmlTextReaderPtr(n_reader, reader, 0);
30841: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
30842: xmlResetLastError();
30843: if (mem_base != xmlMemBlocks()) {
30844: printf("Leak of %d blocks found in xmlTextReaderGetAttribute",
30845: xmlMemBlocks() - mem_base);
30846: test_ret++;
30847: printf(" %d", n_reader);
30848: printf(" %d", n_name);
30849: printf("\n");
30850: }
30851: }
30852: }
30853: function_tests++;
30854: #endif
30855:
30856: return(test_ret);
30857: }
30858:
30859:
30860: static int
30861: test_xmlTextReaderGetAttributeNo(void) {
30862: int test_ret = 0;
30863:
30864: #if defined(LIBXML_READER_ENABLED)
30865: int mem_base;
30866: xmlChar * ret_val;
30867: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30868: int n_reader;
30869: int no; /* the zero-based index of the attribute relative to the containing element */
30870: int n_no;
30871:
30872: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30873: for (n_no = 0;n_no < gen_nb_int;n_no++) {
30874: mem_base = xmlMemBlocks();
30875: reader = gen_xmlTextReaderPtr(n_reader, 0);
30876: no = gen_int(n_no, 1);
30877:
30878: ret_val = xmlTextReaderGetAttributeNo(reader, no);
30879: desret_xmlChar_ptr(ret_val);
30880: call_tests++;
30881: des_xmlTextReaderPtr(n_reader, reader, 0);
30882: des_int(n_no, no, 1);
30883: xmlResetLastError();
30884: if (mem_base != xmlMemBlocks()) {
30885: printf("Leak of %d blocks found in xmlTextReaderGetAttributeNo",
30886: xmlMemBlocks() - mem_base);
30887: test_ret++;
30888: printf(" %d", n_reader);
30889: printf(" %d", n_no);
30890: printf("\n");
30891: }
30892: }
30893: }
30894: function_tests++;
30895: #endif
30896:
30897: return(test_ret);
30898: }
30899:
30900:
30901: static int
30902: test_xmlTextReaderGetAttributeNs(void) {
30903: int test_ret = 0;
30904:
30905: #if defined(LIBXML_READER_ENABLED)
30906: int mem_base;
30907: xmlChar * ret_val;
30908: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30909: int n_reader;
30910: xmlChar * localName; /* the local name of the attribute. */
30911: int n_localName;
30912: xmlChar * namespaceURI; /* the namespace URI of the attribute. */
30913: int n_namespaceURI;
30914:
30915: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30916: for (n_localName = 0;n_localName < gen_nb_const_xmlChar_ptr;n_localName++) {
30917: for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
30918: mem_base = xmlMemBlocks();
30919: reader = gen_xmlTextReaderPtr(n_reader, 0);
30920: localName = gen_const_xmlChar_ptr(n_localName, 1);
30921: namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 2);
30922:
30923: ret_val = xmlTextReaderGetAttributeNs(reader, (const xmlChar *)localName, (const xmlChar *)namespaceURI);
30924: desret_xmlChar_ptr(ret_val);
30925: call_tests++;
30926: des_xmlTextReaderPtr(n_reader, reader, 0);
30927: des_const_xmlChar_ptr(n_localName, (const xmlChar *)localName, 1);
30928: des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 2);
30929: xmlResetLastError();
30930: if (mem_base != xmlMemBlocks()) {
30931: printf("Leak of %d blocks found in xmlTextReaderGetAttributeNs",
30932: xmlMemBlocks() - mem_base);
30933: test_ret++;
30934: printf(" %d", n_reader);
30935: printf(" %d", n_localName);
30936: printf(" %d", n_namespaceURI);
30937: printf("\n");
30938: }
30939: }
30940: }
30941: }
30942: function_tests++;
30943: #endif
30944:
30945: return(test_ret);
30946: }
30947:
30948: #ifdef LIBXML_READER_ENABLED
30949:
30950: #define gen_nb_xmlTextReaderErrorFunc_ptr 1
30951: static xmlTextReaderErrorFunc * gen_xmlTextReaderErrorFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
30952: return(NULL);
30953: }
30954: static void des_xmlTextReaderErrorFunc_ptr(int no ATTRIBUTE_UNUSED, xmlTextReaderErrorFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
30955: }
30956: #endif
30957:
30958:
30959: static int
30960: test_xmlTextReaderGetErrorHandler(void) {
30961: int test_ret = 0;
30962:
30963: #if defined(LIBXML_READER_ENABLED)
30964: int mem_base;
30965: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30966: int n_reader;
30967: xmlTextReaderErrorFunc * f; /* the callback function or NULL is no callback has been registered */
30968: int n_f;
30969: void ** arg; /* a user argument */
30970: int n_arg;
30971:
30972: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30973: for (n_f = 0;n_f < gen_nb_xmlTextReaderErrorFunc_ptr;n_f++) {
30974: for (n_arg = 0;n_arg < gen_nb_void_ptr_ptr;n_arg++) {
30975: mem_base = xmlMemBlocks();
30976: reader = gen_xmlTextReaderPtr(n_reader, 0);
30977: f = gen_xmlTextReaderErrorFunc_ptr(n_f, 1);
30978: arg = gen_void_ptr_ptr(n_arg, 2);
30979:
30980: xmlTextReaderGetErrorHandler(reader, f, arg);
30981: call_tests++;
30982: des_xmlTextReaderPtr(n_reader, reader, 0);
30983: des_xmlTextReaderErrorFunc_ptr(n_f, f, 1);
30984: des_void_ptr_ptr(n_arg, arg, 2);
30985: xmlResetLastError();
30986: if (mem_base != xmlMemBlocks()) {
30987: printf("Leak of %d blocks found in xmlTextReaderGetErrorHandler",
30988: xmlMemBlocks() - mem_base);
30989: test_ret++;
30990: printf(" %d", n_reader);
30991: printf(" %d", n_f);
30992: printf(" %d", n_arg);
30993: printf("\n");
30994: }
30995: }
30996: }
30997: }
30998: function_tests++;
30999: #endif
31000:
31001: return(test_ret);
31002: }
31003:
31004:
31005: static int
31006: test_xmlTextReaderGetParserColumnNumber(void) {
31007: int test_ret = 0;
31008:
31009: #if defined(LIBXML_READER_ENABLED)
31010: int mem_base;
31011: int ret_val;
31012: xmlTextReaderPtr reader; /* the user data (XML reader context) */
31013: int n_reader;
31014:
31015: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31016: mem_base = xmlMemBlocks();
31017: reader = gen_xmlTextReaderPtr(n_reader, 0);
31018:
31019: ret_val = xmlTextReaderGetParserColumnNumber(reader);
31020: desret_int(ret_val);
31021: call_tests++;
31022: des_xmlTextReaderPtr(n_reader, reader, 0);
31023: xmlResetLastError();
31024: if (mem_base != xmlMemBlocks()) {
31025: printf("Leak of %d blocks found in xmlTextReaderGetParserColumnNumber",
31026: xmlMemBlocks() - mem_base);
31027: test_ret++;
31028: printf(" %d", n_reader);
31029: printf("\n");
31030: }
31031: }
31032: function_tests++;
31033: #endif
31034:
31035: return(test_ret);
31036: }
31037:
31038:
31039: static int
31040: test_xmlTextReaderGetParserLineNumber(void) {
31041: int test_ret = 0;
31042:
31043: #if defined(LIBXML_READER_ENABLED)
31044: int mem_base;
31045: int ret_val;
31046: xmlTextReaderPtr reader; /* the user data (XML reader context) */
31047: int n_reader;
31048:
31049: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31050: mem_base = xmlMemBlocks();
31051: reader = gen_xmlTextReaderPtr(n_reader, 0);
31052:
31053: ret_val = xmlTextReaderGetParserLineNumber(reader);
31054: desret_int(ret_val);
31055: call_tests++;
31056: des_xmlTextReaderPtr(n_reader, reader, 0);
31057: xmlResetLastError();
31058: if (mem_base != xmlMemBlocks()) {
31059: printf("Leak of %d blocks found in xmlTextReaderGetParserLineNumber",
31060: xmlMemBlocks() - mem_base);
31061: test_ret++;
31062: printf(" %d", n_reader);
31063: printf("\n");
31064: }
31065: }
31066: function_tests++;
31067: #endif
31068:
31069: return(test_ret);
31070: }
31071:
31072:
31073: static int
31074: test_xmlTextReaderGetParserProp(void) {
31075: int test_ret = 0;
31076:
31077: #if defined(LIBXML_READER_ENABLED)
31078: int mem_base;
31079: int ret_val;
31080: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31081: int n_reader;
31082: int prop; /* the xmlParserProperties to get */
31083: int n_prop;
31084:
31085: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31086: for (n_prop = 0;n_prop < gen_nb_int;n_prop++) {
31087: mem_base = xmlMemBlocks();
31088: reader = gen_xmlTextReaderPtr(n_reader, 0);
31089: prop = gen_int(n_prop, 1);
31090:
31091: ret_val = xmlTextReaderGetParserProp(reader, prop);
31092: desret_int(ret_val);
31093: call_tests++;
31094: des_xmlTextReaderPtr(n_reader, reader, 0);
31095: des_int(n_prop, prop, 1);
31096: xmlResetLastError();
31097: if (mem_base != xmlMemBlocks()) {
31098: printf("Leak of %d blocks found in xmlTextReaderGetParserProp",
31099: xmlMemBlocks() - mem_base);
31100: test_ret++;
31101: printf(" %d", n_reader);
31102: printf(" %d", n_prop);
31103: printf("\n");
31104: }
31105: }
31106: }
31107: function_tests++;
31108: #endif
31109:
31110: return(test_ret);
31111: }
31112:
31113:
31114: static int
31115: test_xmlTextReaderGetRemainder(void) {
31116: int test_ret = 0;
31117:
31118: #if defined(LIBXML_READER_ENABLED)
31119: int mem_base;
31120: xmlParserInputBufferPtr ret_val;
31121: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31122: int n_reader;
31123:
31124: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31125: mem_base = xmlMemBlocks();
31126: reader = gen_xmlTextReaderPtr(n_reader, 0);
31127:
31128: ret_val = xmlTextReaderGetRemainder(reader);
31129: desret_xmlParserInputBufferPtr(ret_val);
31130: call_tests++;
31131: des_xmlTextReaderPtr(n_reader, reader, 0);
31132: xmlResetLastError();
31133: if (mem_base != xmlMemBlocks()) {
31134: printf("Leak of %d blocks found in xmlTextReaderGetRemainder",
31135: xmlMemBlocks() - mem_base);
31136: test_ret++;
31137: printf(" %d", n_reader);
31138: printf("\n");
31139: }
31140: }
31141: function_tests++;
31142: #endif
31143:
31144: return(test_ret);
31145: }
31146:
31147:
31148: static int
31149: test_xmlTextReaderHasAttributes(void) {
31150: int test_ret = 0;
31151:
31152: #if defined(LIBXML_READER_ENABLED)
31153: int mem_base;
31154: int ret_val;
31155: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31156: int n_reader;
31157:
31158: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31159: mem_base = xmlMemBlocks();
31160: reader = gen_xmlTextReaderPtr(n_reader, 0);
31161:
31162: ret_val = xmlTextReaderHasAttributes(reader);
31163: desret_int(ret_val);
31164: call_tests++;
31165: des_xmlTextReaderPtr(n_reader, reader, 0);
31166: xmlResetLastError();
31167: if (mem_base != xmlMemBlocks()) {
31168: printf("Leak of %d blocks found in xmlTextReaderHasAttributes",
31169: xmlMemBlocks() - mem_base);
31170: test_ret++;
31171: printf(" %d", n_reader);
31172: printf("\n");
31173: }
31174: }
31175: function_tests++;
31176: #endif
31177:
31178: return(test_ret);
31179: }
31180:
31181:
31182: static int
31183: test_xmlTextReaderHasValue(void) {
31184: int test_ret = 0;
31185:
31186: #if defined(LIBXML_READER_ENABLED)
31187: int mem_base;
31188: int ret_val;
31189: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31190: int n_reader;
31191:
31192: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31193: mem_base = xmlMemBlocks();
31194: reader = gen_xmlTextReaderPtr(n_reader, 0);
31195:
31196: ret_val = xmlTextReaderHasValue(reader);
31197: desret_int(ret_val);
31198: call_tests++;
31199: des_xmlTextReaderPtr(n_reader, reader, 0);
31200: xmlResetLastError();
31201: if (mem_base != xmlMemBlocks()) {
31202: printf("Leak of %d blocks found in xmlTextReaderHasValue",
31203: xmlMemBlocks() - mem_base);
31204: test_ret++;
31205: printf(" %d", n_reader);
31206: printf("\n");
31207: }
31208: }
31209: function_tests++;
31210: #endif
31211:
31212: return(test_ret);
31213: }
31214:
31215:
31216: static int
31217: test_xmlTextReaderIsDefault(void) {
31218: int test_ret = 0;
31219:
31220: #if defined(LIBXML_READER_ENABLED)
31221: int mem_base;
31222: int ret_val;
31223: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31224: int n_reader;
31225:
31226: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31227: mem_base = xmlMemBlocks();
31228: reader = gen_xmlTextReaderPtr(n_reader, 0);
31229:
31230: ret_val = xmlTextReaderIsDefault(reader);
31231: desret_int(ret_val);
31232: call_tests++;
31233: des_xmlTextReaderPtr(n_reader, reader, 0);
31234: xmlResetLastError();
31235: if (mem_base != xmlMemBlocks()) {
31236: printf("Leak of %d blocks found in xmlTextReaderIsDefault",
31237: xmlMemBlocks() - mem_base);
31238: test_ret++;
31239: printf(" %d", n_reader);
31240: printf("\n");
31241: }
31242: }
31243: function_tests++;
31244: #endif
31245:
31246: return(test_ret);
31247: }
31248:
31249:
31250: static int
31251: test_xmlTextReaderIsEmptyElement(void) {
31252: int test_ret = 0;
31253:
31254: #if defined(LIBXML_READER_ENABLED)
31255: int mem_base;
31256: int ret_val;
31257: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31258: int n_reader;
31259:
31260: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31261: mem_base = xmlMemBlocks();
31262: reader = gen_xmlTextReaderPtr(n_reader, 0);
31263:
31264: ret_val = xmlTextReaderIsEmptyElement(reader);
31265: desret_int(ret_val);
31266: call_tests++;
31267: des_xmlTextReaderPtr(n_reader, reader, 0);
31268: xmlResetLastError();
31269: if (mem_base != xmlMemBlocks()) {
31270: printf("Leak of %d blocks found in xmlTextReaderIsEmptyElement",
31271: xmlMemBlocks() - mem_base);
31272: test_ret++;
31273: printf(" %d", n_reader);
31274: printf("\n");
31275: }
31276: }
31277: function_tests++;
31278: #endif
31279:
31280: return(test_ret);
31281: }
31282:
31283:
31284: static int
31285: test_xmlTextReaderIsNamespaceDecl(void) {
31286: int test_ret = 0;
31287:
31288: #if defined(LIBXML_READER_ENABLED)
31289: int mem_base;
31290: int ret_val;
31291: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31292: int n_reader;
31293:
31294: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31295: mem_base = xmlMemBlocks();
31296: reader = gen_xmlTextReaderPtr(n_reader, 0);
31297:
31298: ret_val = xmlTextReaderIsNamespaceDecl(reader);
31299: desret_int(ret_val);
31300: call_tests++;
31301: des_xmlTextReaderPtr(n_reader, reader, 0);
31302: xmlResetLastError();
31303: if (mem_base != xmlMemBlocks()) {
31304: printf("Leak of %d blocks found in xmlTextReaderIsNamespaceDecl",
31305: xmlMemBlocks() - mem_base);
31306: test_ret++;
31307: printf(" %d", n_reader);
31308: printf("\n");
31309: }
31310: }
31311: function_tests++;
31312: #endif
31313:
31314: return(test_ret);
31315: }
31316:
31317:
31318: static int
31319: test_xmlTextReaderIsValid(void) {
31320: int test_ret = 0;
31321:
31322: #if defined(LIBXML_READER_ENABLED)
31323: int mem_base;
31324: int ret_val;
31325: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31326: int n_reader;
31327:
31328: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31329: mem_base = xmlMemBlocks();
31330: reader = gen_xmlTextReaderPtr(n_reader, 0);
31331:
31332: ret_val = xmlTextReaderIsValid(reader);
31333: desret_int(ret_val);
31334: call_tests++;
31335: des_xmlTextReaderPtr(n_reader, reader, 0);
31336: xmlResetLastError();
31337: if (mem_base != xmlMemBlocks()) {
31338: printf("Leak of %d blocks found in xmlTextReaderIsValid",
31339: xmlMemBlocks() - mem_base);
31340: test_ret++;
31341: printf(" %d", n_reader);
31342: printf("\n");
31343: }
31344: }
31345: function_tests++;
31346: #endif
31347:
31348: return(test_ret);
31349: }
31350:
31351:
31352: static int
31353: test_xmlTextReaderLocalName(void) {
31354: int test_ret = 0;
31355:
31356: #if defined(LIBXML_READER_ENABLED)
31357: int mem_base;
31358: xmlChar * ret_val;
31359: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31360: int n_reader;
31361:
31362: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31363: mem_base = xmlMemBlocks();
31364: reader = gen_xmlTextReaderPtr(n_reader, 0);
31365:
31366: ret_val = xmlTextReaderLocalName(reader);
31367: desret_xmlChar_ptr(ret_val);
31368: call_tests++;
31369: des_xmlTextReaderPtr(n_reader, reader, 0);
31370: xmlResetLastError();
31371: if (mem_base != xmlMemBlocks()) {
31372: printf("Leak of %d blocks found in xmlTextReaderLocalName",
31373: xmlMemBlocks() - mem_base);
31374: test_ret++;
31375: printf(" %d", n_reader);
31376: printf("\n");
31377: }
31378: }
31379: function_tests++;
31380: #endif
31381:
31382: return(test_ret);
31383: }
31384:
31385: #ifdef LIBXML_READER_ENABLED
31386:
31387: #define gen_nb_xmlTextReaderLocatorPtr 1
31388: static xmlTextReaderLocatorPtr gen_xmlTextReaderLocatorPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
31389: return(NULL);
31390: }
31391: static void des_xmlTextReaderLocatorPtr(int no ATTRIBUTE_UNUSED, xmlTextReaderLocatorPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
31392: }
31393: #endif
31394:
31395:
31396: static int
31397: test_xmlTextReaderLocatorBaseURI(void) {
31398: int test_ret = 0;
31399:
31400: #if defined(LIBXML_READER_ENABLED)
31401: int mem_base;
31402: xmlChar * ret_val;
31403: xmlTextReaderLocatorPtr locator; /* the xmlTextReaderLocatorPtr used */
31404: int n_locator;
31405:
31406: for (n_locator = 0;n_locator < gen_nb_xmlTextReaderLocatorPtr;n_locator++) {
31407: mem_base = xmlMemBlocks();
31408: locator = gen_xmlTextReaderLocatorPtr(n_locator, 0);
31409:
31410: ret_val = xmlTextReaderLocatorBaseURI(locator);
31411: desret_xmlChar_ptr(ret_val);
31412: call_tests++;
31413: des_xmlTextReaderLocatorPtr(n_locator, locator, 0);
31414: xmlResetLastError();
31415: if (mem_base != xmlMemBlocks()) {
31416: printf("Leak of %d blocks found in xmlTextReaderLocatorBaseURI",
31417: xmlMemBlocks() - mem_base);
31418: test_ret++;
31419: printf(" %d", n_locator);
31420: printf("\n");
31421: }
31422: }
31423: function_tests++;
31424: #endif
31425:
31426: return(test_ret);
31427: }
31428:
31429:
31430: static int
31431: test_xmlTextReaderLocatorLineNumber(void) {
31432: int test_ret = 0;
31433:
31434: #if defined(LIBXML_READER_ENABLED)
31435: int mem_base;
31436: int ret_val;
31437: xmlTextReaderLocatorPtr locator; /* the xmlTextReaderLocatorPtr used */
31438: int n_locator;
31439:
31440: for (n_locator = 0;n_locator < gen_nb_xmlTextReaderLocatorPtr;n_locator++) {
31441: mem_base = xmlMemBlocks();
31442: locator = gen_xmlTextReaderLocatorPtr(n_locator, 0);
31443:
31444: ret_val = xmlTextReaderLocatorLineNumber(locator);
31445: desret_int(ret_val);
31446: call_tests++;
31447: des_xmlTextReaderLocatorPtr(n_locator, locator, 0);
31448: xmlResetLastError();
31449: if (mem_base != xmlMemBlocks()) {
31450: printf("Leak of %d blocks found in xmlTextReaderLocatorLineNumber",
31451: xmlMemBlocks() - mem_base);
31452: test_ret++;
31453: printf(" %d", n_locator);
31454: printf("\n");
31455: }
31456: }
31457: function_tests++;
31458: #endif
31459:
31460: return(test_ret);
31461: }
31462:
31463:
31464: static int
31465: test_xmlTextReaderLookupNamespace(void) {
31466: int test_ret = 0;
31467:
31468: #if defined(LIBXML_READER_ENABLED)
31469: int mem_base;
31470: xmlChar * ret_val;
31471: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31472: int n_reader;
31473: xmlChar * prefix; /* the prefix whose namespace URI is to be resolved. To return the default namespace, specify NULL */
31474: int n_prefix;
31475:
31476: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31477: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
31478: mem_base = xmlMemBlocks();
31479: reader = gen_xmlTextReaderPtr(n_reader, 0);
31480: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
31481:
31482: ret_val = xmlTextReaderLookupNamespace(reader, (const xmlChar *)prefix);
31483: desret_xmlChar_ptr(ret_val);
31484: call_tests++;
31485: des_xmlTextReaderPtr(n_reader, reader, 0);
31486: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
31487: xmlResetLastError();
31488: if (mem_base != xmlMemBlocks()) {
31489: printf("Leak of %d blocks found in xmlTextReaderLookupNamespace",
31490: xmlMemBlocks() - mem_base);
31491: test_ret++;
31492: printf(" %d", n_reader);
31493: printf(" %d", n_prefix);
31494: printf("\n");
31495: }
31496: }
31497: }
31498: function_tests++;
31499: #endif
31500:
31501: return(test_ret);
31502: }
31503:
31504:
31505: static int
31506: test_xmlTextReaderMoveToAttribute(void) {
31507: int test_ret = 0;
31508:
31509: #if defined(LIBXML_READER_ENABLED)
31510: int mem_base;
31511: int ret_val;
31512: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31513: int n_reader;
31514: xmlChar * name; /* the qualified name of the attribute. */
31515: int n_name;
31516:
31517: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31518: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
31519: mem_base = xmlMemBlocks();
31520: reader = gen_xmlTextReaderPtr(n_reader, 0);
31521: name = gen_const_xmlChar_ptr(n_name, 1);
31522:
31523: ret_val = xmlTextReaderMoveToAttribute(reader, (const xmlChar *)name);
31524: desret_int(ret_val);
31525: call_tests++;
31526: des_xmlTextReaderPtr(n_reader, reader, 0);
31527: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
31528: xmlResetLastError();
31529: if (mem_base != xmlMemBlocks()) {
31530: printf("Leak of %d blocks found in xmlTextReaderMoveToAttribute",
31531: xmlMemBlocks() - mem_base);
31532: test_ret++;
31533: printf(" %d", n_reader);
31534: printf(" %d", n_name);
31535: printf("\n");
31536: }
31537: }
31538: }
31539: function_tests++;
31540: #endif
31541:
31542: return(test_ret);
31543: }
31544:
31545:
31546: static int
31547: test_xmlTextReaderMoveToAttributeNo(void) {
31548: int test_ret = 0;
31549:
31550: #if defined(LIBXML_READER_ENABLED)
31551: int mem_base;
31552: int ret_val;
31553: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31554: int n_reader;
31555: int no; /* the zero-based index of the attribute relative to the containing element. */
31556: int n_no;
31557:
31558: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31559: for (n_no = 0;n_no < gen_nb_int;n_no++) {
31560: mem_base = xmlMemBlocks();
31561: reader = gen_xmlTextReaderPtr(n_reader, 0);
31562: no = gen_int(n_no, 1);
31563:
31564: ret_val = xmlTextReaderMoveToAttributeNo(reader, no);
31565: desret_int(ret_val);
31566: call_tests++;
31567: des_xmlTextReaderPtr(n_reader, reader, 0);
31568: des_int(n_no, no, 1);
31569: xmlResetLastError();
31570: if (mem_base != xmlMemBlocks()) {
31571: printf("Leak of %d blocks found in xmlTextReaderMoveToAttributeNo",
31572: xmlMemBlocks() - mem_base);
31573: test_ret++;
31574: printf(" %d", n_reader);
31575: printf(" %d", n_no);
31576: printf("\n");
31577: }
31578: }
31579: }
31580: function_tests++;
31581: #endif
31582:
31583: return(test_ret);
31584: }
31585:
31586:
31587: static int
31588: test_xmlTextReaderMoveToAttributeNs(void) {
31589: int test_ret = 0;
31590:
31591: #if defined(LIBXML_READER_ENABLED)
31592: int mem_base;
31593: int ret_val;
31594: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31595: int n_reader;
31596: xmlChar * localName; /* the local name of the attribute. */
31597: int n_localName;
31598: xmlChar * namespaceURI; /* the namespace URI of the attribute. */
31599: int n_namespaceURI;
31600:
31601: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31602: for (n_localName = 0;n_localName < gen_nb_const_xmlChar_ptr;n_localName++) {
31603: for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
31604: mem_base = xmlMemBlocks();
31605: reader = gen_xmlTextReaderPtr(n_reader, 0);
31606: localName = gen_const_xmlChar_ptr(n_localName, 1);
31607: namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 2);
31608:
31609: ret_val = xmlTextReaderMoveToAttributeNs(reader, (const xmlChar *)localName, (const xmlChar *)namespaceURI);
31610: desret_int(ret_val);
31611: call_tests++;
31612: des_xmlTextReaderPtr(n_reader, reader, 0);
31613: des_const_xmlChar_ptr(n_localName, (const xmlChar *)localName, 1);
31614: des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 2);
31615: xmlResetLastError();
31616: if (mem_base != xmlMemBlocks()) {
31617: printf("Leak of %d blocks found in xmlTextReaderMoveToAttributeNs",
31618: xmlMemBlocks() - mem_base);
31619: test_ret++;
31620: printf(" %d", n_reader);
31621: printf(" %d", n_localName);
31622: printf(" %d", n_namespaceURI);
31623: printf("\n");
31624: }
31625: }
31626: }
31627: }
31628: function_tests++;
31629: #endif
31630:
31631: return(test_ret);
31632: }
31633:
31634:
31635: static int
31636: test_xmlTextReaderMoveToElement(void) {
31637: int test_ret = 0;
31638:
31639: #if defined(LIBXML_READER_ENABLED)
31640: int mem_base;
31641: int ret_val;
31642: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31643: int n_reader;
31644:
31645: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31646: mem_base = xmlMemBlocks();
31647: reader = gen_xmlTextReaderPtr(n_reader, 0);
31648:
31649: ret_val = xmlTextReaderMoveToElement(reader);
31650: desret_int(ret_val);
31651: call_tests++;
31652: des_xmlTextReaderPtr(n_reader, reader, 0);
31653: xmlResetLastError();
31654: if (mem_base != xmlMemBlocks()) {
31655: printf("Leak of %d blocks found in xmlTextReaderMoveToElement",
31656: xmlMemBlocks() - mem_base);
31657: test_ret++;
31658: printf(" %d", n_reader);
31659: printf("\n");
31660: }
31661: }
31662: function_tests++;
31663: #endif
31664:
31665: return(test_ret);
31666: }
31667:
31668:
31669: static int
31670: test_xmlTextReaderMoveToFirstAttribute(void) {
31671: int test_ret = 0;
31672:
31673: #if defined(LIBXML_READER_ENABLED)
31674: int mem_base;
31675: int ret_val;
31676: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31677: int n_reader;
31678:
31679: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31680: mem_base = xmlMemBlocks();
31681: reader = gen_xmlTextReaderPtr(n_reader, 0);
31682:
31683: ret_val = xmlTextReaderMoveToFirstAttribute(reader);
31684: desret_int(ret_val);
31685: call_tests++;
31686: des_xmlTextReaderPtr(n_reader, reader, 0);
31687: xmlResetLastError();
31688: if (mem_base != xmlMemBlocks()) {
31689: printf("Leak of %d blocks found in xmlTextReaderMoveToFirstAttribute",
31690: xmlMemBlocks() - mem_base);
31691: test_ret++;
31692: printf(" %d", n_reader);
31693: printf("\n");
31694: }
31695: }
31696: function_tests++;
31697: #endif
31698:
31699: return(test_ret);
31700: }
31701:
31702:
31703: static int
31704: test_xmlTextReaderMoveToNextAttribute(void) {
31705: int test_ret = 0;
31706:
31707: #if defined(LIBXML_READER_ENABLED)
31708: int mem_base;
31709: int ret_val;
31710: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31711: int n_reader;
31712:
31713: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31714: mem_base = xmlMemBlocks();
31715: reader = gen_xmlTextReaderPtr(n_reader, 0);
31716:
31717: ret_val = xmlTextReaderMoveToNextAttribute(reader);
31718: desret_int(ret_val);
31719: call_tests++;
31720: des_xmlTextReaderPtr(n_reader, reader, 0);
31721: xmlResetLastError();
31722: if (mem_base != xmlMemBlocks()) {
31723: printf("Leak of %d blocks found in xmlTextReaderMoveToNextAttribute",
31724: xmlMemBlocks() - mem_base);
31725: test_ret++;
31726: printf(" %d", n_reader);
31727: printf("\n");
31728: }
31729: }
31730: function_tests++;
31731: #endif
31732:
31733: return(test_ret);
31734: }
31735:
31736:
31737: static int
31738: test_xmlTextReaderName(void) {
31739: int test_ret = 0;
31740:
31741: #if defined(LIBXML_READER_ENABLED)
31742: int mem_base;
31743: xmlChar * ret_val;
31744: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31745: int n_reader;
31746:
31747: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31748: mem_base = xmlMemBlocks();
31749: reader = gen_xmlTextReaderPtr(n_reader, 0);
31750:
31751: ret_val = xmlTextReaderName(reader);
31752: desret_xmlChar_ptr(ret_val);
31753: call_tests++;
31754: des_xmlTextReaderPtr(n_reader, reader, 0);
31755: xmlResetLastError();
31756: if (mem_base != xmlMemBlocks()) {
31757: printf("Leak of %d blocks found in xmlTextReaderName",
31758: xmlMemBlocks() - mem_base);
31759: test_ret++;
31760: printf(" %d", n_reader);
31761: printf("\n");
31762: }
31763: }
31764: function_tests++;
31765: #endif
31766:
31767: return(test_ret);
31768: }
31769:
31770:
31771: static int
31772: test_xmlTextReaderNamespaceUri(void) {
31773: int test_ret = 0;
31774:
31775: #if defined(LIBXML_READER_ENABLED)
31776: int mem_base;
31777: xmlChar * ret_val;
31778: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31779: int n_reader;
31780:
31781: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31782: mem_base = xmlMemBlocks();
31783: reader = gen_xmlTextReaderPtr(n_reader, 0);
31784:
31785: ret_val = xmlTextReaderNamespaceUri(reader);
31786: desret_xmlChar_ptr(ret_val);
31787: call_tests++;
31788: des_xmlTextReaderPtr(n_reader, reader, 0);
31789: xmlResetLastError();
31790: if (mem_base != xmlMemBlocks()) {
31791: printf("Leak of %d blocks found in xmlTextReaderNamespaceUri",
31792: xmlMemBlocks() - mem_base);
31793: test_ret++;
31794: printf(" %d", n_reader);
31795: printf("\n");
31796: }
31797: }
31798: function_tests++;
31799: #endif
31800:
31801: return(test_ret);
31802: }
31803:
31804:
31805: static int
31806: test_xmlTextReaderNext(void) {
31807: int test_ret = 0;
31808:
31809: #if defined(LIBXML_READER_ENABLED)
31810: int mem_base;
31811: int ret_val;
31812: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31813: int n_reader;
31814:
31815: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31816: mem_base = xmlMemBlocks();
31817: reader = gen_xmlTextReaderPtr(n_reader, 0);
31818:
31819: ret_val = xmlTextReaderNext(reader);
31820: desret_int(ret_val);
31821: call_tests++;
31822: des_xmlTextReaderPtr(n_reader, reader, 0);
31823: xmlResetLastError();
31824: if (mem_base != xmlMemBlocks()) {
31825: printf("Leak of %d blocks found in xmlTextReaderNext",
31826: xmlMemBlocks() - mem_base);
31827: test_ret++;
31828: printf(" %d", n_reader);
31829: printf("\n");
31830: }
31831: }
31832: function_tests++;
31833: #endif
31834:
31835: return(test_ret);
31836: }
31837:
31838:
31839: static int
31840: test_xmlTextReaderNextSibling(void) {
31841: int test_ret = 0;
31842:
31843: #if defined(LIBXML_READER_ENABLED)
31844: int mem_base;
31845: int ret_val;
31846: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31847: int n_reader;
31848:
31849: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31850: mem_base = xmlMemBlocks();
31851: reader = gen_xmlTextReaderPtr(n_reader, 0);
31852:
31853: ret_val = xmlTextReaderNextSibling(reader);
31854: desret_int(ret_val);
31855: call_tests++;
31856: des_xmlTextReaderPtr(n_reader, reader, 0);
31857: xmlResetLastError();
31858: if (mem_base != xmlMemBlocks()) {
31859: printf("Leak of %d blocks found in xmlTextReaderNextSibling",
31860: xmlMemBlocks() - mem_base);
31861: test_ret++;
31862: printf(" %d", n_reader);
31863: printf("\n");
31864: }
31865: }
31866: function_tests++;
31867: #endif
31868:
31869: return(test_ret);
31870: }
31871:
31872:
31873: static int
31874: test_xmlTextReaderNodeType(void) {
31875: int test_ret = 0;
31876:
31877: #if defined(LIBXML_READER_ENABLED)
31878: int mem_base;
31879: int ret_val;
31880: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31881: int n_reader;
31882:
31883: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31884: mem_base = xmlMemBlocks();
31885: reader = gen_xmlTextReaderPtr(n_reader, 0);
31886:
31887: ret_val = xmlTextReaderNodeType(reader);
31888: desret_int(ret_val);
31889: call_tests++;
31890: des_xmlTextReaderPtr(n_reader, reader, 0);
31891: xmlResetLastError();
31892: if (mem_base != xmlMemBlocks()) {
31893: printf("Leak of %d blocks found in xmlTextReaderNodeType",
31894: xmlMemBlocks() - mem_base);
31895: test_ret++;
31896: printf(" %d", n_reader);
31897: printf("\n");
31898: }
31899: }
31900: function_tests++;
31901: #endif
31902:
31903: return(test_ret);
31904: }
31905:
31906:
31907: static int
31908: test_xmlTextReaderNormalization(void) {
31909: int test_ret = 0;
31910:
31911: #if defined(LIBXML_READER_ENABLED)
31912: int mem_base;
31913: int ret_val;
31914: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31915: int n_reader;
31916:
31917: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31918: mem_base = xmlMemBlocks();
31919: reader = gen_xmlTextReaderPtr(n_reader, 0);
31920:
31921: ret_val = xmlTextReaderNormalization(reader);
31922: desret_int(ret_val);
31923: call_tests++;
31924: des_xmlTextReaderPtr(n_reader, reader, 0);
31925: xmlResetLastError();
31926: if (mem_base != xmlMemBlocks()) {
31927: printf("Leak of %d blocks found in xmlTextReaderNormalization",
31928: xmlMemBlocks() - mem_base);
31929: test_ret++;
31930: printf(" %d", n_reader);
31931: printf("\n");
31932: }
31933: }
31934: function_tests++;
31935: #endif
31936:
31937: return(test_ret);
31938: }
31939:
31940:
31941: static int
31942: test_xmlTextReaderPrefix(void) {
31943: int test_ret = 0;
31944:
31945: #if defined(LIBXML_READER_ENABLED)
31946: int mem_base;
31947: xmlChar * ret_val;
31948: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31949: int n_reader;
31950:
31951: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31952: mem_base = xmlMemBlocks();
31953: reader = gen_xmlTextReaderPtr(n_reader, 0);
31954:
31955: ret_val = xmlTextReaderPrefix(reader);
31956: desret_xmlChar_ptr(ret_val);
31957: call_tests++;
31958: des_xmlTextReaderPtr(n_reader, reader, 0);
31959: xmlResetLastError();
31960: if (mem_base != xmlMemBlocks()) {
31961: printf("Leak of %d blocks found in xmlTextReaderPrefix",
31962: xmlMemBlocks() - mem_base);
31963: test_ret++;
31964: printf(" %d", n_reader);
31965: printf("\n");
31966: }
31967: }
31968: function_tests++;
31969: #endif
31970:
31971: return(test_ret);
31972: }
31973:
31974:
31975: static int
31976: test_xmlTextReaderPreserve(void) {
31977: int test_ret = 0;
31978:
31979: #if defined(LIBXML_READER_ENABLED)
31980: int mem_base;
31981: xmlNodePtr ret_val;
31982: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31983: int n_reader;
31984:
31985: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31986: mem_base = xmlMemBlocks();
31987: reader = gen_xmlTextReaderPtr(n_reader, 0);
31988:
31989: ret_val = xmlTextReaderPreserve(reader);
31990: desret_xmlNodePtr(ret_val);
31991: call_tests++;
31992: des_xmlTextReaderPtr(n_reader, reader, 0);
31993: xmlResetLastError();
31994: if (mem_base != xmlMemBlocks()) {
31995: printf("Leak of %d blocks found in xmlTextReaderPreserve",
31996: xmlMemBlocks() - mem_base);
31997: test_ret++;
31998: printf(" %d", n_reader);
31999: printf("\n");
32000: }
32001: }
32002: function_tests++;
32003: #endif
32004:
32005: return(test_ret);
32006: }
32007:
32008:
32009: static int
32010: test_xmlTextReaderPreservePattern(void) {
32011: int test_ret = 0;
32012:
32013: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_PATTERN_ENABLED)
32014: #ifdef LIBXML_PATTERN_ENABLED
32015: int mem_base;
32016: int ret_val;
32017: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32018: int n_reader;
32019: xmlChar * pattern; /* an XPath subset pattern */
32020: int n_pattern;
32021: xmlChar ** namespaces; /* the prefix definitions, array of [URI, prefix] or NULL */
32022: int n_namespaces;
32023:
32024: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32025: for (n_pattern = 0;n_pattern < gen_nb_const_xmlChar_ptr;n_pattern++) {
32026: for (n_namespaces = 0;n_namespaces < gen_nb_const_xmlChar_ptr_ptr;n_namespaces++) {
32027: mem_base = xmlMemBlocks();
32028: reader = gen_xmlTextReaderPtr(n_reader, 0);
32029: pattern = gen_const_xmlChar_ptr(n_pattern, 1);
32030: namespaces = gen_const_xmlChar_ptr_ptr(n_namespaces, 2);
32031:
32032: ret_val = xmlTextReaderPreservePattern(reader, (const xmlChar *)pattern, (const xmlChar **)namespaces);
32033: desret_int(ret_val);
32034: call_tests++;
32035: des_xmlTextReaderPtr(n_reader, reader, 0);
32036: des_const_xmlChar_ptr(n_pattern, (const xmlChar *)pattern, 1);
32037: des_const_xmlChar_ptr_ptr(n_namespaces, (const xmlChar **)namespaces, 2);
32038: xmlResetLastError();
32039: if (mem_base != xmlMemBlocks()) {
32040: printf("Leak of %d blocks found in xmlTextReaderPreservePattern",
32041: xmlMemBlocks() - mem_base);
32042: test_ret++;
32043: printf(" %d", n_reader);
32044: printf(" %d", n_pattern);
32045: printf(" %d", n_namespaces);
32046: printf("\n");
32047: }
32048: }
32049: }
32050: }
32051: function_tests++;
32052: #endif
32053: #endif
32054:
32055: return(test_ret);
32056: }
32057:
32058:
32059: static int
32060: test_xmlTextReaderQuoteChar(void) {
32061: int test_ret = 0;
32062:
32063: #if defined(LIBXML_READER_ENABLED)
32064: int mem_base;
32065: int ret_val;
32066: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32067: int n_reader;
32068:
32069: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32070: mem_base = xmlMemBlocks();
32071: reader = gen_xmlTextReaderPtr(n_reader, 0);
32072:
32073: ret_val = xmlTextReaderQuoteChar(reader);
32074: desret_int(ret_val);
32075: call_tests++;
32076: des_xmlTextReaderPtr(n_reader, reader, 0);
32077: xmlResetLastError();
32078: if (mem_base != xmlMemBlocks()) {
32079: printf("Leak of %d blocks found in xmlTextReaderQuoteChar",
32080: xmlMemBlocks() - mem_base);
32081: test_ret++;
32082: printf(" %d", n_reader);
32083: printf("\n");
32084: }
32085: }
32086: function_tests++;
32087: #endif
32088:
32089: return(test_ret);
32090: }
32091:
32092:
32093: static int
32094: test_xmlTextReaderRead(void) {
32095: int test_ret = 0;
32096:
32097: #if defined(LIBXML_READER_ENABLED)
32098: int mem_base;
32099: int ret_val;
32100: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32101: int n_reader;
32102:
32103: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32104: mem_base = xmlMemBlocks();
32105: reader = gen_xmlTextReaderPtr(n_reader, 0);
32106:
32107: ret_val = xmlTextReaderRead(reader);
32108: desret_int(ret_val);
32109: call_tests++;
32110: des_xmlTextReaderPtr(n_reader, reader, 0);
32111: xmlResetLastError();
32112: if (mem_base != xmlMemBlocks()) {
32113: printf("Leak of %d blocks found in xmlTextReaderRead",
32114: xmlMemBlocks() - mem_base);
32115: test_ret++;
32116: printf(" %d", n_reader);
32117: printf("\n");
32118: }
32119: }
32120: function_tests++;
32121: #endif
32122:
32123: return(test_ret);
32124: }
32125:
32126:
32127: static int
32128: test_xmlTextReaderReadAttributeValue(void) {
32129: int test_ret = 0;
32130:
32131: #if defined(LIBXML_READER_ENABLED)
32132: int mem_base;
32133: int ret_val;
32134: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32135: int n_reader;
32136:
32137: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32138: mem_base = xmlMemBlocks();
32139: reader = gen_xmlTextReaderPtr(n_reader, 0);
32140:
32141: ret_val = xmlTextReaderReadAttributeValue(reader);
32142: desret_int(ret_val);
32143: call_tests++;
32144: des_xmlTextReaderPtr(n_reader, reader, 0);
32145: xmlResetLastError();
32146: if (mem_base != xmlMemBlocks()) {
32147: printf("Leak of %d blocks found in xmlTextReaderReadAttributeValue",
32148: xmlMemBlocks() - mem_base);
32149: test_ret++;
32150: printf(" %d", n_reader);
32151: printf("\n");
32152: }
32153: }
32154: function_tests++;
32155: #endif
32156:
32157: return(test_ret);
32158: }
32159:
32160:
32161: static int
32162: test_xmlTextReaderReadState(void) {
32163: int test_ret = 0;
32164:
32165: #if defined(LIBXML_READER_ENABLED)
32166: int mem_base;
32167: int ret_val;
32168: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32169: int n_reader;
32170:
32171: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32172: mem_base = xmlMemBlocks();
32173: reader = gen_xmlTextReaderPtr(n_reader, 0);
32174:
32175: ret_val = xmlTextReaderReadState(reader);
32176: desret_int(ret_val);
32177: call_tests++;
32178: des_xmlTextReaderPtr(n_reader, reader, 0);
32179: xmlResetLastError();
32180: if (mem_base != xmlMemBlocks()) {
32181: printf("Leak of %d blocks found in xmlTextReaderReadState",
32182: xmlMemBlocks() - mem_base);
32183: test_ret++;
32184: printf(" %d", n_reader);
32185: printf("\n");
32186: }
32187: }
32188: function_tests++;
32189: #endif
32190:
32191: return(test_ret);
32192: }
32193:
32194:
32195: static int
32196: test_xmlTextReaderRelaxNGSetSchema(void) {
32197: int test_ret = 0;
32198:
32199: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
32200: int mem_base;
32201: int ret_val;
32202: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32203: int n_reader;
32204: xmlRelaxNGPtr schema; /* a precompiled RelaxNG schema */
32205: int n_schema;
32206:
32207: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32208: for (n_schema = 0;n_schema < gen_nb_xmlRelaxNGPtr;n_schema++) {
32209: mem_base = xmlMemBlocks();
32210: reader = gen_xmlTextReaderPtr(n_reader, 0);
32211: schema = gen_xmlRelaxNGPtr(n_schema, 1);
32212:
32213: ret_val = xmlTextReaderRelaxNGSetSchema(reader, schema);
32214: desret_int(ret_val);
32215: call_tests++;
32216: des_xmlTextReaderPtr(n_reader, reader, 0);
32217: des_xmlRelaxNGPtr(n_schema, schema, 1);
32218: xmlResetLastError();
32219: if (mem_base != xmlMemBlocks()) {
32220: printf("Leak of %d blocks found in xmlTextReaderRelaxNGSetSchema",
32221: xmlMemBlocks() - mem_base);
32222: test_ret++;
32223: printf(" %d", n_reader);
32224: printf(" %d", n_schema);
32225: printf("\n");
32226: }
32227: }
32228: }
32229: function_tests++;
32230: #endif
32231:
32232: return(test_ret);
32233: }
32234:
32235:
32236: static int
32237: test_xmlTextReaderRelaxNGValidate(void) {
32238: int test_ret = 0;
32239:
32240: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
32241: int mem_base;
32242: int ret_val;
32243: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32244: int n_reader;
32245: char * rng; /* the path to a RelaxNG schema or NULL */
32246: int n_rng;
32247:
32248: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32249: for (n_rng = 0;n_rng < gen_nb_const_char_ptr;n_rng++) {
32250: mem_base = xmlMemBlocks();
32251: reader = gen_xmlTextReaderPtr(n_reader, 0);
32252: rng = gen_const_char_ptr(n_rng, 1);
32253:
32254: ret_val = xmlTextReaderRelaxNGValidate(reader, (const char *)rng);
32255: desret_int(ret_val);
32256: call_tests++;
32257: des_xmlTextReaderPtr(n_reader, reader, 0);
32258: des_const_char_ptr(n_rng, (const char *)rng, 1);
32259: xmlResetLastError();
32260: if (mem_base != xmlMemBlocks()) {
32261: printf("Leak of %d blocks found in xmlTextReaderRelaxNGValidate",
32262: xmlMemBlocks() - mem_base);
32263: test_ret++;
32264: printf(" %d", n_reader);
32265: printf(" %d", n_rng);
32266: printf("\n");
32267: }
32268: }
32269: }
32270: function_tests++;
32271: #endif
32272:
32273: return(test_ret);
32274: }
32275:
32276:
32277: static int
32278: test_xmlTextReaderSchemaValidate(void) {
32279: int test_ret = 0;
32280:
32281: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
32282: int ret_val;
32283: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32284: int n_reader;
32285: char * xsd; /* the path to a W3C XSD schema or NULL */
32286: int n_xsd;
32287:
32288: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32289: for (n_xsd = 0;n_xsd < gen_nb_const_char_ptr;n_xsd++) {
32290: reader = gen_xmlTextReaderPtr(n_reader, 0);
32291: xsd = gen_const_char_ptr(n_xsd, 1);
32292:
32293: ret_val = xmlTextReaderSchemaValidate(reader, (const char *)xsd);
32294: desret_int(ret_val);
32295: call_tests++;
32296: des_xmlTextReaderPtr(n_reader, reader, 0);
32297: des_const_char_ptr(n_xsd, (const char *)xsd, 1);
32298: xmlResetLastError();
32299: }
32300: }
32301: function_tests++;
32302: #endif
32303:
32304: return(test_ret);
32305: }
32306:
32307:
32308: static int
32309: test_xmlTextReaderSchemaValidateCtxt(void) {
32310: int test_ret = 0;
32311:
32312: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
32313: int mem_base;
32314: int ret_val;
32315: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32316: int n_reader;
32317: xmlSchemaValidCtxtPtr ctxt; /* the XML Schema validation context or NULL */
32318: int n_ctxt;
32319: int options; /* options (not used yet) */
32320: int n_options;
32321:
32322: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32323: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
32324: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
32325: mem_base = xmlMemBlocks();
32326: reader = gen_xmlTextReaderPtr(n_reader, 0);
32327: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 1);
32328: options = gen_parseroptions(n_options, 2);
32329:
32330: ret_val = xmlTextReaderSchemaValidateCtxt(reader, ctxt, options);
32331: desret_int(ret_val);
32332: call_tests++;
32333: des_xmlTextReaderPtr(n_reader, reader, 0);
32334: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 1);
32335: des_parseroptions(n_options, options, 2);
32336: xmlResetLastError();
32337: if (mem_base != xmlMemBlocks()) {
32338: printf("Leak of %d blocks found in xmlTextReaderSchemaValidateCtxt",
32339: xmlMemBlocks() - mem_base);
32340: test_ret++;
32341: printf(" %d", n_reader);
32342: printf(" %d", n_ctxt);
32343: printf(" %d", n_options);
32344: printf("\n");
32345: }
32346: }
32347: }
32348: }
32349: function_tests++;
32350: #endif
32351:
32352: return(test_ret);
32353: }
32354:
32355:
32356: static int
32357: test_xmlTextReaderSetErrorHandler(void) {
32358: int test_ret = 0;
32359:
32360:
32361: /* missing type support */
32362: return(test_ret);
32363: }
32364:
32365:
32366: static int
32367: test_xmlTextReaderSetParserProp(void) {
32368: int test_ret = 0;
32369:
32370: #if defined(LIBXML_READER_ENABLED)
32371: int mem_base;
32372: int ret_val;
32373: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32374: int n_reader;
32375: int prop; /* the xmlParserProperties to set */
32376: int n_prop;
32377: int value; /* usually 0 or 1 to (de)activate it */
32378: int n_value;
32379:
32380: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32381: for (n_prop = 0;n_prop < gen_nb_int;n_prop++) {
32382: for (n_value = 0;n_value < gen_nb_int;n_value++) {
32383: mem_base = xmlMemBlocks();
32384: reader = gen_xmlTextReaderPtr(n_reader, 0);
32385: prop = gen_int(n_prop, 1);
32386: value = gen_int(n_value, 2);
32387:
32388: ret_val = xmlTextReaderSetParserProp(reader, prop, value);
32389: desret_int(ret_val);
32390: call_tests++;
32391: des_xmlTextReaderPtr(n_reader, reader, 0);
32392: des_int(n_prop, prop, 1);
32393: des_int(n_value, value, 2);
32394: xmlResetLastError();
32395: if (mem_base != xmlMemBlocks()) {
32396: printf("Leak of %d blocks found in xmlTextReaderSetParserProp",
32397: xmlMemBlocks() - mem_base);
32398: test_ret++;
32399: printf(" %d", n_reader);
32400: printf(" %d", n_prop);
32401: printf(" %d", n_value);
32402: printf("\n");
32403: }
32404: }
32405: }
32406: }
32407: function_tests++;
32408: #endif
32409:
32410: return(test_ret);
32411: }
32412:
32413:
32414: static int
32415: test_xmlTextReaderSetSchema(void) {
32416: int test_ret = 0;
32417:
32418: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
32419: int mem_base;
32420: int ret_val;
32421: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32422: int n_reader;
32423: xmlSchemaPtr schema; /* a precompiled Schema schema */
32424: int n_schema;
32425:
32426: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32427: for (n_schema = 0;n_schema < gen_nb_xmlSchemaPtr;n_schema++) {
32428: mem_base = xmlMemBlocks();
32429: reader = gen_xmlTextReaderPtr(n_reader, 0);
32430: schema = gen_xmlSchemaPtr(n_schema, 1);
32431:
32432: ret_val = xmlTextReaderSetSchema(reader, schema);
32433: desret_int(ret_val);
32434: call_tests++;
32435: des_xmlTextReaderPtr(n_reader, reader, 0);
32436: des_xmlSchemaPtr(n_schema, schema, 1);
32437: xmlResetLastError();
32438: if (mem_base != xmlMemBlocks()) {
32439: printf("Leak of %d blocks found in xmlTextReaderSetSchema",
32440: xmlMemBlocks() - mem_base);
32441: test_ret++;
32442: printf(" %d", n_reader);
32443: printf(" %d", n_schema);
32444: printf("\n");
32445: }
32446: }
32447: }
32448: function_tests++;
32449: #endif
32450:
32451: return(test_ret);
32452: }
32453:
32454:
32455: static int
32456: test_xmlTextReaderSetStructuredErrorHandler(void) {
32457: int test_ret = 0;
32458:
32459:
32460: /* missing type support */
32461: return(test_ret);
32462: }
32463:
32464:
32465: static int
32466: test_xmlTextReaderSetup(void) {
32467: int test_ret = 0;
32468:
32469: #if defined(LIBXML_READER_ENABLED)
32470: int mem_base;
32471: int ret_val;
32472: xmlTextReaderPtr reader; /* an XML reader */
32473: int n_reader;
32474: xmlParserInputBufferPtr input; /* xmlParserInputBufferPtr used to feed the reader, will be destroyed with it. */
32475: int n_input;
32476: const char * URL; /* the base URL to use for the document */
32477: int n_URL;
32478: char * encoding; /* the document encoding, or NULL */
32479: int n_encoding;
32480: int options; /* a combination of xmlParserOption */
32481: int n_options;
32482:
32483: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32484: for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) {
32485: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
32486: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
32487: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
32488: mem_base = xmlMemBlocks();
32489: reader = gen_xmlTextReaderPtr(n_reader, 0);
32490: input = gen_xmlParserInputBufferPtr(n_input, 1);
32491: URL = gen_filepath(n_URL, 2);
32492: encoding = gen_const_char_ptr(n_encoding, 3);
32493: options = gen_parseroptions(n_options, 4);
32494:
32495: ret_val = xmlTextReaderSetup(reader, input, URL, (const char *)encoding, options);
32496: desret_int(ret_val);
32497: call_tests++;
32498: des_xmlTextReaderPtr(n_reader, reader, 0);
32499: des_filepath(n_URL, URL, 2);
32500: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
32501: des_parseroptions(n_options, options, 4);
32502: xmlResetLastError();
32503: if (mem_base != xmlMemBlocks()) {
32504: printf("Leak of %d blocks found in xmlTextReaderSetup",
32505: xmlMemBlocks() - mem_base);
32506: test_ret++;
32507: printf(" %d", n_reader);
32508: printf(" %d", n_input);
32509: printf(" %d", n_URL);
32510: printf(" %d", n_encoding);
32511: printf(" %d", n_options);
32512: printf("\n");
32513: }
32514: }
32515: }
32516: }
32517: }
32518: }
32519: function_tests++;
32520: #endif
32521:
32522: return(test_ret);
32523: }
32524:
32525:
32526: static int
32527: test_xmlTextReaderStandalone(void) {
32528: int test_ret = 0;
32529:
32530: #if defined(LIBXML_READER_ENABLED)
32531: int mem_base;
32532: int ret_val;
32533: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32534: int n_reader;
32535:
32536: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32537: mem_base = xmlMemBlocks();
32538: reader = gen_xmlTextReaderPtr(n_reader, 0);
32539:
32540: ret_val = xmlTextReaderStandalone(reader);
32541: desret_int(ret_val);
32542: call_tests++;
32543: des_xmlTextReaderPtr(n_reader, reader, 0);
32544: xmlResetLastError();
32545: if (mem_base != xmlMemBlocks()) {
32546: printf("Leak of %d blocks found in xmlTextReaderStandalone",
32547: xmlMemBlocks() - mem_base);
32548: test_ret++;
32549: printf(" %d", n_reader);
32550: printf("\n");
32551: }
32552: }
32553: function_tests++;
32554: #endif
32555:
32556: return(test_ret);
32557: }
32558:
32559:
32560: static int
32561: test_xmlTextReaderValue(void) {
32562: int test_ret = 0;
32563:
32564: #if defined(LIBXML_READER_ENABLED)
32565: int mem_base;
32566: xmlChar * ret_val;
32567: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32568: int n_reader;
32569:
32570: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32571: mem_base = xmlMemBlocks();
32572: reader = gen_xmlTextReaderPtr(n_reader, 0);
32573:
32574: ret_val = xmlTextReaderValue(reader);
32575: desret_xmlChar_ptr(ret_val);
32576: call_tests++;
32577: des_xmlTextReaderPtr(n_reader, reader, 0);
32578: xmlResetLastError();
32579: if (mem_base != xmlMemBlocks()) {
32580: printf("Leak of %d blocks found in xmlTextReaderValue",
32581: xmlMemBlocks() - mem_base);
32582: test_ret++;
32583: printf(" %d", n_reader);
32584: printf("\n");
32585: }
32586: }
32587: function_tests++;
32588: #endif
32589:
32590: return(test_ret);
32591: }
32592:
32593:
32594: static int
32595: test_xmlTextReaderXmlLang(void) {
32596: int test_ret = 0;
32597:
32598: #if defined(LIBXML_READER_ENABLED)
32599: int mem_base;
32600: xmlChar * ret_val;
32601: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32602: int n_reader;
32603:
32604: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32605: mem_base = xmlMemBlocks();
32606: reader = gen_xmlTextReaderPtr(n_reader, 0);
32607:
32608: ret_val = xmlTextReaderXmlLang(reader);
32609: desret_xmlChar_ptr(ret_val);
32610: call_tests++;
32611: des_xmlTextReaderPtr(n_reader, reader, 0);
32612: xmlResetLastError();
32613: if (mem_base != xmlMemBlocks()) {
32614: printf("Leak of %d blocks found in xmlTextReaderXmlLang",
32615: xmlMemBlocks() - mem_base);
32616: test_ret++;
32617: printf(" %d", n_reader);
32618: printf("\n");
32619: }
32620: }
32621: function_tests++;
32622: #endif
32623:
32624: return(test_ret);
32625: }
32626:
32627: static int
32628: test_xmlreader(void) {
32629: int test_ret = 0;
32630:
32631: if (quiet == 0) printf("Testing xmlreader : 75 of 85 functions ...\n");
32632: test_ret += test_xmlNewTextReader();
32633: test_ret += test_xmlNewTextReaderFilename();
32634: test_ret += test_xmlReaderForDoc();
32635: test_ret += test_xmlReaderForFile();
32636: test_ret += test_xmlReaderForMemory();
32637: test_ret += test_xmlReaderNewDoc();
32638: test_ret += test_xmlReaderNewFile();
32639: test_ret += test_xmlReaderNewMemory();
32640: test_ret += test_xmlReaderNewWalker();
32641: test_ret += test_xmlReaderWalker();
32642: test_ret += test_xmlTextReaderAttributeCount();
32643: test_ret += test_xmlTextReaderBaseUri();
32644: test_ret += test_xmlTextReaderByteConsumed();
32645: test_ret += test_xmlTextReaderClose();
32646: test_ret += test_xmlTextReaderConstBaseUri();
32647: test_ret += test_xmlTextReaderConstEncoding();
32648: test_ret += test_xmlTextReaderConstLocalName();
32649: test_ret += test_xmlTextReaderConstName();
32650: test_ret += test_xmlTextReaderConstNamespaceUri();
32651: test_ret += test_xmlTextReaderConstPrefix();
32652: test_ret += test_xmlTextReaderConstString();
32653: test_ret += test_xmlTextReaderConstValue();
32654: test_ret += test_xmlTextReaderConstXmlLang();
32655: test_ret += test_xmlTextReaderConstXmlVersion();
32656: test_ret += test_xmlTextReaderCurrentDoc();
32657: test_ret += test_xmlTextReaderCurrentNode();
32658: test_ret += test_xmlTextReaderDepth();
32659: test_ret += test_xmlTextReaderExpand();
32660: test_ret += test_xmlTextReaderGetAttribute();
32661: test_ret += test_xmlTextReaderGetAttributeNo();
32662: test_ret += test_xmlTextReaderGetAttributeNs();
32663: test_ret += test_xmlTextReaderGetErrorHandler();
32664: test_ret += test_xmlTextReaderGetParserColumnNumber();
32665: test_ret += test_xmlTextReaderGetParserLineNumber();
32666: test_ret += test_xmlTextReaderGetParserProp();
32667: test_ret += test_xmlTextReaderGetRemainder();
32668: test_ret += test_xmlTextReaderHasAttributes();
32669: test_ret += test_xmlTextReaderHasValue();
32670: test_ret += test_xmlTextReaderIsDefault();
32671: test_ret += test_xmlTextReaderIsEmptyElement();
32672: test_ret += test_xmlTextReaderIsNamespaceDecl();
32673: test_ret += test_xmlTextReaderIsValid();
32674: test_ret += test_xmlTextReaderLocalName();
32675: test_ret += test_xmlTextReaderLocatorBaseURI();
32676: test_ret += test_xmlTextReaderLocatorLineNumber();
32677: test_ret += test_xmlTextReaderLookupNamespace();
32678: test_ret += test_xmlTextReaderMoveToAttribute();
32679: test_ret += test_xmlTextReaderMoveToAttributeNo();
32680: test_ret += test_xmlTextReaderMoveToAttributeNs();
32681: test_ret += test_xmlTextReaderMoveToElement();
32682: test_ret += test_xmlTextReaderMoveToFirstAttribute();
32683: test_ret += test_xmlTextReaderMoveToNextAttribute();
32684: test_ret += test_xmlTextReaderName();
32685: test_ret += test_xmlTextReaderNamespaceUri();
32686: test_ret += test_xmlTextReaderNext();
32687: test_ret += test_xmlTextReaderNextSibling();
32688: test_ret += test_xmlTextReaderNodeType();
32689: test_ret += test_xmlTextReaderNormalization();
32690: test_ret += test_xmlTextReaderPrefix();
32691: test_ret += test_xmlTextReaderPreserve();
32692: test_ret += test_xmlTextReaderPreservePattern();
32693: test_ret += test_xmlTextReaderQuoteChar();
32694: test_ret += test_xmlTextReaderRead();
32695: test_ret += test_xmlTextReaderReadAttributeValue();
32696: test_ret += test_xmlTextReaderReadState();
32697: test_ret += test_xmlTextReaderRelaxNGSetSchema();
32698: test_ret += test_xmlTextReaderRelaxNGValidate();
32699: test_ret += test_xmlTextReaderSchemaValidate();
32700: test_ret += test_xmlTextReaderSchemaValidateCtxt();
32701: test_ret += test_xmlTextReaderSetErrorHandler();
32702: test_ret += test_xmlTextReaderSetParserProp();
32703: test_ret += test_xmlTextReaderSetSchema();
32704: test_ret += test_xmlTextReaderSetStructuredErrorHandler();
32705: test_ret += test_xmlTextReaderSetup();
32706: test_ret += test_xmlTextReaderStandalone();
32707: test_ret += test_xmlTextReaderValue();
32708: test_ret += test_xmlTextReaderXmlLang();
32709:
32710: if (test_ret != 0)
32711: printf("Module xmlreader: %d errors\n", test_ret);
32712: return(test_ret);
32713: }
32714:
32715: static int
32716: test_xmlExpCtxtNbCons(void) {
32717: int test_ret = 0;
32718:
32719: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
32720: int mem_base;
32721: int ret_val;
32722: xmlExpCtxtPtr ctxt; /* an expression context */
32723: int n_ctxt;
32724:
32725: for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) {
32726: mem_base = xmlMemBlocks();
32727: ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0);
32728:
32729: ret_val = xmlExpCtxtNbCons(ctxt);
32730: desret_int(ret_val);
32731: call_tests++;
32732: des_xmlExpCtxtPtr(n_ctxt, ctxt, 0);
32733: xmlResetLastError();
32734: if (mem_base != xmlMemBlocks()) {
32735: printf("Leak of %d blocks found in xmlExpCtxtNbCons",
32736: xmlMemBlocks() - mem_base);
32737: test_ret++;
32738: printf(" %d", n_ctxt);
32739: printf("\n");
32740: }
32741: }
32742: function_tests++;
32743: #endif
32744:
32745: return(test_ret);
32746: }
32747:
32748:
32749: static int
32750: test_xmlExpCtxtNbNodes(void) {
32751: int test_ret = 0;
32752:
32753: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
32754: int mem_base;
32755: int ret_val;
32756: xmlExpCtxtPtr ctxt; /* an expression context */
32757: int n_ctxt;
32758:
32759: for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) {
32760: mem_base = xmlMemBlocks();
32761: ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0);
32762:
32763: ret_val = xmlExpCtxtNbNodes(ctxt);
32764: desret_int(ret_val);
32765: call_tests++;
32766: des_xmlExpCtxtPtr(n_ctxt, ctxt, 0);
32767: xmlResetLastError();
32768: if (mem_base != xmlMemBlocks()) {
32769: printf("Leak of %d blocks found in xmlExpCtxtNbNodes",
32770: xmlMemBlocks() - mem_base);
32771: test_ret++;
32772: printf(" %d", n_ctxt);
32773: printf("\n");
32774: }
32775: }
32776: function_tests++;
32777: #endif
32778:
32779: return(test_ret);
32780: }
32781:
32782:
32783: static int
32784: test_xmlExpDump(void) {
32785: int test_ret = 0;
32786:
32787: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
32788: int mem_base;
32789: xmlBufferPtr buf; /* a buffer to receive the output */
32790: int n_buf;
32791: xmlExpNodePtr expr; /* the compiled expression */
32792: int n_expr;
32793:
32794: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
32795: for (n_expr = 0;n_expr < gen_nb_xmlExpNodePtr;n_expr++) {
32796: mem_base = xmlMemBlocks();
32797: buf = gen_xmlBufferPtr(n_buf, 0);
32798: expr = gen_xmlExpNodePtr(n_expr, 1);
32799:
32800: xmlExpDump(buf, expr);
32801: call_tests++;
32802: des_xmlBufferPtr(n_buf, buf, 0);
32803: des_xmlExpNodePtr(n_expr, expr, 1);
32804: xmlResetLastError();
32805: if (mem_base != xmlMemBlocks()) {
32806: printf("Leak of %d blocks found in xmlExpDump",
32807: xmlMemBlocks() - mem_base);
32808: test_ret++;
32809: printf(" %d", n_buf);
32810: printf(" %d", n_expr);
32811: printf("\n");
32812: }
32813: }
32814: }
32815: function_tests++;
32816: #endif
32817:
32818: return(test_ret);
32819: }
32820:
32821:
32822: static int
32823: test_xmlExpExpDerive(void) {
32824: int test_ret = 0;
32825:
32826:
32827: /* missing type support */
32828: return(test_ret);
32829: }
32830:
32831:
32832: static int
32833: test_xmlExpGetLanguage(void) {
32834: int test_ret = 0;
32835:
32836: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
32837: int mem_base;
32838: int ret_val;
32839: xmlExpCtxtPtr ctxt; /* the expression context */
32840: int n_ctxt;
32841: xmlExpNodePtr exp; /* the expression */
32842: int n_exp;
32843: xmlChar ** langList; /* where to store the tokens */
32844: int n_langList;
32845: int len; /* the allocated lenght of @list */
32846: int n_len;
32847:
32848: for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) {
32849: for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) {
32850: for (n_langList = 0;n_langList < gen_nb_const_xmlChar_ptr_ptr;n_langList++) {
32851: for (n_len = 0;n_len < gen_nb_int;n_len++) {
32852: mem_base = xmlMemBlocks();
32853: ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0);
32854: exp = gen_xmlExpNodePtr(n_exp, 1);
32855: langList = gen_const_xmlChar_ptr_ptr(n_langList, 2);
32856: len = gen_int(n_len, 3);
32857:
32858: ret_val = xmlExpGetLanguage(ctxt, exp, (const xmlChar **)langList, len);
32859: desret_int(ret_val);
32860: call_tests++;
32861: des_xmlExpCtxtPtr(n_ctxt, ctxt, 0);
32862: des_xmlExpNodePtr(n_exp, exp, 1);
32863: des_const_xmlChar_ptr_ptr(n_langList, (const xmlChar **)langList, 2);
32864: des_int(n_len, len, 3);
32865: xmlResetLastError();
32866: if (mem_base != xmlMemBlocks()) {
32867: printf("Leak of %d blocks found in xmlExpGetLanguage",
32868: xmlMemBlocks() - mem_base);
32869: test_ret++;
32870: printf(" %d", n_ctxt);
32871: printf(" %d", n_exp);
32872: printf(" %d", n_langList);
32873: printf(" %d", n_len);
32874: printf("\n");
32875: }
32876: }
32877: }
32878: }
32879: }
32880: function_tests++;
32881: #endif
32882:
32883: return(test_ret);
32884: }
32885:
32886:
32887: static int
32888: test_xmlExpGetStart(void) {
32889: int test_ret = 0;
32890:
32891: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
32892: int mem_base;
32893: int ret_val;
32894: xmlExpCtxtPtr ctxt; /* the expression context */
32895: int n_ctxt;
32896: xmlExpNodePtr exp; /* the expression */
32897: int n_exp;
32898: xmlChar ** tokList; /* where to store the tokens */
32899: int n_tokList;
32900: int len; /* the allocated lenght of @list */
32901: int n_len;
32902:
32903: for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) {
32904: for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) {
32905: for (n_tokList = 0;n_tokList < gen_nb_const_xmlChar_ptr_ptr;n_tokList++) {
32906: for (n_len = 0;n_len < gen_nb_int;n_len++) {
32907: mem_base = xmlMemBlocks();
32908: ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0);
32909: exp = gen_xmlExpNodePtr(n_exp, 1);
32910: tokList = gen_const_xmlChar_ptr_ptr(n_tokList, 2);
32911: len = gen_int(n_len, 3);
32912:
32913: ret_val = xmlExpGetStart(ctxt, exp, (const xmlChar **)tokList, len);
32914: desret_int(ret_val);
32915: call_tests++;
32916: des_xmlExpCtxtPtr(n_ctxt, ctxt, 0);
32917: des_xmlExpNodePtr(n_exp, exp, 1);
32918: des_const_xmlChar_ptr_ptr(n_tokList, (const xmlChar **)tokList, 2);
32919: des_int(n_len, len, 3);
32920: xmlResetLastError();
32921: if (mem_base != xmlMemBlocks()) {
32922: printf("Leak of %d blocks found in xmlExpGetStart",
32923: xmlMemBlocks() - mem_base);
32924: test_ret++;
32925: printf(" %d", n_ctxt);
32926: printf(" %d", n_exp);
32927: printf(" %d", n_tokList);
32928: printf(" %d", n_len);
32929: printf("\n");
32930: }
32931: }
32932: }
32933: }
32934: }
32935: function_tests++;
32936: #endif
32937:
32938: return(test_ret);
32939: }
32940:
32941:
32942: static int
32943: test_xmlExpIsNillable(void) {
32944: int test_ret = 0;
32945:
32946: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
32947: int mem_base;
32948: int ret_val;
32949: xmlExpNodePtr exp; /* the expression */
32950: int n_exp;
32951:
32952: for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) {
32953: mem_base = xmlMemBlocks();
32954: exp = gen_xmlExpNodePtr(n_exp, 0);
32955:
32956: ret_val = xmlExpIsNillable(exp);
32957: desret_int(ret_val);
32958: call_tests++;
32959: des_xmlExpNodePtr(n_exp, exp, 0);
32960: xmlResetLastError();
32961: if (mem_base != xmlMemBlocks()) {
32962: printf("Leak of %d blocks found in xmlExpIsNillable",
32963: xmlMemBlocks() - mem_base);
32964: test_ret++;
32965: printf(" %d", n_exp);
32966: printf("\n");
32967: }
32968: }
32969: function_tests++;
32970: #endif
32971:
32972: return(test_ret);
32973: }
32974:
32975:
32976: static int
32977: test_xmlExpMaxToken(void) {
32978: int test_ret = 0;
32979:
32980: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
32981: int mem_base;
32982: int ret_val;
32983: xmlExpNodePtr expr; /* a compiled expression */
32984: int n_expr;
32985:
32986: for (n_expr = 0;n_expr < gen_nb_xmlExpNodePtr;n_expr++) {
32987: mem_base = xmlMemBlocks();
32988: expr = gen_xmlExpNodePtr(n_expr, 0);
32989:
32990: ret_val = xmlExpMaxToken(expr);
32991: desret_int(ret_val);
32992: call_tests++;
32993: des_xmlExpNodePtr(n_expr, expr, 0);
32994: xmlResetLastError();
32995: if (mem_base != xmlMemBlocks()) {
32996: printf("Leak of %d blocks found in xmlExpMaxToken",
32997: xmlMemBlocks() - mem_base);
32998: test_ret++;
32999: printf(" %d", n_expr);
33000: printf("\n");
33001: }
33002: }
33003: function_tests++;
33004: #endif
33005:
33006: return(test_ret);
33007: }
33008:
33009:
33010: static int
33011: test_xmlExpNewAtom(void) {
33012: int test_ret = 0;
33013:
33014:
33015: /* missing type support */
33016: return(test_ret);
33017: }
33018:
33019:
33020: static int
33021: test_xmlExpNewCtxt(void) {
33022: int test_ret = 0;
33023:
33024:
33025: /* missing type support */
33026: return(test_ret);
33027: }
33028:
33029:
33030: static int
33031: test_xmlExpNewOr(void) {
33032: int test_ret = 0;
33033:
33034:
33035: /* missing type support */
33036: return(test_ret);
33037: }
33038:
33039:
33040: static int
33041: test_xmlExpNewRange(void) {
33042: int test_ret = 0;
33043:
33044:
33045: /* missing type support */
33046: return(test_ret);
33047: }
33048:
33049:
33050: static int
33051: test_xmlExpNewSeq(void) {
33052: int test_ret = 0;
33053:
33054:
33055: /* missing type support */
33056: return(test_ret);
33057: }
33058:
33059:
33060: static int
33061: test_xmlExpParse(void) {
33062: int test_ret = 0;
33063:
33064:
33065: /* missing type support */
33066: return(test_ret);
33067: }
33068:
33069:
33070: static int
33071: test_xmlExpRef(void) {
33072: int test_ret = 0;
33073:
33074: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
33075: int mem_base;
33076: xmlExpNodePtr exp; /* the expression */
33077: int n_exp;
33078:
33079: for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) {
33080: mem_base = xmlMemBlocks();
33081: exp = gen_xmlExpNodePtr(n_exp, 0);
33082:
33083: xmlExpRef(exp);
33084: call_tests++;
33085: des_xmlExpNodePtr(n_exp, exp, 0);
33086: xmlResetLastError();
33087: if (mem_base != xmlMemBlocks()) {
33088: printf("Leak of %d blocks found in xmlExpRef",
33089: xmlMemBlocks() - mem_base);
33090: test_ret++;
33091: printf(" %d", n_exp);
33092: printf("\n");
33093: }
33094: }
33095: function_tests++;
33096: #endif
33097:
33098: return(test_ret);
33099: }
33100:
33101:
33102: static int
33103: test_xmlExpStringDerive(void) {
33104: int test_ret = 0;
33105:
33106:
33107: /* missing type support */
33108: return(test_ret);
33109: }
33110:
33111:
33112: static int
33113: test_xmlExpSubsume(void) {
33114: int test_ret = 0;
33115:
33116: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
33117: int mem_base;
33118: int ret_val;
33119: xmlExpCtxtPtr ctxt; /* the expressions context */
33120: int n_ctxt;
33121: xmlExpNodePtr exp; /* the englobing expression */
33122: int n_exp;
33123: xmlExpNodePtr sub; /* the subexpression */
33124: int n_sub;
33125:
33126: for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) {
33127: for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) {
33128: for (n_sub = 0;n_sub < gen_nb_xmlExpNodePtr;n_sub++) {
33129: mem_base = xmlMemBlocks();
33130: ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0);
33131: exp = gen_xmlExpNodePtr(n_exp, 1);
33132: sub = gen_xmlExpNodePtr(n_sub, 2);
33133:
33134: ret_val = xmlExpSubsume(ctxt, exp, sub);
33135: desret_int(ret_val);
33136: call_tests++;
33137: des_xmlExpCtxtPtr(n_ctxt, ctxt, 0);
33138: des_xmlExpNodePtr(n_exp, exp, 1);
33139: des_xmlExpNodePtr(n_sub, sub, 2);
33140: xmlResetLastError();
33141: if (mem_base != xmlMemBlocks()) {
33142: printf("Leak of %d blocks found in xmlExpSubsume",
33143: xmlMemBlocks() - mem_base);
33144: test_ret++;
33145: printf(" %d", n_ctxt);
33146: printf(" %d", n_exp);
33147: printf(" %d", n_sub);
33148: printf("\n");
33149: }
33150: }
33151: }
33152: }
33153: function_tests++;
33154: #endif
33155:
33156: return(test_ret);
33157: }
33158:
33159: #ifdef LIBXML_REGEXP_ENABLED
33160:
33161: #define gen_nb_xmlRegExecCtxtPtr 1
33162: static xmlRegExecCtxtPtr gen_xmlRegExecCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33163: return(NULL);
33164: }
33165: static void des_xmlRegExecCtxtPtr(int no ATTRIBUTE_UNUSED, xmlRegExecCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33166: }
33167: #endif
33168:
33169:
33170: static int
33171: test_xmlRegExecErrInfo(void) {
33172: int test_ret = 0;
33173:
33174: #if defined(LIBXML_REGEXP_ENABLED)
33175: int mem_base;
33176: int ret_val;
33177: xmlRegExecCtxtPtr exec; /* a regexp execution context generating an error */
33178: int n_exec;
33179: xmlChar ** string; /* return value for the error string */
33180: int n_string;
33181: int * nbval; /* pointer to the number of accepted values IN/OUT */
33182: int n_nbval;
33183: int * nbneg; /* return number of negative transitions */
33184: int n_nbneg;
33185: xmlChar ** values; /* pointer to the array of acceptable values */
33186: int n_values;
33187: int * terminal; /* return value if this was a terminal state */
33188: int n_terminal;
33189:
33190: for (n_exec = 0;n_exec < gen_nb_xmlRegExecCtxtPtr;n_exec++) {
33191: for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr_ptr;n_string++) {
33192: for (n_nbval = 0;n_nbval < gen_nb_int_ptr;n_nbval++) {
33193: for (n_nbneg = 0;n_nbneg < gen_nb_int_ptr;n_nbneg++) {
33194: for (n_values = 0;n_values < gen_nb_xmlChar_ptr_ptr;n_values++) {
33195: for (n_terminal = 0;n_terminal < gen_nb_int_ptr;n_terminal++) {
33196: mem_base = xmlMemBlocks();
33197: exec = gen_xmlRegExecCtxtPtr(n_exec, 0);
33198: string = gen_const_xmlChar_ptr_ptr(n_string, 1);
33199: nbval = gen_int_ptr(n_nbval, 2);
33200: nbneg = gen_int_ptr(n_nbneg, 3);
33201: values = gen_xmlChar_ptr_ptr(n_values, 4);
33202: terminal = gen_int_ptr(n_terminal, 5);
33203:
33204: ret_val = xmlRegExecErrInfo(exec, (const xmlChar **)string, nbval, nbneg, values, terminal);
33205: desret_int(ret_val);
33206: call_tests++;
33207: des_xmlRegExecCtxtPtr(n_exec, exec, 0);
33208: des_const_xmlChar_ptr_ptr(n_string, (const xmlChar **)string, 1);
33209: des_int_ptr(n_nbval, nbval, 2);
33210: des_int_ptr(n_nbneg, nbneg, 3);
33211: des_xmlChar_ptr_ptr(n_values, values, 4);
33212: des_int_ptr(n_terminal, terminal, 5);
33213: xmlResetLastError();
33214: if (mem_base != xmlMemBlocks()) {
33215: printf("Leak of %d blocks found in xmlRegExecErrInfo",
33216: xmlMemBlocks() - mem_base);
33217: test_ret++;
33218: printf(" %d", n_exec);
33219: printf(" %d", n_string);
33220: printf(" %d", n_nbval);
33221: printf(" %d", n_nbneg);
33222: printf(" %d", n_values);
33223: printf(" %d", n_terminal);
33224: printf("\n");
33225: }
33226: }
33227: }
33228: }
33229: }
33230: }
33231: }
33232: function_tests++;
33233: #endif
33234:
33235: return(test_ret);
33236: }
33237:
33238:
33239: static int
33240: test_xmlRegExecNextValues(void) {
33241: int test_ret = 0;
33242:
33243: #if defined(LIBXML_REGEXP_ENABLED)
33244: int mem_base;
33245: int ret_val;
33246: xmlRegExecCtxtPtr exec; /* a regexp execution context */
33247: int n_exec;
33248: int * nbval; /* pointer to the number of accepted values IN/OUT */
33249: int n_nbval;
33250: int * nbneg; /* return number of negative transitions */
33251: int n_nbneg;
33252: xmlChar ** values; /* pointer to the array of acceptable values */
33253: int n_values;
33254: int * terminal; /* return value if this was a terminal state */
33255: int n_terminal;
33256:
33257: for (n_exec = 0;n_exec < gen_nb_xmlRegExecCtxtPtr;n_exec++) {
33258: for (n_nbval = 0;n_nbval < gen_nb_int_ptr;n_nbval++) {
33259: for (n_nbneg = 0;n_nbneg < gen_nb_int_ptr;n_nbneg++) {
33260: for (n_values = 0;n_values < gen_nb_xmlChar_ptr_ptr;n_values++) {
33261: for (n_terminal = 0;n_terminal < gen_nb_int_ptr;n_terminal++) {
33262: mem_base = xmlMemBlocks();
33263: exec = gen_xmlRegExecCtxtPtr(n_exec, 0);
33264: nbval = gen_int_ptr(n_nbval, 1);
33265: nbneg = gen_int_ptr(n_nbneg, 2);
33266: values = gen_xmlChar_ptr_ptr(n_values, 3);
33267: terminal = gen_int_ptr(n_terminal, 4);
33268:
33269: ret_val = xmlRegExecNextValues(exec, nbval, nbneg, values, terminal);
33270: desret_int(ret_val);
33271: call_tests++;
33272: des_xmlRegExecCtxtPtr(n_exec, exec, 0);
33273: des_int_ptr(n_nbval, nbval, 1);
33274: des_int_ptr(n_nbneg, nbneg, 2);
33275: des_xmlChar_ptr_ptr(n_values, values, 3);
33276: des_int_ptr(n_terminal, terminal, 4);
33277: xmlResetLastError();
33278: if (mem_base != xmlMemBlocks()) {
33279: printf("Leak of %d blocks found in xmlRegExecNextValues",
33280: xmlMemBlocks() - mem_base);
33281: test_ret++;
33282: printf(" %d", n_exec);
33283: printf(" %d", n_nbval);
33284: printf(" %d", n_nbneg);
33285: printf(" %d", n_values);
33286: printf(" %d", n_terminal);
33287: printf("\n");
33288: }
33289: }
33290: }
33291: }
33292: }
33293: }
33294: function_tests++;
33295: #endif
33296:
33297: return(test_ret);
33298: }
33299:
33300:
33301: static int
33302: test_xmlRegExecPushString(void) {
33303: int test_ret = 0;
33304:
33305: #if defined(LIBXML_REGEXP_ENABLED)
33306: int mem_base;
33307: int ret_val;
33308: xmlRegExecCtxtPtr exec; /* a regexp execution context or NULL to indicate the end */
33309: int n_exec;
33310: xmlChar * value; /* a string token input */
33311: int n_value;
33312: void * data; /* data associated to the token to reuse in callbacks */
33313: int n_data;
33314:
33315: for (n_exec = 0;n_exec < gen_nb_xmlRegExecCtxtPtr;n_exec++) {
33316: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
33317: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
33318: mem_base = xmlMemBlocks();
33319: exec = gen_xmlRegExecCtxtPtr(n_exec, 0);
33320: value = gen_const_xmlChar_ptr(n_value, 1);
33321: data = gen_userdata(n_data, 2);
33322:
33323: ret_val = xmlRegExecPushString(exec, (const xmlChar *)value, data);
33324: desret_int(ret_val);
33325: call_tests++;
33326: des_xmlRegExecCtxtPtr(n_exec, exec, 0);
33327: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
33328: des_userdata(n_data, data, 2);
33329: xmlResetLastError();
33330: if (mem_base != xmlMemBlocks()) {
33331: printf("Leak of %d blocks found in xmlRegExecPushString",
33332: xmlMemBlocks() - mem_base);
33333: test_ret++;
33334: printf(" %d", n_exec);
33335: printf(" %d", n_value);
33336: printf(" %d", n_data);
33337: printf("\n");
33338: }
33339: }
33340: }
33341: }
33342: function_tests++;
33343: #endif
33344:
33345: return(test_ret);
33346: }
33347:
33348:
33349: static int
33350: test_xmlRegExecPushString2(void) {
33351: int test_ret = 0;
33352:
33353: #if defined(LIBXML_REGEXP_ENABLED)
33354: int mem_base;
33355: int ret_val;
33356: xmlRegExecCtxtPtr exec; /* a regexp execution context or NULL to indicate the end */
33357: int n_exec;
33358: xmlChar * value; /* the first string token input */
33359: int n_value;
33360: xmlChar * value2; /* the second string token input */
33361: int n_value2;
33362: void * data; /* data associated to the token to reuse in callbacks */
33363: int n_data;
33364:
33365: for (n_exec = 0;n_exec < gen_nb_xmlRegExecCtxtPtr;n_exec++) {
33366: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
33367: for (n_value2 = 0;n_value2 < gen_nb_const_xmlChar_ptr;n_value2++) {
33368: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
33369: mem_base = xmlMemBlocks();
33370: exec = gen_xmlRegExecCtxtPtr(n_exec, 0);
33371: value = gen_const_xmlChar_ptr(n_value, 1);
33372: value2 = gen_const_xmlChar_ptr(n_value2, 2);
33373: data = gen_userdata(n_data, 3);
33374:
33375: ret_val = xmlRegExecPushString2(exec, (const xmlChar *)value, (const xmlChar *)value2, data);
33376: desret_int(ret_val);
33377: call_tests++;
33378: des_xmlRegExecCtxtPtr(n_exec, exec, 0);
33379: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
33380: des_const_xmlChar_ptr(n_value2, (const xmlChar *)value2, 2);
33381: des_userdata(n_data, data, 3);
33382: xmlResetLastError();
33383: if (mem_base != xmlMemBlocks()) {
33384: printf("Leak of %d blocks found in xmlRegExecPushString2",
33385: xmlMemBlocks() - mem_base);
33386: test_ret++;
33387: printf(" %d", n_exec);
33388: printf(" %d", n_value);
33389: printf(" %d", n_value2);
33390: printf(" %d", n_data);
33391: printf("\n");
33392: }
33393: }
33394: }
33395: }
33396: }
33397: function_tests++;
33398: #endif
33399:
33400: return(test_ret);
33401: }
33402:
33403: #ifdef LIBXML_REGEXP_ENABLED
33404:
33405: #define gen_nb_xmlRegexpPtr 1
33406: static xmlRegexpPtr gen_xmlRegexpPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33407: return(NULL);
33408: }
33409: static void des_xmlRegexpPtr(int no ATTRIBUTE_UNUSED, xmlRegexpPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33410: }
33411: #endif
33412:
33413:
33414: static int
33415: test_xmlRegNewExecCtxt(void) {
33416: int test_ret = 0;
33417:
33418:
33419: /* missing type support */
33420: return(test_ret);
33421: }
33422:
33423:
33424: static int
33425: test_xmlRegexpCompile(void) {
33426: int test_ret = 0;
33427:
33428:
33429: /* missing type support */
33430: return(test_ret);
33431: }
33432:
33433:
33434: static int
33435: test_xmlRegexpExec(void) {
33436: int test_ret = 0;
33437:
33438: #if defined(LIBXML_REGEXP_ENABLED)
33439: int mem_base;
33440: int ret_val;
33441: xmlRegexpPtr comp; /* the compiled regular expression */
33442: int n_comp;
33443: xmlChar * content; /* the value to check against the regular expression */
33444: int n_content;
33445:
33446: for (n_comp = 0;n_comp < gen_nb_xmlRegexpPtr;n_comp++) {
33447: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
33448: mem_base = xmlMemBlocks();
33449: comp = gen_xmlRegexpPtr(n_comp, 0);
33450: content = gen_const_xmlChar_ptr(n_content, 1);
33451:
33452: ret_val = xmlRegexpExec(comp, (const xmlChar *)content);
33453: desret_int(ret_val);
33454: call_tests++;
33455: des_xmlRegexpPtr(n_comp, comp, 0);
33456: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
33457: xmlResetLastError();
33458: if (mem_base != xmlMemBlocks()) {
33459: printf("Leak of %d blocks found in xmlRegexpExec",
33460: xmlMemBlocks() - mem_base);
33461: test_ret++;
33462: printf(" %d", n_comp);
33463: printf(" %d", n_content);
33464: printf("\n");
33465: }
33466: }
33467: }
33468: function_tests++;
33469: #endif
33470:
33471: return(test_ret);
33472: }
33473:
33474:
33475: static int
33476: test_xmlRegexpIsDeterminist(void) {
33477: int test_ret = 0;
33478:
33479: #if defined(LIBXML_REGEXP_ENABLED)
33480: int mem_base;
33481: int ret_val;
33482: xmlRegexpPtr comp; /* the compiled regular expression */
33483: int n_comp;
33484:
33485: for (n_comp = 0;n_comp < gen_nb_xmlRegexpPtr;n_comp++) {
33486: mem_base = xmlMemBlocks();
33487: comp = gen_xmlRegexpPtr(n_comp, 0);
33488:
33489: ret_val = xmlRegexpIsDeterminist(comp);
33490: desret_int(ret_val);
33491: call_tests++;
33492: des_xmlRegexpPtr(n_comp, comp, 0);
33493: xmlResetLastError();
33494: if (mem_base != xmlMemBlocks()) {
33495: printf("Leak of %d blocks found in xmlRegexpIsDeterminist",
33496: xmlMemBlocks() - mem_base);
33497: test_ret++;
33498: printf(" %d", n_comp);
33499: printf("\n");
33500: }
33501: }
33502: function_tests++;
33503: #endif
33504:
33505: return(test_ret);
33506: }
33507:
33508:
33509: static int
33510: test_xmlRegexpPrint(void) {
33511: int test_ret = 0;
33512:
33513: #if defined(LIBXML_REGEXP_ENABLED)
33514: int mem_base;
33515: FILE * output; /* the file for the output debug */
33516: int n_output;
33517: xmlRegexpPtr regexp; /* the compiled regexp */
33518: int n_regexp;
33519:
33520: for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
33521: for (n_regexp = 0;n_regexp < gen_nb_xmlRegexpPtr;n_regexp++) {
33522: mem_base = xmlMemBlocks();
33523: output = gen_FILE_ptr(n_output, 0);
33524: regexp = gen_xmlRegexpPtr(n_regexp, 1);
33525:
33526: xmlRegexpPrint(output, regexp);
33527: call_tests++;
33528: des_FILE_ptr(n_output, output, 0);
33529: des_xmlRegexpPtr(n_regexp, regexp, 1);
33530: xmlResetLastError();
33531: if (mem_base != xmlMemBlocks()) {
33532: printf("Leak of %d blocks found in xmlRegexpPrint",
33533: xmlMemBlocks() - mem_base);
33534: test_ret++;
33535: printf(" %d", n_output);
33536: printf(" %d", n_regexp);
33537: printf("\n");
33538: }
33539: }
33540: }
33541: function_tests++;
33542: #endif
33543:
33544: return(test_ret);
33545: }
33546:
33547: static int
33548: test_xmlregexp(void) {
33549: int test_ret = 0;
33550:
33551: if (quiet == 0) printf("Testing xmlregexp : 16 of 30 functions ...\n");
33552: test_ret += test_xmlExpCtxtNbCons();
33553: test_ret += test_xmlExpCtxtNbNodes();
33554: test_ret += test_xmlExpDump();
33555: test_ret += test_xmlExpExpDerive();
33556: test_ret += test_xmlExpGetLanguage();
33557: test_ret += test_xmlExpGetStart();
33558: test_ret += test_xmlExpIsNillable();
33559: test_ret += test_xmlExpMaxToken();
33560: test_ret += test_xmlExpNewAtom();
33561: test_ret += test_xmlExpNewCtxt();
33562: test_ret += test_xmlExpNewOr();
33563: test_ret += test_xmlExpNewRange();
33564: test_ret += test_xmlExpNewSeq();
33565: test_ret += test_xmlExpParse();
33566: test_ret += test_xmlExpRef();
33567: test_ret += test_xmlExpStringDerive();
33568: test_ret += test_xmlExpSubsume();
33569: test_ret += test_xmlRegExecErrInfo();
33570: test_ret += test_xmlRegExecNextValues();
33571: test_ret += test_xmlRegExecPushString();
33572: test_ret += test_xmlRegExecPushString2();
33573: test_ret += test_xmlRegNewExecCtxt();
33574: test_ret += test_xmlRegexpCompile();
33575: test_ret += test_xmlRegexpExec();
33576: test_ret += test_xmlRegexpIsDeterminist();
33577: test_ret += test_xmlRegexpPrint();
33578:
33579: if (test_ret != 0)
33580: printf("Module xmlregexp: %d errors\n", test_ret);
33581: return(test_ret);
33582: }
33583: #ifdef LIBXML_OUTPUT_ENABLED
33584:
33585: #define gen_nb_xmlSaveCtxtPtr 1
33586: static xmlSaveCtxtPtr gen_xmlSaveCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33587: return(NULL);
33588: }
33589: static void des_xmlSaveCtxtPtr(int no ATTRIBUTE_UNUSED, xmlSaveCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33590: }
33591: #endif
33592:
33593:
33594: static int
33595: test_xmlSaveClose(void) {
33596: int test_ret = 0;
33597:
33598: #if defined(LIBXML_OUTPUT_ENABLED)
33599: int mem_base;
33600: int ret_val;
33601: xmlSaveCtxtPtr ctxt; /* a document saving context */
33602: int n_ctxt;
33603:
33604: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSaveCtxtPtr;n_ctxt++) {
33605: mem_base = xmlMemBlocks();
33606: ctxt = gen_xmlSaveCtxtPtr(n_ctxt, 0);
33607:
33608: ret_val = xmlSaveClose(ctxt);
33609: desret_int(ret_val);
33610: call_tests++;
33611: des_xmlSaveCtxtPtr(n_ctxt, ctxt, 0);
33612: xmlResetLastError();
33613: if (mem_base != xmlMemBlocks()) {
33614: printf("Leak of %d blocks found in xmlSaveClose",
33615: xmlMemBlocks() - mem_base);
33616: test_ret++;
33617: printf(" %d", n_ctxt);
33618: printf("\n");
33619: }
33620: }
33621: function_tests++;
33622: #endif
33623:
33624: return(test_ret);
33625: }
33626:
33627:
33628: static int
33629: test_xmlSaveDoc(void) {
33630: int test_ret = 0;
33631:
33632: #if defined(LIBXML_OUTPUT_ENABLED)
33633: int mem_base;
33634: long ret_val;
33635: xmlSaveCtxtPtr ctxt; /* a document saving context */
33636: int n_ctxt;
33637: xmlDocPtr doc; /* a document */
33638: int n_doc;
33639:
33640: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSaveCtxtPtr;n_ctxt++) {
33641: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
33642: mem_base = xmlMemBlocks();
33643: ctxt = gen_xmlSaveCtxtPtr(n_ctxt, 0);
33644: doc = gen_xmlDocPtr(n_doc, 1);
33645:
33646: ret_val = xmlSaveDoc(ctxt, doc);
33647: desret_long(ret_val);
33648: call_tests++;
33649: des_xmlSaveCtxtPtr(n_ctxt, ctxt, 0);
33650: des_xmlDocPtr(n_doc, doc, 1);
33651: xmlResetLastError();
33652: if (mem_base != xmlMemBlocks()) {
33653: printf("Leak of %d blocks found in xmlSaveDoc",
33654: xmlMemBlocks() - mem_base);
33655: test_ret++;
33656: printf(" %d", n_ctxt);
33657: printf(" %d", n_doc);
33658: printf("\n");
33659: }
33660: }
33661: }
33662: function_tests++;
33663: #endif
33664:
33665: return(test_ret);
33666: }
33667:
33668:
33669: static int
33670: test_xmlSaveFlush(void) {
33671: int test_ret = 0;
33672:
33673: #if defined(LIBXML_OUTPUT_ENABLED)
33674: int mem_base;
33675: int ret_val;
33676: xmlSaveCtxtPtr ctxt; /* a document saving context */
33677: int n_ctxt;
33678:
33679: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSaveCtxtPtr;n_ctxt++) {
33680: mem_base = xmlMemBlocks();
33681: ctxt = gen_xmlSaveCtxtPtr(n_ctxt, 0);
33682:
33683: ret_val = xmlSaveFlush(ctxt);
33684: desret_int(ret_val);
33685: call_tests++;
33686: des_xmlSaveCtxtPtr(n_ctxt, ctxt, 0);
33687: xmlResetLastError();
33688: if (mem_base != xmlMemBlocks()) {
33689: printf("Leak of %d blocks found in xmlSaveFlush",
33690: xmlMemBlocks() - mem_base);
33691: test_ret++;
33692: printf(" %d", n_ctxt);
33693: printf("\n");
33694: }
33695: }
33696: function_tests++;
33697: #endif
33698:
33699: return(test_ret);
33700: }
33701:
33702:
33703: static int
33704: test_xmlSaveSetAttrEscape(void) {
33705: int test_ret = 0;
33706:
33707:
33708: /* missing type support */
33709: return(test_ret);
33710: }
33711:
33712:
33713: static int
33714: test_xmlSaveSetEscape(void) {
33715: int test_ret = 0;
33716:
33717:
33718: /* missing type support */
33719: return(test_ret);
33720: }
33721:
33722:
33723: static int
33724: test_xmlSaveToBuffer(void) {
33725: int test_ret = 0;
33726:
33727:
33728: /* missing type support */
33729: return(test_ret);
33730: }
33731:
33732:
33733: static int
33734: test_xmlSaveToFd(void) {
33735: int test_ret = 0;
33736:
33737:
33738: /* missing type support */
33739: return(test_ret);
33740: }
33741:
33742:
33743: static int
33744: test_xmlSaveToFilename(void) {
33745: int test_ret = 0;
33746:
33747:
33748: /* missing type support */
33749: return(test_ret);
33750: }
33751:
33752:
33753: static int
33754: test_xmlSaveTree(void) {
33755: int test_ret = 0;
33756:
33757: #if defined(LIBXML_OUTPUT_ENABLED)
33758: int mem_base;
33759: long ret_val;
33760: xmlSaveCtxtPtr ctxt; /* a document saving context */
33761: int n_ctxt;
33762: xmlNodePtr node; /* the top node of the subtree to save */
33763: int n_node;
33764:
33765: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSaveCtxtPtr;n_ctxt++) {
33766: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
33767: mem_base = xmlMemBlocks();
33768: ctxt = gen_xmlSaveCtxtPtr(n_ctxt, 0);
33769: node = gen_xmlNodePtr(n_node, 1);
33770:
33771: ret_val = xmlSaveTree(ctxt, node);
33772: desret_long(ret_val);
33773: call_tests++;
33774: des_xmlSaveCtxtPtr(n_ctxt, ctxt, 0);
33775: des_xmlNodePtr(n_node, node, 1);
33776: xmlResetLastError();
33777: if (mem_base != xmlMemBlocks()) {
33778: printf("Leak of %d blocks found in xmlSaveTree",
33779: xmlMemBlocks() - mem_base);
33780: test_ret++;
33781: printf(" %d", n_ctxt);
33782: printf(" %d", n_node);
33783: printf("\n");
33784: }
33785: }
33786: }
33787: function_tests++;
33788: #endif
33789:
33790: return(test_ret);
33791: }
33792:
33793: static int
33794: test_xmlsave(void) {
33795: int test_ret = 0;
33796:
33797: if (quiet == 0) printf("Testing xmlsave : 4 of 10 functions ...\n");
33798: test_ret += test_xmlSaveClose();
33799: test_ret += test_xmlSaveDoc();
33800: test_ret += test_xmlSaveFlush();
33801: test_ret += test_xmlSaveSetAttrEscape();
33802: test_ret += test_xmlSaveSetEscape();
33803: test_ret += test_xmlSaveToBuffer();
33804: test_ret += test_xmlSaveToFd();
33805: test_ret += test_xmlSaveToFilename();
33806: test_ret += test_xmlSaveTree();
33807:
33808: if (test_ret != 0)
33809: printf("Module xmlsave: %d errors\n", test_ret);
33810: return(test_ret);
33811: }
33812:
33813: static int
33814: test_xmlSchemaDump(void) {
33815: int test_ret = 0;
33816:
33817: #if defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
33818: int mem_base;
33819: FILE * output; /* the file output */
33820: int n_output;
33821: xmlSchemaPtr schema; /* a schema structure */
33822: int n_schema;
33823:
33824: for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
33825: for (n_schema = 0;n_schema < gen_nb_xmlSchemaPtr;n_schema++) {
33826: mem_base = xmlMemBlocks();
33827: output = gen_FILE_ptr(n_output, 0);
33828: schema = gen_xmlSchemaPtr(n_schema, 1);
33829:
33830: xmlSchemaDump(output, schema);
33831: call_tests++;
33832: des_FILE_ptr(n_output, output, 0);
33833: des_xmlSchemaPtr(n_schema, schema, 1);
33834: xmlResetLastError();
33835: if (mem_base != xmlMemBlocks()) {
33836: printf("Leak of %d blocks found in xmlSchemaDump",
33837: xmlMemBlocks() - mem_base);
33838: test_ret++;
33839: printf(" %d", n_output);
33840: printf(" %d", n_schema);
33841: printf("\n");
33842: }
33843: }
33844: }
33845: function_tests++;
33846: #endif
33847:
33848: return(test_ret);
33849: }
33850:
33851: #ifdef LIBXML_SCHEMAS_ENABLED
33852:
33853: #define gen_nb_xmlSchemaParserCtxtPtr 1
33854: static xmlSchemaParserCtxtPtr gen_xmlSchemaParserCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33855: return(NULL);
33856: }
33857: static void des_xmlSchemaParserCtxtPtr(int no ATTRIBUTE_UNUSED, xmlSchemaParserCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33858: }
33859: #endif
33860:
33861: #ifdef LIBXML_SCHEMAS_ENABLED
33862:
33863: #define gen_nb_xmlSchemaValidityErrorFunc_ptr 1
33864: static xmlSchemaValidityErrorFunc * gen_xmlSchemaValidityErrorFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33865: return(NULL);
33866: }
33867: static void des_xmlSchemaValidityErrorFunc_ptr(int no ATTRIBUTE_UNUSED, xmlSchemaValidityErrorFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33868: }
33869: #endif
33870:
33871: #ifdef LIBXML_SCHEMAS_ENABLED
33872:
33873: #define gen_nb_xmlSchemaValidityWarningFunc_ptr 1
33874: static xmlSchemaValidityWarningFunc * gen_xmlSchemaValidityWarningFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33875: return(NULL);
33876: }
33877: static void des_xmlSchemaValidityWarningFunc_ptr(int no ATTRIBUTE_UNUSED, xmlSchemaValidityWarningFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33878: }
33879: #endif
33880:
33881:
33882: static int
33883: test_xmlSchemaGetParserErrors(void) {
33884: int test_ret = 0;
33885:
33886: #if defined(LIBXML_SCHEMAS_ENABLED)
33887: int mem_base;
33888: int ret_val;
33889: xmlSchemaParserCtxtPtr ctxt; /* a XMl-Schema parser context */
33890: int n_ctxt;
33891: xmlSchemaValidityErrorFunc * err; /* the error callback result */
33892: int n_err;
33893: xmlSchemaValidityWarningFunc * warn; /* the warning callback result */
33894: int n_warn;
33895: void ** ctx; /* contextual data for the callbacks result */
33896: int n_ctx;
33897:
33898: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaParserCtxtPtr;n_ctxt++) {
33899: for (n_err = 0;n_err < gen_nb_xmlSchemaValidityErrorFunc_ptr;n_err++) {
33900: for (n_warn = 0;n_warn < gen_nb_xmlSchemaValidityWarningFunc_ptr;n_warn++) {
33901: for (n_ctx = 0;n_ctx < gen_nb_void_ptr_ptr;n_ctx++) {
33902: mem_base = xmlMemBlocks();
33903: ctxt = gen_xmlSchemaParserCtxtPtr(n_ctxt, 0);
33904: err = gen_xmlSchemaValidityErrorFunc_ptr(n_err, 1);
33905: warn = gen_xmlSchemaValidityWarningFunc_ptr(n_warn, 2);
33906: ctx = gen_void_ptr_ptr(n_ctx, 3);
33907:
33908: ret_val = xmlSchemaGetParserErrors(ctxt, err, warn, ctx);
33909: desret_int(ret_val);
33910: call_tests++;
33911: des_xmlSchemaParserCtxtPtr(n_ctxt, ctxt, 0);
33912: des_xmlSchemaValidityErrorFunc_ptr(n_err, err, 1);
33913: des_xmlSchemaValidityWarningFunc_ptr(n_warn, warn, 2);
33914: des_void_ptr_ptr(n_ctx, ctx, 3);
33915: xmlResetLastError();
33916: if (mem_base != xmlMemBlocks()) {
33917: printf("Leak of %d blocks found in xmlSchemaGetParserErrors",
33918: xmlMemBlocks() - mem_base);
33919: test_ret++;
33920: printf(" %d", n_ctxt);
33921: printf(" %d", n_err);
33922: printf(" %d", n_warn);
33923: printf(" %d", n_ctx);
33924: printf("\n");
33925: }
33926: }
33927: }
33928: }
33929: }
33930: function_tests++;
33931: #endif
33932:
33933: return(test_ret);
33934: }
33935:
33936:
33937: static int
33938: test_xmlSchemaGetValidErrors(void) {
33939: int test_ret = 0;
33940:
33941: #if defined(LIBXML_SCHEMAS_ENABLED)
33942: int mem_base;
33943: int ret_val;
33944: xmlSchemaValidCtxtPtr ctxt; /* a XML-Schema validation context */
33945: int n_ctxt;
33946: xmlSchemaValidityErrorFunc * err; /* the error function result */
33947: int n_err;
33948: xmlSchemaValidityWarningFunc * warn; /* the warning function result */
33949: int n_warn;
33950: void ** ctx; /* the functions context result */
33951: int n_ctx;
33952:
33953: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
33954: for (n_err = 0;n_err < gen_nb_xmlSchemaValidityErrorFunc_ptr;n_err++) {
33955: for (n_warn = 0;n_warn < gen_nb_xmlSchemaValidityWarningFunc_ptr;n_warn++) {
33956: for (n_ctx = 0;n_ctx < gen_nb_void_ptr_ptr;n_ctx++) {
33957: mem_base = xmlMemBlocks();
33958: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
33959: err = gen_xmlSchemaValidityErrorFunc_ptr(n_err, 1);
33960: warn = gen_xmlSchemaValidityWarningFunc_ptr(n_warn, 2);
33961: ctx = gen_void_ptr_ptr(n_ctx, 3);
33962:
33963: ret_val = xmlSchemaGetValidErrors(ctxt, err, warn, ctx);
33964: desret_int(ret_val);
33965: call_tests++;
33966: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
33967: des_xmlSchemaValidityErrorFunc_ptr(n_err, err, 1);
33968: des_xmlSchemaValidityWarningFunc_ptr(n_warn, warn, 2);
33969: des_void_ptr_ptr(n_ctx, ctx, 3);
33970: xmlResetLastError();
33971: if (mem_base != xmlMemBlocks()) {
33972: printf("Leak of %d blocks found in xmlSchemaGetValidErrors",
33973: xmlMemBlocks() - mem_base);
33974: test_ret++;
33975: printf(" %d", n_ctxt);
33976: printf(" %d", n_err);
33977: printf(" %d", n_warn);
33978: printf(" %d", n_ctx);
33979: printf("\n");
33980: }
33981: }
33982: }
33983: }
33984: }
33985: function_tests++;
33986: #endif
33987:
33988: return(test_ret);
33989: }
33990:
33991:
33992: static int
33993: test_xmlSchemaIsValid(void) {
33994: int test_ret = 0;
33995:
33996: #if defined(LIBXML_SCHEMAS_ENABLED)
33997: int mem_base;
33998: int ret_val;
33999: xmlSchemaValidCtxtPtr ctxt; /* the schema validation context */
34000: int n_ctxt;
34001:
34002: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34003: mem_base = xmlMemBlocks();
34004: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34005:
34006: ret_val = xmlSchemaIsValid(ctxt);
34007: desret_int(ret_val);
34008: call_tests++;
34009: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34010: xmlResetLastError();
34011: if (mem_base != xmlMemBlocks()) {
34012: printf("Leak of %d blocks found in xmlSchemaIsValid",
34013: xmlMemBlocks() - mem_base);
34014: test_ret++;
34015: printf(" %d", n_ctxt);
34016: printf("\n");
34017: }
34018: }
34019: function_tests++;
34020: #endif
34021:
34022: return(test_ret);
34023: }
34024:
34025:
34026: static int
34027: test_xmlSchemaNewDocParserCtxt(void) {
34028: int test_ret = 0;
34029:
34030: #if defined(LIBXML_SCHEMAS_ENABLED)
34031: int mem_base;
34032: xmlSchemaParserCtxtPtr ret_val;
34033: xmlDocPtr doc; /* a preparsed document tree */
34034: int n_doc;
34035:
34036: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
34037: mem_base = xmlMemBlocks();
34038: doc = gen_xmlDocPtr(n_doc, 0);
34039:
34040: ret_val = xmlSchemaNewDocParserCtxt(doc);
34041: desret_xmlSchemaParserCtxtPtr(ret_val);
34042: call_tests++;
34043: des_xmlDocPtr(n_doc, doc, 0);
34044: xmlResetLastError();
34045: if (mem_base != xmlMemBlocks()) {
34046: printf("Leak of %d blocks found in xmlSchemaNewDocParserCtxt",
34047: xmlMemBlocks() - mem_base);
34048: test_ret++;
34049: printf(" %d", n_doc);
34050: printf("\n");
34051: }
34052: }
34053: function_tests++;
34054: #endif
34055:
34056: return(test_ret);
34057: }
34058:
34059:
34060: static int
34061: test_xmlSchemaNewMemParserCtxt(void) {
34062: int test_ret = 0;
34063:
34064: #if defined(LIBXML_SCHEMAS_ENABLED)
34065: int mem_base;
34066: xmlSchemaParserCtxtPtr ret_val;
34067: char * buffer; /* a pointer to a char array containing the schemas */
34068: int n_buffer;
34069: int size; /* the size of the array */
34070: int n_size;
34071:
34072: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
34073: for (n_size = 0;n_size < gen_nb_int;n_size++) {
34074: mem_base = xmlMemBlocks();
34075: buffer = gen_const_char_ptr(n_buffer, 0);
34076: size = gen_int(n_size, 1);
34077:
34078: ret_val = xmlSchemaNewMemParserCtxt((const char *)buffer, size);
34079: desret_xmlSchemaParserCtxtPtr(ret_val);
34080: call_tests++;
34081: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
34082: des_int(n_size, size, 1);
34083: xmlResetLastError();
34084: if (mem_base != xmlMemBlocks()) {
34085: printf("Leak of %d blocks found in xmlSchemaNewMemParserCtxt",
34086: xmlMemBlocks() - mem_base);
34087: test_ret++;
34088: printf(" %d", n_buffer);
34089: printf(" %d", n_size);
34090: printf("\n");
34091: }
34092: }
34093: }
34094: function_tests++;
34095: #endif
34096:
34097: return(test_ret);
34098: }
34099:
34100:
34101: static int
34102: test_xmlSchemaNewParserCtxt(void) {
34103: int test_ret = 0;
34104:
34105: #if defined(LIBXML_SCHEMAS_ENABLED)
34106: int mem_base;
34107: xmlSchemaParserCtxtPtr ret_val;
34108: char * URL; /* the location of the schema */
34109: int n_URL;
34110:
34111: for (n_URL = 0;n_URL < gen_nb_const_char_ptr;n_URL++) {
34112: mem_base = xmlMemBlocks();
34113: URL = gen_const_char_ptr(n_URL, 0);
34114:
34115: ret_val = xmlSchemaNewParserCtxt((const char *)URL);
34116: desret_xmlSchemaParserCtxtPtr(ret_val);
34117: call_tests++;
34118: des_const_char_ptr(n_URL, (const char *)URL, 0);
34119: xmlResetLastError();
34120: if (mem_base != xmlMemBlocks()) {
34121: printf("Leak of %d blocks found in xmlSchemaNewParserCtxt",
34122: xmlMemBlocks() - mem_base);
34123: test_ret++;
34124: printf(" %d", n_URL);
34125: printf("\n");
34126: }
34127: }
34128: function_tests++;
34129: #endif
34130:
34131: return(test_ret);
34132: }
34133:
34134:
34135: static int
34136: test_xmlSchemaNewValidCtxt(void) {
34137: int test_ret = 0;
34138:
34139:
34140: /* missing type support */
34141: return(test_ret);
34142: }
34143:
34144:
34145: static int
34146: test_xmlSchemaParse(void) {
34147: int test_ret = 0;
34148:
34149:
34150: /* missing type support */
34151: return(test_ret);
34152: }
34153:
34154: #ifdef LIBXML_SCHEMAS_ENABLED
34155:
34156: #define gen_nb_xmlSAXHandlerPtr_ptr 1
34157: static xmlSAXHandlerPtr * gen_xmlSAXHandlerPtr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34158: return(NULL);
34159: }
34160: static void des_xmlSAXHandlerPtr_ptr(int no ATTRIBUTE_UNUSED, xmlSAXHandlerPtr * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34161: }
34162: #endif
34163:
34164:
34165: static int
34166: test_xmlSchemaSAXPlug(void) {
34167: int test_ret = 0;
34168:
34169:
34170: /* missing type support */
34171: return(test_ret);
34172: }
34173:
34174: #ifdef LIBXML_SCHEMAS_ENABLED
34175:
34176: #define gen_nb_xmlSchemaSAXPlugPtr 1
34177: static xmlSchemaSAXPlugPtr gen_xmlSchemaSAXPlugPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34178: return(NULL);
34179: }
34180: static void des_xmlSchemaSAXPlugPtr(int no ATTRIBUTE_UNUSED, xmlSchemaSAXPlugPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34181: }
34182: #endif
34183:
34184:
34185: static int
34186: test_xmlSchemaSAXUnplug(void) {
34187: int test_ret = 0;
34188:
34189: #if defined(LIBXML_SCHEMAS_ENABLED)
34190: int mem_base;
34191: int ret_val;
34192: xmlSchemaSAXPlugPtr plug; /* a data structure returned by xmlSchemaSAXPlug */
34193: int n_plug;
34194:
34195: for (n_plug = 0;n_plug < gen_nb_xmlSchemaSAXPlugPtr;n_plug++) {
34196: mem_base = xmlMemBlocks();
34197: plug = gen_xmlSchemaSAXPlugPtr(n_plug, 0);
34198:
34199: ret_val = xmlSchemaSAXUnplug(plug);
34200: desret_int(ret_val);
34201: call_tests++;
34202: des_xmlSchemaSAXPlugPtr(n_plug, plug, 0);
34203: xmlResetLastError();
34204: if (mem_base != xmlMemBlocks()) {
34205: printf("Leak of %d blocks found in xmlSchemaSAXUnplug",
34206: xmlMemBlocks() - mem_base);
34207: test_ret++;
34208: printf(" %d", n_plug);
34209: printf("\n");
34210: }
34211: }
34212: function_tests++;
34213: #endif
34214:
34215: return(test_ret);
34216: }
34217:
34218:
34219: static int
34220: test_xmlSchemaSetParserErrors(void) {
34221: int test_ret = 0;
34222:
34223:
34224: /* missing type support */
34225: return(test_ret);
34226: }
34227:
34228:
34229: static int
34230: test_xmlSchemaSetParserStructuredErrors(void) {
34231: int test_ret = 0;
34232:
34233:
34234: /* missing type support */
34235: return(test_ret);
34236: }
34237:
34238:
34239: static int
34240: test_xmlSchemaSetValidErrors(void) {
34241: int test_ret = 0;
34242:
34243:
34244: /* missing type support */
34245: return(test_ret);
34246: }
34247:
34248:
34249: static int
34250: test_xmlSchemaSetValidOptions(void) {
34251: int test_ret = 0;
34252:
34253: #if defined(LIBXML_SCHEMAS_ENABLED)
34254: int mem_base;
34255: int ret_val;
34256: xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
34257: int n_ctxt;
34258: int options; /* a combination of xmlSchemaValidOption */
34259: int n_options;
34260:
34261: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34262: for (n_options = 0;n_options < gen_nb_int;n_options++) {
34263: mem_base = xmlMemBlocks();
34264: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34265: options = gen_int(n_options, 1);
34266:
34267: ret_val = xmlSchemaSetValidOptions(ctxt, options);
34268: desret_int(ret_val);
34269: call_tests++;
34270: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34271: des_int(n_options, options, 1);
34272: xmlResetLastError();
34273: if (mem_base != xmlMemBlocks()) {
34274: printf("Leak of %d blocks found in xmlSchemaSetValidOptions",
34275: xmlMemBlocks() - mem_base);
34276: test_ret++;
34277: printf(" %d", n_ctxt);
34278: printf(" %d", n_options);
34279: printf("\n");
34280: }
34281: }
34282: }
34283: function_tests++;
34284: #endif
34285:
34286: return(test_ret);
34287: }
34288:
34289:
34290: static int
34291: test_xmlSchemaSetValidStructuredErrors(void) {
34292: int test_ret = 0;
34293:
34294:
34295: /* missing type support */
34296: return(test_ret);
34297: }
34298:
34299:
34300: static int
34301: test_xmlSchemaValidCtxtGetOptions(void) {
34302: int test_ret = 0;
34303:
34304: #if defined(LIBXML_SCHEMAS_ENABLED)
34305: int mem_base;
34306: int ret_val;
34307: xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
34308: int n_ctxt;
34309:
34310: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34311: mem_base = xmlMemBlocks();
34312: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34313:
34314: ret_val = xmlSchemaValidCtxtGetOptions(ctxt);
34315: desret_int(ret_val);
34316: call_tests++;
34317: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34318: xmlResetLastError();
34319: if (mem_base != xmlMemBlocks()) {
34320: printf("Leak of %d blocks found in xmlSchemaValidCtxtGetOptions",
34321: xmlMemBlocks() - mem_base);
34322: test_ret++;
34323: printf(" %d", n_ctxt);
34324: printf("\n");
34325: }
34326: }
34327: function_tests++;
34328: #endif
34329:
34330: return(test_ret);
34331: }
34332:
34333:
34334: static int
34335: test_xmlSchemaValidCtxtGetParserCtxt(void) {
34336: int test_ret = 0;
34337:
34338: #if defined(LIBXML_SCHEMAS_ENABLED)
34339: int mem_base;
34340: xmlParserCtxtPtr ret_val;
34341: xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
34342: int n_ctxt;
34343:
34344: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34345: mem_base = xmlMemBlocks();
34346: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34347:
34348: ret_val = xmlSchemaValidCtxtGetParserCtxt(ctxt);
34349: desret_xmlParserCtxtPtr(ret_val);
34350: call_tests++;
34351: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34352: xmlResetLastError();
34353: if (mem_base != xmlMemBlocks()) {
34354: printf("Leak of %d blocks found in xmlSchemaValidCtxtGetParserCtxt",
34355: xmlMemBlocks() - mem_base);
34356: test_ret++;
34357: printf(" %d", n_ctxt);
34358: printf("\n");
34359: }
34360: }
34361: function_tests++;
34362: #endif
34363:
34364: return(test_ret);
34365: }
34366:
34367:
34368: static int
34369: test_xmlSchemaValidateDoc(void) {
34370: int test_ret = 0;
34371:
34372: #if defined(LIBXML_SCHEMAS_ENABLED)
34373: int mem_base;
34374: int ret_val;
34375: xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
34376: int n_ctxt;
34377: xmlDocPtr doc; /* a parsed document tree */
34378: int n_doc;
34379:
34380: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34381: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
34382: mem_base = xmlMemBlocks();
34383: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34384: doc = gen_xmlDocPtr(n_doc, 1);
34385:
34386: ret_val = xmlSchemaValidateDoc(ctxt, doc);
34387: desret_int(ret_val);
34388: call_tests++;
34389: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34390: des_xmlDocPtr(n_doc, doc, 1);
34391: xmlResetLastError();
34392: if (mem_base != xmlMemBlocks()) {
34393: printf("Leak of %d blocks found in xmlSchemaValidateDoc",
34394: xmlMemBlocks() - mem_base);
34395: test_ret++;
34396: printf(" %d", n_ctxt);
34397: printf(" %d", n_doc);
34398: printf("\n");
34399: }
34400: }
34401: }
34402: function_tests++;
34403: #endif
34404:
34405: return(test_ret);
34406: }
34407:
34408:
34409: static int
34410: test_xmlSchemaValidateFile(void) {
34411: int test_ret = 0;
34412:
34413: #if defined(LIBXML_SCHEMAS_ENABLED)
34414: int mem_base;
34415: int ret_val;
34416: xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
34417: int n_ctxt;
34418: const char * filename; /* the URI of the instance */
34419: int n_filename;
34420: int options; /* a future set of options, currently unused */
34421: int n_options;
34422:
34423: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34424: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
34425: for (n_options = 0;n_options < gen_nb_int;n_options++) {
34426: mem_base = xmlMemBlocks();
34427: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34428: filename = gen_filepath(n_filename, 1);
34429: options = gen_int(n_options, 2);
34430:
34431: ret_val = xmlSchemaValidateFile(ctxt, filename, options);
34432: desret_int(ret_val);
34433: call_tests++;
34434: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34435: des_filepath(n_filename, filename, 1);
34436: des_int(n_options, options, 2);
34437: xmlResetLastError();
34438: if (mem_base != xmlMemBlocks()) {
34439: printf("Leak of %d blocks found in xmlSchemaValidateFile",
34440: xmlMemBlocks() - mem_base);
34441: test_ret++;
34442: printf(" %d", n_ctxt);
34443: printf(" %d", n_filename);
34444: printf(" %d", n_options);
34445: printf("\n");
34446: }
34447: }
34448: }
34449: }
34450: function_tests++;
34451: #endif
34452:
34453: return(test_ret);
34454: }
34455:
34456:
34457: static int
34458: test_xmlSchemaValidateOneElement(void) {
34459: int test_ret = 0;
34460:
34461: #if defined(LIBXML_SCHEMAS_ENABLED)
34462: int mem_base;
34463: int ret_val;
34464: xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
34465: int n_ctxt;
34466: xmlNodePtr elem; /* an element node */
34467: int n_elem;
34468:
34469: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34470: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
34471: mem_base = xmlMemBlocks();
34472: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34473: elem = gen_xmlNodePtr(n_elem, 1);
34474:
34475: ret_val = xmlSchemaValidateOneElement(ctxt, elem);
34476: desret_int(ret_val);
34477: call_tests++;
34478: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34479: des_xmlNodePtr(n_elem, elem, 1);
34480: xmlResetLastError();
34481: if (mem_base != xmlMemBlocks()) {
34482: printf("Leak of %d blocks found in xmlSchemaValidateOneElement",
34483: xmlMemBlocks() - mem_base);
34484: test_ret++;
34485: printf(" %d", n_ctxt);
34486: printf(" %d", n_elem);
34487: printf("\n");
34488: }
34489: }
34490: }
34491: function_tests++;
34492: #endif
34493:
34494: return(test_ret);
34495: }
34496:
34497:
34498: static int
34499: test_xmlSchemaValidateStream(void) {
34500: int test_ret = 0;
34501:
34502: #if defined(LIBXML_SCHEMAS_ENABLED)
34503: int mem_base;
34504: int ret_val;
34505: xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
34506: int n_ctxt;
34507: xmlParserInputBufferPtr input; /* the input to use for reading the data */
34508: int n_input;
34509: xmlCharEncoding enc; /* an optional encoding information */
34510: int n_enc;
34511: xmlSAXHandlerPtr sax; /* a SAX handler for the resulting events */
34512: int n_sax;
34513: void * user_data; /* the context to provide to the SAX handler. */
34514: int n_user_data;
34515:
34516: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34517: for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) {
34518: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
34519: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
34520: for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
34521: mem_base = xmlMemBlocks();
34522: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34523: input = gen_xmlParserInputBufferPtr(n_input, 1);
34524: enc = gen_xmlCharEncoding(n_enc, 2);
34525: sax = gen_xmlSAXHandlerPtr(n_sax, 3);
34526: user_data = gen_userdata(n_user_data, 4);
34527:
34528: ret_val = xmlSchemaValidateStream(ctxt, input, enc, sax, user_data);
34529: desret_int(ret_val);
34530: call_tests++;
34531: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34532: des_xmlParserInputBufferPtr(n_input, input, 1);
34533: des_xmlCharEncoding(n_enc, enc, 2);
34534: des_xmlSAXHandlerPtr(n_sax, sax, 3);
34535: des_userdata(n_user_data, user_data, 4);
34536: xmlResetLastError();
34537: if (mem_base != xmlMemBlocks()) {
34538: printf("Leak of %d blocks found in xmlSchemaValidateStream",
34539: xmlMemBlocks() - mem_base);
34540: test_ret++;
34541: printf(" %d", n_ctxt);
34542: printf(" %d", n_input);
34543: printf(" %d", n_enc);
34544: printf(" %d", n_sax);
34545: printf(" %d", n_user_data);
34546: printf("\n");
34547: }
34548: }
34549: }
34550: }
34551: }
34552: }
34553: function_tests++;
34554: #endif
34555:
34556: return(test_ret);
34557: }
34558:
34559: static int
34560: test_xmlschemas(void) {
34561: int test_ret = 0;
34562:
34563: if (quiet == 0) printf("Testing xmlschemas : 15 of 25 functions ...\n");
34564: test_ret += test_xmlSchemaDump();
34565: test_ret += test_xmlSchemaGetParserErrors();
34566: test_ret += test_xmlSchemaGetValidErrors();
34567: test_ret += test_xmlSchemaIsValid();
34568: test_ret += test_xmlSchemaNewDocParserCtxt();
34569: test_ret += test_xmlSchemaNewMemParserCtxt();
34570: test_ret += test_xmlSchemaNewParserCtxt();
34571: test_ret += test_xmlSchemaNewValidCtxt();
34572: test_ret += test_xmlSchemaParse();
34573: test_ret += test_xmlSchemaSAXPlug();
34574: test_ret += test_xmlSchemaSAXUnplug();
34575: test_ret += test_xmlSchemaSetParserErrors();
34576: test_ret += test_xmlSchemaSetParserStructuredErrors();
34577: test_ret += test_xmlSchemaSetValidErrors();
34578: test_ret += test_xmlSchemaSetValidOptions();
34579: test_ret += test_xmlSchemaSetValidStructuredErrors();
34580: test_ret += test_xmlSchemaValidCtxtGetOptions();
34581: test_ret += test_xmlSchemaValidCtxtGetParserCtxt();
34582: test_ret += test_xmlSchemaValidateDoc();
34583: test_ret += test_xmlSchemaValidateFile();
34584: test_ret += test_xmlSchemaValidateOneElement();
34585: test_ret += test_xmlSchemaValidateStream();
34586:
34587: if (test_ret != 0)
34588: printf("Module xmlschemas: %d errors\n", test_ret);
34589: return(test_ret);
34590: }
34591: #ifdef LIBXML_SCHEMAS_ENABLED
34592:
34593: #define gen_nb_xmlSchemaFacetPtr 1
34594: static xmlSchemaFacetPtr gen_xmlSchemaFacetPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34595: return(NULL);
34596: }
34597: static void des_xmlSchemaFacetPtr(int no ATTRIBUTE_UNUSED, xmlSchemaFacetPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34598: }
34599: #endif
34600:
34601: #ifdef LIBXML_SCHEMAS_ENABLED
34602:
34603: #define gen_nb_xmlSchemaTypePtr 1
34604: static xmlSchemaTypePtr gen_xmlSchemaTypePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34605: return(NULL);
34606: }
34607: static void des_xmlSchemaTypePtr(int no ATTRIBUTE_UNUSED, xmlSchemaTypePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34608: }
34609: #endif
34610:
34611:
34612: static int
34613: test_xmlSchemaCheckFacet(void) {
34614: int test_ret = 0;
34615:
34616: #if defined(LIBXML_SCHEMAS_ENABLED)
34617: int mem_base;
34618: int ret_val;
34619: xmlSchemaFacetPtr facet; /* the facet */
34620: int n_facet;
34621: xmlSchemaTypePtr typeDecl; /* the schema type definition */
34622: int n_typeDecl;
34623: xmlSchemaParserCtxtPtr pctxt; /* the schema parser context or NULL */
34624: int n_pctxt;
34625: xmlChar * name; /* the optional name of the type */
34626: int n_name;
34627:
34628: for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
34629: for (n_typeDecl = 0;n_typeDecl < gen_nb_xmlSchemaTypePtr;n_typeDecl++) {
34630: for (n_pctxt = 0;n_pctxt < gen_nb_xmlSchemaParserCtxtPtr;n_pctxt++) {
34631: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
34632: mem_base = xmlMemBlocks();
34633: facet = gen_xmlSchemaFacetPtr(n_facet, 0);
34634: typeDecl = gen_xmlSchemaTypePtr(n_typeDecl, 1);
34635: pctxt = gen_xmlSchemaParserCtxtPtr(n_pctxt, 2);
34636: name = gen_const_xmlChar_ptr(n_name, 3);
34637:
34638: ret_val = xmlSchemaCheckFacet(facet, typeDecl, pctxt, (const xmlChar *)name);
34639: desret_int(ret_val);
34640: call_tests++;
34641: des_xmlSchemaFacetPtr(n_facet, facet, 0);
34642: des_xmlSchemaTypePtr(n_typeDecl, typeDecl, 1);
34643: des_xmlSchemaParserCtxtPtr(n_pctxt, pctxt, 2);
34644: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 3);
34645: xmlResetLastError();
34646: if (mem_base != xmlMemBlocks()) {
34647: printf("Leak of %d blocks found in xmlSchemaCheckFacet",
34648: xmlMemBlocks() - mem_base);
34649: test_ret++;
34650: printf(" %d", n_facet);
34651: printf(" %d", n_typeDecl);
34652: printf(" %d", n_pctxt);
34653: printf(" %d", n_name);
34654: printf("\n");
34655: }
34656: }
34657: }
34658: }
34659: }
34660: function_tests++;
34661: #endif
34662:
34663: return(test_ret);
34664: }
34665:
34666:
34667: static int
34668: test_xmlSchemaCleanupTypes(void) {
34669: int test_ret = 0;
34670:
34671: #if defined(LIBXML_SCHEMAS_ENABLED)
34672:
34673:
34674: xmlSchemaCleanupTypes();
34675: call_tests++;
34676: xmlResetLastError();
34677: function_tests++;
34678: #endif
34679:
34680: return(test_ret);
34681: }
34682:
34683:
34684: static int
34685: test_xmlSchemaCollapseString(void) {
34686: int test_ret = 0;
34687:
34688: #if defined(LIBXML_SCHEMAS_ENABLED)
34689: int mem_base;
34690: xmlChar * ret_val;
34691: xmlChar * value; /* a value */
34692: int n_value;
34693:
34694: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
34695: mem_base = xmlMemBlocks();
34696: value = gen_const_xmlChar_ptr(n_value, 0);
34697:
34698: ret_val = xmlSchemaCollapseString((const xmlChar *)value);
34699: desret_xmlChar_ptr(ret_val);
34700: call_tests++;
34701: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
34702: xmlResetLastError();
34703: if (mem_base != xmlMemBlocks()) {
34704: printf("Leak of %d blocks found in xmlSchemaCollapseString",
34705: xmlMemBlocks() - mem_base);
34706: test_ret++;
34707: printf(" %d", n_value);
34708: printf("\n");
34709: }
34710: }
34711: function_tests++;
34712: #endif
34713:
34714: return(test_ret);
34715: }
34716:
34717: #ifdef LIBXML_SCHEMAS_ENABLED
34718:
34719: #define gen_nb_xmlSchemaValPtr 1
34720: static xmlSchemaValPtr gen_xmlSchemaValPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34721: return(NULL);
34722: }
34723: static void des_xmlSchemaValPtr(int no ATTRIBUTE_UNUSED, xmlSchemaValPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34724: }
34725: #endif
34726:
34727:
34728: static int
34729: test_xmlSchemaCompareValues(void) {
34730: int test_ret = 0;
34731:
34732: #if defined(LIBXML_SCHEMAS_ENABLED)
34733: int mem_base;
34734: int ret_val;
34735: xmlSchemaValPtr x; /* a first value */
34736: int n_x;
34737: xmlSchemaValPtr y; /* a second value */
34738: int n_y;
34739:
34740: for (n_x = 0;n_x < gen_nb_xmlSchemaValPtr;n_x++) {
34741: for (n_y = 0;n_y < gen_nb_xmlSchemaValPtr;n_y++) {
34742: mem_base = xmlMemBlocks();
34743: x = gen_xmlSchemaValPtr(n_x, 0);
34744: y = gen_xmlSchemaValPtr(n_y, 1);
34745:
34746: ret_val = xmlSchemaCompareValues(x, y);
34747: desret_int(ret_val);
34748: call_tests++;
34749: des_xmlSchemaValPtr(n_x, x, 0);
34750: des_xmlSchemaValPtr(n_y, y, 1);
34751: xmlResetLastError();
34752: if (mem_base != xmlMemBlocks()) {
34753: printf("Leak of %d blocks found in xmlSchemaCompareValues",
34754: xmlMemBlocks() - mem_base);
34755: test_ret++;
34756: printf(" %d", n_x);
34757: printf(" %d", n_y);
34758: printf("\n");
34759: }
34760: }
34761: }
34762: function_tests++;
34763: #endif
34764:
34765: return(test_ret);
34766: }
34767:
34768:
34769: static int
34770: test_xmlSchemaCompareValuesWhtsp(void) {
34771: int test_ret = 0;
34772:
34773: #if defined(LIBXML_SCHEMAS_ENABLED)
34774: int mem_base;
34775: int ret_val;
34776: xmlSchemaValPtr x; /* a first value */
34777: int n_x;
34778: xmlSchemaWhitespaceValueType xws; /* the whitespace value of x */
34779: int n_xws;
34780: xmlSchemaValPtr y; /* a second value */
34781: int n_y;
34782: xmlSchemaWhitespaceValueType yws; /* the whitespace value of y */
34783: int n_yws;
34784:
34785: for (n_x = 0;n_x < gen_nb_xmlSchemaValPtr;n_x++) {
34786: for (n_xws = 0;n_xws < gen_nb_xmlSchemaWhitespaceValueType;n_xws++) {
34787: for (n_y = 0;n_y < gen_nb_xmlSchemaValPtr;n_y++) {
34788: for (n_yws = 0;n_yws < gen_nb_xmlSchemaWhitespaceValueType;n_yws++) {
34789: mem_base = xmlMemBlocks();
34790: x = gen_xmlSchemaValPtr(n_x, 0);
34791: xws = gen_xmlSchemaWhitespaceValueType(n_xws, 1);
34792: y = gen_xmlSchemaValPtr(n_y, 2);
34793: yws = gen_xmlSchemaWhitespaceValueType(n_yws, 3);
34794:
34795: ret_val = xmlSchemaCompareValuesWhtsp(x, xws, y, yws);
34796: desret_int(ret_val);
34797: call_tests++;
34798: des_xmlSchemaValPtr(n_x, x, 0);
34799: des_xmlSchemaWhitespaceValueType(n_xws, xws, 1);
34800: des_xmlSchemaValPtr(n_y, y, 2);
34801: des_xmlSchemaWhitespaceValueType(n_yws, yws, 3);
34802: xmlResetLastError();
34803: if (mem_base != xmlMemBlocks()) {
34804: printf("Leak of %d blocks found in xmlSchemaCompareValuesWhtsp",
34805: xmlMemBlocks() - mem_base);
34806: test_ret++;
34807: printf(" %d", n_x);
34808: printf(" %d", n_xws);
34809: printf(" %d", n_y);
34810: printf(" %d", n_yws);
34811: printf("\n");
34812: }
34813: }
34814: }
34815: }
34816: }
34817: function_tests++;
34818: #endif
34819:
34820: return(test_ret);
34821: }
34822:
34823:
34824: static int
34825: test_xmlSchemaCopyValue(void) {
34826: int test_ret = 0;
34827:
34828:
34829: /* missing type support */
34830: return(test_ret);
34831: }
34832:
34833:
34834: static int
34835: test_xmlSchemaGetBuiltInListSimpleTypeItemType(void) {
34836: int test_ret = 0;
34837:
34838: #if defined(LIBXML_SCHEMAS_ENABLED)
34839: int mem_base;
34840: xmlSchemaTypePtr ret_val;
34841: xmlSchemaTypePtr type; /* the built-in simple type. */
34842: int n_type;
34843:
34844: for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
34845: mem_base = xmlMemBlocks();
34846: type = gen_xmlSchemaTypePtr(n_type, 0);
34847:
34848: ret_val = xmlSchemaGetBuiltInListSimpleTypeItemType(type);
34849: desret_xmlSchemaTypePtr(ret_val);
34850: call_tests++;
34851: des_xmlSchemaTypePtr(n_type, type, 0);
34852: xmlResetLastError();
34853: if (mem_base != xmlMemBlocks()) {
34854: printf("Leak of %d blocks found in xmlSchemaGetBuiltInListSimpleTypeItemType",
34855: xmlMemBlocks() - mem_base);
34856: test_ret++;
34857: printf(" %d", n_type);
34858: printf("\n");
34859: }
34860: }
34861: function_tests++;
34862: #endif
34863:
34864: return(test_ret);
34865: }
34866:
34867:
34868: static int
34869: test_xmlSchemaGetBuiltInType(void) {
34870: int test_ret = 0;
34871:
34872: #if defined(LIBXML_SCHEMAS_ENABLED)
34873: xmlSchemaTypePtr ret_val;
34874: xmlSchemaValType type; /* the type of the built in type */
34875: int n_type;
34876:
34877: for (n_type = 0;n_type < gen_nb_xmlSchemaValType;n_type++) {
34878: type = gen_xmlSchemaValType(n_type, 0);
34879:
34880: ret_val = xmlSchemaGetBuiltInType(type);
34881: desret_xmlSchemaTypePtr(ret_val);
34882: call_tests++;
34883: des_xmlSchemaValType(n_type, type, 0);
34884: xmlResetLastError();
34885: }
34886: function_tests++;
34887: #endif
34888:
34889: return(test_ret);
34890: }
34891:
34892:
34893: static int
34894: test_xmlSchemaGetCanonValue(void) {
34895: int test_ret = 0;
34896:
34897: #if defined(LIBXML_SCHEMAS_ENABLED)
34898: int mem_base;
34899: int ret_val;
34900: xmlSchemaValPtr val; /* the precomputed value */
34901: int n_val;
34902: xmlChar ** retValue; /* the returned value */
34903: int n_retValue;
34904:
34905: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
34906: for (n_retValue = 0;n_retValue < gen_nb_const_xmlChar_ptr_ptr;n_retValue++) {
34907: mem_base = xmlMemBlocks();
34908: val = gen_xmlSchemaValPtr(n_val, 0);
34909: retValue = gen_const_xmlChar_ptr_ptr(n_retValue, 1);
34910:
34911: ret_val = xmlSchemaGetCanonValue(val, (const xmlChar **)retValue);
34912: desret_int(ret_val);
34913: call_tests++;
34914: des_xmlSchemaValPtr(n_val, val, 0);
34915: des_const_xmlChar_ptr_ptr(n_retValue, (const xmlChar **)retValue, 1);
34916: xmlResetLastError();
34917: if (mem_base != xmlMemBlocks()) {
34918: printf("Leak of %d blocks found in xmlSchemaGetCanonValue",
34919: xmlMemBlocks() - mem_base);
34920: test_ret++;
34921: printf(" %d", n_val);
34922: printf(" %d", n_retValue);
34923: printf("\n");
34924: }
34925: }
34926: }
34927: function_tests++;
34928: #endif
34929:
34930: return(test_ret);
34931: }
34932:
34933:
34934: static int
34935: test_xmlSchemaGetCanonValueWhtsp(void) {
34936: int test_ret = 0;
34937:
34938: #if defined(LIBXML_SCHEMAS_ENABLED)
34939: int mem_base;
34940: int ret_val;
34941: xmlSchemaValPtr val; /* the precomputed value */
34942: int n_val;
34943: xmlChar ** retValue; /* the returned value */
34944: int n_retValue;
34945: xmlSchemaWhitespaceValueType ws; /* the whitespace type of the value */
34946: int n_ws;
34947:
34948: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
34949: for (n_retValue = 0;n_retValue < gen_nb_const_xmlChar_ptr_ptr;n_retValue++) {
34950: for (n_ws = 0;n_ws < gen_nb_xmlSchemaWhitespaceValueType;n_ws++) {
34951: mem_base = xmlMemBlocks();
34952: val = gen_xmlSchemaValPtr(n_val, 0);
34953: retValue = gen_const_xmlChar_ptr_ptr(n_retValue, 1);
34954: ws = gen_xmlSchemaWhitespaceValueType(n_ws, 2);
34955:
34956: ret_val = xmlSchemaGetCanonValueWhtsp(val, (const xmlChar **)retValue, ws);
34957: desret_int(ret_val);
34958: call_tests++;
34959: des_xmlSchemaValPtr(n_val, val, 0);
34960: des_const_xmlChar_ptr_ptr(n_retValue, (const xmlChar **)retValue, 1);
34961: des_xmlSchemaWhitespaceValueType(n_ws, ws, 2);
34962: xmlResetLastError();
34963: if (mem_base != xmlMemBlocks()) {
34964: printf("Leak of %d blocks found in xmlSchemaGetCanonValueWhtsp",
34965: xmlMemBlocks() - mem_base);
34966: test_ret++;
34967: printf(" %d", n_val);
34968: printf(" %d", n_retValue);
34969: printf(" %d", n_ws);
34970: printf("\n");
34971: }
34972: }
34973: }
34974: }
34975: function_tests++;
34976: #endif
34977:
34978: return(test_ret);
34979: }
34980:
34981:
34982: static int
34983: test_xmlSchemaGetFacetValueAsULong(void) {
34984: int test_ret = 0;
34985:
34986: #if defined(LIBXML_SCHEMAS_ENABLED)
34987: int mem_base;
34988: unsigned long ret_val;
34989: xmlSchemaFacetPtr facet; /* an schemas type facet */
34990: int n_facet;
34991:
34992: for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
34993: mem_base = xmlMemBlocks();
34994: facet = gen_xmlSchemaFacetPtr(n_facet, 0);
34995:
34996: ret_val = xmlSchemaGetFacetValueAsULong(facet);
34997: desret_unsigned_long(ret_val);
34998: call_tests++;
34999: des_xmlSchemaFacetPtr(n_facet, facet, 0);
35000: xmlResetLastError();
35001: if (mem_base != xmlMemBlocks()) {
35002: printf("Leak of %d blocks found in xmlSchemaGetFacetValueAsULong",
35003: xmlMemBlocks() - mem_base);
35004: test_ret++;
35005: printf(" %d", n_facet);
35006: printf("\n");
35007: }
35008: }
35009: function_tests++;
35010: #endif
35011:
35012: return(test_ret);
35013: }
35014:
35015:
35016: static int
35017: test_xmlSchemaGetPredefinedType(void) {
35018: int test_ret = 0;
35019:
35020: #if defined(LIBXML_SCHEMAS_ENABLED)
35021: int mem_base;
35022: xmlSchemaTypePtr ret_val;
35023: xmlChar * name; /* the type name */
35024: int n_name;
35025: xmlChar * ns; /* the URI of the namespace usually "http://www.w3.org/2001/XMLSchema" */
35026: int n_ns;
35027:
35028: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
35029: for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) {
35030: mem_base = xmlMemBlocks();
35031: name = gen_const_xmlChar_ptr(n_name, 0);
35032: ns = gen_const_xmlChar_ptr(n_ns, 1);
35033:
35034: ret_val = xmlSchemaGetPredefinedType((const xmlChar *)name, (const xmlChar *)ns);
35035: desret_xmlSchemaTypePtr(ret_val);
35036: call_tests++;
35037: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
35038: des_const_xmlChar_ptr(n_ns, (const xmlChar *)ns, 1);
35039: xmlResetLastError();
35040: if (mem_base != xmlMemBlocks()) {
35041: printf("Leak of %d blocks found in xmlSchemaGetPredefinedType",
35042: xmlMemBlocks() - mem_base);
35043: test_ret++;
35044: printf(" %d", n_name);
35045: printf(" %d", n_ns);
35046: printf("\n");
35047: }
35048: }
35049: }
35050: function_tests++;
35051: #endif
35052:
35053: return(test_ret);
35054: }
35055:
35056:
35057: static int
35058: test_xmlSchemaGetValType(void) {
35059: int test_ret = 0;
35060:
35061: #if defined(LIBXML_SCHEMAS_ENABLED)
35062: int mem_base;
35063: xmlSchemaValType ret_val;
35064: xmlSchemaValPtr val; /* a schemas value */
35065: int n_val;
35066:
35067: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
35068: mem_base = xmlMemBlocks();
35069: val = gen_xmlSchemaValPtr(n_val, 0);
35070:
35071: ret_val = xmlSchemaGetValType(val);
35072: desret_xmlSchemaValType(ret_val);
35073: call_tests++;
35074: des_xmlSchemaValPtr(n_val, val, 0);
35075: xmlResetLastError();
35076: if (mem_base != xmlMemBlocks()) {
35077: printf("Leak of %d blocks found in xmlSchemaGetValType",
35078: xmlMemBlocks() - mem_base);
35079: test_ret++;
35080: printf(" %d", n_val);
35081: printf("\n");
35082: }
35083: }
35084: function_tests++;
35085: #endif
35086:
35087: return(test_ret);
35088: }
35089:
35090:
35091: static int
35092: test_xmlSchemaInitTypes(void) {
35093: int test_ret = 0;
35094:
35095: #if defined(LIBXML_SCHEMAS_ENABLED)
35096:
35097:
35098: xmlSchemaInitTypes();
35099: call_tests++;
35100: xmlResetLastError();
35101: function_tests++;
35102: #endif
35103:
35104: return(test_ret);
35105: }
35106:
35107:
35108: static int
35109: test_xmlSchemaIsBuiltInTypeFacet(void) {
35110: int test_ret = 0;
35111:
35112: #if defined(LIBXML_SCHEMAS_ENABLED)
35113: int mem_base;
35114: int ret_val;
35115: xmlSchemaTypePtr type; /* the built-in type */
35116: int n_type;
35117: int facetType; /* the facet type */
35118: int n_facetType;
35119:
35120: for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
35121: for (n_facetType = 0;n_facetType < gen_nb_int;n_facetType++) {
35122: mem_base = xmlMemBlocks();
35123: type = gen_xmlSchemaTypePtr(n_type, 0);
35124: facetType = gen_int(n_facetType, 1);
35125:
35126: ret_val = xmlSchemaIsBuiltInTypeFacet(type, facetType);
35127: desret_int(ret_val);
35128: call_tests++;
35129: des_xmlSchemaTypePtr(n_type, type, 0);
35130: des_int(n_facetType, facetType, 1);
35131: xmlResetLastError();
35132: if (mem_base != xmlMemBlocks()) {
35133: printf("Leak of %d blocks found in xmlSchemaIsBuiltInTypeFacet",
35134: xmlMemBlocks() - mem_base);
35135: test_ret++;
35136: printf(" %d", n_type);
35137: printf(" %d", n_facetType);
35138: printf("\n");
35139: }
35140: }
35141: }
35142: function_tests++;
35143: #endif
35144:
35145: return(test_ret);
35146: }
35147:
35148:
35149: static int
35150: test_xmlSchemaNewFacet(void) {
35151: int test_ret = 0;
35152:
35153:
35154: /* missing type support */
35155: return(test_ret);
35156: }
35157:
35158:
35159: static int
35160: test_xmlSchemaNewNOTATIONValue(void) {
35161: int test_ret = 0;
35162:
35163:
35164: /* missing type support */
35165: return(test_ret);
35166: }
35167:
35168:
35169: static int
35170: test_xmlSchemaNewQNameValue(void) {
35171: int test_ret = 0;
35172:
35173:
35174: /* missing type support */
35175: return(test_ret);
35176: }
35177:
35178:
35179: static int
35180: test_xmlSchemaNewStringValue(void) {
35181: int test_ret = 0;
35182:
35183:
35184: /* missing type support */
35185: return(test_ret);
35186: }
35187:
35188: #ifdef LIBXML_SCHEMAS_ENABLED
35189:
35190: #define gen_nb_xmlSchemaValPtr_ptr 1
35191: static xmlSchemaValPtr * gen_xmlSchemaValPtr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
35192: return(NULL);
35193: }
35194: static void des_xmlSchemaValPtr_ptr(int no ATTRIBUTE_UNUSED, xmlSchemaValPtr * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
35195: }
35196: #endif
35197:
35198:
35199: static int
35200: test_xmlSchemaValPredefTypeNode(void) {
35201: int test_ret = 0;
35202:
35203: #if defined(LIBXML_SCHEMAS_ENABLED)
35204: int mem_base;
35205: int ret_val;
35206: xmlSchemaTypePtr type; /* the predefined type */
35207: int n_type;
35208: xmlChar * value; /* the value to check */
35209: int n_value;
35210: xmlSchemaValPtr * val; /* the return computed value */
35211: int n_val;
35212: xmlNodePtr node; /* the node containing the value */
35213: int n_node;
35214:
35215: for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
35216: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35217: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr_ptr;n_val++) {
35218: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
35219: mem_base = xmlMemBlocks();
35220: type = gen_xmlSchemaTypePtr(n_type, 0);
35221: value = gen_const_xmlChar_ptr(n_value, 1);
35222: val = gen_xmlSchemaValPtr_ptr(n_val, 2);
35223: node = gen_xmlNodePtr(n_node, 3);
35224:
35225: ret_val = xmlSchemaValPredefTypeNode(type, (const xmlChar *)value, val, node);
35226: desret_int(ret_val);
35227: call_tests++;
35228: des_xmlSchemaTypePtr(n_type, type, 0);
35229: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
35230: des_xmlSchemaValPtr_ptr(n_val, val, 2);
35231: des_xmlNodePtr(n_node, node, 3);
35232: xmlResetLastError();
35233: if (mem_base != xmlMemBlocks()) {
35234: printf("Leak of %d blocks found in xmlSchemaValPredefTypeNode",
35235: xmlMemBlocks() - mem_base);
35236: test_ret++;
35237: printf(" %d", n_type);
35238: printf(" %d", n_value);
35239: printf(" %d", n_val);
35240: printf(" %d", n_node);
35241: printf("\n");
35242: }
35243: }
35244: }
35245: }
35246: }
35247: function_tests++;
35248: #endif
35249:
35250: return(test_ret);
35251: }
35252:
35253:
35254: static int
35255: test_xmlSchemaValPredefTypeNodeNoNorm(void) {
35256: int test_ret = 0;
35257:
35258: #if defined(LIBXML_SCHEMAS_ENABLED)
35259: int mem_base;
35260: int ret_val;
35261: xmlSchemaTypePtr type; /* the predefined type */
35262: int n_type;
35263: xmlChar * value; /* the value to check */
35264: int n_value;
35265: xmlSchemaValPtr * val; /* the return computed value */
35266: int n_val;
35267: xmlNodePtr node; /* the node containing the value */
35268: int n_node;
35269:
35270: for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
35271: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35272: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr_ptr;n_val++) {
35273: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
35274: mem_base = xmlMemBlocks();
35275: type = gen_xmlSchemaTypePtr(n_type, 0);
35276: value = gen_const_xmlChar_ptr(n_value, 1);
35277: val = gen_xmlSchemaValPtr_ptr(n_val, 2);
35278: node = gen_xmlNodePtr(n_node, 3);
35279:
35280: ret_val = xmlSchemaValPredefTypeNodeNoNorm(type, (const xmlChar *)value, val, node);
35281: desret_int(ret_val);
35282: call_tests++;
35283: des_xmlSchemaTypePtr(n_type, type, 0);
35284: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
35285: des_xmlSchemaValPtr_ptr(n_val, val, 2);
35286: des_xmlNodePtr(n_node, node, 3);
35287: xmlResetLastError();
35288: if (mem_base != xmlMemBlocks()) {
35289: printf("Leak of %d blocks found in xmlSchemaValPredefTypeNodeNoNorm",
35290: xmlMemBlocks() - mem_base);
35291: test_ret++;
35292: printf(" %d", n_type);
35293: printf(" %d", n_value);
35294: printf(" %d", n_val);
35295: printf(" %d", n_node);
35296: printf("\n");
35297: }
35298: }
35299: }
35300: }
35301: }
35302: function_tests++;
35303: #endif
35304:
35305: return(test_ret);
35306: }
35307:
35308:
35309: static int
35310: test_xmlSchemaValidateFacet(void) {
35311: int test_ret = 0;
35312:
35313: #if defined(LIBXML_SCHEMAS_ENABLED)
35314: int mem_base;
35315: int ret_val;
35316: xmlSchemaTypePtr base; /* the base type */
35317: int n_base;
35318: xmlSchemaFacetPtr facet; /* the facet to check */
35319: int n_facet;
35320: xmlChar * value; /* the lexical repr of the value to validate */
35321: int n_value;
35322: xmlSchemaValPtr val; /* the precomputed value */
35323: int n_val;
35324:
35325: for (n_base = 0;n_base < gen_nb_xmlSchemaTypePtr;n_base++) {
35326: for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
35327: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35328: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
35329: mem_base = xmlMemBlocks();
35330: base = gen_xmlSchemaTypePtr(n_base, 0);
35331: facet = gen_xmlSchemaFacetPtr(n_facet, 1);
35332: value = gen_const_xmlChar_ptr(n_value, 2);
35333: val = gen_xmlSchemaValPtr(n_val, 3);
35334:
35335: ret_val = xmlSchemaValidateFacet(base, facet, (const xmlChar *)value, val);
35336: desret_int(ret_val);
35337: call_tests++;
35338: des_xmlSchemaTypePtr(n_base, base, 0);
35339: des_xmlSchemaFacetPtr(n_facet, facet, 1);
35340: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2);
35341: des_xmlSchemaValPtr(n_val, val, 3);
35342: xmlResetLastError();
35343: if (mem_base != xmlMemBlocks()) {
35344: printf("Leak of %d blocks found in xmlSchemaValidateFacet",
35345: xmlMemBlocks() - mem_base);
35346: test_ret++;
35347: printf(" %d", n_base);
35348: printf(" %d", n_facet);
35349: printf(" %d", n_value);
35350: printf(" %d", n_val);
35351: printf("\n");
35352: }
35353: }
35354: }
35355: }
35356: }
35357: function_tests++;
35358: #endif
35359:
35360: return(test_ret);
35361: }
35362:
35363:
35364: static int
35365: test_xmlSchemaValidateFacetWhtsp(void) {
35366: int test_ret = 0;
35367:
35368: #if defined(LIBXML_SCHEMAS_ENABLED)
35369: int mem_base;
35370: int ret_val;
35371: xmlSchemaFacetPtr facet; /* the facet to check */
35372: int n_facet;
35373: xmlSchemaWhitespaceValueType fws; /* the whitespace type of the facet's value */
35374: int n_fws;
35375: xmlSchemaValType valType; /* the built-in type of the value */
35376: int n_valType;
35377: xmlChar * value; /* the lexical (or normalized for pattern) repr of the value to validate */
35378: int n_value;
35379: xmlSchemaValPtr val; /* the precomputed value */
35380: int n_val;
35381: xmlSchemaWhitespaceValueType ws; /* the whitespace type of the value */
35382: int n_ws;
35383:
35384: for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
35385: for (n_fws = 0;n_fws < gen_nb_xmlSchemaWhitespaceValueType;n_fws++) {
35386: for (n_valType = 0;n_valType < gen_nb_xmlSchemaValType;n_valType++) {
35387: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35388: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
35389: for (n_ws = 0;n_ws < gen_nb_xmlSchemaWhitespaceValueType;n_ws++) {
35390: mem_base = xmlMemBlocks();
35391: facet = gen_xmlSchemaFacetPtr(n_facet, 0);
35392: fws = gen_xmlSchemaWhitespaceValueType(n_fws, 1);
35393: valType = gen_xmlSchemaValType(n_valType, 2);
35394: value = gen_const_xmlChar_ptr(n_value, 3);
35395: val = gen_xmlSchemaValPtr(n_val, 4);
35396: ws = gen_xmlSchemaWhitespaceValueType(n_ws, 5);
35397:
35398: ret_val = xmlSchemaValidateFacetWhtsp(facet, fws, valType, (const xmlChar *)value, val, ws);
35399: desret_int(ret_val);
35400: call_tests++;
35401: des_xmlSchemaFacetPtr(n_facet, facet, 0);
35402: des_xmlSchemaWhitespaceValueType(n_fws, fws, 1);
35403: des_xmlSchemaValType(n_valType, valType, 2);
35404: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 3);
35405: des_xmlSchemaValPtr(n_val, val, 4);
35406: des_xmlSchemaWhitespaceValueType(n_ws, ws, 5);
35407: xmlResetLastError();
35408: if (mem_base != xmlMemBlocks()) {
35409: printf("Leak of %d blocks found in xmlSchemaValidateFacetWhtsp",
35410: xmlMemBlocks() - mem_base);
35411: test_ret++;
35412: printf(" %d", n_facet);
35413: printf(" %d", n_fws);
35414: printf(" %d", n_valType);
35415: printf(" %d", n_value);
35416: printf(" %d", n_val);
35417: printf(" %d", n_ws);
35418: printf("\n");
35419: }
35420: }
35421: }
35422: }
35423: }
35424: }
35425: }
35426: function_tests++;
35427: #endif
35428:
35429: return(test_ret);
35430: }
35431:
35432:
35433: static int
35434: test_xmlSchemaValidateLengthFacet(void) {
35435: int test_ret = 0;
35436:
35437: #if defined(LIBXML_SCHEMAS_ENABLED)
35438: int mem_base;
35439: int ret_val;
35440: xmlSchemaTypePtr type; /* the built-in type */
35441: int n_type;
35442: xmlSchemaFacetPtr facet; /* the facet to check */
35443: int n_facet;
35444: xmlChar * value; /* the lexical repr. of the value to be validated */
35445: int n_value;
35446: xmlSchemaValPtr val; /* the precomputed value */
35447: int n_val;
35448: unsigned long * length; /* the actual length of the value */
35449: int n_length;
35450:
35451: for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
35452: for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
35453: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35454: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
35455: for (n_length = 0;n_length < gen_nb_unsigned_long_ptr;n_length++) {
35456: mem_base = xmlMemBlocks();
35457: type = gen_xmlSchemaTypePtr(n_type, 0);
35458: facet = gen_xmlSchemaFacetPtr(n_facet, 1);
35459: value = gen_const_xmlChar_ptr(n_value, 2);
35460: val = gen_xmlSchemaValPtr(n_val, 3);
35461: length = gen_unsigned_long_ptr(n_length, 4);
35462:
35463: ret_val = xmlSchemaValidateLengthFacet(type, facet, (const xmlChar *)value, val, length);
35464: desret_int(ret_val);
35465: call_tests++;
35466: des_xmlSchemaTypePtr(n_type, type, 0);
35467: des_xmlSchemaFacetPtr(n_facet, facet, 1);
35468: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2);
35469: des_xmlSchemaValPtr(n_val, val, 3);
35470: des_unsigned_long_ptr(n_length, length, 4);
35471: xmlResetLastError();
35472: if (mem_base != xmlMemBlocks()) {
35473: printf("Leak of %d blocks found in xmlSchemaValidateLengthFacet",
35474: xmlMemBlocks() - mem_base);
35475: test_ret++;
35476: printf(" %d", n_type);
35477: printf(" %d", n_facet);
35478: printf(" %d", n_value);
35479: printf(" %d", n_val);
35480: printf(" %d", n_length);
35481: printf("\n");
35482: }
35483: }
35484: }
35485: }
35486: }
35487: }
35488: function_tests++;
35489: #endif
35490:
35491: return(test_ret);
35492: }
35493:
35494:
35495: static int
35496: test_xmlSchemaValidateLengthFacetWhtsp(void) {
35497: int test_ret = 0;
35498:
35499: #if defined(LIBXML_SCHEMAS_ENABLED)
35500: int mem_base;
35501: int ret_val;
35502: xmlSchemaFacetPtr facet; /* the facet to check */
35503: int n_facet;
35504: xmlSchemaValType valType; /* the built-in type */
35505: int n_valType;
35506: xmlChar * value; /* the lexical repr. of the value to be validated */
35507: int n_value;
35508: xmlSchemaValPtr val; /* the precomputed value */
35509: int n_val;
35510: unsigned long * length; /* the actual length of the value */
35511: int n_length;
35512: xmlSchemaWhitespaceValueType ws; /* the whitespace type of the value */
35513: int n_ws;
35514:
35515: for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
35516: for (n_valType = 0;n_valType < gen_nb_xmlSchemaValType;n_valType++) {
35517: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35518: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
35519: for (n_length = 0;n_length < gen_nb_unsigned_long_ptr;n_length++) {
35520: for (n_ws = 0;n_ws < gen_nb_xmlSchemaWhitespaceValueType;n_ws++) {
35521: mem_base = xmlMemBlocks();
35522: facet = gen_xmlSchemaFacetPtr(n_facet, 0);
35523: valType = gen_xmlSchemaValType(n_valType, 1);
35524: value = gen_const_xmlChar_ptr(n_value, 2);
35525: val = gen_xmlSchemaValPtr(n_val, 3);
35526: length = gen_unsigned_long_ptr(n_length, 4);
35527: ws = gen_xmlSchemaWhitespaceValueType(n_ws, 5);
35528:
35529: ret_val = xmlSchemaValidateLengthFacetWhtsp(facet, valType, (const xmlChar *)value, val, length, ws);
35530: desret_int(ret_val);
35531: call_tests++;
35532: des_xmlSchemaFacetPtr(n_facet, facet, 0);
35533: des_xmlSchemaValType(n_valType, valType, 1);
35534: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2);
35535: des_xmlSchemaValPtr(n_val, val, 3);
35536: des_unsigned_long_ptr(n_length, length, 4);
35537: des_xmlSchemaWhitespaceValueType(n_ws, ws, 5);
35538: xmlResetLastError();
35539: if (mem_base != xmlMemBlocks()) {
35540: printf("Leak of %d blocks found in xmlSchemaValidateLengthFacetWhtsp",
35541: xmlMemBlocks() - mem_base);
35542: test_ret++;
35543: printf(" %d", n_facet);
35544: printf(" %d", n_valType);
35545: printf(" %d", n_value);
35546: printf(" %d", n_val);
35547: printf(" %d", n_length);
35548: printf(" %d", n_ws);
35549: printf("\n");
35550: }
35551: }
35552: }
35553: }
35554: }
35555: }
35556: }
35557: function_tests++;
35558: #endif
35559:
35560: return(test_ret);
35561: }
35562:
35563:
35564: static int
35565: test_xmlSchemaValidateListSimpleTypeFacet(void) {
35566: int test_ret = 0;
35567:
35568: #if defined(LIBXML_SCHEMAS_ENABLED)
35569: int mem_base;
35570: int ret_val;
35571: xmlSchemaFacetPtr facet; /* the facet to check */
35572: int n_facet;
35573: xmlChar * value; /* the lexical repr of the value to validate */
35574: int n_value;
35575: unsigned long actualLen; /* the number of list items */
35576: int n_actualLen;
35577: unsigned long * expectedLen; /* the resulting expected number of list items */
35578: int n_expectedLen;
35579:
35580: for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
35581: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35582: for (n_actualLen = 0;n_actualLen < gen_nb_unsigned_long;n_actualLen++) {
35583: for (n_expectedLen = 0;n_expectedLen < gen_nb_unsigned_long_ptr;n_expectedLen++) {
35584: mem_base = xmlMemBlocks();
35585: facet = gen_xmlSchemaFacetPtr(n_facet, 0);
35586: value = gen_const_xmlChar_ptr(n_value, 1);
35587: actualLen = gen_unsigned_long(n_actualLen, 2);
35588: expectedLen = gen_unsigned_long_ptr(n_expectedLen, 3);
35589:
35590: ret_val = xmlSchemaValidateListSimpleTypeFacet(facet, (const xmlChar *)value, actualLen, expectedLen);
35591: desret_int(ret_val);
35592: call_tests++;
35593: des_xmlSchemaFacetPtr(n_facet, facet, 0);
35594: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
35595: des_unsigned_long(n_actualLen, actualLen, 2);
35596: des_unsigned_long_ptr(n_expectedLen, expectedLen, 3);
35597: xmlResetLastError();
35598: if (mem_base != xmlMemBlocks()) {
35599: printf("Leak of %d blocks found in xmlSchemaValidateListSimpleTypeFacet",
35600: xmlMemBlocks() - mem_base);
35601: test_ret++;
35602: printf(" %d", n_facet);
35603: printf(" %d", n_value);
35604: printf(" %d", n_actualLen);
35605: printf(" %d", n_expectedLen);
35606: printf("\n");
35607: }
35608: }
35609: }
35610: }
35611: }
35612: function_tests++;
35613: #endif
35614:
35615: return(test_ret);
35616: }
35617:
35618:
35619: static int
35620: test_xmlSchemaValidatePredefinedType(void) {
35621: int test_ret = 0;
35622:
35623: #if defined(LIBXML_SCHEMAS_ENABLED)
35624: int mem_base;
35625: int ret_val;
35626: xmlSchemaTypePtr type; /* the predefined type */
35627: int n_type;
35628: xmlChar * value; /* the value to check */
35629: int n_value;
35630: xmlSchemaValPtr * val; /* the return computed value */
35631: int n_val;
35632:
35633: for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
35634: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35635: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr_ptr;n_val++) {
35636: mem_base = xmlMemBlocks();
35637: type = gen_xmlSchemaTypePtr(n_type, 0);
35638: value = gen_const_xmlChar_ptr(n_value, 1);
35639: val = gen_xmlSchemaValPtr_ptr(n_val, 2);
35640:
35641: ret_val = xmlSchemaValidatePredefinedType(type, (const xmlChar *)value, val);
35642: desret_int(ret_val);
35643: call_tests++;
35644: des_xmlSchemaTypePtr(n_type, type, 0);
35645: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
35646: des_xmlSchemaValPtr_ptr(n_val, val, 2);
35647: xmlResetLastError();
35648: if (mem_base != xmlMemBlocks()) {
35649: printf("Leak of %d blocks found in xmlSchemaValidatePredefinedType",
35650: xmlMemBlocks() - mem_base);
35651: test_ret++;
35652: printf(" %d", n_type);
35653: printf(" %d", n_value);
35654: printf(" %d", n_val);
35655: printf("\n");
35656: }
35657: }
35658: }
35659: }
35660: function_tests++;
35661: #endif
35662:
35663: return(test_ret);
35664: }
35665:
35666:
35667: static int
35668: test_xmlSchemaValueAppend(void) {
35669: int test_ret = 0;
35670:
35671: #if defined(LIBXML_SCHEMAS_ENABLED)
35672: int mem_base;
35673: int ret_val;
35674: xmlSchemaValPtr prev; /* the value */
35675: int n_prev;
35676: xmlSchemaValPtr cur; /* the value to be appended */
35677: int n_cur;
35678:
35679: for (n_prev = 0;n_prev < gen_nb_xmlSchemaValPtr;n_prev++) {
35680: for (n_cur = 0;n_cur < gen_nb_xmlSchemaValPtr;n_cur++) {
35681: mem_base = xmlMemBlocks();
35682: prev = gen_xmlSchemaValPtr(n_prev, 0);
35683: cur = gen_xmlSchemaValPtr(n_cur, 1);
35684:
35685: ret_val = xmlSchemaValueAppend(prev, cur);
35686: desret_int(ret_val);
35687: call_tests++;
35688: des_xmlSchemaValPtr(n_prev, prev, 0);
35689: des_xmlSchemaValPtr(n_cur, cur, 1);
35690: xmlResetLastError();
35691: if (mem_base != xmlMemBlocks()) {
35692: printf("Leak of %d blocks found in xmlSchemaValueAppend",
35693: xmlMemBlocks() - mem_base);
35694: test_ret++;
35695: printf(" %d", n_prev);
35696: printf(" %d", n_cur);
35697: printf("\n");
35698: }
35699: }
35700: }
35701: function_tests++;
35702: #endif
35703:
35704: return(test_ret);
35705: }
35706:
35707:
35708: static int
35709: test_xmlSchemaValueGetAsBoolean(void) {
35710: int test_ret = 0;
35711:
35712: #if defined(LIBXML_SCHEMAS_ENABLED)
35713: int mem_base;
35714: int ret_val;
35715: xmlSchemaValPtr val; /* the value */
35716: int n_val;
35717:
35718: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
35719: mem_base = xmlMemBlocks();
35720: val = gen_xmlSchemaValPtr(n_val, 0);
35721:
35722: ret_val = xmlSchemaValueGetAsBoolean(val);
35723: desret_int(ret_val);
35724: call_tests++;
35725: des_xmlSchemaValPtr(n_val, val, 0);
35726: xmlResetLastError();
35727: if (mem_base != xmlMemBlocks()) {
35728: printf("Leak of %d blocks found in xmlSchemaValueGetAsBoolean",
35729: xmlMemBlocks() - mem_base);
35730: test_ret++;
35731: printf(" %d", n_val);
35732: printf("\n");
35733: }
35734: }
35735: function_tests++;
35736: #endif
35737:
35738: return(test_ret);
35739: }
35740:
35741:
35742: static int
35743: test_xmlSchemaValueGetAsString(void) {
35744: int test_ret = 0;
35745:
35746: #if defined(LIBXML_SCHEMAS_ENABLED)
35747: int mem_base;
35748: const xmlChar * ret_val;
35749: xmlSchemaValPtr val; /* the value */
35750: int n_val;
35751:
35752: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
35753: mem_base = xmlMemBlocks();
35754: val = gen_xmlSchemaValPtr(n_val, 0);
35755:
35756: ret_val = xmlSchemaValueGetAsString(val);
35757: desret_const_xmlChar_ptr(ret_val);
35758: call_tests++;
35759: des_xmlSchemaValPtr(n_val, val, 0);
35760: xmlResetLastError();
35761: if (mem_base != xmlMemBlocks()) {
35762: printf("Leak of %d blocks found in xmlSchemaValueGetAsString",
35763: xmlMemBlocks() - mem_base);
35764: test_ret++;
35765: printf(" %d", n_val);
35766: printf("\n");
35767: }
35768: }
35769: function_tests++;
35770: #endif
35771:
35772: return(test_ret);
35773: }
35774:
35775:
35776: static int
35777: test_xmlSchemaValueGetNext(void) {
35778: int test_ret = 0;
35779:
35780:
35781: /* missing type support */
35782: return(test_ret);
35783: }
35784:
35785:
35786: static int
35787: test_xmlSchemaWhiteSpaceReplace(void) {
35788: int test_ret = 0;
35789:
35790: #if defined(LIBXML_SCHEMAS_ENABLED)
35791: int mem_base;
35792: xmlChar * ret_val;
35793: xmlChar * value; /* a value */
35794: int n_value;
35795:
35796: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35797: mem_base = xmlMemBlocks();
35798: value = gen_const_xmlChar_ptr(n_value, 0);
35799:
35800: ret_val = xmlSchemaWhiteSpaceReplace((const xmlChar *)value);
35801: desret_xmlChar_ptr(ret_val);
35802: call_tests++;
35803: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
35804: xmlResetLastError();
35805: if (mem_base != xmlMemBlocks()) {
35806: printf("Leak of %d blocks found in xmlSchemaWhiteSpaceReplace",
35807: xmlMemBlocks() - mem_base);
35808: test_ret++;
35809: printf(" %d", n_value);
35810: printf("\n");
35811: }
35812: }
35813: function_tests++;
35814: #endif
35815:
35816: return(test_ret);
35817: }
35818:
35819: static int
35820: test_xmlschemastypes(void) {
35821: int test_ret = 0;
35822:
35823: if (quiet == 0) printf("Testing xmlschemastypes : 26 of 34 functions ...\n");
35824: test_ret += test_xmlSchemaCheckFacet();
35825: test_ret += test_xmlSchemaCleanupTypes();
35826: test_ret += test_xmlSchemaCollapseString();
35827: test_ret += test_xmlSchemaCompareValues();
35828: test_ret += test_xmlSchemaCompareValuesWhtsp();
35829: test_ret += test_xmlSchemaCopyValue();
35830: test_ret += test_xmlSchemaGetBuiltInListSimpleTypeItemType();
35831: test_ret += test_xmlSchemaGetBuiltInType();
35832: test_ret += test_xmlSchemaGetCanonValue();
35833: test_ret += test_xmlSchemaGetCanonValueWhtsp();
35834: test_ret += test_xmlSchemaGetFacetValueAsULong();
35835: test_ret += test_xmlSchemaGetPredefinedType();
35836: test_ret += test_xmlSchemaGetValType();
35837: test_ret += test_xmlSchemaInitTypes();
35838: test_ret += test_xmlSchemaIsBuiltInTypeFacet();
35839: test_ret += test_xmlSchemaNewFacet();
35840: test_ret += test_xmlSchemaNewNOTATIONValue();
35841: test_ret += test_xmlSchemaNewQNameValue();
35842: test_ret += test_xmlSchemaNewStringValue();
35843: test_ret += test_xmlSchemaValPredefTypeNode();
35844: test_ret += test_xmlSchemaValPredefTypeNodeNoNorm();
35845: test_ret += test_xmlSchemaValidateFacet();
35846: test_ret += test_xmlSchemaValidateFacetWhtsp();
35847: test_ret += test_xmlSchemaValidateLengthFacet();
35848: test_ret += test_xmlSchemaValidateLengthFacetWhtsp();
35849: test_ret += test_xmlSchemaValidateListSimpleTypeFacet();
35850: test_ret += test_xmlSchemaValidatePredefinedType();
35851: test_ret += test_xmlSchemaValueAppend();
35852: test_ret += test_xmlSchemaValueGetAsBoolean();
35853: test_ret += test_xmlSchemaValueGetAsString();
35854: test_ret += test_xmlSchemaValueGetNext();
35855: test_ret += test_xmlSchemaWhiteSpaceReplace();
35856:
35857: if (test_ret != 0)
35858: printf("Module xmlschemastypes: %d errors\n", test_ret);
35859: return(test_ret);
35860: }
35861:
35862: static int
35863: test_xmlCharStrdup(void) {
35864: int test_ret = 0;
35865:
35866: int mem_base;
35867: xmlChar * ret_val;
35868: char * cur; /* the input char * */
35869: int n_cur;
35870:
35871: for (n_cur = 0;n_cur < gen_nb_const_char_ptr;n_cur++) {
35872: mem_base = xmlMemBlocks();
35873: cur = gen_const_char_ptr(n_cur, 0);
35874:
35875: ret_val = xmlCharStrdup((const char *)cur);
35876: desret_xmlChar_ptr(ret_val);
35877: call_tests++;
35878: des_const_char_ptr(n_cur, (const char *)cur, 0);
35879: xmlResetLastError();
35880: if (mem_base != xmlMemBlocks()) {
35881: printf("Leak of %d blocks found in xmlCharStrdup",
35882: xmlMemBlocks() - mem_base);
35883: test_ret++;
35884: printf(" %d", n_cur);
35885: printf("\n");
35886: }
35887: }
35888: function_tests++;
35889:
35890: return(test_ret);
35891: }
35892:
35893:
35894: static int
35895: test_xmlCharStrndup(void) {
35896: int test_ret = 0;
35897:
35898: int mem_base;
35899: xmlChar * ret_val;
35900: char * cur; /* the input char * */
35901: int n_cur;
35902: int len; /* the len of @cur */
35903: int n_len;
35904:
35905: for (n_cur = 0;n_cur < gen_nb_const_char_ptr;n_cur++) {
35906: for (n_len = 0;n_len < gen_nb_int;n_len++) {
35907: mem_base = xmlMemBlocks();
35908: cur = gen_const_char_ptr(n_cur, 0);
35909: len = gen_int(n_len, 1);
35910:
35911: ret_val = xmlCharStrndup((const char *)cur, len);
35912: desret_xmlChar_ptr(ret_val);
35913: call_tests++;
35914: des_const_char_ptr(n_cur, (const char *)cur, 0);
35915: des_int(n_len, len, 1);
35916: xmlResetLastError();
35917: if (mem_base != xmlMemBlocks()) {
35918: printf("Leak of %d blocks found in xmlCharStrndup",
35919: xmlMemBlocks() - mem_base);
35920: test_ret++;
35921: printf(" %d", n_cur);
35922: printf(" %d", n_len);
35923: printf("\n");
35924: }
35925: }
35926: }
35927: function_tests++;
35928:
35929: return(test_ret);
35930: }
35931:
35932:
35933: static int
35934: test_xmlCheckUTF8(void) {
35935: int test_ret = 0;
35936:
35937: int mem_base;
35938: int ret_val;
35939: unsigned char * utf; /* Pointer to putative UTF-8 encoded string. */
35940: int n_utf;
35941:
35942: for (n_utf = 0;n_utf < gen_nb_const_unsigned_char_ptr;n_utf++) {
35943: mem_base = xmlMemBlocks();
35944: utf = gen_const_unsigned_char_ptr(n_utf, 0);
35945:
35946: ret_val = xmlCheckUTF8((const unsigned char *)utf);
35947: desret_int(ret_val);
35948: call_tests++;
35949: des_const_unsigned_char_ptr(n_utf, (const unsigned char *)utf, 0);
35950: xmlResetLastError();
35951: if (mem_base != xmlMemBlocks()) {
35952: printf("Leak of %d blocks found in xmlCheckUTF8",
35953: xmlMemBlocks() - mem_base);
35954: test_ret++;
35955: printf(" %d", n_utf);
35956: printf("\n");
35957: }
35958: }
35959: function_tests++;
35960:
35961: return(test_ret);
35962: }
35963:
35964:
35965: static int
35966: test_xmlGetUTF8Char(void) {
35967: int test_ret = 0;
35968:
35969: int mem_base;
35970: int ret_val;
35971: unsigned char * utf; /* a sequence of UTF-8 encoded bytes */
35972: int n_utf;
35973: int * len; /* a pointer to the minimum number of bytes present in the sequence. This is used to assure the next character is completely contained within the sequence. */
35974: int n_len;
35975:
35976: for (n_utf = 0;n_utf < gen_nb_const_unsigned_char_ptr;n_utf++) {
35977: for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
35978: mem_base = xmlMemBlocks();
35979: utf = gen_const_unsigned_char_ptr(n_utf, 0);
35980: len = gen_int_ptr(n_len, 1);
35981:
35982: ret_val = xmlGetUTF8Char((const unsigned char *)utf, len);
35983: desret_int(ret_val);
35984: call_tests++;
35985: des_const_unsigned_char_ptr(n_utf, (const unsigned char *)utf, 0);
35986: des_int_ptr(n_len, len, 1);
35987: xmlResetLastError();
35988: if (mem_base != xmlMemBlocks()) {
35989: printf("Leak of %d blocks found in xmlGetUTF8Char",
35990: xmlMemBlocks() - mem_base);
35991: test_ret++;
35992: printf(" %d", n_utf);
35993: printf(" %d", n_len);
35994: printf("\n");
35995: }
35996: }
35997: }
35998: function_tests++;
35999:
36000: return(test_ret);
36001: }
36002:
36003:
36004: static int
36005: test_xmlStrEqual(void) {
36006: int test_ret = 0;
36007:
36008: int mem_base;
36009: int ret_val;
36010: xmlChar * str1; /* the first xmlChar * */
36011: int n_str1;
36012: xmlChar * str2; /* the second xmlChar * */
36013: int n_str2;
36014:
36015: for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
36016: for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
36017: mem_base = xmlMemBlocks();
36018: str1 = gen_const_xmlChar_ptr(n_str1, 0);
36019: str2 = gen_const_xmlChar_ptr(n_str2, 1);
36020:
36021: ret_val = xmlStrEqual((const xmlChar *)str1, (const xmlChar *)str2);
36022: desret_int(ret_val);
36023: call_tests++;
36024: des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0);
36025: des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1);
36026: xmlResetLastError();
36027: if (mem_base != xmlMemBlocks()) {
36028: printf("Leak of %d blocks found in xmlStrEqual",
36029: xmlMemBlocks() - mem_base);
36030: test_ret++;
36031: printf(" %d", n_str1);
36032: printf(" %d", n_str2);
36033: printf("\n");
36034: }
36035: }
36036: }
36037: function_tests++;
36038:
36039: return(test_ret);
36040: }
36041:
36042:
36043: static int
36044: test_xmlStrPrintf(void) {
36045: int test_ret = 0;
36046:
36047:
36048: /* missing type support */
36049: return(test_ret);
36050: }
36051:
36052:
36053: static int
36054: test_xmlStrQEqual(void) {
36055: int test_ret = 0;
36056:
36057: int mem_base;
36058: int ret_val;
36059: xmlChar * pref; /* the prefix of the QName */
36060: int n_pref;
36061: xmlChar * name; /* the localname of the QName */
36062: int n_name;
36063: xmlChar * str; /* the second xmlChar * */
36064: int n_str;
36065:
36066: for (n_pref = 0;n_pref < gen_nb_const_xmlChar_ptr;n_pref++) {
36067: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
36068: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
36069: mem_base = xmlMemBlocks();
36070: pref = gen_const_xmlChar_ptr(n_pref, 0);
36071: name = gen_const_xmlChar_ptr(n_name, 1);
36072: str = gen_const_xmlChar_ptr(n_str, 2);
36073:
36074: ret_val = xmlStrQEqual((const xmlChar *)pref, (const xmlChar *)name, (const xmlChar *)str);
36075: desret_int(ret_val);
36076: call_tests++;
36077: des_const_xmlChar_ptr(n_pref, (const xmlChar *)pref, 0);
36078: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
36079: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 2);
36080: xmlResetLastError();
36081: if (mem_base != xmlMemBlocks()) {
36082: printf("Leak of %d blocks found in xmlStrQEqual",
36083: xmlMemBlocks() - mem_base);
36084: test_ret++;
36085: printf(" %d", n_pref);
36086: printf(" %d", n_name);
36087: printf(" %d", n_str);
36088: printf("\n");
36089: }
36090: }
36091: }
36092: }
36093: function_tests++;
36094:
36095: return(test_ret);
36096: }
36097:
36098:
36099: static int
36100: test_xmlStrVPrintf(void) {
36101: int test_ret = 0;
36102:
36103:
36104: /* missing type support */
36105: return(test_ret);
36106: }
36107:
36108:
36109: static int
36110: test_xmlStrcasecmp(void) {
36111: int test_ret = 0;
36112:
36113: int mem_base;
36114: int ret_val;
36115: xmlChar * str1; /* the first xmlChar * */
36116: int n_str1;
36117: xmlChar * str2; /* the second xmlChar * */
36118: int n_str2;
36119:
36120: for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
36121: for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
36122: mem_base = xmlMemBlocks();
36123: str1 = gen_const_xmlChar_ptr(n_str1, 0);
36124: str2 = gen_const_xmlChar_ptr(n_str2, 1);
36125:
36126: ret_val = xmlStrcasecmp((const xmlChar *)str1, (const xmlChar *)str2);
36127: desret_int(ret_val);
36128: call_tests++;
36129: des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0);
36130: des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1);
36131: xmlResetLastError();
36132: if (mem_base != xmlMemBlocks()) {
36133: printf("Leak of %d blocks found in xmlStrcasecmp",
36134: xmlMemBlocks() - mem_base);
36135: test_ret++;
36136: printf(" %d", n_str1);
36137: printf(" %d", n_str2);
36138: printf("\n");
36139: }
36140: }
36141: }
36142: function_tests++;
36143:
36144: return(test_ret);
36145: }
36146:
36147:
36148: static int
36149: test_xmlStrcasestr(void) {
36150: int test_ret = 0;
36151:
36152: int mem_base;
36153: const xmlChar * ret_val;
36154: xmlChar * str; /* the xmlChar * array (haystack) */
36155: int n_str;
36156: xmlChar * val; /* the xmlChar to search (needle) */
36157: int n_val;
36158:
36159: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
36160: for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) {
36161: mem_base = xmlMemBlocks();
36162: str = gen_const_xmlChar_ptr(n_str, 0);
36163: val = gen_const_xmlChar_ptr(n_val, 1);
36164:
36165: ret_val = xmlStrcasestr((const xmlChar *)str, (const xmlChar *)val);
36166: desret_const_xmlChar_ptr(ret_val);
36167: call_tests++;
36168: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
36169: des_const_xmlChar_ptr(n_val, (const xmlChar *)val, 1);
36170: xmlResetLastError();
36171: if (mem_base != xmlMemBlocks()) {
36172: printf("Leak of %d blocks found in xmlStrcasestr",
36173: xmlMemBlocks() - mem_base);
36174: test_ret++;
36175: printf(" %d", n_str);
36176: printf(" %d", n_val);
36177: printf("\n");
36178: }
36179: }
36180: }
36181: function_tests++;
36182:
36183: return(test_ret);
36184: }
36185:
36186:
36187: static int
36188: test_xmlStrchr(void) {
36189: int test_ret = 0;
36190:
36191: int mem_base;
36192: const xmlChar * ret_val;
36193: xmlChar * str; /* the xmlChar * array */
36194: int n_str;
36195: xmlChar val; /* the xmlChar to search */
36196: int n_val;
36197:
36198: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
36199: for (n_val = 0;n_val < gen_nb_xmlChar;n_val++) {
36200: mem_base = xmlMemBlocks();
36201: str = gen_const_xmlChar_ptr(n_str, 0);
36202: val = gen_xmlChar(n_val, 1);
36203:
36204: ret_val = xmlStrchr((const xmlChar *)str, val);
36205: desret_const_xmlChar_ptr(ret_val);
36206: call_tests++;
36207: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
36208: des_xmlChar(n_val, val, 1);
36209: xmlResetLastError();
36210: if (mem_base != xmlMemBlocks()) {
36211: printf("Leak of %d blocks found in xmlStrchr",
36212: xmlMemBlocks() - mem_base);
36213: test_ret++;
36214: printf(" %d", n_str);
36215: printf(" %d", n_val);
36216: printf("\n");
36217: }
36218: }
36219: }
36220: function_tests++;
36221:
36222: return(test_ret);
36223: }
36224:
36225:
36226: static int
36227: test_xmlStrcmp(void) {
36228: int test_ret = 0;
36229:
36230: int mem_base;
36231: int ret_val;
36232: xmlChar * str1; /* the first xmlChar * */
36233: int n_str1;
36234: xmlChar * str2; /* the second xmlChar * */
36235: int n_str2;
36236:
36237: for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
36238: for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
36239: mem_base = xmlMemBlocks();
36240: str1 = gen_const_xmlChar_ptr(n_str1, 0);
36241: str2 = gen_const_xmlChar_ptr(n_str2, 1);
36242:
36243: ret_val = xmlStrcmp((const xmlChar *)str1, (const xmlChar *)str2);
36244: desret_int(ret_val);
36245: call_tests++;
36246: des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0);
36247: des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1);
36248: xmlResetLastError();
36249: if (mem_base != xmlMemBlocks()) {
36250: printf("Leak of %d blocks found in xmlStrcmp",
36251: xmlMemBlocks() - mem_base);
36252: test_ret++;
36253: printf(" %d", n_str1);
36254: printf(" %d", n_str2);
36255: printf("\n");
36256: }
36257: }
36258: }
36259: function_tests++;
36260:
36261: return(test_ret);
36262: }
36263:
36264:
36265: static int
36266: test_xmlStrdup(void) {
36267: int test_ret = 0;
36268:
36269: int mem_base;
36270: xmlChar * ret_val;
36271: xmlChar * cur; /* the input xmlChar * */
36272: int n_cur;
36273:
36274: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
36275: mem_base = xmlMemBlocks();
36276: cur = gen_const_xmlChar_ptr(n_cur, 0);
36277:
36278: ret_val = xmlStrdup((const xmlChar *)cur);
36279: desret_xmlChar_ptr(ret_val);
36280: call_tests++;
36281: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
36282: xmlResetLastError();
36283: if (mem_base != xmlMemBlocks()) {
36284: printf("Leak of %d blocks found in xmlStrdup",
36285: xmlMemBlocks() - mem_base);
36286: test_ret++;
36287: printf(" %d", n_cur);
36288: printf("\n");
36289: }
36290: }
36291: function_tests++;
36292:
36293: return(test_ret);
36294: }
36295:
36296:
36297: static int
36298: test_xmlStrlen(void) {
36299: int test_ret = 0;
36300:
36301: int mem_base;
36302: int ret_val;
36303: xmlChar * str; /* the xmlChar * array */
36304: int n_str;
36305:
36306: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
36307: mem_base = xmlMemBlocks();
36308: str = gen_const_xmlChar_ptr(n_str, 0);
36309:
36310: ret_val = xmlStrlen((const xmlChar *)str);
36311: desret_int(ret_val);
36312: call_tests++;
36313: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
36314: xmlResetLastError();
36315: if (mem_base != xmlMemBlocks()) {
36316: printf("Leak of %d blocks found in xmlStrlen",
36317: xmlMemBlocks() - mem_base);
36318: test_ret++;
36319: printf(" %d", n_str);
36320: printf("\n");
36321: }
36322: }
36323: function_tests++;
36324:
36325: return(test_ret);
36326: }
36327:
36328:
36329: static int
36330: test_xmlStrncasecmp(void) {
36331: int test_ret = 0;
36332:
36333: int mem_base;
36334: int ret_val;
36335: xmlChar * str1; /* the first xmlChar * */
36336: int n_str1;
36337: xmlChar * str2; /* the second xmlChar * */
36338: int n_str2;
36339: int len; /* the max comparison length */
36340: int n_len;
36341:
36342: for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
36343: for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
36344: for (n_len = 0;n_len < gen_nb_int;n_len++) {
36345: mem_base = xmlMemBlocks();
36346: str1 = gen_const_xmlChar_ptr(n_str1, 0);
36347: str2 = gen_const_xmlChar_ptr(n_str2, 1);
36348: len = gen_int(n_len, 2);
36349:
36350: ret_val = xmlStrncasecmp((const xmlChar *)str1, (const xmlChar *)str2, len);
36351: desret_int(ret_val);
36352: call_tests++;
36353: des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0);
36354: des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1);
36355: des_int(n_len, len, 2);
36356: xmlResetLastError();
36357: if (mem_base != xmlMemBlocks()) {
36358: printf("Leak of %d blocks found in xmlStrncasecmp",
36359: xmlMemBlocks() - mem_base);
36360: test_ret++;
36361: printf(" %d", n_str1);
36362: printf(" %d", n_str2);
36363: printf(" %d", n_len);
36364: printf("\n");
36365: }
36366: }
36367: }
36368: }
36369: function_tests++;
36370:
36371: return(test_ret);
36372: }
36373:
36374:
36375: static int
36376: test_xmlStrncatNew(void) {
36377: int test_ret = 0;
36378:
36379: int mem_base;
36380: xmlChar * ret_val;
36381: xmlChar * str1; /* first xmlChar string */
36382: int n_str1;
36383: xmlChar * str2; /* second xmlChar string */
36384: int n_str2;
36385: int len; /* the len of @str2 or < 0 */
36386: int n_len;
36387:
36388: for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
36389: for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
36390: for (n_len = 0;n_len < gen_nb_int;n_len++) {
36391: mem_base = xmlMemBlocks();
36392: str1 = gen_const_xmlChar_ptr(n_str1, 0);
36393: str2 = gen_const_xmlChar_ptr(n_str2, 1);
36394: len = gen_int(n_len, 2);
36395:
36396: ret_val = xmlStrncatNew((const xmlChar *)str1, (const xmlChar *)str2, len);
36397: desret_xmlChar_ptr(ret_val);
36398: call_tests++;
36399: des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0);
36400: des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1);
36401: des_int(n_len, len, 2);
36402: xmlResetLastError();
36403: if (mem_base != xmlMemBlocks()) {
36404: printf("Leak of %d blocks found in xmlStrncatNew",
36405: xmlMemBlocks() - mem_base);
36406: test_ret++;
36407: printf(" %d", n_str1);
36408: printf(" %d", n_str2);
36409: printf(" %d", n_len);
36410: printf("\n");
36411: }
36412: }
36413: }
36414: }
36415: function_tests++;
36416:
36417: return(test_ret);
36418: }
36419:
36420:
36421: static int
36422: test_xmlStrncmp(void) {
36423: int test_ret = 0;
36424:
36425: int mem_base;
36426: int ret_val;
36427: xmlChar * str1; /* the first xmlChar * */
36428: int n_str1;
36429: xmlChar * str2; /* the second xmlChar * */
36430: int n_str2;
36431: int len; /* the max comparison length */
36432: int n_len;
36433:
36434: for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
36435: for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
36436: for (n_len = 0;n_len < gen_nb_int;n_len++) {
36437: mem_base = xmlMemBlocks();
36438: str1 = gen_const_xmlChar_ptr(n_str1, 0);
36439: str2 = gen_const_xmlChar_ptr(n_str2, 1);
36440: len = gen_int(n_len, 2);
36441:
36442: ret_val = xmlStrncmp((const xmlChar *)str1, (const xmlChar *)str2, len);
36443: desret_int(ret_val);
36444: call_tests++;
36445: des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0);
36446: des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1);
36447: des_int(n_len, len, 2);
36448: xmlResetLastError();
36449: if (mem_base != xmlMemBlocks()) {
36450: printf("Leak of %d blocks found in xmlStrncmp",
36451: xmlMemBlocks() - mem_base);
36452: test_ret++;
36453: printf(" %d", n_str1);
36454: printf(" %d", n_str2);
36455: printf(" %d", n_len);
36456: printf("\n");
36457: }
36458: }
36459: }
36460: }
36461: function_tests++;
36462:
36463: return(test_ret);
36464: }
36465:
36466:
36467: static int
36468: test_xmlStrndup(void) {
36469: int test_ret = 0;
36470:
36471: int mem_base;
36472: xmlChar * ret_val;
36473: xmlChar * cur; /* the input xmlChar * */
36474: int n_cur;
36475: int len; /* the len of @cur */
36476: int n_len;
36477:
36478: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
36479: for (n_len = 0;n_len < gen_nb_int;n_len++) {
36480: mem_base = xmlMemBlocks();
36481: cur = gen_const_xmlChar_ptr(n_cur, 0);
36482: len = gen_int(n_len, 1);
36483:
36484: ret_val = xmlStrndup((const xmlChar *)cur, len);
36485: desret_xmlChar_ptr(ret_val);
36486: call_tests++;
36487: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
36488: des_int(n_len, len, 1);
36489: xmlResetLastError();
36490: if (mem_base != xmlMemBlocks()) {
36491: printf("Leak of %d blocks found in xmlStrndup",
36492: xmlMemBlocks() - mem_base);
36493: test_ret++;
36494: printf(" %d", n_cur);
36495: printf(" %d", n_len);
36496: printf("\n");
36497: }
36498: }
36499: }
36500: function_tests++;
36501:
36502: return(test_ret);
36503: }
36504:
36505:
36506: static int
36507: test_xmlStrstr(void) {
36508: int test_ret = 0;
36509:
36510: int mem_base;
36511: const xmlChar * ret_val;
36512: xmlChar * str; /* the xmlChar * array (haystack) */
36513: int n_str;
36514: xmlChar * val; /* the xmlChar to search (needle) */
36515: int n_val;
36516:
36517: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
36518: for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) {
36519: mem_base = xmlMemBlocks();
36520: str = gen_const_xmlChar_ptr(n_str, 0);
36521: val = gen_const_xmlChar_ptr(n_val, 1);
36522:
36523: ret_val = xmlStrstr((const xmlChar *)str, (const xmlChar *)val);
36524: desret_const_xmlChar_ptr(ret_val);
36525: call_tests++;
36526: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
36527: des_const_xmlChar_ptr(n_val, (const xmlChar *)val, 1);
36528: xmlResetLastError();
36529: if (mem_base != xmlMemBlocks()) {
36530: printf("Leak of %d blocks found in xmlStrstr",
36531: xmlMemBlocks() - mem_base);
36532: test_ret++;
36533: printf(" %d", n_str);
36534: printf(" %d", n_val);
36535: printf("\n");
36536: }
36537: }
36538: }
36539: function_tests++;
36540:
36541: return(test_ret);
36542: }
36543:
36544:
36545: static int
36546: test_xmlStrsub(void) {
36547: int test_ret = 0;
36548:
36549: int mem_base;
36550: xmlChar * ret_val;
36551: xmlChar * str; /* the xmlChar * array (haystack) */
36552: int n_str;
36553: int start; /* the index of the first char (zero based) */
36554: int n_start;
36555: int len; /* the length of the substring */
36556: int n_len;
36557:
36558: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
36559: for (n_start = 0;n_start < gen_nb_int;n_start++) {
36560: for (n_len = 0;n_len < gen_nb_int;n_len++) {
36561: mem_base = xmlMemBlocks();
36562: str = gen_const_xmlChar_ptr(n_str, 0);
36563: start = gen_int(n_start, 1);
36564: len = gen_int(n_len, 2);
36565:
36566: ret_val = xmlStrsub((const xmlChar *)str, start, len);
36567: desret_xmlChar_ptr(ret_val);
36568: call_tests++;
36569: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
36570: des_int(n_start, start, 1);
36571: des_int(n_len, len, 2);
36572: xmlResetLastError();
36573: if (mem_base != xmlMemBlocks()) {
36574: printf("Leak of %d blocks found in xmlStrsub",
36575: xmlMemBlocks() - mem_base);
36576: test_ret++;
36577: printf(" %d", n_str);
36578: printf(" %d", n_start);
36579: printf(" %d", n_len);
36580: printf("\n");
36581: }
36582: }
36583: }
36584: }
36585: function_tests++;
36586:
36587: return(test_ret);
36588: }
36589:
36590:
36591: static int
36592: test_xmlUTF8Charcmp(void) {
36593: int test_ret = 0;
36594:
36595: int mem_base;
36596: int ret_val;
36597: xmlChar * utf1; /* pointer to first UTF8 char */
36598: int n_utf1;
36599: xmlChar * utf2; /* pointer to second UTF8 char */
36600: int n_utf2;
36601:
36602: for (n_utf1 = 0;n_utf1 < gen_nb_const_xmlChar_ptr;n_utf1++) {
36603: for (n_utf2 = 0;n_utf2 < gen_nb_const_xmlChar_ptr;n_utf2++) {
36604: mem_base = xmlMemBlocks();
36605: utf1 = gen_const_xmlChar_ptr(n_utf1, 0);
36606: utf2 = gen_const_xmlChar_ptr(n_utf2, 1);
36607:
36608: ret_val = xmlUTF8Charcmp((const xmlChar *)utf1, (const xmlChar *)utf2);
36609: desret_int(ret_val);
36610: call_tests++;
36611: des_const_xmlChar_ptr(n_utf1, (const xmlChar *)utf1, 0);
36612: des_const_xmlChar_ptr(n_utf2, (const xmlChar *)utf2, 1);
36613: xmlResetLastError();
36614: if (mem_base != xmlMemBlocks()) {
36615: printf("Leak of %d blocks found in xmlUTF8Charcmp",
36616: xmlMemBlocks() - mem_base);
36617: test_ret++;
36618: printf(" %d", n_utf1);
36619: printf(" %d", n_utf2);
36620: printf("\n");
36621: }
36622: }
36623: }
36624: function_tests++;
36625:
36626: return(test_ret);
36627: }
36628:
36629:
36630: static int
36631: test_xmlUTF8Size(void) {
36632: int test_ret = 0;
36633:
36634: int mem_base;
36635: int ret_val;
36636: xmlChar * utf; /* pointer to the UTF8 character */
36637: int n_utf;
36638:
36639: for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
36640: mem_base = xmlMemBlocks();
36641: utf = gen_const_xmlChar_ptr(n_utf, 0);
36642:
36643: ret_val = xmlUTF8Size((const xmlChar *)utf);
36644: desret_int(ret_val);
36645: call_tests++;
36646: des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
36647: xmlResetLastError();
36648: if (mem_base != xmlMemBlocks()) {
36649: printf("Leak of %d blocks found in xmlUTF8Size",
36650: xmlMemBlocks() - mem_base);
36651: test_ret++;
36652: printf(" %d", n_utf);
36653: printf("\n");
36654: }
36655: }
36656: function_tests++;
36657:
36658: return(test_ret);
36659: }
36660:
36661:
36662: static int
36663: test_xmlUTF8Strlen(void) {
36664: int test_ret = 0;
36665:
36666: int mem_base;
36667: int ret_val;
36668: xmlChar * utf; /* a sequence of UTF-8 encoded bytes */
36669: int n_utf;
36670:
36671: for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
36672: mem_base = xmlMemBlocks();
36673: utf = gen_const_xmlChar_ptr(n_utf, 0);
36674:
36675: ret_val = xmlUTF8Strlen((const xmlChar *)utf);
36676: desret_int(ret_val);
36677: call_tests++;
36678: des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
36679: xmlResetLastError();
36680: if (mem_base != xmlMemBlocks()) {
36681: printf("Leak of %d blocks found in xmlUTF8Strlen",
36682: xmlMemBlocks() - mem_base);
36683: test_ret++;
36684: printf(" %d", n_utf);
36685: printf("\n");
36686: }
36687: }
36688: function_tests++;
36689:
36690: return(test_ret);
36691: }
36692:
36693:
36694: static int
36695: test_xmlUTF8Strloc(void) {
36696: int test_ret = 0;
36697:
36698: int mem_base;
36699: int ret_val;
36700: xmlChar * utf; /* the input UTF8 * */
36701: int n_utf;
36702: xmlChar * utfchar; /* the UTF8 character to be found */
36703: int n_utfchar;
36704:
36705: for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
36706: for (n_utfchar = 0;n_utfchar < gen_nb_const_xmlChar_ptr;n_utfchar++) {
36707: mem_base = xmlMemBlocks();
36708: utf = gen_const_xmlChar_ptr(n_utf, 0);
36709: utfchar = gen_const_xmlChar_ptr(n_utfchar, 1);
36710:
36711: ret_val = xmlUTF8Strloc((const xmlChar *)utf, (const xmlChar *)utfchar);
36712: desret_int(ret_val);
36713: call_tests++;
36714: des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
36715: des_const_xmlChar_ptr(n_utfchar, (const xmlChar *)utfchar, 1);
36716: xmlResetLastError();
36717: if (mem_base != xmlMemBlocks()) {
36718: printf("Leak of %d blocks found in xmlUTF8Strloc",
36719: xmlMemBlocks() - mem_base);
36720: test_ret++;
36721: printf(" %d", n_utf);
36722: printf(" %d", n_utfchar);
36723: printf("\n");
36724: }
36725: }
36726: }
36727: function_tests++;
36728:
36729: return(test_ret);
36730: }
36731:
36732:
36733: static int
36734: test_xmlUTF8Strndup(void) {
36735: int test_ret = 0;
36736:
36737: int mem_base;
36738: xmlChar * ret_val;
36739: xmlChar * utf; /* the input UTF8 * */
36740: int n_utf;
36741: int len; /* the len of @utf (in chars) */
36742: int n_len;
36743:
36744: for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
36745: for (n_len = 0;n_len < gen_nb_int;n_len++) {
36746: mem_base = xmlMemBlocks();
36747: utf = gen_const_xmlChar_ptr(n_utf, 0);
36748: len = gen_int(n_len, 1);
36749:
36750: ret_val = xmlUTF8Strndup((const xmlChar *)utf, len);
36751: desret_xmlChar_ptr(ret_val);
36752: call_tests++;
36753: des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
36754: des_int(n_len, len, 1);
36755: xmlResetLastError();
36756: if (mem_base != xmlMemBlocks()) {
36757: printf("Leak of %d blocks found in xmlUTF8Strndup",
36758: xmlMemBlocks() - mem_base);
36759: test_ret++;
36760: printf(" %d", n_utf);
36761: printf(" %d", n_len);
36762: printf("\n");
36763: }
36764: }
36765: }
36766: function_tests++;
36767:
36768: return(test_ret);
36769: }
36770:
36771:
36772: static int
36773: test_xmlUTF8Strpos(void) {
36774: int test_ret = 0;
36775:
36776: int mem_base;
36777: const xmlChar * ret_val;
36778: xmlChar * utf; /* the input UTF8 * */
36779: int n_utf;
36780: int pos; /* the position of the desired UTF8 char (in chars) */
36781: int n_pos;
36782:
36783: for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
36784: for (n_pos = 0;n_pos < gen_nb_int;n_pos++) {
36785: mem_base = xmlMemBlocks();
36786: utf = gen_const_xmlChar_ptr(n_utf, 0);
36787: pos = gen_int(n_pos, 1);
36788:
36789: ret_val = xmlUTF8Strpos((const xmlChar *)utf, pos);
36790: desret_const_xmlChar_ptr(ret_val);
36791: call_tests++;
36792: des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
36793: des_int(n_pos, pos, 1);
36794: xmlResetLastError();
36795: if (mem_base != xmlMemBlocks()) {
36796: printf("Leak of %d blocks found in xmlUTF8Strpos",
36797: xmlMemBlocks() - mem_base);
36798: test_ret++;
36799: printf(" %d", n_utf);
36800: printf(" %d", n_pos);
36801: printf("\n");
36802: }
36803: }
36804: }
36805: function_tests++;
36806:
36807: return(test_ret);
36808: }
36809:
36810:
36811: static int
36812: test_xmlUTF8Strsize(void) {
36813: int test_ret = 0;
36814:
36815: int mem_base;
36816: int ret_val;
36817: xmlChar * utf; /* a sequence of UTF-8 encoded bytes */
36818: int n_utf;
36819: int len; /* the number of characters in the array */
36820: int n_len;
36821:
36822: for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
36823: for (n_len = 0;n_len < gen_nb_int;n_len++) {
36824: mem_base = xmlMemBlocks();
36825: utf = gen_const_xmlChar_ptr(n_utf, 0);
36826: len = gen_int(n_len, 1);
36827:
36828: ret_val = xmlUTF8Strsize((const xmlChar *)utf, len);
36829: desret_int(ret_val);
36830: call_tests++;
36831: des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
36832: des_int(n_len, len, 1);
36833: xmlResetLastError();
36834: if (mem_base != xmlMemBlocks()) {
36835: printf("Leak of %d blocks found in xmlUTF8Strsize",
36836: xmlMemBlocks() - mem_base);
36837: test_ret++;
36838: printf(" %d", n_utf);
36839: printf(" %d", n_len);
36840: printf("\n");
36841: }
36842: }
36843: }
36844: function_tests++;
36845:
36846: return(test_ret);
36847: }
36848:
36849:
36850: static int
36851: test_xmlUTF8Strsub(void) {
36852: int test_ret = 0;
36853:
36854: int mem_base;
36855: xmlChar * ret_val;
36856: xmlChar * utf; /* a sequence of UTF-8 encoded bytes */
36857: int n_utf;
36858: int start; /* relative pos of first char */
36859: int n_start;
36860: int len; /* total number to copy */
36861: int n_len;
36862:
36863: for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
36864: for (n_start = 0;n_start < gen_nb_int;n_start++) {
36865: for (n_len = 0;n_len < gen_nb_int;n_len++) {
36866: mem_base = xmlMemBlocks();
36867: utf = gen_const_xmlChar_ptr(n_utf, 0);
36868: start = gen_int(n_start, 1);
36869: len = gen_int(n_len, 2);
36870:
36871: ret_val = xmlUTF8Strsub((const xmlChar *)utf, start, len);
36872: desret_xmlChar_ptr(ret_val);
36873: call_tests++;
36874: des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
36875: des_int(n_start, start, 1);
36876: des_int(n_len, len, 2);
36877: xmlResetLastError();
36878: if (mem_base != xmlMemBlocks()) {
36879: printf("Leak of %d blocks found in xmlUTF8Strsub",
36880: xmlMemBlocks() - mem_base);
36881: test_ret++;
36882: printf(" %d", n_utf);
36883: printf(" %d", n_start);
36884: printf(" %d", n_len);
36885: printf("\n");
36886: }
36887: }
36888: }
36889: }
36890: function_tests++;
36891:
36892: return(test_ret);
36893: }
36894:
36895: static int
36896: test_xmlstring(void) {
36897: int test_ret = 0;
36898:
36899: if (quiet == 0) printf("Testing xmlstring : 26 of 30 functions ...\n");
36900: test_ret += test_xmlCharStrdup();
36901: test_ret += test_xmlCharStrndup();
36902: test_ret += test_xmlCheckUTF8();
36903: test_ret += test_xmlGetUTF8Char();
36904: test_ret += test_xmlStrEqual();
36905: test_ret += test_xmlStrPrintf();
36906: test_ret += test_xmlStrQEqual();
36907: test_ret += test_xmlStrVPrintf();
36908: test_ret += test_xmlStrcasecmp();
36909: test_ret += test_xmlStrcasestr();
36910: test_ret += test_xmlStrchr();
36911: test_ret += test_xmlStrcmp();
36912: test_ret += test_xmlStrdup();
36913: test_ret += test_xmlStrlen();
36914: test_ret += test_xmlStrncasecmp();
36915: test_ret += test_xmlStrncatNew();
36916: test_ret += test_xmlStrncmp();
36917: test_ret += test_xmlStrndup();
36918: test_ret += test_xmlStrstr();
36919: test_ret += test_xmlStrsub();
36920: test_ret += test_xmlUTF8Charcmp();
36921: test_ret += test_xmlUTF8Size();
36922: test_ret += test_xmlUTF8Strlen();
36923: test_ret += test_xmlUTF8Strloc();
36924: test_ret += test_xmlUTF8Strndup();
36925: test_ret += test_xmlUTF8Strpos();
36926: test_ret += test_xmlUTF8Strsize();
36927: test_ret += test_xmlUTF8Strsub();
36928:
36929: if (test_ret != 0)
36930: printf("Module xmlstring: %d errors\n", test_ret);
36931: return(test_ret);
36932: }
36933:
36934: static int
36935: test_xmlUCSIsAegeanNumbers(void) {
36936: int test_ret = 0;
36937:
36938: #if defined(LIBXML_UNICODE_ENABLED)
36939: int mem_base;
36940: int ret_val;
36941: int code; /* UCS code point */
36942: int n_code;
36943:
36944: for (n_code = 0;n_code < gen_nb_int;n_code++) {
36945: mem_base = xmlMemBlocks();
36946: code = gen_int(n_code, 0);
36947:
36948: ret_val = xmlUCSIsAegeanNumbers(code);
36949: desret_int(ret_val);
36950: call_tests++;
36951: des_int(n_code, code, 0);
36952: xmlResetLastError();
36953: if (mem_base != xmlMemBlocks()) {
36954: printf("Leak of %d blocks found in xmlUCSIsAegeanNumbers",
36955: xmlMemBlocks() - mem_base);
36956: test_ret++;
36957: printf(" %d", n_code);
36958: printf("\n");
36959: }
36960: }
36961: function_tests++;
36962: #endif
36963:
36964: return(test_ret);
36965: }
36966:
36967:
36968: static int
36969: test_xmlUCSIsAlphabeticPresentationForms(void) {
36970: int test_ret = 0;
36971:
36972: #if defined(LIBXML_UNICODE_ENABLED)
36973: int mem_base;
36974: int ret_val;
36975: int code; /* UCS code point */
36976: int n_code;
36977:
36978: for (n_code = 0;n_code < gen_nb_int;n_code++) {
36979: mem_base = xmlMemBlocks();
36980: code = gen_int(n_code, 0);
36981:
36982: ret_val = xmlUCSIsAlphabeticPresentationForms(code);
36983: desret_int(ret_val);
36984: call_tests++;
36985: des_int(n_code, code, 0);
36986: xmlResetLastError();
36987: if (mem_base != xmlMemBlocks()) {
36988: printf("Leak of %d blocks found in xmlUCSIsAlphabeticPresentationForms",
36989: xmlMemBlocks() - mem_base);
36990: test_ret++;
36991: printf(" %d", n_code);
36992: printf("\n");
36993: }
36994: }
36995: function_tests++;
36996: #endif
36997:
36998: return(test_ret);
36999: }
37000:
37001:
37002: static int
37003: test_xmlUCSIsArabic(void) {
37004: int test_ret = 0;
37005:
37006: #if defined(LIBXML_UNICODE_ENABLED)
37007: int mem_base;
37008: int ret_val;
37009: int code; /* UCS code point */
37010: int n_code;
37011:
37012: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37013: mem_base = xmlMemBlocks();
37014: code = gen_int(n_code, 0);
37015:
37016: ret_val = xmlUCSIsArabic(code);
37017: desret_int(ret_val);
37018: call_tests++;
37019: des_int(n_code, code, 0);
37020: xmlResetLastError();
37021: if (mem_base != xmlMemBlocks()) {
37022: printf("Leak of %d blocks found in xmlUCSIsArabic",
37023: xmlMemBlocks() - mem_base);
37024: test_ret++;
37025: printf(" %d", n_code);
37026: printf("\n");
37027: }
37028: }
37029: function_tests++;
37030: #endif
37031:
37032: return(test_ret);
37033: }
37034:
37035:
37036: static int
37037: test_xmlUCSIsArabicPresentationFormsA(void) {
37038: int test_ret = 0;
37039:
37040: #if defined(LIBXML_UNICODE_ENABLED)
37041: int mem_base;
37042: int ret_val;
37043: int code; /* UCS code point */
37044: int n_code;
37045:
37046: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37047: mem_base = xmlMemBlocks();
37048: code = gen_int(n_code, 0);
37049:
37050: ret_val = xmlUCSIsArabicPresentationFormsA(code);
37051: desret_int(ret_val);
37052: call_tests++;
37053: des_int(n_code, code, 0);
37054: xmlResetLastError();
37055: if (mem_base != xmlMemBlocks()) {
37056: printf("Leak of %d blocks found in xmlUCSIsArabicPresentationFormsA",
37057: xmlMemBlocks() - mem_base);
37058: test_ret++;
37059: printf(" %d", n_code);
37060: printf("\n");
37061: }
37062: }
37063: function_tests++;
37064: #endif
37065:
37066: return(test_ret);
37067: }
37068:
37069:
37070: static int
37071: test_xmlUCSIsArabicPresentationFormsB(void) {
37072: int test_ret = 0;
37073:
37074: #if defined(LIBXML_UNICODE_ENABLED)
37075: int mem_base;
37076: int ret_val;
37077: int code; /* UCS code point */
37078: int n_code;
37079:
37080: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37081: mem_base = xmlMemBlocks();
37082: code = gen_int(n_code, 0);
37083:
37084: ret_val = xmlUCSIsArabicPresentationFormsB(code);
37085: desret_int(ret_val);
37086: call_tests++;
37087: des_int(n_code, code, 0);
37088: xmlResetLastError();
37089: if (mem_base != xmlMemBlocks()) {
37090: printf("Leak of %d blocks found in xmlUCSIsArabicPresentationFormsB",
37091: xmlMemBlocks() - mem_base);
37092: test_ret++;
37093: printf(" %d", n_code);
37094: printf("\n");
37095: }
37096: }
37097: function_tests++;
37098: #endif
37099:
37100: return(test_ret);
37101: }
37102:
37103:
37104: static int
37105: test_xmlUCSIsArmenian(void) {
37106: int test_ret = 0;
37107:
37108: #if defined(LIBXML_UNICODE_ENABLED)
37109: int mem_base;
37110: int ret_val;
37111: int code; /* UCS code point */
37112: int n_code;
37113:
37114: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37115: mem_base = xmlMemBlocks();
37116: code = gen_int(n_code, 0);
37117:
37118: ret_val = xmlUCSIsArmenian(code);
37119: desret_int(ret_val);
37120: call_tests++;
37121: des_int(n_code, code, 0);
37122: xmlResetLastError();
37123: if (mem_base != xmlMemBlocks()) {
37124: printf("Leak of %d blocks found in xmlUCSIsArmenian",
37125: xmlMemBlocks() - mem_base);
37126: test_ret++;
37127: printf(" %d", n_code);
37128: printf("\n");
37129: }
37130: }
37131: function_tests++;
37132: #endif
37133:
37134: return(test_ret);
37135: }
37136:
37137:
37138: static int
37139: test_xmlUCSIsArrows(void) {
37140: int test_ret = 0;
37141:
37142: #if defined(LIBXML_UNICODE_ENABLED)
37143: int mem_base;
37144: int ret_val;
37145: int code; /* UCS code point */
37146: int n_code;
37147:
37148: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37149: mem_base = xmlMemBlocks();
37150: code = gen_int(n_code, 0);
37151:
37152: ret_val = xmlUCSIsArrows(code);
37153: desret_int(ret_val);
37154: call_tests++;
37155: des_int(n_code, code, 0);
37156: xmlResetLastError();
37157: if (mem_base != xmlMemBlocks()) {
37158: printf("Leak of %d blocks found in xmlUCSIsArrows",
37159: xmlMemBlocks() - mem_base);
37160: test_ret++;
37161: printf(" %d", n_code);
37162: printf("\n");
37163: }
37164: }
37165: function_tests++;
37166: #endif
37167:
37168: return(test_ret);
37169: }
37170:
37171:
37172: static int
37173: test_xmlUCSIsBasicLatin(void) {
37174: int test_ret = 0;
37175:
37176: #if defined(LIBXML_UNICODE_ENABLED)
37177: int mem_base;
37178: int ret_val;
37179: int code; /* UCS code point */
37180: int n_code;
37181:
37182: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37183: mem_base = xmlMemBlocks();
37184: code = gen_int(n_code, 0);
37185:
37186: ret_val = xmlUCSIsBasicLatin(code);
37187: desret_int(ret_val);
37188: call_tests++;
37189: des_int(n_code, code, 0);
37190: xmlResetLastError();
37191: if (mem_base != xmlMemBlocks()) {
37192: printf("Leak of %d blocks found in xmlUCSIsBasicLatin",
37193: xmlMemBlocks() - mem_base);
37194: test_ret++;
37195: printf(" %d", n_code);
37196: printf("\n");
37197: }
37198: }
37199: function_tests++;
37200: #endif
37201:
37202: return(test_ret);
37203: }
37204:
37205:
37206: static int
37207: test_xmlUCSIsBengali(void) {
37208: int test_ret = 0;
37209:
37210: #if defined(LIBXML_UNICODE_ENABLED)
37211: int mem_base;
37212: int ret_val;
37213: int code; /* UCS code point */
37214: int n_code;
37215:
37216: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37217: mem_base = xmlMemBlocks();
37218: code = gen_int(n_code, 0);
37219:
37220: ret_val = xmlUCSIsBengali(code);
37221: desret_int(ret_val);
37222: call_tests++;
37223: des_int(n_code, code, 0);
37224: xmlResetLastError();
37225: if (mem_base != xmlMemBlocks()) {
37226: printf("Leak of %d blocks found in xmlUCSIsBengali",
37227: xmlMemBlocks() - mem_base);
37228: test_ret++;
37229: printf(" %d", n_code);
37230: printf("\n");
37231: }
37232: }
37233: function_tests++;
37234: #endif
37235:
37236: return(test_ret);
37237: }
37238:
37239:
37240: static int
37241: test_xmlUCSIsBlock(void) {
37242: int test_ret = 0;
37243:
37244: #if defined(LIBXML_UNICODE_ENABLED)
37245: int mem_base;
37246: int ret_val;
37247: int code; /* UCS code point */
37248: int n_code;
37249: char * block; /* UCS block name */
37250: int n_block;
37251:
37252: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37253: for (n_block = 0;n_block < gen_nb_const_char_ptr;n_block++) {
37254: mem_base = xmlMemBlocks();
37255: code = gen_int(n_code, 0);
37256: block = gen_const_char_ptr(n_block, 1);
37257:
37258: ret_val = xmlUCSIsBlock(code, (const char *)block);
37259: desret_int(ret_val);
37260: call_tests++;
37261: des_int(n_code, code, 0);
37262: des_const_char_ptr(n_block, (const char *)block, 1);
37263: xmlResetLastError();
37264: if (mem_base != xmlMemBlocks()) {
37265: printf("Leak of %d blocks found in xmlUCSIsBlock",
37266: xmlMemBlocks() - mem_base);
37267: test_ret++;
37268: printf(" %d", n_code);
37269: printf(" %d", n_block);
37270: printf("\n");
37271: }
37272: }
37273: }
37274: function_tests++;
37275: #endif
37276:
37277: return(test_ret);
37278: }
37279:
37280:
37281: static int
37282: test_xmlUCSIsBlockElements(void) {
37283: int test_ret = 0;
37284:
37285: #if defined(LIBXML_UNICODE_ENABLED)
37286: int mem_base;
37287: int ret_val;
37288: int code; /* UCS code point */
37289: int n_code;
37290:
37291: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37292: mem_base = xmlMemBlocks();
37293: code = gen_int(n_code, 0);
37294:
37295: ret_val = xmlUCSIsBlockElements(code);
37296: desret_int(ret_val);
37297: call_tests++;
37298: des_int(n_code, code, 0);
37299: xmlResetLastError();
37300: if (mem_base != xmlMemBlocks()) {
37301: printf("Leak of %d blocks found in xmlUCSIsBlockElements",
37302: xmlMemBlocks() - mem_base);
37303: test_ret++;
37304: printf(" %d", n_code);
37305: printf("\n");
37306: }
37307: }
37308: function_tests++;
37309: #endif
37310:
37311: return(test_ret);
37312: }
37313:
37314:
37315: static int
37316: test_xmlUCSIsBopomofo(void) {
37317: int test_ret = 0;
37318:
37319: #if defined(LIBXML_UNICODE_ENABLED)
37320: int mem_base;
37321: int ret_val;
37322: int code; /* UCS code point */
37323: int n_code;
37324:
37325: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37326: mem_base = xmlMemBlocks();
37327: code = gen_int(n_code, 0);
37328:
37329: ret_val = xmlUCSIsBopomofo(code);
37330: desret_int(ret_val);
37331: call_tests++;
37332: des_int(n_code, code, 0);
37333: xmlResetLastError();
37334: if (mem_base != xmlMemBlocks()) {
37335: printf("Leak of %d blocks found in xmlUCSIsBopomofo",
37336: xmlMemBlocks() - mem_base);
37337: test_ret++;
37338: printf(" %d", n_code);
37339: printf("\n");
37340: }
37341: }
37342: function_tests++;
37343: #endif
37344:
37345: return(test_ret);
37346: }
37347:
37348:
37349: static int
37350: test_xmlUCSIsBopomofoExtended(void) {
37351: int test_ret = 0;
37352:
37353: #if defined(LIBXML_UNICODE_ENABLED)
37354: int mem_base;
37355: int ret_val;
37356: int code; /* UCS code point */
37357: int n_code;
37358:
37359: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37360: mem_base = xmlMemBlocks();
37361: code = gen_int(n_code, 0);
37362:
37363: ret_val = xmlUCSIsBopomofoExtended(code);
37364: desret_int(ret_val);
37365: call_tests++;
37366: des_int(n_code, code, 0);
37367: xmlResetLastError();
37368: if (mem_base != xmlMemBlocks()) {
37369: printf("Leak of %d blocks found in xmlUCSIsBopomofoExtended",
37370: xmlMemBlocks() - mem_base);
37371: test_ret++;
37372: printf(" %d", n_code);
37373: printf("\n");
37374: }
37375: }
37376: function_tests++;
37377: #endif
37378:
37379: return(test_ret);
37380: }
37381:
37382:
37383: static int
37384: test_xmlUCSIsBoxDrawing(void) {
37385: int test_ret = 0;
37386:
37387: #if defined(LIBXML_UNICODE_ENABLED)
37388: int mem_base;
37389: int ret_val;
37390: int code; /* UCS code point */
37391: int n_code;
37392:
37393: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37394: mem_base = xmlMemBlocks();
37395: code = gen_int(n_code, 0);
37396:
37397: ret_val = xmlUCSIsBoxDrawing(code);
37398: desret_int(ret_val);
37399: call_tests++;
37400: des_int(n_code, code, 0);
37401: xmlResetLastError();
37402: if (mem_base != xmlMemBlocks()) {
37403: printf("Leak of %d blocks found in xmlUCSIsBoxDrawing",
37404: xmlMemBlocks() - mem_base);
37405: test_ret++;
37406: printf(" %d", n_code);
37407: printf("\n");
37408: }
37409: }
37410: function_tests++;
37411: #endif
37412:
37413: return(test_ret);
37414: }
37415:
37416:
37417: static int
37418: test_xmlUCSIsBraillePatterns(void) {
37419: int test_ret = 0;
37420:
37421: #if defined(LIBXML_UNICODE_ENABLED)
37422: int mem_base;
37423: int ret_val;
37424: int code; /* UCS code point */
37425: int n_code;
37426:
37427: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37428: mem_base = xmlMemBlocks();
37429: code = gen_int(n_code, 0);
37430:
37431: ret_val = xmlUCSIsBraillePatterns(code);
37432: desret_int(ret_val);
37433: call_tests++;
37434: des_int(n_code, code, 0);
37435: xmlResetLastError();
37436: if (mem_base != xmlMemBlocks()) {
37437: printf("Leak of %d blocks found in xmlUCSIsBraillePatterns",
37438: xmlMemBlocks() - mem_base);
37439: test_ret++;
37440: printf(" %d", n_code);
37441: printf("\n");
37442: }
37443: }
37444: function_tests++;
37445: #endif
37446:
37447: return(test_ret);
37448: }
37449:
37450:
37451: static int
37452: test_xmlUCSIsBuhid(void) {
37453: int test_ret = 0;
37454:
37455: #if defined(LIBXML_UNICODE_ENABLED)
37456: int mem_base;
37457: int ret_val;
37458: int code; /* UCS code point */
37459: int n_code;
37460:
37461: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37462: mem_base = xmlMemBlocks();
37463: code = gen_int(n_code, 0);
37464:
37465: ret_val = xmlUCSIsBuhid(code);
37466: desret_int(ret_val);
37467: call_tests++;
37468: des_int(n_code, code, 0);
37469: xmlResetLastError();
37470: if (mem_base != xmlMemBlocks()) {
37471: printf("Leak of %d blocks found in xmlUCSIsBuhid",
37472: xmlMemBlocks() - mem_base);
37473: test_ret++;
37474: printf(" %d", n_code);
37475: printf("\n");
37476: }
37477: }
37478: function_tests++;
37479: #endif
37480:
37481: return(test_ret);
37482: }
37483:
37484:
37485: static int
37486: test_xmlUCSIsByzantineMusicalSymbols(void) {
37487: int test_ret = 0;
37488:
37489: #if defined(LIBXML_UNICODE_ENABLED)
37490: int mem_base;
37491: int ret_val;
37492: int code; /* UCS code point */
37493: int n_code;
37494:
37495: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37496: mem_base = xmlMemBlocks();
37497: code = gen_int(n_code, 0);
37498:
37499: ret_val = xmlUCSIsByzantineMusicalSymbols(code);
37500: desret_int(ret_val);
37501: call_tests++;
37502: des_int(n_code, code, 0);
37503: xmlResetLastError();
37504: if (mem_base != xmlMemBlocks()) {
37505: printf("Leak of %d blocks found in xmlUCSIsByzantineMusicalSymbols",
37506: xmlMemBlocks() - mem_base);
37507: test_ret++;
37508: printf(" %d", n_code);
37509: printf("\n");
37510: }
37511: }
37512: function_tests++;
37513: #endif
37514:
37515: return(test_ret);
37516: }
37517:
37518:
37519: static int
37520: test_xmlUCSIsCJKCompatibility(void) {
37521: int test_ret = 0;
37522:
37523: #if defined(LIBXML_UNICODE_ENABLED)
37524: int mem_base;
37525: int ret_val;
37526: int code; /* UCS code point */
37527: int n_code;
37528:
37529: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37530: mem_base = xmlMemBlocks();
37531: code = gen_int(n_code, 0);
37532:
37533: ret_val = xmlUCSIsCJKCompatibility(code);
37534: desret_int(ret_val);
37535: call_tests++;
37536: des_int(n_code, code, 0);
37537: xmlResetLastError();
37538: if (mem_base != xmlMemBlocks()) {
37539: printf("Leak of %d blocks found in xmlUCSIsCJKCompatibility",
37540: xmlMemBlocks() - mem_base);
37541: test_ret++;
37542: printf(" %d", n_code);
37543: printf("\n");
37544: }
37545: }
37546: function_tests++;
37547: #endif
37548:
37549: return(test_ret);
37550: }
37551:
37552:
37553: static int
37554: test_xmlUCSIsCJKCompatibilityForms(void) {
37555: int test_ret = 0;
37556:
37557: #if defined(LIBXML_UNICODE_ENABLED)
37558: int mem_base;
37559: int ret_val;
37560: int code; /* UCS code point */
37561: int n_code;
37562:
37563: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37564: mem_base = xmlMemBlocks();
37565: code = gen_int(n_code, 0);
37566:
37567: ret_val = xmlUCSIsCJKCompatibilityForms(code);
37568: desret_int(ret_val);
37569: call_tests++;
37570: des_int(n_code, code, 0);
37571: xmlResetLastError();
37572: if (mem_base != xmlMemBlocks()) {
37573: printf("Leak of %d blocks found in xmlUCSIsCJKCompatibilityForms",
37574: xmlMemBlocks() - mem_base);
37575: test_ret++;
37576: printf(" %d", n_code);
37577: printf("\n");
37578: }
37579: }
37580: function_tests++;
37581: #endif
37582:
37583: return(test_ret);
37584: }
37585:
37586:
37587: static int
37588: test_xmlUCSIsCJKCompatibilityIdeographs(void) {
37589: int test_ret = 0;
37590:
37591: #if defined(LIBXML_UNICODE_ENABLED)
37592: int mem_base;
37593: int ret_val;
37594: int code; /* UCS code point */
37595: int n_code;
37596:
37597: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37598: mem_base = xmlMemBlocks();
37599: code = gen_int(n_code, 0);
37600:
37601: ret_val = xmlUCSIsCJKCompatibilityIdeographs(code);
37602: desret_int(ret_val);
37603: call_tests++;
37604: des_int(n_code, code, 0);
37605: xmlResetLastError();
37606: if (mem_base != xmlMemBlocks()) {
37607: printf("Leak of %d blocks found in xmlUCSIsCJKCompatibilityIdeographs",
37608: xmlMemBlocks() - mem_base);
37609: test_ret++;
37610: printf(" %d", n_code);
37611: printf("\n");
37612: }
37613: }
37614: function_tests++;
37615: #endif
37616:
37617: return(test_ret);
37618: }
37619:
37620:
37621: static int
37622: test_xmlUCSIsCJKCompatibilityIdeographsSupplement(void) {
37623: int test_ret = 0;
37624:
37625: #if defined(LIBXML_UNICODE_ENABLED)
37626: int mem_base;
37627: int ret_val;
37628: int code; /* UCS code point */
37629: int n_code;
37630:
37631: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37632: mem_base = xmlMemBlocks();
37633: code = gen_int(n_code, 0);
37634:
37635: ret_val = xmlUCSIsCJKCompatibilityIdeographsSupplement(code);
37636: desret_int(ret_val);
37637: call_tests++;
37638: des_int(n_code, code, 0);
37639: xmlResetLastError();
37640: if (mem_base != xmlMemBlocks()) {
37641: printf("Leak of %d blocks found in xmlUCSIsCJKCompatibilityIdeographsSupplement",
37642: xmlMemBlocks() - mem_base);
37643: test_ret++;
37644: printf(" %d", n_code);
37645: printf("\n");
37646: }
37647: }
37648: function_tests++;
37649: #endif
37650:
37651: return(test_ret);
37652: }
37653:
37654:
37655: static int
37656: test_xmlUCSIsCJKRadicalsSupplement(void) {
37657: int test_ret = 0;
37658:
37659: #if defined(LIBXML_UNICODE_ENABLED)
37660: int mem_base;
37661: int ret_val;
37662: int code; /* UCS code point */
37663: int n_code;
37664:
37665: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37666: mem_base = xmlMemBlocks();
37667: code = gen_int(n_code, 0);
37668:
37669: ret_val = xmlUCSIsCJKRadicalsSupplement(code);
37670: desret_int(ret_val);
37671: call_tests++;
37672: des_int(n_code, code, 0);
37673: xmlResetLastError();
37674: if (mem_base != xmlMemBlocks()) {
37675: printf("Leak of %d blocks found in xmlUCSIsCJKRadicalsSupplement",
37676: xmlMemBlocks() - mem_base);
37677: test_ret++;
37678: printf(" %d", n_code);
37679: printf("\n");
37680: }
37681: }
37682: function_tests++;
37683: #endif
37684:
37685: return(test_ret);
37686: }
37687:
37688:
37689: static int
37690: test_xmlUCSIsCJKSymbolsandPunctuation(void) {
37691: int test_ret = 0;
37692:
37693: #if defined(LIBXML_UNICODE_ENABLED)
37694: int mem_base;
37695: int ret_val;
37696: int code; /* UCS code point */
37697: int n_code;
37698:
37699: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37700: mem_base = xmlMemBlocks();
37701: code = gen_int(n_code, 0);
37702:
37703: ret_val = xmlUCSIsCJKSymbolsandPunctuation(code);
37704: desret_int(ret_val);
37705: call_tests++;
37706: des_int(n_code, code, 0);
37707: xmlResetLastError();
37708: if (mem_base != xmlMemBlocks()) {
37709: printf("Leak of %d blocks found in xmlUCSIsCJKSymbolsandPunctuation",
37710: xmlMemBlocks() - mem_base);
37711: test_ret++;
37712: printf(" %d", n_code);
37713: printf("\n");
37714: }
37715: }
37716: function_tests++;
37717: #endif
37718:
37719: return(test_ret);
37720: }
37721:
37722:
37723: static int
37724: test_xmlUCSIsCJKUnifiedIdeographs(void) {
37725: int test_ret = 0;
37726:
37727: #if defined(LIBXML_UNICODE_ENABLED)
37728: int mem_base;
37729: int ret_val;
37730: int code; /* UCS code point */
37731: int n_code;
37732:
37733: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37734: mem_base = xmlMemBlocks();
37735: code = gen_int(n_code, 0);
37736:
37737: ret_val = xmlUCSIsCJKUnifiedIdeographs(code);
37738: desret_int(ret_val);
37739: call_tests++;
37740: des_int(n_code, code, 0);
37741: xmlResetLastError();
37742: if (mem_base != xmlMemBlocks()) {
37743: printf("Leak of %d blocks found in xmlUCSIsCJKUnifiedIdeographs",
37744: xmlMemBlocks() - mem_base);
37745: test_ret++;
37746: printf(" %d", n_code);
37747: printf("\n");
37748: }
37749: }
37750: function_tests++;
37751: #endif
37752:
37753: return(test_ret);
37754: }
37755:
37756:
37757: static int
37758: test_xmlUCSIsCJKUnifiedIdeographsExtensionA(void) {
37759: int test_ret = 0;
37760:
37761: #if defined(LIBXML_UNICODE_ENABLED)
37762: int mem_base;
37763: int ret_val;
37764: int code; /* UCS code point */
37765: int n_code;
37766:
37767: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37768: mem_base = xmlMemBlocks();
37769: code = gen_int(n_code, 0);
37770:
37771: ret_val = xmlUCSIsCJKUnifiedIdeographsExtensionA(code);
37772: desret_int(ret_val);
37773: call_tests++;
37774: des_int(n_code, code, 0);
37775: xmlResetLastError();
37776: if (mem_base != xmlMemBlocks()) {
37777: printf("Leak of %d blocks found in xmlUCSIsCJKUnifiedIdeographsExtensionA",
37778: xmlMemBlocks() - mem_base);
37779: test_ret++;
37780: printf(" %d", n_code);
37781: printf("\n");
37782: }
37783: }
37784: function_tests++;
37785: #endif
37786:
37787: return(test_ret);
37788: }
37789:
37790:
37791: static int
37792: test_xmlUCSIsCJKUnifiedIdeographsExtensionB(void) {
37793: int test_ret = 0;
37794:
37795: #if defined(LIBXML_UNICODE_ENABLED)
37796: int mem_base;
37797: int ret_val;
37798: int code; /* UCS code point */
37799: int n_code;
37800:
37801: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37802: mem_base = xmlMemBlocks();
37803: code = gen_int(n_code, 0);
37804:
37805: ret_val = xmlUCSIsCJKUnifiedIdeographsExtensionB(code);
37806: desret_int(ret_val);
37807: call_tests++;
37808: des_int(n_code, code, 0);
37809: xmlResetLastError();
37810: if (mem_base != xmlMemBlocks()) {
37811: printf("Leak of %d blocks found in xmlUCSIsCJKUnifiedIdeographsExtensionB",
37812: xmlMemBlocks() - mem_base);
37813: test_ret++;
37814: printf(" %d", n_code);
37815: printf("\n");
37816: }
37817: }
37818: function_tests++;
37819: #endif
37820:
37821: return(test_ret);
37822: }
37823:
37824:
37825: static int
37826: test_xmlUCSIsCat(void) {
37827: int test_ret = 0;
37828:
37829: #if defined(LIBXML_UNICODE_ENABLED)
37830: int mem_base;
37831: int ret_val;
37832: int code; /* UCS code point */
37833: int n_code;
37834: char * cat; /* UCS Category name */
37835: int n_cat;
37836:
37837: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37838: for (n_cat = 0;n_cat < gen_nb_const_char_ptr;n_cat++) {
37839: mem_base = xmlMemBlocks();
37840: code = gen_int(n_code, 0);
37841: cat = gen_const_char_ptr(n_cat, 1);
37842:
37843: ret_val = xmlUCSIsCat(code, (const char *)cat);
37844: desret_int(ret_val);
37845: call_tests++;
37846: des_int(n_code, code, 0);
37847: des_const_char_ptr(n_cat, (const char *)cat, 1);
37848: xmlResetLastError();
37849: if (mem_base != xmlMemBlocks()) {
37850: printf("Leak of %d blocks found in xmlUCSIsCat",
37851: xmlMemBlocks() - mem_base);
37852: test_ret++;
37853: printf(" %d", n_code);
37854: printf(" %d", n_cat);
37855: printf("\n");
37856: }
37857: }
37858: }
37859: function_tests++;
37860: #endif
37861:
37862: return(test_ret);
37863: }
37864:
37865:
37866: static int
37867: test_xmlUCSIsCatC(void) {
37868: int test_ret = 0;
37869:
37870: #if defined(LIBXML_UNICODE_ENABLED)
37871: int mem_base;
37872: int ret_val;
37873: int code; /* UCS code point */
37874: int n_code;
37875:
37876: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37877: mem_base = xmlMemBlocks();
37878: code = gen_int(n_code, 0);
37879:
37880: ret_val = xmlUCSIsCatC(code);
37881: desret_int(ret_val);
37882: call_tests++;
37883: des_int(n_code, code, 0);
37884: xmlResetLastError();
37885: if (mem_base != xmlMemBlocks()) {
37886: printf("Leak of %d blocks found in xmlUCSIsCatC",
37887: xmlMemBlocks() - mem_base);
37888: test_ret++;
37889: printf(" %d", n_code);
37890: printf("\n");
37891: }
37892: }
37893: function_tests++;
37894: #endif
37895:
37896: return(test_ret);
37897: }
37898:
37899:
37900: static int
37901: test_xmlUCSIsCatCc(void) {
37902: int test_ret = 0;
37903:
37904: #if defined(LIBXML_UNICODE_ENABLED)
37905: int mem_base;
37906: int ret_val;
37907: int code; /* UCS code point */
37908: int n_code;
37909:
37910: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37911: mem_base = xmlMemBlocks();
37912: code = gen_int(n_code, 0);
37913:
37914: ret_val = xmlUCSIsCatCc(code);
37915: desret_int(ret_val);
37916: call_tests++;
37917: des_int(n_code, code, 0);
37918: xmlResetLastError();
37919: if (mem_base != xmlMemBlocks()) {
37920: printf("Leak of %d blocks found in xmlUCSIsCatCc",
37921: xmlMemBlocks() - mem_base);
37922: test_ret++;
37923: printf(" %d", n_code);
37924: printf("\n");
37925: }
37926: }
37927: function_tests++;
37928: #endif
37929:
37930: return(test_ret);
37931: }
37932:
37933:
37934: static int
37935: test_xmlUCSIsCatCf(void) {
37936: int test_ret = 0;
37937:
37938: #if defined(LIBXML_UNICODE_ENABLED)
37939: int mem_base;
37940: int ret_val;
37941: int code; /* UCS code point */
37942: int n_code;
37943:
37944: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37945: mem_base = xmlMemBlocks();
37946: code = gen_int(n_code, 0);
37947:
37948: ret_val = xmlUCSIsCatCf(code);
37949: desret_int(ret_val);
37950: call_tests++;
37951: des_int(n_code, code, 0);
37952: xmlResetLastError();
37953: if (mem_base != xmlMemBlocks()) {
37954: printf("Leak of %d blocks found in xmlUCSIsCatCf",
37955: xmlMemBlocks() - mem_base);
37956: test_ret++;
37957: printf(" %d", n_code);
37958: printf("\n");
37959: }
37960: }
37961: function_tests++;
37962: #endif
37963:
37964: return(test_ret);
37965: }
37966:
37967:
37968: static int
37969: test_xmlUCSIsCatCo(void) {
37970: int test_ret = 0;
37971:
37972: #if defined(LIBXML_UNICODE_ENABLED)
37973: int mem_base;
37974: int ret_val;
37975: int code; /* UCS code point */
37976: int n_code;
37977:
37978: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37979: mem_base = xmlMemBlocks();
37980: code = gen_int(n_code, 0);
37981:
37982: ret_val = xmlUCSIsCatCo(code);
37983: desret_int(ret_val);
37984: call_tests++;
37985: des_int(n_code, code, 0);
37986: xmlResetLastError();
37987: if (mem_base != xmlMemBlocks()) {
37988: printf("Leak of %d blocks found in xmlUCSIsCatCo",
37989: xmlMemBlocks() - mem_base);
37990: test_ret++;
37991: printf(" %d", n_code);
37992: printf("\n");
37993: }
37994: }
37995: function_tests++;
37996: #endif
37997:
37998: return(test_ret);
37999: }
38000:
38001:
38002: static int
38003: test_xmlUCSIsCatCs(void) {
38004: int test_ret = 0;
38005:
38006: #if defined(LIBXML_UNICODE_ENABLED)
38007: int mem_base;
38008: int ret_val;
38009: int code; /* UCS code point */
38010: int n_code;
38011:
38012: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38013: mem_base = xmlMemBlocks();
38014: code = gen_int(n_code, 0);
38015:
38016: ret_val = xmlUCSIsCatCs(code);
38017: desret_int(ret_val);
38018: call_tests++;
38019: des_int(n_code, code, 0);
38020: xmlResetLastError();
38021: if (mem_base != xmlMemBlocks()) {
38022: printf("Leak of %d blocks found in xmlUCSIsCatCs",
38023: xmlMemBlocks() - mem_base);
38024: test_ret++;
38025: printf(" %d", n_code);
38026: printf("\n");
38027: }
38028: }
38029: function_tests++;
38030: #endif
38031:
38032: return(test_ret);
38033: }
38034:
38035:
38036: static int
38037: test_xmlUCSIsCatL(void) {
38038: int test_ret = 0;
38039:
38040: #if defined(LIBXML_UNICODE_ENABLED)
38041: int mem_base;
38042: int ret_val;
38043: int code; /* UCS code point */
38044: int n_code;
38045:
38046: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38047: mem_base = xmlMemBlocks();
38048: code = gen_int(n_code, 0);
38049:
38050: ret_val = xmlUCSIsCatL(code);
38051: desret_int(ret_val);
38052: call_tests++;
38053: des_int(n_code, code, 0);
38054: xmlResetLastError();
38055: if (mem_base != xmlMemBlocks()) {
38056: printf("Leak of %d blocks found in xmlUCSIsCatL",
38057: xmlMemBlocks() - mem_base);
38058: test_ret++;
38059: printf(" %d", n_code);
38060: printf("\n");
38061: }
38062: }
38063: function_tests++;
38064: #endif
38065:
38066: return(test_ret);
38067: }
38068:
38069:
38070: static int
38071: test_xmlUCSIsCatLl(void) {
38072: int test_ret = 0;
38073:
38074: #if defined(LIBXML_UNICODE_ENABLED)
38075: int mem_base;
38076: int ret_val;
38077: int code; /* UCS code point */
38078: int n_code;
38079:
38080: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38081: mem_base = xmlMemBlocks();
38082: code = gen_int(n_code, 0);
38083:
38084: ret_val = xmlUCSIsCatLl(code);
38085: desret_int(ret_val);
38086: call_tests++;
38087: des_int(n_code, code, 0);
38088: xmlResetLastError();
38089: if (mem_base != xmlMemBlocks()) {
38090: printf("Leak of %d blocks found in xmlUCSIsCatLl",
38091: xmlMemBlocks() - mem_base);
38092: test_ret++;
38093: printf(" %d", n_code);
38094: printf("\n");
38095: }
38096: }
38097: function_tests++;
38098: #endif
38099:
38100: return(test_ret);
38101: }
38102:
38103:
38104: static int
38105: test_xmlUCSIsCatLm(void) {
38106: int test_ret = 0;
38107:
38108: #if defined(LIBXML_UNICODE_ENABLED)
38109: int mem_base;
38110: int ret_val;
38111: int code; /* UCS code point */
38112: int n_code;
38113:
38114: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38115: mem_base = xmlMemBlocks();
38116: code = gen_int(n_code, 0);
38117:
38118: ret_val = xmlUCSIsCatLm(code);
38119: desret_int(ret_val);
38120: call_tests++;
38121: des_int(n_code, code, 0);
38122: xmlResetLastError();
38123: if (mem_base != xmlMemBlocks()) {
38124: printf("Leak of %d blocks found in xmlUCSIsCatLm",
38125: xmlMemBlocks() - mem_base);
38126: test_ret++;
38127: printf(" %d", n_code);
38128: printf("\n");
38129: }
38130: }
38131: function_tests++;
38132: #endif
38133:
38134: return(test_ret);
38135: }
38136:
38137:
38138: static int
38139: test_xmlUCSIsCatLo(void) {
38140: int test_ret = 0;
38141:
38142: #if defined(LIBXML_UNICODE_ENABLED)
38143: int mem_base;
38144: int ret_val;
38145: int code; /* UCS code point */
38146: int n_code;
38147:
38148: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38149: mem_base = xmlMemBlocks();
38150: code = gen_int(n_code, 0);
38151:
38152: ret_val = xmlUCSIsCatLo(code);
38153: desret_int(ret_val);
38154: call_tests++;
38155: des_int(n_code, code, 0);
38156: xmlResetLastError();
38157: if (mem_base != xmlMemBlocks()) {
38158: printf("Leak of %d blocks found in xmlUCSIsCatLo",
38159: xmlMemBlocks() - mem_base);
38160: test_ret++;
38161: printf(" %d", n_code);
38162: printf("\n");
38163: }
38164: }
38165: function_tests++;
38166: #endif
38167:
38168: return(test_ret);
38169: }
38170:
38171:
38172: static int
38173: test_xmlUCSIsCatLt(void) {
38174: int test_ret = 0;
38175:
38176: #if defined(LIBXML_UNICODE_ENABLED)
38177: int mem_base;
38178: int ret_val;
38179: int code; /* UCS code point */
38180: int n_code;
38181:
38182: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38183: mem_base = xmlMemBlocks();
38184: code = gen_int(n_code, 0);
38185:
38186: ret_val = xmlUCSIsCatLt(code);
38187: desret_int(ret_val);
38188: call_tests++;
38189: des_int(n_code, code, 0);
38190: xmlResetLastError();
38191: if (mem_base != xmlMemBlocks()) {
38192: printf("Leak of %d blocks found in xmlUCSIsCatLt",
38193: xmlMemBlocks() - mem_base);
38194: test_ret++;
38195: printf(" %d", n_code);
38196: printf("\n");
38197: }
38198: }
38199: function_tests++;
38200: #endif
38201:
38202: return(test_ret);
38203: }
38204:
38205:
38206: static int
38207: test_xmlUCSIsCatLu(void) {
38208: int test_ret = 0;
38209:
38210: #if defined(LIBXML_UNICODE_ENABLED)
38211: int mem_base;
38212: int ret_val;
38213: int code; /* UCS code point */
38214: int n_code;
38215:
38216: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38217: mem_base = xmlMemBlocks();
38218: code = gen_int(n_code, 0);
38219:
38220: ret_val = xmlUCSIsCatLu(code);
38221: desret_int(ret_val);
38222: call_tests++;
38223: des_int(n_code, code, 0);
38224: xmlResetLastError();
38225: if (mem_base != xmlMemBlocks()) {
38226: printf("Leak of %d blocks found in xmlUCSIsCatLu",
38227: xmlMemBlocks() - mem_base);
38228: test_ret++;
38229: printf(" %d", n_code);
38230: printf("\n");
38231: }
38232: }
38233: function_tests++;
38234: #endif
38235:
38236: return(test_ret);
38237: }
38238:
38239:
38240: static int
38241: test_xmlUCSIsCatM(void) {
38242: int test_ret = 0;
38243:
38244: #if defined(LIBXML_UNICODE_ENABLED)
38245: int mem_base;
38246: int ret_val;
38247: int code; /* UCS code point */
38248: int n_code;
38249:
38250: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38251: mem_base = xmlMemBlocks();
38252: code = gen_int(n_code, 0);
38253:
38254: ret_val = xmlUCSIsCatM(code);
38255: desret_int(ret_val);
38256: call_tests++;
38257: des_int(n_code, code, 0);
38258: xmlResetLastError();
38259: if (mem_base != xmlMemBlocks()) {
38260: printf("Leak of %d blocks found in xmlUCSIsCatM",
38261: xmlMemBlocks() - mem_base);
38262: test_ret++;
38263: printf(" %d", n_code);
38264: printf("\n");
38265: }
38266: }
38267: function_tests++;
38268: #endif
38269:
38270: return(test_ret);
38271: }
38272:
38273:
38274: static int
38275: test_xmlUCSIsCatMc(void) {
38276: int test_ret = 0;
38277:
38278: #if defined(LIBXML_UNICODE_ENABLED)
38279: int mem_base;
38280: int ret_val;
38281: int code; /* UCS code point */
38282: int n_code;
38283:
38284: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38285: mem_base = xmlMemBlocks();
38286: code = gen_int(n_code, 0);
38287:
38288: ret_val = xmlUCSIsCatMc(code);
38289: desret_int(ret_val);
38290: call_tests++;
38291: des_int(n_code, code, 0);
38292: xmlResetLastError();
38293: if (mem_base != xmlMemBlocks()) {
38294: printf("Leak of %d blocks found in xmlUCSIsCatMc",
38295: xmlMemBlocks() - mem_base);
38296: test_ret++;
38297: printf(" %d", n_code);
38298: printf("\n");
38299: }
38300: }
38301: function_tests++;
38302: #endif
38303:
38304: return(test_ret);
38305: }
38306:
38307:
38308: static int
38309: test_xmlUCSIsCatMe(void) {
38310: int test_ret = 0;
38311:
38312: #if defined(LIBXML_UNICODE_ENABLED)
38313: int mem_base;
38314: int ret_val;
38315: int code; /* UCS code point */
38316: int n_code;
38317:
38318: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38319: mem_base = xmlMemBlocks();
38320: code = gen_int(n_code, 0);
38321:
38322: ret_val = xmlUCSIsCatMe(code);
38323: desret_int(ret_val);
38324: call_tests++;
38325: des_int(n_code, code, 0);
38326: xmlResetLastError();
38327: if (mem_base != xmlMemBlocks()) {
38328: printf("Leak of %d blocks found in xmlUCSIsCatMe",
38329: xmlMemBlocks() - mem_base);
38330: test_ret++;
38331: printf(" %d", n_code);
38332: printf("\n");
38333: }
38334: }
38335: function_tests++;
38336: #endif
38337:
38338: return(test_ret);
38339: }
38340:
38341:
38342: static int
38343: test_xmlUCSIsCatMn(void) {
38344: int test_ret = 0;
38345:
38346: #if defined(LIBXML_UNICODE_ENABLED)
38347: int mem_base;
38348: int ret_val;
38349: int code; /* UCS code point */
38350: int n_code;
38351:
38352: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38353: mem_base = xmlMemBlocks();
38354: code = gen_int(n_code, 0);
38355:
38356: ret_val = xmlUCSIsCatMn(code);
38357: desret_int(ret_val);
38358: call_tests++;
38359: des_int(n_code, code, 0);
38360: xmlResetLastError();
38361: if (mem_base != xmlMemBlocks()) {
38362: printf("Leak of %d blocks found in xmlUCSIsCatMn",
38363: xmlMemBlocks() - mem_base);
38364: test_ret++;
38365: printf(" %d", n_code);
38366: printf("\n");
38367: }
38368: }
38369: function_tests++;
38370: #endif
38371:
38372: return(test_ret);
38373: }
38374:
38375:
38376: static int
38377: test_xmlUCSIsCatN(void) {
38378: int test_ret = 0;
38379:
38380: #if defined(LIBXML_UNICODE_ENABLED)
38381: int mem_base;
38382: int ret_val;
38383: int code; /* UCS code point */
38384: int n_code;
38385:
38386: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38387: mem_base = xmlMemBlocks();
38388: code = gen_int(n_code, 0);
38389:
38390: ret_val = xmlUCSIsCatN(code);
38391: desret_int(ret_val);
38392: call_tests++;
38393: des_int(n_code, code, 0);
38394: xmlResetLastError();
38395: if (mem_base != xmlMemBlocks()) {
38396: printf("Leak of %d blocks found in xmlUCSIsCatN",
38397: xmlMemBlocks() - mem_base);
38398: test_ret++;
38399: printf(" %d", n_code);
38400: printf("\n");
38401: }
38402: }
38403: function_tests++;
38404: #endif
38405:
38406: return(test_ret);
38407: }
38408:
38409:
38410: static int
38411: test_xmlUCSIsCatNd(void) {
38412: int test_ret = 0;
38413:
38414: #if defined(LIBXML_UNICODE_ENABLED)
38415: int mem_base;
38416: int ret_val;
38417: int code; /* UCS code point */
38418: int n_code;
38419:
38420: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38421: mem_base = xmlMemBlocks();
38422: code = gen_int(n_code, 0);
38423:
38424: ret_val = xmlUCSIsCatNd(code);
38425: desret_int(ret_val);
38426: call_tests++;
38427: des_int(n_code, code, 0);
38428: xmlResetLastError();
38429: if (mem_base != xmlMemBlocks()) {
38430: printf("Leak of %d blocks found in xmlUCSIsCatNd",
38431: xmlMemBlocks() - mem_base);
38432: test_ret++;
38433: printf(" %d", n_code);
38434: printf("\n");
38435: }
38436: }
38437: function_tests++;
38438: #endif
38439:
38440: return(test_ret);
38441: }
38442:
38443:
38444: static int
38445: test_xmlUCSIsCatNl(void) {
38446: int test_ret = 0;
38447:
38448: #if defined(LIBXML_UNICODE_ENABLED)
38449: int mem_base;
38450: int ret_val;
38451: int code; /* UCS code point */
38452: int n_code;
38453:
38454: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38455: mem_base = xmlMemBlocks();
38456: code = gen_int(n_code, 0);
38457:
38458: ret_val = xmlUCSIsCatNl(code);
38459: desret_int(ret_val);
38460: call_tests++;
38461: des_int(n_code, code, 0);
38462: xmlResetLastError();
38463: if (mem_base != xmlMemBlocks()) {
38464: printf("Leak of %d blocks found in xmlUCSIsCatNl",
38465: xmlMemBlocks() - mem_base);
38466: test_ret++;
38467: printf(" %d", n_code);
38468: printf("\n");
38469: }
38470: }
38471: function_tests++;
38472: #endif
38473:
38474: return(test_ret);
38475: }
38476:
38477:
38478: static int
38479: test_xmlUCSIsCatNo(void) {
38480: int test_ret = 0;
38481:
38482: #if defined(LIBXML_UNICODE_ENABLED)
38483: int mem_base;
38484: int ret_val;
38485: int code; /* UCS code point */
38486: int n_code;
38487:
38488: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38489: mem_base = xmlMemBlocks();
38490: code = gen_int(n_code, 0);
38491:
38492: ret_val = xmlUCSIsCatNo(code);
38493: desret_int(ret_val);
38494: call_tests++;
38495: des_int(n_code, code, 0);
38496: xmlResetLastError();
38497: if (mem_base != xmlMemBlocks()) {
38498: printf("Leak of %d blocks found in xmlUCSIsCatNo",
38499: xmlMemBlocks() - mem_base);
38500: test_ret++;
38501: printf(" %d", n_code);
38502: printf("\n");
38503: }
38504: }
38505: function_tests++;
38506: #endif
38507:
38508: return(test_ret);
38509: }
38510:
38511:
38512: static int
38513: test_xmlUCSIsCatP(void) {
38514: int test_ret = 0;
38515:
38516: #if defined(LIBXML_UNICODE_ENABLED)
38517: int mem_base;
38518: int ret_val;
38519: int code; /* UCS code point */
38520: int n_code;
38521:
38522: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38523: mem_base = xmlMemBlocks();
38524: code = gen_int(n_code, 0);
38525:
38526: ret_val = xmlUCSIsCatP(code);
38527: desret_int(ret_val);
38528: call_tests++;
38529: des_int(n_code, code, 0);
38530: xmlResetLastError();
38531: if (mem_base != xmlMemBlocks()) {
38532: printf("Leak of %d blocks found in xmlUCSIsCatP",
38533: xmlMemBlocks() - mem_base);
38534: test_ret++;
38535: printf(" %d", n_code);
38536: printf("\n");
38537: }
38538: }
38539: function_tests++;
38540: #endif
38541:
38542: return(test_ret);
38543: }
38544:
38545:
38546: static int
38547: test_xmlUCSIsCatPc(void) {
38548: int test_ret = 0;
38549:
38550: #if defined(LIBXML_UNICODE_ENABLED)
38551: int mem_base;
38552: int ret_val;
38553: int code; /* UCS code point */
38554: int n_code;
38555:
38556: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38557: mem_base = xmlMemBlocks();
38558: code = gen_int(n_code, 0);
38559:
38560: ret_val = xmlUCSIsCatPc(code);
38561: desret_int(ret_val);
38562: call_tests++;
38563: des_int(n_code, code, 0);
38564: xmlResetLastError();
38565: if (mem_base != xmlMemBlocks()) {
38566: printf("Leak of %d blocks found in xmlUCSIsCatPc",
38567: xmlMemBlocks() - mem_base);
38568: test_ret++;
38569: printf(" %d", n_code);
38570: printf("\n");
38571: }
38572: }
38573: function_tests++;
38574: #endif
38575:
38576: return(test_ret);
38577: }
38578:
38579:
38580: static int
38581: test_xmlUCSIsCatPd(void) {
38582: int test_ret = 0;
38583:
38584: #if defined(LIBXML_UNICODE_ENABLED)
38585: int mem_base;
38586: int ret_val;
38587: int code; /* UCS code point */
38588: int n_code;
38589:
38590: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38591: mem_base = xmlMemBlocks();
38592: code = gen_int(n_code, 0);
38593:
38594: ret_val = xmlUCSIsCatPd(code);
38595: desret_int(ret_val);
38596: call_tests++;
38597: des_int(n_code, code, 0);
38598: xmlResetLastError();
38599: if (mem_base != xmlMemBlocks()) {
38600: printf("Leak of %d blocks found in xmlUCSIsCatPd",
38601: xmlMemBlocks() - mem_base);
38602: test_ret++;
38603: printf(" %d", n_code);
38604: printf("\n");
38605: }
38606: }
38607: function_tests++;
38608: #endif
38609:
38610: return(test_ret);
38611: }
38612:
38613:
38614: static int
38615: test_xmlUCSIsCatPe(void) {
38616: int test_ret = 0;
38617:
38618: #if defined(LIBXML_UNICODE_ENABLED)
38619: int mem_base;
38620: int ret_val;
38621: int code; /* UCS code point */
38622: int n_code;
38623:
38624: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38625: mem_base = xmlMemBlocks();
38626: code = gen_int(n_code, 0);
38627:
38628: ret_val = xmlUCSIsCatPe(code);
38629: desret_int(ret_val);
38630: call_tests++;
38631: des_int(n_code, code, 0);
38632: xmlResetLastError();
38633: if (mem_base != xmlMemBlocks()) {
38634: printf("Leak of %d blocks found in xmlUCSIsCatPe",
38635: xmlMemBlocks() - mem_base);
38636: test_ret++;
38637: printf(" %d", n_code);
38638: printf("\n");
38639: }
38640: }
38641: function_tests++;
38642: #endif
38643:
38644: return(test_ret);
38645: }
38646:
38647:
38648: static int
38649: test_xmlUCSIsCatPf(void) {
38650: int test_ret = 0;
38651:
38652: #if defined(LIBXML_UNICODE_ENABLED)
38653: int mem_base;
38654: int ret_val;
38655: int code; /* UCS code point */
38656: int n_code;
38657:
38658: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38659: mem_base = xmlMemBlocks();
38660: code = gen_int(n_code, 0);
38661:
38662: ret_val = xmlUCSIsCatPf(code);
38663: desret_int(ret_val);
38664: call_tests++;
38665: des_int(n_code, code, 0);
38666: xmlResetLastError();
38667: if (mem_base != xmlMemBlocks()) {
38668: printf("Leak of %d blocks found in xmlUCSIsCatPf",
38669: xmlMemBlocks() - mem_base);
38670: test_ret++;
38671: printf(" %d", n_code);
38672: printf("\n");
38673: }
38674: }
38675: function_tests++;
38676: #endif
38677:
38678: return(test_ret);
38679: }
38680:
38681:
38682: static int
38683: test_xmlUCSIsCatPi(void) {
38684: int test_ret = 0;
38685:
38686: #if defined(LIBXML_UNICODE_ENABLED)
38687: int mem_base;
38688: int ret_val;
38689: int code; /* UCS code point */
38690: int n_code;
38691:
38692: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38693: mem_base = xmlMemBlocks();
38694: code = gen_int(n_code, 0);
38695:
38696: ret_val = xmlUCSIsCatPi(code);
38697: desret_int(ret_val);
38698: call_tests++;
38699: des_int(n_code, code, 0);
38700: xmlResetLastError();
38701: if (mem_base != xmlMemBlocks()) {
38702: printf("Leak of %d blocks found in xmlUCSIsCatPi",
38703: xmlMemBlocks() - mem_base);
38704: test_ret++;
38705: printf(" %d", n_code);
38706: printf("\n");
38707: }
38708: }
38709: function_tests++;
38710: #endif
38711:
38712: return(test_ret);
38713: }
38714:
38715:
38716: static int
38717: test_xmlUCSIsCatPo(void) {
38718: int test_ret = 0;
38719:
38720: #if defined(LIBXML_UNICODE_ENABLED)
38721: int mem_base;
38722: int ret_val;
38723: int code; /* UCS code point */
38724: int n_code;
38725:
38726: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38727: mem_base = xmlMemBlocks();
38728: code = gen_int(n_code, 0);
38729:
38730: ret_val = xmlUCSIsCatPo(code);
38731: desret_int(ret_val);
38732: call_tests++;
38733: des_int(n_code, code, 0);
38734: xmlResetLastError();
38735: if (mem_base != xmlMemBlocks()) {
38736: printf("Leak of %d blocks found in xmlUCSIsCatPo",
38737: xmlMemBlocks() - mem_base);
38738: test_ret++;
38739: printf(" %d", n_code);
38740: printf("\n");
38741: }
38742: }
38743: function_tests++;
38744: #endif
38745:
38746: return(test_ret);
38747: }
38748:
38749:
38750: static int
38751: test_xmlUCSIsCatPs(void) {
38752: int test_ret = 0;
38753:
38754: #if defined(LIBXML_UNICODE_ENABLED)
38755: int mem_base;
38756: int ret_val;
38757: int code; /* UCS code point */
38758: int n_code;
38759:
38760: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38761: mem_base = xmlMemBlocks();
38762: code = gen_int(n_code, 0);
38763:
38764: ret_val = xmlUCSIsCatPs(code);
38765: desret_int(ret_val);
38766: call_tests++;
38767: des_int(n_code, code, 0);
38768: xmlResetLastError();
38769: if (mem_base != xmlMemBlocks()) {
38770: printf("Leak of %d blocks found in xmlUCSIsCatPs",
38771: xmlMemBlocks() - mem_base);
38772: test_ret++;
38773: printf(" %d", n_code);
38774: printf("\n");
38775: }
38776: }
38777: function_tests++;
38778: #endif
38779:
38780: return(test_ret);
38781: }
38782:
38783:
38784: static int
38785: test_xmlUCSIsCatS(void) {
38786: int test_ret = 0;
38787:
38788: #if defined(LIBXML_UNICODE_ENABLED)
38789: int mem_base;
38790: int ret_val;
38791: int code; /* UCS code point */
38792: int n_code;
38793:
38794: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38795: mem_base = xmlMemBlocks();
38796: code = gen_int(n_code, 0);
38797:
38798: ret_val = xmlUCSIsCatS(code);
38799: desret_int(ret_val);
38800: call_tests++;
38801: des_int(n_code, code, 0);
38802: xmlResetLastError();
38803: if (mem_base != xmlMemBlocks()) {
38804: printf("Leak of %d blocks found in xmlUCSIsCatS",
38805: xmlMemBlocks() - mem_base);
38806: test_ret++;
38807: printf(" %d", n_code);
38808: printf("\n");
38809: }
38810: }
38811: function_tests++;
38812: #endif
38813:
38814: return(test_ret);
38815: }
38816:
38817:
38818: static int
38819: test_xmlUCSIsCatSc(void) {
38820: int test_ret = 0;
38821:
38822: #if defined(LIBXML_UNICODE_ENABLED)
38823: int mem_base;
38824: int ret_val;
38825: int code; /* UCS code point */
38826: int n_code;
38827:
38828: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38829: mem_base = xmlMemBlocks();
38830: code = gen_int(n_code, 0);
38831:
38832: ret_val = xmlUCSIsCatSc(code);
38833: desret_int(ret_val);
38834: call_tests++;
38835: des_int(n_code, code, 0);
38836: xmlResetLastError();
38837: if (mem_base != xmlMemBlocks()) {
38838: printf("Leak of %d blocks found in xmlUCSIsCatSc",
38839: xmlMemBlocks() - mem_base);
38840: test_ret++;
38841: printf(" %d", n_code);
38842: printf("\n");
38843: }
38844: }
38845: function_tests++;
38846: #endif
38847:
38848: return(test_ret);
38849: }
38850:
38851:
38852: static int
38853: test_xmlUCSIsCatSk(void) {
38854: int test_ret = 0;
38855:
38856: #if defined(LIBXML_UNICODE_ENABLED)
38857: int mem_base;
38858: int ret_val;
38859: int code; /* UCS code point */
38860: int n_code;
38861:
38862: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38863: mem_base = xmlMemBlocks();
38864: code = gen_int(n_code, 0);
38865:
38866: ret_val = xmlUCSIsCatSk(code);
38867: desret_int(ret_val);
38868: call_tests++;
38869: des_int(n_code, code, 0);
38870: xmlResetLastError();
38871: if (mem_base != xmlMemBlocks()) {
38872: printf("Leak of %d blocks found in xmlUCSIsCatSk",
38873: xmlMemBlocks() - mem_base);
38874: test_ret++;
38875: printf(" %d", n_code);
38876: printf("\n");
38877: }
38878: }
38879: function_tests++;
38880: #endif
38881:
38882: return(test_ret);
38883: }
38884:
38885:
38886: static int
38887: test_xmlUCSIsCatSm(void) {
38888: int test_ret = 0;
38889:
38890: #if defined(LIBXML_UNICODE_ENABLED)
38891: int mem_base;
38892: int ret_val;
38893: int code; /* UCS code point */
38894: int n_code;
38895:
38896: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38897: mem_base = xmlMemBlocks();
38898: code = gen_int(n_code, 0);
38899:
38900: ret_val = xmlUCSIsCatSm(code);
38901: desret_int(ret_val);
38902: call_tests++;
38903: des_int(n_code, code, 0);
38904: xmlResetLastError();
38905: if (mem_base != xmlMemBlocks()) {
38906: printf("Leak of %d blocks found in xmlUCSIsCatSm",
38907: xmlMemBlocks() - mem_base);
38908: test_ret++;
38909: printf(" %d", n_code);
38910: printf("\n");
38911: }
38912: }
38913: function_tests++;
38914: #endif
38915:
38916: return(test_ret);
38917: }
38918:
38919:
38920: static int
38921: test_xmlUCSIsCatSo(void) {
38922: int test_ret = 0;
38923:
38924: #if defined(LIBXML_UNICODE_ENABLED)
38925: int mem_base;
38926: int ret_val;
38927: int code; /* UCS code point */
38928: int n_code;
38929:
38930: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38931: mem_base = xmlMemBlocks();
38932: code = gen_int(n_code, 0);
38933:
38934: ret_val = xmlUCSIsCatSo(code);
38935: desret_int(ret_val);
38936: call_tests++;
38937: des_int(n_code, code, 0);
38938: xmlResetLastError();
38939: if (mem_base != xmlMemBlocks()) {
38940: printf("Leak of %d blocks found in xmlUCSIsCatSo",
38941: xmlMemBlocks() - mem_base);
38942: test_ret++;
38943: printf(" %d", n_code);
38944: printf("\n");
38945: }
38946: }
38947: function_tests++;
38948: #endif
38949:
38950: return(test_ret);
38951: }
38952:
38953:
38954: static int
38955: test_xmlUCSIsCatZ(void) {
38956: int test_ret = 0;
38957:
38958: #if defined(LIBXML_UNICODE_ENABLED)
38959: int mem_base;
38960: int ret_val;
38961: int code; /* UCS code point */
38962: int n_code;
38963:
38964: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38965: mem_base = xmlMemBlocks();
38966: code = gen_int(n_code, 0);
38967:
38968: ret_val = xmlUCSIsCatZ(code);
38969: desret_int(ret_val);
38970: call_tests++;
38971: des_int(n_code, code, 0);
38972: xmlResetLastError();
38973: if (mem_base != xmlMemBlocks()) {
38974: printf("Leak of %d blocks found in xmlUCSIsCatZ",
38975: xmlMemBlocks() - mem_base);
38976: test_ret++;
38977: printf(" %d", n_code);
38978: printf("\n");
38979: }
38980: }
38981: function_tests++;
38982: #endif
38983:
38984: return(test_ret);
38985: }
38986:
38987:
38988: static int
38989: test_xmlUCSIsCatZl(void) {
38990: int test_ret = 0;
38991:
38992: #if defined(LIBXML_UNICODE_ENABLED)
38993: int mem_base;
38994: int ret_val;
38995: int code; /* UCS code point */
38996: int n_code;
38997:
38998: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38999: mem_base = xmlMemBlocks();
39000: code = gen_int(n_code, 0);
39001:
39002: ret_val = xmlUCSIsCatZl(code);
39003: desret_int(ret_val);
39004: call_tests++;
39005: des_int(n_code, code, 0);
39006: xmlResetLastError();
39007: if (mem_base != xmlMemBlocks()) {
39008: printf("Leak of %d blocks found in xmlUCSIsCatZl",
39009: xmlMemBlocks() - mem_base);
39010: test_ret++;
39011: printf(" %d", n_code);
39012: printf("\n");
39013: }
39014: }
39015: function_tests++;
39016: #endif
39017:
39018: return(test_ret);
39019: }
39020:
39021:
39022: static int
39023: test_xmlUCSIsCatZp(void) {
39024: int test_ret = 0;
39025:
39026: #if defined(LIBXML_UNICODE_ENABLED)
39027: int mem_base;
39028: int ret_val;
39029: int code; /* UCS code point */
39030: int n_code;
39031:
39032: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39033: mem_base = xmlMemBlocks();
39034: code = gen_int(n_code, 0);
39035:
39036: ret_val = xmlUCSIsCatZp(code);
39037: desret_int(ret_val);
39038: call_tests++;
39039: des_int(n_code, code, 0);
39040: xmlResetLastError();
39041: if (mem_base != xmlMemBlocks()) {
39042: printf("Leak of %d blocks found in xmlUCSIsCatZp",
39043: xmlMemBlocks() - mem_base);
39044: test_ret++;
39045: printf(" %d", n_code);
39046: printf("\n");
39047: }
39048: }
39049: function_tests++;
39050: #endif
39051:
39052: return(test_ret);
39053: }
39054:
39055:
39056: static int
39057: test_xmlUCSIsCatZs(void) {
39058: int test_ret = 0;
39059:
39060: #if defined(LIBXML_UNICODE_ENABLED)
39061: int mem_base;
39062: int ret_val;
39063: int code; /* UCS code point */
39064: int n_code;
39065:
39066: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39067: mem_base = xmlMemBlocks();
39068: code = gen_int(n_code, 0);
39069:
39070: ret_val = xmlUCSIsCatZs(code);
39071: desret_int(ret_val);
39072: call_tests++;
39073: des_int(n_code, code, 0);
39074: xmlResetLastError();
39075: if (mem_base != xmlMemBlocks()) {
39076: printf("Leak of %d blocks found in xmlUCSIsCatZs",
39077: xmlMemBlocks() - mem_base);
39078: test_ret++;
39079: printf(" %d", n_code);
39080: printf("\n");
39081: }
39082: }
39083: function_tests++;
39084: #endif
39085:
39086: return(test_ret);
39087: }
39088:
39089:
39090: static int
39091: test_xmlUCSIsCherokee(void) {
39092: int test_ret = 0;
39093:
39094: #if defined(LIBXML_UNICODE_ENABLED)
39095: int mem_base;
39096: int ret_val;
39097: int code; /* UCS code point */
39098: int n_code;
39099:
39100: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39101: mem_base = xmlMemBlocks();
39102: code = gen_int(n_code, 0);
39103:
39104: ret_val = xmlUCSIsCherokee(code);
39105: desret_int(ret_val);
39106: call_tests++;
39107: des_int(n_code, code, 0);
39108: xmlResetLastError();
39109: if (mem_base != xmlMemBlocks()) {
39110: printf("Leak of %d blocks found in xmlUCSIsCherokee",
39111: xmlMemBlocks() - mem_base);
39112: test_ret++;
39113: printf(" %d", n_code);
39114: printf("\n");
39115: }
39116: }
39117: function_tests++;
39118: #endif
39119:
39120: return(test_ret);
39121: }
39122:
39123:
39124: static int
39125: test_xmlUCSIsCombiningDiacriticalMarks(void) {
39126: int test_ret = 0;
39127:
39128: #if defined(LIBXML_UNICODE_ENABLED)
39129: int mem_base;
39130: int ret_val;
39131: int code; /* UCS code point */
39132: int n_code;
39133:
39134: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39135: mem_base = xmlMemBlocks();
39136: code = gen_int(n_code, 0);
39137:
39138: ret_val = xmlUCSIsCombiningDiacriticalMarks(code);
39139: desret_int(ret_val);
39140: call_tests++;
39141: des_int(n_code, code, 0);
39142: xmlResetLastError();
39143: if (mem_base != xmlMemBlocks()) {
39144: printf("Leak of %d blocks found in xmlUCSIsCombiningDiacriticalMarks",
39145: xmlMemBlocks() - mem_base);
39146: test_ret++;
39147: printf(" %d", n_code);
39148: printf("\n");
39149: }
39150: }
39151: function_tests++;
39152: #endif
39153:
39154: return(test_ret);
39155: }
39156:
39157:
39158: static int
39159: test_xmlUCSIsCombiningDiacriticalMarksforSymbols(void) {
39160: int test_ret = 0;
39161:
39162: #if defined(LIBXML_UNICODE_ENABLED)
39163: int mem_base;
39164: int ret_val;
39165: int code; /* UCS code point */
39166: int n_code;
39167:
39168: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39169: mem_base = xmlMemBlocks();
39170: code = gen_int(n_code, 0);
39171:
39172: ret_val = xmlUCSIsCombiningDiacriticalMarksforSymbols(code);
39173: desret_int(ret_val);
39174: call_tests++;
39175: des_int(n_code, code, 0);
39176: xmlResetLastError();
39177: if (mem_base != xmlMemBlocks()) {
39178: printf("Leak of %d blocks found in xmlUCSIsCombiningDiacriticalMarksforSymbols",
39179: xmlMemBlocks() - mem_base);
39180: test_ret++;
39181: printf(" %d", n_code);
39182: printf("\n");
39183: }
39184: }
39185: function_tests++;
39186: #endif
39187:
39188: return(test_ret);
39189: }
39190:
39191:
39192: static int
39193: test_xmlUCSIsCombiningHalfMarks(void) {
39194: int test_ret = 0;
39195:
39196: #if defined(LIBXML_UNICODE_ENABLED)
39197: int mem_base;
39198: int ret_val;
39199: int code; /* UCS code point */
39200: int n_code;
39201:
39202: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39203: mem_base = xmlMemBlocks();
39204: code = gen_int(n_code, 0);
39205:
39206: ret_val = xmlUCSIsCombiningHalfMarks(code);
39207: desret_int(ret_val);
39208: call_tests++;
39209: des_int(n_code, code, 0);
39210: xmlResetLastError();
39211: if (mem_base != xmlMemBlocks()) {
39212: printf("Leak of %d blocks found in xmlUCSIsCombiningHalfMarks",
39213: xmlMemBlocks() - mem_base);
39214: test_ret++;
39215: printf(" %d", n_code);
39216: printf("\n");
39217: }
39218: }
39219: function_tests++;
39220: #endif
39221:
39222: return(test_ret);
39223: }
39224:
39225:
39226: static int
39227: test_xmlUCSIsCombiningMarksforSymbols(void) {
39228: int test_ret = 0;
39229:
39230: #if defined(LIBXML_UNICODE_ENABLED)
39231: int mem_base;
39232: int ret_val;
39233: int code; /* UCS code point */
39234: int n_code;
39235:
39236: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39237: mem_base = xmlMemBlocks();
39238: code = gen_int(n_code, 0);
39239:
39240: ret_val = xmlUCSIsCombiningMarksforSymbols(code);
39241: desret_int(ret_val);
39242: call_tests++;
39243: des_int(n_code, code, 0);
39244: xmlResetLastError();
39245: if (mem_base != xmlMemBlocks()) {
39246: printf("Leak of %d blocks found in xmlUCSIsCombiningMarksforSymbols",
39247: xmlMemBlocks() - mem_base);
39248: test_ret++;
39249: printf(" %d", n_code);
39250: printf("\n");
39251: }
39252: }
39253: function_tests++;
39254: #endif
39255:
39256: return(test_ret);
39257: }
39258:
39259:
39260: static int
39261: test_xmlUCSIsControlPictures(void) {
39262: int test_ret = 0;
39263:
39264: #if defined(LIBXML_UNICODE_ENABLED)
39265: int mem_base;
39266: int ret_val;
39267: int code; /* UCS code point */
39268: int n_code;
39269:
39270: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39271: mem_base = xmlMemBlocks();
39272: code = gen_int(n_code, 0);
39273:
39274: ret_val = xmlUCSIsControlPictures(code);
39275: desret_int(ret_val);
39276: call_tests++;
39277: des_int(n_code, code, 0);
39278: xmlResetLastError();
39279: if (mem_base != xmlMemBlocks()) {
39280: printf("Leak of %d blocks found in xmlUCSIsControlPictures",
39281: xmlMemBlocks() - mem_base);
39282: test_ret++;
39283: printf(" %d", n_code);
39284: printf("\n");
39285: }
39286: }
39287: function_tests++;
39288: #endif
39289:
39290: return(test_ret);
39291: }
39292:
39293:
39294: static int
39295: test_xmlUCSIsCurrencySymbols(void) {
39296: int test_ret = 0;
39297:
39298: #if defined(LIBXML_UNICODE_ENABLED)
39299: int mem_base;
39300: int ret_val;
39301: int code; /* UCS code point */
39302: int n_code;
39303:
39304: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39305: mem_base = xmlMemBlocks();
39306: code = gen_int(n_code, 0);
39307:
39308: ret_val = xmlUCSIsCurrencySymbols(code);
39309: desret_int(ret_val);
39310: call_tests++;
39311: des_int(n_code, code, 0);
39312: xmlResetLastError();
39313: if (mem_base != xmlMemBlocks()) {
39314: printf("Leak of %d blocks found in xmlUCSIsCurrencySymbols",
39315: xmlMemBlocks() - mem_base);
39316: test_ret++;
39317: printf(" %d", n_code);
39318: printf("\n");
39319: }
39320: }
39321: function_tests++;
39322: #endif
39323:
39324: return(test_ret);
39325: }
39326:
39327:
39328: static int
39329: test_xmlUCSIsCypriotSyllabary(void) {
39330: int test_ret = 0;
39331:
39332: #if defined(LIBXML_UNICODE_ENABLED)
39333: int mem_base;
39334: int ret_val;
39335: int code; /* UCS code point */
39336: int n_code;
39337:
39338: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39339: mem_base = xmlMemBlocks();
39340: code = gen_int(n_code, 0);
39341:
39342: ret_val = xmlUCSIsCypriotSyllabary(code);
39343: desret_int(ret_val);
39344: call_tests++;
39345: des_int(n_code, code, 0);
39346: xmlResetLastError();
39347: if (mem_base != xmlMemBlocks()) {
39348: printf("Leak of %d blocks found in xmlUCSIsCypriotSyllabary",
39349: xmlMemBlocks() - mem_base);
39350: test_ret++;
39351: printf(" %d", n_code);
39352: printf("\n");
39353: }
39354: }
39355: function_tests++;
39356: #endif
39357:
39358: return(test_ret);
39359: }
39360:
39361:
39362: static int
39363: test_xmlUCSIsCyrillic(void) {
39364: int test_ret = 0;
39365:
39366: #if defined(LIBXML_UNICODE_ENABLED)
39367: int mem_base;
39368: int ret_val;
39369: int code; /* UCS code point */
39370: int n_code;
39371:
39372: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39373: mem_base = xmlMemBlocks();
39374: code = gen_int(n_code, 0);
39375:
39376: ret_val = xmlUCSIsCyrillic(code);
39377: desret_int(ret_val);
39378: call_tests++;
39379: des_int(n_code, code, 0);
39380: xmlResetLastError();
39381: if (mem_base != xmlMemBlocks()) {
39382: printf("Leak of %d blocks found in xmlUCSIsCyrillic",
39383: xmlMemBlocks() - mem_base);
39384: test_ret++;
39385: printf(" %d", n_code);
39386: printf("\n");
39387: }
39388: }
39389: function_tests++;
39390: #endif
39391:
39392: return(test_ret);
39393: }
39394:
39395:
39396: static int
39397: test_xmlUCSIsCyrillicSupplement(void) {
39398: int test_ret = 0;
39399:
39400: #if defined(LIBXML_UNICODE_ENABLED)
39401: int mem_base;
39402: int ret_val;
39403: int code; /* UCS code point */
39404: int n_code;
39405:
39406: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39407: mem_base = xmlMemBlocks();
39408: code = gen_int(n_code, 0);
39409:
39410: ret_val = xmlUCSIsCyrillicSupplement(code);
39411: desret_int(ret_val);
39412: call_tests++;
39413: des_int(n_code, code, 0);
39414: xmlResetLastError();
39415: if (mem_base != xmlMemBlocks()) {
39416: printf("Leak of %d blocks found in xmlUCSIsCyrillicSupplement",
39417: xmlMemBlocks() - mem_base);
39418: test_ret++;
39419: printf(" %d", n_code);
39420: printf("\n");
39421: }
39422: }
39423: function_tests++;
39424: #endif
39425:
39426: return(test_ret);
39427: }
39428:
39429:
39430: static int
39431: test_xmlUCSIsDeseret(void) {
39432: int test_ret = 0;
39433:
39434: #if defined(LIBXML_UNICODE_ENABLED)
39435: int mem_base;
39436: int ret_val;
39437: int code; /* UCS code point */
39438: int n_code;
39439:
39440: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39441: mem_base = xmlMemBlocks();
39442: code = gen_int(n_code, 0);
39443:
39444: ret_val = xmlUCSIsDeseret(code);
39445: desret_int(ret_val);
39446: call_tests++;
39447: des_int(n_code, code, 0);
39448: xmlResetLastError();
39449: if (mem_base != xmlMemBlocks()) {
39450: printf("Leak of %d blocks found in xmlUCSIsDeseret",
39451: xmlMemBlocks() - mem_base);
39452: test_ret++;
39453: printf(" %d", n_code);
39454: printf("\n");
39455: }
39456: }
39457: function_tests++;
39458: #endif
39459:
39460: return(test_ret);
39461: }
39462:
39463:
39464: static int
39465: test_xmlUCSIsDevanagari(void) {
39466: int test_ret = 0;
39467:
39468: #if defined(LIBXML_UNICODE_ENABLED)
39469: int mem_base;
39470: int ret_val;
39471: int code; /* UCS code point */
39472: int n_code;
39473:
39474: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39475: mem_base = xmlMemBlocks();
39476: code = gen_int(n_code, 0);
39477:
39478: ret_val = xmlUCSIsDevanagari(code);
39479: desret_int(ret_val);
39480: call_tests++;
39481: des_int(n_code, code, 0);
39482: xmlResetLastError();
39483: if (mem_base != xmlMemBlocks()) {
39484: printf("Leak of %d blocks found in xmlUCSIsDevanagari",
39485: xmlMemBlocks() - mem_base);
39486: test_ret++;
39487: printf(" %d", n_code);
39488: printf("\n");
39489: }
39490: }
39491: function_tests++;
39492: #endif
39493:
39494: return(test_ret);
39495: }
39496:
39497:
39498: static int
39499: test_xmlUCSIsDingbats(void) {
39500: int test_ret = 0;
39501:
39502: #if defined(LIBXML_UNICODE_ENABLED)
39503: int mem_base;
39504: int ret_val;
39505: int code; /* UCS code point */
39506: int n_code;
39507:
39508: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39509: mem_base = xmlMemBlocks();
39510: code = gen_int(n_code, 0);
39511:
39512: ret_val = xmlUCSIsDingbats(code);
39513: desret_int(ret_val);
39514: call_tests++;
39515: des_int(n_code, code, 0);
39516: xmlResetLastError();
39517: if (mem_base != xmlMemBlocks()) {
39518: printf("Leak of %d blocks found in xmlUCSIsDingbats",
39519: xmlMemBlocks() - mem_base);
39520: test_ret++;
39521: printf(" %d", n_code);
39522: printf("\n");
39523: }
39524: }
39525: function_tests++;
39526: #endif
39527:
39528: return(test_ret);
39529: }
39530:
39531:
39532: static int
39533: test_xmlUCSIsEnclosedAlphanumerics(void) {
39534: int test_ret = 0;
39535:
39536: #if defined(LIBXML_UNICODE_ENABLED)
39537: int mem_base;
39538: int ret_val;
39539: int code; /* UCS code point */
39540: int n_code;
39541:
39542: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39543: mem_base = xmlMemBlocks();
39544: code = gen_int(n_code, 0);
39545:
39546: ret_val = xmlUCSIsEnclosedAlphanumerics(code);
39547: desret_int(ret_val);
39548: call_tests++;
39549: des_int(n_code, code, 0);
39550: xmlResetLastError();
39551: if (mem_base != xmlMemBlocks()) {
39552: printf("Leak of %d blocks found in xmlUCSIsEnclosedAlphanumerics",
39553: xmlMemBlocks() - mem_base);
39554: test_ret++;
39555: printf(" %d", n_code);
39556: printf("\n");
39557: }
39558: }
39559: function_tests++;
39560: #endif
39561:
39562: return(test_ret);
39563: }
39564:
39565:
39566: static int
39567: test_xmlUCSIsEnclosedCJKLettersandMonths(void) {
39568: int test_ret = 0;
39569:
39570: #if defined(LIBXML_UNICODE_ENABLED)
39571: int mem_base;
39572: int ret_val;
39573: int code; /* UCS code point */
39574: int n_code;
39575:
39576: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39577: mem_base = xmlMemBlocks();
39578: code = gen_int(n_code, 0);
39579:
39580: ret_val = xmlUCSIsEnclosedCJKLettersandMonths(code);
39581: desret_int(ret_val);
39582: call_tests++;
39583: des_int(n_code, code, 0);
39584: xmlResetLastError();
39585: if (mem_base != xmlMemBlocks()) {
39586: printf("Leak of %d blocks found in xmlUCSIsEnclosedCJKLettersandMonths",
39587: xmlMemBlocks() - mem_base);
39588: test_ret++;
39589: printf(" %d", n_code);
39590: printf("\n");
39591: }
39592: }
39593: function_tests++;
39594: #endif
39595:
39596: return(test_ret);
39597: }
39598:
39599:
39600: static int
39601: test_xmlUCSIsEthiopic(void) {
39602: int test_ret = 0;
39603:
39604: #if defined(LIBXML_UNICODE_ENABLED)
39605: int mem_base;
39606: int ret_val;
39607: int code; /* UCS code point */
39608: int n_code;
39609:
39610: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39611: mem_base = xmlMemBlocks();
39612: code = gen_int(n_code, 0);
39613:
39614: ret_val = xmlUCSIsEthiopic(code);
39615: desret_int(ret_val);
39616: call_tests++;
39617: des_int(n_code, code, 0);
39618: xmlResetLastError();
39619: if (mem_base != xmlMemBlocks()) {
39620: printf("Leak of %d blocks found in xmlUCSIsEthiopic",
39621: xmlMemBlocks() - mem_base);
39622: test_ret++;
39623: printf(" %d", n_code);
39624: printf("\n");
39625: }
39626: }
39627: function_tests++;
39628: #endif
39629:
39630: return(test_ret);
39631: }
39632:
39633:
39634: static int
39635: test_xmlUCSIsGeneralPunctuation(void) {
39636: int test_ret = 0;
39637:
39638: #if defined(LIBXML_UNICODE_ENABLED)
39639: int mem_base;
39640: int ret_val;
39641: int code; /* UCS code point */
39642: int n_code;
39643:
39644: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39645: mem_base = xmlMemBlocks();
39646: code = gen_int(n_code, 0);
39647:
39648: ret_val = xmlUCSIsGeneralPunctuation(code);
39649: desret_int(ret_val);
39650: call_tests++;
39651: des_int(n_code, code, 0);
39652: xmlResetLastError();
39653: if (mem_base != xmlMemBlocks()) {
39654: printf("Leak of %d blocks found in xmlUCSIsGeneralPunctuation",
39655: xmlMemBlocks() - mem_base);
39656: test_ret++;
39657: printf(" %d", n_code);
39658: printf("\n");
39659: }
39660: }
39661: function_tests++;
39662: #endif
39663:
39664: return(test_ret);
39665: }
39666:
39667:
39668: static int
39669: test_xmlUCSIsGeometricShapes(void) {
39670: int test_ret = 0;
39671:
39672: #if defined(LIBXML_UNICODE_ENABLED)
39673: int mem_base;
39674: int ret_val;
39675: int code; /* UCS code point */
39676: int n_code;
39677:
39678: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39679: mem_base = xmlMemBlocks();
39680: code = gen_int(n_code, 0);
39681:
39682: ret_val = xmlUCSIsGeometricShapes(code);
39683: desret_int(ret_val);
39684: call_tests++;
39685: des_int(n_code, code, 0);
39686: xmlResetLastError();
39687: if (mem_base != xmlMemBlocks()) {
39688: printf("Leak of %d blocks found in xmlUCSIsGeometricShapes",
39689: xmlMemBlocks() - mem_base);
39690: test_ret++;
39691: printf(" %d", n_code);
39692: printf("\n");
39693: }
39694: }
39695: function_tests++;
39696: #endif
39697:
39698: return(test_ret);
39699: }
39700:
39701:
39702: static int
39703: test_xmlUCSIsGeorgian(void) {
39704: int test_ret = 0;
39705:
39706: #if defined(LIBXML_UNICODE_ENABLED)
39707: int mem_base;
39708: int ret_val;
39709: int code; /* UCS code point */
39710: int n_code;
39711:
39712: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39713: mem_base = xmlMemBlocks();
39714: code = gen_int(n_code, 0);
39715:
39716: ret_val = xmlUCSIsGeorgian(code);
39717: desret_int(ret_val);
39718: call_tests++;
39719: des_int(n_code, code, 0);
39720: xmlResetLastError();
39721: if (mem_base != xmlMemBlocks()) {
39722: printf("Leak of %d blocks found in xmlUCSIsGeorgian",
39723: xmlMemBlocks() - mem_base);
39724: test_ret++;
39725: printf(" %d", n_code);
39726: printf("\n");
39727: }
39728: }
39729: function_tests++;
39730: #endif
39731:
39732: return(test_ret);
39733: }
39734:
39735:
39736: static int
39737: test_xmlUCSIsGothic(void) {
39738: int test_ret = 0;
39739:
39740: #if defined(LIBXML_UNICODE_ENABLED)
39741: int mem_base;
39742: int ret_val;
39743: int code; /* UCS code point */
39744: int n_code;
39745:
39746: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39747: mem_base = xmlMemBlocks();
39748: code = gen_int(n_code, 0);
39749:
39750: ret_val = xmlUCSIsGothic(code);
39751: desret_int(ret_val);
39752: call_tests++;
39753: des_int(n_code, code, 0);
39754: xmlResetLastError();
39755: if (mem_base != xmlMemBlocks()) {
39756: printf("Leak of %d blocks found in xmlUCSIsGothic",
39757: xmlMemBlocks() - mem_base);
39758: test_ret++;
39759: printf(" %d", n_code);
39760: printf("\n");
39761: }
39762: }
39763: function_tests++;
39764: #endif
39765:
39766: return(test_ret);
39767: }
39768:
39769:
39770: static int
39771: test_xmlUCSIsGreek(void) {
39772: int test_ret = 0;
39773:
39774: #if defined(LIBXML_UNICODE_ENABLED)
39775: int mem_base;
39776: int ret_val;
39777: int code; /* UCS code point */
39778: int n_code;
39779:
39780: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39781: mem_base = xmlMemBlocks();
39782: code = gen_int(n_code, 0);
39783:
39784: ret_val = xmlUCSIsGreek(code);
39785: desret_int(ret_val);
39786: call_tests++;
39787: des_int(n_code, code, 0);
39788: xmlResetLastError();
39789: if (mem_base != xmlMemBlocks()) {
39790: printf("Leak of %d blocks found in xmlUCSIsGreek",
39791: xmlMemBlocks() - mem_base);
39792: test_ret++;
39793: printf(" %d", n_code);
39794: printf("\n");
39795: }
39796: }
39797: function_tests++;
39798: #endif
39799:
39800: return(test_ret);
39801: }
39802:
39803:
39804: static int
39805: test_xmlUCSIsGreekExtended(void) {
39806: int test_ret = 0;
39807:
39808: #if defined(LIBXML_UNICODE_ENABLED)
39809: int mem_base;
39810: int ret_val;
39811: int code; /* UCS code point */
39812: int n_code;
39813:
39814: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39815: mem_base = xmlMemBlocks();
39816: code = gen_int(n_code, 0);
39817:
39818: ret_val = xmlUCSIsGreekExtended(code);
39819: desret_int(ret_val);
39820: call_tests++;
39821: des_int(n_code, code, 0);
39822: xmlResetLastError();
39823: if (mem_base != xmlMemBlocks()) {
39824: printf("Leak of %d blocks found in xmlUCSIsGreekExtended",
39825: xmlMemBlocks() - mem_base);
39826: test_ret++;
39827: printf(" %d", n_code);
39828: printf("\n");
39829: }
39830: }
39831: function_tests++;
39832: #endif
39833:
39834: return(test_ret);
39835: }
39836:
39837:
39838: static int
39839: test_xmlUCSIsGreekandCoptic(void) {
39840: int test_ret = 0;
39841:
39842: #if defined(LIBXML_UNICODE_ENABLED)
39843: int mem_base;
39844: int ret_val;
39845: int code; /* UCS code point */
39846: int n_code;
39847:
39848: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39849: mem_base = xmlMemBlocks();
39850: code = gen_int(n_code, 0);
39851:
39852: ret_val = xmlUCSIsGreekandCoptic(code);
39853: desret_int(ret_val);
39854: call_tests++;
39855: des_int(n_code, code, 0);
39856: xmlResetLastError();
39857: if (mem_base != xmlMemBlocks()) {
39858: printf("Leak of %d blocks found in xmlUCSIsGreekandCoptic",
39859: xmlMemBlocks() - mem_base);
39860: test_ret++;
39861: printf(" %d", n_code);
39862: printf("\n");
39863: }
39864: }
39865: function_tests++;
39866: #endif
39867:
39868: return(test_ret);
39869: }
39870:
39871:
39872: static int
39873: test_xmlUCSIsGujarati(void) {
39874: int test_ret = 0;
39875:
39876: #if defined(LIBXML_UNICODE_ENABLED)
39877: int mem_base;
39878: int ret_val;
39879: int code; /* UCS code point */
39880: int n_code;
39881:
39882: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39883: mem_base = xmlMemBlocks();
39884: code = gen_int(n_code, 0);
39885:
39886: ret_val = xmlUCSIsGujarati(code);
39887: desret_int(ret_val);
39888: call_tests++;
39889: des_int(n_code, code, 0);
39890: xmlResetLastError();
39891: if (mem_base != xmlMemBlocks()) {
39892: printf("Leak of %d blocks found in xmlUCSIsGujarati",
39893: xmlMemBlocks() - mem_base);
39894: test_ret++;
39895: printf(" %d", n_code);
39896: printf("\n");
39897: }
39898: }
39899: function_tests++;
39900: #endif
39901:
39902: return(test_ret);
39903: }
39904:
39905:
39906: static int
39907: test_xmlUCSIsGurmukhi(void) {
39908: int test_ret = 0;
39909:
39910: #if defined(LIBXML_UNICODE_ENABLED)
39911: int mem_base;
39912: int ret_val;
39913: int code; /* UCS code point */
39914: int n_code;
39915:
39916: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39917: mem_base = xmlMemBlocks();
39918: code = gen_int(n_code, 0);
39919:
39920: ret_val = xmlUCSIsGurmukhi(code);
39921: desret_int(ret_val);
39922: call_tests++;
39923: des_int(n_code, code, 0);
39924: xmlResetLastError();
39925: if (mem_base != xmlMemBlocks()) {
39926: printf("Leak of %d blocks found in xmlUCSIsGurmukhi",
39927: xmlMemBlocks() - mem_base);
39928: test_ret++;
39929: printf(" %d", n_code);
39930: printf("\n");
39931: }
39932: }
39933: function_tests++;
39934: #endif
39935:
39936: return(test_ret);
39937: }
39938:
39939:
39940: static int
39941: test_xmlUCSIsHalfwidthandFullwidthForms(void) {
39942: int test_ret = 0;
39943:
39944: #if defined(LIBXML_UNICODE_ENABLED)
39945: int mem_base;
39946: int ret_val;
39947: int code; /* UCS code point */
39948: int n_code;
39949:
39950: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39951: mem_base = xmlMemBlocks();
39952: code = gen_int(n_code, 0);
39953:
39954: ret_val = xmlUCSIsHalfwidthandFullwidthForms(code);
39955: desret_int(ret_val);
39956: call_tests++;
39957: des_int(n_code, code, 0);
39958: xmlResetLastError();
39959: if (mem_base != xmlMemBlocks()) {
39960: printf("Leak of %d blocks found in xmlUCSIsHalfwidthandFullwidthForms",
39961: xmlMemBlocks() - mem_base);
39962: test_ret++;
39963: printf(" %d", n_code);
39964: printf("\n");
39965: }
39966: }
39967: function_tests++;
39968: #endif
39969:
39970: return(test_ret);
39971: }
39972:
39973:
39974: static int
39975: test_xmlUCSIsHangulCompatibilityJamo(void) {
39976: int test_ret = 0;
39977:
39978: #if defined(LIBXML_UNICODE_ENABLED)
39979: int mem_base;
39980: int ret_val;
39981: int code; /* UCS code point */
39982: int n_code;
39983:
39984: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39985: mem_base = xmlMemBlocks();
39986: code = gen_int(n_code, 0);
39987:
39988: ret_val = xmlUCSIsHangulCompatibilityJamo(code);
39989: desret_int(ret_val);
39990: call_tests++;
39991: des_int(n_code, code, 0);
39992: xmlResetLastError();
39993: if (mem_base != xmlMemBlocks()) {
39994: printf("Leak of %d blocks found in xmlUCSIsHangulCompatibilityJamo",
39995: xmlMemBlocks() - mem_base);
39996: test_ret++;
39997: printf(" %d", n_code);
39998: printf("\n");
39999: }
40000: }
40001: function_tests++;
40002: #endif
40003:
40004: return(test_ret);
40005: }
40006:
40007:
40008: static int
40009: test_xmlUCSIsHangulJamo(void) {
40010: int test_ret = 0;
40011:
40012: #if defined(LIBXML_UNICODE_ENABLED)
40013: int mem_base;
40014: int ret_val;
40015: int code; /* UCS code point */
40016: int n_code;
40017:
40018: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40019: mem_base = xmlMemBlocks();
40020: code = gen_int(n_code, 0);
40021:
40022: ret_val = xmlUCSIsHangulJamo(code);
40023: desret_int(ret_val);
40024: call_tests++;
40025: des_int(n_code, code, 0);
40026: xmlResetLastError();
40027: if (mem_base != xmlMemBlocks()) {
40028: printf("Leak of %d blocks found in xmlUCSIsHangulJamo",
40029: xmlMemBlocks() - mem_base);
40030: test_ret++;
40031: printf(" %d", n_code);
40032: printf("\n");
40033: }
40034: }
40035: function_tests++;
40036: #endif
40037:
40038: return(test_ret);
40039: }
40040:
40041:
40042: static int
40043: test_xmlUCSIsHangulSyllables(void) {
40044: int test_ret = 0;
40045:
40046: #if defined(LIBXML_UNICODE_ENABLED)
40047: int mem_base;
40048: int ret_val;
40049: int code; /* UCS code point */
40050: int n_code;
40051:
40052: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40053: mem_base = xmlMemBlocks();
40054: code = gen_int(n_code, 0);
40055:
40056: ret_val = xmlUCSIsHangulSyllables(code);
40057: desret_int(ret_val);
40058: call_tests++;
40059: des_int(n_code, code, 0);
40060: xmlResetLastError();
40061: if (mem_base != xmlMemBlocks()) {
40062: printf("Leak of %d blocks found in xmlUCSIsHangulSyllables",
40063: xmlMemBlocks() - mem_base);
40064: test_ret++;
40065: printf(" %d", n_code);
40066: printf("\n");
40067: }
40068: }
40069: function_tests++;
40070: #endif
40071:
40072: return(test_ret);
40073: }
40074:
40075:
40076: static int
40077: test_xmlUCSIsHanunoo(void) {
40078: int test_ret = 0;
40079:
40080: #if defined(LIBXML_UNICODE_ENABLED)
40081: int mem_base;
40082: int ret_val;
40083: int code; /* UCS code point */
40084: int n_code;
40085:
40086: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40087: mem_base = xmlMemBlocks();
40088: code = gen_int(n_code, 0);
40089:
40090: ret_val = xmlUCSIsHanunoo(code);
40091: desret_int(ret_val);
40092: call_tests++;
40093: des_int(n_code, code, 0);
40094: xmlResetLastError();
40095: if (mem_base != xmlMemBlocks()) {
40096: printf("Leak of %d blocks found in xmlUCSIsHanunoo",
40097: xmlMemBlocks() - mem_base);
40098: test_ret++;
40099: printf(" %d", n_code);
40100: printf("\n");
40101: }
40102: }
40103: function_tests++;
40104: #endif
40105:
40106: return(test_ret);
40107: }
40108:
40109:
40110: static int
40111: test_xmlUCSIsHebrew(void) {
40112: int test_ret = 0;
40113:
40114: #if defined(LIBXML_UNICODE_ENABLED)
40115: int mem_base;
40116: int ret_val;
40117: int code; /* UCS code point */
40118: int n_code;
40119:
40120: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40121: mem_base = xmlMemBlocks();
40122: code = gen_int(n_code, 0);
40123:
40124: ret_val = xmlUCSIsHebrew(code);
40125: desret_int(ret_val);
40126: call_tests++;
40127: des_int(n_code, code, 0);
40128: xmlResetLastError();
40129: if (mem_base != xmlMemBlocks()) {
40130: printf("Leak of %d blocks found in xmlUCSIsHebrew",
40131: xmlMemBlocks() - mem_base);
40132: test_ret++;
40133: printf(" %d", n_code);
40134: printf("\n");
40135: }
40136: }
40137: function_tests++;
40138: #endif
40139:
40140: return(test_ret);
40141: }
40142:
40143:
40144: static int
40145: test_xmlUCSIsHighPrivateUseSurrogates(void) {
40146: int test_ret = 0;
40147:
40148: #if defined(LIBXML_UNICODE_ENABLED)
40149: int mem_base;
40150: int ret_val;
40151: int code; /* UCS code point */
40152: int n_code;
40153:
40154: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40155: mem_base = xmlMemBlocks();
40156: code = gen_int(n_code, 0);
40157:
40158: ret_val = xmlUCSIsHighPrivateUseSurrogates(code);
40159: desret_int(ret_val);
40160: call_tests++;
40161: des_int(n_code, code, 0);
40162: xmlResetLastError();
40163: if (mem_base != xmlMemBlocks()) {
40164: printf("Leak of %d blocks found in xmlUCSIsHighPrivateUseSurrogates",
40165: xmlMemBlocks() - mem_base);
40166: test_ret++;
40167: printf(" %d", n_code);
40168: printf("\n");
40169: }
40170: }
40171: function_tests++;
40172: #endif
40173:
40174: return(test_ret);
40175: }
40176:
40177:
40178: static int
40179: test_xmlUCSIsHighSurrogates(void) {
40180: int test_ret = 0;
40181:
40182: #if defined(LIBXML_UNICODE_ENABLED)
40183: int mem_base;
40184: int ret_val;
40185: int code; /* UCS code point */
40186: int n_code;
40187:
40188: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40189: mem_base = xmlMemBlocks();
40190: code = gen_int(n_code, 0);
40191:
40192: ret_val = xmlUCSIsHighSurrogates(code);
40193: desret_int(ret_val);
40194: call_tests++;
40195: des_int(n_code, code, 0);
40196: xmlResetLastError();
40197: if (mem_base != xmlMemBlocks()) {
40198: printf("Leak of %d blocks found in xmlUCSIsHighSurrogates",
40199: xmlMemBlocks() - mem_base);
40200: test_ret++;
40201: printf(" %d", n_code);
40202: printf("\n");
40203: }
40204: }
40205: function_tests++;
40206: #endif
40207:
40208: return(test_ret);
40209: }
40210:
40211:
40212: static int
40213: test_xmlUCSIsHiragana(void) {
40214: int test_ret = 0;
40215:
40216: #if defined(LIBXML_UNICODE_ENABLED)
40217: int mem_base;
40218: int ret_val;
40219: int code; /* UCS code point */
40220: int n_code;
40221:
40222: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40223: mem_base = xmlMemBlocks();
40224: code = gen_int(n_code, 0);
40225:
40226: ret_val = xmlUCSIsHiragana(code);
40227: desret_int(ret_val);
40228: call_tests++;
40229: des_int(n_code, code, 0);
40230: xmlResetLastError();
40231: if (mem_base != xmlMemBlocks()) {
40232: printf("Leak of %d blocks found in xmlUCSIsHiragana",
40233: xmlMemBlocks() - mem_base);
40234: test_ret++;
40235: printf(" %d", n_code);
40236: printf("\n");
40237: }
40238: }
40239: function_tests++;
40240: #endif
40241:
40242: return(test_ret);
40243: }
40244:
40245:
40246: static int
40247: test_xmlUCSIsIPAExtensions(void) {
40248: int test_ret = 0;
40249:
40250: #if defined(LIBXML_UNICODE_ENABLED)
40251: int mem_base;
40252: int ret_val;
40253: int code; /* UCS code point */
40254: int n_code;
40255:
40256: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40257: mem_base = xmlMemBlocks();
40258: code = gen_int(n_code, 0);
40259:
40260: ret_val = xmlUCSIsIPAExtensions(code);
40261: desret_int(ret_val);
40262: call_tests++;
40263: des_int(n_code, code, 0);
40264: xmlResetLastError();
40265: if (mem_base != xmlMemBlocks()) {
40266: printf("Leak of %d blocks found in xmlUCSIsIPAExtensions",
40267: xmlMemBlocks() - mem_base);
40268: test_ret++;
40269: printf(" %d", n_code);
40270: printf("\n");
40271: }
40272: }
40273: function_tests++;
40274: #endif
40275:
40276: return(test_ret);
40277: }
40278:
40279:
40280: static int
40281: test_xmlUCSIsIdeographicDescriptionCharacters(void) {
40282: int test_ret = 0;
40283:
40284: #if defined(LIBXML_UNICODE_ENABLED)
40285: int mem_base;
40286: int ret_val;
40287: int code; /* UCS code point */
40288: int n_code;
40289:
40290: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40291: mem_base = xmlMemBlocks();
40292: code = gen_int(n_code, 0);
40293:
40294: ret_val = xmlUCSIsIdeographicDescriptionCharacters(code);
40295: desret_int(ret_val);
40296: call_tests++;
40297: des_int(n_code, code, 0);
40298: xmlResetLastError();
40299: if (mem_base != xmlMemBlocks()) {
40300: printf("Leak of %d blocks found in xmlUCSIsIdeographicDescriptionCharacters",
40301: xmlMemBlocks() - mem_base);
40302: test_ret++;
40303: printf(" %d", n_code);
40304: printf("\n");
40305: }
40306: }
40307: function_tests++;
40308: #endif
40309:
40310: return(test_ret);
40311: }
40312:
40313:
40314: static int
40315: test_xmlUCSIsKanbun(void) {
40316: int test_ret = 0;
40317:
40318: #if defined(LIBXML_UNICODE_ENABLED)
40319: int mem_base;
40320: int ret_val;
40321: int code; /* UCS code point */
40322: int n_code;
40323:
40324: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40325: mem_base = xmlMemBlocks();
40326: code = gen_int(n_code, 0);
40327:
40328: ret_val = xmlUCSIsKanbun(code);
40329: desret_int(ret_val);
40330: call_tests++;
40331: des_int(n_code, code, 0);
40332: xmlResetLastError();
40333: if (mem_base != xmlMemBlocks()) {
40334: printf("Leak of %d blocks found in xmlUCSIsKanbun",
40335: xmlMemBlocks() - mem_base);
40336: test_ret++;
40337: printf(" %d", n_code);
40338: printf("\n");
40339: }
40340: }
40341: function_tests++;
40342: #endif
40343:
40344: return(test_ret);
40345: }
40346:
40347:
40348: static int
40349: test_xmlUCSIsKangxiRadicals(void) {
40350: int test_ret = 0;
40351:
40352: #if defined(LIBXML_UNICODE_ENABLED)
40353: int mem_base;
40354: int ret_val;
40355: int code; /* UCS code point */
40356: int n_code;
40357:
40358: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40359: mem_base = xmlMemBlocks();
40360: code = gen_int(n_code, 0);
40361:
40362: ret_val = xmlUCSIsKangxiRadicals(code);
40363: desret_int(ret_val);
40364: call_tests++;
40365: des_int(n_code, code, 0);
40366: xmlResetLastError();
40367: if (mem_base != xmlMemBlocks()) {
40368: printf("Leak of %d blocks found in xmlUCSIsKangxiRadicals",
40369: xmlMemBlocks() - mem_base);
40370: test_ret++;
40371: printf(" %d", n_code);
40372: printf("\n");
40373: }
40374: }
40375: function_tests++;
40376: #endif
40377:
40378: return(test_ret);
40379: }
40380:
40381:
40382: static int
40383: test_xmlUCSIsKannada(void) {
40384: int test_ret = 0;
40385:
40386: #if defined(LIBXML_UNICODE_ENABLED)
40387: int mem_base;
40388: int ret_val;
40389: int code; /* UCS code point */
40390: int n_code;
40391:
40392: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40393: mem_base = xmlMemBlocks();
40394: code = gen_int(n_code, 0);
40395:
40396: ret_val = xmlUCSIsKannada(code);
40397: desret_int(ret_val);
40398: call_tests++;
40399: des_int(n_code, code, 0);
40400: xmlResetLastError();
40401: if (mem_base != xmlMemBlocks()) {
40402: printf("Leak of %d blocks found in xmlUCSIsKannada",
40403: xmlMemBlocks() - mem_base);
40404: test_ret++;
40405: printf(" %d", n_code);
40406: printf("\n");
40407: }
40408: }
40409: function_tests++;
40410: #endif
40411:
40412: return(test_ret);
40413: }
40414:
40415:
40416: static int
40417: test_xmlUCSIsKatakana(void) {
40418: int test_ret = 0;
40419:
40420: #if defined(LIBXML_UNICODE_ENABLED)
40421: int mem_base;
40422: int ret_val;
40423: int code; /* UCS code point */
40424: int n_code;
40425:
40426: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40427: mem_base = xmlMemBlocks();
40428: code = gen_int(n_code, 0);
40429:
40430: ret_val = xmlUCSIsKatakana(code);
40431: desret_int(ret_val);
40432: call_tests++;
40433: des_int(n_code, code, 0);
40434: xmlResetLastError();
40435: if (mem_base != xmlMemBlocks()) {
40436: printf("Leak of %d blocks found in xmlUCSIsKatakana",
40437: xmlMemBlocks() - mem_base);
40438: test_ret++;
40439: printf(" %d", n_code);
40440: printf("\n");
40441: }
40442: }
40443: function_tests++;
40444: #endif
40445:
40446: return(test_ret);
40447: }
40448:
40449:
40450: static int
40451: test_xmlUCSIsKatakanaPhoneticExtensions(void) {
40452: int test_ret = 0;
40453:
40454: #if defined(LIBXML_UNICODE_ENABLED)
40455: int mem_base;
40456: int ret_val;
40457: int code; /* UCS code point */
40458: int n_code;
40459:
40460: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40461: mem_base = xmlMemBlocks();
40462: code = gen_int(n_code, 0);
40463:
40464: ret_val = xmlUCSIsKatakanaPhoneticExtensions(code);
40465: desret_int(ret_val);
40466: call_tests++;
40467: des_int(n_code, code, 0);
40468: xmlResetLastError();
40469: if (mem_base != xmlMemBlocks()) {
40470: printf("Leak of %d blocks found in xmlUCSIsKatakanaPhoneticExtensions",
40471: xmlMemBlocks() - mem_base);
40472: test_ret++;
40473: printf(" %d", n_code);
40474: printf("\n");
40475: }
40476: }
40477: function_tests++;
40478: #endif
40479:
40480: return(test_ret);
40481: }
40482:
40483:
40484: static int
40485: test_xmlUCSIsKhmer(void) {
40486: int test_ret = 0;
40487:
40488: #if defined(LIBXML_UNICODE_ENABLED)
40489: int mem_base;
40490: int ret_val;
40491: int code; /* UCS code point */
40492: int n_code;
40493:
40494: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40495: mem_base = xmlMemBlocks();
40496: code = gen_int(n_code, 0);
40497:
40498: ret_val = xmlUCSIsKhmer(code);
40499: desret_int(ret_val);
40500: call_tests++;
40501: des_int(n_code, code, 0);
40502: xmlResetLastError();
40503: if (mem_base != xmlMemBlocks()) {
40504: printf("Leak of %d blocks found in xmlUCSIsKhmer",
40505: xmlMemBlocks() - mem_base);
40506: test_ret++;
40507: printf(" %d", n_code);
40508: printf("\n");
40509: }
40510: }
40511: function_tests++;
40512: #endif
40513:
40514: return(test_ret);
40515: }
40516:
40517:
40518: static int
40519: test_xmlUCSIsKhmerSymbols(void) {
40520: int test_ret = 0;
40521:
40522: #if defined(LIBXML_UNICODE_ENABLED)
40523: int mem_base;
40524: int ret_val;
40525: int code; /* UCS code point */
40526: int n_code;
40527:
40528: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40529: mem_base = xmlMemBlocks();
40530: code = gen_int(n_code, 0);
40531:
40532: ret_val = xmlUCSIsKhmerSymbols(code);
40533: desret_int(ret_val);
40534: call_tests++;
40535: des_int(n_code, code, 0);
40536: xmlResetLastError();
40537: if (mem_base != xmlMemBlocks()) {
40538: printf("Leak of %d blocks found in xmlUCSIsKhmerSymbols",
40539: xmlMemBlocks() - mem_base);
40540: test_ret++;
40541: printf(" %d", n_code);
40542: printf("\n");
40543: }
40544: }
40545: function_tests++;
40546: #endif
40547:
40548: return(test_ret);
40549: }
40550:
40551:
40552: static int
40553: test_xmlUCSIsLao(void) {
40554: int test_ret = 0;
40555:
40556: #if defined(LIBXML_UNICODE_ENABLED)
40557: int mem_base;
40558: int ret_val;
40559: int code; /* UCS code point */
40560: int n_code;
40561:
40562: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40563: mem_base = xmlMemBlocks();
40564: code = gen_int(n_code, 0);
40565:
40566: ret_val = xmlUCSIsLao(code);
40567: desret_int(ret_val);
40568: call_tests++;
40569: des_int(n_code, code, 0);
40570: xmlResetLastError();
40571: if (mem_base != xmlMemBlocks()) {
40572: printf("Leak of %d blocks found in xmlUCSIsLao",
40573: xmlMemBlocks() - mem_base);
40574: test_ret++;
40575: printf(" %d", n_code);
40576: printf("\n");
40577: }
40578: }
40579: function_tests++;
40580: #endif
40581:
40582: return(test_ret);
40583: }
40584:
40585:
40586: static int
40587: test_xmlUCSIsLatin1Supplement(void) {
40588: int test_ret = 0;
40589:
40590: #if defined(LIBXML_UNICODE_ENABLED)
40591: int mem_base;
40592: int ret_val;
40593: int code; /* UCS code point */
40594: int n_code;
40595:
40596: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40597: mem_base = xmlMemBlocks();
40598: code = gen_int(n_code, 0);
40599:
40600: ret_val = xmlUCSIsLatin1Supplement(code);
40601: desret_int(ret_val);
40602: call_tests++;
40603: des_int(n_code, code, 0);
40604: xmlResetLastError();
40605: if (mem_base != xmlMemBlocks()) {
40606: printf("Leak of %d blocks found in xmlUCSIsLatin1Supplement",
40607: xmlMemBlocks() - mem_base);
40608: test_ret++;
40609: printf(" %d", n_code);
40610: printf("\n");
40611: }
40612: }
40613: function_tests++;
40614: #endif
40615:
40616: return(test_ret);
40617: }
40618:
40619:
40620: static int
40621: test_xmlUCSIsLatinExtendedA(void) {
40622: int test_ret = 0;
40623:
40624: #if defined(LIBXML_UNICODE_ENABLED)
40625: int mem_base;
40626: int ret_val;
40627: int code; /* UCS code point */
40628: int n_code;
40629:
40630: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40631: mem_base = xmlMemBlocks();
40632: code = gen_int(n_code, 0);
40633:
40634: ret_val = xmlUCSIsLatinExtendedA(code);
40635: desret_int(ret_val);
40636: call_tests++;
40637: des_int(n_code, code, 0);
40638: xmlResetLastError();
40639: if (mem_base != xmlMemBlocks()) {
40640: printf("Leak of %d blocks found in xmlUCSIsLatinExtendedA",
40641: xmlMemBlocks() - mem_base);
40642: test_ret++;
40643: printf(" %d", n_code);
40644: printf("\n");
40645: }
40646: }
40647: function_tests++;
40648: #endif
40649:
40650: return(test_ret);
40651: }
40652:
40653:
40654: static int
40655: test_xmlUCSIsLatinExtendedAdditional(void) {
40656: int test_ret = 0;
40657:
40658: #if defined(LIBXML_UNICODE_ENABLED)
40659: int mem_base;
40660: int ret_val;
40661: int code; /* UCS code point */
40662: int n_code;
40663:
40664: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40665: mem_base = xmlMemBlocks();
40666: code = gen_int(n_code, 0);
40667:
40668: ret_val = xmlUCSIsLatinExtendedAdditional(code);
40669: desret_int(ret_val);
40670: call_tests++;
40671: des_int(n_code, code, 0);
40672: xmlResetLastError();
40673: if (mem_base != xmlMemBlocks()) {
40674: printf("Leak of %d blocks found in xmlUCSIsLatinExtendedAdditional",
40675: xmlMemBlocks() - mem_base);
40676: test_ret++;
40677: printf(" %d", n_code);
40678: printf("\n");
40679: }
40680: }
40681: function_tests++;
40682: #endif
40683:
40684: return(test_ret);
40685: }
40686:
40687:
40688: static int
40689: test_xmlUCSIsLatinExtendedB(void) {
40690: int test_ret = 0;
40691:
40692: #if defined(LIBXML_UNICODE_ENABLED)
40693: int mem_base;
40694: int ret_val;
40695: int code; /* UCS code point */
40696: int n_code;
40697:
40698: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40699: mem_base = xmlMemBlocks();
40700: code = gen_int(n_code, 0);
40701:
40702: ret_val = xmlUCSIsLatinExtendedB(code);
40703: desret_int(ret_val);
40704: call_tests++;
40705: des_int(n_code, code, 0);
40706: xmlResetLastError();
40707: if (mem_base != xmlMemBlocks()) {
40708: printf("Leak of %d blocks found in xmlUCSIsLatinExtendedB",
40709: xmlMemBlocks() - mem_base);
40710: test_ret++;
40711: printf(" %d", n_code);
40712: printf("\n");
40713: }
40714: }
40715: function_tests++;
40716: #endif
40717:
40718: return(test_ret);
40719: }
40720:
40721:
40722: static int
40723: test_xmlUCSIsLetterlikeSymbols(void) {
40724: int test_ret = 0;
40725:
40726: #if defined(LIBXML_UNICODE_ENABLED)
40727: int mem_base;
40728: int ret_val;
40729: int code; /* UCS code point */
40730: int n_code;
40731:
40732: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40733: mem_base = xmlMemBlocks();
40734: code = gen_int(n_code, 0);
40735:
40736: ret_val = xmlUCSIsLetterlikeSymbols(code);
40737: desret_int(ret_val);
40738: call_tests++;
40739: des_int(n_code, code, 0);
40740: xmlResetLastError();
40741: if (mem_base != xmlMemBlocks()) {
40742: printf("Leak of %d blocks found in xmlUCSIsLetterlikeSymbols",
40743: xmlMemBlocks() - mem_base);
40744: test_ret++;
40745: printf(" %d", n_code);
40746: printf("\n");
40747: }
40748: }
40749: function_tests++;
40750: #endif
40751:
40752: return(test_ret);
40753: }
40754:
40755:
40756: static int
40757: test_xmlUCSIsLimbu(void) {
40758: int test_ret = 0;
40759:
40760: #if defined(LIBXML_UNICODE_ENABLED)
40761: int mem_base;
40762: int ret_val;
40763: int code; /* UCS code point */
40764: int n_code;
40765:
40766: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40767: mem_base = xmlMemBlocks();
40768: code = gen_int(n_code, 0);
40769:
40770: ret_val = xmlUCSIsLimbu(code);
40771: desret_int(ret_val);
40772: call_tests++;
40773: des_int(n_code, code, 0);
40774: xmlResetLastError();
40775: if (mem_base != xmlMemBlocks()) {
40776: printf("Leak of %d blocks found in xmlUCSIsLimbu",
40777: xmlMemBlocks() - mem_base);
40778: test_ret++;
40779: printf(" %d", n_code);
40780: printf("\n");
40781: }
40782: }
40783: function_tests++;
40784: #endif
40785:
40786: return(test_ret);
40787: }
40788:
40789:
40790: static int
40791: test_xmlUCSIsLinearBIdeograms(void) {
40792: int test_ret = 0;
40793:
40794: #if defined(LIBXML_UNICODE_ENABLED)
40795: int mem_base;
40796: int ret_val;
40797: int code; /* UCS code point */
40798: int n_code;
40799:
40800: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40801: mem_base = xmlMemBlocks();
40802: code = gen_int(n_code, 0);
40803:
40804: ret_val = xmlUCSIsLinearBIdeograms(code);
40805: desret_int(ret_val);
40806: call_tests++;
40807: des_int(n_code, code, 0);
40808: xmlResetLastError();
40809: if (mem_base != xmlMemBlocks()) {
40810: printf("Leak of %d blocks found in xmlUCSIsLinearBIdeograms",
40811: xmlMemBlocks() - mem_base);
40812: test_ret++;
40813: printf(" %d", n_code);
40814: printf("\n");
40815: }
40816: }
40817: function_tests++;
40818: #endif
40819:
40820: return(test_ret);
40821: }
40822:
40823:
40824: static int
40825: test_xmlUCSIsLinearBSyllabary(void) {
40826: int test_ret = 0;
40827:
40828: #if defined(LIBXML_UNICODE_ENABLED)
40829: int mem_base;
40830: int ret_val;
40831: int code; /* UCS code point */
40832: int n_code;
40833:
40834: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40835: mem_base = xmlMemBlocks();
40836: code = gen_int(n_code, 0);
40837:
40838: ret_val = xmlUCSIsLinearBSyllabary(code);
40839: desret_int(ret_val);
40840: call_tests++;
40841: des_int(n_code, code, 0);
40842: xmlResetLastError();
40843: if (mem_base != xmlMemBlocks()) {
40844: printf("Leak of %d blocks found in xmlUCSIsLinearBSyllabary",
40845: xmlMemBlocks() - mem_base);
40846: test_ret++;
40847: printf(" %d", n_code);
40848: printf("\n");
40849: }
40850: }
40851: function_tests++;
40852: #endif
40853:
40854: return(test_ret);
40855: }
40856:
40857:
40858: static int
40859: test_xmlUCSIsLowSurrogates(void) {
40860: int test_ret = 0;
40861:
40862: #if defined(LIBXML_UNICODE_ENABLED)
40863: int mem_base;
40864: int ret_val;
40865: int code; /* UCS code point */
40866: int n_code;
40867:
40868: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40869: mem_base = xmlMemBlocks();
40870: code = gen_int(n_code, 0);
40871:
40872: ret_val = xmlUCSIsLowSurrogates(code);
40873: desret_int(ret_val);
40874: call_tests++;
40875: des_int(n_code, code, 0);
40876: xmlResetLastError();
40877: if (mem_base != xmlMemBlocks()) {
40878: printf("Leak of %d blocks found in xmlUCSIsLowSurrogates",
40879: xmlMemBlocks() - mem_base);
40880: test_ret++;
40881: printf(" %d", n_code);
40882: printf("\n");
40883: }
40884: }
40885: function_tests++;
40886: #endif
40887:
40888: return(test_ret);
40889: }
40890:
40891:
40892: static int
40893: test_xmlUCSIsMalayalam(void) {
40894: int test_ret = 0;
40895:
40896: #if defined(LIBXML_UNICODE_ENABLED)
40897: int mem_base;
40898: int ret_val;
40899: int code; /* UCS code point */
40900: int n_code;
40901:
40902: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40903: mem_base = xmlMemBlocks();
40904: code = gen_int(n_code, 0);
40905:
40906: ret_val = xmlUCSIsMalayalam(code);
40907: desret_int(ret_val);
40908: call_tests++;
40909: des_int(n_code, code, 0);
40910: xmlResetLastError();
40911: if (mem_base != xmlMemBlocks()) {
40912: printf("Leak of %d blocks found in xmlUCSIsMalayalam",
40913: xmlMemBlocks() - mem_base);
40914: test_ret++;
40915: printf(" %d", n_code);
40916: printf("\n");
40917: }
40918: }
40919: function_tests++;
40920: #endif
40921:
40922: return(test_ret);
40923: }
40924:
40925:
40926: static int
40927: test_xmlUCSIsMathematicalAlphanumericSymbols(void) {
40928: int test_ret = 0;
40929:
40930: #if defined(LIBXML_UNICODE_ENABLED)
40931: int mem_base;
40932: int ret_val;
40933: int code; /* UCS code point */
40934: int n_code;
40935:
40936: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40937: mem_base = xmlMemBlocks();
40938: code = gen_int(n_code, 0);
40939:
40940: ret_val = xmlUCSIsMathematicalAlphanumericSymbols(code);
40941: desret_int(ret_val);
40942: call_tests++;
40943: des_int(n_code, code, 0);
40944: xmlResetLastError();
40945: if (mem_base != xmlMemBlocks()) {
40946: printf("Leak of %d blocks found in xmlUCSIsMathematicalAlphanumericSymbols",
40947: xmlMemBlocks() - mem_base);
40948: test_ret++;
40949: printf(" %d", n_code);
40950: printf("\n");
40951: }
40952: }
40953: function_tests++;
40954: #endif
40955:
40956: return(test_ret);
40957: }
40958:
40959:
40960: static int
40961: test_xmlUCSIsMathematicalOperators(void) {
40962: int test_ret = 0;
40963:
40964: #if defined(LIBXML_UNICODE_ENABLED)
40965: int mem_base;
40966: int ret_val;
40967: int code; /* UCS code point */
40968: int n_code;
40969:
40970: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40971: mem_base = xmlMemBlocks();
40972: code = gen_int(n_code, 0);
40973:
40974: ret_val = xmlUCSIsMathematicalOperators(code);
40975: desret_int(ret_val);
40976: call_tests++;
40977: des_int(n_code, code, 0);
40978: xmlResetLastError();
40979: if (mem_base != xmlMemBlocks()) {
40980: printf("Leak of %d blocks found in xmlUCSIsMathematicalOperators",
40981: xmlMemBlocks() - mem_base);
40982: test_ret++;
40983: printf(" %d", n_code);
40984: printf("\n");
40985: }
40986: }
40987: function_tests++;
40988: #endif
40989:
40990: return(test_ret);
40991: }
40992:
40993:
40994: static int
40995: test_xmlUCSIsMiscellaneousMathematicalSymbolsA(void) {
40996: int test_ret = 0;
40997:
40998: #if defined(LIBXML_UNICODE_ENABLED)
40999: int mem_base;
41000: int ret_val;
41001: int code; /* UCS code point */
41002: int n_code;
41003:
41004: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41005: mem_base = xmlMemBlocks();
41006: code = gen_int(n_code, 0);
41007:
41008: ret_val = xmlUCSIsMiscellaneousMathematicalSymbolsA(code);
41009: desret_int(ret_val);
41010: call_tests++;
41011: des_int(n_code, code, 0);
41012: xmlResetLastError();
41013: if (mem_base != xmlMemBlocks()) {
41014: printf("Leak of %d blocks found in xmlUCSIsMiscellaneousMathematicalSymbolsA",
41015: xmlMemBlocks() - mem_base);
41016: test_ret++;
41017: printf(" %d", n_code);
41018: printf("\n");
41019: }
41020: }
41021: function_tests++;
41022: #endif
41023:
41024: return(test_ret);
41025: }
41026:
41027:
41028: static int
41029: test_xmlUCSIsMiscellaneousMathematicalSymbolsB(void) {
41030: int test_ret = 0;
41031:
41032: #if defined(LIBXML_UNICODE_ENABLED)
41033: int mem_base;
41034: int ret_val;
41035: int code; /* UCS code point */
41036: int n_code;
41037:
41038: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41039: mem_base = xmlMemBlocks();
41040: code = gen_int(n_code, 0);
41041:
41042: ret_val = xmlUCSIsMiscellaneousMathematicalSymbolsB(code);
41043: desret_int(ret_val);
41044: call_tests++;
41045: des_int(n_code, code, 0);
41046: xmlResetLastError();
41047: if (mem_base != xmlMemBlocks()) {
41048: printf("Leak of %d blocks found in xmlUCSIsMiscellaneousMathematicalSymbolsB",
41049: xmlMemBlocks() - mem_base);
41050: test_ret++;
41051: printf(" %d", n_code);
41052: printf("\n");
41053: }
41054: }
41055: function_tests++;
41056: #endif
41057:
41058: return(test_ret);
41059: }
41060:
41061:
41062: static int
41063: test_xmlUCSIsMiscellaneousSymbols(void) {
41064: int test_ret = 0;
41065:
41066: #if defined(LIBXML_UNICODE_ENABLED)
41067: int mem_base;
41068: int ret_val;
41069: int code; /* UCS code point */
41070: int n_code;
41071:
41072: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41073: mem_base = xmlMemBlocks();
41074: code = gen_int(n_code, 0);
41075:
41076: ret_val = xmlUCSIsMiscellaneousSymbols(code);
41077: desret_int(ret_val);
41078: call_tests++;
41079: des_int(n_code, code, 0);
41080: xmlResetLastError();
41081: if (mem_base != xmlMemBlocks()) {
41082: printf("Leak of %d blocks found in xmlUCSIsMiscellaneousSymbols",
41083: xmlMemBlocks() - mem_base);
41084: test_ret++;
41085: printf(" %d", n_code);
41086: printf("\n");
41087: }
41088: }
41089: function_tests++;
41090: #endif
41091:
41092: return(test_ret);
41093: }
41094:
41095:
41096: static int
41097: test_xmlUCSIsMiscellaneousSymbolsandArrows(void) {
41098: int test_ret = 0;
41099:
41100: #if defined(LIBXML_UNICODE_ENABLED)
41101: int mem_base;
41102: int ret_val;
41103: int code; /* UCS code point */
41104: int n_code;
41105:
41106: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41107: mem_base = xmlMemBlocks();
41108: code = gen_int(n_code, 0);
41109:
41110: ret_val = xmlUCSIsMiscellaneousSymbolsandArrows(code);
41111: desret_int(ret_val);
41112: call_tests++;
41113: des_int(n_code, code, 0);
41114: xmlResetLastError();
41115: if (mem_base != xmlMemBlocks()) {
41116: printf("Leak of %d blocks found in xmlUCSIsMiscellaneousSymbolsandArrows",
41117: xmlMemBlocks() - mem_base);
41118: test_ret++;
41119: printf(" %d", n_code);
41120: printf("\n");
41121: }
41122: }
41123: function_tests++;
41124: #endif
41125:
41126: return(test_ret);
41127: }
41128:
41129:
41130: static int
41131: test_xmlUCSIsMiscellaneousTechnical(void) {
41132: int test_ret = 0;
41133:
41134: #if defined(LIBXML_UNICODE_ENABLED)
41135: int mem_base;
41136: int ret_val;
41137: int code; /* UCS code point */
41138: int n_code;
41139:
41140: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41141: mem_base = xmlMemBlocks();
41142: code = gen_int(n_code, 0);
41143:
41144: ret_val = xmlUCSIsMiscellaneousTechnical(code);
41145: desret_int(ret_val);
41146: call_tests++;
41147: des_int(n_code, code, 0);
41148: xmlResetLastError();
41149: if (mem_base != xmlMemBlocks()) {
41150: printf("Leak of %d blocks found in xmlUCSIsMiscellaneousTechnical",
41151: xmlMemBlocks() - mem_base);
41152: test_ret++;
41153: printf(" %d", n_code);
41154: printf("\n");
41155: }
41156: }
41157: function_tests++;
41158: #endif
41159:
41160: return(test_ret);
41161: }
41162:
41163:
41164: static int
41165: test_xmlUCSIsMongolian(void) {
41166: int test_ret = 0;
41167:
41168: #if defined(LIBXML_UNICODE_ENABLED)
41169: int mem_base;
41170: int ret_val;
41171: int code; /* UCS code point */
41172: int n_code;
41173:
41174: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41175: mem_base = xmlMemBlocks();
41176: code = gen_int(n_code, 0);
41177:
41178: ret_val = xmlUCSIsMongolian(code);
41179: desret_int(ret_val);
41180: call_tests++;
41181: des_int(n_code, code, 0);
41182: xmlResetLastError();
41183: if (mem_base != xmlMemBlocks()) {
41184: printf("Leak of %d blocks found in xmlUCSIsMongolian",
41185: xmlMemBlocks() - mem_base);
41186: test_ret++;
41187: printf(" %d", n_code);
41188: printf("\n");
41189: }
41190: }
41191: function_tests++;
41192: #endif
41193:
41194: return(test_ret);
41195: }
41196:
41197:
41198: static int
41199: test_xmlUCSIsMusicalSymbols(void) {
41200: int test_ret = 0;
41201:
41202: #if defined(LIBXML_UNICODE_ENABLED)
41203: int mem_base;
41204: int ret_val;
41205: int code; /* UCS code point */
41206: int n_code;
41207:
41208: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41209: mem_base = xmlMemBlocks();
41210: code = gen_int(n_code, 0);
41211:
41212: ret_val = xmlUCSIsMusicalSymbols(code);
41213: desret_int(ret_val);
41214: call_tests++;
41215: des_int(n_code, code, 0);
41216: xmlResetLastError();
41217: if (mem_base != xmlMemBlocks()) {
41218: printf("Leak of %d blocks found in xmlUCSIsMusicalSymbols",
41219: xmlMemBlocks() - mem_base);
41220: test_ret++;
41221: printf(" %d", n_code);
41222: printf("\n");
41223: }
41224: }
41225: function_tests++;
41226: #endif
41227:
41228: return(test_ret);
41229: }
41230:
41231:
41232: static int
41233: test_xmlUCSIsMyanmar(void) {
41234: int test_ret = 0;
41235:
41236: #if defined(LIBXML_UNICODE_ENABLED)
41237: int mem_base;
41238: int ret_val;
41239: int code; /* UCS code point */
41240: int n_code;
41241:
41242: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41243: mem_base = xmlMemBlocks();
41244: code = gen_int(n_code, 0);
41245:
41246: ret_val = xmlUCSIsMyanmar(code);
41247: desret_int(ret_val);
41248: call_tests++;
41249: des_int(n_code, code, 0);
41250: xmlResetLastError();
41251: if (mem_base != xmlMemBlocks()) {
41252: printf("Leak of %d blocks found in xmlUCSIsMyanmar",
41253: xmlMemBlocks() - mem_base);
41254: test_ret++;
41255: printf(" %d", n_code);
41256: printf("\n");
41257: }
41258: }
41259: function_tests++;
41260: #endif
41261:
41262: return(test_ret);
41263: }
41264:
41265:
41266: static int
41267: test_xmlUCSIsNumberForms(void) {
41268: int test_ret = 0;
41269:
41270: #if defined(LIBXML_UNICODE_ENABLED)
41271: int mem_base;
41272: int ret_val;
41273: int code; /* UCS code point */
41274: int n_code;
41275:
41276: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41277: mem_base = xmlMemBlocks();
41278: code = gen_int(n_code, 0);
41279:
41280: ret_val = xmlUCSIsNumberForms(code);
41281: desret_int(ret_val);
41282: call_tests++;
41283: des_int(n_code, code, 0);
41284: xmlResetLastError();
41285: if (mem_base != xmlMemBlocks()) {
41286: printf("Leak of %d blocks found in xmlUCSIsNumberForms",
41287: xmlMemBlocks() - mem_base);
41288: test_ret++;
41289: printf(" %d", n_code);
41290: printf("\n");
41291: }
41292: }
41293: function_tests++;
41294: #endif
41295:
41296: return(test_ret);
41297: }
41298:
41299:
41300: static int
41301: test_xmlUCSIsOgham(void) {
41302: int test_ret = 0;
41303:
41304: #if defined(LIBXML_UNICODE_ENABLED)
41305: int mem_base;
41306: int ret_val;
41307: int code; /* UCS code point */
41308: int n_code;
41309:
41310: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41311: mem_base = xmlMemBlocks();
41312: code = gen_int(n_code, 0);
41313:
41314: ret_val = xmlUCSIsOgham(code);
41315: desret_int(ret_val);
41316: call_tests++;
41317: des_int(n_code, code, 0);
41318: xmlResetLastError();
41319: if (mem_base != xmlMemBlocks()) {
41320: printf("Leak of %d blocks found in xmlUCSIsOgham",
41321: xmlMemBlocks() - mem_base);
41322: test_ret++;
41323: printf(" %d", n_code);
41324: printf("\n");
41325: }
41326: }
41327: function_tests++;
41328: #endif
41329:
41330: return(test_ret);
41331: }
41332:
41333:
41334: static int
41335: test_xmlUCSIsOldItalic(void) {
41336: int test_ret = 0;
41337:
41338: #if defined(LIBXML_UNICODE_ENABLED)
41339: int mem_base;
41340: int ret_val;
41341: int code; /* UCS code point */
41342: int n_code;
41343:
41344: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41345: mem_base = xmlMemBlocks();
41346: code = gen_int(n_code, 0);
41347:
41348: ret_val = xmlUCSIsOldItalic(code);
41349: desret_int(ret_val);
41350: call_tests++;
41351: des_int(n_code, code, 0);
41352: xmlResetLastError();
41353: if (mem_base != xmlMemBlocks()) {
41354: printf("Leak of %d blocks found in xmlUCSIsOldItalic",
41355: xmlMemBlocks() - mem_base);
41356: test_ret++;
41357: printf(" %d", n_code);
41358: printf("\n");
41359: }
41360: }
41361: function_tests++;
41362: #endif
41363:
41364: return(test_ret);
41365: }
41366:
41367:
41368: static int
41369: test_xmlUCSIsOpticalCharacterRecognition(void) {
41370: int test_ret = 0;
41371:
41372: #if defined(LIBXML_UNICODE_ENABLED)
41373: int mem_base;
41374: int ret_val;
41375: int code; /* UCS code point */
41376: int n_code;
41377:
41378: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41379: mem_base = xmlMemBlocks();
41380: code = gen_int(n_code, 0);
41381:
41382: ret_val = xmlUCSIsOpticalCharacterRecognition(code);
41383: desret_int(ret_val);
41384: call_tests++;
41385: des_int(n_code, code, 0);
41386: xmlResetLastError();
41387: if (mem_base != xmlMemBlocks()) {
41388: printf("Leak of %d blocks found in xmlUCSIsOpticalCharacterRecognition",
41389: xmlMemBlocks() - mem_base);
41390: test_ret++;
41391: printf(" %d", n_code);
41392: printf("\n");
41393: }
41394: }
41395: function_tests++;
41396: #endif
41397:
41398: return(test_ret);
41399: }
41400:
41401:
41402: static int
41403: test_xmlUCSIsOriya(void) {
41404: int test_ret = 0;
41405:
41406: #if defined(LIBXML_UNICODE_ENABLED)
41407: int mem_base;
41408: int ret_val;
41409: int code; /* UCS code point */
41410: int n_code;
41411:
41412: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41413: mem_base = xmlMemBlocks();
41414: code = gen_int(n_code, 0);
41415:
41416: ret_val = xmlUCSIsOriya(code);
41417: desret_int(ret_val);
41418: call_tests++;
41419: des_int(n_code, code, 0);
41420: xmlResetLastError();
41421: if (mem_base != xmlMemBlocks()) {
41422: printf("Leak of %d blocks found in xmlUCSIsOriya",
41423: xmlMemBlocks() - mem_base);
41424: test_ret++;
41425: printf(" %d", n_code);
41426: printf("\n");
41427: }
41428: }
41429: function_tests++;
41430: #endif
41431:
41432: return(test_ret);
41433: }
41434:
41435:
41436: static int
41437: test_xmlUCSIsOsmanya(void) {
41438: int test_ret = 0;
41439:
41440: #if defined(LIBXML_UNICODE_ENABLED)
41441: int mem_base;
41442: int ret_val;
41443: int code; /* UCS code point */
41444: int n_code;
41445:
41446: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41447: mem_base = xmlMemBlocks();
41448: code = gen_int(n_code, 0);
41449:
41450: ret_val = xmlUCSIsOsmanya(code);
41451: desret_int(ret_val);
41452: call_tests++;
41453: des_int(n_code, code, 0);
41454: xmlResetLastError();
41455: if (mem_base != xmlMemBlocks()) {
41456: printf("Leak of %d blocks found in xmlUCSIsOsmanya",
41457: xmlMemBlocks() - mem_base);
41458: test_ret++;
41459: printf(" %d", n_code);
41460: printf("\n");
41461: }
41462: }
41463: function_tests++;
41464: #endif
41465:
41466: return(test_ret);
41467: }
41468:
41469:
41470: static int
41471: test_xmlUCSIsPhoneticExtensions(void) {
41472: int test_ret = 0;
41473:
41474: #if defined(LIBXML_UNICODE_ENABLED)
41475: int mem_base;
41476: int ret_val;
41477: int code; /* UCS code point */
41478: int n_code;
41479:
41480: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41481: mem_base = xmlMemBlocks();
41482: code = gen_int(n_code, 0);
41483:
41484: ret_val = xmlUCSIsPhoneticExtensions(code);
41485: desret_int(ret_val);
41486: call_tests++;
41487: des_int(n_code, code, 0);
41488: xmlResetLastError();
41489: if (mem_base != xmlMemBlocks()) {
41490: printf("Leak of %d blocks found in xmlUCSIsPhoneticExtensions",
41491: xmlMemBlocks() - mem_base);
41492: test_ret++;
41493: printf(" %d", n_code);
41494: printf("\n");
41495: }
41496: }
41497: function_tests++;
41498: #endif
41499:
41500: return(test_ret);
41501: }
41502:
41503:
41504: static int
41505: test_xmlUCSIsPrivateUse(void) {
41506: int test_ret = 0;
41507:
41508: #if defined(LIBXML_UNICODE_ENABLED)
41509: int mem_base;
41510: int ret_val;
41511: int code; /* UCS code point */
41512: int n_code;
41513:
41514: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41515: mem_base = xmlMemBlocks();
41516: code = gen_int(n_code, 0);
41517:
41518: ret_val = xmlUCSIsPrivateUse(code);
41519: desret_int(ret_val);
41520: call_tests++;
41521: des_int(n_code, code, 0);
41522: xmlResetLastError();
41523: if (mem_base != xmlMemBlocks()) {
41524: printf("Leak of %d blocks found in xmlUCSIsPrivateUse",
41525: xmlMemBlocks() - mem_base);
41526: test_ret++;
41527: printf(" %d", n_code);
41528: printf("\n");
41529: }
41530: }
41531: function_tests++;
41532: #endif
41533:
41534: return(test_ret);
41535: }
41536:
41537:
41538: static int
41539: test_xmlUCSIsPrivateUseArea(void) {
41540: int test_ret = 0;
41541:
41542: #if defined(LIBXML_UNICODE_ENABLED)
41543: int mem_base;
41544: int ret_val;
41545: int code; /* UCS code point */
41546: int n_code;
41547:
41548: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41549: mem_base = xmlMemBlocks();
41550: code = gen_int(n_code, 0);
41551:
41552: ret_val = xmlUCSIsPrivateUseArea(code);
41553: desret_int(ret_val);
41554: call_tests++;
41555: des_int(n_code, code, 0);
41556: xmlResetLastError();
41557: if (mem_base != xmlMemBlocks()) {
41558: printf("Leak of %d blocks found in xmlUCSIsPrivateUseArea",
41559: xmlMemBlocks() - mem_base);
41560: test_ret++;
41561: printf(" %d", n_code);
41562: printf("\n");
41563: }
41564: }
41565: function_tests++;
41566: #endif
41567:
41568: return(test_ret);
41569: }
41570:
41571:
41572: static int
41573: test_xmlUCSIsRunic(void) {
41574: int test_ret = 0;
41575:
41576: #if defined(LIBXML_UNICODE_ENABLED)
41577: int mem_base;
41578: int ret_val;
41579: int code; /* UCS code point */
41580: int n_code;
41581:
41582: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41583: mem_base = xmlMemBlocks();
41584: code = gen_int(n_code, 0);
41585:
41586: ret_val = xmlUCSIsRunic(code);
41587: desret_int(ret_val);
41588: call_tests++;
41589: des_int(n_code, code, 0);
41590: xmlResetLastError();
41591: if (mem_base != xmlMemBlocks()) {
41592: printf("Leak of %d blocks found in xmlUCSIsRunic",
41593: xmlMemBlocks() - mem_base);
41594: test_ret++;
41595: printf(" %d", n_code);
41596: printf("\n");
41597: }
41598: }
41599: function_tests++;
41600: #endif
41601:
41602: return(test_ret);
41603: }
41604:
41605:
41606: static int
41607: test_xmlUCSIsShavian(void) {
41608: int test_ret = 0;
41609:
41610: #if defined(LIBXML_UNICODE_ENABLED)
41611: int mem_base;
41612: int ret_val;
41613: int code; /* UCS code point */
41614: int n_code;
41615:
41616: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41617: mem_base = xmlMemBlocks();
41618: code = gen_int(n_code, 0);
41619:
41620: ret_val = xmlUCSIsShavian(code);
41621: desret_int(ret_val);
41622: call_tests++;
41623: des_int(n_code, code, 0);
41624: xmlResetLastError();
41625: if (mem_base != xmlMemBlocks()) {
41626: printf("Leak of %d blocks found in xmlUCSIsShavian",
41627: xmlMemBlocks() - mem_base);
41628: test_ret++;
41629: printf(" %d", n_code);
41630: printf("\n");
41631: }
41632: }
41633: function_tests++;
41634: #endif
41635:
41636: return(test_ret);
41637: }
41638:
41639:
41640: static int
41641: test_xmlUCSIsSinhala(void) {
41642: int test_ret = 0;
41643:
41644: #if defined(LIBXML_UNICODE_ENABLED)
41645: int mem_base;
41646: int ret_val;
41647: int code; /* UCS code point */
41648: int n_code;
41649:
41650: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41651: mem_base = xmlMemBlocks();
41652: code = gen_int(n_code, 0);
41653:
41654: ret_val = xmlUCSIsSinhala(code);
41655: desret_int(ret_val);
41656: call_tests++;
41657: des_int(n_code, code, 0);
41658: xmlResetLastError();
41659: if (mem_base != xmlMemBlocks()) {
41660: printf("Leak of %d blocks found in xmlUCSIsSinhala",
41661: xmlMemBlocks() - mem_base);
41662: test_ret++;
41663: printf(" %d", n_code);
41664: printf("\n");
41665: }
41666: }
41667: function_tests++;
41668: #endif
41669:
41670: return(test_ret);
41671: }
41672:
41673:
41674: static int
41675: test_xmlUCSIsSmallFormVariants(void) {
41676: int test_ret = 0;
41677:
41678: #if defined(LIBXML_UNICODE_ENABLED)
41679: int mem_base;
41680: int ret_val;
41681: int code; /* UCS code point */
41682: int n_code;
41683:
41684: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41685: mem_base = xmlMemBlocks();
41686: code = gen_int(n_code, 0);
41687:
41688: ret_val = xmlUCSIsSmallFormVariants(code);
41689: desret_int(ret_val);
41690: call_tests++;
41691: des_int(n_code, code, 0);
41692: xmlResetLastError();
41693: if (mem_base != xmlMemBlocks()) {
41694: printf("Leak of %d blocks found in xmlUCSIsSmallFormVariants",
41695: xmlMemBlocks() - mem_base);
41696: test_ret++;
41697: printf(" %d", n_code);
41698: printf("\n");
41699: }
41700: }
41701: function_tests++;
41702: #endif
41703:
41704: return(test_ret);
41705: }
41706:
41707:
41708: static int
41709: test_xmlUCSIsSpacingModifierLetters(void) {
41710: int test_ret = 0;
41711:
41712: #if defined(LIBXML_UNICODE_ENABLED)
41713: int mem_base;
41714: int ret_val;
41715: int code; /* UCS code point */
41716: int n_code;
41717:
41718: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41719: mem_base = xmlMemBlocks();
41720: code = gen_int(n_code, 0);
41721:
41722: ret_val = xmlUCSIsSpacingModifierLetters(code);
41723: desret_int(ret_val);
41724: call_tests++;
41725: des_int(n_code, code, 0);
41726: xmlResetLastError();
41727: if (mem_base != xmlMemBlocks()) {
41728: printf("Leak of %d blocks found in xmlUCSIsSpacingModifierLetters",
41729: xmlMemBlocks() - mem_base);
41730: test_ret++;
41731: printf(" %d", n_code);
41732: printf("\n");
41733: }
41734: }
41735: function_tests++;
41736: #endif
41737:
41738: return(test_ret);
41739: }
41740:
41741:
41742: static int
41743: test_xmlUCSIsSpecials(void) {
41744: int test_ret = 0;
41745:
41746: #if defined(LIBXML_UNICODE_ENABLED)
41747: int mem_base;
41748: int ret_val;
41749: int code; /* UCS code point */
41750: int n_code;
41751:
41752: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41753: mem_base = xmlMemBlocks();
41754: code = gen_int(n_code, 0);
41755:
41756: ret_val = xmlUCSIsSpecials(code);
41757: desret_int(ret_val);
41758: call_tests++;
41759: des_int(n_code, code, 0);
41760: xmlResetLastError();
41761: if (mem_base != xmlMemBlocks()) {
41762: printf("Leak of %d blocks found in xmlUCSIsSpecials",
41763: xmlMemBlocks() - mem_base);
41764: test_ret++;
41765: printf(" %d", n_code);
41766: printf("\n");
41767: }
41768: }
41769: function_tests++;
41770: #endif
41771:
41772: return(test_ret);
41773: }
41774:
41775:
41776: static int
41777: test_xmlUCSIsSuperscriptsandSubscripts(void) {
41778: int test_ret = 0;
41779:
41780: #if defined(LIBXML_UNICODE_ENABLED)
41781: int mem_base;
41782: int ret_val;
41783: int code; /* UCS code point */
41784: int n_code;
41785:
41786: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41787: mem_base = xmlMemBlocks();
41788: code = gen_int(n_code, 0);
41789:
41790: ret_val = xmlUCSIsSuperscriptsandSubscripts(code);
41791: desret_int(ret_val);
41792: call_tests++;
41793: des_int(n_code, code, 0);
41794: xmlResetLastError();
41795: if (mem_base != xmlMemBlocks()) {
41796: printf("Leak of %d blocks found in xmlUCSIsSuperscriptsandSubscripts",
41797: xmlMemBlocks() - mem_base);
41798: test_ret++;
41799: printf(" %d", n_code);
41800: printf("\n");
41801: }
41802: }
41803: function_tests++;
41804: #endif
41805:
41806: return(test_ret);
41807: }
41808:
41809:
41810: static int
41811: test_xmlUCSIsSupplementalArrowsA(void) {
41812: int test_ret = 0;
41813:
41814: #if defined(LIBXML_UNICODE_ENABLED)
41815: int mem_base;
41816: int ret_val;
41817: int code; /* UCS code point */
41818: int n_code;
41819:
41820: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41821: mem_base = xmlMemBlocks();
41822: code = gen_int(n_code, 0);
41823:
41824: ret_val = xmlUCSIsSupplementalArrowsA(code);
41825: desret_int(ret_val);
41826: call_tests++;
41827: des_int(n_code, code, 0);
41828: xmlResetLastError();
41829: if (mem_base != xmlMemBlocks()) {
41830: printf("Leak of %d blocks found in xmlUCSIsSupplementalArrowsA",
41831: xmlMemBlocks() - mem_base);
41832: test_ret++;
41833: printf(" %d", n_code);
41834: printf("\n");
41835: }
41836: }
41837: function_tests++;
41838: #endif
41839:
41840: return(test_ret);
41841: }
41842:
41843:
41844: static int
41845: test_xmlUCSIsSupplementalArrowsB(void) {
41846: int test_ret = 0;
41847:
41848: #if defined(LIBXML_UNICODE_ENABLED)
41849: int mem_base;
41850: int ret_val;
41851: int code; /* UCS code point */
41852: int n_code;
41853:
41854: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41855: mem_base = xmlMemBlocks();
41856: code = gen_int(n_code, 0);
41857:
41858: ret_val = xmlUCSIsSupplementalArrowsB(code);
41859: desret_int(ret_val);
41860: call_tests++;
41861: des_int(n_code, code, 0);
41862: xmlResetLastError();
41863: if (mem_base != xmlMemBlocks()) {
41864: printf("Leak of %d blocks found in xmlUCSIsSupplementalArrowsB",
41865: xmlMemBlocks() - mem_base);
41866: test_ret++;
41867: printf(" %d", n_code);
41868: printf("\n");
41869: }
41870: }
41871: function_tests++;
41872: #endif
41873:
41874: return(test_ret);
41875: }
41876:
41877:
41878: static int
41879: test_xmlUCSIsSupplementalMathematicalOperators(void) {
41880: int test_ret = 0;
41881:
41882: #if defined(LIBXML_UNICODE_ENABLED)
41883: int mem_base;
41884: int ret_val;
41885: int code; /* UCS code point */
41886: int n_code;
41887:
41888: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41889: mem_base = xmlMemBlocks();
41890: code = gen_int(n_code, 0);
41891:
41892: ret_val = xmlUCSIsSupplementalMathematicalOperators(code);
41893: desret_int(ret_val);
41894: call_tests++;
41895: des_int(n_code, code, 0);
41896: xmlResetLastError();
41897: if (mem_base != xmlMemBlocks()) {
41898: printf("Leak of %d blocks found in xmlUCSIsSupplementalMathematicalOperators",
41899: xmlMemBlocks() - mem_base);
41900: test_ret++;
41901: printf(" %d", n_code);
41902: printf("\n");
41903: }
41904: }
41905: function_tests++;
41906: #endif
41907:
41908: return(test_ret);
41909: }
41910:
41911:
41912: static int
41913: test_xmlUCSIsSupplementaryPrivateUseAreaA(void) {
41914: int test_ret = 0;
41915:
41916: #if defined(LIBXML_UNICODE_ENABLED)
41917: int mem_base;
41918: int ret_val;
41919: int code; /* UCS code point */
41920: int n_code;
41921:
41922: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41923: mem_base = xmlMemBlocks();
41924: code = gen_int(n_code, 0);
41925:
41926: ret_val = xmlUCSIsSupplementaryPrivateUseAreaA(code);
41927: desret_int(ret_val);
41928: call_tests++;
41929: des_int(n_code, code, 0);
41930: xmlResetLastError();
41931: if (mem_base != xmlMemBlocks()) {
41932: printf("Leak of %d blocks found in xmlUCSIsSupplementaryPrivateUseAreaA",
41933: xmlMemBlocks() - mem_base);
41934: test_ret++;
41935: printf(" %d", n_code);
41936: printf("\n");
41937: }
41938: }
41939: function_tests++;
41940: #endif
41941:
41942: return(test_ret);
41943: }
41944:
41945:
41946: static int
41947: test_xmlUCSIsSupplementaryPrivateUseAreaB(void) {
41948: int test_ret = 0;
41949:
41950: #if defined(LIBXML_UNICODE_ENABLED)
41951: int mem_base;
41952: int ret_val;
41953: int code; /* UCS code point */
41954: int n_code;
41955:
41956: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41957: mem_base = xmlMemBlocks();
41958: code = gen_int(n_code, 0);
41959:
41960: ret_val = xmlUCSIsSupplementaryPrivateUseAreaB(code);
41961: desret_int(ret_val);
41962: call_tests++;
41963: des_int(n_code, code, 0);
41964: xmlResetLastError();
41965: if (mem_base != xmlMemBlocks()) {
41966: printf("Leak of %d blocks found in xmlUCSIsSupplementaryPrivateUseAreaB",
41967: xmlMemBlocks() - mem_base);
41968: test_ret++;
41969: printf(" %d", n_code);
41970: printf("\n");
41971: }
41972: }
41973: function_tests++;
41974: #endif
41975:
41976: return(test_ret);
41977: }
41978:
41979:
41980: static int
41981: test_xmlUCSIsSyriac(void) {
41982: int test_ret = 0;
41983:
41984: #if defined(LIBXML_UNICODE_ENABLED)
41985: int mem_base;
41986: int ret_val;
41987: int code; /* UCS code point */
41988: int n_code;
41989:
41990: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41991: mem_base = xmlMemBlocks();
41992: code = gen_int(n_code, 0);
41993:
41994: ret_val = xmlUCSIsSyriac(code);
41995: desret_int(ret_val);
41996: call_tests++;
41997: des_int(n_code, code, 0);
41998: xmlResetLastError();
41999: if (mem_base != xmlMemBlocks()) {
42000: printf("Leak of %d blocks found in xmlUCSIsSyriac",
42001: xmlMemBlocks() - mem_base);
42002: test_ret++;
42003: printf(" %d", n_code);
42004: printf("\n");
42005: }
42006: }
42007: function_tests++;
42008: #endif
42009:
42010: return(test_ret);
42011: }
42012:
42013:
42014: static int
42015: test_xmlUCSIsTagalog(void) {
42016: int test_ret = 0;
42017:
42018: #if defined(LIBXML_UNICODE_ENABLED)
42019: int mem_base;
42020: int ret_val;
42021: int code; /* UCS code point */
42022: int n_code;
42023:
42024: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42025: mem_base = xmlMemBlocks();
42026: code = gen_int(n_code, 0);
42027:
42028: ret_val = xmlUCSIsTagalog(code);
42029: desret_int(ret_val);
42030: call_tests++;
42031: des_int(n_code, code, 0);
42032: xmlResetLastError();
42033: if (mem_base != xmlMemBlocks()) {
42034: printf("Leak of %d blocks found in xmlUCSIsTagalog",
42035: xmlMemBlocks() - mem_base);
42036: test_ret++;
42037: printf(" %d", n_code);
42038: printf("\n");
42039: }
42040: }
42041: function_tests++;
42042: #endif
42043:
42044: return(test_ret);
42045: }
42046:
42047:
42048: static int
42049: test_xmlUCSIsTagbanwa(void) {
42050: int test_ret = 0;
42051:
42052: #if defined(LIBXML_UNICODE_ENABLED)
42053: int mem_base;
42054: int ret_val;
42055: int code; /* UCS code point */
42056: int n_code;
42057:
42058: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42059: mem_base = xmlMemBlocks();
42060: code = gen_int(n_code, 0);
42061:
42062: ret_val = xmlUCSIsTagbanwa(code);
42063: desret_int(ret_val);
42064: call_tests++;
42065: des_int(n_code, code, 0);
42066: xmlResetLastError();
42067: if (mem_base != xmlMemBlocks()) {
42068: printf("Leak of %d blocks found in xmlUCSIsTagbanwa",
42069: xmlMemBlocks() - mem_base);
42070: test_ret++;
42071: printf(" %d", n_code);
42072: printf("\n");
42073: }
42074: }
42075: function_tests++;
42076: #endif
42077:
42078: return(test_ret);
42079: }
42080:
42081:
42082: static int
42083: test_xmlUCSIsTags(void) {
42084: int test_ret = 0;
42085:
42086: #if defined(LIBXML_UNICODE_ENABLED)
42087: int mem_base;
42088: int ret_val;
42089: int code; /* UCS code point */
42090: int n_code;
42091:
42092: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42093: mem_base = xmlMemBlocks();
42094: code = gen_int(n_code, 0);
42095:
42096: ret_val = xmlUCSIsTags(code);
42097: desret_int(ret_val);
42098: call_tests++;
42099: des_int(n_code, code, 0);
42100: xmlResetLastError();
42101: if (mem_base != xmlMemBlocks()) {
42102: printf("Leak of %d blocks found in xmlUCSIsTags",
42103: xmlMemBlocks() - mem_base);
42104: test_ret++;
42105: printf(" %d", n_code);
42106: printf("\n");
42107: }
42108: }
42109: function_tests++;
42110: #endif
42111:
42112: return(test_ret);
42113: }
42114:
42115:
42116: static int
42117: test_xmlUCSIsTaiLe(void) {
42118: int test_ret = 0;
42119:
42120: #if defined(LIBXML_UNICODE_ENABLED)
42121: int mem_base;
42122: int ret_val;
42123: int code; /* UCS code point */
42124: int n_code;
42125:
42126: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42127: mem_base = xmlMemBlocks();
42128: code = gen_int(n_code, 0);
42129:
42130: ret_val = xmlUCSIsTaiLe(code);
42131: desret_int(ret_val);
42132: call_tests++;
42133: des_int(n_code, code, 0);
42134: xmlResetLastError();
42135: if (mem_base != xmlMemBlocks()) {
42136: printf("Leak of %d blocks found in xmlUCSIsTaiLe",
42137: xmlMemBlocks() - mem_base);
42138: test_ret++;
42139: printf(" %d", n_code);
42140: printf("\n");
42141: }
42142: }
42143: function_tests++;
42144: #endif
42145:
42146: return(test_ret);
42147: }
42148:
42149:
42150: static int
42151: test_xmlUCSIsTaiXuanJingSymbols(void) {
42152: int test_ret = 0;
42153:
42154: #if defined(LIBXML_UNICODE_ENABLED)
42155: int mem_base;
42156: int ret_val;
42157: int code; /* UCS code point */
42158: int n_code;
42159:
42160: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42161: mem_base = xmlMemBlocks();
42162: code = gen_int(n_code, 0);
42163:
42164: ret_val = xmlUCSIsTaiXuanJingSymbols(code);
42165: desret_int(ret_val);
42166: call_tests++;
42167: des_int(n_code, code, 0);
42168: xmlResetLastError();
42169: if (mem_base != xmlMemBlocks()) {
42170: printf("Leak of %d blocks found in xmlUCSIsTaiXuanJingSymbols",
42171: xmlMemBlocks() - mem_base);
42172: test_ret++;
42173: printf(" %d", n_code);
42174: printf("\n");
42175: }
42176: }
42177: function_tests++;
42178: #endif
42179:
42180: return(test_ret);
42181: }
42182:
42183:
42184: static int
42185: test_xmlUCSIsTamil(void) {
42186: int test_ret = 0;
42187:
42188: #if defined(LIBXML_UNICODE_ENABLED)
42189: int mem_base;
42190: int ret_val;
42191: int code; /* UCS code point */
42192: int n_code;
42193:
42194: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42195: mem_base = xmlMemBlocks();
42196: code = gen_int(n_code, 0);
42197:
42198: ret_val = xmlUCSIsTamil(code);
42199: desret_int(ret_val);
42200: call_tests++;
42201: des_int(n_code, code, 0);
42202: xmlResetLastError();
42203: if (mem_base != xmlMemBlocks()) {
42204: printf("Leak of %d blocks found in xmlUCSIsTamil",
42205: xmlMemBlocks() - mem_base);
42206: test_ret++;
42207: printf(" %d", n_code);
42208: printf("\n");
42209: }
42210: }
42211: function_tests++;
42212: #endif
42213:
42214: return(test_ret);
42215: }
42216:
42217:
42218: static int
42219: test_xmlUCSIsTelugu(void) {
42220: int test_ret = 0;
42221:
42222: #if defined(LIBXML_UNICODE_ENABLED)
42223: int mem_base;
42224: int ret_val;
42225: int code; /* UCS code point */
42226: int n_code;
42227:
42228: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42229: mem_base = xmlMemBlocks();
42230: code = gen_int(n_code, 0);
42231:
42232: ret_val = xmlUCSIsTelugu(code);
42233: desret_int(ret_val);
42234: call_tests++;
42235: des_int(n_code, code, 0);
42236: xmlResetLastError();
42237: if (mem_base != xmlMemBlocks()) {
42238: printf("Leak of %d blocks found in xmlUCSIsTelugu",
42239: xmlMemBlocks() - mem_base);
42240: test_ret++;
42241: printf(" %d", n_code);
42242: printf("\n");
42243: }
42244: }
42245: function_tests++;
42246: #endif
42247:
42248: return(test_ret);
42249: }
42250:
42251:
42252: static int
42253: test_xmlUCSIsThaana(void) {
42254: int test_ret = 0;
42255:
42256: #if defined(LIBXML_UNICODE_ENABLED)
42257: int mem_base;
42258: int ret_val;
42259: int code; /* UCS code point */
42260: int n_code;
42261:
42262: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42263: mem_base = xmlMemBlocks();
42264: code = gen_int(n_code, 0);
42265:
42266: ret_val = xmlUCSIsThaana(code);
42267: desret_int(ret_val);
42268: call_tests++;
42269: des_int(n_code, code, 0);
42270: xmlResetLastError();
42271: if (mem_base != xmlMemBlocks()) {
42272: printf("Leak of %d blocks found in xmlUCSIsThaana",
42273: xmlMemBlocks() - mem_base);
42274: test_ret++;
42275: printf(" %d", n_code);
42276: printf("\n");
42277: }
42278: }
42279: function_tests++;
42280: #endif
42281:
42282: return(test_ret);
42283: }
42284:
42285:
42286: static int
42287: test_xmlUCSIsThai(void) {
42288: int test_ret = 0;
42289:
42290: #if defined(LIBXML_UNICODE_ENABLED)
42291: int mem_base;
42292: int ret_val;
42293: int code; /* UCS code point */
42294: int n_code;
42295:
42296: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42297: mem_base = xmlMemBlocks();
42298: code = gen_int(n_code, 0);
42299:
42300: ret_val = xmlUCSIsThai(code);
42301: desret_int(ret_val);
42302: call_tests++;
42303: des_int(n_code, code, 0);
42304: xmlResetLastError();
42305: if (mem_base != xmlMemBlocks()) {
42306: printf("Leak of %d blocks found in xmlUCSIsThai",
42307: xmlMemBlocks() - mem_base);
42308: test_ret++;
42309: printf(" %d", n_code);
42310: printf("\n");
42311: }
42312: }
42313: function_tests++;
42314: #endif
42315:
42316: return(test_ret);
42317: }
42318:
42319:
42320: static int
42321: test_xmlUCSIsTibetan(void) {
42322: int test_ret = 0;
42323:
42324: #if defined(LIBXML_UNICODE_ENABLED)
42325: int mem_base;
42326: int ret_val;
42327: int code; /* UCS code point */
42328: int n_code;
42329:
42330: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42331: mem_base = xmlMemBlocks();
42332: code = gen_int(n_code, 0);
42333:
42334: ret_val = xmlUCSIsTibetan(code);
42335: desret_int(ret_val);
42336: call_tests++;
42337: des_int(n_code, code, 0);
42338: xmlResetLastError();
42339: if (mem_base != xmlMemBlocks()) {
42340: printf("Leak of %d blocks found in xmlUCSIsTibetan",
42341: xmlMemBlocks() - mem_base);
42342: test_ret++;
42343: printf(" %d", n_code);
42344: printf("\n");
42345: }
42346: }
42347: function_tests++;
42348: #endif
42349:
42350: return(test_ret);
42351: }
42352:
42353:
42354: static int
42355: test_xmlUCSIsUgaritic(void) {
42356: int test_ret = 0;
42357:
42358: #if defined(LIBXML_UNICODE_ENABLED)
42359: int mem_base;
42360: int ret_val;
42361: int code; /* UCS code point */
42362: int n_code;
42363:
42364: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42365: mem_base = xmlMemBlocks();
42366: code = gen_int(n_code, 0);
42367:
42368: ret_val = xmlUCSIsUgaritic(code);
42369: desret_int(ret_val);
42370: call_tests++;
42371: des_int(n_code, code, 0);
42372: xmlResetLastError();
42373: if (mem_base != xmlMemBlocks()) {
42374: printf("Leak of %d blocks found in xmlUCSIsUgaritic",
42375: xmlMemBlocks() - mem_base);
42376: test_ret++;
42377: printf(" %d", n_code);
42378: printf("\n");
42379: }
42380: }
42381: function_tests++;
42382: #endif
42383:
42384: return(test_ret);
42385: }
42386:
42387:
42388: static int
42389: test_xmlUCSIsUnifiedCanadianAboriginalSyllabics(void) {
42390: int test_ret = 0;
42391:
42392: #if defined(LIBXML_UNICODE_ENABLED)
42393: int mem_base;
42394: int ret_val;
42395: int code; /* UCS code point */
42396: int n_code;
42397:
42398: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42399: mem_base = xmlMemBlocks();
42400: code = gen_int(n_code, 0);
42401:
42402: ret_val = xmlUCSIsUnifiedCanadianAboriginalSyllabics(code);
42403: desret_int(ret_val);
42404: call_tests++;
42405: des_int(n_code, code, 0);
42406: xmlResetLastError();
42407: if (mem_base != xmlMemBlocks()) {
42408: printf("Leak of %d blocks found in xmlUCSIsUnifiedCanadianAboriginalSyllabics",
42409: xmlMemBlocks() - mem_base);
42410: test_ret++;
42411: printf(" %d", n_code);
42412: printf("\n");
42413: }
42414: }
42415: function_tests++;
42416: #endif
42417:
42418: return(test_ret);
42419: }
42420:
42421:
42422: static int
42423: test_xmlUCSIsVariationSelectors(void) {
42424: int test_ret = 0;
42425:
42426: #if defined(LIBXML_UNICODE_ENABLED)
42427: int mem_base;
42428: int ret_val;
42429: int code; /* UCS code point */
42430: int n_code;
42431:
42432: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42433: mem_base = xmlMemBlocks();
42434: code = gen_int(n_code, 0);
42435:
42436: ret_val = xmlUCSIsVariationSelectors(code);
42437: desret_int(ret_val);
42438: call_tests++;
42439: des_int(n_code, code, 0);
42440: xmlResetLastError();
42441: if (mem_base != xmlMemBlocks()) {
42442: printf("Leak of %d blocks found in xmlUCSIsVariationSelectors",
42443: xmlMemBlocks() - mem_base);
42444: test_ret++;
42445: printf(" %d", n_code);
42446: printf("\n");
42447: }
42448: }
42449: function_tests++;
42450: #endif
42451:
42452: return(test_ret);
42453: }
42454:
42455:
42456: static int
42457: test_xmlUCSIsVariationSelectorsSupplement(void) {
42458: int test_ret = 0;
42459:
42460: #if defined(LIBXML_UNICODE_ENABLED)
42461: int mem_base;
42462: int ret_val;
42463: int code; /* UCS code point */
42464: int n_code;
42465:
42466: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42467: mem_base = xmlMemBlocks();
42468: code = gen_int(n_code, 0);
42469:
42470: ret_val = xmlUCSIsVariationSelectorsSupplement(code);
42471: desret_int(ret_val);
42472: call_tests++;
42473: des_int(n_code, code, 0);
42474: xmlResetLastError();
42475: if (mem_base != xmlMemBlocks()) {
42476: printf("Leak of %d blocks found in xmlUCSIsVariationSelectorsSupplement",
42477: xmlMemBlocks() - mem_base);
42478: test_ret++;
42479: printf(" %d", n_code);
42480: printf("\n");
42481: }
42482: }
42483: function_tests++;
42484: #endif
42485:
42486: return(test_ret);
42487: }
42488:
42489:
42490: static int
42491: test_xmlUCSIsYiRadicals(void) {
42492: int test_ret = 0;
42493:
42494: #if defined(LIBXML_UNICODE_ENABLED)
42495: int mem_base;
42496: int ret_val;
42497: int code; /* UCS code point */
42498: int n_code;
42499:
42500: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42501: mem_base = xmlMemBlocks();
42502: code = gen_int(n_code, 0);
42503:
42504: ret_val = xmlUCSIsYiRadicals(code);
42505: desret_int(ret_val);
42506: call_tests++;
42507: des_int(n_code, code, 0);
42508: xmlResetLastError();
42509: if (mem_base != xmlMemBlocks()) {
42510: printf("Leak of %d blocks found in xmlUCSIsYiRadicals",
42511: xmlMemBlocks() - mem_base);
42512: test_ret++;
42513: printf(" %d", n_code);
42514: printf("\n");
42515: }
42516: }
42517: function_tests++;
42518: #endif
42519:
42520: return(test_ret);
42521: }
42522:
42523:
42524: static int
42525: test_xmlUCSIsYiSyllables(void) {
42526: int test_ret = 0;
42527:
42528: #if defined(LIBXML_UNICODE_ENABLED)
42529: int mem_base;
42530: int ret_val;
42531: int code; /* UCS code point */
42532: int n_code;
42533:
42534: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42535: mem_base = xmlMemBlocks();
42536: code = gen_int(n_code, 0);
42537:
42538: ret_val = xmlUCSIsYiSyllables(code);
42539: desret_int(ret_val);
42540: call_tests++;
42541: des_int(n_code, code, 0);
42542: xmlResetLastError();
42543: if (mem_base != xmlMemBlocks()) {
42544: printf("Leak of %d blocks found in xmlUCSIsYiSyllables",
42545: xmlMemBlocks() - mem_base);
42546: test_ret++;
42547: printf(" %d", n_code);
42548: printf("\n");
42549: }
42550: }
42551: function_tests++;
42552: #endif
42553:
42554: return(test_ret);
42555: }
42556:
42557:
42558: static int
42559: test_xmlUCSIsYijingHexagramSymbols(void) {
42560: int test_ret = 0;
42561:
42562: #if defined(LIBXML_UNICODE_ENABLED)
42563: int mem_base;
42564: int ret_val;
42565: int code; /* UCS code point */
42566: int n_code;
42567:
42568: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42569: mem_base = xmlMemBlocks();
42570: code = gen_int(n_code, 0);
42571:
42572: ret_val = xmlUCSIsYijingHexagramSymbols(code);
42573: desret_int(ret_val);
42574: call_tests++;
42575: des_int(n_code, code, 0);
42576: xmlResetLastError();
42577: if (mem_base != xmlMemBlocks()) {
42578: printf("Leak of %d blocks found in xmlUCSIsYijingHexagramSymbols",
42579: xmlMemBlocks() - mem_base);
42580: test_ret++;
42581: printf(" %d", n_code);
42582: printf("\n");
42583: }
42584: }
42585: function_tests++;
42586: #endif
42587:
42588: return(test_ret);
42589: }
42590:
42591: static int
42592: test_xmlunicode(void) {
42593: int test_ret = 0;
42594:
42595: if (quiet == 0) printf("Testing xmlunicode : 166 of 166 functions ...\n");
42596: test_ret += test_xmlUCSIsAegeanNumbers();
42597: test_ret += test_xmlUCSIsAlphabeticPresentationForms();
42598: test_ret += test_xmlUCSIsArabic();
42599: test_ret += test_xmlUCSIsArabicPresentationFormsA();
42600: test_ret += test_xmlUCSIsArabicPresentationFormsB();
42601: test_ret += test_xmlUCSIsArmenian();
42602: test_ret += test_xmlUCSIsArrows();
42603: test_ret += test_xmlUCSIsBasicLatin();
42604: test_ret += test_xmlUCSIsBengali();
42605: test_ret += test_xmlUCSIsBlock();
42606: test_ret += test_xmlUCSIsBlockElements();
42607: test_ret += test_xmlUCSIsBopomofo();
42608: test_ret += test_xmlUCSIsBopomofoExtended();
42609: test_ret += test_xmlUCSIsBoxDrawing();
42610: test_ret += test_xmlUCSIsBraillePatterns();
42611: test_ret += test_xmlUCSIsBuhid();
42612: test_ret += test_xmlUCSIsByzantineMusicalSymbols();
42613: test_ret += test_xmlUCSIsCJKCompatibility();
42614: test_ret += test_xmlUCSIsCJKCompatibilityForms();
42615: test_ret += test_xmlUCSIsCJKCompatibilityIdeographs();
42616: test_ret += test_xmlUCSIsCJKCompatibilityIdeographsSupplement();
42617: test_ret += test_xmlUCSIsCJKRadicalsSupplement();
42618: test_ret += test_xmlUCSIsCJKSymbolsandPunctuation();
42619: test_ret += test_xmlUCSIsCJKUnifiedIdeographs();
42620: test_ret += test_xmlUCSIsCJKUnifiedIdeographsExtensionA();
42621: test_ret += test_xmlUCSIsCJKUnifiedIdeographsExtensionB();
42622: test_ret += test_xmlUCSIsCat();
42623: test_ret += test_xmlUCSIsCatC();
42624: test_ret += test_xmlUCSIsCatCc();
42625: test_ret += test_xmlUCSIsCatCf();
42626: test_ret += test_xmlUCSIsCatCo();
42627: test_ret += test_xmlUCSIsCatCs();
42628: test_ret += test_xmlUCSIsCatL();
42629: test_ret += test_xmlUCSIsCatLl();
42630: test_ret += test_xmlUCSIsCatLm();
42631: test_ret += test_xmlUCSIsCatLo();
42632: test_ret += test_xmlUCSIsCatLt();
42633: test_ret += test_xmlUCSIsCatLu();
42634: test_ret += test_xmlUCSIsCatM();
42635: test_ret += test_xmlUCSIsCatMc();
42636: test_ret += test_xmlUCSIsCatMe();
42637: test_ret += test_xmlUCSIsCatMn();
42638: test_ret += test_xmlUCSIsCatN();
42639: test_ret += test_xmlUCSIsCatNd();
42640: test_ret += test_xmlUCSIsCatNl();
42641: test_ret += test_xmlUCSIsCatNo();
42642: test_ret += test_xmlUCSIsCatP();
42643: test_ret += test_xmlUCSIsCatPc();
42644: test_ret += test_xmlUCSIsCatPd();
42645: test_ret += test_xmlUCSIsCatPe();
42646: test_ret += test_xmlUCSIsCatPf();
42647: test_ret += test_xmlUCSIsCatPi();
42648: test_ret += test_xmlUCSIsCatPo();
42649: test_ret += test_xmlUCSIsCatPs();
42650: test_ret += test_xmlUCSIsCatS();
42651: test_ret += test_xmlUCSIsCatSc();
42652: test_ret += test_xmlUCSIsCatSk();
42653: test_ret += test_xmlUCSIsCatSm();
42654: test_ret += test_xmlUCSIsCatSo();
42655: test_ret += test_xmlUCSIsCatZ();
42656: test_ret += test_xmlUCSIsCatZl();
42657: test_ret += test_xmlUCSIsCatZp();
42658: test_ret += test_xmlUCSIsCatZs();
42659: test_ret += test_xmlUCSIsCherokee();
42660: test_ret += test_xmlUCSIsCombiningDiacriticalMarks();
42661: test_ret += test_xmlUCSIsCombiningDiacriticalMarksforSymbols();
42662: test_ret += test_xmlUCSIsCombiningHalfMarks();
42663: test_ret += test_xmlUCSIsCombiningMarksforSymbols();
42664: test_ret += test_xmlUCSIsControlPictures();
42665: test_ret += test_xmlUCSIsCurrencySymbols();
42666: test_ret += test_xmlUCSIsCypriotSyllabary();
42667: test_ret += test_xmlUCSIsCyrillic();
42668: test_ret += test_xmlUCSIsCyrillicSupplement();
42669: test_ret += test_xmlUCSIsDeseret();
42670: test_ret += test_xmlUCSIsDevanagari();
42671: test_ret += test_xmlUCSIsDingbats();
42672: test_ret += test_xmlUCSIsEnclosedAlphanumerics();
42673: test_ret += test_xmlUCSIsEnclosedCJKLettersandMonths();
42674: test_ret += test_xmlUCSIsEthiopic();
42675: test_ret += test_xmlUCSIsGeneralPunctuation();
42676: test_ret += test_xmlUCSIsGeometricShapes();
42677: test_ret += test_xmlUCSIsGeorgian();
42678: test_ret += test_xmlUCSIsGothic();
42679: test_ret += test_xmlUCSIsGreek();
42680: test_ret += test_xmlUCSIsGreekExtended();
42681: test_ret += test_xmlUCSIsGreekandCoptic();
42682: test_ret += test_xmlUCSIsGujarati();
42683: test_ret += test_xmlUCSIsGurmukhi();
42684: test_ret += test_xmlUCSIsHalfwidthandFullwidthForms();
42685: test_ret += test_xmlUCSIsHangulCompatibilityJamo();
42686: test_ret += test_xmlUCSIsHangulJamo();
42687: test_ret += test_xmlUCSIsHangulSyllables();
42688: test_ret += test_xmlUCSIsHanunoo();
42689: test_ret += test_xmlUCSIsHebrew();
42690: test_ret += test_xmlUCSIsHighPrivateUseSurrogates();
42691: test_ret += test_xmlUCSIsHighSurrogates();
42692: test_ret += test_xmlUCSIsHiragana();
42693: test_ret += test_xmlUCSIsIPAExtensions();
42694: test_ret += test_xmlUCSIsIdeographicDescriptionCharacters();
42695: test_ret += test_xmlUCSIsKanbun();
42696: test_ret += test_xmlUCSIsKangxiRadicals();
42697: test_ret += test_xmlUCSIsKannada();
42698: test_ret += test_xmlUCSIsKatakana();
42699: test_ret += test_xmlUCSIsKatakanaPhoneticExtensions();
42700: test_ret += test_xmlUCSIsKhmer();
42701: test_ret += test_xmlUCSIsKhmerSymbols();
42702: test_ret += test_xmlUCSIsLao();
42703: test_ret += test_xmlUCSIsLatin1Supplement();
42704: test_ret += test_xmlUCSIsLatinExtendedA();
42705: test_ret += test_xmlUCSIsLatinExtendedAdditional();
42706: test_ret += test_xmlUCSIsLatinExtendedB();
42707: test_ret += test_xmlUCSIsLetterlikeSymbols();
42708: test_ret += test_xmlUCSIsLimbu();
42709: test_ret += test_xmlUCSIsLinearBIdeograms();
42710: test_ret += test_xmlUCSIsLinearBSyllabary();
42711: test_ret += test_xmlUCSIsLowSurrogates();
42712: test_ret += test_xmlUCSIsMalayalam();
42713: test_ret += test_xmlUCSIsMathematicalAlphanumericSymbols();
42714: test_ret += test_xmlUCSIsMathematicalOperators();
42715: test_ret += test_xmlUCSIsMiscellaneousMathematicalSymbolsA();
42716: test_ret += test_xmlUCSIsMiscellaneousMathematicalSymbolsB();
42717: test_ret += test_xmlUCSIsMiscellaneousSymbols();
42718: test_ret += test_xmlUCSIsMiscellaneousSymbolsandArrows();
42719: test_ret += test_xmlUCSIsMiscellaneousTechnical();
42720: test_ret += test_xmlUCSIsMongolian();
42721: test_ret += test_xmlUCSIsMusicalSymbols();
42722: test_ret += test_xmlUCSIsMyanmar();
42723: test_ret += test_xmlUCSIsNumberForms();
42724: test_ret += test_xmlUCSIsOgham();
42725: test_ret += test_xmlUCSIsOldItalic();
42726: test_ret += test_xmlUCSIsOpticalCharacterRecognition();
42727: test_ret += test_xmlUCSIsOriya();
42728: test_ret += test_xmlUCSIsOsmanya();
42729: test_ret += test_xmlUCSIsPhoneticExtensions();
42730: test_ret += test_xmlUCSIsPrivateUse();
42731: test_ret += test_xmlUCSIsPrivateUseArea();
42732: test_ret += test_xmlUCSIsRunic();
42733: test_ret += test_xmlUCSIsShavian();
42734: test_ret += test_xmlUCSIsSinhala();
42735: test_ret += test_xmlUCSIsSmallFormVariants();
42736: test_ret += test_xmlUCSIsSpacingModifierLetters();
42737: test_ret += test_xmlUCSIsSpecials();
42738: test_ret += test_xmlUCSIsSuperscriptsandSubscripts();
42739: test_ret += test_xmlUCSIsSupplementalArrowsA();
42740: test_ret += test_xmlUCSIsSupplementalArrowsB();
42741: test_ret += test_xmlUCSIsSupplementalMathematicalOperators();
42742: test_ret += test_xmlUCSIsSupplementaryPrivateUseAreaA();
42743: test_ret += test_xmlUCSIsSupplementaryPrivateUseAreaB();
42744: test_ret += test_xmlUCSIsSyriac();
42745: test_ret += test_xmlUCSIsTagalog();
42746: test_ret += test_xmlUCSIsTagbanwa();
42747: test_ret += test_xmlUCSIsTags();
42748: test_ret += test_xmlUCSIsTaiLe();
42749: test_ret += test_xmlUCSIsTaiXuanJingSymbols();
42750: test_ret += test_xmlUCSIsTamil();
42751: test_ret += test_xmlUCSIsTelugu();
42752: test_ret += test_xmlUCSIsThaana();
42753: test_ret += test_xmlUCSIsThai();
42754: test_ret += test_xmlUCSIsTibetan();
42755: test_ret += test_xmlUCSIsUgaritic();
42756: test_ret += test_xmlUCSIsUnifiedCanadianAboriginalSyllabics();
42757: test_ret += test_xmlUCSIsVariationSelectors();
42758: test_ret += test_xmlUCSIsVariationSelectorsSupplement();
42759: test_ret += test_xmlUCSIsYiRadicals();
42760: test_ret += test_xmlUCSIsYiSyllables();
42761: test_ret += test_xmlUCSIsYijingHexagramSymbols();
42762:
42763: if (test_ret != 0)
42764: printf("Module xmlunicode: %d errors\n", test_ret);
42765: return(test_ret);
42766: }
42767:
42768: static int
42769: test_xmlNewTextWriter(void) {
42770: int test_ret = 0;
42771:
42772: #if defined(LIBXML_WRITER_ENABLED)
42773: int mem_base;
42774: xmlTextWriterPtr ret_val;
42775: xmlOutputBufferPtr out; /* an xmlOutputBufferPtr */
42776: int n_out;
42777:
42778: for (n_out = 0;n_out < gen_nb_xmlOutputBufferPtr;n_out++) {
42779: mem_base = xmlMemBlocks();
42780: out = gen_xmlOutputBufferPtr(n_out, 0);
42781:
42782: ret_val = xmlNewTextWriter(out);
42783: if (ret_val != NULL) out = NULL;
42784: desret_xmlTextWriterPtr(ret_val);
42785: call_tests++;
42786: des_xmlOutputBufferPtr(n_out, out, 0);
42787: xmlResetLastError();
42788: if (mem_base != xmlMemBlocks()) {
42789: printf("Leak of %d blocks found in xmlNewTextWriter",
42790: xmlMemBlocks() - mem_base);
42791: test_ret++;
42792: printf(" %d", n_out);
42793: printf("\n");
42794: }
42795: }
42796: function_tests++;
42797: #endif
42798:
42799: return(test_ret);
42800: }
42801:
42802:
42803: static int
42804: test_xmlNewTextWriterFilename(void) {
42805: int test_ret = 0;
42806:
42807: #if defined(LIBXML_WRITER_ENABLED)
42808: int mem_base;
42809: xmlTextWriterPtr ret_val;
42810: const char * uri; /* the URI of the resource for the output */
42811: int n_uri;
42812: int compression; /* compress the output? */
42813: int n_compression;
42814:
42815: for (n_uri = 0;n_uri < gen_nb_fileoutput;n_uri++) {
42816: for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
42817: mem_base = xmlMemBlocks();
42818: uri = gen_fileoutput(n_uri, 0);
42819: compression = gen_int(n_compression, 1);
42820:
42821: ret_val = xmlNewTextWriterFilename(uri, compression);
42822: desret_xmlTextWriterPtr(ret_val);
42823: call_tests++;
42824: des_fileoutput(n_uri, uri, 0);
42825: des_int(n_compression, compression, 1);
42826: xmlResetLastError();
42827: if (mem_base != xmlMemBlocks()) {
42828: printf("Leak of %d blocks found in xmlNewTextWriterFilename",
42829: xmlMemBlocks() - mem_base);
42830: test_ret++;
42831: printf(" %d", n_uri);
42832: printf(" %d", n_compression);
42833: printf("\n");
42834: }
42835: }
42836: }
42837: function_tests++;
42838: #endif
42839:
42840: return(test_ret);
42841: }
42842:
42843:
42844: static int
42845: test_xmlNewTextWriterMemory(void) {
42846: int test_ret = 0;
42847:
42848: #if defined(LIBXML_WRITER_ENABLED)
42849: int mem_base;
42850: xmlTextWriterPtr ret_val;
42851: xmlBufferPtr buf; /* xmlBufferPtr */
42852: int n_buf;
42853: int compression; /* compress the output? */
42854: int n_compression;
42855:
42856: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
42857: for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
42858: mem_base = xmlMemBlocks();
42859: buf = gen_xmlBufferPtr(n_buf, 0);
42860: compression = gen_int(n_compression, 1);
42861:
42862: ret_val = xmlNewTextWriterMemory(buf, compression);
42863: desret_xmlTextWriterPtr(ret_val);
42864: call_tests++;
42865: des_xmlBufferPtr(n_buf, buf, 0);
42866: des_int(n_compression, compression, 1);
42867: xmlResetLastError();
42868: if (mem_base != xmlMemBlocks()) {
42869: printf("Leak of %d blocks found in xmlNewTextWriterMemory",
42870: xmlMemBlocks() - mem_base);
42871: test_ret++;
42872: printf(" %d", n_buf);
42873: printf(" %d", n_compression);
42874: printf("\n");
42875: }
42876: }
42877: }
42878: function_tests++;
42879: #endif
42880:
42881: return(test_ret);
42882: }
42883:
42884:
42885: static int
42886: test_xmlNewTextWriterPushParser(void) {
42887: int test_ret = 0;
42888:
42889: #if defined(LIBXML_WRITER_ENABLED)
42890: int mem_base;
42891: xmlTextWriterPtr ret_val;
42892: xmlParserCtxtPtr ctxt; /* xmlParserCtxtPtr to hold the new XML document tree */
42893: int n_ctxt;
42894: int compression; /* compress the output? */
42895: int n_compression;
42896:
42897: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
42898: for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
42899: mem_base = xmlMemBlocks();
42900: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
42901: compression = gen_int(n_compression, 1);
42902:
42903: ret_val = xmlNewTextWriterPushParser(ctxt, compression);
42904: if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;} if (ret_val != NULL) ctxt = NULL;
42905: desret_xmlTextWriterPtr(ret_val);
42906: call_tests++;
42907: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
42908: des_int(n_compression, compression, 1);
42909: xmlResetLastError();
42910: if (mem_base != xmlMemBlocks()) {
42911: printf("Leak of %d blocks found in xmlNewTextWriterPushParser",
42912: xmlMemBlocks() - mem_base);
42913: test_ret++;
42914: printf(" %d", n_ctxt);
42915: printf(" %d", n_compression);
42916: printf("\n");
42917: }
42918: }
42919: }
42920: function_tests++;
42921: #endif
42922:
42923: return(test_ret);
42924: }
42925:
42926:
42927: static int
42928: test_xmlNewTextWriterTree(void) {
42929: int test_ret = 0;
42930:
42931: #if defined(LIBXML_WRITER_ENABLED)
42932: int mem_base;
42933: xmlTextWriterPtr ret_val;
42934: xmlDocPtr doc; /* xmlDocPtr */
42935: int n_doc;
42936: xmlNodePtr node; /* xmlNodePtr or NULL for doc->children */
42937: int n_node;
42938: int compression; /* compress the output? */
42939: int n_compression;
42940:
42941: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
42942: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
42943: for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
42944: mem_base = xmlMemBlocks();
42945: doc = gen_xmlDocPtr(n_doc, 0);
42946: node = gen_xmlNodePtr(n_node, 1);
42947: compression = gen_int(n_compression, 2);
42948:
42949: ret_val = xmlNewTextWriterTree(doc, node, compression);
42950: desret_xmlTextWriterPtr(ret_val);
42951: call_tests++;
42952: des_xmlDocPtr(n_doc, doc, 0);
42953: des_xmlNodePtr(n_node, node, 1);
42954: des_int(n_compression, compression, 2);
42955: xmlResetLastError();
42956: if (mem_base != xmlMemBlocks()) {
42957: printf("Leak of %d blocks found in xmlNewTextWriterTree",
42958: xmlMemBlocks() - mem_base);
42959: test_ret++;
42960: printf(" %d", n_doc);
42961: printf(" %d", n_node);
42962: printf(" %d", n_compression);
42963: printf("\n");
42964: }
42965: }
42966: }
42967: }
42968: function_tests++;
42969: #endif
42970:
42971: return(test_ret);
42972: }
42973:
42974:
42975: static int
42976: test_xmlTextWriterEndAttribute(void) {
42977: int test_ret = 0;
42978:
42979: #if defined(LIBXML_WRITER_ENABLED)
42980: int mem_base;
42981: int ret_val;
42982: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
42983: int n_writer;
42984:
42985: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
42986: mem_base = xmlMemBlocks();
42987: writer = gen_xmlTextWriterPtr(n_writer, 0);
42988:
42989: ret_val = xmlTextWriterEndAttribute(writer);
42990: desret_int(ret_val);
42991: call_tests++;
42992: des_xmlTextWriterPtr(n_writer, writer, 0);
42993: xmlResetLastError();
42994: if (mem_base != xmlMemBlocks()) {
42995: printf("Leak of %d blocks found in xmlTextWriterEndAttribute",
42996: xmlMemBlocks() - mem_base);
42997: test_ret++;
42998: printf(" %d", n_writer);
42999: printf("\n");
43000: }
43001: }
43002: function_tests++;
43003: #endif
43004:
43005: return(test_ret);
43006: }
43007:
43008:
43009: static int
43010: test_xmlTextWriterEndCDATA(void) {
43011: int test_ret = 0;
43012:
43013: #if defined(LIBXML_WRITER_ENABLED)
43014: int mem_base;
43015: int ret_val;
43016: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43017: int n_writer;
43018:
43019: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43020: mem_base = xmlMemBlocks();
43021: writer = gen_xmlTextWriterPtr(n_writer, 0);
43022:
43023: ret_val = xmlTextWriterEndCDATA(writer);
43024: desret_int(ret_val);
43025: call_tests++;
43026: des_xmlTextWriterPtr(n_writer, writer, 0);
43027: xmlResetLastError();
43028: if (mem_base != xmlMemBlocks()) {
43029: printf("Leak of %d blocks found in xmlTextWriterEndCDATA",
43030: xmlMemBlocks() - mem_base);
43031: test_ret++;
43032: printf(" %d", n_writer);
43033: printf("\n");
43034: }
43035: }
43036: function_tests++;
43037: #endif
43038:
43039: return(test_ret);
43040: }
43041:
43042:
43043: static int
43044: test_xmlTextWriterEndComment(void) {
43045: int test_ret = 0;
43046:
43047: #if defined(LIBXML_WRITER_ENABLED)
43048: int mem_base;
43049: int ret_val;
43050: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43051: int n_writer;
43052:
43053: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43054: mem_base = xmlMemBlocks();
43055: writer = gen_xmlTextWriterPtr(n_writer, 0);
43056:
43057: ret_val = xmlTextWriterEndComment(writer);
43058: desret_int(ret_val);
43059: call_tests++;
43060: des_xmlTextWriterPtr(n_writer, writer, 0);
43061: xmlResetLastError();
43062: if (mem_base != xmlMemBlocks()) {
43063: printf("Leak of %d blocks found in xmlTextWriterEndComment",
43064: xmlMemBlocks() - mem_base);
43065: test_ret++;
43066: printf(" %d", n_writer);
43067: printf("\n");
43068: }
43069: }
43070: function_tests++;
43071: #endif
43072:
43073: return(test_ret);
43074: }
43075:
43076:
43077: static int
43078: test_xmlTextWriterEndDTD(void) {
43079: int test_ret = 0;
43080:
43081: #if defined(LIBXML_WRITER_ENABLED)
43082: int mem_base;
43083: int ret_val;
43084: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43085: int n_writer;
43086:
43087: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43088: mem_base = xmlMemBlocks();
43089: writer = gen_xmlTextWriterPtr(n_writer, 0);
43090:
43091: ret_val = xmlTextWriterEndDTD(writer);
43092: desret_int(ret_val);
43093: call_tests++;
43094: des_xmlTextWriterPtr(n_writer, writer, 0);
43095: xmlResetLastError();
43096: if (mem_base != xmlMemBlocks()) {
43097: printf("Leak of %d blocks found in xmlTextWriterEndDTD",
43098: xmlMemBlocks() - mem_base);
43099: test_ret++;
43100: printf(" %d", n_writer);
43101: printf("\n");
43102: }
43103: }
43104: function_tests++;
43105: #endif
43106:
43107: return(test_ret);
43108: }
43109:
43110:
43111: static int
43112: test_xmlTextWriterEndDTDAttlist(void) {
43113: int test_ret = 0;
43114:
43115: #if defined(LIBXML_WRITER_ENABLED)
43116: int mem_base;
43117: int ret_val;
43118: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43119: int n_writer;
43120:
43121: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43122: mem_base = xmlMemBlocks();
43123: writer = gen_xmlTextWriterPtr(n_writer, 0);
43124:
43125: ret_val = xmlTextWriterEndDTDAttlist(writer);
43126: desret_int(ret_val);
43127: call_tests++;
43128: des_xmlTextWriterPtr(n_writer, writer, 0);
43129: xmlResetLastError();
43130: if (mem_base != xmlMemBlocks()) {
43131: printf("Leak of %d blocks found in xmlTextWriterEndDTDAttlist",
43132: xmlMemBlocks() - mem_base);
43133: test_ret++;
43134: printf(" %d", n_writer);
43135: printf("\n");
43136: }
43137: }
43138: function_tests++;
43139: #endif
43140:
43141: return(test_ret);
43142: }
43143:
43144:
43145: static int
43146: test_xmlTextWriterEndDTDElement(void) {
43147: int test_ret = 0;
43148:
43149: #if defined(LIBXML_WRITER_ENABLED)
43150: int mem_base;
43151: int ret_val;
43152: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43153: int n_writer;
43154:
43155: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43156: mem_base = xmlMemBlocks();
43157: writer = gen_xmlTextWriterPtr(n_writer, 0);
43158:
43159: ret_val = xmlTextWriterEndDTDElement(writer);
43160: desret_int(ret_val);
43161: call_tests++;
43162: des_xmlTextWriterPtr(n_writer, writer, 0);
43163: xmlResetLastError();
43164: if (mem_base != xmlMemBlocks()) {
43165: printf("Leak of %d blocks found in xmlTextWriterEndDTDElement",
43166: xmlMemBlocks() - mem_base);
43167: test_ret++;
43168: printf(" %d", n_writer);
43169: printf("\n");
43170: }
43171: }
43172: function_tests++;
43173: #endif
43174:
43175: return(test_ret);
43176: }
43177:
43178:
43179: static int
43180: test_xmlTextWriterEndDTDEntity(void) {
43181: int test_ret = 0;
43182:
43183: #if defined(LIBXML_WRITER_ENABLED)
43184: int mem_base;
43185: int ret_val;
43186: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43187: int n_writer;
43188:
43189: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43190: mem_base = xmlMemBlocks();
43191: writer = gen_xmlTextWriterPtr(n_writer, 0);
43192:
43193: ret_val = xmlTextWriterEndDTDEntity(writer);
43194: desret_int(ret_val);
43195: call_tests++;
43196: des_xmlTextWriterPtr(n_writer, writer, 0);
43197: xmlResetLastError();
43198: if (mem_base != xmlMemBlocks()) {
43199: printf("Leak of %d blocks found in xmlTextWriterEndDTDEntity",
43200: xmlMemBlocks() - mem_base);
43201: test_ret++;
43202: printf(" %d", n_writer);
43203: printf("\n");
43204: }
43205: }
43206: function_tests++;
43207: #endif
43208:
43209: return(test_ret);
43210: }
43211:
43212:
43213: static int
43214: test_xmlTextWriterEndDocument(void) {
43215: int test_ret = 0;
43216:
43217: #if defined(LIBXML_WRITER_ENABLED)
43218: int mem_base;
43219: int ret_val;
43220: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43221: int n_writer;
43222:
43223: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43224: mem_base = xmlMemBlocks();
43225: writer = gen_xmlTextWriterPtr(n_writer, 0);
43226:
43227: ret_val = xmlTextWriterEndDocument(writer);
43228: desret_int(ret_val);
43229: call_tests++;
43230: des_xmlTextWriterPtr(n_writer, writer, 0);
43231: xmlResetLastError();
43232: if (mem_base != xmlMemBlocks()) {
43233: printf("Leak of %d blocks found in xmlTextWriterEndDocument",
43234: xmlMemBlocks() - mem_base);
43235: test_ret++;
43236: printf(" %d", n_writer);
43237: printf("\n");
43238: }
43239: }
43240: function_tests++;
43241: #endif
43242:
43243: return(test_ret);
43244: }
43245:
43246:
43247: static int
43248: test_xmlTextWriterEndElement(void) {
43249: int test_ret = 0;
43250:
43251: #if defined(LIBXML_WRITER_ENABLED)
43252: int mem_base;
43253: int ret_val;
43254: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43255: int n_writer;
43256:
43257: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43258: mem_base = xmlMemBlocks();
43259: writer = gen_xmlTextWriterPtr(n_writer, 0);
43260:
43261: ret_val = xmlTextWriterEndElement(writer);
43262: desret_int(ret_val);
43263: call_tests++;
43264: des_xmlTextWriterPtr(n_writer, writer, 0);
43265: xmlResetLastError();
43266: if (mem_base != xmlMemBlocks()) {
43267: printf("Leak of %d blocks found in xmlTextWriterEndElement",
43268: xmlMemBlocks() - mem_base);
43269: test_ret++;
43270: printf(" %d", n_writer);
43271: printf("\n");
43272: }
43273: }
43274: function_tests++;
43275: #endif
43276:
43277: return(test_ret);
43278: }
43279:
43280:
43281: static int
43282: test_xmlTextWriterEndPI(void) {
43283: int test_ret = 0;
43284:
43285: #if defined(LIBXML_WRITER_ENABLED)
43286: int mem_base;
43287: int ret_val;
43288: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43289: int n_writer;
43290:
43291: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43292: mem_base = xmlMemBlocks();
43293: writer = gen_xmlTextWriterPtr(n_writer, 0);
43294:
43295: ret_val = xmlTextWriterEndPI(writer);
43296: desret_int(ret_val);
43297: call_tests++;
43298: des_xmlTextWriterPtr(n_writer, writer, 0);
43299: xmlResetLastError();
43300: if (mem_base != xmlMemBlocks()) {
43301: printf("Leak of %d blocks found in xmlTextWriterEndPI",
43302: xmlMemBlocks() - mem_base);
43303: test_ret++;
43304: printf(" %d", n_writer);
43305: printf("\n");
43306: }
43307: }
43308: function_tests++;
43309: #endif
43310:
43311: return(test_ret);
43312: }
43313:
43314:
43315: static int
43316: test_xmlTextWriterFlush(void) {
43317: int test_ret = 0;
43318:
43319: #if defined(LIBXML_WRITER_ENABLED)
43320: int mem_base;
43321: int ret_val;
43322: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43323: int n_writer;
43324:
43325: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43326: mem_base = xmlMemBlocks();
43327: writer = gen_xmlTextWriterPtr(n_writer, 0);
43328:
43329: ret_val = xmlTextWriterFlush(writer);
43330: desret_int(ret_val);
43331: call_tests++;
43332: des_xmlTextWriterPtr(n_writer, writer, 0);
43333: xmlResetLastError();
43334: if (mem_base != xmlMemBlocks()) {
43335: printf("Leak of %d blocks found in xmlTextWriterFlush",
43336: xmlMemBlocks() - mem_base);
43337: test_ret++;
43338: printf(" %d", n_writer);
43339: printf("\n");
43340: }
43341: }
43342: function_tests++;
43343: #endif
43344:
43345: return(test_ret);
43346: }
43347:
43348:
43349: static int
43350: test_xmlTextWriterFullEndElement(void) {
43351: int test_ret = 0;
43352:
43353: #if defined(LIBXML_WRITER_ENABLED)
43354: int mem_base;
43355: int ret_val;
43356: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43357: int n_writer;
43358:
43359: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43360: mem_base = xmlMemBlocks();
43361: writer = gen_xmlTextWriterPtr(n_writer, 0);
43362:
43363: ret_val = xmlTextWriterFullEndElement(writer);
43364: desret_int(ret_val);
43365: call_tests++;
43366: des_xmlTextWriterPtr(n_writer, writer, 0);
43367: xmlResetLastError();
43368: if (mem_base != xmlMemBlocks()) {
43369: printf("Leak of %d blocks found in xmlTextWriterFullEndElement",
43370: xmlMemBlocks() - mem_base);
43371: test_ret++;
43372: printf(" %d", n_writer);
43373: printf("\n");
43374: }
43375: }
43376: function_tests++;
43377: #endif
43378:
43379: return(test_ret);
43380: }
43381:
43382:
43383: static int
43384: test_xmlTextWriterSetIndent(void) {
43385: int test_ret = 0;
43386:
43387: #if defined(LIBXML_WRITER_ENABLED)
43388: int mem_base;
43389: int ret_val;
43390: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43391: int n_writer;
43392: int indent; /* do indentation? */
43393: int n_indent;
43394:
43395: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43396: for (n_indent = 0;n_indent < gen_nb_int;n_indent++) {
43397: mem_base = xmlMemBlocks();
43398: writer = gen_xmlTextWriterPtr(n_writer, 0);
43399: indent = gen_int(n_indent, 1);
43400:
43401: ret_val = xmlTextWriterSetIndent(writer, indent);
43402: desret_int(ret_val);
43403: call_tests++;
43404: des_xmlTextWriterPtr(n_writer, writer, 0);
43405: des_int(n_indent, indent, 1);
43406: xmlResetLastError();
43407: if (mem_base != xmlMemBlocks()) {
43408: printf("Leak of %d blocks found in xmlTextWriterSetIndent",
43409: xmlMemBlocks() - mem_base);
43410: test_ret++;
43411: printf(" %d", n_writer);
43412: printf(" %d", n_indent);
43413: printf("\n");
43414: }
43415: }
43416: }
43417: function_tests++;
43418: #endif
43419:
43420: return(test_ret);
43421: }
43422:
43423:
43424: static int
43425: test_xmlTextWriterSetIndentString(void) {
43426: int test_ret = 0;
43427:
43428: #if defined(LIBXML_WRITER_ENABLED)
43429: int mem_base;
43430: int ret_val;
43431: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43432: int n_writer;
43433: xmlChar * str; /* the xmlChar string */
43434: int n_str;
43435:
43436: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43437: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
43438: mem_base = xmlMemBlocks();
43439: writer = gen_xmlTextWriterPtr(n_writer, 0);
43440: str = gen_const_xmlChar_ptr(n_str, 1);
43441:
43442: ret_val = xmlTextWriterSetIndentString(writer, (const xmlChar *)str);
43443: desret_int(ret_val);
43444: call_tests++;
43445: des_xmlTextWriterPtr(n_writer, writer, 0);
43446: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
43447: xmlResetLastError();
43448: if (mem_base != xmlMemBlocks()) {
43449: printf("Leak of %d blocks found in xmlTextWriterSetIndentString",
43450: xmlMemBlocks() - mem_base);
43451: test_ret++;
43452: printf(" %d", n_writer);
43453: printf(" %d", n_str);
43454: printf("\n");
43455: }
43456: }
43457: }
43458: function_tests++;
43459: #endif
43460:
43461: return(test_ret);
43462: }
43463:
43464:
43465: static int
43466: test_xmlTextWriterStartAttribute(void) {
43467: int test_ret = 0;
43468:
43469: #if defined(LIBXML_WRITER_ENABLED)
43470: int mem_base;
43471: int ret_val;
43472: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43473: int n_writer;
43474: xmlChar * name; /* element name */
43475: int n_name;
43476:
43477: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43478: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
43479: mem_base = xmlMemBlocks();
43480: writer = gen_xmlTextWriterPtr(n_writer, 0);
43481: name = gen_const_xmlChar_ptr(n_name, 1);
43482:
43483: ret_val = xmlTextWriterStartAttribute(writer, (const xmlChar *)name);
43484: desret_int(ret_val);
43485: call_tests++;
43486: des_xmlTextWriterPtr(n_writer, writer, 0);
43487: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
43488: xmlResetLastError();
43489: if (mem_base != xmlMemBlocks()) {
43490: printf("Leak of %d blocks found in xmlTextWriterStartAttribute",
43491: xmlMemBlocks() - mem_base);
43492: test_ret++;
43493: printf(" %d", n_writer);
43494: printf(" %d", n_name);
43495: printf("\n");
43496: }
43497: }
43498: }
43499: function_tests++;
43500: #endif
43501:
43502: return(test_ret);
43503: }
43504:
43505:
43506: static int
43507: test_xmlTextWriterStartAttributeNS(void) {
43508: int test_ret = 0;
43509:
43510: #if defined(LIBXML_WRITER_ENABLED)
43511: int mem_base;
43512: int ret_val;
43513: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43514: int n_writer;
43515: xmlChar * prefix; /* namespace prefix or NULL */
43516: int n_prefix;
43517: xmlChar * name; /* element local name */
43518: int n_name;
43519: xmlChar * namespaceURI; /* namespace URI or NULL */
43520: int n_namespaceURI;
43521:
43522: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43523: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
43524: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
43525: for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
43526: mem_base = xmlMemBlocks();
43527: writer = gen_xmlTextWriterPtr(n_writer, 0);
43528: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
43529: name = gen_const_xmlChar_ptr(n_name, 2);
43530: namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 3);
43531:
43532: ret_val = xmlTextWriterStartAttributeNS(writer, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)namespaceURI);
43533: desret_int(ret_val);
43534: call_tests++;
43535: des_xmlTextWriterPtr(n_writer, writer, 0);
43536: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
43537: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
43538: des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 3);
43539: xmlResetLastError();
43540: if (mem_base != xmlMemBlocks()) {
43541: printf("Leak of %d blocks found in xmlTextWriterStartAttributeNS",
43542: xmlMemBlocks() - mem_base);
43543: test_ret++;
43544: printf(" %d", n_writer);
43545: printf(" %d", n_prefix);
43546: printf(" %d", n_name);
43547: printf(" %d", n_namespaceURI);
43548: printf("\n");
43549: }
43550: }
43551: }
43552: }
43553: }
43554: function_tests++;
43555: #endif
43556:
43557: return(test_ret);
43558: }
43559:
43560:
43561: static int
43562: test_xmlTextWriterStartCDATA(void) {
43563: int test_ret = 0;
43564:
43565: #if defined(LIBXML_WRITER_ENABLED)
43566: int mem_base;
43567: int ret_val;
43568: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43569: int n_writer;
43570:
43571: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43572: mem_base = xmlMemBlocks();
43573: writer = gen_xmlTextWriterPtr(n_writer, 0);
43574:
43575: ret_val = xmlTextWriterStartCDATA(writer);
43576: desret_int(ret_val);
43577: call_tests++;
43578: des_xmlTextWriterPtr(n_writer, writer, 0);
43579: xmlResetLastError();
43580: if (mem_base != xmlMemBlocks()) {
43581: printf("Leak of %d blocks found in xmlTextWriterStartCDATA",
43582: xmlMemBlocks() - mem_base);
43583: test_ret++;
43584: printf(" %d", n_writer);
43585: printf("\n");
43586: }
43587: }
43588: function_tests++;
43589: #endif
43590:
43591: return(test_ret);
43592: }
43593:
43594:
43595: static int
43596: test_xmlTextWriterStartComment(void) {
43597: int test_ret = 0;
43598:
43599: #if defined(LIBXML_WRITER_ENABLED)
43600: int mem_base;
43601: int ret_val;
43602: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43603: int n_writer;
43604:
43605: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43606: mem_base = xmlMemBlocks();
43607: writer = gen_xmlTextWriterPtr(n_writer, 0);
43608:
43609: ret_val = xmlTextWriterStartComment(writer);
43610: desret_int(ret_val);
43611: call_tests++;
43612: des_xmlTextWriterPtr(n_writer, writer, 0);
43613: xmlResetLastError();
43614: if (mem_base != xmlMemBlocks()) {
43615: printf("Leak of %d blocks found in xmlTextWriterStartComment",
43616: xmlMemBlocks() - mem_base);
43617: test_ret++;
43618: printf(" %d", n_writer);
43619: printf("\n");
43620: }
43621: }
43622: function_tests++;
43623: #endif
43624:
43625: return(test_ret);
43626: }
43627:
43628:
43629: static int
43630: test_xmlTextWriterStartDTD(void) {
43631: int test_ret = 0;
43632:
43633: #if defined(LIBXML_WRITER_ENABLED)
43634: int mem_base;
43635: int ret_val;
43636: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43637: int n_writer;
43638: xmlChar * name; /* the name of the DTD */
43639: int n_name;
43640: xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
43641: int n_pubid;
43642: xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
43643: int n_sysid;
43644:
43645: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43646: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
43647: for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
43648: for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
43649: mem_base = xmlMemBlocks();
43650: writer = gen_xmlTextWriterPtr(n_writer, 0);
43651: name = gen_const_xmlChar_ptr(n_name, 1);
43652: pubid = gen_const_xmlChar_ptr(n_pubid, 2);
43653: sysid = gen_const_xmlChar_ptr(n_sysid, 3);
43654:
43655: ret_val = xmlTextWriterStartDTD(writer, (const xmlChar *)name, (const xmlChar *)pubid, (const xmlChar *)sysid);
43656: desret_int(ret_val);
43657: call_tests++;
43658: des_xmlTextWriterPtr(n_writer, writer, 0);
43659: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
43660: des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 2);
43661: des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 3);
43662: xmlResetLastError();
43663: if (mem_base != xmlMemBlocks()) {
43664: printf("Leak of %d blocks found in xmlTextWriterStartDTD",
43665: xmlMemBlocks() - mem_base);
43666: test_ret++;
43667: printf(" %d", n_writer);
43668: printf(" %d", n_name);
43669: printf(" %d", n_pubid);
43670: printf(" %d", n_sysid);
43671: printf("\n");
43672: }
43673: }
43674: }
43675: }
43676: }
43677: function_tests++;
43678: #endif
43679:
43680: return(test_ret);
43681: }
43682:
43683:
43684: static int
43685: test_xmlTextWriterStartDTDAttlist(void) {
43686: int test_ret = 0;
43687:
43688: #if defined(LIBXML_WRITER_ENABLED)
43689: int mem_base;
43690: int ret_val;
43691: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43692: int n_writer;
43693: xmlChar * name; /* the name of the DTD ATTLIST */
43694: int n_name;
43695:
43696: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43697: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
43698: mem_base = xmlMemBlocks();
43699: writer = gen_xmlTextWriterPtr(n_writer, 0);
43700: name = gen_const_xmlChar_ptr(n_name, 1);
43701:
43702: ret_val = xmlTextWriterStartDTDAttlist(writer, (const xmlChar *)name);
43703: desret_int(ret_val);
43704: call_tests++;
43705: des_xmlTextWriterPtr(n_writer, writer, 0);
43706: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
43707: xmlResetLastError();
43708: if (mem_base != xmlMemBlocks()) {
43709: printf("Leak of %d blocks found in xmlTextWriterStartDTDAttlist",
43710: xmlMemBlocks() - mem_base);
43711: test_ret++;
43712: printf(" %d", n_writer);
43713: printf(" %d", n_name);
43714: printf("\n");
43715: }
43716: }
43717: }
43718: function_tests++;
43719: #endif
43720:
43721: return(test_ret);
43722: }
43723:
43724:
43725: static int
43726: test_xmlTextWriterStartDTDElement(void) {
43727: int test_ret = 0;
43728:
43729: #if defined(LIBXML_WRITER_ENABLED)
43730: int mem_base;
43731: int ret_val;
43732: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43733: int n_writer;
43734: xmlChar * name; /* the name of the DTD element */
43735: int n_name;
43736:
43737: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43738: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
43739: mem_base = xmlMemBlocks();
43740: writer = gen_xmlTextWriterPtr(n_writer, 0);
43741: name = gen_const_xmlChar_ptr(n_name, 1);
43742:
43743: ret_val = xmlTextWriterStartDTDElement(writer, (const xmlChar *)name);
43744: desret_int(ret_val);
43745: call_tests++;
43746: des_xmlTextWriterPtr(n_writer, writer, 0);
43747: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
43748: xmlResetLastError();
43749: if (mem_base != xmlMemBlocks()) {
43750: printf("Leak of %d blocks found in xmlTextWriterStartDTDElement",
43751: xmlMemBlocks() - mem_base);
43752: test_ret++;
43753: printf(" %d", n_writer);
43754: printf(" %d", n_name);
43755: printf("\n");
43756: }
43757: }
43758: }
43759: function_tests++;
43760: #endif
43761:
43762: return(test_ret);
43763: }
43764:
43765:
43766: static int
43767: test_xmlTextWriterStartDTDEntity(void) {
43768: int test_ret = 0;
43769:
43770: #if defined(LIBXML_WRITER_ENABLED)
43771: int mem_base;
43772: int ret_val;
43773: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43774: int n_writer;
43775: int pe; /* TRUE if this is a parameter entity, FALSE if not */
43776: int n_pe;
43777: xmlChar * name; /* the name of the DTD ATTLIST */
43778: int n_name;
43779:
43780: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43781: for (n_pe = 0;n_pe < gen_nb_int;n_pe++) {
43782: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
43783: mem_base = xmlMemBlocks();
43784: writer = gen_xmlTextWriterPtr(n_writer, 0);
43785: pe = gen_int(n_pe, 1);
43786: name = gen_const_xmlChar_ptr(n_name, 2);
43787:
43788: ret_val = xmlTextWriterStartDTDEntity(writer, pe, (const xmlChar *)name);
43789: desret_int(ret_val);
43790: call_tests++;
43791: des_xmlTextWriterPtr(n_writer, writer, 0);
43792: des_int(n_pe, pe, 1);
43793: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
43794: xmlResetLastError();
43795: if (mem_base != xmlMemBlocks()) {
43796: printf("Leak of %d blocks found in xmlTextWriterStartDTDEntity",
43797: xmlMemBlocks() - mem_base);
43798: test_ret++;
43799: printf(" %d", n_writer);
43800: printf(" %d", n_pe);
43801: printf(" %d", n_name);
43802: printf("\n");
43803: }
43804: }
43805: }
43806: }
43807: function_tests++;
43808: #endif
43809:
43810: return(test_ret);
43811: }
43812:
43813:
43814: static int
43815: test_xmlTextWriterStartDocument(void) {
43816: int test_ret = 0;
43817:
43818: #if defined(LIBXML_WRITER_ENABLED)
43819: int mem_base;
43820: int ret_val;
43821: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43822: int n_writer;
43823: char * version; /* the xml version ("1.0") or NULL for default ("1.0") */
43824: int n_version;
43825: char * encoding; /* the encoding or NULL for default */
43826: int n_encoding;
43827: char * standalone; /* "yes" or "no" or NULL for default */
43828: int n_standalone;
43829:
43830: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43831: for (n_version = 0;n_version < gen_nb_const_char_ptr;n_version++) {
43832: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
43833: for (n_standalone = 0;n_standalone < gen_nb_const_char_ptr;n_standalone++) {
43834: mem_base = xmlMemBlocks();
43835: writer = gen_xmlTextWriterPtr(n_writer, 0);
43836: version = gen_const_char_ptr(n_version, 1);
43837: encoding = gen_const_char_ptr(n_encoding, 2);
43838: standalone = gen_const_char_ptr(n_standalone, 3);
43839:
43840: ret_val = xmlTextWriterStartDocument(writer, (const char *)version, (const char *)encoding, (const char *)standalone);
43841: desret_int(ret_val);
43842: call_tests++;
43843: des_xmlTextWriterPtr(n_writer, writer, 0);
43844: des_const_char_ptr(n_version, (const char *)version, 1);
43845: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
43846: des_const_char_ptr(n_standalone, (const char *)standalone, 3);
43847: xmlResetLastError();
43848: if (mem_base != xmlMemBlocks()) {
43849: printf("Leak of %d blocks found in xmlTextWriterStartDocument",
43850: xmlMemBlocks() - mem_base);
43851: test_ret++;
43852: printf(" %d", n_writer);
43853: printf(" %d", n_version);
43854: printf(" %d", n_encoding);
43855: printf(" %d", n_standalone);
43856: printf("\n");
43857: }
43858: }
43859: }
43860: }
43861: }
43862: function_tests++;
43863: #endif
43864:
43865: return(test_ret);
43866: }
43867:
43868:
43869: static int
43870: test_xmlTextWriterStartElement(void) {
43871: int test_ret = 0;
43872:
43873: #if defined(LIBXML_WRITER_ENABLED)
43874: int mem_base;
43875: int ret_val;
43876: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43877: int n_writer;
43878: xmlChar * name; /* element name */
43879: int n_name;
43880:
43881: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43882: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
43883: mem_base = xmlMemBlocks();
43884: writer = gen_xmlTextWriterPtr(n_writer, 0);
43885: name = gen_const_xmlChar_ptr(n_name, 1);
43886:
43887: ret_val = xmlTextWriterStartElement(writer, (const xmlChar *)name);
43888: desret_int(ret_val);
43889: call_tests++;
43890: des_xmlTextWriterPtr(n_writer, writer, 0);
43891: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
43892: xmlResetLastError();
43893: if (mem_base != xmlMemBlocks()) {
43894: printf("Leak of %d blocks found in xmlTextWriterStartElement",
43895: xmlMemBlocks() - mem_base);
43896: test_ret++;
43897: printf(" %d", n_writer);
43898: printf(" %d", n_name);
43899: printf("\n");
43900: }
43901: }
43902: }
43903: function_tests++;
43904: #endif
43905:
43906: return(test_ret);
43907: }
43908:
43909:
43910: static int
43911: test_xmlTextWriterStartElementNS(void) {
43912: int test_ret = 0;
43913:
43914: #if defined(LIBXML_WRITER_ENABLED)
43915: int mem_base;
43916: int ret_val;
43917: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43918: int n_writer;
43919: xmlChar * prefix; /* namespace prefix or NULL */
43920: int n_prefix;
43921: xmlChar * name; /* element local name */
43922: int n_name;
43923: xmlChar * namespaceURI; /* namespace URI or NULL */
43924: int n_namespaceURI;
43925:
43926: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43927: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
43928: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
43929: for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
43930: mem_base = xmlMemBlocks();
43931: writer = gen_xmlTextWriterPtr(n_writer, 0);
43932: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
43933: name = gen_const_xmlChar_ptr(n_name, 2);
43934: namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 3);
43935:
43936: ret_val = xmlTextWriterStartElementNS(writer, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)namespaceURI);
43937: desret_int(ret_val);
43938: call_tests++;
43939: des_xmlTextWriterPtr(n_writer, writer, 0);
43940: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
43941: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
43942: des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 3);
43943: xmlResetLastError();
43944: if (mem_base != xmlMemBlocks()) {
43945: printf("Leak of %d blocks found in xmlTextWriterStartElementNS",
43946: xmlMemBlocks() - mem_base);
43947: test_ret++;
43948: printf(" %d", n_writer);
43949: printf(" %d", n_prefix);
43950: printf(" %d", n_name);
43951: printf(" %d", n_namespaceURI);
43952: printf("\n");
43953: }
43954: }
43955: }
43956: }
43957: }
43958: function_tests++;
43959: #endif
43960:
43961: return(test_ret);
43962: }
43963:
43964:
43965: static int
43966: test_xmlTextWriterStartPI(void) {
43967: int test_ret = 0;
43968:
43969: #if defined(LIBXML_WRITER_ENABLED)
43970: int mem_base;
43971: int ret_val;
43972: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43973: int n_writer;
43974: xmlChar * target; /* PI target */
43975: int n_target;
43976:
43977: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43978: for (n_target = 0;n_target < gen_nb_const_xmlChar_ptr;n_target++) {
43979: mem_base = xmlMemBlocks();
43980: writer = gen_xmlTextWriterPtr(n_writer, 0);
43981: target = gen_const_xmlChar_ptr(n_target, 1);
43982:
43983: ret_val = xmlTextWriterStartPI(writer, (const xmlChar *)target);
43984: desret_int(ret_val);
43985: call_tests++;
43986: des_xmlTextWriterPtr(n_writer, writer, 0);
43987: des_const_xmlChar_ptr(n_target, (const xmlChar *)target, 1);
43988: xmlResetLastError();
43989: if (mem_base != xmlMemBlocks()) {
43990: printf("Leak of %d blocks found in xmlTextWriterStartPI",
43991: xmlMemBlocks() - mem_base);
43992: test_ret++;
43993: printf(" %d", n_writer);
43994: printf(" %d", n_target);
43995: printf("\n");
43996: }
43997: }
43998: }
43999: function_tests++;
44000: #endif
44001:
44002: return(test_ret);
44003: }
44004:
44005:
44006: static int
44007: test_xmlTextWriterWriteAttribute(void) {
44008: int test_ret = 0;
44009:
44010: #if defined(LIBXML_WRITER_ENABLED)
44011: int mem_base;
44012: int ret_val;
44013: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44014: int n_writer;
44015: xmlChar * name; /* attribute name */
44016: int n_name;
44017: xmlChar * content; /* attribute content */
44018: int n_content;
44019:
44020: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44021: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44022: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44023: mem_base = xmlMemBlocks();
44024: writer = gen_xmlTextWriterPtr(n_writer, 0);
44025: name = gen_const_xmlChar_ptr(n_name, 1);
44026: content = gen_const_xmlChar_ptr(n_content, 2);
44027:
44028: ret_val = xmlTextWriterWriteAttribute(writer, (const xmlChar *)name, (const xmlChar *)content);
44029: desret_int(ret_val);
44030: call_tests++;
44031: des_xmlTextWriterPtr(n_writer, writer, 0);
44032: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
44033: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2);
44034: xmlResetLastError();
44035: if (mem_base != xmlMemBlocks()) {
44036: printf("Leak of %d blocks found in xmlTextWriterWriteAttribute",
44037: xmlMemBlocks() - mem_base);
44038: test_ret++;
44039: printf(" %d", n_writer);
44040: printf(" %d", n_name);
44041: printf(" %d", n_content);
44042: printf("\n");
44043: }
44044: }
44045: }
44046: }
44047: function_tests++;
44048: #endif
44049:
44050: return(test_ret);
44051: }
44052:
44053:
44054: static int
44055: test_xmlTextWriterWriteAttributeNS(void) {
44056: int test_ret = 0;
44057:
44058: #if defined(LIBXML_WRITER_ENABLED)
44059: int mem_base;
44060: int ret_val;
44061: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44062: int n_writer;
44063: xmlChar * prefix; /* namespace prefix */
44064: int n_prefix;
44065: xmlChar * name; /* attribute local name */
44066: int n_name;
44067: xmlChar * namespaceURI; /* namespace URI */
44068: int n_namespaceURI;
44069: xmlChar * content; /* attribute content */
44070: int n_content;
44071:
44072: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44073: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
44074: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44075: for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
44076: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44077: mem_base = xmlMemBlocks();
44078: writer = gen_xmlTextWriterPtr(n_writer, 0);
44079: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
44080: name = gen_const_xmlChar_ptr(n_name, 2);
44081: namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 3);
44082: content = gen_const_xmlChar_ptr(n_content, 4);
44083:
44084: ret_val = xmlTextWriterWriteAttributeNS(writer, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)namespaceURI, (const xmlChar *)content);
44085: desret_int(ret_val);
44086: call_tests++;
44087: des_xmlTextWriterPtr(n_writer, writer, 0);
44088: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
44089: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
44090: des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 3);
44091: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 4);
44092: xmlResetLastError();
44093: if (mem_base != xmlMemBlocks()) {
44094: printf("Leak of %d blocks found in xmlTextWriterWriteAttributeNS",
44095: xmlMemBlocks() - mem_base);
44096: test_ret++;
44097: printf(" %d", n_writer);
44098: printf(" %d", n_prefix);
44099: printf(" %d", n_name);
44100: printf(" %d", n_namespaceURI);
44101: printf(" %d", n_content);
44102: printf("\n");
44103: }
44104: }
44105: }
44106: }
44107: }
44108: }
44109: function_tests++;
44110: #endif
44111:
44112: return(test_ret);
44113: }
44114:
44115:
44116: static int
44117: test_xmlTextWriterWriteBase64(void) {
44118: int test_ret = 0;
44119:
44120: #if defined(LIBXML_WRITER_ENABLED)
44121: int mem_base;
44122: int ret_val;
44123: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44124: int n_writer;
44125: char * data; /* binary data */
44126: int n_data;
44127: int start; /* the position within the data of the first byte to encode */
44128: int n_start;
44129: int len; /* the number of bytes to encode */
44130: int n_len;
44131:
44132: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44133: for (n_data = 0;n_data < gen_nb_const_char_ptr;n_data++) {
44134: for (n_start = 0;n_start < gen_nb_int;n_start++) {
44135: for (n_len = 0;n_len < gen_nb_int;n_len++) {
44136: mem_base = xmlMemBlocks();
44137: writer = gen_xmlTextWriterPtr(n_writer, 0);
44138: data = gen_const_char_ptr(n_data, 1);
44139: start = gen_int(n_start, 2);
44140: len = gen_int(n_len, 3);
44141:
44142: ret_val = xmlTextWriterWriteBase64(writer, (const char *)data, start, len);
44143: desret_int(ret_val);
44144: call_tests++;
44145: des_xmlTextWriterPtr(n_writer, writer, 0);
44146: des_const_char_ptr(n_data, (const char *)data, 1);
44147: des_int(n_start, start, 2);
44148: des_int(n_len, len, 3);
44149: xmlResetLastError();
44150: if (mem_base != xmlMemBlocks()) {
44151: printf("Leak of %d blocks found in xmlTextWriterWriteBase64",
44152: xmlMemBlocks() - mem_base);
44153: test_ret++;
44154: printf(" %d", n_writer);
44155: printf(" %d", n_data);
44156: printf(" %d", n_start);
44157: printf(" %d", n_len);
44158: printf("\n");
44159: }
44160: }
44161: }
44162: }
44163: }
44164: function_tests++;
44165: #endif
44166:
44167: return(test_ret);
44168: }
44169:
44170:
44171: static int
44172: test_xmlTextWriterWriteBinHex(void) {
44173: int test_ret = 0;
44174:
44175: #if defined(LIBXML_WRITER_ENABLED)
44176: int mem_base;
44177: int ret_val;
44178: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44179: int n_writer;
44180: char * data; /* binary data */
44181: int n_data;
44182: int start; /* the position within the data of the first byte to encode */
44183: int n_start;
44184: int len; /* the number of bytes to encode */
44185: int n_len;
44186:
44187: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44188: for (n_data = 0;n_data < gen_nb_const_char_ptr;n_data++) {
44189: for (n_start = 0;n_start < gen_nb_int;n_start++) {
44190: for (n_len = 0;n_len < gen_nb_int;n_len++) {
44191: mem_base = xmlMemBlocks();
44192: writer = gen_xmlTextWriterPtr(n_writer, 0);
44193: data = gen_const_char_ptr(n_data, 1);
44194: start = gen_int(n_start, 2);
44195: len = gen_int(n_len, 3);
44196:
44197: ret_val = xmlTextWriterWriteBinHex(writer, (const char *)data, start, len);
44198: desret_int(ret_val);
44199: call_tests++;
44200: des_xmlTextWriterPtr(n_writer, writer, 0);
44201: des_const_char_ptr(n_data, (const char *)data, 1);
44202: des_int(n_start, start, 2);
44203: des_int(n_len, len, 3);
44204: xmlResetLastError();
44205: if (mem_base != xmlMemBlocks()) {
44206: printf("Leak of %d blocks found in xmlTextWriterWriteBinHex",
44207: xmlMemBlocks() - mem_base);
44208: test_ret++;
44209: printf(" %d", n_writer);
44210: printf(" %d", n_data);
44211: printf(" %d", n_start);
44212: printf(" %d", n_len);
44213: printf("\n");
44214: }
44215: }
44216: }
44217: }
44218: }
44219: function_tests++;
44220: #endif
44221:
44222: return(test_ret);
44223: }
44224:
44225:
44226: static int
44227: test_xmlTextWriterWriteCDATA(void) {
44228: int test_ret = 0;
44229:
44230: #if defined(LIBXML_WRITER_ENABLED)
44231: int mem_base;
44232: int ret_val;
44233: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44234: int n_writer;
44235: xmlChar * content; /* CDATA content */
44236: int n_content;
44237:
44238: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44239: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44240: mem_base = xmlMemBlocks();
44241: writer = gen_xmlTextWriterPtr(n_writer, 0);
44242: content = gen_const_xmlChar_ptr(n_content, 1);
44243:
44244: ret_val = xmlTextWriterWriteCDATA(writer, (const xmlChar *)content);
44245: desret_int(ret_val);
44246: call_tests++;
44247: des_xmlTextWriterPtr(n_writer, writer, 0);
44248: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
44249: xmlResetLastError();
44250: if (mem_base != xmlMemBlocks()) {
44251: printf("Leak of %d blocks found in xmlTextWriterWriteCDATA",
44252: xmlMemBlocks() - mem_base);
44253: test_ret++;
44254: printf(" %d", n_writer);
44255: printf(" %d", n_content);
44256: printf("\n");
44257: }
44258: }
44259: }
44260: function_tests++;
44261: #endif
44262:
44263: return(test_ret);
44264: }
44265:
44266:
44267: static int
44268: test_xmlTextWriterWriteComment(void) {
44269: int test_ret = 0;
44270:
44271: #if defined(LIBXML_WRITER_ENABLED)
44272: int mem_base;
44273: int ret_val;
44274: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44275: int n_writer;
44276: xmlChar * content; /* comment string */
44277: int n_content;
44278:
44279: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44280: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44281: mem_base = xmlMemBlocks();
44282: writer = gen_xmlTextWriterPtr(n_writer, 0);
44283: content = gen_const_xmlChar_ptr(n_content, 1);
44284:
44285: ret_val = xmlTextWriterWriteComment(writer, (const xmlChar *)content);
44286: desret_int(ret_val);
44287: call_tests++;
44288: des_xmlTextWriterPtr(n_writer, writer, 0);
44289: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
44290: xmlResetLastError();
44291: if (mem_base != xmlMemBlocks()) {
44292: printf("Leak of %d blocks found in xmlTextWriterWriteComment",
44293: xmlMemBlocks() - mem_base);
44294: test_ret++;
44295: printf(" %d", n_writer);
44296: printf(" %d", n_content);
44297: printf("\n");
44298: }
44299: }
44300: }
44301: function_tests++;
44302: #endif
44303:
44304: return(test_ret);
44305: }
44306:
44307:
44308: static int
44309: test_xmlTextWriterWriteDTD(void) {
44310: int test_ret = 0;
44311:
44312: #if defined(LIBXML_WRITER_ENABLED)
44313: int mem_base;
44314: int ret_val;
44315: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44316: int n_writer;
44317: xmlChar * name; /* the name of the DTD */
44318: int n_name;
44319: xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
44320: int n_pubid;
44321: xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
44322: int n_sysid;
44323: xmlChar * subset; /* string content of the DTD */
44324: int n_subset;
44325:
44326: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44327: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44328: for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
44329: for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
44330: for (n_subset = 0;n_subset < gen_nb_const_xmlChar_ptr;n_subset++) {
44331: mem_base = xmlMemBlocks();
44332: writer = gen_xmlTextWriterPtr(n_writer, 0);
44333: name = gen_const_xmlChar_ptr(n_name, 1);
44334: pubid = gen_const_xmlChar_ptr(n_pubid, 2);
44335: sysid = gen_const_xmlChar_ptr(n_sysid, 3);
44336: subset = gen_const_xmlChar_ptr(n_subset, 4);
44337:
44338: ret_val = xmlTextWriterWriteDTD(writer, (const xmlChar *)name, (const xmlChar *)pubid, (const xmlChar *)sysid, (const xmlChar *)subset);
44339: desret_int(ret_val);
44340: call_tests++;
44341: des_xmlTextWriterPtr(n_writer, writer, 0);
44342: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
44343: des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 2);
44344: des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 3);
44345: des_const_xmlChar_ptr(n_subset, (const xmlChar *)subset, 4);
44346: xmlResetLastError();
44347: if (mem_base != xmlMemBlocks()) {
44348: printf("Leak of %d blocks found in xmlTextWriterWriteDTD",
44349: xmlMemBlocks() - mem_base);
44350: test_ret++;
44351: printf(" %d", n_writer);
44352: printf(" %d", n_name);
44353: printf(" %d", n_pubid);
44354: printf(" %d", n_sysid);
44355: printf(" %d", n_subset);
44356: printf("\n");
44357: }
44358: }
44359: }
44360: }
44361: }
44362: }
44363: function_tests++;
44364: #endif
44365:
44366: return(test_ret);
44367: }
44368:
44369:
44370: static int
44371: test_xmlTextWriterWriteDTDAttlist(void) {
44372: int test_ret = 0;
44373:
44374: #if defined(LIBXML_WRITER_ENABLED)
44375: int mem_base;
44376: int ret_val;
44377: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44378: int n_writer;
44379: xmlChar * name; /* the name of the DTD ATTLIST */
44380: int n_name;
44381: xmlChar * content; /* content of the ATTLIST */
44382: int n_content;
44383:
44384: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44385: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44386: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44387: mem_base = xmlMemBlocks();
44388: writer = gen_xmlTextWriterPtr(n_writer, 0);
44389: name = gen_const_xmlChar_ptr(n_name, 1);
44390: content = gen_const_xmlChar_ptr(n_content, 2);
44391:
44392: ret_val = xmlTextWriterWriteDTDAttlist(writer, (const xmlChar *)name, (const xmlChar *)content);
44393: desret_int(ret_val);
44394: call_tests++;
44395: des_xmlTextWriterPtr(n_writer, writer, 0);
44396: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
44397: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2);
44398: xmlResetLastError();
44399: if (mem_base != xmlMemBlocks()) {
44400: printf("Leak of %d blocks found in xmlTextWriterWriteDTDAttlist",
44401: xmlMemBlocks() - mem_base);
44402: test_ret++;
44403: printf(" %d", n_writer);
44404: printf(" %d", n_name);
44405: printf(" %d", n_content);
44406: printf("\n");
44407: }
44408: }
44409: }
44410: }
44411: function_tests++;
44412: #endif
44413:
44414: return(test_ret);
44415: }
44416:
44417:
44418: static int
44419: test_xmlTextWriterWriteDTDElement(void) {
44420: int test_ret = 0;
44421:
44422: #if defined(LIBXML_WRITER_ENABLED)
44423: int mem_base;
44424: int ret_val;
44425: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44426: int n_writer;
44427: xmlChar * name; /* the name of the DTD element */
44428: int n_name;
44429: xmlChar * content; /* content of the element */
44430: int n_content;
44431:
44432: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44433: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44434: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44435: mem_base = xmlMemBlocks();
44436: writer = gen_xmlTextWriterPtr(n_writer, 0);
44437: name = gen_const_xmlChar_ptr(n_name, 1);
44438: content = gen_const_xmlChar_ptr(n_content, 2);
44439:
44440: ret_val = xmlTextWriterWriteDTDElement(writer, (const xmlChar *)name, (const xmlChar *)content);
44441: desret_int(ret_val);
44442: call_tests++;
44443: des_xmlTextWriterPtr(n_writer, writer, 0);
44444: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
44445: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2);
44446: xmlResetLastError();
44447: if (mem_base != xmlMemBlocks()) {
44448: printf("Leak of %d blocks found in xmlTextWriterWriteDTDElement",
44449: xmlMemBlocks() - mem_base);
44450: test_ret++;
44451: printf(" %d", n_writer);
44452: printf(" %d", n_name);
44453: printf(" %d", n_content);
44454: printf("\n");
44455: }
44456: }
44457: }
44458: }
44459: function_tests++;
44460: #endif
44461:
44462: return(test_ret);
44463: }
44464:
44465:
44466: static int
44467: test_xmlTextWriterWriteDTDEntity(void) {
44468: int test_ret = 0;
44469:
44470: #if defined(LIBXML_WRITER_ENABLED)
44471: int mem_base;
44472: int ret_val;
44473: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44474: int n_writer;
44475: int pe; /* TRUE if this is a parameter entity, FALSE if not */
44476: int n_pe;
44477: xmlChar * name; /* the name of the DTD entity */
44478: int n_name;
44479: xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
44480: int n_pubid;
44481: xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
44482: int n_sysid;
44483: xmlChar * ndataid; /* the xml notation name. */
44484: int n_ndataid;
44485: xmlChar * content; /* content of the entity */
44486: int n_content;
44487:
44488: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44489: for (n_pe = 0;n_pe < gen_nb_int;n_pe++) {
44490: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44491: for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
44492: for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
44493: for (n_ndataid = 0;n_ndataid < gen_nb_const_xmlChar_ptr;n_ndataid++) {
44494: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44495: mem_base = xmlMemBlocks();
44496: writer = gen_xmlTextWriterPtr(n_writer, 0);
44497: pe = gen_int(n_pe, 1);
44498: name = gen_const_xmlChar_ptr(n_name, 2);
44499: pubid = gen_const_xmlChar_ptr(n_pubid, 3);
44500: sysid = gen_const_xmlChar_ptr(n_sysid, 4);
44501: ndataid = gen_const_xmlChar_ptr(n_ndataid, 5);
44502: content = gen_const_xmlChar_ptr(n_content, 6);
44503:
44504: ret_val = xmlTextWriterWriteDTDEntity(writer, pe, (const xmlChar *)name, (const xmlChar *)pubid, (const xmlChar *)sysid, (const xmlChar *)ndataid, (const xmlChar *)content);
44505: desret_int(ret_val);
44506: call_tests++;
44507: des_xmlTextWriterPtr(n_writer, writer, 0);
44508: des_int(n_pe, pe, 1);
44509: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
44510: des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 3);
44511: des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 4);
44512: des_const_xmlChar_ptr(n_ndataid, (const xmlChar *)ndataid, 5);
44513: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 6);
44514: xmlResetLastError();
44515: if (mem_base != xmlMemBlocks()) {
44516: printf("Leak of %d blocks found in xmlTextWriterWriteDTDEntity",
44517: xmlMemBlocks() - mem_base);
44518: test_ret++;
44519: printf(" %d", n_writer);
44520: printf(" %d", n_pe);
44521: printf(" %d", n_name);
44522: printf(" %d", n_pubid);
44523: printf(" %d", n_sysid);
44524: printf(" %d", n_ndataid);
44525: printf(" %d", n_content);
44526: printf("\n");
44527: }
44528: }
44529: }
44530: }
44531: }
44532: }
44533: }
44534: }
44535: function_tests++;
44536: #endif
44537:
44538: return(test_ret);
44539: }
44540:
44541:
44542: static int
44543: test_xmlTextWriterWriteDTDExternalEntity(void) {
44544: int test_ret = 0;
44545:
44546: #if defined(LIBXML_WRITER_ENABLED)
44547: int mem_base;
44548: int ret_val;
44549: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44550: int n_writer;
44551: int pe; /* TRUE if this is a parameter entity, FALSE if not */
44552: int n_pe;
44553: xmlChar * name; /* the name of the DTD entity */
44554: int n_name;
44555: xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
44556: int n_pubid;
44557: xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
44558: int n_sysid;
44559: xmlChar * ndataid; /* the xml notation name. */
44560: int n_ndataid;
44561:
44562: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44563: for (n_pe = 0;n_pe < gen_nb_int;n_pe++) {
44564: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44565: for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
44566: for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
44567: for (n_ndataid = 0;n_ndataid < gen_nb_const_xmlChar_ptr;n_ndataid++) {
44568: mem_base = xmlMemBlocks();
44569: writer = gen_xmlTextWriterPtr(n_writer, 0);
44570: pe = gen_int(n_pe, 1);
44571: name = gen_const_xmlChar_ptr(n_name, 2);
44572: pubid = gen_const_xmlChar_ptr(n_pubid, 3);
44573: sysid = gen_const_xmlChar_ptr(n_sysid, 4);
44574: ndataid = gen_const_xmlChar_ptr(n_ndataid, 5);
44575:
44576: ret_val = xmlTextWriterWriteDTDExternalEntity(writer, pe, (const xmlChar *)name, (const xmlChar *)pubid, (const xmlChar *)sysid, (const xmlChar *)ndataid);
44577: desret_int(ret_val);
44578: call_tests++;
44579: des_xmlTextWriterPtr(n_writer, writer, 0);
44580: des_int(n_pe, pe, 1);
44581: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
44582: des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 3);
44583: des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 4);
44584: des_const_xmlChar_ptr(n_ndataid, (const xmlChar *)ndataid, 5);
44585: xmlResetLastError();
44586: if (mem_base != xmlMemBlocks()) {
44587: printf("Leak of %d blocks found in xmlTextWriterWriteDTDExternalEntity",
44588: xmlMemBlocks() - mem_base);
44589: test_ret++;
44590: printf(" %d", n_writer);
44591: printf(" %d", n_pe);
44592: printf(" %d", n_name);
44593: printf(" %d", n_pubid);
44594: printf(" %d", n_sysid);
44595: printf(" %d", n_ndataid);
44596: printf("\n");
44597: }
44598: }
44599: }
44600: }
44601: }
44602: }
44603: }
44604: function_tests++;
44605: #endif
44606:
44607: return(test_ret);
44608: }
44609:
44610:
44611: static int
44612: test_xmlTextWriterWriteDTDExternalEntityContents(void) {
44613: int test_ret = 0;
44614:
44615: #if defined(LIBXML_WRITER_ENABLED)
44616: int mem_base;
44617: int ret_val;
44618: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44619: int n_writer;
44620: xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
44621: int n_pubid;
44622: xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
44623: int n_sysid;
44624: xmlChar * ndataid; /* the xml notation name. */
44625: int n_ndataid;
44626:
44627: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44628: for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
44629: for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
44630: for (n_ndataid = 0;n_ndataid < gen_nb_const_xmlChar_ptr;n_ndataid++) {
44631: mem_base = xmlMemBlocks();
44632: writer = gen_xmlTextWriterPtr(n_writer, 0);
44633: pubid = gen_const_xmlChar_ptr(n_pubid, 1);
44634: sysid = gen_const_xmlChar_ptr(n_sysid, 2);
44635: ndataid = gen_const_xmlChar_ptr(n_ndataid, 3);
44636:
44637: ret_val = xmlTextWriterWriteDTDExternalEntityContents(writer, (const xmlChar *)pubid, (const xmlChar *)sysid, (const xmlChar *)ndataid);
44638: desret_int(ret_val);
44639: call_tests++;
44640: des_xmlTextWriterPtr(n_writer, writer, 0);
44641: des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 1);
44642: des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 2);
44643: des_const_xmlChar_ptr(n_ndataid, (const xmlChar *)ndataid, 3);
44644: xmlResetLastError();
44645: if (mem_base != xmlMemBlocks()) {
44646: printf("Leak of %d blocks found in xmlTextWriterWriteDTDExternalEntityContents",
44647: xmlMemBlocks() - mem_base);
44648: test_ret++;
44649: printf(" %d", n_writer);
44650: printf(" %d", n_pubid);
44651: printf(" %d", n_sysid);
44652: printf(" %d", n_ndataid);
44653: printf("\n");
44654: }
44655: }
44656: }
44657: }
44658: }
44659: function_tests++;
44660: #endif
44661:
44662: return(test_ret);
44663: }
44664:
44665:
44666: static int
44667: test_xmlTextWriterWriteDTDInternalEntity(void) {
44668: int test_ret = 0;
44669:
44670: #if defined(LIBXML_WRITER_ENABLED)
44671: int mem_base;
44672: int ret_val;
44673: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44674: int n_writer;
44675: int pe; /* TRUE if this is a parameter entity, FALSE if not */
44676: int n_pe;
44677: xmlChar * name; /* the name of the DTD entity */
44678: int n_name;
44679: xmlChar * content; /* content of the entity */
44680: int n_content;
44681:
44682: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44683: for (n_pe = 0;n_pe < gen_nb_int;n_pe++) {
44684: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44685: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44686: mem_base = xmlMemBlocks();
44687: writer = gen_xmlTextWriterPtr(n_writer, 0);
44688: pe = gen_int(n_pe, 1);
44689: name = gen_const_xmlChar_ptr(n_name, 2);
44690: content = gen_const_xmlChar_ptr(n_content, 3);
44691:
44692: ret_val = xmlTextWriterWriteDTDInternalEntity(writer, pe, (const xmlChar *)name, (const xmlChar *)content);
44693: desret_int(ret_val);
44694: call_tests++;
44695: des_xmlTextWriterPtr(n_writer, writer, 0);
44696: des_int(n_pe, pe, 1);
44697: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
44698: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3);
44699: xmlResetLastError();
44700: if (mem_base != xmlMemBlocks()) {
44701: printf("Leak of %d blocks found in xmlTextWriterWriteDTDInternalEntity",
44702: xmlMemBlocks() - mem_base);
44703: test_ret++;
44704: printf(" %d", n_writer);
44705: printf(" %d", n_pe);
44706: printf(" %d", n_name);
44707: printf(" %d", n_content);
44708: printf("\n");
44709: }
44710: }
44711: }
44712: }
44713: }
44714: function_tests++;
44715: #endif
44716:
44717: return(test_ret);
44718: }
44719:
44720:
44721: static int
44722: test_xmlTextWriterWriteDTDNotation(void) {
44723: int test_ret = 0;
44724:
44725: #if defined(LIBXML_WRITER_ENABLED)
44726: int mem_base;
44727: int ret_val;
44728: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44729: int n_writer;
44730: xmlChar * name; /* the name of the xml notation */
44731: int n_name;
44732: xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
44733: int n_pubid;
44734: xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
44735: int n_sysid;
44736:
44737: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44738: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44739: for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
44740: for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
44741: mem_base = xmlMemBlocks();
44742: writer = gen_xmlTextWriterPtr(n_writer, 0);
44743: name = gen_const_xmlChar_ptr(n_name, 1);
44744: pubid = gen_const_xmlChar_ptr(n_pubid, 2);
44745: sysid = gen_const_xmlChar_ptr(n_sysid, 3);
44746:
44747: ret_val = xmlTextWriterWriteDTDNotation(writer, (const xmlChar *)name, (const xmlChar *)pubid, (const xmlChar *)sysid);
44748: desret_int(ret_val);
44749: call_tests++;
44750: des_xmlTextWriterPtr(n_writer, writer, 0);
44751: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
44752: des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 2);
44753: des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 3);
44754: xmlResetLastError();
44755: if (mem_base != xmlMemBlocks()) {
44756: printf("Leak of %d blocks found in xmlTextWriterWriteDTDNotation",
44757: xmlMemBlocks() - mem_base);
44758: test_ret++;
44759: printf(" %d", n_writer);
44760: printf(" %d", n_name);
44761: printf(" %d", n_pubid);
44762: printf(" %d", n_sysid);
44763: printf("\n");
44764: }
44765: }
44766: }
44767: }
44768: }
44769: function_tests++;
44770: #endif
44771:
44772: return(test_ret);
44773: }
44774:
44775:
44776: static int
44777: test_xmlTextWriterWriteElement(void) {
44778: int test_ret = 0;
44779:
44780: #if defined(LIBXML_WRITER_ENABLED)
44781: int mem_base;
44782: int ret_val;
44783: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44784: int n_writer;
44785: xmlChar * name; /* element name */
44786: int n_name;
44787: xmlChar * content; /* element content */
44788: int n_content;
44789:
44790: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44791: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44792: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44793: mem_base = xmlMemBlocks();
44794: writer = gen_xmlTextWriterPtr(n_writer, 0);
44795: name = gen_const_xmlChar_ptr(n_name, 1);
44796: content = gen_const_xmlChar_ptr(n_content, 2);
44797:
44798: ret_val = xmlTextWriterWriteElement(writer, (const xmlChar *)name, (const xmlChar *)content);
44799: desret_int(ret_val);
44800: call_tests++;
44801: des_xmlTextWriterPtr(n_writer, writer, 0);
44802: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
44803: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2);
44804: xmlResetLastError();
44805: if (mem_base != xmlMemBlocks()) {
44806: printf("Leak of %d blocks found in xmlTextWriterWriteElement",
44807: xmlMemBlocks() - mem_base);
44808: test_ret++;
44809: printf(" %d", n_writer);
44810: printf(" %d", n_name);
44811: printf(" %d", n_content);
44812: printf("\n");
44813: }
44814: }
44815: }
44816: }
44817: function_tests++;
44818: #endif
44819:
44820: return(test_ret);
44821: }
44822:
44823:
44824: static int
44825: test_xmlTextWriterWriteElementNS(void) {
44826: int test_ret = 0;
44827:
44828: #if defined(LIBXML_WRITER_ENABLED)
44829: int mem_base;
44830: int ret_val;
44831: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44832: int n_writer;
44833: xmlChar * prefix; /* namespace prefix */
44834: int n_prefix;
44835: xmlChar * name; /* element local name */
44836: int n_name;
44837: xmlChar * namespaceURI; /* namespace URI */
44838: int n_namespaceURI;
44839: xmlChar * content; /* element content */
44840: int n_content;
44841:
44842: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44843: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
44844: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44845: for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
44846: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44847: mem_base = xmlMemBlocks();
44848: writer = gen_xmlTextWriterPtr(n_writer, 0);
44849: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
44850: name = gen_const_xmlChar_ptr(n_name, 2);
44851: namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 3);
44852: content = gen_const_xmlChar_ptr(n_content, 4);
44853:
44854: ret_val = xmlTextWriterWriteElementNS(writer, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)namespaceURI, (const xmlChar *)content);
44855: desret_int(ret_val);
44856: call_tests++;
44857: des_xmlTextWriterPtr(n_writer, writer, 0);
44858: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
44859: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
44860: des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 3);
44861: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 4);
44862: xmlResetLastError();
44863: if (mem_base != xmlMemBlocks()) {
44864: printf("Leak of %d blocks found in xmlTextWriterWriteElementNS",
44865: xmlMemBlocks() - mem_base);
44866: test_ret++;
44867: printf(" %d", n_writer);
44868: printf(" %d", n_prefix);
44869: printf(" %d", n_name);
44870: printf(" %d", n_namespaceURI);
44871: printf(" %d", n_content);
44872: printf("\n");
44873: }
44874: }
44875: }
44876: }
44877: }
44878: }
44879: function_tests++;
44880: #endif
44881:
44882: return(test_ret);
44883: }
44884:
44885:
44886: static int
44887: test_xmlTextWriterWriteFormatAttribute(void) {
44888: int test_ret = 0;
44889:
44890:
44891: /* missing type support */
44892: return(test_ret);
44893: }
44894:
44895:
44896: static int
44897: test_xmlTextWriterWriteFormatAttributeNS(void) {
44898: int test_ret = 0;
44899:
44900:
44901: /* missing type support */
44902: return(test_ret);
44903: }
44904:
44905:
44906: static int
44907: test_xmlTextWriterWriteFormatCDATA(void) {
44908: int test_ret = 0;
44909:
44910:
44911: /* missing type support */
44912: return(test_ret);
44913: }
44914:
44915:
44916: static int
44917: test_xmlTextWriterWriteFormatComment(void) {
44918: int test_ret = 0;
44919:
44920:
44921: /* missing type support */
44922: return(test_ret);
44923: }
44924:
44925:
44926: static int
44927: test_xmlTextWriterWriteFormatDTD(void) {
44928: int test_ret = 0;
44929:
44930:
44931: /* missing type support */
44932: return(test_ret);
44933: }
44934:
44935:
44936: static int
44937: test_xmlTextWriterWriteFormatDTDAttlist(void) {
44938: int test_ret = 0;
44939:
44940:
44941: /* missing type support */
44942: return(test_ret);
44943: }
44944:
44945:
44946: static int
44947: test_xmlTextWriterWriteFormatDTDElement(void) {
44948: int test_ret = 0;
44949:
44950:
44951: /* missing type support */
44952: return(test_ret);
44953: }
44954:
44955:
44956: static int
44957: test_xmlTextWriterWriteFormatDTDInternalEntity(void) {
44958: int test_ret = 0;
44959:
44960:
44961: /* missing type support */
44962: return(test_ret);
44963: }
44964:
44965:
44966: static int
44967: test_xmlTextWriterWriteFormatElement(void) {
44968: int test_ret = 0;
44969:
44970:
44971: /* missing type support */
44972: return(test_ret);
44973: }
44974:
44975:
44976: static int
44977: test_xmlTextWriterWriteFormatElementNS(void) {
44978: int test_ret = 0;
44979:
44980:
44981: /* missing type support */
44982: return(test_ret);
44983: }
44984:
44985:
44986: static int
44987: test_xmlTextWriterWriteFormatPI(void) {
44988: int test_ret = 0;
44989:
44990:
44991: /* missing type support */
44992: return(test_ret);
44993: }
44994:
44995:
44996: static int
44997: test_xmlTextWriterWriteFormatRaw(void) {
44998: int test_ret = 0;
44999:
45000:
45001: /* missing type support */
45002: return(test_ret);
45003: }
45004:
45005:
45006: static int
45007: test_xmlTextWriterWriteFormatString(void) {
45008: int test_ret = 0;
45009:
45010:
45011: /* missing type support */
45012: return(test_ret);
45013: }
45014:
45015:
45016: static int
45017: test_xmlTextWriterWritePI(void) {
45018: int test_ret = 0;
45019:
45020: #if defined(LIBXML_WRITER_ENABLED)
45021: int mem_base;
45022: int ret_val;
45023: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
45024: int n_writer;
45025: xmlChar * target; /* PI target */
45026: int n_target;
45027: xmlChar * content; /* PI content */
45028: int n_content;
45029:
45030: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
45031: for (n_target = 0;n_target < gen_nb_const_xmlChar_ptr;n_target++) {
45032: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
45033: mem_base = xmlMemBlocks();
45034: writer = gen_xmlTextWriterPtr(n_writer, 0);
45035: target = gen_const_xmlChar_ptr(n_target, 1);
45036: content = gen_const_xmlChar_ptr(n_content, 2);
45037:
45038: ret_val = xmlTextWriterWritePI(writer, (const xmlChar *)target, (const xmlChar *)content);
45039: desret_int(ret_val);
45040: call_tests++;
45041: des_xmlTextWriterPtr(n_writer, writer, 0);
45042: des_const_xmlChar_ptr(n_target, (const xmlChar *)target, 1);
45043: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2);
45044: xmlResetLastError();
45045: if (mem_base != xmlMemBlocks()) {
45046: printf("Leak of %d blocks found in xmlTextWriterWritePI",
45047: xmlMemBlocks() - mem_base);
45048: test_ret++;
45049: printf(" %d", n_writer);
45050: printf(" %d", n_target);
45051: printf(" %d", n_content);
45052: printf("\n");
45053: }
45054: }
45055: }
45056: }
45057: function_tests++;
45058: #endif
45059:
45060: return(test_ret);
45061: }
45062:
45063:
45064: static int
45065: test_xmlTextWriterWriteRaw(void) {
45066: int test_ret = 0;
45067:
45068: #if defined(LIBXML_WRITER_ENABLED)
45069: int mem_base;
45070: int ret_val;
45071: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
45072: int n_writer;
45073: xmlChar * content; /* text string */
45074: int n_content;
45075:
45076: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
45077: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
45078: mem_base = xmlMemBlocks();
45079: writer = gen_xmlTextWriterPtr(n_writer, 0);
45080: content = gen_const_xmlChar_ptr(n_content, 1);
45081:
45082: ret_val = xmlTextWriterWriteRaw(writer, (const xmlChar *)content);
45083: desret_int(ret_val);
45084: call_tests++;
45085: des_xmlTextWriterPtr(n_writer, writer, 0);
45086: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
45087: xmlResetLastError();
45088: if (mem_base != xmlMemBlocks()) {
45089: printf("Leak of %d blocks found in xmlTextWriterWriteRaw",
45090: xmlMemBlocks() - mem_base);
45091: test_ret++;
45092: printf(" %d", n_writer);
45093: printf(" %d", n_content);
45094: printf("\n");
45095: }
45096: }
45097: }
45098: function_tests++;
45099: #endif
45100:
45101: return(test_ret);
45102: }
45103:
45104:
45105: static int
45106: test_xmlTextWriterWriteRawLen(void) {
45107: int test_ret = 0;
45108:
45109: #if defined(LIBXML_WRITER_ENABLED)
45110: int mem_base;
45111: int ret_val;
45112: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
45113: int n_writer;
45114: xmlChar * content; /* text string */
45115: int n_content;
45116: int len; /* length of the text string */
45117: int n_len;
45118:
45119: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
45120: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
45121: for (n_len = 0;n_len < gen_nb_int;n_len++) {
45122: mem_base = xmlMemBlocks();
45123: writer = gen_xmlTextWriterPtr(n_writer, 0);
45124: content = gen_const_xmlChar_ptr(n_content, 1);
45125: len = gen_int(n_len, 2);
45126:
45127: ret_val = xmlTextWriterWriteRawLen(writer, (const xmlChar *)content, len);
45128: desret_int(ret_val);
45129: call_tests++;
45130: des_xmlTextWriterPtr(n_writer, writer, 0);
45131: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
45132: des_int(n_len, len, 2);
45133: xmlResetLastError();
45134: if (mem_base != xmlMemBlocks()) {
45135: printf("Leak of %d blocks found in xmlTextWriterWriteRawLen",
45136: xmlMemBlocks() - mem_base);
45137: test_ret++;
45138: printf(" %d", n_writer);
45139: printf(" %d", n_content);
45140: printf(" %d", n_len);
45141: printf("\n");
45142: }
45143: }
45144: }
45145: }
45146: function_tests++;
45147: #endif
45148:
45149: return(test_ret);
45150: }
45151:
45152:
45153: static int
45154: test_xmlTextWriterWriteString(void) {
45155: int test_ret = 0;
45156:
45157: #if defined(LIBXML_WRITER_ENABLED)
45158: int mem_base;
45159: int ret_val;
45160: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
45161: int n_writer;
45162: xmlChar * content; /* text string */
45163: int n_content;
45164:
45165: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
45166: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
45167: mem_base = xmlMemBlocks();
45168: writer = gen_xmlTextWriterPtr(n_writer, 0);
45169: content = gen_const_xmlChar_ptr(n_content, 1);
45170:
45171: ret_val = xmlTextWriterWriteString(writer, (const xmlChar *)content);
45172: desret_int(ret_val);
45173: call_tests++;
45174: des_xmlTextWriterPtr(n_writer, writer, 0);
45175: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
45176: xmlResetLastError();
45177: if (mem_base != xmlMemBlocks()) {
45178: printf("Leak of %d blocks found in xmlTextWriterWriteString",
45179: xmlMemBlocks() - mem_base);
45180: test_ret++;
45181: printf(" %d", n_writer);
45182: printf(" %d", n_content);
45183: printf("\n");
45184: }
45185: }
45186: }
45187: function_tests++;
45188: #endif
45189:
45190: return(test_ret);
45191: }
45192:
45193:
45194: static int
45195: test_xmlTextWriterWriteVFormatAttribute(void) {
45196: int test_ret = 0;
45197:
45198:
45199: /* missing type support */
45200: return(test_ret);
45201: }
45202:
45203:
45204: static int
45205: test_xmlTextWriterWriteVFormatAttributeNS(void) {
45206: int test_ret = 0;
45207:
45208:
45209: /* missing type support */
45210: return(test_ret);
45211: }
45212:
45213:
45214: static int
45215: test_xmlTextWriterWriteVFormatCDATA(void) {
45216: int test_ret = 0;
45217:
45218:
45219: /* missing type support */
45220: return(test_ret);
45221: }
45222:
45223:
45224: static int
45225: test_xmlTextWriterWriteVFormatComment(void) {
45226: int test_ret = 0;
45227:
45228:
45229: /* missing type support */
45230: return(test_ret);
45231: }
45232:
45233:
45234: static int
45235: test_xmlTextWriterWriteVFormatDTD(void) {
45236: int test_ret = 0;
45237:
45238:
45239: /* missing type support */
45240: return(test_ret);
45241: }
45242:
45243:
45244: static int
45245: test_xmlTextWriterWriteVFormatDTDAttlist(void) {
45246: int test_ret = 0;
45247:
45248:
45249: /* missing type support */
45250: return(test_ret);
45251: }
45252:
45253:
45254: static int
45255: test_xmlTextWriterWriteVFormatDTDElement(void) {
45256: int test_ret = 0;
45257:
45258:
45259: /* missing type support */
45260: return(test_ret);
45261: }
45262:
45263:
45264: static int
45265: test_xmlTextWriterWriteVFormatDTDInternalEntity(void) {
45266: int test_ret = 0;
45267:
45268:
45269: /* missing type support */
45270: return(test_ret);
45271: }
45272:
45273:
45274: static int
45275: test_xmlTextWriterWriteVFormatElement(void) {
45276: int test_ret = 0;
45277:
45278:
45279: /* missing type support */
45280: return(test_ret);
45281: }
45282:
45283:
45284: static int
45285: test_xmlTextWriterWriteVFormatElementNS(void) {
45286: int test_ret = 0;
45287:
45288:
45289: /* missing type support */
45290: return(test_ret);
45291: }
45292:
45293:
45294: static int
45295: test_xmlTextWriterWriteVFormatPI(void) {
45296: int test_ret = 0;
45297:
45298:
45299: /* missing type support */
45300: return(test_ret);
45301: }
45302:
45303:
45304: static int
45305: test_xmlTextWriterWriteVFormatRaw(void) {
45306: int test_ret = 0;
45307:
45308:
45309: /* missing type support */
45310: return(test_ret);
45311: }
45312:
45313:
45314: static int
45315: test_xmlTextWriterWriteVFormatString(void) {
45316: int test_ret = 0;
45317:
45318:
45319: /* missing type support */
45320: return(test_ret);
45321: }
45322:
45323: static int
45324: test_xmlwriter(void) {
45325: int test_ret = 0;
45326:
45327: if (quiet == 0) printf("Testing xmlwriter : 51 of 79 functions ...\n");
45328: test_ret += test_xmlNewTextWriter();
45329: test_ret += test_xmlNewTextWriterFilename();
45330: test_ret += test_xmlNewTextWriterMemory();
45331: test_ret += test_xmlNewTextWriterPushParser();
45332: test_ret += test_xmlNewTextWriterTree();
45333: test_ret += test_xmlTextWriterEndAttribute();
45334: test_ret += test_xmlTextWriterEndCDATA();
45335: test_ret += test_xmlTextWriterEndComment();
45336: test_ret += test_xmlTextWriterEndDTD();
45337: test_ret += test_xmlTextWriterEndDTDAttlist();
45338: test_ret += test_xmlTextWriterEndDTDElement();
45339: test_ret += test_xmlTextWriterEndDTDEntity();
45340: test_ret += test_xmlTextWriterEndDocument();
45341: test_ret += test_xmlTextWriterEndElement();
45342: test_ret += test_xmlTextWriterEndPI();
45343: test_ret += test_xmlTextWriterFlush();
45344: test_ret += test_xmlTextWriterFullEndElement();
45345: test_ret += test_xmlTextWriterSetIndent();
45346: test_ret += test_xmlTextWriterSetIndentString();
45347: test_ret += test_xmlTextWriterStartAttribute();
45348: test_ret += test_xmlTextWriterStartAttributeNS();
45349: test_ret += test_xmlTextWriterStartCDATA();
45350: test_ret += test_xmlTextWriterStartComment();
45351: test_ret += test_xmlTextWriterStartDTD();
45352: test_ret += test_xmlTextWriterStartDTDAttlist();
45353: test_ret += test_xmlTextWriterStartDTDElement();
45354: test_ret += test_xmlTextWriterStartDTDEntity();
45355: test_ret += test_xmlTextWriterStartDocument();
45356: test_ret += test_xmlTextWriterStartElement();
45357: test_ret += test_xmlTextWriterStartElementNS();
45358: test_ret += test_xmlTextWriterStartPI();
45359: test_ret += test_xmlTextWriterWriteAttribute();
45360: test_ret += test_xmlTextWriterWriteAttributeNS();
45361: test_ret += test_xmlTextWriterWriteBase64();
45362: test_ret += test_xmlTextWriterWriteBinHex();
45363: test_ret += test_xmlTextWriterWriteCDATA();
45364: test_ret += test_xmlTextWriterWriteComment();
45365: test_ret += test_xmlTextWriterWriteDTD();
45366: test_ret += test_xmlTextWriterWriteDTDAttlist();
45367: test_ret += test_xmlTextWriterWriteDTDElement();
45368: test_ret += test_xmlTextWriterWriteDTDEntity();
45369: test_ret += test_xmlTextWriterWriteDTDExternalEntity();
45370: test_ret += test_xmlTextWriterWriteDTDExternalEntityContents();
45371: test_ret += test_xmlTextWriterWriteDTDInternalEntity();
45372: test_ret += test_xmlTextWriterWriteDTDNotation();
45373: test_ret += test_xmlTextWriterWriteElement();
45374: test_ret += test_xmlTextWriterWriteElementNS();
45375: test_ret += test_xmlTextWriterWriteFormatAttribute();
45376: test_ret += test_xmlTextWriterWriteFormatAttributeNS();
45377: test_ret += test_xmlTextWriterWriteFormatCDATA();
45378: test_ret += test_xmlTextWriterWriteFormatComment();
45379: test_ret += test_xmlTextWriterWriteFormatDTD();
45380: test_ret += test_xmlTextWriterWriteFormatDTDAttlist();
45381: test_ret += test_xmlTextWriterWriteFormatDTDElement();
45382: test_ret += test_xmlTextWriterWriteFormatDTDInternalEntity();
45383: test_ret += test_xmlTextWriterWriteFormatElement();
45384: test_ret += test_xmlTextWriterWriteFormatElementNS();
45385: test_ret += test_xmlTextWriterWriteFormatPI();
45386: test_ret += test_xmlTextWriterWriteFormatRaw();
45387: test_ret += test_xmlTextWriterWriteFormatString();
45388: test_ret += test_xmlTextWriterWritePI();
45389: test_ret += test_xmlTextWriterWriteRaw();
45390: test_ret += test_xmlTextWriterWriteRawLen();
45391: test_ret += test_xmlTextWriterWriteString();
45392: test_ret += test_xmlTextWriterWriteVFormatAttribute();
45393: test_ret += test_xmlTextWriterWriteVFormatAttributeNS();
45394: test_ret += test_xmlTextWriterWriteVFormatCDATA();
45395: test_ret += test_xmlTextWriterWriteVFormatComment();
45396: test_ret += test_xmlTextWriterWriteVFormatDTD();
45397: test_ret += test_xmlTextWriterWriteVFormatDTDAttlist();
45398: test_ret += test_xmlTextWriterWriteVFormatDTDElement();
45399: test_ret += test_xmlTextWriterWriteVFormatDTDInternalEntity();
45400: test_ret += test_xmlTextWriterWriteVFormatElement();
45401: test_ret += test_xmlTextWriterWriteVFormatElementNS();
45402: test_ret += test_xmlTextWriterWriteVFormatPI();
45403: test_ret += test_xmlTextWriterWriteVFormatRaw();
45404: test_ret += test_xmlTextWriterWriteVFormatString();
45405:
45406: if (test_ret != 0)
45407: printf("Module xmlwriter: %d errors\n", test_ret);
45408: return(test_ret);
45409: }
45410:
45411: static int
45412: test_xmlXPathCastBooleanToNumber(void) {
45413: int test_ret = 0;
45414:
45415: #if defined(LIBXML_XPATH_ENABLED)
45416: int mem_base;
45417: double ret_val;
45418: int val; /* a boolean */
45419: int n_val;
45420:
45421: for (n_val = 0;n_val < gen_nb_int;n_val++) {
45422: mem_base = xmlMemBlocks();
45423: val = gen_int(n_val, 0);
45424:
45425: ret_val = xmlXPathCastBooleanToNumber(val);
45426: desret_double(ret_val);
45427: call_tests++;
45428: des_int(n_val, val, 0);
45429: xmlResetLastError();
45430: if (mem_base != xmlMemBlocks()) {
45431: printf("Leak of %d blocks found in xmlXPathCastBooleanToNumber",
45432: xmlMemBlocks() - mem_base);
45433: test_ret++;
45434: printf(" %d", n_val);
45435: printf("\n");
45436: }
45437: }
45438: function_tests++;
45439: #endif
45440:
45441: return(test_ret);
45442: }
45443:
45444:
45445: static int
45446: test_xmlXPathCastBooleanToString(void) {
45447: int test_ret = 0;
45448:
45449: #if defined(LIBXML_XPATH_ENABLED)
45450: int mem_base;
45451: xmlChar * ret_val;
45452: int val; /* a boolean */
45453: int n_val;
45454:
45455: for (n_val = 0;n_val < gen_nb_int;n_val++) {
45456: mem_base = xmlMemBlocks();
45457: val = gen_int(n_val, 0);
45458:
45459: ret_val = xmlXPathCastBooleanToString(val);
45460: desret_xmlChar_ptr(ret_val);
45461: call_tests++;
45462: des_int(n_val, val, 0);
45463: xmlResetLastError();
45464: if (mem_base != xmlMemBlocks()) {
45465: printf("Leak of %d blocks found in xmlXPathCastBooleanToString",
45466: xmlMemBlocks() - mem_base);
45467: test_ret++;
45468: printf(" %d", n_val);
45469: printf("\n");
45470: }
45471: }
45472: function_tests++;
45473: #endif
45474:
45475: return(test_ret);
45476: }
45477:
45478:
45479: static int
45480: test_xmlXPathCastNodeSetToBoolean(void) {
45481: int test_ret = 0;
45482:
45483: #if defined(LIBXML_XPATH_ENABLED)
45484: int mem_base;
45485: int ret_val;
45486: xmlNodeSetPtr ns; /* a node-set */
45487: int n_ns;
45488:
45489: for (n_ns = 0;n_ns < gen_nb_xmlNodeSetPtr;n_ns++) {
45490: mem_base = xmlMemBlocks();
45491: ns = gen_xmlNodeSetPtr(n_ns, 0);
45492:
45493: ret_val = xmlXPathCastNodeSetToBoolean(ns);
45494: desret_int(ret_val);
45495: call_tests++;
45496: des_xmlNodeSetPtr(n_ns, ns, 0);
45497: xmlResetLastError();
45498: if (mem_base != xmlMemBlocks()) {
45499: printf("Leak of %d blocks found in xmlXPathCastNodeSetToBoolean",
45500: xmlMemBlocks() - mem_base);
45501: test_ret++;
45502: printf(" %d", n_ns);
45503: printf("\n");
45504: }
45505: }
45506: function_tests++;
45507: #endif
45508:
45509: return(test_ret);
45510: }
45511:
45512:
45513: static int
45514: test_xmlXPathCastNodeSetToNumber(void) {
45515: int test_ret = 0;
45516:
45517: #if defined(LIBXML_XPATH_ENABLED)
45518: int mem_base;
45519: double ret_val;
45520: xmlNodeSetPtr ns; /* a node-set */
45521: int n_ns;
45522:
45523: for (n_ns = 0;n_ns < gen_nb_xmlNodeSetPtr;n_ns++) {
45524: mem_base = xmlMemBlocks();
45525: ns = gen_xmlNodeSetPtr(n_ns, 0);
45526:
45527: ret_val = xmlXPathCastNodeSetToNumber(ns);
45528: desret_double(ret_val);
45529: call_tests++;
45530: des_xmlNodeSetPtr(n_ns, ns, 0);
45531: xmlResetLastError();
45532: if (mem_base != xmlMemBlocks()) {
45533: printf("Leak of %d blocks found in xmlXPathCastNodeSetToNumber",
45534: xmlMemBlocks() - mem_base);
45535: test_ret++;
45536: printf(" %d", n_ns);
45537: printf("\n");
45538: }
45539: }
45540: function_tests++;
45541: #endif
45542:
45543: return(test_ret);
45544: }
45545:
45546:
45547: static int
45548: test_xmlXPathCastNodeSetToString(void) {
45549: int test_ret = 0;
45550:
45551: #if defined(LIBXML_XPATH_ENABLED)
45552: int mem_base;
45553: xmlChar * ret_val;
45554: xmlNodeSetPtr ns; /* a node-set */
45555: int n_ns;
45556:
45557: for (n_ns = 0;n_ns < gen_nb_xmlNodeSetPtr;n_ns++) {
45558: mem_base = xmlMemBlocks();
45559: ns = gen_xmlNodeSetPtr(n_ns, 0);
45560:
45561: ret_val = xmlXPathCastNodeSetToString(ns);
45562: desret_xmlChar_ptr(ret_val);
45563: call_tests++;
45564: des_xmlNodeSetPtr(n_ns, ns, 0);
45565: xmlResetLastError();
45566: if (mem_base != xmlMemBlocks()) {
45567: printf("Leak of %d blocks found in xmlXPathCastNodeSetToString",
45568: xmlMemBlocks() - mem_base);
45569: test_ret++;
45570: printf(" %d", n_ns);
45571: printf("\n");
45572: }
45573: }
45574: function_tests++;
45575: #endif
45576:
45577: return(test_ret);
45578: }
45579:
45580:
45581: static int
45582: test_xmlXPathCastNodeToNumber(void) {
45583: int test_ret = 0;
45584:
45585: #if defined(LIBXML_XPATH_ENABLED)
45586: int mem_base;
45587: double ret_val;
45588: xmlNodePtr node; /* a node */
45589: int n_node;
45590:
45591: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
45592: mem_base = xmlMemBlocks();
45593: node = gen_xmlNodePtr(n_node, 0);
45594:
45595: ret_val = xmlXPathCastNodeToNumber(node);
45596: desret_double(ret_val);
45597: call_tests++;
45598: des_xmlNodePtr(n_node, node, 0);
45599: xmlResetLastError();
45600: if (mem_base != xmlMemBlocks()) {
45601: printf("Leak of %d blocks found in xmlXPathCastNodeToNumber",
45602: xmlMemBlocks() - mem_base);
45603: test_ret++;
45604: printf(" %d", n_node);
45605: printf("\n");
45606: }
45607: }
45608: function_tests++;
45609: #endif
45610:
45611: return(test_ret);
45612: }
45613:
45614:
45615: static int
45616: test_xmlXPathCastNodeToString(void) {
45617: int test_ret = 0;
45618:
45619: #if defined(LIBXML_XPATH_ENABLED)
45620: int mem_base;
45621: xmlChar * ret_val;
45622: xmlNodePtr node; /* a node */
45623: int n_node;
45624:
45625: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
45626: mem_base = xmlMemBlocks();
45627: node = gen_xmlNodePtr(n_node, 0);
45628:
45629: ret_val = xmlXPathCastNodeToString(node);
45630: desret_xmlChar_ptr(ret_val);
45631: call_tests++;
45632: des_xmlNodePtr(n_node, node, 0);
45633: xmlResetLastError();
45634: if (mem_base != xmlMemBlocks()) {
45635: printf("Leak of %d blocks found in xmlXPathCastNodeToString",
45636: xmlMemBlocks() - mem_base);
45637: test_ret++;
45638: printf(" %d", n_node);
45639: printf("\n");
45640: }
45641: }
45642: function_tests++;
45643: #endif
45644:
45645: return(test_ret);
45646: }
45647:
45648:
45649: static int
45650: test_xmlXPathCastNumberToBoolean(void) {
45651: int test_ret = 0;
45652:
45653: #if defined(LIBXML_XPATH_ENABLED)
45654: int mem_base;
45655: int ret_val;
45656: double val; /* a number */
45657: int n_val;
45658:
45659: for (n_val = 0;n_val < gen_nb_double;n_val++) {
45660: mem_base = xmlMemBlocks();
45661: val = gen_double(n_val, 0);
45662:
45663: ret_val = xmlXPathCastNumberToBoolean(val);
45664: desret_int(ret_val);
45665: call_tests++;
45666: des_double(n_val, val, 0);
45667: xmlResetLastError();
45668: if (mem_base != xmlMemBlocks()) {
45669: printf("Leak of %d blocks found in xmlXPathCastNumberToBoolean",
45670: xmlMemBlocks() - mem_base);
45671: test_ret++;
45672: printf(" %d", n_val);
45673: printf("\n");
45674: }
45675: }
45676: function_tests++;
45677: #endif
45678:
45679: return(test_ret);
45680: }
45681:
45682:
45683: static int
45684: test_xmlXPathCastNumberToString(void) {
45685: int test_ret = 0;
45686:
45687: #if defined(LIBXML_XPATH_ENABLED)
45688: int mem_base;
45689: xmlChar * ret_val;
45690: double val; /* a number */
45691: int n_val;
45692:
45693: for (n_val = 0;n_val < gen_nb_double;n_val++) {
45694: mem_base = xmlMemBlocks();
45695: val = gen_double(n_val, 0);
45696:
45697: ret_val = xmlXPathCastNumberToString(val);
45698: desret_xmlChar_ptr(ret_val);
45699: call_tests++;
45700: des_double(n_val, val, 0);
45701: xmlResetLastError();
45702: if (mem_base != xmlMemBlocks()) {
45703: printf("Leak of %d blocks found in xmlXPathCastNumberToString",
45704: xmlMemBlocks() - mem_base);
45705: test_ret++;
45706: printf(" %d", n_val);
45707: printf("\n");
45708: }
45709: }
45710: function_tests++;
45711: #endif
45712:
45713: return(test_ret);
45714: }
45715:
45716:
45717: static int
45718: test_xmlXPathCastStringToBoolean(void) {
45719: int test_ret = 0;
45720:
45721: #if defined(LIBXML_XPATH_ENABLED)
45722: int mem_base;
45723: int ret_val;
45724: xmlChar * val; /* a string */
45725: int n_val;
45726:
45727: for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) {
45728: mem_base = xmlMemBlocks();
45729: val = gen_const_xmlChar_ptr(n_val, 0);
45730:
45731: ret_val = xmlXPathCastStringToBoolean((const xmlChar *)val);
45732: desret_int(ret_val);
45733: call_tests++;
45734: des_const_xmlChar_ptr(n_val, (const xmlChar *)val, 0);
45735: xmlResetLastError();
45736: if (mem_base != xmlMemBlocks()) {
45737: printf("Leak of %d blocks found in xmlXPathCastStringToBoolean",
45738: xmlMemBlocks() - mem_base);
45739: test_ret++;
45740: printf(" %d", n_val);
45741: printf("\n");
45742: }
45743: }
45744: function_tests++;
45745: #endif
45746:
45747: return(test_ret);
45748: }
45749:
45750:
45751: static int
45752: test_xmlXPathCastStringToNumber(void) {
45753: int test_ret = 0;
45754:
45755: #if defined(LIBXML_XPATH_ENABLED)
45756: int mem_base;
45757: double ret_val;
45758: xmlChar * val; /* a string */
45759: int n_val;
45760:
45761: for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) {
45762: mem_base = xmlMemBlocks();
45763: val = gen_const_xmlChar_ptr(n_val, 0);
45764:
45765: ret_val = xmlXPathCastStringToNumber((const xmlChar *)val);
45766: desret_double(ret_val);
45767: call_tests++;
45768: des_const_xmlChar_ptr(n_val, (const xmlChar *)val, 0);
45769: xmlResetLastError();
45770: if (mem_base != xmlMemBlocks()) {
45771: printf("Leak of %d blocks found in xmlXPathCastStringToNumber",
45772: xmlMemBlocks() - mem_base);
45773: test_ret++;
45774: printf(" %d", n_val);
45775: printf("\n");
45776: }
45777: }
45778: function_tests++;
45779: #endif
45780:
45781: return(test_ret);
45782: }
45783:
45784:
45785: static int
45786: test_xmlXPathCastToBoolean(void) {
45787: int test_ret = 0;
45788:
45789: #if defined(LIBXML_XPATH_ENABLED)
45790: int mem_base;
45791: int ret_val;
45792: xmlXPathObjectPtr val; /* an XPath object */
45793: int n_val;
45794:
45795: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
45796: mem_base = xmlMemBlocks();
45797: val = gen_xmlXPathObjectPtr(n_val, 0);
45798:
45799: ret_val = xmlXPathCastToBoolean(val);
45800: desret_int(ret_val);
45801: call_tests++;
45802: des_xmlXPathObjectPtr(n_val, val, 0);
45803: xmlResetLastError();
45804: if (mem_base != xmlMemBlocks()) {
45805: printf("Leak of %d blocks found in xmlXPathCastToBoolean",
45806: xmlMemBlocks() - mem_base);
45807: test_ret++;
45808: printf(" %d", n_val);
45809: printf("\n");
45810: }
45811: }
45812: function_tests++;
45813: #endif
45814:
45815: return(test_ret);
45816: }
45817:
45818:
45819: static int
45820: test_xmlXPathCastToNumber(void) {
45821: int test_ret = 0;
45822:
45823: #if defined(LIBXML_XPATH_ENABLED)
45824: int mem_base;
45825: double ret_val;
45826: xmlXPathObjectPtr val; /* an XPath object */
45827: int n_val;
45828:
45829: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
45830: mem_base = xmlMemBlocks();
45831: val = gen_xmlXPathObjectPtr(n_val, 0);
45832:
45833: ret_val = xmlXPathCastToNumber(val);
45834: desret_double(ret_val);
45835: call_tests++;
45836: des_xmlXPathObjectPtr(n_val, val, 0);
45837: xmlResetLastError();
45838: if (mem_base != xmlMemBlocks()) {
45839: printf("Leak of %d blocks found in xmlXPathCastToNumber",
45840: xmlMemBlocks() - mem_base);
45841: test_ret++;
45842: printf(" %d", n_val);
45843: printf("\n");
45844: }
45845: }
45846: function_tests++;
45847: #endif
45848:
45849: return(test_ret);
45850: }
45851:
45852:
45853: static int
45854: test_xmlXPathCastToString(void) {
45855: int test_ret = 0;
45856:
45857: #if defined(LIBXML_XPATH_ENABLED)
45858: int mem_base;
45859: xmlChar * ret_val;
45860: xmlXPathObjectPtr val; /* an XPath object */
45861: int n_val;
45862:
45863: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
45864: mem_base = xmlMemBlocks();
45865: val = gen_xmlXPathObjectPtr(n_val, 0);
45866:
45867: ret_val = xmlXPathCastToString(val);
45868: desret_xmlChar_ptr(ret_val);
45869: call_tests++;
45870: des_xmlXPathObjectPtr(n_val, val, 0);
45871: xmlResetLastError();
45872: if (mem_base != xmlMemBlocks()) {
45873: printf("Leak of %d blocks found in xmlXPathCastToString",
45874: xmlMemBlocks() - mem_base);
45875: test_ret++;
45876: printf(" %d", n_val);
45877: printf("\n");
45878: }
45879: }
45880: function_tests++;
45881: #endif
45882:
45883: return(test_ret);
45884: }
45885:
45886:
45887: static int
45888: test_xmlXPathCmpNodes(void) {
45889: int test_ret = 0;
45890:
45891: #if defined(LIBXML_XPATH_ENABLED)
45892: int mem_base;
45893: int ret_val;
45894: xmlNodePtr node1; /* the first node */
45895: int n_node1;
45896: xmlNodePtr node2; /* the second node */
45897: int n_node2;
45898:
45899: for (n_node1 = 0;n_node1 < gen_nb_xmlNodePtr;n_node1++) {
45900: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
45901: mem_base = xmlMemBlocks();
45902: node1 = gen_xmlNodePtr(n_node1, 0);
45903: node2 = gen_xmlNodePtr(n_node2, 1);
45904:
45905: ret_val = xmlXPathCmpNodes(node1, node2);
45906: desret_int(ret_val);
45907: call_tests++;
45908: des_xmlNodePtr(n_node1, node1, 0);
45909: des_xmlNodePtr(n_node2, node2, 1);
45910: xmlResetLastError();
45911: if (mem_base != xmlMemBlocks()) {
45912: printf("Leak of %d blocks found in xmlXPathCmpNodes",
45913: xmlMemBlocks() - mem_base);
45914: test_ret++;
45915: printf(" %d", n_node1);
45916: printf(" %d", n_node2);
45917: printf("\n");
45918: }
45919: }
45920: }
45921: function_tests++;
45922: #endif
45923:
45924: return(test_ret);
45925: }
45926:
45927:
45928: static int
45929: test_xmlXPathCompile(void) {
45930: int test_ret = 0;
45931:
45932:
45933: /* missing type support */
45934: return(test_ret);
45935: }
45936:
45937: #ifdef LIBXML_XPATH_ENABLED
45938:
45939: #define gen_nb_xmlXPathCompExprPtr 1
45940: static xmlXPathCompExprPtr gen_xmlXPathCompExprPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
45941: return(NULL);
45942: }
45943: static void des_xmlXPathCompExprPtr(int no ATTRIBUTE_UNUSED, xmlXPathCompExprPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
45944: }
45945: #endif
45946:
45947: #ifdef LIBXML_XPATH_ENABLED
45948:
45949: #define gen_nb_xmlXPathContextPtr 1
45950: static xmlXPathContextPtr gen_xmlXPathContextPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
45951: return(NULL);
45952: }
45953: static void des_xmlXPathContextPtr(int no ATTRIBUTE_UNUSED, xmlXPathContextPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
45954: }
45955: #endif
45956:
45957:
45958: static int
45959: test_xmlXPathCompiledEval(void) {
45960: int test_ret = 0;
45961:
45962: #if defined(LIBXML_XPATH_ENABLED)
45963: int mem_base;
45964: xmlXPathObjectPtr ret_val;
45965: xmlXPathCompExprPtr comp; /* the compiled XPath expression */
45966: int n_comp;
45967: xmlXPathContextPtr ctx; /* the XPath context */
45968: int n_ctx;
45969:
45970: for (n_comp = 0;n_comp < gen_nb_xmlXPathCompExprPtr;n_comp++) {
45971: for (n_ctx = 0;n_ctx < gen_nb_xmlXPathContextPtr;n_ctx++) {
45972: mem_base = xmlMemBlocks();
45973: comp = gen_xmlXPathCompExprPtr(n_comp, 0);
45974: ctx = gen_xmlXPathContextPtr(n_ctx, 1);
45975:
45976: ret_val = xmlXPathCompiledEval(comp, ctx);
45977: desret_xmlXPathObjectPtr(ret_val);
45978: call_tests++;
45979: des_xmlXPathCompExprPtr(n_comp, comp, 0);
45980: des_xmlXPathContextPtr(n_ctx, ctx, 1);
45981: xmlResetLastError();
45982: if (mem_base != xmlMemBlocks()) {
45983: printf("Leak of %d blocks found in xmlXPathCompiledEval",
45984: xmlMemBlocks() - mem_base);
45985: test_ret++;
45986: printf(" %d", n_comp);
45987: printf(" %d", n_ctx);
45988: printf("\n");
45989: }
45990: }
45991: }
45992: function_tests++;
45993: #endif
45994:
45995: return(test_ret);
45996: }
45997:
45998:
45999: static int
46000: test_xmlXPathCompiledEvalToBoolean(void) {
46001: int test_ret = 0;
46002:
46003: #if defined(LIBXML_XPATH_ENABLED)
46004: int mem_base;
46005: int ret_val;
46006: xmlXPathCompExprPtr comp; /* the compiled XPath expression */
46007: int n_comp;
46008: xmlXPathContextPtr ctxt; /* the XPath context */
46009: int n_ctxt;
46010:
46011: for (n_comp = 0;n_comp < gen_nb_xmlXPathCompExprPtr;n_comp++) {
46012: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
46013: mem_base = xmlMemBlocks();
46014: comp = gen_xmlXPathCompExprPtr(n_comp, 0);
46015: ctxt = gen_xmlXPathContextPtr(n_ctxt, 1);
46016:
46017: ret_val = xmlXPathCompiledEvalToBoolean(comp, ctxt);
46018: desret_int(ret_val);
46019: call_tests++;
46020: des_xmlXPathCompExprPtr(n_comp, comp, 0);
46021: des_xmlXPathContextPtr(n_ctxt, ctxt, 1);
46022: xmlResetLastError();
46023: if (mem_base != xmlMemBlocks()) {
46024: printf("Leak of %d blocks found in xmlXPathCompiledEvalToBoolean",
46025: xmlMemBlocks() - mem_base);
46026: test_ret++;
46027: printf(" %d", n_comp);
46028: printf(" %d", n_ctxt);
46029: printf("\n");
46030: }
46031: }
46032: }
46033: function_tests++;
46034: #endif
46035:
46036: return(test_ret);
46037: }
46038:
46039:
46040: static int
46041: test_xmlXPathContextSetCache(void) {
46042: int test_ret = 0;
46043:
46044: #if defined(LIBXML_XPATH_ENABLED)
46045: int mem_base;
46046: int ret_val;
46047: xmlXPathContextPtr ctxt; /* the XPath context */
46048: int n_ctxt;
46049: int active; /* enables/disables (creates/frees) the cache */
46050: int n_active;
46051: int value; /* a value with semantics dependant on @options */
46052: int n_value;
46053: int options; /* options (currently only the value 0 is used) */
46054: int n_options;
46055:
46056: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
46057: for (n_active = 0;n_active < gen_nb_int;n_active++) {
46058: for (n_value = 0;n_value < gen_nb_int;n_value++) {
46059: for (n_options = 0;n_options < gen_nb_int;n_options++) {
46060: mem_base = xmlMemBlocks();
46061: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
46062: active = gen_int(n_active, 1);
46063: value = gen_int(n_value, 2);
46064: options = gen_int(n_options, 3);
46065:
46066: ret_val = xmlXPathContextSetCache(ctxt, active, value, options);
46067: desret_int(ret_val);
46068: call_tests++;
46069: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
46070: des_int(n_active, active, 1);
46071: des_int(n_value, value, 2);
46072: des_int(n_options, options, 3);
46073: xmlResetLastError();
46074: if (mem_base != xmlMemBlocks()) {
46075: printf("Leak of %d blocks found in xmlXPathContextSetCache",
46076: xmlMemBlocks() - mem_base);
46077: test_ret++;
46078: printf(" %d", n_ctxt);
46079: printf(" %d", n_active);
46080: printf(" %d", n_value);
46081: printf(" %d", n_options);
46082: printf("\n");
46083: }
46084: }
46085: }
46086: }
46087: }
46088: function_tests++;
46089: #endif
46090:
46091: return(test_ret);
46092: }
46093:
46094:
46095: static int
46096: test_xmlXPathConvertBoolean(void) {
46097: int test_ret = 0;
46098:
46099: #if defined(LIBXML_XPATH_ENABLED)
46100: int mem_base;
46101: xmlXPathObjectPtr ret_val;
46102: xmlXPathObjectPtr val; /* an XPath object */
46103: int n_val;
46104:
46105: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
46106: mem_base = xmlMemBlocks();
46107: val = gen_xmlXPathObjectPtr(n_val, 0);
46108:
46109: ret_val = xmlXPathConvertBoolean(val);
46110: val = NULL;
46111: desret_xmlXPathObjectPtr(ret_val);
46112: call_tests++;
46113: des_xmlXPathObjectPtr(n_val, val, 0);
46114: xmlResetLastError();
46115: if (mem_base != xmlMemBlocks()) {
46116: printf("Leak of %d blocks found in xmlXPathConvertBoolean",
46117: xmlMemBlocks() - mem_base);
46118: test_ret++;
46119: printf(" %d", n_val);
46120: printf("\n");
46121: }
46122: }
46123: function_tests++;
46124: #endif
46125:
46126: return(test_ret);
46127: }
46128:
46129:
46130: static int
46131: test_xmlXPathConvertNumber(void) {
46132: int test_ret = 0;
46133:
46134: #if defined(LIBXML_XPATH_ENABLED)
46135: int mem_base;
46136: xmlXPathObjectPtr ret_val;
46137: xmlXPathObjectPtr val; /* an XPath object */
46138: int n_val;
46139:
46140: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
46141: mem_base = xmlMemBlocks();
46142: val = gen_xmlXPathObjectPtr(n_val, 0);
46143:
46144: ret_val = xmlXPathConvertNumber(val);
46145: val = NULL;
46146: desret_xmlXPathObjectPtr(ret_val);
46147: call_tests++;
46148: des_xmlXPathObjectPtr(n_val, val, 0);
46149: xmlResetLastError();
46150: if (mem_base != xmlMemBlocks()) {
46151: printf("Leak of %d blocks found in xmlXPathConvertNumber",
46152: xmlMemBlocks() - mem_base);
46153: test_ret++;
46154: printf(" %d", n_val);
46155: printf("\n");
46156: }
46157: }
46158: function_tests++;
46159: #endif
46160:
46161: return(test_ret);
46162: }
46163:
46164:
46165: static int
46166: test_xmlXPathConvertString(void) {
46167: int test_ret = 0;
46168:
46169: #if defined(LIBXML_XPATH_ENABLED)
46170: int mem_base;
46171: xmlXPathObjectPtr ret_val;
46172: xmlXPathObjectPtr val; /* an XPath object */
46173: int n_val;
46174:
46175: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
46176: mem_base = xmlMemBlocks();
46177: val = gen_xmlXPathObjectPtr(n_val, 0);
46178:
46179: ret_val = xmlXPathConvertString(val);
46180: val = NULL;
46181: desret_xmlXPathObjectPtr(ret_val);
46182: call_tests++;
46183: des_xmlXPathObjectPtr(n_val, val, 0);
46184: xmlResetLastError();
46185: if (mem_base != xmlMemBlocks()) {
46186: printf("Leak of %d blocks found in xmlXPathConvertString",
46187: xmlMemBlocks() - mem_base);
46188: test_ret++;
46189: printf(" %d", n_val);
46190: printf("\n");
46191: }
46192: }
46193: function_tests++;
46194: #endif
46195:
46196: return(test_ret);
46197: }
46198:
46199:
46200: static int
46201: test_xmlXPathCtxtCompile(void) {
46202: int test_ret = 0;
46203:
46204:
46205: /* missing type support */
46206: return(test_ret);
46207: }
46208:
46209:
46210: static int
46211: test_xmlXPathEval(void) {
46212: int test_ret = 0;
46213:
46214: #if defined(LIBXML_XPATH_ENABLED)
46215: int mem_base;
46216: xmlXPathObjectPtr ret_val;
46217: xmlChar * str; /* the XPath expression */
46218: int n_str;
46219: xmlXPathContextPtr ctx; /* the XPath context */
46220: int n_ctx;
46221:
46222: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
46223: for (n_ctx = 0;n_ctx < gen_nb_xmlXPathContextPtr;n_ctx++) {
46224: mem_base = xmlMemBlocks();
46225: str = gen_const_xmlChar_ptr(n_str, 0);
46226: ctx = gen_xmlXPathContextPtr(n_ctx, 1);
46227:
46228: ret_val = xmlXPathEval((const xmlChar *)str, ctx);
46229: desret_xmlXPathObjectPtr(ret_val);
46230: call_tests++;
46231: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
46232: des_xmlXPathContextPtr(n_ctx, ctx, 1);
46233: xmlResetLastError();
46234: if (mem_base != xmlMemBlocks()) {
46235: printf("Leak of %d blocks found in xmlXPathEval",
46236: xmlMemBlocks() - mem_base);
46237: test_ret++;
46238: printf(" %d", n_str);
46239: printf(" %d", n_ctx);
46240: printf("\n");
46241: }
46242: }
46243: }
46244: function_tests++;
46245: #endif
46246:
46247: return(test_ret);
46248: }
46249:
46250:
46251: static int
46252: test_xmlXPathEvalExpression(void) {
46253: int test_ret = 0;
46254:
46255: #if defined(LIBXML_XPATH_ENABLED)
46256: int mem_base;
46257: xmlXPathObjectPtr ret_val;
46258: xmlChar * str; /* the XPath expression */
46259: int n_str;
46260: xmlXPathContextPtr ctxt; /* the XPath context */
46261: int n_ctxt;
46262:
46263: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
46264: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
46265: mem_base = xmlMemBlocks();
46266: str = gen_const_xmlChar_ptr(n_str, 0);
46267: ctxt = gen_xmlXPathContextPtr(n_ctxt, 1);
46268:
46269: ret_val = xmlXPathEvalExpression((const xmlChar *)str, ctxt);
46270: desret_xmlXPathObjectPtr(ret_val);
46271: call_tests++;
46272: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
46273: des_xmlXPathContextPtr(n_ctxt, ctxt, 1);
46274: xmlResetLastError();
46275: if (mem_base != xmlMemBlocks()) {
46276: printf("Leak of %d blocks found in xmlXPathEvalExpression",
46277: xmlMemBlocks() - mem_base);
46278: test_ret++;
46279: printf(" %d", n_str);
46280: printf(" %d", n_ctxt);
46281: printf("\n");
46282: }
46283: }
46284: }
46285: function_tests++;
46286: #endif
46287:
46288: return(test_ret);
46289: }
46290:
46291:
46292: static int
46293: test_xmlXPathEvalPredicate(void) {
46294: int test_ret = 0;
46295:
46296: #if defined(LIBXML_XPATH_ENABLED)
46297: int mem_base;
46298: int ret_val;
46299: xmlXPathContextPtr ctxt; /* the XPath context */
46300: int n_ctxt;
46301: xmlXPathObjectPtr res; /* the Predicate Expression evaluation result */
46302: int n_res;
46303:
46304: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
46305: for (n_res = 0;n_res < gen_nb_xmlXPathObjectPtr;n_res++) {
46306: mem_base = xmlMemBlocks();
46307: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
46308: res = gen_xmlXPathObjectPtr(n_res, 1);
46309:
46310: ret_val = xmlXPathEvalPredicate(ctxt, res);
46311: desret_int(ret_val);
46312: call_tests++;
46313: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
46314: des_xmlXPathObjectPtr(n_res, res, 1);
46315: xmlResetLastError();
46316: if (mem_base != xmlMemBlocks()) {
46317: printf("Leak of %d blocks found in xmlXPathEvalPredicate",
46318: xmlMemBlocks() - mem_base);
46319: test_ret++;
46320: printf(" %d", n_ctxt);
46321: printf(" %d", n_res);
46322: printf("\n");
46323: }
46324: }
46325: }
46326: function_tests++;
46327: #endif
46328:
46329: return(test_ret);
46330: }
46331:
46332:
46333: static int
46334: test_xmlXPathInit(void) {
46335: int test_ret = 0;
46336:
46337: #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
46338: int mem_base;
46339:
46340: mem_base = xmlMemBlocks();
46341:
46342: xmlXPathInit();
46343: call_tests++;
46344: xmlResetLastError();
46345: if (mem_base != xmlMemBlocks()) {
46346: printf("Leak of %d blocks found in xmlXPathInit",
46347: xmlMemBlocks() - mem_base);
46348: test_ret++;
46349: printf("\n");
46350: }
46351: function_tests++;
46352: #endif
46353:
46354: return(test_ret);
46355: }
46356:
46357:
46358: static int
46359: test_xmlXPathIsInf(void) {
46360: int test_ret = 0;
46361:
46362: #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
46363: int mem_base;
46364: int ret_val;
46365: double val; /* a double value */
46366: int n_val;
46367:
46368: for (n_val = 0;n_val < gen_nb_double;n_val++) {
46369: mem_base = xmlMemBlocks();
46370: val = gen_double(n_val, 0);
46371:
46372: ret_val = xmlXPathIsInf(val);
46373: desret_int(ret_val);
46374: call_tests++;
46375: des_double(n_val, val, 0);
46376: xmlResetLastError();
46377: if (mem_base != xmlMemBlocks()) {
46378: printf("Leak of %d blocks found in xmlXPathIsInf",
46379: xmlMemBlocks() - mem_base);
46380: test_ret++;
46381: printf(" %d", n_val);
46382: printf("\n");
46383: }
46384: }
46385: function_tests++;
46386: #endif
46387:
46388: return(test_ret);
46389: }
46390:
46391:
46392: static int
46393: test_xmlXPathIsNaN(void) {
46394: int test_ret = 0;
46395:
46396: #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
46397: int mem_base;
46398: int ret_val;
46399: double val; /* a double value */
46400: int n_val;
46401:
46402: for (n_val = 0;n_val < gen_nb_double;n_val++) {
46403: mem_base = xmlMemBlocks();
46404: val = gen_double(n_val, 0);
46405:
46406: ret_val = xmlXPathIsNaN(val);
46407: desret_int(ret_val);
46408: call_tests++;
46409: des_double(n_val, val, 0);
46410: xmlResetLastError();
46411: if (mem_base != xmlMemBlocks()) {
46412: printf("Leak of %d blocks found in xmlXPathIsNaN",
46413: xmlMemBlocks() - mem_base);
46414: test_ret++;
46415: printf(" %d", n_val);
46416: printf("\n");
46417: }
46418: }
46419: function_tests++;
46420: #endif
46421:
46422: return(test_ret);
46423: }
46424:
46425:
46426: static int
46427: test_xmlXPathNewContext(void) {
46428: int test_ret = 0;
46429:
46430:
46431: /* missing type support */
46432: return(test_ret);
46433: }
46434:
46435:
46436: static int
46437: test_xmlXPathNodeSetCreate(void) {
46438: int test_ret = 0;
46439:
46440: #if defined(LIBXML_XPATH_ENABLED)
46441: int mem_base;
46442: xmlNodeSetPtr ret_val;
46443: xmlNodePtr val; /* an initial xmlNodePtr, or NULL */
46444: int n_val;
46445:
46446: for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
46447: mem_base = xmlMemBlocks();
46448: val = gen_xmlNodePtr(n_val, 0);
46449:
46450: ret_val = xmlXPathNodeSetCreate(val);
46451: desret_xmlNodeSetPtr(ret_val);
46452: call_tests++;
46453: des_xmlNodePtr(n_val, val, 0);
46454: xmlResetLastError();
46455: if (mem_base != xmlMemBlocks()) {
46456: printf("Leak of %d blocks found in xmlXPathNodeSetCreate",
46457: xmlMemBlocks() - mem_base);
46458: test_ret++;
46459: printf(" %d", n_val);
46460: printf("\n");
46461: }
46462: }
46463: function_tests++;
46464: #endif
46465:
46466: return(test_ret);
46467: }
46468:
46469:
46470: static int
46471: test_xmlXPathObjectCopy(void) {
46472: int test_ret = 0;
46473:
46474: #if defined(LIBXML_XPATH_ENABLED)
46475: int mem_base;
46476: xmlXPathObjectPtr ret_val;
46477: xmlXPathObjectPtr val; /* the original object */
46478: int n_val;
46479:
46480: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
46481: mem_base = xmlMemBlocks();
46482: val = gen_xmlXPathObjectPtr(n_val, 0);
46483:
46484: ret_val = xmlXPathObjectCopy(val);
46485: desret_xmlXPathObjectPtr(ret_val);
46486: call_tests++;
46487: des_xmlXPathObjectPtr(n_val, val, 0);
46488: xmlResetLastError();
46489: if (mem_base != xmlMemBlocks()) {
46490: printf("Leak of %d blocks found in xmlXPathObjectCopy",
46491: xmlMemBlocks() - mem_base);
46492: test_ret++;
46493: printf(" %d", n_val);
46494: printf("\n");
46495: }
46496: }
46497: function_tests++;
46498: #endif
46499:
46500: return(test_ret);
46501: }
46502:
46503:
46504: static int
46505: test_xmlXPathOrderDocElems(void) {
46506: int test_ret = 0;
46507:
46508: #if defined(LIBXML_XPATH_ENABLED)
46509: int mem_base;
46510: long ret_val;
46511: xmlDocPtr doc; /* an input document */
46512: int n_doc;
46513:
46514: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
46515: mem_base = xmlMemBlocks();
46516: doc = gen_xmlDocPtr(n_doc, 0);
46517:
46518: ret_val = xmlXPathOrderDocElems(doc);
46519: desret_long(ret_val);
46520: call_tests++;
46521: des_xmlDocPtr(n_doc, doc, 0);
46522: xmlResetLastError();
46523: if (mem_base != xmlMemBlocks()) {
46524: printf("Leak of %d blocks found in xmlXPathOrderDocElems",
46525: xmlMemBlocks() - mem_base);
46526: test_ret++;
46527: printf(" %d", n_doc);
46528: printf("\n");
46529: }
46530: }
46531: function_tests++;
46532: #endif
46533:
46534: return(test_ret);
46535: }
46536:
46537: static int
46538: test_xpath(void) {
46539: int test_ret = 0;
46540:
46541: if (quiet == 0) printf("Testing xpath : 30 of 38 functions ...\n");
46542: test_ret += test_xmlXPathCastBooleanToNumber();
46543: test_ret += test_xmlXPathCastBooleanToString();
46544: test_ret += test_xmlXPathCastNodeSetToBoolean();
46545: test_ret += test_xmlXPathCastNodeSetToNumber();
46546: test_ret += test_xmlXPathCastNodeSetToString();
46547: test_ret += test_xmlXPathCastNodeToNumber();
46548: test_ret += test_xmlXPathCastNodeToString();
46549: test_ret += test_xmlXPathCastNumberToBoolean();
46550: test_ret += test_xmlXPathCastNumberToString();
46551: test_ret += test_xmlXPathCastStringToBoolean();
46552: test_ret += test_xmlXPathCastStringToNumber();
46553: test_ret += test_xmlXPathCastToBoolean();
46554: test_ret += test_xmlXPathCastToNumber();
46555: test_ret += test_xmlXPathCastToString();
46556: test_ret += test_xmlXPathCmpNodes();
46557: test_ret += test_xmlXPathCompile();
46558: test_ret += test_xmlXPathCompiledEval();
46559: test_ret += test_xmlXPathCompiledEvalToBoolean();
46560: test_ret += test_xmlXPathContextSetCache();
46561: test_ret += test_xmlXPathConvertBoolean();
46562: test_ret += test_xmlXPathConvertNumber();
46563: test_ret += test_xmlXPathConvertString();
46564: test_ret += test_xmlXPathCtxtCompile();
46565: test_ret += test_xmlXPathEval();
46566: test_ret += test_xmlXPathEvalExpression();
46567: test_ret += test_xmlXPathEvalPredicate();
46568: test_ret += test_xmlXPathInit();
46569: test_ret += test_xmlXPathIsInf();
46570: test_ret += test_xmlXPathIsNaN();
46571: test_ret += test_xmlXPathNewContext();
46572: test_ret += test_xmlXPathNodeSetCreate();
46573: test_ret += test_xmlXPathObjectCopy();
46574: test_ret += test_xmlXPathOrderDocElems();
46575:
46576: if (test_ret != 0)
46577: printf("Module xpath: %d errors\n", test_ret);
46578: return(test_ret);
46579: }
46580: #ifdef LIBXML_XPATH_ENABLED
46581:
46582: #define gen_nb_xmlXPathParserContextPtr 1
46583: static xmlXPathParserContextPtr gen_xmlXPathParserContextPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
46584: return(NULL);
46585: }
46586: static void des_xmlXPathParserContextPtr(int no ATTRIBUTE_UNUSED, xmlXPathParserContextPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
46587: }
46588: #endif
46589:
46590:
46591: static int
46592: test_valuePop(void) {
46593: int test_ret = 0;
46594:
46595: #if defined(LIBXML_XPATH_ENABLED)
46596: int mem_base;
46597: xmlXPathObjectPtr ret_val;
46598: xmlXPathParserContextPtr ctxt; /* an XPath evaluation context */
46599: int n_ctxt;
46600:
46601: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
46602: mem_base = xmlMemBlocks();
46603: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
46604:
46605: ret_val = valuePop(ctxt);
46606: desret_xmlXPathObjectPtr(ret_val);
46607: call_tests++;
46608: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
46609: xmlResetLastError();
46610: if (mem_base != xmlMemBlocks()) {
46611: printf("Leak of %d blocks found in valuePop",
46612: xmlMemBlocks() - mem_base);
46613: test_ret++;
46614: printf(" %d", n_ctxt);
46615: printf("\n");
46616: }
46617: }
46618: function_tests++;
46619: #endif
46620:
46621: return(test_ret);
46622: }
46623:
46624:
46625: static int
46626: test_valuePush(void) {
46627: int test_ret = 0;
46628:
46629: #if defined(LIBXML_XPATH_ENABLED)
46630: int mem_base;
46631: int ret_val;
46632: xmlXPathParserContextPtr ctxt; /* an XPath evaluation context */
46633: int n_ctxt;
46634: xmlXPathObjectPtr value; /* the XPath object */
46635: int n_value;
46636:
46637: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
46638: for (n_value = 0;n_value < gen_nb_xmlXPathObjectPtr;n_value++) {
46639: mem_base = xmlMemBlocks();
46640: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
46641: value = gen_xmlXPathObjectPtr(n_value, 1);
46642:
46643: ret_val = valuePush(ctxt, value);
46644: desret_int(ret_val);
46645: call_tests++;
46646: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
46647: des_xmlXPathObjectPtr(n_value, value, 1);
46648: xmlResetLastError();
46649: if (mem_base != xmlMemBlocks()) {
46650: printf("Leak of %d blocks found in valuePush",
46651: xmlMemBlocks() - mem_base);
46652: test_ret++;
46653: printf(" %d", n_ctxt);
46654: printf(" %d", n_value);
46655: printf("\n");
46656: }
46657: }
46658: }
46659: function_tests++;
46660: #endif
46661:
46662: return(test_ret);
46663: }
46664:
46665:
46666: static int
46667: test_xmlXPathAddValues(void) {
46668: int test_ret = 0;
46669:
46670: #if defined(LIBXML_XPATH_ENABLED)
46671: int mem_base;
46672: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
46673: int n_ctxt;
46674:
46675: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
46676: mem_base = xmlMemBlocks();
46677: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
46678:
46679: xmlXPathAddValues(ctxt);
46680: call_tests++;
46681: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
46682: xmlResetLastError();
46683: if (mem_base != xmlMemBlocks()) {
46684: printf("Leak of %d blocks found in xmlXPathAddValues",
46685: xmlMemBlocks() - mem_base);
46686: test_ret++;
46687: printf(" %d", n_ctxt);
46688: printf("\n");
46689: }
46690: }
46691: function_tests++;
46692: #endif
46693:
46694: return(test_ret);
46695: }
46696:
46697:
46698: static int
46699: test_xmlXPathBooleanFunction(void) {
46700: int test_ret = 0;
46701:
46702: #if defined(LIBXML_XPATH_ENABLED)
46703: int mem_base;
46704: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
46705: int n_ctxt;
46706: int nargs; /* the number of arguments */
46707: int n_nargs;
46708:
46709: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
46710: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
46711: mem_base = xmlMemBlocks();
46712: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
46713: nargs = gen_int(n_nargs, 1);
46714:
46715: xmlXPathBooleanFunction(ctxt, nargs);
46716: call_tests++;
46717: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
46718: des_int(n_nargs, nargs, 1);
46719: xmlResetLastError();
46720: if (mem_base != xmlMemBlocks()) {
46721: printf("Leak of %d blocks found in xmlXPathBooleanFunction",
46722: xmlMemBlocks() - mem_base);
46723: test_ret++;
46724: printf(" %d", n_ctxt);
46725: printf(" %d", n_nargs);
46726: printf("\n");
46727: }
46728: }
46729: }
46730: function_tests++;
46731: #endif
46732:
46733: return(test_ret);
46734: }
46735:
46736:
46737: static int
46738: test_xmlXPathCeilingFunction(void) {
46739: int test_ret = 0;
46740:
46741: #if defined(LIBXML_XPATH_ENABLED)
46742: int mem_base;
46743: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
46744: int n_ctxt;
46745: int nargs; /* the number of arguments */
46746: int n_nargs;
46747:
46748: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
46749: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
46750: mem_base = xmlMemBlocks();
46751: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
46752: nargs = gen_int(n_nargs, 1);
46753:
46754: xmlXPathCeilingFunction(ctxt, nargs);
46755: call_tests++;
46756: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
46757: des_int(n_nargs, nargs, 1);
46758: xmlResetLastError();
46759: if (mem_base != xmlMemBlocks()) {
46760: printf("Leak of %d blocks found in xmlXPathCeilingFunction",
46761: xmlMemBlocks() - mem_base);
46762: test_ret++;
46763: printf(" %d", n_ctxt);
46764: printf(" %d", n_nargs);
46765: printf("\n");
46766: }
46767: }
46768: }
46769: function_tests++;
46770: #endif
46771:
46772: return(test_ret);
46773: }
46774:
46775:
46776: static int
46777: test_xmlXPathCompareValues(void) {
46778: int test_ret = 0;
46779:
46780: #if defined(LIBXML_XPATH_ENABLED)
46781: int mem_base;
46782: int ret_val;
46783: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
46784: int n_ctxt;
46785: int inf; /* less than (1) or greater than (0) */
46786: int n_inf;
46787: int strict; /* is the comparison strict */
46788: int n_strict;
46789:
46790: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
46791: for (n_inf = 0;n_inf < gen_nb_int;n_inf++) {
46792: for (n_strict = 0;n_strict < gen_nb_int;n_strict++) {
46793: mem_base = xmlMemBlocks();
46794: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
46795: inf = gen_int(n_inf, 1);
46796: strict = gen_int(n_strict, 2);
46797:
46798: ret_val = xmlXPathCompareValues(ctxt, inf, strict);
46799: desret_int(ret_val);
46800: call_tests++;
46801: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
46802: des_int(n_inf, inf, 1);
46803: des_int(n_strict, strict, 2);
46804: xmlResetLastError();
46805: if (mem_base != xmlMemBlocks()) {
46806: printf("Leak of %d blocks found in xmlXPathCompareValues",
46807: xmlMemBlocks() - mem_base);
46808: test_ret++;
46809: printf(" %d", n_ctxt);
46810: printf(" %d", n_inf);
46811: printf(" %d", n_strict);
46812: printf("\n");
46813: }
46814: }
46815: }
46816: }
46817: function_tests++;
46818: #endif
46819:
46820: return(test_ret);
46821: }
46822:
46823:
46824: static int
46825: test_xmlXPathConcatFunction(void) {
46826: int test_ret = 0;
46827:
46828: #if defined(LIBXML_XPATH_ENABLED)
46829: int mem_base;
46830: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
46831: int n_ctxt;
46832: int nargs; /* the number of arguments */
46833: int n_nargs;
46834:
46835: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
46836: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
46837: mem_base = xmlMemBlocks();
46838: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
46839: nargs = gen_int(n_nargs, 1);
46840:
46841: xmlXPathConcatFunction(ctxt, nargs);
46842: call_tests++;
46843: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
46844: des_int(n_nargs, nargs, 1);
46845: xmlResetLastError();
46846: if (mem_base != xmlMemBlocks()) {
46847: printf("Leak of %d blocks found in xmlXPathConcatFunction",
46848: xmlMemBlocks() - mem_base);
46849: test_ret++;
46850: printf(" %d", n_ctxt);
46851: printf(" %d", n_nargs);
46852: printf("\n");
46853: }
46854: }
46855: }
46856: function_tests++;
46857: #endif
46858:
46859: return(test_ret);
46860: }
46861:
46862:
46863: static int
46864: test_xmlXPathContainsFunction(void) {
46865: int test_ret = 0;
46866:
46867: #if defined(LIBXML_XPATH_ENABLED)
46868: int mem_base;
46869: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
46870: int n_ctxt;
46871: int nargs; /* the number of arguments */
46872: int n_nargs;
46873:
46874: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
46875: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
46876: mem_base = xmlMemBlocks();
46877: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
46878: nargs = gen_int(n_nargs, 1);
46879:
46880: xmlXPathContainsFunction(ctxt, nargs);
46881: call_tests++;
46882: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
46883: des_int(n_nargs, nargs, 1);
46884: xmlResetLastError();
46885: if (mem_base != xmlMemBlocks()) {
46886: printf("Leak of %d blocks found in xmlXPathContainsFunction",
46887: xmlMemBlocks() - mem_base);
46888: test_ret++;
46889: printf(" %d", n_ctxt);
46890: printf(" %d", n_nargs);
46891: printf("\n");
46892: }
46893: }
46894: }
46895: function_tests++;
46896: #endif
46897:
46898: return(test_ret);
46899: }
46900:
46901:
46902: static int
46903: test_xmlXPathCountFunction(void) {
46904: int test_ret = 0;
46905:
46906: #if defined(LIBXML_XPATH_ENABLED)
46907: int mem_base;
46908: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
46909: int n_ctxt;
46910: int nargs; /* the number of arguments */
46911: int n_nargs;
46912:
46913: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
46914: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
46915: mem_base = xmlMemBlocks();
46916: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
46917: nargs = gen_int(n_nargs, 1);
46918:
46919: xmlXPathCountFunction(ctxt, nargs);
46920: call_tests++;
46921: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
46922: des_int(n_nargs, nargs, 1);
46923: xmlResetLastError();
46924: if (mem_base != xmlMemBlocks()) {
46925: printf("Leak of %d blocks found in xmlXPathCountFunction",
46926: xmlMemBlocks() - mem_base);
46927: test_ret++;
46928: printf(" %d", n_ctxt);
46929: printf(" %d", n_nargs);
46930: printf("\n");
46931: }
46932: }
46933: }
46934: function_tests++;
46935: #endif
46936:
46937: return(test_ret);
46938: }
46939:
46940:
46941: static int
46942: test_xmlXPathDebugDumpCompExpr(void) {
46943: int test_ret = 0;
46944:
46945: #if defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_DEBUG_ENABLED)
46946: int mem_base;
46947: FILE * output; /* the FILE * for the output */
46948: int n_output;
46949: xmlXPathCompExprPtr comp; /* the precompiled XPath expression */
46950: int n_comp;
46951: int depth; /* the indentation level. */
46952: int n_depth;
46953:
46954: for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
46955: for (n_comp = 0;n_comp < gen_nb_xmlXPathCompExprPtr;n_comp++) {
46956: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
46957: mem_base = xmlMemBlocks();
46958: output = gen_FILE_ptr(n_output, 0);
46959: comp = gen_xmlXPathCompExprPtr(n_comp, 1);
46960: depth = gen_int(n_depth, 2);
46961:
46962: xmlXPathDebugDumpCompExpr(output, comp, depth);
46963: call_tests++;
46964: des_FILE_ptr(n_output, output, 0);
46965: des_xmlXPathCompExprPtr(n_comp, comp, 1);
46966: des_int(n_depth, depth, 2);
46967: xmlResetLastError();
46968: if (mem_base != xmlMemBlocks()) {
46969: printf("Leak of %d blocks found in xmlXPathDebugDumpCompExpr",
46970: xmlMemBlocks() - mem_base);
46971: test_ret++;
46972: printf(" %d", n_output);
46973: printf(" %d", n_comp);
46974: printf(" %d", n_depth);
46975: printf("\n");
46976: }
46977: }
46978: }
46979: }
46980: function_tests++;
46981: #endif
46982:
46983: return(test_ret);
46984: }
46985:
46986:
46987: static int
46988: test_xmlXPathDebugDumpObject(void) {
46989: int test_ret = 0;
46990:
46991: #if defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_DEBUG_ENABLED)
46992: int mem_base;
46993: FILE * output; /* the FILE * to dump the output */
46994: int n_output;
46995: xmlXPathObjectPtr cur; /* the object to inspect */
46996: int n_cur;
46997: int depth; /* indentation level */
46998: int n_depth;
46999:
47000: for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
47001: for (n_cur = 0;n_cur < gen_nb_xmlXPathObjectPtr;n_cur++) {
47002: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
47003: mem_base = xmlMemBlocks();
47004: output = gen_FILE_ptr(n_output, 0);
47005: cur = gen_xmlXPathObjectPtr(n_cur, 1);
47006: depth = gen_int(n_depth, 2);
47007:
47008: xmlXPathDebugDumpObject(output, cur, depth);
47009: call_tests++;
47010: des_FILE_ptr(n_output, output, 0);
47011: des_xmlXPathObjectPtr(n_cur, cur, 1);
47012: des_int(n_depth, depth, 2);
47013: xmlResetLastError();
47014: if (mem_base != xmlMemBlocks()) {
47015: printf("Leak of %d blocks found in xmlXPathDebugDumpObject",
47016: xmlMemBlocks() - mem_base);
47017: test_ret++;
47018: printf(" %d", n_output);
47019: printf(" %d", n_cur);
47020: printf(" %d", n_depth);
47021: printf("\n");
47022: }
47023: }
47024: }
47025: }
47026: function_tests++;
47027: #endif
47028:
47029: return(test_ret);
47030: }
47031:
47032:
47033: static int
47034: test_xmlXPathDifference(void) {
47035: int test_ret = 0;
47036:
47037: #if defined(LIBXML_XPATH_ENABLED)
47038: int mem_base;
47039: xmlNodeSetPtr ret_val;
47040: xmlNodeSetPtr nodes1; /* a node-set */
47041: int n_nodes1;
47042: xmlNodeSetPtr nodes2; /* a node-set */
47043: int n_nodes2;
47044:
47045: for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
47046: for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
47047: mem_base = xmlMemBlocks();
47048: nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
47049: nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
47050:
47051: ret_val = xmlXPathDifference(nodes1, nodes2);
47052: desret_xmlNodeSetPtr(ret_val);
47053: call_tests++;
47054: des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
47055: des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
47056: xmlResetLastError();
47057: if (mem_base != xmlMemBlocks()) {
47058: printf("Leak of %d blocks found in xmlXPathDifference",
47059: xmlMemBlocks() - mem_base);
47060: test_ret++;
47061: printf(" %d", n_nodes1);
47062: printf(" %d", n_nodes2);
47063: printf("\n");
47064: }
47065: }
47066: }
47067: function_tests++;
47068: #endif
47069:
47070: return(test_ret);
47071: }
47072:
47073:
47074: static int
47075: test_xmlXPathDistinct(void) {
47076: int test_ret = 0;
47077:
47078: #if defined(LIBXML_XPATH_ENABLED)
47079: int mem_base;
47080: xmlNodeSetPtr ret_val;
47081: xmlNodeSetPtr nodes; /* a node-set */
47082: int n_nodes;
47083:
47084: for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
47085: mem_base = xmlMemBlocks();
47086: nodes = gen_xmlNodeSetPtr(n_nodes, 0);
47087:
47088: ret_val = xmlXPathDistinct(nodes);
47089: desret_xmlNodeSetPtr(ret_val);
47090: call_tests++;
47091: des_xmlNodeSetPtr(n_nodes, nodes, 0);
47092: xmlResetLastError();
47093: if (mem_base != xmlMemBlocks()) {
47094: printf("Leak of %d blocks found in xmlXPathDistinct",
47095: xmlMemBlocks() - mem_base);
47096: test_ret++;
47097: printf(" %d", n_nodes);
47098: printf("\n");
47099: }
47100: }
47101: function_tests++;
47102: #endif
47103:
47104: return(test_ret);
47105: }
47106:
47107:
47108: static int
47109: test_xmlXPathDistinctSorted(void) {
47110: int test_ret = 0;
47111:
47112: #if defined(LIBXML_XPATH_ENABLED)
47113: int mem_base;
47114: xmlNodeSetPtr ret_val;
47115: xmlNodeSetPtr nodes; /* a node-set, sorted by document order */
47116: int n_nodes;
47117:
47118: for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
47119: mem_base = xmlMemBlocks();
47120: nodes = gen_xmlNodeSetPtr(n_nodes, 0);
47121:
47122: ret_val = xmlXPathDistinctSorted(nodes);
47123: desret_xmlNodeSetPtr(ret_val);
47124: call_tests++;
47125: des_xmlNodeSetPtr(n_nodes, nodes, 0);
47126: xmlResetLastError();
47127: if (mem_base != xmlMemBlocks()) {
47128: printf("Leak of %d blocks found in xmlXPathDistinctSorted",
47129: xmlMemBlocks() - mem_base);
47130: test_ret++;
47131: printf(" %d", n_nodes);
47132: printf("\n");
47133: }
47134: }
47135: function_tests++;
47136: #endif
47137:
47138: return(test_ret);
47139: }
47140:
47141:
47142: static int
47143: test_xmlXPathDivValues(void) {
47144: int test_ret = 0;
47145:
47146: #if defined(LIBXML_XPATH_ENABLED)
47147: int mem_base;
47148: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47149: int n_ctxt;
47150:
47151: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47152: mem_base = xmlMemBlocks();
47153: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47154:
47155: xmlXPathDivValues(ctxt);
47156: call_tests++;
47157: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47158: xmlResetLastError();
47159: if (mem_base != xmlMemBlocks()) {
47160: printf("Leak of %d blocks found in xmlXPathDivValues",
47161: xmlMemBlocks() - mem_base);
47162: test_ret++;
47163: printf(" %d", n_ctxt);
47164: printf("\n");
47165: }
47166: }
47167: function_tests++;
47168: #endif
47169:
47170: return(test_ret);
47171: }
47172:
47173:
47174: static int
47175: test_xmlXPathEqualValues(void) {
47176: int test_ret = 0;
47177:
47178: #if defined(LIBXML_XPATH_ENABLED)
47179: int mem_base;
47180: int ret_val;
47181: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47182: int n_ctxt;
47183:
47184: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47185: mem_base = xmlMemBlocks();
47186: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47187:
47188: ret_val = xmlXPathEqualValues(ctxt);
47189: desret_int(ret_val);
47190: call_tests++;
47191: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47192: xmlResetLastError();
47193: if (mem_base != xmlMemBlocks()) {
47194: printf("Leak of %d blocks found in xmlXPathEqualValues",
47195: xmlMemBlocks() - mem_base);
47196: test_ret++;
47197: printf(" %d", n_ctxt);
47198: printf("\n");
47199: }
47200: }
47201: function_tests++;
47202: #endif
47203:
47204: return(test_ret);
47205: }
47206:
47207:
47208: static int
47209: test_xmlXPathErr(void) {
47210: int test_ret = 0;
47211:
47212: #if defined(LIBXML_XPATH_ENABLED)
47213: int mem_base;
47214: xmlXPathParserContextPtr ctxt; /* a XPath parser context */
47215: int n_ctxt;
47216: int error; /* the error code */
47217: int n_error;
47218:
47219: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47220: for (n_error = 0;n_error < gen_nb_int;n_error++) {
47221: mem_base = xmlMemBlocks();
47222: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47223: error = gen_int(n_error, 1);
47224:
47225: xmlXPathErr(ctxt, error);
47226: call_tests++;
47227: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47228: des_int(n_error, error, 1);
47229: xmlResetLastError();
47230: if (mem_base != xmlMemBlocks()) {
47231: printf("Leak of %d blocks found in xmlXPathErr",
47232: xmlMemBlocks() - mem_base);
47233: test_ret++;
47234: printf(" %d", n_ctxt);
47235: printf(" %d", n_error);
47236: printf("\n");
47237: }
47238: }
47239: }
47240: function_tests++;
47241: #endif
47242:
47243: return(test_ret);
47244: }
47245:
47246:
47247: static int
47248: test_xmlXPathEvalExpr(void) {
47249: int test_ret = 0;
47250:
47251: #if defined(LIBXML_XPATH_ENABLED)
47252: int mem_base;
47253: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47254: int n_ctxt;
47255:
47256: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47257: mem_base = xmlMemBlocks();
47258: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47259:
47260: xmlXPathEvalExpr(ctxt);
47261: call_tests++;
47262: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47263: xmlResetLastError();
47264: if (mem_base != xmlMemBlocks()) {
47265: printf("Leak of %d blocks found in xmlXPathEvalExpr",
47266: xmlMemBlocks() - mem_base);
47267: test_ret++;
47268: printf(" %d", n_ctxt);
47269: printf("\n");
47270: }
47271: }
47272: function_tests++;
47273: #endif
47274:
47275: return(test_ret);
47276: }
47277:
47278:
47279: static int
47280: test_xmlXPathEvaluatePredicateResult(void) {
47281: int test_ret = 0;
47282:
47283: #if defined(LIBXML_XPATH_ENABLED)
47284: int mem_base;
47285: int ret_val;
47286: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47287: int n_ctxt;
47288: xmlXPathObjectPtr res; /* the Predicate Expression evaluation result */
47289: int n_res;
47290:
47291: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47292: for (n_res = 0;n_res < gen_nb_xmlXPathObjectPtr;n_res++) {
47293: mem_base = xmlMemBlocks();
47294: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47295: res = gen_xmlXPathObjectPtr(n_res, 1);
47296:
47297: ret_val = xmlXPathEvaluatePredicateResult(ctxt, res);
47298: desret_int(ret_val);
47299: call_tests++;
47300: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47301: des_xmlXPathObjectPtr(n_res, res, 1);
47302: xmlResetLastError();
47303: if (mem_base != xmlMemBlocks()) {
47304: printf("Leak of %d blocks found in xmlXPathEvaluatePredicateResult",
47305: xmlMemBlocks() - mem_base);
47306: test_ret++;
47307: printf(" %d", n_ctxt);
47308: printf(" %d", n_res);
47309: printf("\n");
47310: }
47311: }
47312: }
47313: function_tests++;
47314: #endif
47315:
47316: return(test_ret);
47317: }
47318:
47319:
47320: static int
47321: test_xmlXPathFalseFunction(void) {
47322: int test_ret = 0;
47323:
47324: #if defined(LIBXML_XPATH_ENABLED)
47325: int mem_base;
47326: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47327: int n_ctxt;
47328: int nargs; /* the number of arguments */
47329: int n_nargs;
47330:
47331: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47332: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
47333: mem_base = xmlMemBlocks();
47334: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47335: nargs = gen_int(n_nargs, 1);
47336:
47337: xmlXPathFalseFunction(ctxt, nargs);
47338: call_tests++;
47339: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47340: des_int(n_nargs, nargs, 1);
47341: xmlResetLastError();
47342: if (mem_base != xmlMemBlocks()) {
47343: printf("Leak of %d blocks found in xmlXPathFalseFunction",
47344: xmlMemBlocks() - mem_base);
47345: test_ret++;
47346: printf(" %d", n_ctxt);
47347: printf(" %d", n_nargs);
47348: printf("\n");
47349: }
47350: }
47351: }
47352: function_tests++;
47353: #endif
47354:
47355: return(test_ret);
47356: }
47357:
47358:
47359: static int
47360: test_xmlXPathFloorFunction(void) {
47361: int test_ret = 0;
47362:
47363: #if defined(LIBXML_XPATH_ENABLED)
47364: int mem_base;
47365: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47366: int n_ctxt;
47367: int nargs; /* the number of arguments */
47368: int n_nargs;
47369:
47370: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47371: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
47372: mem_base = xmlMemBlocks();
47373: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47374: nargs = gen_int(n_nargs, 1);
47375:
47376: xmlXPathFloorFunction(ctxt, nargs);
47377: call_tests++;
47378: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47379: des_int(n_nargs, nargs, 1);
47380: xmlResetLastError();
47381: if (mem_base != xmlMemBlocks()) {
47382: printf("Leak of %d blocks found in xmlXPathFloorFunction",
47383: xmlMemBlocks() - mem_base);
47384: test_ret++;
47385: printf(" %d", n_ctxt);
47386: printf(" %d", n_nargs);
47387: printf("\n");
47388: }
47389: }
47390: }
47391: function_tests++;
47392: #endif
47393:
47394: return(test_ret);
47395: }
47396:
47397:
47398: static int
47399: test_xmlXPathFunctionLookup(void) {
47400: int test_ret = 0;
47401:
47402:
47403: /* missing type support */
47404: return(test_ret);
47405: }
47406:
47407:
47408: static int
47409: test_xmlXPathFunctionLookupNS(void) {
47410: int test_ret = 0;
47411:
47412:
47413: /* missing type support */
47414: return(test_ret);
47415: }
47416:
47417:
47418: static int
47419: test_xmlXPathHasSameNodes(void) {
47420: int test_ret = 0;
47421:
47422: #if defined(LIBXML_XPATH_ENABLED)
47423: int mem_base;
47424: int ret_val;
47425: xmlNodeSetPtr nodes1; /* a node-set */
47426: int n_nodes1;
47427: xmlNodeSetPtr nodes2; /* a node-set */
47428: int n_nodes2;
47429:
47430: for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
47431: for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
47432: mem_base = xmlMemBlocks();
47433: nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
47434: nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
47435:
47436: ret_val = xmlXPathHasSameNodes(nodes1, nodes2);
47437: desret_int(ret_val);
47438: call_tests++;
47439: des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
47440: des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
47441: xmlResetLastError();
47442: if (mem_base != xmlMemBlocks()) {
47443: printf("Leak of %d blocks found in xmlXPathHasSameNodes",
47444: xmlMemBlocks() - mem_base);
47445: test_ret++;
47446: printf(" %d", n_nodes1);
47447: printf(" %d", n_nodes2);
47448: printf("\n");
47449: }
47450: }
47451: }
47452: function_tests++;
47453: #endif
47454:
47455: return(test_ret);
47456: }
47457:
47458:
47459: static int
47460: test_xmlXPathIdFunction(void) {
47461: int test_ret = 0;
47462:
47463: #if defined(LIBXML_XPATH_ENABLED)
47464: int mem_base;
47465: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47466: int n_ctxt;
47467: int nargs; /* the number of arguments */
47468: int n_nargs;
47469:
47470: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47471: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
47472: mem_base = xmlMemBlocks();
47473: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47474: nargs = gen_int(n_nargs, 1);
47475:
47476: xmlXPathIdFunction(ctxt, nargs);
47477: call_tests++;
47478: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47479: des_int(n_nargs, nargs, 1);
47480: xmlResetLastError();
47481: if (mem_base != xmlMemBlocks()) {
47482: printf("Leak of %d blocks found in xmlXPathIdFunction",
47483: xmlMemBlocks() - mem_base);
47484: test_ret++;
47485: printf(" %d", n_ctxt);
47486: printf(" %d", n_nargs);
47487: printf("\n");
47488: }
47489: }
47490: }
47491: function_tests++;
47492: #endif
47493:
47494: return(test_ret);
47495: }
47496:
47497:
47498: static int
47499: test_xmlXPathIntersection(void) {
47500: int test_ret = 0;
47501:
47502: #if defined(LIBXML_XPATH_ENABLED)
47503: int mem_base;
47504: xmlNodeSetPtr ret_val;
47505: xmlNodeSetPtr nodes1; /* a node-set */
47506: int n_nodes1;
47507: xmlNodeSetPtr nodes2; /* a node-set */
47508: int n_nodes2;
47509:
47510: for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
47511: for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
47512: mem_base = xmlMemBlocks();
47513: nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
47514: nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
47515:
47516: ret_val = xmlXPathIntersection(nodes1, nodes2);
47517: desret_xmlNodeSetPtr(ret_val);
47518: call_tests++;
47519: des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
47520: des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
47521: xmlResetLastError();
47522: if (mem_base != xmlMemBlocks()) {
47523: printf("Leak of %d blocks found in xmlXPathIntersection",
47524: xmlMemBlocks() - mem_base);
47525: test_ret++;
47526: printf(" %d", n_nodes1);
47527: printf(" %d", n_nodes2);
47528: printf("\n");
47529: }
47530: }
47531: }
47532: function_tests++;
47533: #endif
47534:
47535: return(test_ret);
47536: }
47537:
47538:
47539: static int
47540: test_xmlXPathIsNodeType(void) {
47541: int test_ret = 0;
47542:
47543: #if defined(LIBXML_XPATH_ENABLED)
47544: int mem_base;
47545: int ret_val;
47546: xmlChar * name; /* a name string */
47547: int n_name;
47548:
47549: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
47550: mem_base = xmlMemBlocks();
47551: name = gen_const_xmlChar_ptr(n_name, 0);
47552:
47553: ret_val = xmlXPathIsNodeType((const xmlChar *)name);
47554: desret_int(ret_val);
47555: call_tests++;
47556: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
47557: xmlResetLastError();
47558: if (mem_base != xmlMemBlocks()) {
47559: printf("Leak of %d blocks found in xmlXPathIsNodeType",
47560: xmlMemBlocks() - mem_base);
47561: test_ret++;
47562: printf(" %d", n_name);
47563: printf("\n");
47564: }
47565: }
47566: function_tests++;
47567: #endif
47568:
47569: return(test_ret);
47570: }
47571:
47572:
47573: static int
47574: test_xmlXPathLangFunction(void) {
47575: int test_ret = 0;
47576:
47577: #if defined(LIBXML_XPATH_ENABLED)
47578: int mem_base;
47579: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47580: int n_ctxt;
47581: int nargs; /* the number of arguments */
47582: int n_nargs;
47583:
47584: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47585: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
47586: mem_base = xmlMemBlocks();
47587: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47588: nargs = gen_int(n_nargs, 1);
47589:
47590: xmlXPathLangFunction(ctxt, nargs);
47591: call_tests++;
47592: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47593: des_int(n_nargs, nargs, 1);
47594: xmlResetLastError();
47595: if (mem_base != xmlMemBlocks()) {
47596: printf("Leak of %d blocks found in xmlXPathLangFunction",
47597: xmlMemBlocks() - mem_base);
47598: test_ret++;
47599: printf(" %d", n_ctxt);
47600: printf(" %d", n_nargs);
47601: printf("\n");
47602: }
47603: }
47604: }
47605: function_tests++;
47606: #endif
47607:
47608: return(test_ret);
47609: }
47610:
47611:
47612: static int
47613: test_xmlXPathLastFunction(void) {
47614: int test_ret = 0;
47615:
47616: #if defined(LIBXML_XPATH_ENABLED)
47617: int mem_base;
47618: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47619: int n_ctxt;
47620: int nargs; /* the number of arguments */
47621: int n_nargs;
47622:
47623: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47624: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
47625: mem_base = xmlMemBlocks();
47626: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47627: nargs = gen_int(n_nargs, 1);
47628:
47629: xmlXPathLastFunction(ctxt, nargs);
47630: call_tests++;
47631: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47632: des_int(n_nargs, nargs, 1);
47633: xmlResetLastError();
47634: if (mem_base != xmlMemBlocks()) {
47635: printf("Leak of %d blocks found in xmlXPathLastFunction",
47636: xmlMemBlocks() - mem_base);
47637: test_ret++;
47638: printf(" %d", n_ctxt);
47639: printf(" %d", n_nargs);
47640: printf("\n");
47641: }
47642: }
47643: }
47644: function_tests++;
47645: #endif
47646:
47647: return(test_ret);
47648: }
47649:
47650:
47651: static int
47652: test_xmlXPathLeading(void) {
47653: int test_ret = 0;
47654:
47655: #if defined(LIBXML_XPATH_ENABLED)
47656: int mem_base;
47657: xmlNodeSetPtr ret_val;
47658: xmlNodeSetPtr nodes1; /* a node-set */
47659: int n_nodes1;
47660: xmlNodeSetPtr nodes2; /* a node-set */
47661: int n_nodes2;
47662:
47663: for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
47664: for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
47665: mem_base = xmlMemBlocks();
47666: nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
47667: nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
47668:
47669: ret_val = xmlXPathLeading(nodes1, nodes2);
47670: desret_xmlNodeSetPtr(ret_val);
47671: call_tests++;
47672: des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
47673: des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
47674: xmlResetLastError();
47675: if (mem_base != xmlMemBlocks()) {
47676: printf("Leak of %d blocks found in xmlXPathLeading",
47677: xmlMemBlocks() - mem_base);
47678: test_ret++;
47679: printf(" %d", n_nodes1);
47680: printf(" %d", n_nodes2);
47681: printf("\n");
47682: }
47683: }
47684: }
47685: function_tests++;
47686: #endif
47687:
47688: return(test_ret);
47689: }
47690:
47691:
47692: static int
47693: test_xmlXPathLeadingSorted(void) {
47694: int test_ret = 0;
47695:
47696: #if defined(LIBXML_XPATH_ENABLED)
47697: int mem_base;
47698: xmlNodeSetPtr ret_val;
47699: xmlNodeSetPtr nodes1; /* a node-set, sorted by document order */
47700: int n_nodes1;
47701: xmlNodeSetPtr nodes2; /* a node-set, sorted by document order */
47702: int n_nodes2;
47703:
47704: for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
47705: for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
47706: mem_base = xmlMemBlocks();
47707: nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
47708: nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
47709:
47710: ret_val = xmlXPathLeadingSorted(nodes1, nodes2);
47711: desret_xmlNodeSetPtr(ret_val);
47712: call_tests++;
47713: des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
47714: des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
47715: xmlResetLastError();
47716: if (mem_base != xmlMemBlocks()) {
47717: printf("Leak of %d blocks found in xmlXPathLeadingSorted",
47718: xmlMemBlocks() - mem_base);
47719: test_ret++;
47720: printf(" %d", n_nodes1);
47721: printf(" %d", n_nodes2);
47722: printf("\n");
47723: }
47724: }
47725: }
47726: function_tests++;
47727: #endif
47728:
47729: return(test_ret);
47730: }
47731:
47732:
47733: static int
47734: test_xmlXPathLocalNameFunction(void) {
47735: int test_ret = 0;
47736:
47737: #if defined(LIBXML_XPATH_ENABLED)
47738: int mem_base;
47739: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47740: int n_ctxt;
47741: int nargs; /* the number of arguments */
47742: int n_nargs;
47743:
47744: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47745: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
47746: mem_base = xmlMemBlocks();
47747: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47748: nargs = gen_int(n_nargs, 1);
47749:
47750: xmlXPathLocalNameFunction(ctxt, nargs);
47751: call_tests++;
47752: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47753: des_int(n_nargs, nargs, 1);
47754: xmlResetLastError();
47755: if (mem_base != xmlMemBlocks()) {
47756: printf("Leak of %d blocks found in xmlXPathLocalNameFunction",
47757: xmlMemBlocks() - mem_base);
47758: test_ret++;
47759: printf(" %d", n_ctxt);
47760: printf(" %d", n_nargs);
47761: printf("\n");
47762: }
47763: }
47764: }
47765: function_tests++;
47766: #endif
47767:
47768: return(test_ret);
47769: }
47770:
47771:
47772: static int
47773: test_xmlXPathModValues(void) {
47774: int test_ret = 0;
47775:
47776: #if defined(LIBXML_XPATH_ENABLED)
47777: int mem_base;
47778: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47779: int n_ctxt;
47780:
47781: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47782: mem_base = xmlMemBlocks();
47783: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47784:
47785: xmlXPathModValues(ctxt);
47786: call_tests++;
47787: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47788: xmlResetLastError();
47789: if (mem_base != xmlMemBlocks()) {
47790: printf("Leak of %d blocks found in xmlXPathModValues",
47791: xmlMemBlocks() - mem_base);
47792: test_ret++;
47793: printf(" %d", n_ctxt);
47794: printf("\n");
47795: }
47796: }
47797: function_tests++;
47798: #endif
47799:
47800: return(test_ret);
47801: }
47802:
47803:
47804: static int
47805: test_xmlXPathMultValues(void) {
47806: int test_ret = 0;
47807:
47808: #if defined(LIBXML_XPATH_ENABLED)
47809: int mem_base;
47810: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47811: int n_ctxt;
47812:
47813: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47814: mem_base = xmlMemBlocks();
47815: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47816:
47817: xmlXPathMultValues(ctxt);
47818: call_tests++;
47819: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47820: xmlResetLastError();
47821: if (mem_base != xmlMemBlocks()) {
47822: printf("Leak of %d blocks found in xmlXPathMultValues",
47823: xmlMemBlocks() - mem_base);
47824: test_ret++;
47825: printf(" %d", n_ctxt);
47826: printf("\n");
47827: }
47828: }
47829: function_tests++;
47830: #endif
47831:
47832: return(test_ret);
47833: }
47834:
47835:
47836: static int
47837: test_xmlXPathNamespaceURIFunction(void) {
47838: int test_ret = 0;
47839:
47840: #if defined(LIBXML_XPATH_ENABLED)
47841: int mem_base;
47842: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47843: int n_ctxt;
47844: int nargs; /* the number of arguments */
47845: int n_nargs;
47846:
47847: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47848: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
47849: mem_base = xmlMemBlocks();
47850: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47851: nargs = gen_int(n_nargs, 1);
47852:
47853: xmlXPathNamespaceURIFunction(ctxt, nargs);
47854: call_tests++;
47855: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47856: des_int(n_nargs, nargs, 1);
47857: xmlResetLastError();
47858: if (mem_base != xmlMemBlocks()) {
47859: printf("Leak of %d blocks found in xmlXPathNamespaceURIFunction",
47860: xmlMemBlocks() - mem_base);
47861: test_ret++;
47862: printf(" %d", n_ctxt);
47863: printf(" %d", n_nargs);
47864: printf("\n");
47865: }
47866: }
47867: }
47868: function_tests++;
47869: #endif
47870:
47871: return(test_ret);
47872: }
47873:
47874:
47875: static int
47876: test_xmlXPathNewBoolean(void) {
47877: int test_ret = 0;
47878:
47879: #if defined(LIBXML_XPATH_ENABLED)
47880: int mem_base;
47881: xmlXPathObjectPtr ret_val;
47882: int val; /* the boolean value */
47883: int n_val;
47884:
47885: for (n_val = 0;n_val < gen_nb_int;n_val++) {
47886: mem_base = xmlMemBlocks();
47887: val = gen_int(n_val, 0);
47888:
47889: ret_val = xmlXPathNewBoolean(val);
47890: desret_xmlXPathObjectPtr(ret_val);
47891: call_tests++;
47892: des_int(n_val, val, 0);
47893: xmlResetLastError();
47894: if (mem_base != xmlMemBlocks()) {
47895: printf("Leak of %d blocks found in xmlXPathNewBoolean",
47896: xmlMemBlocks() - mem_base);
47897: test_ret++;
47898: printf(" %d", n_val);
47899: printf("\n");
47900: }
47901: }
47902: function_tests++;
47903: #endif
47904:
47905: return(test_ret);
47906: }
47907:
47908:
47909: static int
47910: test_xmlXPathNewCString(void) {
47911: int test_ret = 0;
47912:
47913: #if defined(LIBXML_XPATH_ENABLED)
47914: int mem_base;
47915: xmlXPathObjectPtr ret_val;
47916: char * val; /* the char * value */
47917: int n_val;
47918:
47919: for (n_val = 0;n_val < gen_nb_const_char_ptr;n_val++) {
47920: mem_base = xmlMemBlocks();
47921: val = gen_const_char_ptr(n_val, 0);
47922:
47923: ret_val = xmlXPathNewCString((const char *)val);
47924: desret_xmlXPathObjectPtr(ret_val);
47925: call_tests++;
47926: des_const_char_ptr(n_val, (const char *)val, 0);
47927: xmlResetLastError();
47928: if (mem_base != xmlMemBlocks()) {
47929: printf("Leak of %d blocks found in xmlXPathNewCString",
47930: xmlMemBlocks() - mem_base);
47931: test_ret++;
47932: printf(" %d", n_val);
47933: printf("\n");
47934: }
47935: }
47936: function_tests++;
47937: #endif
47938:
47939: return(test_ret);
47940: }
47941:
47942:
47943: static int
47944: test_xmlXPathNewFloat(void) {
47945: int test_ret = 0;
47946:
47947: #if defined(LIBXML_XPATH_ENABLED)
47948: int mem_base;
47949: xmlXPathObjectPtr ret_val;
47950: double val; /* the double value */
47951: int n_val;
47952:
47953: for (n_val = 0;n_val < gen_nb_double;n_val++) {
47954: mem_base = xmlMemBlocks();
47955: val = gen_double(n_val, 0);
47956:
47957: ret_val = xmlXPathNewFloat(val);
47958: desret_xmlXPathObjectPtr(ret_val);
47959: call_tests++;
47960: des_double(n_val, val, 0);
47961: xmlResetLastError();
47962: if (mem_base != xmlMemBlocks()) {
47963: printf("Leak of %d blocks found in xmlXPathNewFloat",
47964: xmlMemBlocks() - mem_base);
47965: test_ret++;
47966: printf(" %d", n_val);
47967: printf("\n");
47968: }
47969: }
47970: function_tests++;
47971: #endif
47972:
47973: return(test_ret);
47974: }
47975:
47976:
47977: static int
47978: test_xmlXPathNewNodeSet(void) {
47979: int test_ret = 0;
47980:
47981: #if defined(LIBXML_XPATH_ENABLED)
47982: int mem_base;
47983: xmlXPathObjectPtr ret_val;
47984: xmlNodePtr val; /* the NodePtr value */
47985: int n_val;
47986:
47987: for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
47988: mem_base = xmlMemBlocks();
47989: val = gen_xmlNodePtr(n_val, 0);
47990:
47991: ret_val = xmlXPathNewNodeSet(val);
47992: desret_xmlXPathObjectPtr(ret_val);
47993: call_tests++;
47994: des_xmlNodePtr(n_val, val, 0);
47995: xmlResetLastError();
47996: if (mem_base != xmlMemBlocks()) {
47997: printf("Leak of %d blocks found in xmlXPathNewNodeSet",
47998: xmlMemBlocks() - mem_base);
47999: test_ret++;
48000: printf(" %d", n_val);
48001: printf("\n");
48002: }
48003: }
48004: function_tests++;
48005: #endif
48006:
48007: return(test_ret);
48008: }
48009:
48010:
48011: static int
48012: test_xmlXPathNewNodeSetList(void) {
48013: int test_ret = 0;
48014:
48015: #if defined(LIBXML_XPATH_ENABLED)
48016: int mem_base;
48017: xmlXPathObjectPtr ret_val;
48018: xmlNodeSetPtr val; /* an existing NodeSet */
48019: int n_val;
48020:
48021: for (n_val = 0;n_val < gen_nb_xmlNodeSetPtr;n_val++) {
48022: mem_base = xmlMemBlocks();
48023: val = gen_xmlNodeSetPtr(n_val, 0);
48024:
48025: ret_val = xmlXPathNewNodeSetList(val);
48026: desret_xmlXPathObjectPtr(ret_val);
48027: call_tests++;
48028: des_xmlNodeSetPtr(n_val, val, 0);
48029: xmlResetLastError();
48030: if (mem_base != xmlMemBlocks()) {
48031: printf("Leak of %d blocks found in xmlXPathNewNodeSetList",
48032: xmlMemBlocks() - mem_base);
48033: test_ret++;
48034: printf(" %d", n_val);
48035: printf("\n");
48036: }
48037: }
48038: function_tests++;
48039: #endif
48040:
48041: return(test_ret);
48042: }
48043:
48044:
48045: static int
48046: test_xmlXPathNewParserContext(void) {
48047: int test_ret = 0;
48048:
48049:
48050: /* missing type support */
48051: return(test_ret);
48052: }
48053:
48054:
48055: static int
48056: test_xmlXPathNewString(void) {
48057: int test_ret = 0;
48058:
48059: #if defined(LIBXML_XPATH_ENABLED)
48060: int mem_base;
48061: xmlXPathObjectPtr ret_val;
48062: xmlChar * val; /* the xmlChar * value */
48063: int n_val;
48064:
48065: for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) {
48066: mem_base = xmlMemBlocks();
48067: val = gen_const_xmlChar_ptr(n_val, 0);
48068:
48069: ret_val = xmlXPathNewString((const xmlChar *)val);
48070: desret_xmlXPathObjectPtr(ret_val);
48071: call_tests++;
48072: des_const_xmlChar_ptr(n_val, (const xmlChar *)val, 0);
48073: xmlResetLastError();
48074: if (mem_base != xmlMemBlocks()) {
48075: printf("Leak of %d blocks found in xmlXPathNewString",
48076: xmlMemBlocks() - mem_base);
48077: test_ret++;
48078: printf(" %d", n_val);
48079: printf("\n");
48080: }
48081: }
48082: function_tests++;
48083: #endif
48084:
48085: return(test_ret);
48086: }
48087:
48088:
48089: static int
48090: test_xmlXPathNextAncestor(void) {
48091: int test_ret = 0;
48092:
48093: #if defined(LIBXML_XPATH_ENABLED)
48094: int mem_base;
48095: xmlNodePtr ret_val;
48096: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48097: int n_ctxt;
48098: xmlNodePtr cur; /* the current node in the traversal */
48099: int n_cur;
48100:
48101: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48102: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48103: mem_base = xmlMemBlocks();
48104: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48105: cur = gen_xmlNodePtr(n_cur, 1);
48106:
48107: ret_val = xmlXPathNextAncestor(ctxt, cur);
48108: desret_xmlNodePtr(ret_val);
48109: call_tests++;
48110: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48111: des_xmlNodePtr(n_cur, cur, 1);
48112: xmlResetLastError();
48113: if (mem_base != xmlMemBlocks()) {
48114: printf("Leak of %d blocks found in xmlXPathNextAncestor",
48115: xmlMemBlocks() - mem_base);
48116: test_ret++;
48117: printf(" %d", n_ctxt);
48118: printf(" %d", n_cur);
48119: printf("\n");
48120: }
48121: }
48122: }
48123: function_tests++;
48124: #endif
48125:
48126: return(test_ret);
48127: }
48128:
48129:
48130: static int
48131: test_xmlXPathNextAncestorOrSelf(void) {
48132: int test_ret = 0;
48133:
48134: #if defined(LIBXML_XPATH_ENABLED)
48135: int mem_base;
48136: xmlNodePtr ret_val;
48137: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48138: int n_ctxt;
48139: xmlNodePtr cur; /* the current node in the traversal */
48140: int n_cur;
48141:
48142: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48143: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48144: mem_base = xmlMemBlocks();
48145: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48146: cur = gen_xmlNodePtr(n_cur, 1);
48147:
48148: ret_val = xmlXPathNextAncestorOrSelf(ctxt, cur);
48149: desret_xmlNodePtr(ret_val);
48150: call_tests++;
48151: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48152: des_xmlNodePtr(n_cur, cur, 1);
48153: xmlResetLastError();
48154: if (mem_base != xmlMemBlocks()) {
48155: printf("Leak of %d blocks found in xmlXPathNextAncestorOrSelf",
48156: xmlMemBlocks() - mem_base);
48157: test_ret++;
48158: printf(" %d", n_ctxt);
48159: printf(" %d", n_cur);
48160: printf("\n");
48161: }
48162: }
48163: }
48164: function_tests++;
48165: #endif
48166:
48167: return(test_ret);
48168: }
48169:
48170:
48171: static int
48172: test_xmlXPathNextAttribute(void) {
48173: int test_ret = 0;
48174:
48175: #if defined(LIBXML_XPATH_ENABLED)
48176: int mem_base;
48177: xmlNodePtr ret_val;
48178: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48179: int n_ctxt;
48180: xmlNodePtr cur; /* the current attribute in the traversal */
48181: int n_cur;
48182:
48183: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48184: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48185: mem_base = xmlMemBlocks();
48186: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48187: cur = gen_xmlNodePtr(n_cur, 1);
48188:
48189: ret_val = xmlXPathNextAttribute(ctxt, cur);
48190: desret_xmlNodePtr(ret_val);
48191: call_tests++;
48192: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48193: des_xmlNodePtr(n_cur, cur, 1);
48194: xmlResetLastError();
48195: if (mem_base != xmlMemBlocks()) {
48196: printf("Leak of %d blocks found in xmlXPathNextAttribute",
48197: xmlMemBlocks() - mem_base);
48198: test_ret++;
48199: printf(" %d", n_ctxt);
48200: printf(" %d", n_cur);
48201: printf("\n");
48202: }
48203: }
48204: }
48205: function_tests++;
48206: #endif
48207:
48208: return(test_ret);
48209: }
48210:
48211:
48212: static int
48213: test_xmlXPathNextChild(void) {
48214: int test_ret = 0;
48215:
48216: #if defined(LIBXML_XPATH_ENABLED)
48217: int mem_base;
48218: xmlNodePtr ret_val;
48219: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48220: int n_ctxt;
48221: xmlNodePtr cur; /* the current node in the traversal */
48222: int n_cur;
48223:
48224: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48225: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48226: mem_base = xmlMemBlocks();
48227: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48228: cur = gen_xmlNodePtr(n_cur, 1);
48229:
48230: ret_val = xmlXPathNextChild(ctxt, cur);
48231: desret_xmlNodePtr(ret_val);
48232: call_tests++;
48233: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48234: des_xmlNodePtr(n_cur, cur, 1);
48235: xmlResetLastError();
48236: if (mem_base != xmlMemBlocks()) {
48237: printf("Leak of %d blocks found in xmlXPathNextChild",
48238: xmlMemBlocks() - mem_base);
48239: test_ret++;
48240: printf(" %d", n_ctxt);
48241: printf(" %d", n_cur);
48242: printf("\n");
48243: }
48244: }
48245: }
48246: function_tests++;
48247: #endif
48248:
48249: return(test_ret);
48250: }
48251:
48252:
48253: static int
48254: test_xmlXPathNextDescendant(void) {
48255: int test_ret = 0;
48256:
48257: #if defined(LIBXML_XPATH_ENABLED)
48258: int mem_base;
48259: xmlNodePtr ret_val;
48260: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48261: int n_ctxt;
48262: xmlNodePtr cur; /* the current node in the traversal */
48263: int n_cur;
48264:
48265: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48266: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48267: mem_base = xmlMemBlocks();
48268: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48269: cur = gen_xmlNodePtr(n_cur, 1);
48270:
48271: ret_val = xmlXPathNextDescendant(ctxt, cur);
48272: desret_xmlNodePtr(ret_val);
48273: call_tests++;
48274: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48275: des_xmlNodePtr(n_cur, cur, 1);
48276: xmlResetLastError();
48277: if (mem_base != xmlMemBlocks()) {
48278: printf("Leak of %d blocks found in xmlXPathNextDescendant",
48279: xmlMemBlocks() - mem_base);
48280: test_ret++;
48281: printf(" %d", n_ctxt);
48282: printf(" %d", n_cur);
48283: printf("\n");
48284: }
48285: }
48286: }
48287: function_tests++;
48288: #endif
48289:
48290: return(test_ret);
48291: }
48292:
48293:
48294: static int
48295: test_xmlXPathNextDescendantOrSelf(void) {
48296: int test_ret = 0;
48297:
48298: #if defined(LIBXML_XPATH_ENABLED)
48299: int mem_base;
48300: xmlNodePtr ret_val;
48301: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48302: int n_ctxt;
48303: xmlNodePtr cur; /* the current node in the traversal */
48304: int n_cur;
48305:
48306: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48307: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48308: mem_base = xmlMemBlocks();
48309: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48310: cur = gen_xmlNodePtr(n_cur, 1);
48311:
48312: ret_val = xmlXPathNextDescendantOrSelf(ctxt, cur);
48313: desret_xmlNodePtr(ret_val);
48314: call_tests++;
48315: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48316: des_xmlNodePtr(n_cur, cur, 1);
48317: xmlResetLastError();
48318: if (mem_base != xmlMemBlocks()) {
48319: printf("Leak of %d blocks found in xmlXPathNextDescendantOrSelf",
48320: xmlMemBlocks() - mem_base);
48321: test_ret++;
48322: printf(" %d", n_ctxt);
48323: printf(" %d", n_cur);
48324: printf("\n");
48325: }
48326: }
48327: }
48328: function_tests++;
48329: #endif
48330:
48331: return(test_ret);
48332: }
48333:
48334:
48335: static int
48336: test_xmlXPathNextFollowing(void) {
48337: int test_ret = 0;
48338:
48339: #if defined(LIBXML_XPATH_ENABLED)
48340: int mem_base;
48341: xmlNodePtr ret_val;
48342: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48343: int n_ctxt;
48344: xmlNodePtr cur; /* the current node in the traversal */
48345: int n_cur;
48346:
48347: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48348: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48349: mem_base = xmlMemBlocks();
48350: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48351: cur = gen_xmlNodePtr(n_cur, 1);
48352:
48353: ret_val = xmlXPathNextFollowing(ctxt, cur);
48354: desret_xmlNodePtr(ret_val);
48355: call_tests++;
48356: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48357: des_xmlNodePtr(n_cur, cur, 1);
48358: xmlResetLastError();
48359: if (mem_base != xmlMemBlocks()) {
48360: printf("Leak of %d blocks found in xmlXPathNextFollowing",
48361: xmlMemBlocks() - mem_base);
48362: test_ret++;
48363: printf(" %d", n_ctxt);
48364: printf(" %d", n_cur);
48365: printf("\n");
48366: }
48367: }
48368: }
48369: function_tests++;
48370: #endif
48371:
48372: return(test_ret);
48373: }
48374:
48375:
48376: static int
48377: test_xmlXPathNextFollowingSibling(void) {
48378: int test_ret = 0;
48379:
48380: #if defined(LIBXML_XPATH_ENABLED)
48381: int mem_base;
48382: xmlNodePtr ret_val;
48383: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48384: int n_ctxt;
48385: xmlNodePtr cur; /* the current node in the traversal */
48386: int n_cur;
48387:
48388: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48389: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48390: mem_base = xmlMemBlocks();
48391: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48392: cur = gen_xmlNodePtr(n_cur, 1);
48393:
48394: ret_val = xmlXPathNextFollowingSibling(ctxt, cur);
48395: desret_xmlNodePtr(ret_val);
48396: call_tests++;
48397: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48398: des_xmlNodePtr(n_cur, cur, 1);
48399: xmlResetLastError();
48400: if (mem_base != xmlMemBlocks()) {
48401: printf("Leak of %d blocks found in xmlXPathNextFollowingSibling",
48402: xmlMemBlocks() - mem_base);
48403: test_ret++;
48404: printf(" %d", n_ctxt);
48405: printf(" %d", n_cur);
48406: printf("\n");
48407: }
48408: }
48409: }
48410: function_tests++;
48411: #endif
48412:
48413: return(test_ret);
48414: }
48415:
48416:
48417: static int
48418: test_xmlXPathNextNamespace(void) {
48419: int test_ret = 0;
48420:
48421: #if defined(LIBXML_XPATH_ENABLED)
48422: int mem_base;
48423: xmlNodePtr ret_val;
48424: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48425: int n_ctxt;
48426: xmlNodePtr cur; /* the current attribute in the traversal */
48427: int n_cur;
48428:
48429: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48430: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48431: mem_base = xmlMemBlocks();
48432: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48433: cur = gen_xmlNodePtr(n_cur, 1);
48434:
48435: ret_val = xmlXPathNextNamespace(ctxt, cur);
48436: desret_xmlNodePtr(ret_val);
48437: call_tests++;
48438: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48439: des_xmlNodePtr(n_cur, cur, 1);
48440: xmlResetLastError();
48441: if (mem_base != xmlMemBlocks()) {
48442: printf("Leak of %d blocks found in xmlXPathNextNamespace",
48443: xmlMemBlocks() - mem_base);
48444: test_ret++;
48445: printf(" %d", n_ctxt);
48446: printf(" %d", n_cur);
48447: printf("\n");
48448: }
48449: }
48450: }
48451: function_tests++;
48452: #endif
48453:
48454: return(test_ret);
48455: }
48456:
48457:
48458: static int
48459: test_xmlXPathNextParent(void) {
48460: int test_ret = 0;
48461:
48462: #if defined(LIBXML_XPATH_ENABLED)
48463: int mem_base;
48464: xmlNodePtr ret_val;
48465: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48466: int n_ctxt;
48467: xmlNodePtr cur; /* the current node in the traversal */
48468: int n_cur;
48469:
48470: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48471: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48472: mem_base = xmlMemBlocks();
48473: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48474: cur = gen_xmlNodePtr(n_cur, 1);
48475:
48476: ret_val = xmlXPathNextParent(ctxt, cur);
48477: desret_xmlNodePtr(ret_val);
48478: call_tests++;
48479: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48480: des_xmlNodePtr(n_cur, cur, 1);
48481: xmlResetLastError();
48482: if (mem_base != xmlMemBlocks()) {
48483: printf("Leak of %d blocks found in xmlXPathNextParent",
48484: xmlMemBlocks() - mem_base);
48485: test_ret++;
48486: printf(" %d", n_ctxt);
48487: printf(" %d", n_cur);
48488: printf("\n");
48489: }
48490: }
48491: }
48492: function_tests++;
48493: #endif
48494:
48495: return(test_ret);
48496: }
48497:
48498:
48499: static int
48500: test_xmlXPathNextPreceding(void) {
48501: int test_ret = 0;
48502:
48503: #if defined(LIBXML_XPATH_ENABLED)
48504: int mem_base;
48505: xmlNodePtr ret_val;
48506: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48507: int n_ctxt;
48508: xmlNodePtr cur; /* the current node in the traversal */
48509: int n_cur;
48510:
48511: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48512: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48513: mem_base = xmlMemBlocks();
48514: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48515: cur = gen_xmlNodePtr(n_cur, 1);
48516:
48517: ret_val = xmlXPathNextPreceding(ctxt, cur);
48518: desret_xmlNodePtr(ret_val);
48519: call_tests++;
48520: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48521: des_xmlNodePtr(n_cur, cur, 1);
48522: xmlResetLastError();
48523: if (mem_base != xmlMemBlocks()) {
48524: printf("Leak of %d blocks found in xmlXPathNextPreceding",
48525: xmlMemBlocks() - mem_base);
48526: test_ret++;
48527: printf(" %d", n_ctxt);
48528: printf(" %d", n_cur);
48529: printf("\n");
48530: }
48531: }
48532: }
48533: function_tests++;
48534: #endif
48535:
48536: return(test_ret);
48537: }
48538:
48539:
48540: static int
48541: test_xmlXPathNextPrecedingSibling(void) {
48542: int test_ret = 0;
48543:
48544: #if defined(LIBXML_XPATH_ENABLED)
48545: int mem_base;
48546: xmlNodePtr ret_val;
48547: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48548: int n_ctxt;
48549: xmlNodePtr cur; /* the current node in the traversal */
48550: int n_cur;
48551:
48552: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48553: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48554: mem_base = xmlMemBlocks();
48555: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48556: cur = gen_xmlNodePtr(n_cur, 1);
48557:
48558: ret_val = xmlXPathNextPrecedingSibling(ctxt, cur);
48559: desret_xmlNodePtr(ret_val);
48560: call_tests++;
48561: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48562: des_xmlNodePtr(n_cur, cur, 1);
48563: xmlResetLastError();
48564: if (mem_base != xmlMemBlocks()) {
48565: printf("Leak of %d blocks found in xmlXPathNextPrecedingSibling",
48566: xmlMemBlocks() - mem_base);
48567: test_ret++;
48568: printf(" %d", n_ctxt);
48569: printf(" %d", n_cur);
48570: printf("\n");
48571: }
48572: }
48573: }
48574: function_tests++;
48575: #endif
48576:
48577: return(test_ret);
48578: }
48579:
48580:
48581: static int
48582: test_xmlXPathNextSelf(void) {
48583: int test_ret = 0;
48584:
48585: #if defined(LIBXML_XPATH_ENABLED)
48586: int mem_base;
48587: xmlNodePtr ret_val;
48588: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48589: int n_ctxt;
48590: xmlNodePtr cur; /* the current node in the traversal */
48591: int n_cur;
48592:
48593: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48594: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48595: mem_base = xmlMemBlocks();
48596: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48597: cur = gen_xmlNodePtr(n_cur, 1);
48598:
48599: ret_val = xmlXPathNextSelf(ctxt, cur);
48600: desret_xmlNodePtr(ret_val);
48601: call_tests++;
48602: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48603: des_xmlNodePtr(n_cur, cur, 1);
48604: xmlResetLastError();
48605: if (mem_base != xmlMemBlocks()) {
48606: printf("Leak of %d blocks found in xmlXPathNextSelf",
48607: xmlMemBlocks() - mem_base);
48608: test_ret++;
48609: printf(" %d", n_ctxt);
48610: printf(" %d", n_cur);
48611: printf("\n");
48612: }
48613: }
48614: }
48615: function_tests++;
48616: #endif
48617:
48618: return(test_ret);
48619: }
48620:
48621:
48622: static int
48623: test_xmlXPathNodeLeading(void) {
48624: int test_ret = 0;
48625:
48626: #if defined(LIBXML_XPATH_ENABLED)
48627: int mem_base;
48628: xmlNodeSetPtr ret_val;
48629: xmlNodeSetPtr nodes; /* a node-set */
48630: int n_nodes;
48631: xmlNodePtr node; /* a node */
48632: int n_node;
48633:
48634: for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
48635: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
48636: mem_base = xmlMemBlocks();
48637: nodes = gen_xmlNodeSetPtr(n_nodes, 0);
48638: node = gen_xmlNodePtr(n_node, 1);
48639:
48640: ret_val = xmlXPathNodeLeading(nodes, node);
48641: desret_xmlNodeSetPtr(ret_val);
48642: call_tests++;
48643: des_xmlNodeSetPtr(n_nodes, nodes, 0);
48644: des_xmlNodePtr(n_node, node, 1);
48645: xmlResetLastError();
48646: if (mem_base != xmlMemBlocks()) {
48647: printf("Leak of %d blocks found in xmlXPathNodeLeading",
48648: xmlMemBlocks() - mem_base);
48649: test_ret++;
48650: printf(" %d", n_nodes);
48651: printf(" %d", n_node);
48652: printf("\n");
48653: }
48654: }
48655: }
48656: function_tests++;
48657: #endif
48658:
48659: return(test_ret);
48660: }
48661:
48662:
48663: static int
48664: test_xmlXPathNodeLeadingSorted(void) {
48665: int test_ret = 0;
48666:
48667: #if defined(LIBXML_XPATH_ENABLED)
48668: int mem_base;
48669: xmlNodeSetPtr ret_val;
48670: xmlNodeSetPtr nodes; /* a node-set, sorted by document order */
48671: int n_nodes;
48672: xmlNodePtr node; /* a node */
48673: int n_node;
48674:
48675: for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
48676: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
48677: mem_base = xmlMemBlocks();
48678: nodes = gen_xmlNodeSetPtr(n_nodes, 0);
48679: node = gen_xmlNodePtr(n_node, 1);
48680:
48681: ret_val = xmlXPathNodeLeadingSorted(nodes, node);
48682: desret_xmlNodeSetPtr(ret_val);
48683: call_tests++;
48684: des_xmlNodeSetPtr(n_nodes, nodes, 0);
48685: des_xmlNodePtr(n_node, node, 1);
48686: xmlResetLastError();
48687: if (mem_base != xmlMemBlocks()) {
48688: printf("Leak of %d blocks found in xmlXPathNodeLeadingSorted",
48689: xmlMemBlocks() - mem_base);
48690: test_ret++;
48691: printf(" %d", n_nodes);
48692: printf(" %d", n_node);
48693: printf("\n");
48694: }
48695: }
48696: }
48697: function_tests++;
48698: #endif
48699:
48700: return(test_ret);
48701: }
48702:
48703:
48704: static int
48705: test_xmlXPathNodeSetAdd(void) {
48706: int test_ret = 0;
48707:
48708: #if defined(LIBXML_XPATH_ENABLED)
48709: int mem_base;
48710: xmlNodeSetPtr cur; /* the initial node set */
48711: int n_cur;
48712: xmlNodePtr val; /* a new xmlNodePtr */
48713: int n_val;
48714:
48715: for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
48716: for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
48717: mem_base = xmlMemBlocks();
48718: cur = gen_xmlNodeSetPtr(n_cur, 0);
48719: val = gen_xmlNodePtr(n_val, 1);
48720:
48721: xmlXPathNodeSetAdd(cur, val);
48722: call_tests++;
48723: des_xmlNodeSetPtr(n_cur, cur, 0);
48724: des_xmlNodePtr(n_val, val, 1);
48725: xmlResetLastError();
48726: if (mem_base != xmlMemBlocks()) {
48727: printf("Leak of %d blocks found in xmlXPathNodeSetAdd",
48728: xmlMemBlocks() - mem_base);
48729: test_ret++;
48730: printf(" %d", n_cur);
48731: printf(" %d", n_val);
48732: printf("\n");
48733: }
48734: }
48735: }
48736: function_tests++;
48737: #endif
48738:
48739: return(test_ret);
48740: }
48741:
48742:
48743: static int
48744: test_xmlXPathNodeSetAddNs(void) {
48745: int test_ret = 0;
48746:
48747: #if defined(LIBXML_XPATH_ENABLED)
48748: int mem_base;
48749: xmlNodeSetPtr cur; /* the initial node set */
48750: int n_cur;
48751: xmlNodePtr node; /* the hosting node */
48752: int n_node;
48753: xmlNsPtr ns; /* a the namespace node */
48754: int n_ns;
48755:
48756: for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
48757: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
48758: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
48759: mem_base = xmlMemBlocks();
48760: cur = gen_xmlNodeSetPtr(n_cur, 0);
48761: node = gen_xmlNodePtr(n_node, 1);
48762: ns = gen_xmlNsPtr(n_ns, 2);
48763:
48764: xmlXPathNodeSetAddNs(cur, node, ns);
48765: call_tests++;
48766: des_xmlNodeSetPtr(n_cur, cur, 0);
48767: des_xmlNodePtr(n_node, node, 1);
48768: des_xmlNsPtr(n_ns, ns, 2);
48769: xmlResetLastError();
48770: if (mem_base != xmlMemBlocks()) {
48771: printf("Leak of %d blocks found in xmlXPathNodeSetAddNs",
48772: xmlMemBlocks() - mem_base);
48773: test_ret++;
48774: printf(" %d", n_cur);
48775: printf(" %d", n_node);
48776: printf(" %d", n_ns);
48777: printf("\n");
48778: }
48779: }
48780: }
48781: }
48782: function_tests++;
48783: #endif
48784:
48785: return(test_ret);
48786: }
48787:
48788:
48789: static int
48790: test_xmlXPathNodeSetAddUnique(void) {
48791: int test_ret = 0;
48792:
48793: #if defined(LIBXML_XPATH_ENABLED)
48794: int mem_base;
48795: xmlNodeSetPtr cur; /* the initial node set */
48796: int n_cur;
48797: xmlNodePtr val; /* a new xmlNodePtr */
48798: int n_val;
48799:
48800: for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
48801: for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
48802: mem_base = xmlMemBlocks();
48803: cur = gen_xmlNodeSetPtr(n_cur, 0);
48804: val = gen_xmlNodePtr(n_val, 1);
48805:
48806: xmlXPathNodeSetAddUnique(cur, val);
48807: call_tests++;
48808: des_xmlNodeSetPtr(n_cur, cur, 0);
48809: des_xmlNodePtr(n_val, val, 1);
48810: xmlResetLastError();
48811: if (mem_base != xmlMemBlocks()) {
48812: printf("Leak of %d blocks found in xmlXPathNodeSetAddUnique",
48813: xmlMemBlocks() - mem_base);
48814: test_ret++;
48815: printf(" %d", n_cur);
48816: printf(" %d", n_val);
48817: printf("\n");
48818: }
48819: }
48820: }
48821: function_tests++;
48822: #endif
48823:
48824: return(test_ret);
48825: }
48826:
48827:
48828: static int
48829: test_xmlXPathNodeSetContains(void) {
48830: int test_ret = 0;
48831:
48832: #if defined(LIBXML_XPATH_ENABLED)
48833: int mem_base;
48834: int ret_val;
48835: xmlNodeSetPtr cur; /* the node-set */
48836: int n_cur;
48837: xmlNodePtr val; /* the node */
48838: int n_val;
48839:
48840: for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
48841: for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
48842: mem_base = xmlMemBlocks();
48843: cur = gen_xmlNodeSetPtr(n_cur, 0);
48844: val = gen_xmlNodePtr(n_val, 1);
48845:
48846: ret_val = xmlXPathNodeSetContains(cur, val);
48847: desret_int(ret_val);
48848: call_tests++;
48849: des_xmlNodeSetPtr(n_cur, cur, 0);
48850: des_xmlNodePtr(n_val, val, 1);
48851: xmlResetLastError();
48852: if (mem_base != xmlMemBlocks()) {
48853: printf("Leak of %d blocks found in xmlXPathNodeSetContains",
48854: xmlMemBlocks() - mem_base);
48855: test_ret++;
48856: printf(" %d", n_cur);
48857: printf(" %d", n_val);
48858: printf("\n");
48859: }
48860: }
48861: }
48862: function_tests++;
48863: #endif
48864:
48865: return(test_ret);
48866: }
48867:
48868:
48869: static int
48870: test_xmlXPathNodeSetDel(void) {
48871: int test_ret = 0;
48872:
48873: #if defined(LIBXML_XPATH_ENABLED)
48874: int mem_base;
48875: xmlNodeSetPtr cur; /* the initial node set */
48876: int n_cur;
48877: xmlNodePtr val; /* an xmlNodePtr */
48878: int n_val;
48879:
48880: for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
48881: for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
48882: mem_base = xmlMemBlocks();
48883: cur = gen_xmlNodeSetPtr(n_cur, 0);
48884: val = gen_xmlNodePtr(n_val, 1);
48885:
48886: xmlXPathNodeSetDel(cur, val);
48887: call_tests++;
48888: des_xmlNodeSetPtr(n_cur, cur, 0);
48889: des_xmlNodePtr(n_val, val, 1);
48890: xmlResetLastError();
48891: if (mem_base != xmlMemBlocks()) {
48892: printf("Leak of %d blocks found in xmlXPathNodeSetDel",
48893: xmlMemBlocks() - mem_base);
48894: test_ret++;
48895: printf(" %d", n_cur);
48896: printf(" %d", n_val);
48897: printf("\n");
48898: }
48899: }
48900: }
48901: function_tests++;
48902: #endif
48903:
48904: return(test_ret);
48905: }
48906:
48907:
48908: static int
48909: test_xmlXPathNodeSetMerge(void) {
48910: int test_ret = 0;
48911:
48912: #if defined(LIBXML_XPATH_ENABLED)
48913: int mem_base;
48914: xmlNodeSetPtr ret_val;
48915: xmlNodeSetPtr val1; /* the first NodeSet or NULL */
48916: int n_val1;
48917: xmlNodeSetPtr val2; /* the second NodeSet */
48918: int n_val2;
48919:
48920: for (n_val1 = 0;n_val1 < gen_nb_xmlNodeSetPtr;n_val1++) {
48921: for (n_val2 = 0;n_val2 < gen_nb_xmlNodeSetPtr;n_val2++) {
48922: mem_base = xmlMemBlocks();
48923: val1 = gen_xmlNodeSetPtr(n_val1, 0);
48924: val2 = gen_xmlNodeSetPtr(n_val2, 1);
48925:
48926: ret_val = xmlXPathNodeSetMerge(val1, val2);
48927: desret_xmlNodeSetPtr(ret_val);
48928: call_tests++;
48929: des_xmlNodeSetPtr(n_val1, val1, 0);
48930: des_xmlNodeSetPtr(n_val2, val2, 1);
48931: xmlResetLastError();
48932: if (mem_base != xmlMemBlocks()) {
48933: printf("Leak of %d blocks found in xmlXPathNodeSetMerge",
48934: xmlMemBlocks() - mem_base);
48935: test_ret++;
48936: printf(" %d", n_val1);
48937: printf(" %d", n_val2);
48938: printf("\n");
48939: }
48940: }
48941: }
48942: function_tests++;
48943: #endif
48944:
48945: return(test_ret);
48946: }
48947:
48948:
48949: static int
48950: test_xmlXPathNodeSetRemove(void) {
48951: int test_ret = 0;
48952:
48953: #if defined(LIBXML_XPATH_ENABLED)
48954: int mem_base;
48955: xmlNodeSetPtr cur; /* the initial node set */
48956: int n_cur;
48957: int val; /* the index to remove */
48958: int n_val;
48959:
48960: for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
48961: for (n_val = 0;n_val < gen_nb_int;n_val++) {
48962: mem_base = xmlMemBlocks();
48963: cur = gen_xmlNodeSetPtr(n_cur, 0);
48964: val = gen_int(n_val, 1);
48965:
48966: xmlXPathNodeSetRemove(cur, val);
48967: call_tests++;
48968: des_xmlNodeSetPtr(n_cur, cur, 0);
48969: des_int(n_val, val, 1);
48970: xmlResetLastError();
48971: if (mem_base != xmlMemBlocks()) {
48972: printf("Leak of %d blocks found in xmlXPathNodeSetRemove",
48973: xmlMemBlocks() - mem_base);
48974: test_ret++;
48975: printf(" %d", n_cur);
48976: printf(" %d", n_val);
48977: printf("\n");
48978: }
48979: }
48980: }
48981: function_tests++;
48982: #endif
48983:
48984: return(test_ret);
48985: }
48986:
48987:
48988: static int
48989: test_xmlXPathNodeSetSort(void) {
48990: int test_ret = 0;
48991:
48992: #if defined(LIBXML_XPATH_ENABLED)
48993: int mem_base;
48994: xmlNodeSetPtr set; /* the node set */
48995: int n_set;
48996:
48997: for (n_set = 0;n_set < gen_nb_xmlNodeSetPtr;n_set++) {
48998: mem_base = xmlMemBlocks();
48999: set = gen_xmlNodeSetPtr(n_set, 0);
49000:
49001: xmlXPathNodeSetSort(set);
49002: call_tests++;
49003: des_xmlNodeSetPtr(n_set, set, 0);
49004: xmlResetLastError();
49005: if (mem_base != xmlMemBlocks()) {
49006: printf("Leak of %d blocks found in xmlXPathNodeSetSort",
49007: xmlMemBlocks() - mem_base);
49008: test_ret++;
49009: printf(" %d", n_set);
49010: printf("\n");
49011: }
49012: }
49013: function_tests++;
49014: #endif
49015:
49016: return(test_ret);
49017: }
49018:
49019:
49020: static int
49021: test_xmlXPathNodeTrailing(void) {
49022: int test_ret = 0;
49023:
49024: #if defined(LIBXML_XPATH_ENABLED)
49025: int mem_base;
49026: xmlNodeSetPtr ret_val;
49027: xmlNodeSetPtr nodes; /* a node-set */
49028: int n_nodes;
49029: xmlNodePtr node; /* a node */
49030: int n_node;
49031:
49032: for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
49033: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
49034: mem_base = xmlMemBlocks();
49035: nodes = gen_xmlNodeSetPtr(n_nodes, 0);
49036: node = gen_xmlNodePtr(n_node, 1);
49037:
49038: ret_val = xmlXPathNodeTrailing(nodes, node);
49039: desret_xmlNodeSetPtr(ret_val);
49040: call_tests++;
49041: des_xmlNodeSetPtr(n_nodes, nodes, 0);
49042: des_xmlNodePtr(n_node, node, 1);
49043: xmlResetLastError();
49044: if (mem_base != xmlMemBlocks()) {
49045: printf("Leak of %d blocks found in xmlXPathNodeTrailing",
49046: xmlMemBlocks() - mem_base);
49047: test_ret++;
49048: printf(" %d", n_nodes);
49049: printf(" %d", n_node);
49050: printf("\n");
49051: }
49052: }
49053: }
49054: function_tests++;
49055: #endif
49056:
49057: return(test_ret);
49058: }
49059:
49060:
49061: static int
49062: test_xmlXPathNodeTrailingSorted(void) {
49063: int test_ret = 0;
49064:
49065: #if defined(LIBXML_XPATH_ENABLED)
49066: int mem_base;
49067: xmlNodeSetPtr ret_val;
49068: xmlNodeSetPtr nodes; /* a node-set, sorted by document order */
49069: int n_nodes;
49070: xmlNodePtr node; /* a node */
49071: int n_node;
49072:
49073: for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
49074: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
49075: mem_base = xmlMemBlocks();
49076: nodes = gen_xmlNodeSetPtr(n_nodes, 0);
49077: node = gen_xmlNodePtr(n_node, 1);
49078:
49079: ret_val = xmlXPathNodeTrailingSorted(nodes, node);
49080: desret_xmlNodeSetPtr(ret_val);
49081: call_tests++;
49082: des_xmlNodeSetPtr(n_nodes, nodes, 0);
49083: des_xmlNodePtr(n_node, node, 1);
49084: xmlResetLastError();
49085: if (mem_base != xmlMemBlocks()) {
49086: printf("Leak of %d blocks found in xmlXPathNodeTrailingSorted",
49087: xmlMemBlocks() - mem_base);
49088: test_ret++;
49089: printf(" %d", n_nodes);
49090: printf(" %d", n_node);
49091: printf("\n");
49092: }
49093: }
49094: }
49095: function_tests++;
49096: #endif
49097:
49098: return(test_ret);
49099: }
49100:
49101:
49102: static int
49103: test_xmlXPathNormalizeFunction(void) {
49104: int test_ret = 0;
49105:
49106: #if defined(LIBXML_XPATH_ENABLED)
49107: int mem_base;
49108: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49109: int n_ctxt;
49110: int nargs; /* the number of arguments */
49111: int n_nargs;
49112:
49113: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49114: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
49115: mem_base = xmlMemBlocks();
49116: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49117: nargs = gen_int(n_nargs, 1);
49118:
49119: xmlXPathNormalizeFunction(ctxt, nargs);
49120: call_tests++;
49121: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49122: des_int(n_nargs, nargs, 1);
49123: xmlResetLastError();
49124: if (mem_base != xmlMemBlocks()) {
49125: printf("Leak of %d blocks found in xmlXPathNormalizeFunction",
49126: xmlMemBlocks() - mem_base);
49127: test_ret++;
49128: printf(" %d", n_ctxt);
49129: printf(" %d", n_nargs);
49130: printf("\n");
49131: }
49132: }
49133: }
49134: function_tests++;
49135: #endif
49136:
49137: return(test_ret);
49138: }
49139:
49140:
49141: static int
49142: test_xmlXPathNotEqualValues(void) {
49143: int test_ret = 0;
49144:
49145: #if defined(LIBXML_XPATH_ENABLED)
49146: int mem_base;
49147: int ret_val;
49148: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49149: int n_ctxt;
49150:
49151: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49152: mem_base = xmlMemBlocks();
49153: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49154:
49155: ret_val = xmlXPathNotEqualValues(ctxt);
49156: desret_int(ret_val);
49157: call_tests++;
49158: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49159: xmlResetLastError();
49160: if (mem_base != xmlMemBlocks()) {
49161: printf("Leak of %d blocks found in xmlXPathNotEqualValues",
49162: xmlMemBlocks() - mem_base);
49163: test_ret++;
49164: printf(" %d", n_ctxt);
49165: printf("\n");
49166: }
49167: }
49168: function_tests++;
49169: #endif
49170:
49171: return(test_ret);
49172: }
49173:
49174:
49175: static int
49176: test_xmlXPathNotFunction(void) {
49177: int test_ret = 0;
49178:
49179: #if defined(LIBXML_XPATH_ENABLED)
49180: int mem_base;
49181: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49182: int n_ctxt;
49183: int nargs; /* the number of arguments */
49184: int n_nargs;
49185:
49186: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49187: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
49188: mem_base = xmlMemBlocks();
49189: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49190: nargs = gen_int(n_nargs, 1);
49191:
49192: xmlXPathNotFunction(ctxt, nargs);
49193: call_tests++;
49194: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49195: des_int(n_nargs, nargs, 1);
49196: xmlResetLastError();
49197: if (mem_base != xmlMemBlocks()) {
49198: printf("Leak of %d blocks found in xmlXPathNotFunction",
49199: xmlMemBlocks() - mem_base);
49200: test_ret++;
49201: printf(" %d", n_ctxt);
49202: printf(" %d", n_nargs);
49203: printf("\n");
49204: }
49205: }
49206: }
49207: function_tests++;
49208: #endif
49209:
49210: return(test_ret);
49211: }
49212:
49213:
49214: static int
49215: test_xmlXPathNsLookup(void) {
49216: int test_ret = 0;
49217:
49218: #if defined(LIBXML_XPATH_ENABLED)
49219: int mem_base;
49220: const xmlChar * ret_val;
49221: xmlXPathContextPtr ctxt; /* the XPath context */
49222: int n_ctxt;
49223: xmlChar * prefix; /* the namespace prefix value */
49224: int n_prefix;
49225:
49226: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
49227: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
49228: mem_base = xmlMemBlocks();
49229: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
49230: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
49231:
49232: ret_val = xmlXPathNsLookup(ctxt, (const xmlChar *)prefix);
49233: desret_const_xmlChar_ptr(ret_val);
49234: call_tests++;
49235: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
49236: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
49237: xmlResetLastError();
49238: if (mem_base != xmlMemBlocks()) {
49239: printf("Leak of %d blocks found in xmlXPathNsLookup",
49240: xmlMemBlocks() - mem_base);
49241: test_ret++;
49242: printf(" %d", n_ctxt);
49243: printf(" %d", n_prefix);
49244: printf("\n");
49245: }
49246: }
49247: }
49248: function_tests++;
49249: #endif
49250:
49251: return(test_ret);
49252: }
49253:
49254:
49255: static int
49256: test_xmlXPathNumberFunction(void) {
49257: int test_ret = 0;
49258:
49259: #if defined(LIBXML_XPATH_ENABLED)
49260: int mem_base;
49261: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49262: int n_ctxt;
49263: int nargs; /* the number of arguments */
49264: int n_nargs;
49265:
49266: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49267: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
49268: mem_base = xmlMemBlocks();
49269: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49270: nargs = gen_int(n_nargs, 1);
49271:
49272: xmlXPathNumberFunction(ctxt, nargs);
49273: call_tests++;
49274: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49275: des_int(n_nargs, nargs, 1);
49276: xmlResetLastError();
49277: if (mem_base != xmlMemBlocks()) {
49278: printf("Leak of %d blocks found in xmlXPathNumberFunction",
49279: xmlMemBlocks() - mem_base);
49280: test_ret++;
49281: printf(" %d", n_ctxt);
49282: printf(" %d", n_nargs);
49283: printf("\n");
49284: }
49285: }
49286: }
49287: function_tests++;
49288: #endif
49289:
49290: return(test_ret);
49291: }
49292:
49293:
49294: static int
49295: test_xmlXPathParseNCName(void) {
49296: int test_ret = 0;
49297:
49298: #if defined(LIBXML_XPATH_ENABLED)
49299: int mem_base;
49300: xmlChar * ret_val;
49301: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49302: int n_ctxt;
49303:
49304: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49305: mem_base = xmlMemBlocks();
49306: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49307:
49308: ret_val = xmlXPathParseNCName(ctxt);
49309: desret_xmlChar_ptr(ret_val);
49310: call_tests++;
49311: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49312: xmlResetLastError();
49313: if (mem_base != xmlMemBlocks()) {
49314: printf("Leak of %d blocks found in xmlXPathParseNCName",
49315: xmlMemBlocks() - mem_base);
49316: test_ret++;
49317: printf(" %d", n_ctxt);
49318: printf("\n");
49319: }
49320: }
49321: function_tests++;
49322: #endif
49323:
49324: return(test_ret);
49325: }
49326:
49327:
49328: static int
49329: test_xmlXPathParseName(void) {
49330: int test_ret = 0;
49331:
49332: #if defined(LIBXML_XPATH_ENABLED)
49333: int mem_base;
49334: xmlChar * ret_val;
49335: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49336: int n_ctxt;
49337:
49338: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49339: mem_base = xmlMemBlocks();
49340: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49341:
49342: ret_val = xmlXPathParseName(ctxt);
49343: desret_xmlChar_ptr(ret_val);
49344: call_tests++;
49345: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49346: xmlResetLastError();
49347: if (mem_base != xmlMemBlocks()) {
49348: printf("Leak of %d blocks found in xmlXPathParseName",
49349: xmlMemBlocks() - mem_base);
49350: test_ret++;
49351: printf(" %d", n_ctxt);
49352: printf("\n");
49353: }
49354: }
49355: function_tests++;
49356: #endif
49357:
49358: return(test_ret);
49359: }
49360:
49361:
49362: static int
49363: test_xmlXPathPopBoolean(void) {
49364: int test_ret = 0;
49365:
49366: #if defined(LIBXML_XPATH_ENABLED)
49367: int mem_base;
49368: int ret_val;
49369: xmlXPathParserContextPtr ctxt; /* an XPath parser context */
49370: int n_ctxt;
49371:
49372: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49373: mem_base = xmlMemBlocks();
49374: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49375:
49376: ret_val = xmlXPathPopBoolean(ctxt);
49377: desret_int(ret_val);
49378: call_tests++;
49379: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49380: xmlResetLastError();
49381: if (mem_base != xmlMemBlocks()) {
49382: printf("Leak of %d blocks found in xmlXPathPopBoolean",
49383: xmlMemBlocks() - mem_base);
49384: test_ret++;
49385: printf(" %d", n_ctxt);
49386: printf("\n");
49387: }
49388: }
49389: function_tests++;
49390: #endif
49391:
49392: return(test_ret);
49393: }
49394:
49395:
49396: static int
49397: test_xmlXPathPopExternal(void) {
49398: int test_ret = 0;
49399:
49400: #if defined(LIBXML_XPATH_ENABLED)
49401: int mem_base;
49402: void * ret_val;
49403: xmlXPathParserContextPtr ctxt; /* an XPath parser context */
49404: int n_ctxt;
49405:
49406: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49407: mem_base = xmlMemBlocks();
49408: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49409:
49410: ret_val = xmlXPathPopExternal(ctxt);
49411: desret_void_ptr(ret_val);
49412: call_tests++;
49413: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49414: xmlResetLastError();
49415: if (mem_base != xmlMemBlocks()) {
49416: printf("Leak of %d blocks found in xmlXPathPopExternal",
49417: xmlMemBlocks() - mem_base);
49418: test_ret++;
49419: printf(" %d", n_ctxt);
49420: printf("\n");
49421: }
49422: }
49423: function_tests++;
49424: #endif
49425:
49426: return(test_ret);
49427: }
49428:
49429:
49430: static int
49431: test_xmlXPathPopNodeSet(void) {
49432: int test_ret = 0;
49433:
49434: #if defined(LIBXML_XPATH_ENABLED)
49435: int mem_base;
49436: xmlNodeSetPtr ret_val;
49437: xmlXPathParserContextPtr ctxt; /* an XPath parser context */
49438: int n_ctxt;
49439:
49440: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49441: mem_base = xmlMemBlocks();
49442: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49443:
49444: ret_val = xmlXPathPopNodeSet(ctxt);
49445: desret_xmlNodeSetPtr(ret_val);
49446: call_tests++;
49447: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49448: xmlResetLastError();
49449: if (mem_base != xmlMemBlocks()) {
49450: printf("Leak of %d blocks found in xmlXPathPopNodeSet",
49451: xmlMemBlocks() - mem_base);
49452: test_ret++;
49453: printf(" %d", n_ctxt);
49454: printf("\n");
49455: }
49456: }
49457: function_tests++;
49458: #endif
49459:
49460: return(test_ret);
49461: }
49462:
49463:
49464: static int
49465: test_xmlXPathPopNumber(void) {
49466: int test_ret = 0;
49467:
49468: #if defined(LIBXML_XPATH_ENABLED)
49469: int mem_base;
49470: double ret_val;
49471: xmlXPathParserContextPtr ctxt; /* an XPath parser context */
49472: int n_ctxt;
49473:
49474: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49475: mem_base = xmlMemBlocks();
49476: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49477:
49478: ret_val = xmlXPathPopNumber(ctxt);
49479: desret_double(ret_val);
49480: call_tests++;
49481: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49482: xmlResetLastError();
49483: if (mem_base != xmlMemBlocks()) {
49484: printf("Leak of %d blocks found in xmlXPathPopNumber",
49485: xmlMemBlocks() - mem_base);
49486: test_ret++;
49487: printf(" %d", n_ctxt);
49488: printf("\n");
49489: }
49490: }
49491: function_tests++;
49492: #endif
49493:
49494: return(test_ret);
49495: }
49496:
49497:
49498: static int
49499: test_xmlXPathPopString(void) {
49500: int test_ret = 0;
49501:
49502: #if defined(LIBXML_XPATH_ENABLED)
49503: int mem_base;
49504: xmlChar * ret_val;
49505: xmlXPathParserContextPtr ctxt; /* an XPath parser context */
49506: int n_ctxt;
49507:
49508: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49509: mem_base = xmlMemBlocks();
49510: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49511:
49512: ret_val = xmlXPathPopString(ctxt);
49513: desret_xmlChar_ptr(ret_val);
49514: call_tests++;
49515: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49516: xmlResetLastError();
49517: if (mem_base != xmlMemBlocks()) {
49518: printf("Leak of %d blocks found in xmlXPathPopString",
49519: xmlMemBlocks() - mem_base);
49520: test_ret++;
49521: printf(" %d", n_ctxt);
49522: printf("\n");
49523: }
49524: }
49525: function_tests++;
49526: #endif
49527:
49528: return(test_ret);
49529: }
49530:
49531:
49532: static int
49533: test_xmlXPathPositionFunction(void) {
49534: int test_ret = 0;
49535:
49536: #if defined(LIBXML_XPATH_ENABLED)
49537: int mem_base;
49538: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49539: int n_ctxt;
49540: int nargs; /* the number of arguments */
49541: int n_nargs;
49542:
49543: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49544: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
49545: mem_base = xmlMemBlocks();
49546: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49547: nargs = gen_int(n_nargs, 1);
49548:
49549: xmlXPathPositionFunction(ctxt, nargs);
49550: call_tests++;
49551: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49552: des_int(n_nargs, nargs, 1);
49553: xmlResetLastError();
49554: if (mem_base != xmlMemBlocks()) {
49555: printf("Leak of %d blocks found in xmlXPathPositionFunction",
49556: xmlMemBlocks() - mem_base);
49557: test_ret++;
49558: printf(" %d", n_ctxt);
49559: printf(" %d", n_nargs);
49560: printf("\n");
49561: }
49562: }
49563: }
49564: function_tests++;
49565: #endif
49566:
49567: return(test_ret);
49568: }
49569:
49570:
49571: static int
49572: test_xmlXPathRegisterAllFunctions(void) {
49573: int test_ret = 0;
49574:
49575: #if defined(LIBXML_XPATH_ENABLED)
49576: int mem_base;
49577: xmlXPathContextPtr ctxt; /* the XPath context */
49578: int n_ctxt;
49579:
49580: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
49581: mem_base = xmlMemBlocks();
49582: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
49583:
49584: xmlXPathRegisterAllFunctions(ctxt);
49585: call_tests++;
49586: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
49587: xmlResetLastError();
49588: if (mem_base != xmlMemBlocks()) {
49589: printf("Leak of %d blocks found in xmlXPathRegisterAllFunctions",
49590: xmlMemBlocks() - mem_base);
49591: test_ret++;
49592: printf(" %d", n_ctxt);
49593: printf("\n");
49594: }
49595: }
49596: function_tests++;
49597: #endif
49598:
49599: return(test_ret);
49600: }
49601:
49602:
49603: static int
49604: test_xmlXPathRegisterFunc(void) {
49605: int test_ret = 0;
49606:
49607:
49608: /* missing type support */
49609: return(test_ret);
49610: }
49611:
49612:
49613: static int
49614: test_xmlXPathRegisterFuncLookup(void) {
49615: int test_ret = 0;
49616:
49617:
49618: /* missing type support */
49619: return(test_ret);
49620: }
49621:
49622:
49623: static int
49624: test_xmlXPathRegisterFuncNS(void) {
49625: int test_ret = 0;
49626:
49627:
49628: /* missing type support */
49629: return(test_ret);
49630: }
49631:
49632:
49633: static int
49634: test_xmlXPathRegisterNs(void) {
49635: int test_ret = 0;
49636:
49637: #if defined(LIBXML_XPATH_ENABLED)
49638: int mem_base;
49639: int ret_val;
49640: xmlXPathContextPtr ctxt; /* the XPath context */
49641: int n_ctxt;
49642: xmlChar * prefix; /* the namespace prefix cannot be NULL or empty string */
49643: int n_prefix;
49644: xmlChar * ns_uri; /* the namespace name */
49645: int n_ns_uri;
49646:
49647: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
49648: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
49649: for (n_ns_uri = 0;n_ns_uri < gen_nb_const_xmlChar_ptr;n_ns_uri++) {
49650: mem_base = xmlMemBlocks();
49651: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
49652: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
49653: ns_uri = gen_const_xmlChar_ptr(n_ns_uri, 2);
49654:
49655: ret_val = xmlXPathRegisterNs(ctxt, (const xmlChar *)prefix, (const xmlChar *)ns_uri);
49656: desret_int(ret_val);
49657: call_tests++;
49658: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
49659: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
49660: des_const_xmlChar_ptr(n_ns_uri, (const xmlChar *)ns_uri, 2);
49661: xmlResetLastError();
49662: if (mem_base != xmlMemBlocks()) {
49663: printf("Leak of %d blocks found in xmlXPathRegisterNs",
49664: xmlMemBlocks() - mem_base);
49665: test_ret++;
49666: printf(" %d", n_ctxt);
49667: printf(" %d", n_prefix);
49668: printf(" %d", n_ns_uri);
49669: printf("\n");
49670: }
49671: }
49672: }
49673: }
49674: function_tests++;
49675: #endif
49676:
49677: return(test_ret);
49678: }
49679:
49680:
49681: static int
49682: test_xmlXPathRegisterVariable(void) {
49683: int test_ret = 0;
49684:
49685: #if defined(LIBXML_XPATH_ENABLED)
49686: int mem_base;
49687: int ret_val;
49688: xmlXPathContextPtr ctxt; /* the XPath context */
49689: int n_ctxt;
49690: xmlChar * name; /* the variable name */
49691: int n_name;
49692: xmlXPathObjectPtr value; /* the variable value or NULL */
49693: int n_value;
49694:
49695: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
49696: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
49697: for (n_value = 0;n_value < gen_nb_xmlXPathObjectPtr;n_value++) {
49698: mem_base = xmlMemBlocks();
49699: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
49700: name = gen_const_xmlChar_ptr(n_name, 1);
49701: value = gen_xmlXPathObjectPtr(n_value, 2);
49702:
49703: ret_val = xmlXPathRegisterVariable(ctxt, (const xmlChar *)name, value);
49704: desret_int(ret_val);
49705: call_tests++;
49706: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
49707: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
49708: des_xmlXPathObjectPtr(n_value, value, 2);
49709: xmlResetLastError();
49710: if (mem_base != xmlMemBlocks()) {
49711: printf("Leak of %d blocks found in xmlXPathRegisterVariable",
49712: xmlMemBlocks() - mem_base);
49713: test_ret++;
49714: printf(" %d", n_ctxt);
49715: printf(" %d", n_name);
49716: printf(" %d", n_value);
49717: printf("\n");
49718: }
49719: }
49720: }
49721: }
49722: function_tests++;
49723: #endif
49724:
49725: return(test_ret);
49726: }
49727:
49728:
49729: static int
49730: test_xmlXPathRegisterVariableLookup(void) {
49731: int test_ret = 0;
49732:
49733:
49734: /* missing type support */
49735: return(test_ret);
49736: }
49737:
49738:
49739: static int
49740: test_xmlXPathRegisterVariableNS(void) {
49741: int test_ret = 0;
49742:
49743: #if defined(LIBXML_XPATH_ENABLED)
49744: int mem_base;
49745: int ret_val;
49746: xmlXPathContextPtr ctxt; /* the XPath context */
49747: int n_ctxt;
49748: xmlChar * name; /* the variable name */
49749: int n_name;
49750: xmlChar * ns_uri; /* the variable namespace URI */
49751: int n_ns_uri;
49752: xmlXPathObjectPtr value; /* the variable value or NULL */
49753: int n_value;
49754:
49755: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
49756: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
49757: for (n_ns_uri = 0;n_ns_uri < gen_nb_const_xmlChar_ptr;n_ns_uri++) {
49758: for (n_value = 0;n_value < gen_nb_xmlXPathObjectPtr;n_value++) {
49759: mem_base = xmlMemBlocks();
49760: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
49761: name = gen_const_xmlChar_ptr(n_name, 1);
49762: ns_uri = gen_const_xmlChar_ptr(n_ns_uri, 2);
49763: value = gen_xmlXPathObjectPtr(n_value, 3);
49764:
49765: ret_val = xmlXPathRegisterVariableNS(ctxt, (const xmlChar *)name, (const xmlChar *)ns_uri, value);
49766: desret_int(ret_val);
49767: call_tests++;
49768: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
49769: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
49770: des_const_xmlChar_ptr(n_ns_uri, (const xmlChar *)ns_uri, 2);
49771: des_xmlXPathObjectPtr(n_value, value, 3);
49772: xmlResetLastError();
49773: if (mem_base != xmlMemBlocks()) {
49774: printf("Leak of %d blocks found in xmlXPathRegisterVariableNS",
49775: xmlMemBlocks() - mem_base);
49776: test_ret++;
49777: printf(" %d", n_ctxt);
49778: printf(" %d", n_name);
49779: printf(" %d", n_ns_uri);
49780: printf(" %d", n_value);
49781: printf("\n");
49782: }
49783: }
49784: }
49785: }
49786: }
49787: function_tests++;
49788: #endif
49789:
49790: return(test_ret);
49791: }
49792:
49793:
49794: static int
49795: test_xmlXPathRegisteredFuncsCleanup(void) {
49796: int test_ret = 0;
49797:
49798: #if defined(LIBXML_XPATH_ENABLED)
49799: int mem_base;
49800: xmlXPathContextPtr ctxt; /* the XPath context */
49801: int n_ctxt;
49802:
49803: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
49804: mem_base = xmlMemBlocks();
49805: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
49806:
49807: xmlXPathRegisteredFuncsCleanup(ctxt);
49808: call_tests++;
49809: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
49810: xmlResetLastError();
49811: if (mem_base != xmlMemBlocks()) {
49812: printf("Leak of %d blocks found in xmlXPathRegisteredFuncsCleanup",
49813: xmlMemBlocks() - mem_base);
49814: test_ret++;
49815: printf(" %d", n_ctxt);
49816: printf("\n");
49817: }
49818: }
49819: function_tests++;
49820: #endif
49821:
49822: return(test_ret);
49823: }
49824:
49825:
49826: static int
49827: test_xmlXPathRegisteredNsCleanup(void) {
49828: int test_ret = 0;
49829:
49830: #if defined(LIBXML_XPATH_ENABLED)
49831: int mem_base;
49832: xmlXPathContextPtr ctxt; /* the XPath context */
49833: int n_ctxt;
49834:
49835: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
49836: mem_base = xmlMemBlocks();
49837: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
49838:
49839: xmlXPathRegisteredNsCleanup(ctxt);
49840: call_tests++;
49841: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
49842: xmlResetLastError();
49843: if (mem_base != xmlMemBlocks()) {
49844: printf("Leak of %d blocks found in xmlXPathRegisteredNsCleanup",
49845: xmlMemBlocks() - mem_base);
49846: test_ret++;
49847: printf(" %d", n_ctxt);
49848: printf("\n");
49849: }
49850: }
49851: function_tests++;
49852: #endif
49853:
49854: return(test_ret);
49855: }
49856:
49857:
49858: static int
49859: test_xmlXPathRegisteredVariablesCleanup(void) {
49860: int test_ret = 0;
49861:
49862: #if defined(LIBXML_XPATH_ENABLED)
49863: int mem_base;
49864: xmlXPathContextPtr ctxt; /* the XPath context */
49865: int n_ctxt;
49866:
49867: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
49868: mem_base = xmlMemBlocks();
49869: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
49870:
49871: xmlXPathRegisteredVariablesCleanup(ctxt);
49872: call_tests++;
49873: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
49874: xmlResetLastError();
49875: if (mem_base != xmlMemBlocks()) {
49876: printf("Leak of %d blocks found in xmlXPathRegisteredVariablesCleanup",
49877: xmlMemBlocks() - mem_base);
49878: test_ret++;
49879: printf(" %d", n_ctxt);
49880: printf("\n");
49881: }
49882: }
49883: function_tests++;
49884: #endif
49885:
49886: return(test_ret);
49887: }
49888:
49889:
49890: static int
49891: test_xmlXPathRoot(void) {
49892: int test_ret = 0;
49893:
49894: #if defined(LIBXML_XPATH_ENABLED)
49895: int mem_base;
49896: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49897: int n_ctxt;
49898:
49899: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49900: mem_base = xmlMemBlocks();
49901: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49902:
49903: xmlXPathRoot(ctxt);
49904: call_tests++;
49905: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49906: xmlResetLastError();
49907: if (mem_base != xmlMemBlocks()) {
49908: printf("Leak of %d blocks found in xmlXPathRoot",
49909: xmlMemBlocks() - mem_base);
49910: test_ret++;
49911: printf(" %d", n_ctxt);
49912: printf("\n");
49913: }
49914: }
49915: function_tests++;
49916: #endif
49917:
49918: return(test_ret);
49919: }
49920:
49921:
49922: static int
49923: test_xmlXPathRoundFunction(void) {
49924: int test_ret = 0;
49925:
49926: #if defined(LIBXML_XPATH_ENABLED)
49927: int mem_base;
49928: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49929: int n_ctxt;
49930: int nargs; /* the number of arguments */
49931: int n_nargs;
49932:
49933: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49934: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
49935: mem_base = xmlMemBlocks();
49936: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49937: nargs = gen_int(n_nargs, 1);
49938:
49939: xmlXPathRoundFunction(ctxt, nargs);
49940: call_tests++;
49941: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49942: des_int(n_nargs, nargs, 1);
49943: xmlResetLastError();
49944: if (mem_base != xmlMemBlocks()) {
49945: printf("Leak of %d blocks found in xmlXPathRoundFunction",
49946: xmlMemBlocks() - mem_base);
49947: test_ret++;
49948: printf(" %d", n_ctxt);
49949: printf(" %d", n_nargs);
49950: printf("\n");
49951: }
49952: }
49953: }
49954: function_tests++;
49955: #endif
49956:
49957: return(test_ret);
49958: }
49959:
49960:
49961: static int
49962: test_xmlXPathStartsWithFunction(void) {
49963: int test_ret = 0;
49964:
49965: #if defined(LIBXML_XPATH_ENABLED)
49966: int mem_base;
49967: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49968: int n_ctxt;
49969: int nargs; /* the number of arguments */
49970: int n_nargs;
49971:
49972: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49973: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
49974: mem_base = xmlMemBlocks();
49975: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49976: nargs = gen_int(n_nargs, 1);
49977:
49978: xmlXPathStartsWithFunction(ctxt, nargs);
49979: call_tests++;
49980: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49981: des_int(n_nargs, nargs, 1);
49982: xmlResetLastError();
49983: if (mem_base != xmlMemBlocks()) {
49984: printf("Leak of %d blocks found in xmlXPathStartsWithFunction",
49985: xmlMemBlocks() - mem_base);
49986: test_ret++;
49987: printf(" %d", n_ctxt);
49988: printf(" %d", n_nargs);
49989: printf("\n");
49990: }
49991: }
49992: }
49993: function_tests++;
49994: #endif
49995:
49996: return(test_ret);
49997: }
49998:
49999:
50000: static int
50001: test_xmlXPathStringEvalNumber(void) {
50002: int test_ret = 0;
50003:
50004: #if defined(LIBXML_XPATH_ENABLED)
50005: int mem_base;
50006: double ret_val;
50007: xmlChar * str; /* A string to scan */
50008: int n_str;
50009:
50010: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
50011: mem_base = xmlMemBlocks();
50012: str = gen_const_xmlChar_ptr(n_str, 0);
50013:
50014: ret_val = xmlXPathStringEvalNumber((const xmlChar *)str);
50015: desret_double(ret_val);
50016: call_tests++;
50017: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
50018: xmlResetLastError();
50019: if (mem_base != xmlMemBlocks()) {
50020: printf("Leak of %d blocks found in xmlXPathStringEvalNumber",
50021: xmlMemBlocks() - mem_base);
50022: test_ret++;
50023: printf(" %d", n_str);
50024: printf("\n");
50025: }
50026: }
50027: function_tests++;
50028: #endif
50029:
50030: return(test_ret);
50031: }
50032:
50033:
50034: static int
50035: test_xmlXPathStringFunction(void) {
50036: int test_ret = 0;
50037:
50038: #if defined(LIBXML_XPATH_ENABLED)
50039: int mem_base;
50040: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50041: int n_ctxt;
50042: int nargs; /* the number of arguments */
50043: int n_nargs;
50044:
50045: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50046: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50047: mem_base = xmlMemBlocks();
50048: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50049: nargs = gen_int(n_nargs, 1);
50050:
50051: xmlXPathStringFunction(ctxt, nargs);
50052: call_tests++;
50053: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50054: des_int(n_nargs, nargs, 1);
50055: xmlResetLastError();
50056: if (mem_base != xmlMemBlocks()) {
50057: printf("Leak of %d blocks found in xmlXPathStringFunction",
50058: xmlMemBlocks() - mem_base);
50059: test_ret++;
50060: printf(" %d", n_ctxt);
50061: printf(" %d", n_nargs);
50062: printf("\n");
50063: }
50064: }
50065: }
50066: function_tests++;
50067: #endif
50068:
50069: return(test_ret);
50070: }
50071:
50072:
50073: static int
50074: test_xmlXPathStringLengthFunction(void) {
50075: int test_ret = 0;
50076:
50077: #if defined(LIBXML_XPATH_ENABLED)
50078: int mem_base;
50079: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50080: int n_ctxt;
50081: int nargs; /* the number of arguments */
50082: int n_nargs;
50083:
50084: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50085: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50086: mem_base = xmlMemBlocks();
50087: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50088: nargs = gen_int(n_nargs, 1);
50089:
50090: xmlXPathStringLengthFunction(ctxt, nargs);
50091: call_tests++;
50092: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50093: des_int(n_nargs, nargs, 1);
50094: xmlResetLastError();
50095: if (mem_base != xmlMemBlocks()) {
50096: printf("Leak of %d blocks found in xmlXPathStringLengthFunction",
50097: xmlMemBlocks() - mem_base);
50098: test_ret++;
50099: printf(" %d", n_ctxt);
50100: printf(" %d", n_nargs);
50101: printf("\n");
50102: }
50103: }
50104: }
50105: function_tests++;
50106: #endif
50107:
50108: return(test_ret);
50109: }
50110:
50111:
50112: static int
50113: test_xmlXPathSubValues(void) {
50114: int test_ret = 0;
50115:
50116: #if defined(LIBXML_XPATH_ENABLED)
50117: int mem_base;
50118: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50119: int n_ctxt;
50120:
50121: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50122: mem_base = xmlMemBlocks();
50123: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50124:
50125: xmlXPathSubValues(ctxt);
50126: call_tests++;
50127: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50128: xmlResetLastError();
50129: if (mem_base != xmlMemBlocks()) {
50130: printf("Leak of %d blocks found in xmlXPathSubValues",
50131: xmlMemBlocks() - mem_base);
50132: test_ret++;
50133: printf(" %d", n_ctxt);
50134: printf("\n");
50135: }
50136: }
50137: function_tests++;
50138: #endif
50139:
50140: return(test_ret);
50141: }
50142:
50143:
50144: static int
50145: test_xmlXPathSubstringAfterFunction(void) {
50146: int test_ret = 0;
50147:
50148: #if defined(LIBXML_XPATH_ENABLED)
50149: int mem_base;
50150: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50151: int n_ctxt;
50152: int nargs; /* the number of arguments */
50153: int n_nargs;
50154:
50155: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50156: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50157: mem_base = xmlMemBlocks();
50158: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50159: nargs = gen_int(n_nargs, 1);
50160:
50161: xmlXPathSubstringAfterFunction(ctxt, nargs);
50162: call_tests++;
50163: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50164: des_int(n_nargs, nargs, 1);
50165: xmlResetLastError();
50166: if (mem_base != xmlMemBlocks()) {
50167: printf("Leak of %d blocks found in xmlXPathSubstringAfterFunction",
50168: xmlMemBlocks() - mem_base);
50169: test_ret++;
50170: printf(" %d", n_ctxt);
50171: printf(" %d", n_nargs);
50172: printf("\n");
50173: }
50174: }
50175: }
50176: function_tests++;
50177: #endif
50178:
50179: return(test_ret);
50180: }
50181:
50182:
50183: static int
50184: test_xmlXPathSubstringBeforeFunction(void) {
50185: int test_ret = 0;
50186:
50187: #if defined(LIBXML_XPATH_ENABLED)
50188: int mem_base;
50189: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50190: int n_ctxt;
50191: int nargs; /* the number of arguments */
50192: int n_nargs;
50193:
50194: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50195: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50196: mem_base = xmlMemBlocks();
50197: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50198: nargs = gen_int(n_nargs, 1);
50199:
50200: xmlXPathSubstringBeforeFunction(ctxt, nargs);
50201: call_tests++;
50202: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50203: des_int(n_nargs, nargs, 1);
50204: xmlResetLastError();
50205: if (mem_base != xmlMemBlocks()) {
50206: printf("Leak of %d blocks found in xmlXPathSubstringBeforeFunction",
50207: xmlMemBlocks() - mem_base);
50208: test_ret++;
50209: printf(" %d", n_ctxt);
50210: printf(" %d", n_nargs);
50211: printf("\n");
50212: }
50213: }
50214: }
50215: function_tests++;
50216: #endif
50217:
50218: return(test_ret);
50219: }
50220:
50221:
50222: static int
50223: test_xmlXPathSubstringFunction(void) {
50224: int test_ret = 0;
50225:
50226: #if defined(LIBXML_XPATH_ENABLED)
50227: int mem_base;
50228: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50229: int n_ctxt;
50230: int nargs; /* the number of arguments */
50231: int n_nargs;
50232:
50233: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50234: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50235: mem_base = xmlMemBlocks();
50236: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50237: nargs = gen_int(n_nargs, 1);
50238:
50239: xmlXPathSubstringFunction(ctxt, nargs);
50240: call_tests++;
50241: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50242: des_int(n_nargs, nargs, 1);
50243: xmlResetLastError();
50244: if (mem_base != xmlMemBlocks()) {
50245: printf("Leak of %d blocks found in xmlXPathSubstringFunction",
50246: xmlMemBlocks() - mem_base);
50247: test_ret++;
50248: printf(" %d", n_ctxt);
50249: printf(" %d", n_nargs);
50250: printf("\n");
50251: }
50252: }
50253: }
50254: function_tests++;
50255: #endif
50256:
50257: return(test_ret);
50258: }
50259:
50260:
50261: static int
50262: test_xmlXPathSumFunction(void) {
50263: int test_ret = 0;
50264:
50265: #if defined(LIBXML_XPATH_ENABLED)
50266: int mem_base;
50267: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50268: int n_ctxt;
50269: int nargs; /* the number of arguments */
50270: int n_nargs;
50271:
50272: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50273: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50274: mem_base = xmlMemBlocks();
50275: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50276: nargs = gen_int(n_nargs, 1);
50277:
50278: xmlXPathSumFunction(ctxt, nargs);
50279: call_tests++;
50280: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50281: des_int(n_nargs, nargs, 1);
50282: xmlResetLastError();
50283: if (mem_base != xmlMemBlocks()) {
50284: printf("Leak of %d blocks found in xmlXPathSumFunction",
50285: xmlMemBlocks() - mem_base);
50286: test_ret++;
50287: printf(" %d", n_ctxt);
50288: printf(" %d", n_nargs);
50289: printf("\n");
50290: }
50291: }
50292: }
50293: function_tests++;
50294: #endif
50295:
50296: return(test_ret);
50297: }
50298:
50299:
50300: static int
50301: test_xmlXPathTrailing(void) {
50302: int test_ret = 0;
50303:
50304: #if defined(LIBXML_XPATH_ENABLED)
50305: int mem_base;
50306: xmlNodeSetPtr ret_val;
50307: xmlNodeSetPtr nodes1; /* a node-set */
50308: int n_nodes1;
50309: xmlNodeSetPtr nodes2; /* a node-set */
50310: int n_nodes2;
50311:
50312: for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
50313: for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
50314: mem_base = xmlMemBlocks();
50315: nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
50316: nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
50317:
50318: ret_val = xmlXPathTrailing(nodes1, nodes2);
50319: desret_xmlNodeSetPtr(ret_val);
50320: call_tests++;
50321: des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
50322: des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
50323: xmlResetLastError();
50324: if (mem_base != xmlMemBlocks()) {
50325: printf("Leak of %d blocks found in xmlXPathTrailing",
50326: xmlMemBlocks() - mem_base);
50327: test_ret++;
50328: printf(" %d", n_nodes1);
50329: printf(" %d", n_nodes2);
50330: printf("\n");
50331: }
50332: }
50333: }
50334: function_tests++;
50335: #endif
50336:
50337: return(test_ret);
50338: }
50339:
50340:
50341: static int
50342: test_xmlXPathTrailingSorted(void) {
50343: int test_ret = 0;
50344:
50345: #if defined(LIBXML_XPATH_ENABLED)
50346: int mem_base;
50347: xmlNodeSetPtr ret_val;
50348: xmlNodeSetPtr nodes1; /* a node-set, sorted by document order */
50349: int n_nodes1;
50350: xmlNodeSetPtr nodes2; /* a node-set, sorted by document order */
50351: int n_nodes2;
50352:
50353: for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
50354: for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
50355: mem_base = xmlMemBlocks();
50356: nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
50357: nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
50358:
50359: ret_val = xmlXPathTrailingSorted(nodes1, nodes2);
50360: desret_xmlNodeSetPtr(ret_val);
50361: call_tests++;
50362: des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
50363: des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
50364: xmlResetLastError();
50365: if (mem_base != xmlMemBlocks()) {
50366: printf("Leak of %d blocks found in xmlXPathTrailingSorted",
50367: xmlMemBlocks() - mem_base);
50368: test_ret++;
50369: printf(" %d", n_nodes1);
50370: printf(" %d", n_nodes2);
50371: printf("\n");
50372: }
50373: }
50374: }
50375: function_tests++;
50376: #endif
50377:
50378: return(test_ret);
50379: }
50380:
50381:
50382: static int
50383: test_xmlXPathTranslateFunction(void) {
50384: int test_ret = 0;
50385:
50386: #if defined(LIBXML_XPATH_ENABLED)
50387: int mem_base;
50388: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50389: int n_ctxt;
50390: int nargs; /* the number of arguments */
50391: int n_nargs;
50392:
50393: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50394: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50395: mem_base = xmlMemBlocks();
50396: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50397: nargs = gen_int(n_nargs, 1);
50398:
50399: xmlXPathTranslateFunction(ctxt, nargs);
50400: call_tests++;
50401: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50402: des_int(n_nargs, nargs, 1);
50403: xmlResetLastError();
50404: if (mem_base != xmlMemBlocks()) {
50405: printf("Leak of %d blocks found in xmlXPathTranslateFunction",
50406: xmlMemBlocks() - mem_base);
50407: test_ret++;
50408: printf(" %d", n_ctxt);
50409: printf(" %d", n_nargs);
50410: printf("\n");
50411: }
50412: }
50413: }
50414: function_tests++;
50415: #endif
50416:
50417: return(test_ret);
50418: }
50419:
50420:
50421: static int
50422: test_xmlXPathTrueFunction(void) {
50423: int test_ret = 0;
50424:
50425: #if defined(LIBXML_XPATH_ENABLED)
50426: int mem_base;
50427: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50428: int n_ctxt;
50429: int nargs; /* the number of arguments */
50430: int n_nargs;
50431:
50432: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50433: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50434: mem_base = xmlMemBlocks();
50435: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50436: nargs = gen_int(n_nargs, 1);
50437:
50438: xmlXPathTrueFunction(ctxt, nargs);
50439: call_tests++;
50440: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50441: des_int(n_nargs, nargs, 1);
50442: xmlResetLastError();
50443: if (mem_base != xmlMemBlocks()) {
50444: printf("Leak of %d blocks found in xmlXPathTrueFunction",
50445: xmlMemBlocks() - mem_base);
50446: test_ret++;
50447: printf(" %d", n_ctxt);
50448: printf(" %d", n_nargs);
50449: printf("\n");
50450: }
50451: }
50452: }
50453: function_tests++;
50454: #endif
50455:
50456: return(test_ret);
50457: }
50458:
50459:
50460: static int
50461: test_xmlXPathValueFlipSign(void) {
50462: int test_ret = 0;
50463:
50464: #if defined(LIBXML_XPATH_ENABLED)
50465: int mem_base;
50466: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50467: int n_ctxt;
50468:
50469: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50470: mem_base = xmlMemBlocks();
50471: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50472:
50473: xmlXPathValueFlipSign(ctxt);
50474: call_tests++;
50475: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50476: xmlResetLastError();
50477: if (mem_base != xmlMemBlocks()) {
50478: printf("Leak of %d blocks found in xmlXPathValueFlipSign",
50479: xmlMemBlocks() - mem_base);
50480: test_ret++;
50481: printf(" %d", n_ctxt);
50482: printf("\n");
50483: }
50484: }
50485: function_tests++;
50486: #endif
50487:
50488: return(test_ret);
50489: }
50490:
50491:
50492: static int
50493: test_xmlXPathVariableLookup(void) {
50494: int test_ret = 0;
50495:
50496: #if defined(LIBXML_XPATH_ENABLED)
50497: int mem_base;
50498: xmlXPathObjectPtr ret_val;
50499: xmlXPathContextPtr ctxt; /* the XPath context */
50500: int n_ctxt;
50501: xmlChar * name; /* the variable name */
50502: int n_name;
50503:
50504: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
50505: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
50506: mem_base = xmlMemBlocks();
50507: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
50508: name = gen_const_xmlChar_ptr(n_name, 1);
50509:
50510: ret_val = xmlXPathVariableLookup(ctxt, (const xmlChar *)name);
50511: desret_xmlXPathObjectPtr(ret_val);
50512: call_tests++;
50513: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
50514: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
50515: xmlResetLastError();
50516: if (mem_base != xmlMemBlocks()) {
50517: printf("Leak of %d blocks found in xmlXPathVariableLookup",
50518: xmlMemBlocks() - mem_base);
50519: test_ret++;
50520: printf(" %d", n_ctxt);
50521: printf(" %d", n_name);
50522: printf("\n");
50523: }
50524: }
50525: }
50526: function_tests++;
50527: #endif
50528:
50529: return(test_ret);
50530: }
50531:
50532:
50533: static int
50534: test_xmlXPathVariableLookupNS(void) {
50535: int test_ret = 0;
50536:
50537: #if defined(LIBXML_XPATH_ENABLED)
50538: int mem_base;
50539: xmlXPathObjectPtr ret_val;
50540: xmlXPathContextPtr ctxt; /* the XPath context */
50541: int n_ctxt;
50542: xmlChar * name; /* the variable name */
50543: int n_name;
50544: xmlChar * ns_uri; /* the variable namespace URI */
50545: int n_ns_uri;
50546:
50547: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
50548: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
50549: for (n_ns_uri = 0;n_ns_uri < gen_nb_const_xmlChar_ptr;n_ns_uri++) {
50550: mem_base = xmlMemBlocks();
50551: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
50552: name = gen_const_xmlChar_ptr(n_name, 1);
50553: ns_uri = gen_const_xmlChar_ptr(n_ns_uri, 2);
50554:
50555: ret_val = xmlXPathVariableLookupNS(ctxt, (const xmlChar *)name, (const xmlChar *)ns_uri);
50556: desret_xmlXPathObjectPtr(ret_val);
50557: call_tests++;
50558: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
50559: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
50560: des_const_xmlChar_ptr(n_ns_uri, (const xmlChar *)ns_uri, 2);
50561: xmlResetLastError();
50562: if (mem_base != xmlMemBlocks()) {
50563: printf("Leak of %d blocks found in xmlXPathVariableLookupNS",
50564: xmlMemBlocks() - mem_base);
50565: test_ret++;
50566: printf(" %d", n_ctxt);
50567: printf(" %d", n_name);
50568: printf(" %d", n_ns_uri);
50569: printf("\n");
50570: }
50571: }
50572: }
50573: }
50574: function_tests++;
50575: #endif
50576:
50577: return(test_ret);
50578: }
50579:
50580:
50581: static int
50582: test_xmlXPathWrapCString(void) {
50583: int test_ret = 0;
50584:
50585: #if defined(LIBXML_XPATH_ENABLED)
50586: int mem_base;
50587: xmlXPathObjectPtr ret_val;
50588: char * val; /* the char * value */
50589: int n_val;
50590:
50591: for (n_val = 0;n_val < gen_nb_char_ptr;n_val++) {
50592: mem_base = xmlMemBlocks();
50593: val = gen_char_ptr(n_val, 0);
50594:
50595: ret_val = xmlXPathWrapCString(val);
50596: desret_xmlXPathObjectPtr(ret_val);
50597: call_tests++;
50598: des_char_ptr(n_val, val, 0);
50599: xmlResetLastError();
50600: if (mem_base != xmlMemBlocks()) {
50601: printf("Leak of %d blocks found in xmlXPathWrapCString",
50602: xmlMemBlocks() - mem_base);
50603: test_ret++;
50604: printf(" %d", n_val);
50605: printf("\n");
50606: }
50607: }
50608: function_tests++;
50609: #endif
50610:
50611: return(test_ret);
50612: }
50613:
50614:
50615: static int
50616: test_xmlXPathWrapExternal(void) {
50617: int test_ret = 0;
50618:
50619: #if defined(LIBXML_XPATH_ENABLED)
50620: int mem_base;
50621: xmlXPathObjectPtr ret_val;
50622: void * val; /* the user data */
50623: int n_val;
50624:
50625: for (n_val = 0;n_val < gen_nb_void_ptr;n_val++) {
50626: mem_base = xmlMemBlocks();
50627: val = gen_void_ptr(n_val, 0);
50628:
50629: ret_val = xmlXPathWrapExternal(val);
50630: desret_xmlXPathObjectPtr(ret_val);
50631: call_tests++;
50632: des_void_ptr(n_val, val, 0);
50633: xmlResetLastError();
50634: if (mem_base != xmlMemBlocks()) {
50635: printf("Leak of %d blocks found in xmlXPathWrapExternal",
50636: xmlMemBlocks() - mem_base);
50637: test_ret++;
50638: printf(" %d", n_val);
50639: printf("\n");
50640: }
50641: }
50642: function_tests++;
50643: #endif
50644:
50645: return(test_ret);
50646: }
50647:
50648:
50649: static int
50650: test_xmlXPathWrapNodeSet(void) {
50651: int test_ret = 0;
50652:
50653: #if defined(LIBXML_XPATH_ENABLED)
50654: int mem_base;
50655: xmlXPathObjectPtr ret_val;
50656: xmlNodeSetPtr val; /* the NodePtr value */
50657: int n_val;
50658:
50659: for (n_val = 0;n_val < gen_nb_xmlNodeSetPtr;n_val++) {
50660: mem_base = xmlMemBlocks();
50661: val = gen_xmlNodeSetPtr(n_val, 0);
50662:
50663: ret_val = xmlXPathWrapNodeSet(val);
50664: desret_xmlXPathObjectPtr(ret_val);
50665: call_tests++;
50666: des_xmlNodeSetPtr(n_val, val, 0);
50667: xmlResetLastError();
50668: if (mem_base != xmlMemBlocks()) {
50669: printf("Leak of %d blocks found in xmlXPathWrapNodeSet",
50670: xmlMemBlocks() - mem_base);
50671: test_ret++;
50672: printf(" %d", n_val);
50673: printf("\n");
50674: }
50675: }
50676: function_tests++;
50677: #endif
50678:
50679: return(test_ret);
50680: }
50681:
50682:
50683: static int
50684: test_xmlXPatherror(void) {
50685: int test_ret = 0;
50686:
50687: #if defined(LIBXML_XPATH_ENABLED)
50688: int mem_base;
50689: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50690: int n_ctxt;
50691: const char * file; /* the file name */
50692: int n_file;
50693: int line; /* the line number */
50694: int n_line;
50695: int no; /* the error number */
50696: int n_no;
50697:
50698: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50699: for (n_file = 0;n_file < gen_nb_filepath;n_file++) {
50700: for (n_line = 0;n_line < gen_nb_int;n_line++) {
50701: for (n_no = 0;n_no < gen_nb_int;n_no++) {
50702: mem_base = xmlMemBlocks();
50703: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50704: file = gen_filepath(n_file, 1);
50705: line = gen_int(n_line, 2);
50706: no = gen_int(n_no, 3);
50707:
50708: xmlXPatherror(ctxt, file, line, no);
50709: call_tests++;
50710: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50711: des_filepath(n_file, file, 1);
50712: des_int(n_line, line, 2);
50713: des_int(n_no, no, 3);
50714: xmlResetLastError();
50715: if (mem_base != xmlMemBlocks()) {
50716: printf("Leak of %d blocks found in xmlXPatherror",
50717: xmlMemBlocks() - mem_base);
50718: test_ret++;
50719: printf(" %d", n_ctxt);
50720: printf(" %d", n_file);
50721: printf(" %d", n_line);
50722: printf(" %d", n_no);
50723: printf("\n");
50724: }
50725: }
50726: }
50727: }
50728: }
50729: function_tests++;
50730: #endif
50731:
50732: return(test_ret);
50733: }
50734:
50735: static int
50736: test_xpathInternals(void) {
50737: int test_ret = 0;
50738:
50739: if (quiet == 0) printf("Testing xpathInternals : 106 of 117 functions ...\n");
50740: test_ret += test_valuePop();
50741: test_ret += test_valuePush();
50742: test_ret += test_xmlXPathAddValues();
50743: test_ret += test_xmlXPathBooleanFunction();
50744: test_ret += test_xmlXPathCeilingFunction();
50745: test_ret += test_xmlXPathCompareValues();
50746: test_ret += test_xmlXPathConcatFunction();
50747: test_ret += test_xmlXPathContainsFunction();
50748: test_ret += test_xmlXPathCountFunction();
50749: test_ret += test_xmlXPathDebugDumpCompExpr();
50750: test_ret += test_xmlXPathDebugDumpObject();
50751: test_ret += test_xmlXPathDifference();
50752: test_ret += test_xmlXPathDistinct();
50753: test_ret += test_xmlXPathDistinctSorted();
50754: test_ret += test_xmlXPathDivValues();
50755: test_ret += test_xmlXPathEqualValues();
50756: test_ret += test_xmlXPathErr();
50757: test_ret += test_xmlXPathEvalExpr();
50758: test_ret += test_xmlXPathEvaluatePredicateResult();
50759: test_ret += test_xmlXPathFalseFunction();
50760: test_ret += test_xmlXPathFloorFunction();
50761: test_ret += test_xmlXPathFunctionLookup();
50762: test_ret += test_xmlXPathFunctionLookupNS();
50763: test_ret += test_xmlXPathHasSameNodes();
50764: test_ret += test_xmlXPathIdFunction();
50765: test_ret += test_xmlXPathIntersection();
50766: test_ret += test_xmlXPathIsNodeType();
50767: test_ret += test_xmlXPathLangFunction();
50768: test_ret += test_xmlXPathLastFunction();
50769: test_ret += test_xmlXPathLeading();
50770: test_ret += test_xmlXPathLeadingSorted();
50771: test_ret += test_xmlXPathLocalNameFunction();
50772: test_ret += test_xmlXPathModValues();
50773: test_ret += test_xmlXPathMultValues();
50774: test_ret += test_xmlXPathNamespaceURIFunction();
50775: test_ret += test_xmlXPathNewBoolean();
50776: test_ret += test_xmlXPathNewCString();
50777: test_ret += test_xmlXPathNewFloat();
50778: test_ret += test_xmlXPathNewNodeSet();
50779: test_ret += test_xmlXPathNewNodeSetList();
50780: test_ret += test_xmlXPathNewParserContext();
50781: test_ret += test_xmlXPathNewString();
50782: test_ret += test_xmlXPathNextAncestor();
50783: test_ret += test_xmlXPathNextAncestorOrSelf();
50784: test_ret += test_xmlXPathNextAttribute();
50785: test_ret += test_xmlXPathNextChild();
50786: test_ret += test_xmlXPathNextDescendant();
50787: test_ret += test_xmlXPathNextDescendantOrSelf();
50788: test_ret += test_xmlXPathNextFollowing();
50789: test_ret += test_xmlXPathNextFollowingSibling();
50790: test_ret += test_xmlXPathNextNamespace();
50791: test_ret += test_xmlXPathNextParent();
50792: test_ret += test_xmlXPathNextPreceding();
50793: test_ret += test_xmlXPathNextPrecedingSibling();
50794: test_ret += test_xmlXPathNextSelf();
50795: test_ret += test_xmlXPathNodeLeading();
50796: test_ret += test_xmlXPathNodeLeadingSorted();
50797: test_ret += test_xmlXPathNodeSetAdd();
50798: test_ret += test_xmlXPathNodeSetAddNs();
50799: test_ret += test_xmlXPathNodeSetAddUnique();
50800: test_ret += test_xmlXPathNodeSetContains();
50801: test_ret += test_xmlXPathNodeSetDel();
50802: test_ret += test_xmlXPathNodeSetMerge();
50803: test_ret += test_xmlXPathNodeSetRemove();
50804: test_ret += test_xmlXPathNodeSetSort();
50805: test_ret += test_xmlXPathNodeTrailing();
50806: test_ret += test_xmlXPathNodeTrailingSorted();
50807: test_ret += test_xmlXPathNormalizeFunction();
50808: test_ret += test_xmlXPathNotEqualValues();
50809: test_ret += test_xmlXPathNotFunction();
50810: test_ret += test_xmlXPathNsLookup();
50811: test_ret += test_xmlXPathNumberFunction();
50812: test_ret += test_xmlXPathParseNCName();
50813: test_ret += test_xmlXPathParseName();
50814: test_ret += test_xmlXPathPopBoolean();
50815: test_ret += test_xmlXPathPopExternal();
50816: test_ret += test_xmlXPathPopNodeSet();
50817: test_ret += test_xmlXPathPopNumber();
50818: test_ret += test_xmlXPathPopString();
50819: test_ret += test_xmlXPathPositionFunction();
50820: test_ret += test_xmlXPathRegisterAllFunctions();
50821: test_ret += test_xmlXPathRegisterFunc();
50822: test_ret += test_xmlXPathRegisterFuncLookup();
50823: test_ret += test_xmlXPathRegisterFuncNS();
50824: test_ret += test_xmlXPathRegisterNs();
50825: test_ret += test_xmlXPathRegisterVariable();
50826: test_ret += test_xmlXPathRegisterVariableLookup();
50827: test_ret += test_xmlXPathRegisterVariableNS();
50828: test_ret += test_xmlXPathRegisteredFuncsCleanup();
50829: test_ret += test_xmlXPathRegisteredNsCleanup();
50830: test_ret += test_xmlXPathRegisteredVariablesCleanup();
50831: test_ret += test_xmlXPathRoot();
50832: test_ret += test_xmlXPathRoundFunction();
50833: test_ret += test_xmlXPathStartsWithFunction();
50834: test_ret += test_xmlXPathStringEvalNumber();
50835: test_ret += test_xmlXPathStringFunction();
50836: test_ret += test_xmlXPathStringLengthFunction();
50837: test_ret += test_xmlXPathSubValues();
50838: test_ret += test_xmlXPathSubstringAfterFunction();
50839: test_ret += test_xmlXPathSubstringBeforeFunction();
50840: test_ret += test_xmlXPathSubstringFunction();
50841: test_ret += test_xmlXPathSumFunction();
50842: test_ret += test_xmlXPathTrailing();
50843: test_ret += test_xmlXPathTrailingSorted();
50844: test_ret += test_xmlXPathTranslateFunction();
50845: test_ret += test_xmlXPathTrueFunction();
50846: test_ret += test_xmlXPathValueFlipSign();
50847: test_ret += test_xmlXPathVariableLookup();
50848: test_ret += test_xmlXPathVariableLookupNS();
50849: test_ret += test_xmlXPathWrapCString();
50850: test_ret += test_xmlXPathWrapExternal();
50851: test_ret += test_xmlXPathWrapNodeSet();
50852: test_ret += test_xmlXPatherror();
50853:
50854: if (test_ret != 0)
50855: printf("Module xpathInternals: %d errors\n", test_ret);
50856: return(test_ret);
50857: }
50858:
50859: static int
50860: test_xmlXPtrBuildNodeList(void) {
50861: int test_ret = 0;
50862:
50863: #if defined(LIBXML_XPTR_ENABLED)
50864: int mem_base;
50865: xmlNodePtr ret_val;
50866: xmlXPathObjectPtr obj; /* the XPointer result from the evaluation. */
50867: int n_obj;
50868:
50869: for (n_obj = 0;n_obj < gen_nb_xmlXPathObjectPtr;n_obj++) {
50870: mem_base = xmlMemBlocks();
50871: obj = gen_xmlXPathObjectPtr(n_obj, 0);
50872:
50873: ret_val = xmlXPtrBuildNodeList(obj);
50874: desret_xmlNodePtr(ret_val);
50875: call_tests++;
50876: des_xmlXPathObjectPtr(n_obj, obj, 0);
50877: xmlResetLastError();
50878: if (mem_base != xmlMemBlocks()) {
50879: printf("Leak of %d blocks found in xmlXPtrBuildNodeList",
50880: xmlMemBlocks() - mem_base);
50881: test_ret++;
50882: printf(" %d", n_obj);
50883: printf("\n");
50884: }
50885: }
50886: function_tests++;
50887: #endif
50888:
50889: return(test_ret);
50890: }
50891:
50892:
50893: static int
50894: test_xmlXPtrEval(void) {
50895: int test_ret = 0;
50896:
50897: #if defined(LIBXML_XPTR_ENABLED)
50898: int mem_base;
50899: xmlXPathObjectPtr ret_val;
50900: xmlChar * str; /* the XPointer expression */
50901: int n_str;
50902: xmlXPathContextPtr ctx; /* the XPointer context */
50903: int n_ctx;
50904:
50905: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
50906: for (n_ctx = 0;n_ctx < gen_nb_xmlXPathContextPtr;n_ctx++) {
50907: mem_base = xmlMemBlocks();
50908: str = gen_const_xmlChar_ptr(n_str, 0);
50909: ctx = gen_xmlXPathContextPtr(n_ctx, 1);
50910:
50911: ret_val = xmlXPtrEval((const xmlChar *)str, ctx);
50912: desret_xmlXPathObjectPtr(ret_val);
50913: call_tests++;
50914: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
50915: des_xmlXPathContextPtr(n_ctx, ctx, 1);
50916: xmlResetLastError();
50917: if (mem_base != xmlMemBlocks()) {
50918: printf("Leak of %d blocks found in xmlXPtrEval",
50919: xmlMemBlocks() - mem_base);
50920: test_ret++;
50921: printf(" %d", n_str);
50922: printf(" %d", n_ctx);
50923: printf("\n");
50924: }
50925: }
50926: }
50927: function_tests++;
50928: #endif
50929:
50930: return(test_ret);
50931: }
50932:
50933:
50934: static int
50935: test_xmlXPtrEvalRangePredicate(void) {
50936: int test_ret = 0;
50937:
50938: #if defined(LIBXML_XPTR_ENABLED)
50939: int mem_base;
50940: xmlXPathParserContextPtr ctxt; /* the XPointer Parser context */
50941: int n_ctxt;
50942:
50943: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50944: mem_base = xmlMemBlocks();
50945: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50946:
50947: xmlXPtrEvalRangePredicate(ctxt);
50948: call_tests++;
50949: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50950: xmlResetLastError();
50951: if (mem_base != xmlMemBlocks()) {
50952: printf("Leak of %d blocks found in xmlXPtrEvalRangePredicate",
50953: xmlMemBlocks() - mem_base);
50954: test_ret++;
50955: printf(" %d", n_ctxt);
50956: printf("\n");
50957: }
50958: }
50959: function_tests++;
50960: #endif
50961:
50962: return(test_ret);
50963: }
50964:
50965: #ifdef LIBXML_XPTR_ENABLED
50966:
50967: #define gen_nb_xmlLocationSetPtr 1
50968: static xmlLocationSetPtr gen_xmlLocationSetPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
50969: return(NULL);
50970: }
50971: static void des_xmlLocationSetPtr(int no ATTRIBUTE_UNUSED, xmlLocationSetPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
50972: }
50973: #endif
50974:
50975:
50976: static int
50977: test_xmlXPtrLocationSetAdd(void) {
50978: int test_ret = 0;
50979:
50980: #if defined(LIBXML_XPTR_ENABLED)
50981: int mem_base;
50982: xmlLocationSetPtr cur; /* the initial range set */
50983: int n_cur;
50984: xmlXPathObjectPtr val; /* a new xmlXPathObjectPtr */
50985: int n_val;
50986:
50987: for (n_cur = 0;n_cur < gen_nb_xmlLocationSetPtr;n_cur++) {
50988: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
50989: mem_base = xmlMemBlocks();
50990: cur = gen_xmlLocationSetPtr(n_cur, 0);
50991: val = gen_xmlXPathObjectPtr(n_val, 1);
50992:
50993: xmlXPtrLocationSetAdd(cur, val);
50994: call_tests++;
50995: des_xmlLocationSetPtr(n_cur, cur, 0);
50996: des_xmlXPathObjectPtr(n_val, val, 1);
50997: xmlResetLastError();
50998: if (mem_base != xmlMemBlocks()) {
50999: printf("Leak of %d blocks found in xmlXPtrLocationSetAdd",
51000: xmlMemBlocks() - mem_base);
51001: test_ret++;
51002: printf(" %d", n_cur);
51003: printf(" %d", n_val);
51004: printf("\n");
51005: }
51006: }
51007: }
51008: function_tests++;
51009: #endif
51010:
51011: return(test_ret);
51012: }
51013:
51014:
51015: static int
51016: test_xmlXPtrLocationSetCreate(void) {
51017: int test_ret = 0;
51018:
51019:
51020: /* missing type support */
51021: return(test_ret);
51022: }
51023:
51024:
51025: static int
51026: test_xmlXPtrLocationSetDel(void) {
51027: int test_ret = 0;
51028:
51029: #if defined(LIBXML_XPTR_ENABLED)
51030: int mem_base;
51031: xmlLocationSetPtr cur; /* the initial range set */
51032: int n_cur;
51033: xmlXPathObjectPtr val; /* an xmlXPathObjectPtr */
51034: int n_val;
51035:
51036: for (n_cur = 0;n_cur < gen_nb_xmlLocationSetPtr;n_cur++) {
51037: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
51038: mem_base = xmlMemBlocks();
51039: cur = gen_xmlLocationSetPtr(n_cur, 0);
51040: val = gen_xmlXPathObjectPtr(n_val, 1);
51041:
51042: xmlXPtrLocationSetDel(cur, val);
51043: call_tests++;
51044: des_xmlLocationSetPtr(n_cur, cur, 0);
51045: des_xmlXPathObjectPtr(n_val, val, 1);
51046: xmlResetLastError();
51047: if (mem_base != xmlMemBlocks()) {
51048: printf("Leak of %d blocks found in xmlXPtrLocationSetDel",
51049: xmlMemBlocks() - mem_base);
51050: test_ret++;
51051: printf(" %d", n_cur);
51052: printf(" %d", n_val);
51053: printf("\n");
51054: }
51055: }
51056: }
51057: function_tests++;
51058: #endif
51059:
51060: return(test_ret);
51061: }
51062:
51063:
51064: static int
51065: test_xmlXPtrLocationSetMerge(void) {
51066: int test_ret = 0;
51067:
51068:
51069: /* missing type support */
51070: return(test_ret);
51071: }
51072:
51073:
51074: static int
51075: test_xmlXPtrLocationSetRemove(void) {
51076: int test_ret = 0;
51077:
51078: #if defined(LIBXML_XPTR_ENABLED)
51079: int mem_base;
51080: xmlLocationSetPtr cur; /* the initial range set */
51081: int n_cur;
51082: int val; /* the index to remove */
51083: int n_val;
51084:
51085: for (n_cur = 0;n_cur < gen_nb_xmlLocationSetPtr;n_cur++) {
51086: for (n_val = 0;n_val < gen_nb_int;n_val++) {
51087: mem_base = xmlMemBlocks();
51088: cur = gen_xmlLocationSetPtr(n_cur, 0);
51089: val = gen_int(n_val, 1);
51090:
51091: xmlXPtrLocationSetRemove(cur, val);
51092: call_tests++;
51093: des_xmlLocationSetPtr(n_cur, cur, 0);
51094: des_int(n_val, val, 1);
51095: xmlResetLastError();
51096: if (mem_base != xmlMemBlocks()) {
51097: printf("Leak of %d blocks found in xmlXPtrLocationSetRemove",
51098: xmlMemBlocks() - mem_base);
51099: test_ret++;
51100: printf(" %d", n_cur);
51101: printf(" %d", n_val);
51102: printf("\n");
51103: }
51104: }
51105: }
51106: function_tests++;
51107: #endif
51108:
51109: return(test_ret);
51110: }
51111:
51112:
51113: static int
51114: test_xmlXPtrNewCollapsedRange(void) {
51115: int test_ret = 0;
51116:
51117: #if defined(LIBXML_XPTR_ENABLED)
51118: int mem_base;
51119: xmlXPathObjectPtr ret_val;
51120: xmlNodePtr start; /* the starting and ending node */
51121: int n_start;
51122:
51123: for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
51124: mem_base = xmlMemBlocks();
51125: start = gen_xmlNodePtr(n_start, 0);
51126:
51127: ret_val = xmlXPtrNewCollapsedRange(start);
51128: desret_xmlXPathObjectPtr(ret_val);
51129: call_tests++;
51130: des_xmlNodePtr(n_start, start, 0);
51131: xmlResetLastError();
51132: if (mem_base != xmlMemBlocks()) {
51133: printf("Leak of %d blocks found in xmlXPtrNewCollapsedRange",
51134: xmlMemBlocks() - mem_base);
51135: test_ret++;
51136: printf(" %d", n_start);
51137: printf("\n");
51138: }
51139: }
51140: function_tests++;
51141: #endif
51142:
51143: return(test_ret);
51144: }
51145:
51146:
51147: static int
51148: test_xmlXPtrNewContext(void) {
51149: int test_ret = 0;
51150:
51151:
51152: /* missing type support */
51153: return(test_ret);
51154: }
51155:
51156:
51157: static int
51158: test_xmlXPtrNewLocationSetNodeSet(void) {
51159: int test_ret = 0;
51160:
51161: #if defined(LIBXML_XPTR_ENABLED)
51162: int mem_base;
51163: xmlXPathObjectPtr ret_val;
51164: xmlNodeSetPtr set; /* a node set */
51165: int n_set;
51166:
51167: for (n_set = 0;n_set < gen_nb_xmlNodeSetPtr;n_set++) {
51168: mem_base = xmlMemBlocks();
51169: set = gen_xmlNodeSetPtr(n_set, 0);
51170:
51171: ret_val = xmlXPtrNewLocationSetNodeSet(set);
51172: desret_xmlXPathObjectPtr(ret_val);
51173: call_tests++;
51174: des_xmlNodeSetPtr(n_set, set, 0);
51175: xmlResetLastError();
51176: if (mem_base != xmlMemBlocks()) {
51177: printf("Leak of %d blocks found in xmlXPtrNewLocationSetNodeSet",
51178: xmlMemBlocks() - mem_base);
51179: test_ret++;
51180: printf(" %d", n_set);
51181: printf("\n");
51182: }
51183: }
51184: function_tests++;
51185: #endif
51186:
51187: return(test_ret);
51188: }
51189:
51190:
51191: static int
51192: test_xmlXPtrNewLocationSetNodes(void) {
51193: int test_ret = 0;
51194:
51195: #if defined(LIBXML_XPTR_ENABLED)
51196: int mem_base;
51197: xmlXPathObjectPtr ret_val;
51198: xmlNodePtr start; /* the start NodePtr value */
51199: int n_start;
51200: xmlNodePtr end; /* the end NodePtr value or NULL */
51201: int n_end;
51202:
51203: for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
51204: for (n_end = 0;n_end < gen_nb_xmlNodePtr;n_end++) {
51205: mem_base = xmlMemBlocks();
51206: start = gen_xmlNodePtr(n_start, 0);
51207: end = gen_xmlNodePtr(n_end, 1);
51208:
51209: ret_val = xmlXPtrNewLocationSetNodes(start, end);
51210: desret_xmlXPathObjectPtr(ret_val);
51211: call_tests++;
51212: des_xmlNodePtr(n_start, start, 0);
51213: des_xmlNodePtr(n_end, end, 1);
51214: xmlResetLastError();
51215: if (mem_base != xmlMemBlocks()) {
51216: printf("Leak of %d blocks found in xmlXPtrNewLocationSetNodes",
51217: xmlMemBlocks() - mem_base);
51218: test_ret++;
51219: printf(" %d", n_start);
51220: printf(" %d", n_end);
51221: printf("\n");
51222: }
51223: }
51224: }
51225: function_tests++;
51226: #endif
51227:
51228: return(test_ret);
51229: }
51230:
51231:
51232: static int
51233: test_xmlXPtrNewRange(void) {
51234: int test_ret = 0;
51235:
51236: #if defined(LIBXML_XPTR_ENABLED)
51237: int mem_base;
51238: xmlXPathObjectPtr ret_val;
51239: xmlNodePtr start; /* the starting node */
51240: int n_start;
51241: int startindex; /* the start index */
51242: int n_startindex;
51243: xmlNodePtr end; /* the ending point */
51244: int n_end;
51245: int endindex; /* the ending index */
51246: int n_endindex;
51247:
51248: for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
51249: for (n_startindex = 0;n_startindex < gen_nb_int;n_startindex++) {
51250: for (n_end = 0;n_end < gen_nb_xmlNodePtr;n_end++) {
51251: for (n_endindex = 0;n_endindex < gen_nb_int;n_endindex++) {
51252: mem_base = xmlMemBlocks();
51253: start = gen_xmlNodePtr(n_start, 0);
51254: startindex = gen_int(n_startindex, 1);
51255: end = gen_xmlNodePtr(n_end, 2);
51256: endindex = gen_int(n_endindex, 3);
51257:
51258: ret_val = xmlXPtrNewRange(start, startindex, end, endindex);
51259: desret_xmlXPathObjectPtr(ret_val);
51260: call_tests++;
51261: des_xmlNodePtr(n_start, start, 0);
51262: des_int(n_startindex, startindex, 1);
51263: des_xmlNodePtr(n_end, end, 2);
51264: des_int(n_endindex, endindex, 3);
51265: xmlResetLastError();
51266: if (mem_base != xmlMemBlocks()) {
51267: printf("Leak of %d blocks found in xmlXPtrNewRange",
51268: xmlMemBlocks() - mem_base);
51269: test_ret++;
51270: printf(" %d", n_start);
51271: printf(" %d", n_startindex);
51272: printf(" %d", n_end);
51273: printf(" %d", n_endindex);
51274: printf("\n");
51275: }
51276: }
51277: }
51278: }
51279: }
51280: function_tests++;
51281: #endif
51282:
51283: return(test_ret);
51284: }
51285:
51286:
51287: static int
51288: test_xmlXPtrNewRangeNodeObject(void) {
51289: int test_ret = 0;
51290:
51291: #if defined(LIBXML_XPTR_ENABLED)
51292: int mem_base;
51293: xmlXPathObjectPtr ret_val;
51294: xmlNodePtr start; /* the starting node */
51295: int n_start;
51296: xmlXPathObjectPtr end; /* the ending object */
51297: int n_end;
51298:
51299: for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
51300: for (n_end = 0;n_end < gen_nb_xmlXPathObjectPtr;n_end++) {
51301: mem_base = xmlMemBlocks();
51302: start = gen_xmlNodePtr(n_start, 0);
51303: end = gen_xmlXPathObjectPtr(n_end, 1);
51304:
51305: ret_val = xmlXPtrNewRangeNodeObject(start, end);
51306: desret_xmlXPathObjectPtr(ret_val);
51307: call_tests++;
51308: des_xmlNodePtr(n_start, start, 0);
51309: des_xmlXPathObjectPtr(n_end, end, 1);
51310: xmlResetLastError();
51311: if (mem_base != xmlMemBlocks()) {
51312: printf("Leak of %d blocks found in xmlXPtrNewRangeNodeObject",
51313: xmlMemBlocks() - mem_base);
51314: test_ret++;
51315: printf(" %d", n_start);
51316: printf(" %d", n_end);
51317: printf("\n");
51318: }
51319: }
51320: }
51321: function_tests++;
51322: #endif
51323:
51324: return(test_ret);
51325: }
51326:
51327:
51328: static int
51329: test_xmlXPtrNewRangeNodePoint(void) {
51330: int test_ret = 0;
51331:
51332: #if defined(LIBXML_XPTR_ENABLED)
51333: int mem_base;
51334: xmlXPathObjectPtr ret_val;
51335: xmlNodePtr start; /* the starting node */
51336: int n_start;
51337: xmlXPathObjectPtr end; /* the ending point */
51338: int n_end;
51339:
51340: for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
51341: for (n_end = 0;n_end < gen_nb_xmlXPathObjectPtr;n_end++) {
51342: mem_base = xmlMemBlocks();
51343: start = gen_xmlNodePtr(n_start, 0);
51344: end = gen_xmlXPathObjectPtr(n_end, 1);
51345:
51346: ret_val = xmlXPtrNewRangeNodePoint(start, end);
51347: desret_xmlXPathObjectPtr(ret_val);
51348: call_tests++;
51349: des_xmlNodePtr(n_start, start, 0);
51350: des_xmlXPathObjectPtr(n_end, end, 1);
51351: xmlResetLastError();
51352: if (mem_base != xmlMemBlocks()) {
51353: printf("Leak of %d blocks found in xmlXPtrNewRangeNodePoint",
51354: xmlMemBlocks() - mem_base);
51355: test_ret++;
51356: printf(" %d", n_start);
51357: printf(" %d", n_end);
51358: printf("\n");
51359: }
51360: }
51361: }
51362: function_tests++;
51363: #endif
51364:
51365: return(test_ret);
51366: }
51367:
51368:
51369: static int
51370: test_xmlXPtrNewRangeNodes(void) {
51371: int test_ret = 0;
51372:
51373: #if defined(LIBXML_XPTR_ENABLED)
51374: int mem_base;
51375: xmlXPathObjectPtr ret_val;
51376: xmlNodePtr start; /* the starting node */
51377: int n_start;
51378: xmlNodePtr end; /* the ending node */
51379: int n_end;
51380:
51381: for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
51382: for (n_end = 0;n_end < gen_nb_xmlNodePtr;n_end++) {
51383: mem_base = xmlMemBlocks();
51384: start = gen_xmlNodePtr(n_start, 0);
51385: end = gen_xmlNodePtr(n_end, 1);
51386:
51387: ret_val = xmlXPtrNewRangeNodes(start, end);
51388: desret_xmlXPathObjectPtr(ret_val);
51389: call_tests++;
51390: des_xmlNodePtr(n_start, start, 0);
51391: des_xmlNodePtr(n_end, end, 1);
51392: xmlResetLastError();
51393: if (mem_base != xmlMemBlocks()) {
51394: printf("Leak of %d blocks found in xmlXPtrNewRangeNodes",
51395: xmlMemBlocks() - mem_base);
51396: test_ret++;
51397: printf(" %d", n_start);
51398: printf(" %d", n_end);
51399: printf("\n");
51400: }
51401: }
51402: }
51403: function_tests++;
51404: #endif
51405:
51406: return(test_ret);
51407: }
51408:
51409:
51410: static int
51411: test_xmlXPtrNewRangePointNode(void) {
51412: int test_ret = 0;
51413:
51414: #if defined(LIBXML_XPTR_ENABLED)
51415: int mem_base;
51416: xmlXPathObjectPtr ret_val;
51417: xmlXPathObjectPtr start; /* the starting point */
51418: int n_start;
51419: xmlNodePtr end; /* the ending node */
51420: int n_end;
51421:
51422: for (n_start = 0;n_start < gen_nb_xmlXPathObjectPtr;n_start++) {
51423: for (n_end = 0;n_end < gen_nb_xmlNodePtr;n_end++) {
51424: mem_base = xmlMemBlocks();
51425: start = gen_xmlXPathObjectPtr(n_start, 0);
51426: end = gen_xmlNodePtr(n_end, 1);
51427:
51428: ret_val = xmlXPtrNewRangePointNode(start, end);
51429: desret_xmlXPathObjectPtr(ret_val);
51430: call_tests++;
51431: des_xmlXPathObjectPtr(n_start, start, 0);
51432: des_xmlNodePtr(n_end, end, 1);
51433: xmlResetLastError();
51434: if (mem_base != xmlMemBlocks()) {
51435: printf("Leak of %d blocks found in xmlXPtrNewRangePointNode",
51436: xmlMemBlocks() - mem_base);
51437: test_ret++;
51438: printf(" %d", n_start);
51439: printf(" %d", n_end);
51440: printf("\n");
51441: }
51442: }
51443: }
51444: function_tests++;
51445: #endif
51446:
51447: return(test_ret);
51448: }
51449:
51450:
51451: static int
51452: test_xmlXPtrNewRangePoints(void) {
51453: int test_ret = 0;
51454:
51455: #if defined(LIBXML_XPTR_ENABLED)
51456: int mem_base;
51457: xmlXPathObjectPtr ret_val;
51458: xmlXPathObjectPtr start; /* the starting point */
51459: int n_start;
51460: xmlXPathObjectPtr end; /* the ending point */
51461: int n_end;
51462:
51463: for (n_start = 0;n_start < gen_nb_xmlXPathObjectPtr;n_start++) {
51464: for (n_end = 0;n_end < gen_nb_xmlXPathObjectPtr;n_end++) {
51465: mem_base = xmlMemBlocks();
51466: start = gen_xmlXPathObjectPtr(n_start, 0);
51467: end = gen_xmlXPathObjectPtr(n_end, 1);
51468:
51469: ret_val = xmlXPtrNewRangePoints(start, end);
51470: desret_xmlXPathObjectPtr(ret_val);
51471: call_tests++;
51472: des_xmlXPathObjectPtr(n_start, start, 0);
51473: des_xmlXPathObjectPtr(n_end, end, 1);
51474: xmlResetLastError();
51475: if (mem_base != xmlMemBlocks()) {
51476: printf("Leak of %d blocks found in xmlXPtrNewRangePoints",
51477: xmlMemBlocks() - mem_base);
51478: test_ret++;
51479: printf(" %d", n_start);
51480: printf(" %d", n_end);
51481: printf("\n");
51482: }
51483: }
51484: }
51485: function_tests++;
51486: #endif
51487:
51488: return(test_ret);
51489: }
51490:
51491:
51492: static int
51493: test_xmlXPtrRangeToFunction(void) {
51494: int test_ret = 0;
51495:
51496: #if defined(LIBXML_XPTR_ENABLED)
51497: int mem_base;
51498: xmlXPathParserContextPtr ctxt; /* the XPointer Parser context */
51499: int n_ctxt;
51500: int nargs; /* the number of args */
51501: int n_nargs;
51502:
51503: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
51504: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
51505: mem_base = xmlMemBlocks();
51506: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
51507: nargs = gen_int(n_nargs, 1);
51508:
51509: xmlXPtrRangeToFunction(ctxt, nargs);
51510: call_tests++;
51511: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
51512: des_int(n_nargs, nargs, 1);
51513: xmlResetLastError();
51514: if (mem_base != xmlMemBlocks()) {
51515: printf("Leak of %d blocks found in xmlXPtrRangeToFunction",
51516: xmlMemBlocks() - mem_base);
51517: test_ret++;
51518: printf(" %d", n_ctxt);
51519: printf(" %d", n_nargs);
51520: printf("\n");
51521: }
51522: }
51523: }
51524: function_tests++;
51525: #endif
51526:
51527: return(test_ret);
51528: }
51529:
51530:
51531: static int
51532: test_xmlXPtrWrapLocationSet(void) {
51533: int test_ret = 0;
51534:
51535: #if defined(LIBXML_XPTR_ENABLED)
51536: int mem_base;
51537: xmlXPathObjectPtr ret_val;
51538: xmlLocationSetPtr val; /* the LocationSet value */
51539: int n_val;
51540:
51541: for (n_val = 0;n_val < gen_nb_xmlLocationSetPtr;n_val++) {
51542: mem_base = xmlMemBlocks();
51543: val = gen_xmlLocationSetPtr(n_val, 0);
51544:
51545: ret_val = xmlXPtrWrapLocationSet(val);
51546: desret_xmlXPathObjectPtr(ret_val);
51547: call_tests++;
51548: des_xmlLocationSetPtr(n_val, val, 0);
51549: xmlResetLastError();
51550: if (mem_base != xmlMemBlocks()) {
51551: printf("Leak of %d blocks found in xmlXPtrWrapLocationSet",
51552: xmlMemBlocks() - mem_base);
51553: test_ret++;
51554: printf(" %d", n_val);
51555: printf("\n");
51556: }
51557: }
51558: function_tests++;
51559: #endif
51560:
51561: return(test_ret);
51562: }
51563:
51564: static int
51565: test_xpointer(void) {
51566: int test_ret = 0;
51567:
51568: if (quiet == 0) printf("Testing xpointer : 17 of 21 functions ...\n");
51569: test_ret += test_xmlXPtrBuildNodeList();
51570: test_ret += test_xmlXPtrEval();
51571: test_ret += test_xmlXPtrEvalRangePredicate();
51572: test_ret += test_xmlXPtrLocationSetAdd();
51573: test_ret += test_xmlXPtrLocationSetCreate();
51574: test_ret += test_xmlXPtrLocationSetDel();
51575: test_ret += test_xmlXPtrLocationSetMerge();
51576: test_ret += test_xmlXPtrLocationSetRemove();
51577: test_ret += test_xmlXPtrNewCollapsedRange();
51578: test_ret += test_xmlXPtrNewContext();
51579: test_ret += test_xmlXPtrNewLocationSetNodeSet();
51580: test_ret += test_xmlXPtrNewLocationSetNodes();
51581: test_ret += test_xmlXPtrNewRange();
51582: test_ret += test_xmlXPtrNewRangeNodeObject();
51583: test_ret += test_xmlXPtrNewRangeNodePoint();
51584: test_ret += test_xmlXPtrNewRangeNodes();
51585: test_ret += test_xmlXPtrNewRangePointNode();
51586: test_ret += test_xmlXPtrNewRangePoints();
51587: test_ret += test_xmlXPtrRangeToFunction();
51588: test_ret += test_xmlXPtrWrapLocationSet();
51589:
51590: if (test_ret != 0)
51591: printf("Module xpointer: %d errors\n", test_ret);
51592: return(test_ret);
51593: }
51594: static int
51595: test_module(const char *module) {
51596: if (!strcmp(module, "HTMLparser")) return(test_HTMLparser());
51597: if (!strcmp(module, "HTMLtree")) return(test_HTMLtree());
51598: if (!strcmp(module, "SAX2")) return(test_SAX2());
51599: if (!strcmp(module, "c14n")) return(test_c14n());
51600: if (!strcmp(module, "catalog")) return(test_catalog());
51601: if (!strcmp(module, "chvalid")) return(test_chvalid());
51602: if (!strcmp(module, "debugXML")) return(test_debugXML());
51603: if (!strcmp(module, "dict")) return(test_dict());
51604: if (!strcmp(module, "encoding")) return(test_encoding());
51605: if (!strcmp(module, "entities")) return(test_entities());
51606: if (!strcmp(module, "hash")) return(test_hash());
51607: if (!strcmp(module, "list")) return(test_list());
51608: if (!strcmp(module, "nanoftp")) return(test_nanoftp());
51609: if (!strcmp(module, "nanohttp")) return(test_nanohttp());
51610: if (!strcmp(module, "parser")) return(test_parser());
51611: if (!strcmp(module, "parserInternals")) return(test_parserInternals());
51612: if (!strcmp(module, "pattern")) return(test_pattern());
51613: if (!strcmp(module, "relaxng")) return(test_relaxng());
51614: if (!strcmp(module, "schemasInternals")) return(test_schemasInternals());
51615: if (!strcmp(module, "schematron")) return(test_schematron());
51616: if (!strcmp(module, "tree")) return(test_tree());
51617: if (!strcmp(module, "uri")) return(test_uri());
51618: if (!strcmp(module, "valid")) return(test_valid());
51619: if (!strcmp(module, "xinclude")) return(test_xinclude());
51620: if (!strcmp(module, "xmlIO")) return(test_xmlIO());
51621: if (!strcmp(module, "xmlautomata")) return(test_xmlautomata());
51622: if (!strcmp(module, "xmlerror")) return(test_xmlerror());
51623: if (!strcmp(module, "xmlmodule")) return(test_xmlmodule());
51624: if (!strcmp(module, "xmlreader")) return(test_xmlreader());
51625: if (!strcmp(module, "xmlregexp")) return(test_xmlregexp());
51626: if (!strcmp(module, "xmlsave")) return(test_xmlsave());
51627: if (!strcmp(module, "xmlschemas")) return(test_xmlschemas());
51628: if (!strcmp(module, "xmlschemastypes")) return(test_xmlschemastypes());
51629: if (!strcmp(module, "xmlstring")) return(test_xmlstring());
51630: if (!strcmp(module, "xmlunicode")) return(test_xmlunicode());
51631: if (!strcmp(module, "xmlwriter")) return(test_xmlwriter());
51632: if (!strcmp(module, "xpath")) return(test_xpath());
51633: if (!strcmp(module, "xpathInternals")) return(test_xpathInternals());
51634: if (!strcmp(module, "xpointer")) return(test_xpointer());
51635: return(0);
51636: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to testapi.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2