Annotation of embedaddon/libxml2/testapi.c, revision 1.1.1.2
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:
1.1.1.2 ! misho 22: #if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__MINGW32__)
1.1 misho 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
1.1.1.2 ! misho 602: static const xmlChar *static_buf_content = (xmlChar *)"a static buffer";
1.1 misho 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);
1.1.1.2 ! misho 1043: if (no == 3) return(XML_BUFFER_ALLOC_HYBRID);
! 1044: if (no == 4) return(XML_BUFFER_ALLOC_IMMUTABLE);
1.1 misho 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:
1.1.1.2 ! misho 8449:
! 8450: static int
! 8451: test_xmlInitializeDict(void) {
! 8452: int test_ret = 0;
! 8453:
! 8454: int mem_base;
! 8455: int ret_val;
! 8456:
! 8457: mem_base = xmlMemBlocks();
! 8458:
! 8459: ret_val = xmlInitializeDict();
! 8460: desret_int(ret_val);
! 8461: call_tests++;
! 8462: xmlResetLastError();
! 8463: if (mem_base != xmlMemBlocks()) {
! 8464: printf("Leak of %d blocks found in xmlInitializeDict",
! 8465: xmlMemBlocks() - mem_base);
! 8466: test_ret++;
! 8467: printf("\n");
! 8468: }
! 8469: function_tests++;
! 8470:
! 8471: return(test_ret);
! 8472: }
! 8473:
1.1 misho 8474: static int
8475: test_dict(void) {
8476: int test_ret = 0;
8477:
1.1.1.2 ! misho 8478: if (quiet == 0) printf("Testing dict : 10 of 11 functions ...\n");
1.1 misho 8479: test_ret += test_xmlDictCleanup();
8480: test_ret += test_xmlDictCreate();
8481: test_ret += test_xmlDictCreateSub();
8482: test_ret += test_xmlDictExists();
8483: test_ret += test_xmlDictLookup();
8484: test_ret += test_xmlDictOwns();
8485: test_ret += test_xmlDictQLookup();
8486: test_ret += test_xmlDictReference();
8487: test_ret += test_xmlDictSize();
1.1.1.2 ! misho 8488: test_ret += test_xmlInitializeDict();
1.1 misho 8489:
8490: if (test_ret != 0)
8491: printf("Module dict: %d errors\n", test_ret);
8492: return(test_ret);
8493: }
8494:
8495: static int
8496: test_UTF8Toisolat1(void) {
8497: int test_ret = 0;
8498:
8499: #if defined(LIBXML_OUTPUT_ENABLED)
8500: #ifdef LIBXML_OUTPUT_ENABLED
8501: int mem_base;
8502: int ret_val;
8503: unsigned char * out; /* a pointer to an array of bytes to store the result */
8504: int n_out;
8505: int * outlen; /* the length of @out */
8506: int n_outlen;
8507: unsigned char * in; /* a pointer to an array of UTF-8 chars */
8508: int n_in;
8509: int * inlen; /* the length of @in */
8510: int n_inlen;
8511:
8512: for (n_out = 0;n_out < gen_nb_unsigned_char_ptr;n_out++) {
8513: for (n_outlen = 0;n_outlen < gen_nb_int_ptr;n_outlen++) {
8514: for (n_in = 0;n_in < gen_nb_const_unsigned_char_ptr;n_in++) {
8515: for (n_inlen = 0;n_inlen < gen_nb_int_ptr;n_inlen++) {
8516: mem_base = xmlMemBlocks();
8517: out = gen_unsigned_char_ptr(n_out, 0);
8518: outlen = gen_int_ptr(n_outlen, 1);
8519: in = gen_const_unsigned_char_ptr(n_in, 2);
8520: inlen = gen_int_ptr(n_inlen, 3);
8521:
8522: ret_val = UTF8Toisolat1(out, outlen, (const unsigned char *)in, inlen);
8523: desret_int(ret_val);
8524: call_tests++;
8525: des_unsigned_char_ptr(n_out, out, 0);
8526: des_int_ptr(n_outlen, outlen, 1);
8527: des_const_unsigned_char_ptr(n_in, (const unsigned char *)in, 2);
8528: des_int_ptr(n_inlen, inlen, 3);
8529: xmlResetLastError();
8530: if (mem_base != xmlMemBlocks()) {
8531: printf("Leak of %d blocks found in UTF8Toisolat1",
8532: xmlMemBlocks() - mem_base);
8533: test_ret++;
8534: printf(" %d", n_out);
8535: printf(" %d", n_outlen);
8536: printf(" %d", n_in);
8537: printf(" %d", n_inlen);
8538: printf("\n");
8539: }
8540: }
8541: }
8542: }
8543: }
8544: function_tests++;
8545: #endif
8546: #endif
8547:
8548: return(test_ret);
8549: }
8550:
8551:
8552: static int
8553: test_isolat1ToUTF8(void) {
8554: int test_ret = 0;
8555:
8556: int mem_base;
8557: int ret_val;
8558: unsigned char * out; /* a pointer to an array of bytes to store the result */
8559: int n_out;
8560: int * outlen; /* the length of @out */
8561: int n_outlen;
8562: unsigned char * in; /* a pointer to an array of ISO Latin 1 chars */
8563: int n_in;
8564: int * inlen; /* the length of @in */
8565: int n_inlen;
8566:
8567: for (n_out = 0;n_out < gen_nb_unsigned_char_ptr;n_out++) {
8568: for (n_outlen = 0;n_outlen < gen_nb_int_ptr;n_outlen++) {
8569: for (n_in = 0;n_in < gen_nb_const_unsigned_char_ptr;n_in++) {
8570: for (n_inlen = 0;n_inlen < gen_nb_int_ptr;n_inlen++) {
8571: mem_base = xmlMemBlocks();
8572: out = gen_unsigned_char_ptr(n_out, 0);
8573: outlen = gen_int_ptr(n_outlen, 1);
8574: in = gen_const_unsigned_char_ptr(n_in, 2);
8575: inlen = gen_int_ptr(n_inlen, 3);
8576:
8577: ret_val = isolat1ToUTF8(out, outlen, (const unsigned char *)in, inlen);
8578: desret_int(ret_val);
8579: call_tests++;
8580: des_unsigned_char_ptr(n_out, out, 0);
8581: des_int_ptr(n_outlen, outlen, 1);
8582: des_const_unsigned_char_ptr(n_in, (const unsigned char *)in, 2);
8583: des_int_ptr(n_inlen, inlen, 3);
8584: xmlResetLastError();
8585: if (mem_base != xmlMemBlocks()) {
8586: printf("Leak of %d blocks found in isolat1ToUTF8",
8587: xmlMemBlocks() - mem_base);
8588: test_ret++;
8589: printf(" %d", n_out);
8590: printf(" %d", n_outlen);
8591: printf(" %d", n_in);
8592: printf(" %d", n_inlen);
8593: printf("\n");
8594: }
8595: }
8596: }
8597: }
8598: }
8599: function_tests++;
8600:
8601: return(test_ret);
8602: }
8603:
8604:
8605: static int
8606: test_xmlAddEncodingAlias(void) {
8607: int test_ret = 0;
8608:
8609: int ret_val;
8610: char * name; /* the encoding name as parsed, in UTF-8 format (ASCII actually) */
8611: int n_name;
8612: char * alias; /* the alias name as parsed, in UTF-8 format (ASCII actually) */
8613: int n_alias;
8614:
8615: for (n_name = 0;n_name < gen_nb_const_char_ptr;n_name++) {
8616: for (n_alias = 0;n_alias < gen_nb_const_char_ptr;n_alias++) {
8617: name = gen_const_char_ptr(n_name, 0);
8618: alias = gen_const_char_ptr(n_alias, 1);
8619:
8620: ret_val = xmlAddEncodingAlias((const char *)name, (const char *)alias);
8621: desret_int(ret_val);
8622: call_tests++;
8623: des_const_char_ptr(n_name, (const char *)name, 0);
8624: des_const_char_ptr(n_alias, (const char *)alias, 1);
8625: xmlResetLastError();
8626: }
8627: }
8628: function_tests++;
8629:
8630: return(test_ret);
8631: }
8632:
8633:
8634: #define gen_nb_xmlCharEncodingHandler_ptr 1
8635: static xmlCharEncodingHandler * gen_xmlCharEncodingHandler_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
8636: return(NULL);
8637: }
8638: static void des_xmlCharEncodingHandler_ptr(int no ATTRIBUTE_UNUSED, xmlCharEncodingHandler * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
8639: }
8640:
8641: static int
8642: test_xmlCharEncCloseFunc(void) {
8643: int test_ret = 0;
8644:
8645: int mem_base;
8646: int ret_val;
8647: xmlCharEncodingHandler * handler; /* char enconding transformation data structure */
8648: int n_handler;
8649:
8650: for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandler_ptr;n_handler++) {
8651: mem_base = xmlMemBlocks();
8652: handler = gen_xmlCharEncodingHandler_ptr(n_handler, 0);
8653:
8654: ret_val = xmlCharEncCloseFunc(handler);
8655: desret_int(ret_val);
8656: call_tests++;
8657: des_xmlCharEncodingHandler_ptr(n_handler, handler, 0);
8658: xmlResetLastError();
8659: if (mem_base != xmlMemBlocks()) {
8660: printf("Leak of %d blocks found in xmlCharEncCloseFunc",
8661: xmlMemBlocks() - mem_base);
8662: test_ret++;
8663: printf(" %d", n_handler);
8664: printf("\n");
8665: }
8666: }
8667: function_tests++;
8668:
8669: return(test_ret);
8670: }
8671:
8672:
8673: static int
8674: test_xmlCharEncFirstLine(void) {
8675: int test_ret = 0;
8676:
8677: int mem_base;
8678: int ret_val;
8679: xmlCharEncodingHandler * handler; /* char enconding transformation data structure */
8680: int n_handler;
8681: xmlBufferPtr out; /* an xmlBuffer for the output. */
8682: int n_out;
8683: xmlBufferPtr in; /* an xmlBuffer for the input */
8684: int n_in;
8685:
8686: for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandler_ptr;n_handler++) {
8687: for (n_out = 0;n_out < gen_nb_xmlBufferPtr;n_out++) {
8688: for (n_in = 0;n_in < gen_nb_xmlBufferPtr;n_in++) {
8689: mem_base = xmlMemBlocks();
8690: handler = gen_xmlCharEncodingHandler_ptr(n_handler, 0);
8691: out = gen_xmlBufferPtr(n_out, 1);
8692: in = gen_xmlBufferPtr(n_in, 2);
8693:
8694: ret_val = xmlCharEncFirstLine(handler, out, in);
8695: desret_int(ret_val);
8696: call_tests++;
8697: des_xmlCharEncodingHandler_ptr(n_handler, handler, 0);
8698: des_xmlBufferPtr(n_out, out, 1);
8699: des_xmlBufferPtr(n_in, in, 2);
8700: xmlResetLastError();
8701: if (mem_base != xmlMemBlocks()) {
8702: printf("Leak of %d blocks found in xmlCharEncFirstLine",
8703: xmlMemBlocks() - mem_base);
8704: test_ret++;
8705: printf(" %d", n_handler);
8706: printf(" %d", n_out);
8707: printf(" %d", n_in);
8708: printf("\n");
8709: }
8710: }
8711: }
8712: }
8713: function_tests++;
8714:
8715: return(test_ret);
8716: }
8717:
8718:
8719: static int
8720: test_xmlCharEncInFunc(void) {
8721: int test_ret = 0;
8722:
8723: int mem_base;
8724: int ret_val;
8725: xmlCharEncodingHandler * handler; /* char encoding transformation data structure */
8726: int n_handler;
8727: xmlBufferPtr out; /* an xmlBuffer for the output. */
8728: int n_out;
8729: xmlBufferPtr in; /* an xmlBuffer for the input */
8730: int n_in;
8731:
8732: for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandler_ptr;n_handler++) {
8733: for (n_out = 0;n_out < gen_nb_xmlBufferPtr;n_out++) {
8734: for (n_in = 0;n_in < gen_nb_xmlBufferPtr;n_in++) {
8735: mem_base = xmlMemBlocks();
8736: handler = gen_xmlCharEncodingHandler_ptr(n_handler, 0);
8737: out = gen_xmlBufferPtr(n_out, 1);
8738: in = gen_xmlBufferPtr(n_in, 2);
8739:
8740: ret_val = xmlCharEncInFunc(handler, out, in);
8741: desret_int(ret_val);
8742: call_tests++;
8743: des_xmlCharEncodingHandler_ptr(n_handler, handler, 0);
8744: des_xmlBufferPtr(n_out, out, 1);
8745: des_xmlBufferPtr(n_in, in, 2);
8746: xmlResetLastError();
8747: if (mem_base != xmlMemBlocks()) {
8748: printf("Leak of %d blocks found in xmlCharEncInFunc",
8749: xmlMemBlocks() - mem_base);
8750: test_ret++;
8751: printf(" %d", n_handler);
8752: printf(" %d", n_out);
8753: printf(" %d", n_in);
8754: printf("\n");
8755: }
8756: }
8757: }
8758: }
8759: function_tests++;
8760:
8761: return(test_ret);
8762: }
8763:
8764:
8765: static int
8766: test_xmlCharEncOutFunc(void) {
8767: int test_ret = 0;
8768:
8769: int mem_base;
8770: int ret_val;
8771: xmlCharEncodingHandler * handler; /* char enconding transformation data structure */
8772: int n_handler;
8773: xmlBufferPtr out; /* an xmlBuffer for the output. */
8774: int n_out;
8775: xmlBufferPtr in; /* an xmlBuffer for the input */
8776: int n_in;
8777:
8778: for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandler_ptr;n_handler++) {
8779: for (n_out = 0;n_out < gen_nb_xmlBufferPtr;n_out++) {
8780: for (n_in = 0;n_in < gen_nb_xmlBufferPtr;n_in++) {
8781: mem_base = xmlMemBlocks();
8782: handler = gen_xmlCharEncodingHandler_ptr(n_handler, 0);
8783: out = gen_xmlBufferPtr(n_out, 1);
8784: in = gen_xmlBufferPtr(n_in, 2);
8785:
8786: ret_val = xmlCharEncOutFunc(handler, out, in);
8787: desret_int(ret_val);
8788: call_tests++;
8789: des_xmlCharEncodingHandler_ptr(n_handler, handler, 0);
8790: des_xmlBufferPtr(n_out, out, 1);
8791: des_xmlBufferPtr(n_in, in, 2);
8792: xmlResetLastError();
8793: if (mem_base != xmlMemBlocks()) {
8794: printf("Leak of %d blocks found in xmlCharEncOutFunc",
8795: xmlMemBlocks() - mem_base);
8796: test_ret++;
8797: printf(" %d", n_handler);
8798: printf(" %d", n_out);
8799: printf(" %d", n_in);
8800: printf("\n");
8801: }
8802: }
8803: }
8804: }
8805: function_tests++;
8806:
8807: return(test_ret);
8808: }
8809:
8810:
8811: static int
8812: test_xmlCleanupCharEncodingHandlers(void) {
8813: int test_ret = 0;
8814:
8815:
8816:
8817: xmlCleanupCharEncodingHandlers();
8818: call_tests++;
8819: xmlResetLastError();
8820: function_tests++;
8821:
8822: return(test_ret);
8823: }
8824:
8825:
8826: static int
8827: test_xmlCleanupEncodingAliases(void) {
8828: int test_ret = 0;
8829:
8830: int mem_base;
8831:
8832: mem_base = xmlMemBlocks();
8833:
8834: xmlCleanupEncodingAliases();
8835: call_tests++;
8836: xmlResetLastError();
8837: if (mem_base != xmlMemBlocks()) {
8838: printf("Leak of %d blocks found in xmlCleanupEncodingAliases",
8839: xmlMemBlocks() - mem_base);
8840: test_ret++;
8841: printf("\n");
8842: }
8843: function_tests++;
8844:
8845: return(test_ret);
8846: }
8847:
8848:
8849: static int
8850: test_xmlDelEncodingAlias(void) {
8851: int test_ret = 0;
8852:
8853: int mem_base;
8854: int ret_val;
8855: char * alias; /* the alias name as parsed, in UTF-8 format (ASCII actually) */
8856: int n_alias;
8857:
8858: for (n_alias = 0;n_alias < gen_nb_const_char_ptr;n_alias++) {
8859: mem_base = xmlMemBlocks();
8860: alias = gen_const_char_ptr(n_alias, 0);
8861:
8862: ret_val = xmlDelEncodingAlias((const char *)alias);
8863: desret_int(ret_val);
8864: call_tests++;
8865: des_const_char_ptr(n_alias, (const char *)alias, 0);
8866: xmlResetLastError();
8867: if (mem_base != xmlMemBlocks()) {
8868: printf("Leak of %d blocks found in xmlDelEncodingAlias",
8869: xmlMemBlocks() - mem_base);
8870: test_ret++;
8871: printf(" %d", n_alias);
8872: printf("\n");
8873: }
8874: }
8875: function_tests++;
8876:
8877: return(test_ret);
8878: }
8879:
8880:
8881: static int
8882: test_xmlDetectCharEncoding(void) {
8883: int test_ret = 0;
8884:
8885: int mem_base;
8886: xmlCharEncoding ret_val;
8887: 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). */
8888: int n_in;
8889: int len; /* pointer to the length of the buffer */
8890: int n_len;
8891:
8892: for (n_in = 0;n_in < gen_nb_const_unsigned_char_ptr;n_in++) {
8893: for (n_len = 0;n_len < gen_nb_int;n_len++) {
8894: mem_base = xmlMemBlocks();
8895: in = gen_const_unsigned_char_ptr(n_in, 0);
8896: len = gen_int(n_len, 1);
8897:
8898: ret_val = xmlDetectCharEncoding((const unsigned char *)in, len);
8899: desret_xmlCharEncoding(ret_val);
8900: call_tests++;
8901: des_const_unsigned_char_ptr(n_in, (const unsigned char *)in, 0);
8902: des_int(n_len, len, 1);
8903: xmlResetLastError();
8904: if (mem_base != xmlMemBlocks()) {
8905: printf("Leak of %d blocks found in xmlDetectCharEncoding",
8906: xmlMemBlocks() - mem_base);
8907: test_ret++;
8908: printf(" %d", n_in);
8909: printf(" %d", n_len);
8910: printf("\n");
8911: }
8912: }
8913: }
8914: function_tests++;
8915:
8916: return(test_ret);
8917: }
8918:
8919:
8920: static int
8921: test_xmlFindCharEncodingHandler(void) {
8922: int test_ret = 0;
8923:
8924:
8925: /* missing type support */
8926: return(test_ret);
8927: }
8928:
8929:
8930: static int
8931: test_xmlGetCharEncodingHandler(void) {
8932: int test_ret = 0;
8933:
8934:
8935: /* missing type support */
8936: return(test_ret);
8937: }
8938:
8939:
8940: static int
8941: test_xmlGetCharEncodingName(void) {
8942: int test_ret = 0;
8943:
8944: int mem_base;
8945: const char * ret_val;
8946: xmlCharEncoding enc; /* the encoding */
8947: int n_enc;
8948:
8949: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
8950: mem_base = xmlMemBlocks();
8951: enc = gen_xmlCharEncoding(n_enc, 0);
8952:
8953: ret_val = xmlGetCharEncodingName(enc);
8954: desret_const_char_ptr(ret_val);
8955: call_tests++;
8956: des_xmlCharEncoding(n_enc, enc, 0);
8957: xmlResetLastError();
8958: if (mem_base != xmlMemBlocks()) {
8959: printf("Leak of %d blocks found in xmlGetCharEncodingName",
8960: xmlMemBlocks() - mem_base);
8961: test_ret++;
8962: printf(" %d", n_enc);
8963: printf("\n");
8964: }
8965: }
8966: function_tests++;
8967:
8968: return(test_ret);
8969: }
8970:
8971:
8972: static int
8973: test_xmlGetEncodingAlias(void) {
8974: int test_ret = 0;
8975:
8976: int mem_base;
8977: const char * ret_val;
8978: char * alias; /* the alias name as parsed, in UTF-8 format (ASCII actually) */
8979: int n_alias;
8980:
8981: for (n_alias = 0;n_alias < gen_nb_const_char_ptr;n_alias++) {
8982: mem_base = xmlMemBlocks();
8983: alias = gen_const_char_ptr(n_alias, 0);
8984:
8985: ret_val = xmlGetEncodingAlias((const char *)alias);
8986: desret_const_char_ptr(ret_val);
8987: call_tests++;
8988: des_const_char_ptr(n_alias, (const char *)alias, 0);
8989: xmlResetLastError();
8990: if (mem_base != xmlMemBlocks()) {
8991: printf("Leak of %d blocks found in xmlGetEncodingAlias",
8992: xmlMemBlocks() - mem_base);
8993: test_ret++;
8994: printf(" %d", n_alias);
8995: printf("\n");
8996: }
8997: }
8998: function_tests++;
8999:
9000: return(test_ret);
9001: }
9002:
9003:
9004: static int
9005: test_xmlInitCharEncodingHandlers(void) {
9006: int test_ret = 0;
9007:
9008:
9009:
9010: xmlInitCharEncodingHandlers();
9011: call_tests++;
9012: xmlResetLastError();
9013: function_tests++;
9014:
9015: return(test_ret);
9016: }
9017:
9018:
9019: static int
9020: test_xmlNewCharEncodingHandler(void) {
9021: int test_ret = 0;
9022:
9023:
9024: /* missing type support */
9025: return(test_ret);
9026: }
9027:
9028:
9029: static int
9030: test_xmlParseCharEncoding(void) {
9031: int test_ret = 0;
9032:
9033: int mem_base;
9034: xmlCharEncoding ret_val;
9035: char * name; /* the encoding name as parsed, in UTF-8 format (ASCII actually) */
9036: int n_name;
9037:
9038: for (n_name = 0;n_name < gen_nb_const_char_ptr;n_name++) {
9039: mem_base = xmlMemBlocks();
9040: name = gen_const_char_ptr(n_name, 0);
9041:
9042: ret_val = xmlParseCharEncoding((const char *)name);
9043: desret_xmlCharEncoding(ret_val);
9044: call_tests++;
9045: des_const_char_ptr(n_name, (const char *)name, 0);
9046: xmlResetLastError();
9047: if (mem_base != xmlMemBlocks()) {
9048: printf("Leak of %d blocks found in xmlParseCharEncoding",
9049: xmlMemBlocks() - mem_base);
9050: test_ret++;
9051: printf(" %d", n_name);
9052: printf("\n");
9053: }
9054: }
9055: function_tests++;
9056:
9057: return(test_ret);
9058: }
9059:
9060:
9061: #define gen_nb_xmlCharEncodingHandlerPtr 1
9062: static xmlCharEncodingHandlerPtr gen_xmlCharEncodingHandlerPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
9063: return(NULL);
9064: }
9065: static void des_xmlCharEncodingHandlerPtr(int no ATTRIBUTE_UNUSED, xmlCharEncodingHandlerPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
9066: }
9067:
9068: static int
9069: test_xmlRegisterCharEncodingHandler(void) {
9070: int test_ret = 0;
9071:
9072: int mem_base;
9073: xmlCharEncodingHandlerPtr handler; /* the xmlCharEncodingHandlerPtr handler block */
9074: int n_handler;
9075:
9076: for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandlerPtr;n_handler++) {
9077: mem_base = xmlMemBlocks();
9078: handler = gen_xmlCharEncodingHandlerPtr(n_handler, 0);
9079:
9080: xmlRegisterCharEncodingHandler(handler);
9081: call_tests++;
9082: des_xmlCharEncodingHandlerPtr(n_handler, handler, 0);
9083: xmlResetLastError();
9084: if (mem_base != xmlMemBlocks()) {
9085: printf("Leak of %d blocks found in xmlRegisterCharEncodingHandler",
9086: xmlMemBlocks() - mem_base);
9087: test_ret++;
9088: printf(" %d", n_handler);
9089: printf("\n");
9090: }
9091: }
9092: function_tests++;
9093:
9094: return(test_ret);
9095: }
9096:
9097: static int
9098: test_encoding(void) {
9099: int test_ret = 0;
9100:
9101: if (quiet == 0) printf("Testing encoding : 16 of 19 functions ...\n");
9102: test_ret += test_UTF8Toisolat1();
9103: test_ret += test_isolat1ToUTF8();
9104: test_ret += test_xmlAddEncodingAlias();
9105: test_ret += test_xmlCharEncCloseFunc();
9106: test_ret += test_xmlCharEncFirstLine();
9107: test_ret += test_xmlCharEncInFunc();
9108: test_ret += test_xmlCharEncOutFunc();
9109: test_ret += test_xmlCleanupCharEncodingHandlers();
9110: test_ret += test_xmlCleanupEncodingAliases();
9111: test_ret += test_xmlDelEncodingAlias();
9112: test_ret += test_xmlDetectCharEncoding();
9113: test_ret += test_xmlFindCharEncodingHandler();
9114: test_ret += test_xmlGetCharEncodingHandler();
9115: test_ret += test_xmlGetCharEncodingName();
9116: test_ret += test_xmlGetEncodingAlias();
9117: test_ret += test_xmlInitCharEncodingHandlers();
9118: test_ret += test_xmlNewCharEncodingHandler();
9119: test_ret += test_xmlParseCharEncoding();
9120: test_ret += test_xmlRegisterCharEncodingHandler();
9121:
9122: if (test_ret != 0)
9123: printf("Module encoding: %d errors\n", test_ret);
9124: return(test_ret);
9125: }
9126:
9127: static int
9128: test_xmlAddDocEntity(void) {
9129: int test_ret = 0;
9130:
9131: int mem_base;
9132: xmlEntityPtr ret_val;
9133: xmlDocPtr doc; /* the document */
9134: int n_doc;
9135: xmlChar * name; /* the entity name */
9136: int n_name;
9137: int type; /* the entity type XML_xxx_yyy_ENTITY */
9138: int n_type;
9139: xmlChar * ExternalID; /* the entity external ID if available */
9140: int n_ExternalID;
9141: xmlChar * SystemID; /* the entity system ID if available */
9142: int n_SystemID;
9143: xmlChar * content; /* the entity content */
9144: int n_content;
9145:
9146: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
9147: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9148: for (n_type = 0;n_type < gen_nb_int;n_type++) {
9149: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
9150: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
9151: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
9152: mem_base = xmlMemBlocks();
9153: doc = gen_xmlDocPtr(n_doc, 0);
9154: name = gen_const_xmlChar_ptr(n_name, 1);
9155: type = gen_int(n_type, 2);
9156: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 3);
9157: SystemID = gen_const_xmlChar_ptr(n_SystemID, 4);
9158: content = gen_const_xmlChar_ptr(n_content, 5);
9159:
9160: ret_val = xmlAddDocEntity(doc, (const xmlChar *)name, type, (const xmlChar *)ExternalID, (const xmlChar *)SystemID, (const xmlChar *)content);
9161: desret_xmlEntityPtr(ret_val);
9162: call_tests++;
9163: des_xmlDocPtr(n_doc, doc, 0);
9164: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9165: des_int(n_type, type, 2);
9166: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 3);
9167: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 4);
9168: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 5);
9169: xmlResetLastError();
9170: if (mem_base != xmlMemBlocks()) {
9171: printf("Leak of %d blocks found in xmlAddDocEntity",
9172: xmlMemBlocks() - mem_base);
9173: test_ret++;
9174: printf(" %d", n_doc);
9175: printf(" %d", n_name);
9176: printf(" %d", n_type);
9177: printf(" %d", n_ExternalID);
9178: printf(" %d", n_SystemID);
9179: printf(" %d", n_content);
9180: printf("\n");
9181: }
9182: }
9183: }
9184: }
9185: }
9186: }
9187: }
9188: function_tests++;
9189:
9190: return(test_ret);
9191: }
9192:
9193:
9194: static int
9195: test_xmlAddDtdEntity(void) {
9196: int test_ret = 0;
9197:
9198: int mem_base;
9199: xmlEntityPtr ret_val;
9200: xmlDocPtr doc; /* the document */
9201: int n_doc;
9202: xmlChar * name; /* the entity name */
9203: int n_name;
9204: int type; /* the entity type XML_xxx_yyy_ENTITY */
9205: int n_type;
9206: xmlChar * ExternalID; /* the entity external ID if available */
9207: int n_ExternalID;
9208: xmlChar * SystemID; /* the entity system ID if available */
9209: int n_SystemID;
9210: xmlChar * content; /* the entity content */
9211: int n_content;
9212:
9213: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
9214: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9215: for (n_type = 0;n_type < gen_nb_int;n_type++) {
9216: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
9217: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
9218: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
9219: mem_base = xmlMemBlocks();
9220: doc = gen_xmlDocPtr(n_doc, 0);
9221: name = gen_const_xmlChar_ptr(n_name, 1);
9222: type = gen_int(n_type, 2);
9223: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 3);
9224: SystemID = gen_const_xmlChar_ptr(n_SystemID, 4);
9225: content = gen_const_xmlChar_ptr(n_content, 5);
9226:
9227: ret_val = xmlAddDtdEntity(doc, (const xmlChar *)name, type, (const xmlChar *)ExternalID, (const xmlChar *)SystemID, (const xmlChar *)content);
9228: desret_xmlEntityPtr(ret_val);
9229: call_tests++;
9230: des_xmlDocPtr(n_doc, doc, 0);
9231: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9232: des_int(n_type, type, 2);
9233: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 3);
9234: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 4);
9235: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 5);
9236: xmlResetLastError();
9237: if (mem_base != xmlMemBlocks()) {
9238: printf("Leak of %d blocks found in xmlAddDtdEntity",
9239: xmlMemBlocks() - mem_base);
9240: test_ret++;
9241: printf(" %d", n_doc);
9242: printf(" %d", n_name);
9243: printf(" %d", n_type);
9244: printf(" %d", n_ExternalID);
9245: printf(" %d", n_SystemID);
9246: printf(" %d", n_content);
9247: printf("\n");
9248: }
9249: }
9250: }
9251: }
9252: }
9253: }
9254: }
9255: function_tests++;
9256:
9257: return(test_ret);
9258: }
9259:
9260:
9261: static int
9262: test_xmlCleanupPredefinedEntities(void) {
9263: int test_ret = 0;
9264:
9265: #if defined(LIBXML_LEGACY_ENABLED)
9266: #ifdef LIBXML_LEGACY_ENABLED
9267: int mem_base;
9268:
9269: mem_base = xmlMemBlocks();
9270:
9271: xmlCleanupPredefinedEntities();
9272: call_tests++;
9273: xmlResetLastError();
9274: if (mem_base != xmlMemBlocks()) {
9275: printf("Leak of %d blocks found in xmlCleanupPredefinedEntities",
9276: xmlMemBlocks() - mem_base);
9277: test_ret++;
9278: printf("\n");
9279: }
9280: function_tests++;
9281: #endif
9282: #endif
9283:
9284: return(test_ret);
9285: }
9286:
9287:
9288: #define gen_nb_xmlEntitiesTablePtr 1
9289: static xmlEntitiesTablePtr gen_xmlEntitiesTablePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
9290: return(NULL);
9291: }
9292: static void des_xmlEntitiesTablePtr(int no ATTRIBUTE_UNUSED, xmlEntitiesTablePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
9293: }
9294:
9295: static int
9296: test_xmlCopyEntitiesTable(void) {
9297: int test_ret = 0;
9298:
9299:
9300: /* missing type support */
9301: return(test_ret);
9302: }
9303:
9304:
9305: static int
9306: test_xmlCreateEntitiesTable(void) {
9307: int test_ret = 0;
9308:
9309:
9310: /* missing type support */
9311: return(test_ret);
9312: }
9313:
9314:
9315: static int
9316: test_xmlDumpEntitiesTable(void) {
9317: int test_ret = 0;
9318:
9319: #if defined(LIBXML_OUTPUT_ENABLED)
9320: int mem_base;
9321: xmlBufferPtr buf; /* An XML buffer. */
9322: int n_buf;
9323: xmlEntitiesTablePtr table; /* An entity table */
9324: int n_table;
9325:
9326: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
9327: for (n_table = 0;n_table < gen_nb_xmlEntitiesTablePtr;n_table++) {
9328: mem_base = xmlMemBlocks();
9329: buf = gen_xmlBufferPtr(n_buf, 0);
9330: table = gen_xmlEntitiesTablePtr(n_table, 1);
9331:
9332: xmlDumpEntitiesTable(buf, table);
9333: call_tests++;
9334: des_xmlBufferPtr(n_buf, buf, 0);
9335: des_xmlEntitiesTablePtr(n_table, table, 1);
9336: xmlResetLastError();
9337: if (mem_base != xmlMemBlocks()) {
9338: printf("Leak of %d blocks found in xmlDumpEntitiesTable",
9339: xmlMemBlocks() - mem_base);
9340: test_ret++;
9341: printf(" %d", n_buf);
9342: printf(" %d", n_table);
9343: printf("\n");
9344: }
9345: }
9346: }
9347: function_tests++;
9348: #endif
9349:
9350: return(test_ret);
9351: }
9352:
9353:
9354: #define gen_nb_xmlEntityPtr 1
9355: static xmlEntityPtr gen_xmlEntityPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
9356: return(NULL);
9357: }
9358: static void des_xmlEntityPtr(int no ATTRIBUTE_UNUSED, xmlEntityPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
9359: }
9360:
9361: static int
9362: test_xmlDumpEntityDecl(void) {
9363: int test_ret = 0;
9364:
9365: #if defined(LIBXML_OUTPUT_ENABLED)
9366: int mem_base;
9367: xmlBufferPtr buf; /* An XML buffer. */
9368: int n_buf;
9369: xmlEntityPtr ent; /* An entity table */
9370: int n_ent;
9371:
9372: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
9373: for (n_ent = 0;n_ent < gen_nb_xmlEntityPtr;n_ent++) {
9374: mem_base = xmlMemBlocks();
9375: buf = gen_xmlBufferPtr(n_buf, 0);
9376: ent = gen_xmlEntityPtr(n_ent, 1);
9377:
9378: xmlDumpEntityDecl(buf, ent);
9379: call_tests++;
9380: des_xmlBufferPtr(n_buf, buf, 0);
9381: des_xmlEntityPtr(n_ent, ent, 1);
9382: xmlResetLastError();
9383: if (mem_base != xmlMemBlocks()) {
9384: printf("Leak of %d blocks found in xmlDumpEntityDecl",
9385: xmlMemBlocks() - mem_base);
9386: test_ret++;
9387: printf(" %d", n_buf);
9388: printf(" %d", n_ent);
9389: printf("\n");
9390: }
9391: }
9392: }
9393: function_tests++;
9394: #endif
9395:
9396: return(test_ret);
9397: }
9398:
9399:
9400: static int
9401: test_xmlEncodeEntitiesReentrant(void) {
9402: int test_ret = 0;
9403:
9404: int mem_base;
9405: xmlChar * ret_val;
9406: xmlDocPtr doc; /* the document containing the string */
9407: int n_doc;
9408: xmlChar * input; /* A string to convert to XML. */
9409: int n_input;
9410:
9411: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
9412: for (n_input = 0;n_input < gen_nb_const_xmlChar_ptr;n_input++) {
9413: mem_base = xmlMemBlocks();
9414: doc = gen_xmlDocPtr(n_doc, 0);
9415: input = gen_const_xmlChar_ptr(n_input, 1);
9416:
9417: ret_val = xmlEncodeEntitiesReentrant(doc, (const xmlChar *)input);
9418: desret_xmlChar_ptr(ret_val);
9419: call_tests++;
9420: des_xmlDocPtr(n_doc, doc, 0);
9421: des_const_xmlChar_ptr(n_input, (const xmlChar *)input, 1);
9422: xmlResetLastError();
9423: if (mem_base != xmlMemBlocks()) {
9424: printf("Leak of %d blocks found in xmlEncodeEntitiesReentrant",
9425: xmlMemBlocks() - mem_base);
9426: test_ret++;
9427: printf(" %d", n_doc);
9428: printf(" %d", n_input);
9429: printf("\n");
9430: }
9431: }
9432: }
9433: function_tests++;
9434:
9435: return(test_ret);
9436: }
9437:
9438:
9439: static int
9440: test_xmlEncodeSpecialChars(void) {
9441: int test_ret = 0;
9442:
9443: int mem_base;
9444: xmlChar * ret_val;
9445: xmlDocPtr doc; /* the document containing the string */
9446: int n_doc;
9447: xmlChar * input; /* A string to convert to XML. */
9448: int n_input;
9449:
9450: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
9451: for (n_input = 0;n_input < gen_nb_const_xmlChar_ptr;n_input++) {
9452: mem_base = xmlMemBlocks();
9453: doc = gen_xmlDocPtr(n_doc, 0);
9454: input = gen_const_xmlChar_ptr(n_input, 1);
9455:
9456: ret_val = xmlEncodeSpecialChars(doc, (const xmlChar *)input);
9457: desret_xmlChar_ptr(ret_val);
9458: call_tests++;
9459: des_xmlDocPtr(n_doc, doc, 0);
9460: des_const_xmlChar_ptr(n_input, (const xmlChar *)input, 1);
9461: xmlResetLastError();
9462: if (mem_base != xmlMemBlocks()) {
9463: printf("Leak of %d blocks found in xmlEncodeSpecialChars",
9464: xmlMemBlocks() - mem_base);
9465: test_ret++;
9466: printf(" %d", n_doc);
9467: printf(" %d", n_input);
9468: printf("\n");
9469: }
9470: }
9471: }
9472: function_tests++;
9473:
9474: return(test_ret);
9475: }
9476:
9477:
9478: static int
9479: test_xmlGetDocEntity(void) {
9480: int test_ret = 0;
9481:
9482: int mem_base;
9483: xmlEntityPtr ret_val;
9484: xmlDocPtr doc; /* the document referencing the entity */
9485: int n_doc;
9486: xmlChar * name; /* the entity name */
9487: int n_name;
9488:
9489: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
9490: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9491: mem_base = xmlMemBlocks();
9492: doc = gen_xmlDocPtr(n_doc, 0);
9493: name = gen_const_xmlChar_ptr(n_name, 1);
9494:
9495: ret_val = xmlGetDocEntity(doc, (const xmlChar *)name);
9496: desret_xmlEntityPtr(ret_val);
9497: call_tests++;
9498: des_xmlDocPtr(n_doc, doc, 0);
9499: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9500: xmlResetLastError();
9501: if (mem_base != xmlMemBlocks()) {
9502: printf("Leak of %d blocks found in xmlGetDocEntity",
9503: xmlMemBlocks() - mem_base);
9504: test_ret++;
9505: printf(" %d", n_doc);
9506: printf(" %d", n_name);
9507: printf("\n");
9508: }
9509: }
9510: }
9511: function_tests++;
9512:
9513: return(test_ret);
9514: }
9515:
9516:
9517: static int
9518: test_xmlGetDtdEntity(void) {
9519: int test_ret = 0;
9520:
9521: int mem_base;
9522: xmlEntityPtr ret_val;
9523: xmlDocPtr doc; /* the document referencing the entity */
9524: int n_doc;
9525: xmlChar * name; /* the entity name */
9526: int n_name;
9527:
9528: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
9529: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9530: mem_base = xmlMemBlocks();
9531: doc = gen_xmlDocPtr(n_doc, 0);
9532: name = gen_const_xmlChar_ptr(n_name, 1);
9533:
9534: ret_val = xmlGetDtdEntity(doc, (const xmlChar *)name);
9535: desret_xmlEntityPtr(ret_val);
9536: call_tests++;
9537: des_xmlDocPtr(n_doc, doc, 0);
9538: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9539: xmlResetLastError();
9540: if (mem_base != xmlMemBlocks()) {
9541: printf("Leak of %d blocks found in xmlGetDtdEntity",
9542: xmlMemBlocks() - mem_base);
9543: test_ret++;
9544: printf(" %d", n_doc);
9545: printf(" %d", n_name);
9546: printf("\n");
9547: }
9548: }
9549: }
9550: function_tests++;
9551:
9552: return(test_ret);
9553: }
9554:
9555:
9556: static int
9557: test_xmlGetParameterEntity(void) {
9558: int test_ret = 0;
9559:
9560: int mem_base;
9561: xmlEntityPtr ret_val;
9562: xmlDocPtr doc; /* the document referencing the entity */
9563: int n_doc;
9564: xmlChar * name; /* the entity name */
9565: int n_name;
9566:
9567: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
9568: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9569: mem_base = xmlMemBlocks();
9570: doc = gen_xmlDocPtr(n_doc, 0);
9571: name = gen_const_xmlChar_ptr(n_name, 1);
9572:
9573: ret_val = xmlGetParameterEntity(doc, (const xmlChar *)name);
9574: desret_xmlEntityPtr(ret_val);
9575: call_tests++;
9576: des_xmlDocPtr(n_doc, doc, 0);
9577: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9578: xmlResetLastError();
9579: if (mem_base != xmlMemBlocks()) {
9580: printf("Leak of %d blocks found in xmlGetParameterEntity",
9581: xmlMemBlocks() - mem_base);
9582: test_ret++;
9583: printf(" %d", n_doc);
9584: printf(" %d", n_name);
9585: printf("\n");
9586: }
9587: }
9588: }
9589: function_tests++;
9590:
9591: return(test_ret);
9592: }
9593:
9594:
9595: static int
9596: test_xmlGetPredefinedEntity(void) {
9597: int test_ret = 0;
9598:
9599: int mem_base;
9600: xmlEntityPtr ret_val;
9601: xmlChar * name; /* the entity name */
9602: int n_name;
9603:
9604: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9605: mem_base = xmlMemBlocks();
9606: name = gen_const_xmlChar_ptr(n_name, 0);
9607:
9608: ret_val = xmlGetPredefinedEntity((const xmlChar *)name);
9609: desret_xmlEntityPtr(ret_val);
9610: call_tests++;
9611: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
9612: xmlResetLastError();
9613: if (mem_base != xmlMemBlocks()) {
9614: printf("Leak of %d blocks found in xmlGetPredefinedEntity",
9615: xmlMemBlocks() - mem_base);
9616: test_ret++;
9617: printf(" %d", n_name);
9618: printf("\n");
9619: }
9620: }
9621: function_tests++;
9622:
9623: return(test_ret);
9624: }
9625:
9626:
9627: static int
9628: test_xmlInitializePredefinedEntities(void) {
9629: int test_ret = 0;
9630:
9631: #if defined(LIBXML_LEGACY_ENABLED)
9632: #ifdef LIBXML_LEGACY_ENABLED
9633: int mem_base;
9634:
9635: mem_base = xmlMemBlocks();
9636:
9637: xmlInitializePredefinedEntities();
9638: call_tests++;
9639: xmlResetLastError();
9640: if (mem_base != xmlMemBlocks()) {
9641: printf("Leak of %d blocks found in xmlInitializePredefinedEntities",
9642: xmlMemBlocks() - mem_base);
9643: test_ret++;
9644: printf("\n");
9645: }
9646: function_tests++;
9647: #endif
9648: #endif
9649:
9650: return(test_ret);
9651: }
9652:
9653:
9654: static int
9655: test_xmlNewEntity(void) {
9656: int test_ret = 0;
9657:
9658: int mem_base;
9659: xmlEntityPtr ret_val;
9660: xmlDocPtr doc; /* the document */
9661: int n_doc;
9662: xmlChar * name; /* the entity name */
9663: int n_name;
9664: int type; /* the entity type XML_xxx_yyy_ENTITY */
9665: int n_type;
9666: xmlChar * ExternalID; /* the entity external ID if available */
9667: int n_ExternalID;
9668: xmlChar * SystemID; /* the entity system ID if available */
9669: int n_SystemID;
9670: xmlChar * content; /* the entity content */
9671: int n_content;
9672:
9673: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
9674: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9675: for (n_type = 0;n_type < gen_nb_int;n_type++) {
9676: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
9677: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
9678: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
9679: mem_base = xmlMemBlocks();
9680: doc = gen_xmlDocPtr(n_doc, 0);
9681: name = gen_const_xmlChar_ptr(n_name, 1);
9682: type = gen_int(n_type, 2);
9683: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 3);
9684: SystemID = gen_const_xmlChar_ptr(n_SystemID, 4);
9685: content = gen_const_xmlChar_ptr(n_content, 5);
9686:
9687: ret_val = xmlNewEntity(doc, (const xmlChar *)name, type, (const xmlChar *)ExternalID, (const xmlChar *)SystemID, (const xmlChar *)content);
9688: desret_xmlEntityPtr(ret_val);
9689: call_tests++;
9690: des_xmlDocPtr(n_doc, doc, 0);
9691: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9692: des_int(n_type, type, 2);
9693: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 3);
9694: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 4);
9695: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 5);
9696: xmlResetLastError();
9697: if (mem_base != xmlMemBlocks()) {
9698: printf("Leak of %d blocks found in xmlNewEntity",
9699: xmlMemBlocks() - mem_base);
9700: test_ret++;
9701: printf(" %d", n_doc);
9702: printf(" %d", n_name);
9703: printf(" %d", n_type);
9704: printf(" %d", n_ExternalID);
9705: printf(" %d", n_SystemID);
9706: printf(" %d", n_content);
9707: printf("\n");
9708: }
9709: }
9710: }
9711: }
9712: }
9713: }
9714: }
9715: function_tests++;
9716:
9717: return(test_ret);
9718: }
9719:
9720: static int
9721: test_entities(void) {
9722: int test_ret = 0;
9723:
9724: if (quiet == 0) printf("Testing entities : 13 of 17 functions ...\n");
9725: test_ret += test_xmlAddDocEntity();
9726: test_ret += test_xmlAddDtdEntity();
9727: test_ret += test_xmlCleanupPredefinedEntities();
9728: test_ret += test_xmlCopyEntitiesTable();
9729: test_ret += test_xmlCreateEntitiesTable();
9730: test_ret += test_xmlDumpEntitiesTable();
9731: test_ret += test_xmlDumpEntityDecl();
9732: test_ret += test_xmlEncodeEntitiesReentrant();
9733: test_ret += test_xmlEncodeSpecialChars();
9734: test_ret += test_xmlGetDocEntity();
9735: test_ret += test_xmlGetDtdEntity();
9736: test_ret += test_xmlGetParameterEntity();
9737: test_ret += test_xmlGetPredefinedEntity();
9738: test_ret += test_xmlInitializePredefinedEntities();
9739: test_ret += test_xmlNewEntity();
9740:
9741: if (test_ret != 0)
9742: printf("Module entities: %d errors\n", test_ret);
9743: return(test_ret);
9744: }
9745:
9746: static int
9747: test_xmlHashAddEntry(void) {
9748: int test_ret = 0;
9749:
9750: int mem_base;
9751: int ret_val;
9752: xmlHashTablePtr table; /* the hash table */
9753: int n_table;
9754: xmlChar * name; /* the name of the userdata */
9755: int n_name;
9756: void * userdata; /* a pointer to the userdata */
9757: int n_userdata;
9758:
9759: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
9760: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9761: for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) {
9762: mem_base = xmlMemBlocks();
9763: table = gen_xmlHashTablePtr(n_table, 0);
9764: name = gen_const_xmlChar_ptr(n_name, 1);
9765: userdata = gen_userdata(n_userdata, 2);
9766:
9767: ret_val = xmlHashAddEntry(table, (const xmlChar *)name, userdata);
9768: desret_int(ret_val);
9769: call_tests++;
9770: des_xmlHashTablePtr(n_table, table, 0);
9771: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9772: des_userdata(n_userdata, userdata, 2);
9773: xmlResetLastError();
9774: if (mem_base != xmlMemBlocks()) {
9775: printf("Leak of %d blocks found in xmlHashAddEntry",
9776: xmlMemBlocks() - mem_base);
9777: test_ret++;
9778: printf(" %d", n_table);
9779: printf(" %d", n_name);
9780: printf(" %d", n_userdata);
9781: printf("\n");
9782: }
9783: }
9784: }
9785: }
9786: function_tests++;
9787:
9788: return(test_ret);
9789: }
9790:
9791:
9792: static int
9793: test_xmlHashAddEntry2(void) {
9794: int test_ret = 0;
9795:
9796: int mem_base;
9797: int ret_val;
9798: xmlHashTablePtr table; /* the hash table */
9799: int n_table;
9800: xmlChar * name; /* the name of the userdata */
9801: int n_name;
9802: xmlChar * name2; /* a second name of the userdata */
9803: int n_name2;
9804: void * userdata; /* a pointer to the userdata */
9805: int n_userdata;
9806:
9807: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
9808: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9809: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
9810: for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) {
9811: mem_base = xmlMemBlocks();
9812: table = gen_xmlHashTablePtr(n_table, 0);
9813: name = gen_const_xmlChar_ptr(n_name, 1);
9814: name2 = gen_const_xmlChar_ptr(n_name2, 2);
9815: userdata = gen_userdata(n_userdata, 3);
9816:
9817: ret_val = xmlHashAddEntry2(table, (const xmlChar *)name, (const xmlChar *)name2, userdata);
9818: desret_int(ret_val);
9819: call_tests++;
9820: des_xmlHashTablePtr(n_table, table, 0);
9821: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9822: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
9823: des_userdata(n_userdata, userdata, 3);
9824: xmlResetLastError();
9825: if (mem_base != xmlMemBlocks()) {
9826: printf("Leak of %d blocks found in xmlHashAddEntry2",
9827: xmlMemBlocks() - mem_base);
9828: test_ret++;
9829: printf(" %d", n_table);
9830: printf(" %d", n_name);
9831: printf(" %d", n_name2);
9832: printf(" %d", n_userdata);
9833: printf("\n");
9834: }
9835: }
9836: }
9837: }
9838: }
9839: function_tests++;
9840:
9841: return(test_ret);
9842: }
9843:
9844:
9845: static int
9846: test_xmlHashAddEntry3(void) {
9847: int test_ret = 0;
9848:
9849: int mem_base;
9850: int ret_val;
9851: xmlHashTablePtr table; /* the hash table */
9852: int n_table;
9853: xmlChar * name; /* the name of the userdata */
9854: int n_name;
9855: xmlChar * name2; /* a second name of the userdata */
9856: int n_name2;
9857: xmlChar * name3; /* a third name of the userdata */
9858: int n_name3;
9859: void * userdata; /* a pointer to the userdata */
9860: int n_userdata;
9861:
9862: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
9863: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9864: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
9865: for (n_name3 = 0;n_name3 < gen_nb_const_xmlChar_ptr;n_name3++) {
9866: for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) {
9867: mem_base = xmlMemBlocks();
9868: table = gen_xmlHashTablePtr(n_table, 0);
9869: name = gen_const_xmlChar_ptr(n_name, 1);
9870: name2 = gen_const_xmlChar_ptr(n_name2, 2);
9871: name3 = gen_const_xmlChar_ptr(n_name3, 3);
9872: userdata = gen_userdata(n_userdata, 4);
9873:
9874: ret_val = xmlHashAddEntry3(table, (const xmlChar *)name, (const xmlChar *)name2, (const xmlChar *)name3, userdata);
9875: desret_int(ret_val);
9876: call_tests++;
9877: des_xmlHashTablePtr(n_table, table, 0);
9878: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9879: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
9880: des_const_xmlChar_ptr(n_name3, (const xmlChar *)name3, 3);
9881: des_userdata(n_userdata, userdata, 4);
9882: xmlResetLastError();
9883: if (mem_base != xmlMemBlocks()) {
9884: printf("Leak of %d blocks found in xmlHashAddEntry3",
9885: xmlMemBlocks() - mem_base);
9886: test_ret++;
9887: printf(" %d", n_table);
9888: printf(" %d", n_name);
9889: printf(" %d", n_name2);
9890: printf(" %d", n_name3);
9891: printf(" %d", n_userdata);
9892: printf("\n");
9893: }
9894: }
9895: }
9896: }
9897: }
9898: }
9899: function_tests++;
9900:
9901: return(test_ret);
9902: }
9903:
9904:
9905: static int
9906: test_xmlHashCopy(void) {
9907: int test_ret = 0;
9908:
9909:
9910: /* missing type support */
9911: return(test_ret);
9912: }
9913:
9914:
9915: static int
9916: test_xmlHashCreate(void) {
9917: int test_ret = 0;
9918:
9919:
9920: /* missing type support */
9921: return(test_ret);
9922: }
9923:
9924:
9925: static int
9926: test_xmlHashCreateDict(void) {
9927: int test_ret = 0;
9928:
9929:
9930: /* missing type support */
9931: return(test_ret);
9932: }
9933:
9934:
9935: static int
9936: test_xmlHashLookup(void) {
9937: int test_ret = 0;
9938:
9939: int mem_base;
9940: void * ret_val;
9941: xmlHashTablePtr table; /* the hash table */
9942: int n_table;
9943: xmlChar * name; /* the name of the userdata */
9944: int n_name;
9945:
9946: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
9947: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9948: mem_base = xmlMemBlocks();
9949: table = gen_xmlHashTablePtr(n_table, 0);
9950: name = gen_const_xmlChar_ptr(n_name, 1);
9951:
9952: ret_val = xmlHashLookup(table, (const xmlChar *)name);
9953: desret_void_ptr(ret_val);
9954: call_tests++;
9955: des_xmlHashTablePtr(n_table, table, 0);
9956: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9957: xmlResetLastError();
9958: if (mem_base != xmlMemBlocks()) {
9959: printf("Leak of %d blocks found in xmlHashLookup",
9960: xmlMemBlocks() - mem_base);
9961: test_ret++;
9962: printf(" %d", n_table);
9963: printf(" %d", n_name);
9964: printf("\n");
9965: }
9966: }
9967: }
9968: function_tests++;
9969:
9970: return(test_ret);
9971: }
9972:
9973:
9974: static int
9975: test_xmlHashLookup2(void) {
9976: int test_ret = 0;
9977:
9978: int mem_base;
9979: void * ret_val;
9980: xmlHashTablePtr table; /* the hash table */
9981: int n_table;
9982: xmlChar * name; /* the name of the userdata */
9983: int n_name;
9984: xmlChar * name2; /* a second name of the userdata */
9985: int n_name2;
9986:
9987: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
9988: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9989: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
9990: mem_base = xmlMemBlocks();
9991: table = gen_xmlHashTablePtr(n_table, 0);
9992: name = gen_const_xmlChar_ptr(n_name, 1);
9993: name2 = gen_const_xmlChar_ptr(n_name2, 2);
9994:
9995: ret_val = xmlHashLookup2(table, (const xmlChar *)name, (const xmlChar *)name2);
9996: desret_void_ptr(ret_val);
9997: call_tests++;
9998: des_xmlHashTablePtr(n_table, table, 0);
9999: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
10000: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
10001: xmlResetLastError();
10002: if (mem_base != xmlMemBlocks()) {
10003: printf("Leak of %d blocks found in xmlHashLookup2",
10004: xmlMemBlocks() - mem_base);
10005: test_ret++;
10006: printf(" %d", n_table);
10007: printf(" %d", n_name);
10008: printf(" %d", n_name2);
10009: printf("\n");
10010: }
10011: }
10012: }
10013: }
10014: function_tests++;
10015:
10016: return(test_ret);
10017: }
10018:
10019:
10020: static int
10021: test_xmlHashLookup3(void) {
10022: int test_ret = 0;
10023:
10024: int mem_base;
10025: void * ret_val;
10026: xmlHashTablePtr table; /* the hash table */
10027: int n_table;
10028: xmlChar * name; /* the name of the userdata */
10029: int n_name;
10030: xmlChar * name2; /* a second name of the userdata */
10031: int n_name2;
10032: xmlChar * name3; /* a third name of the userdata */
10033: int n_name3;
10034:
10035: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10036: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10037: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
10038: for (n_name3 = 0;n_name3 < gen_nb_const_xmlChar_ptr;n_name3++) {
10039: mem_base = xmlMemBlocks();
10040: table = gen_xmlHashTablePtr(n_table, 0);
10041: name = gen_const_xmlChar_ptr(n_name, 1);
10042: name2 = gen_const_xmlChar_ptr(n_name2, 2);
10043: name3 = gen_const_xmlChar_ptr(n_name3, 3);
10044:
10045: ret_val = xmlHashLookup3(table, (const xmlChar *)name, (const xmlChar *)name2, (const xmlChar *)name3);
10046: desret_void_ptr(ret_val);
10047: call_tests++;
10048: des_xmlHashTablePtr(n_table, table, 0);
10049: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
10050: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
10051: des_const_xmlChar_ptr(n_name3, (const xmlChar *)name3, 3);
10052: xmlResetLastError();
10053: if (mem_base != xmlMemBlocks()) {
10054: printf("Leak of %d blocks found in xmlHashLookup3",
10055: xmlMemBlocks() - mem_base);
10056: test_ret++;
10057: printf(" %d", n_table);
10058: printf(" %d", n_name);
10059: printf(" %d", n_name2);
10060: printf(" %d", n_name3);
10061: printf("\n");
10062: }
10063: }
10064: }
10065: }
10066: }
10067: function_tests++;
10068:
10069: return(test_ret);
10070: }
10071:
10072:
10073: static int
10074: test_xmlHashQLookup(void) {
10075: int test_ret = 0;
10076:
10077: int mem_base;
10078: void * ret_val;
10079: xmlHashTablePtr table; /* the hash table */
10080: int n_table;
10081: xmlChar * prefix; /* the prefix of the userdata */
10082: int n_prefix;
10083: xmlChar * name; /* the name of the userdata */
10084: int n_name;
10085:
10086: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10087: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
10088: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10089: mem_base = xmlMemBlocks();
10090: table = gen_xmlHashTablePtr(n_table, 0);
10091: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
10092: name = gen_const_xmlChar_ptr(n_name, 2);
10093:
10094: ret_val = xmlHashQLookup(table, (const xmlChar *)prefix, (const xmlChar *)name);
10095: desret_void_ptr(ret_val);
10096: call_tests++;
10097: des_xmlHashTablePtr(n_table, table, 0);
10098: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
10099: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
10100: xmlResetLastError();
10101: if (mem_base != xmlMemBlocks()) {
10102: printf("Leak of %d blocks found in xmlHashQLookup",
10103: xmlMemBlocks() - mem_base);
10104: test_ret++;
10105: printf(" %d", n_table);
10106: printf(" %d", n_prefix);
10107: printf(" %d", n_name);
10108: printf("\n");
10109: }
10110: }
10111: }
10112: }
10113: function_tests++;
10114:
10115: return(test_ret);
10116: }
10117:
10118:
10119: static int
10120: test_xmlHashQLookup2(void) {
10121: int test_ret = 0;
10122:
10123: int mem_base;
10124: void * ret_val;
10125: xmlHashTablePtr table; /* the hash table */
10126: int n_table;
10127: xmlChar * prefix; /* the prefix of the userdata */
10128: int n_prefix;
10129: xmlChar * name; /* the name of the userdata */
10130: int n_name;
10131: xmlChar * prefix2; /* the second prefix of the userdata */
10132: int n_prefix2;
10133: xmlChar * name2; /* a second name of the userdata */
10134: int n_name2;
10135:
10136: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10137: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
10138: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10139: for (n_prefix2 = 0;n_prefix2 < gen_nb_const_xmlChar_ptr;n_prefix2++) {
10140: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
10141: mem_base = xmlMemBlocks();
10142: table = gen_xmlHashTablePtr(n_table, 0);
10143: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
10144: name = gen_const_xmlChar_ptr(n_name, 2);
10145: prefix2 = gen_const_xmlChar_ptr(n_prefix2, 3);
10146: name2 = gen_const_xmlChar_ptr(n_name2, 4);
10147:
10148: ret_val = xmlHashQLookup2(table, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)prefix2, (const xmlChar *)name2);
10149: desret_void_ptr(ret_val);
10150: call_tests++;
10151: des_xmlHashTablePtr(n_table, table, 0);
10152: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
10153: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
10154: des_const_xmlChar_ptr(n_prefix2, (const xmlChar *)prefix2, 3);
10155: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 4);
10156: xmlResetLastError();
10157: if (mem_base != xmlMemBlocks()) {
10158: printf("Leak of %d blocks found in xmlHashQLookup2",
10159: xmlMemBlocks() - mem_base);
10160: test_ret++;
10161: printf(" %d", n_table);
10162: printf(" %d", n_prefix);
10163: printf(" %d", n_name);
10164: printf(" %d", n_prefix2);
10165: printf(" %d", n_name2);
10166: printf("\n");
10167: }
10168: }
10169: }
10170: }
10171: }
10172: }
10173: function_tests++;
10174:
10175: return(test_ret);
10176: }
10177:
10178:
10179: static int
10180: test_xmlHashQLookup3(void) {
10181: int test_ret = 0;
10182:
10183: int mem_base;
10184: void * ret_val;
10185: xmlHashTablePtr table; /* the hash table */
10186: int n_table;
10187: xmlChar * prefix; /* the prefix of the userdata */
10188: int n_prefix;
10189: xmlChar * name; /* the name of the userdata */
10190: int n_name;
10191: xmlChar * prefix2; /* the second prefix of the userdata */
10192: int n_prefix2;
10193: xmlChar * name2; /* a second name of the userdata */
10194: int n_name2;
10195: xmlChar * prefix3; /* the third prefix of the userdata */
10196: int n_prefix3;
10197: xmlChar * name3; /* a third name of the userdata */
10198: int n_name3;
10199:
10200: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10201: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
10202: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10203: for (n_prefix2 = 0;n_prefix2 < gen_nb_const_xmlChar_ptr;n_prefix2++) {
10204: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
10205: for (n_prefix3 = 0;n_prefix3 < gen_nb_const_xmlChar_ptr;n_prefix3++) {
10206: for (n_name3 = 0;n_name3 < gen_nb_const_xmlChar_ptr;n_name3++) {
10207: mem_base = xmlMemBlocks();
10208: table = gen_xmlHashTablePtr(n_table, 0);
10209: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
10210: name = gen_const_xmlChar_ptr(n_name, 2);
10211: prefix2 = gen_const_xmlChar_ptr(n_prefix2, 3);
10212: name2 = gen_const_xmlChar_ptr(n_name2, 4);
10213: prefix3 = gen_const_xmlChar_ptr(n_prefix3, 5);
10214: name3 = gen_const_xmlChar_ptr(n_name3, 6);
10215:
10216: ret_val = xmlHashQLookup3(table, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)prefix2, (const xmlChar *)name2, (const xmlChar *)prefix3, (const xmlChar *)name3);
10217: desret_void_ptr(ret_val);
10218: call_tests++;
10219: des_xmlHashTablePtr(n_table, table, 0);
10220: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
10221: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
10222: des_const_xmlChar_ptr(n_prefix2, (const xmlChar *)prefix2, 3);
10223: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 4);
10224: des_const_xmlChar_ptr(n_prefix3, (const xmlChar *)prefix3, 5);
10225: des_const_xmlChar_ptr(n_name3, (const xmlChar *)name3, 6);
10226: xmlResetLastError();
10227: if (mem_base != xmlMemBlocks()) {
10228: printf("Leak of %d blocks found in xmlHashQLookup3",
10229: xmlMemBlocks() - mem_base);
10230: test_ret++;
10231: printf(" %d", n_table);
10232: printf(" %d", n_prefix);
10233: printf(" %d", n_name);
10234: printf(" %d", n_prefix2);
10235: printf(" %d", n_name2);
10236: printf(" %d", n_prefix3);
10237: printf(" %d", n_name3);
10238: printf("\n");
10239: }
10240: }
10241: }
10242: }
10243: }
10244: }
10245: }
10246: }
10247: function_tests++;
10248:
10249: return(test_ret);
10250: }
10251:
10252:
10253: static int
10254: test_xmlHashRemoveEntry(void) {
10255: int test_ret = 0;
10256:
10257: int mem_base;
10258: int ret_val;
10259: xmlHashTablePtr table; /* the hash table */
10260: int n_table;
10261: xmlChar * name; /* the name of the userdata */
10262: int n_name;
10263: xmlHashDeallocator f; /* the deallocator function for removed item (if any) */
10264: int n_f;
10265:
10266: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10267: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10268: for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) {
10269: mem_base = xmlMemBlocks();
10270: table = gen_xmlHashTablePtr(n_table, 0);
10271: name = gen_const_xmlChar_ptr(n_name, 1);
10272: f = gen_xmlHashDeallocator(n_f, 2);
10273:
10274: ret_val = xmlHashRemoveEntry(table, (const xmlChar *)name, f);
10275: desret_int(ret_val);
10276: call_tests++;
10277: des_xmlHashTablePtr(n_table, table, 0);
10278: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
10279: des_xmlHashDeallocator(n_f, f, 2);
10280: xmlResetLastError();
10281: if (mem_base != xmlMemBlocks()) {
10282: printf("Leak of %d blocks found in xmlHashRemoveEntry",
10283: xmlMemBlocks() - mem_base);
10284: test_ret++;
10285: printf(" %d", n_table);
10286: printf(" %d", n_name);
10287: printf(" %d", n_f);
10288: printf("\n");
10289: }
10290: }
10291: }
10292: }
10293: function_tests++;
10294:
10295: return(test_ret);
10296: }
10297:
10298:
10299: static int
10300: test_xmlHashRemoveEntry2(void) {
10301: int test_ret = 0;
10302:
10303: int mem_base;
10304: int ret_val;
10305: xmlHashTablePtr table; /* the hash table */
10306: int n_table;
10307: xmlChar * name; /* the name of the userdata */
10308: int n_name;
10309: xmlChar * name2; /* a second name of the userdata */
10310: int n_name2;
10311: xmlHashDeallocator f; /* the deallocator function for removed item (if any) */
10312: int n_f;
10313:
10314: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10315: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10316: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
10317: for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) {
10318: mem_base = xmlMemBlocks();
10319: table = gen_xmlHashTablePtr(n_table, 0);
10320: name = gen_const_xmlChar_ptr(n_name, 1);
10321: name2 = gen_const_xmlChar_ptr(n_name2, 2);
10322: f = gen_xmlHashDeallocator(n_f, 3);
10323:
10324: ret_val = xmlHashRemoveEntry2(table, (const xmlChar *)name, (const xmlChar *)name2, f);
10325: desret_int(ret_val);
10326: call_tests++;
10327: des_xmlHashTablePtr(n_table, table, 0);
10328: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
10329: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
10330: des_xmlHashDeallocator(n_f, f, 3);
10331: xmlResetLastError();
10332: if (mem_base != xmlMemBlocks()) {
10333: printf("Leak of %d blocks found in xmlHashRemoveEntry2",
10334: xmlMemBlocks() - mem_base);
10335: test_ret++;
10336: printf(" %d", n_table);
10337: printf(" %d", n_name);
10338: printf(" %d", n_name2);
10339: printf(" %d", n_f);
10340: printf("\n");
10341: }
10342: }
10343: }
10344: }
10345: }
10346: function_tests++;
10347:
10348: return(test_ret);
10349: }
10350:
10351:
10352: static int
10353: test_xmlHashRemoveEntry3(void) {
10354: int test_ret = 0;
10355:
10356: int mem_base;
10357: int ret_val;
10358: xmlHashTablePtr table; /* the hash table */
10359: int n_table;
10360: xmlChar * name; /* the name of the userdata */
10361: int n_name;
10362: xmlChar * name2; /* a second name of the userdata */
10363: int n_name2;
10364: xmlChar * name3; /* a third name of the userdata */
10365: int n_name3;
10366: xmlHashDeallocator f; /* the deallocator function for removed item (if any) */
10367: int n_f;
10368:
10369: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10370: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10371: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
10372: for (n_name3 = 0;n_name3 < gen_nb_const_xmlChar_ptr;n_name3++) {
10373: for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) {
10374: mem_base = xmlMemBlocks();
10375: table = gen_xmlHashTablePtr(n_table, 0);
10376: name = gen_const_xmlChar_ptr(n_name, 1);
10377: name2 = gen_const_xmlChar_ptr(n_name2, 2);
10378: name3 = gen_const_xmlChar_ptr(n_name3, 3);
10379: f = gen_xmlHashDeallocator(n_f, 4);
10380:
10381: ret_val = xmlHashRemoveEntry3(table, (const xmlChar *)name, (const xmlChar *)name2, (const xmlChar *)name3, f);
10382: desret_int(ret_val);
10383: call_tests++;
10384: des_xmlHashTablePtr(n_table, table, 0);
10385: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
10386: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
10387: des_const_xmlChar_ptr(n_name3, (const xmlChar *)name3, 3);
10388: des_xmlHashDeallocator(n_f, f, 4);
10389: xmlResetLastError();
10390: if (mem_base != xmlMemBlocks()) {
10391: printf("Leak of %d blocks found in xmlHashRemoveEntry3",
10392: xmlMemBlocks() - mem_base);
10393: test_ret++;
10394: printf(" %d", n_table);
10395: printf(" %d", n_name);
10396: printf(" %d", n_name2);
10397: printf(" %d", n_name3);
10398: printf(" %d", n_f);
10399: printf("\n");
10400: }
10401: }
10402: }
10403: }
10404: }
10405: }
10406: function_tests++;
10407:
10408: return(test_ret);
10409: }
10410:
10411:
10412: static int
10413: test_xmlHashScan(void) {
10414: int test_ret = 0;
10415:
10416:
10417: /* missing type support */
10418: return(test_ret);
10419: }
10420:
10421:
10422: static int
10423: test_xmlHashScan3(void) {
10424: int test_ret = 0;
10425:
10426:
10427: /* missing type support */
10428: return(test_ret);
10429: }
10430:
10431:
10432: static int
10433: test_xmlHashScanFull(void) {
10434: int test_ret = 0;
10435:
10436:
10437: /* missing type support */
10438: return(test_ret);
10439: }
10440:
10441:
10442: static int
10443: test_xmlHashScanFull3(void) {
10444: int test_ret = 0;
10445:
10446:
10447: /* missing type support */
10448: return(test_ret);
10449: }
10450:
10451:
10452: static int
10453: test_xmlHashSize(void) {
10454: int test_ret = 0;
10455:
10456: int mem_base;
10457: int ret_val;
10458: xmlHashTablePtr table; /* the hash table */
10459: int n_table;
10460:
10461: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10462: mem_base = xmlMemBlocks();
10463: table = gen_xmlHashTablePtr(n_table, 0);
10464:
10465: ret_val = xmlHashSize(table);
10466: desret_int(ret_val);
10467: call_tests++;
10468: des_xmlHashTablePtr(n_table, table, 0);
10469: xmlResetLastError();
10470: if (mem_base != xmlMemBlocks()) {
10471: printf("Leak of %d blocks found in xmlHashSize",
10472: xmlMemBlocks() - mem_base);
10473: test_ret++;
10474: printf(" %d", n_table);
10475: printf("\n");
10476: }
10477: }
10478: function_tests++;
10479:
10480: return(test_ret);
10481: }
10482:
10483:
10484: static int
10485: test_xmlHashUpdateEntry(void) {
10486: int test_ret = 0;
10487:
10488: int mem_base;
10489: int ret_val;
10490: xmlHashTablePtr table; /* the hash table */
10491: int n_table;
10492: xmlChar * name; /* the name of the userdata */
10493: int n_name;
10494: void * userdata; /* a pointer to the userdata */
10495: int n_userdata;
10496: xmlHashDeallocator f; /* the deallocator function for replaced item (if any) */
10497: int n_f;
10498:
10499: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10500: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10501: for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) {
10502: for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) {
10503: mem_base = xmlMemBlocks();
10504: table = gen_xmlHashTablePtr(n_table, 0);
10505: name = gen_const_xmlChar_ptr(n_name, 1);
10506: userdata = gen_userdata(n_userdata, 2);
10507: f = gen_xmlHashDeallocator(n_f, 3);
10508:
10509: ret_val = xmlHashUpdateEntry(table, (const xmlChar *)name, userdata, f);
10510: desret_int(ret_val);
10511: call_tests++;
10512: des_xmlHashTablePtr(n_table, table, 0);
10513: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
10514: des_userdata(n_userdata, userdata, 2);
10515: des_xmlHashDeallocator(n_f, f, 3);
10516: xmlResetLastError();
10517: if (mem_base != xmlMemBlocks()) {
10518: printf("Leak of %d blocks found in xmlHashUpdateEntry",
10519: xmlMemBlocks() - mem_base);
10520: test_ret++;
10521: printf(" %d", n_table);
10522: printf(" %d", n_name);
10523: printf(" %d", n_userdata);
10524: printf(" %d", n_f);
10525: printf("\n");
10526: }
10527: }
10528: }
10529: }
10530: }
10531: function_tests++;
10532:
10533: return(test_ret);
10534: }
10535:
10536:
10537: static int
10538: test_xmlHashUpdateEntry2(void) {
10539: int test_ret = 0;
10540:
10541: int mem_base;
10542: int ret_val;
10543: xmlHashTablePtr table; /* the hash table */
10544: int n_table;
10545: xmlChar * name; /* the name of the userdata */
10546: int n_name;
10547: xmlChar * name2; /* a second name of the userdata */
10548: int n_name2;
10549: void * userdata; /* a pointer to the userdata */
10550: int n_userdata;
10551: xmlHashDeallocator f; /* the deallocator function for replaced item (if any) */
10552: int n_f;
10553:
10554: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10555: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10556: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
10557: for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) {
10558: for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) {
10559: mem_base = xmlMemBlocks();
10560: table = gen_xmlHashTablePtr(n_table, 0);
10561: name = gen_const_xmlChar_ptr(n_name, 1);
10562: name2 = gen_const_xmlChar_ptr(n_name2, 2);
10563: userdata = gen_userdata(n_userdata, 3);
10564: f = gen_xmlHashDeallocator(n_f, 4);
10565:
10566: ret_val = xmlHashUpdateEntry2(table, (const xmlChar *)name, (const xmlChar *)name2, userdata, f);
10567: desret_int(ret_val);
10568: call_tests++;
10569: des_xmlHashTablePtr(n_table, table, 0);
10570: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
10571: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
10572: des_userdata(n_userdata, userdata, 3);
10573: des_xmlHashDeallocator(n_f, f, 4);
10574: xmlResetLastError();
10575: if (mem_base != xmlMemBlocks()) {
10576: printf("Leak of %d blocks found in xmlHashUpdateEntry2",
10577: xmlMemBlocks() - mem_base);
10578: test_ret++;
10579: printf(" %d", n_table);
10580: printf(" %d", n_name);
10581: printf(" %d", n_name2);
10582: printf(" %d", n_userdata);
10583: printf(" %d", n_f);
10584: printf("\n");
10585: }
10586: }
10587: }
10588: }
10589: }
10590: }
10591: function_tests++;
10592:
10593: return(test_ret);
10594: }
10595:
10596:
10597: static int
10598: test_xmlHashUpdateEntry3(void) {
10599: int test_ret = 0;
10600:
10601: int mem_base;
10602: int ret_val;
10603: xmlHashTablePtr table; /* the hash table */
10604: int n_table;
10605: xmlChar * name; /* the name of the userdata */
10606: int n_name;
10607: xmlChar * name2; /* a second name of the userdata */
10608: int n_name2;
10609: xmlChar * name3; /* a third name of the userdata */
10610: int n_name3;
10611: void * userdata; /* a pointer to the userdata */
10612: int n_userdata;
10613: xmlHashDeallocator f; /* the deallocator function for replaced item (if any) */
10614: int n_f;
10615:
10616: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10617: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10618: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
10619: for (n_name3 = 0;n_name3 < gen_nb_const_xmlChar_ptr;n_name3++) {
10620: for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) {
10621: for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) {
10622: mem_base = xmlMemBlocks();
10623: table = gen_xmlHashTablePtr(n_table, 0);
10624: name = gen_const_xmlChar_ptr(n_name, 1);
10625: name2 = gen_const_xmlChar_ptr(n_name2, 2);
10626: name3 = gen_const_xmlChar_ptr(n_name3, 3);
10627: userdata = gen_userdata(n_userdata, 4);
10628: f = gen_xmlHashDeallocator(n_f, 5);
10629:
10630: ret_val = xmlHashUpdateEntry3(table, (const xmlChar *)name, (const xmlChar *)name2, (const xmlChar *)name3, userdata, f);
10631: desret_int(ret_val);
10632: call_tests++;
10633: des_xmlHashTablePtr(n_table, table, 0);
10634: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
10635: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
10636: des_const_xmlChar_ptr(n_name3, (const xmlChar *)name3, 3);
10637: des_userdata(n_userdata, userdata, 4);
10638: des_xmlHashDeallocator(n_f, f, 5);
10639: xmlResetLastError();
10640: if (mem_base != xmlMemBlocks()) {
10641: printf("Leak of %d blocks found in xmlHashUpdateEntry3",
10642: xmlMemBlocks() - mem_base);
10643: test_ret++;
10644: printf(" %d", n_table);
10645: printf(" %d", n_name);
10646: printf(" %d", n_name2);
10647: printf(" %d", n_name3);
10648: printf(" %d", n_userdata);
10649: printf(" %d", n_f);
10650: printf("\n");
10651: }
10652: }
10653: }
10654: }
10655: }
10656: }
10657: }
10658: function_tests++;
10659:
10660: return(test_ret);
10661: }
10662:
10663: static int
10664: test_hash(void) {
10665: int test_ret = 0;
10666:
10667: if (quiet == 0) printf("Testing hash : 16 of 24 functions ...\n");
10668: test_ret += test_xmlHashAddEntry();
10669: test_ret += test_xmlHashAddEntry2();
10670: test_ret += test_xmlHashAddEntry3();
10671: test_ret += test_xmlHashCopy();
10672: test_ret += test_xmlHashCreate();
10673: test_ret += test_xmlHashCreateDict();
10674: test_ret += test_xmlHashLookup();
10675: test_ret += test_xmlHashLookup2();
10676: test_ret += test_xmlHashLookup3();
10677: test_ret += test_xmlHashQLookup();
10678: test_ret += test_xmlHashQLookup2();
10679: test_ret += test_xmlHashQLookup3();
10680: test_ret += test_xmlHashRemoveEntry();
10681: test_ret += test_xmlHashRemoveEntry2();
10682: test_ret += test_xmlHashRemoveEntry3();
10683: test_ret += test_xmlHashScan();
10684: test_ret += test_xmlHashScan3();
10685: test_ret += test_xmlHashScanFull();
10686: test_ret += test_xmlHashScanFull3();
10687: test_ret += test_xmlHashSize();
10688: test_ret += test_xmlHashUpdateEntry();
10689: test_ret += test_xmlHashUpdateEntry2();
10690: test_ret += test_xmlHashUpdateEntry3();
10691:
10692: if (test_ret != 0)
10693: printf("Module hash: %d errors\n", test_ret);
10694: return(test_ret);
10695: }
10696:
10697: #define gen_nb_xmlLinkPtr 1
10698: static xmlLinkPtr gen_xmlLinkPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
10699: return(NULL);
10700: }
10701: static void des_xmlLinkPtr(int no ATTRIBUTE_UNUSED, xmlLinkPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
10702: }
10703:
10704: static int
10705: test_xmlLinkGetData(void) {
10706: int test_ret = 0;
10707:
10708: int mem_base;
10709: void * ret_val;
10710: xmlLinkPtr lk; /* a link */
10711: int n_lk;
10712:
10713: for (n_lk = 0;n_lk < gen_nb_xmlLinkPtr;n_lk++) {
10714: mem_base = xmlMemBlocks();
10715: lk = gen_xmlLinkPtr(n_lk, 0);
10716:
10717: ret_val = xmlLinkGetData(lk);
10718: desret_void_ptr(ret_val);
10719: call_tests++;
10720: des_xmlLinkPtr(n_lk, lk, 0);
10721: xmlResetLastError();
10722: if (mem_base != xmlMemBlocks()) {
10723: printf("Leak of %d blocks found in xmlLinkGetData",
10724: xmlMemBlocks() - mem_base);
10725: test_ret++;
10726: printf(" %d", n_lk);
10727: printf("\n");
10728: }
10729: }
10730: function_tests++;
10731:
10732: return(test_ret);
10733: }
10734:
10735:
10736: static int
10737: test_xmlListAppend(void) {
10738: int test_ret = 0;
10739:
10740: int mem_base;
10741: int ret_val;
10742: xmlListPtr l; /* a list */
10743: int n_l;
10744: void * data; /* the data */
10745: int n_data;
10746:
10747: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
10748: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
10749: mem_base = xmlMemBlocks();
10750: l = gen_xmlListPtr(n_l, 0);
10751: data = gen_userdata(n_data, 1);
10752:
10753: ret_val = xmlListAppend(l, data);
10754: desret_int(ret_val);
10755: call_tests++;
10756: des_xmlListPtr(n_l, l, 0);
10757: des_userdata(n_data, data, 1);
10758: xmlResetLastError();
10759: if (mem_base != xmlMemBlocks()) {
10760: printf("Leak of %d blocks found in xmlListAppend",
10761: xmlMemBlocks() - mem_base);
10762: test_ret++;
10763: printf(" %d", n_l);
10764: printf(" %d", n_data);
10765: printf("\n");
10766: }
10767: }
10768: }
10769: function_tests++;
10770:
10771: return(test_ret);
10772: }
10773:
10774:
10775: static int
10776: test_xmlListClear(void) {
10777: int test_ret = 0;
10778:
10779: int mem_base;
10780: xmlListPtr l; /* a list */
10781: int n_l;
10782:
10783: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
10784: mem_base = xmlMemBlocks();
10785: l = gen_xmlListPtr(n_l, 0);
10786:
10787: xmlListClear(l);
10788: call_tests++;
10789: des_xmlListPtr(n_l, l, 0);
10790: xmlResetLastError();
10791: if (mem_base != xmlMemBlocks()) {
10792: printf("Leak of %d blocks found in xmlListClear",
10793: xmlMemBlocks() - mem_base);
10794: test_ret++;
10795: printf(" %d", n_l);
10796: printf("\n");
10797: }
10798: }
10799: function_tests++;
10800:
10801: return(test_ret);
10802: }
10803:
10804:
10805: #define gen_nb_const_xmlListPtr 1
10806: static xmlListPtr gen_const_xmlListPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
10807: return(NULL);
10808: }
10809: static void des_const_xmlListPtr(int no ATTRIBUTE_UNUSED, const xmlListPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
10810: }
10811:
10812: static int
10813: test_xmlListCopy(void) {
10814: int test_ret = 0;
10815:
10816: int mem_base;
10817: int ret_val;
10818: xmlListPtr cur; /* the new list */
10819: int n_cur;
10820: xmlListPtr old; /* the old list */
10821: int n_old;
10822:
10823: for (n_cur = 0;n_cur < gen_nb_xmlListPtr;n_cur++) {
10824: for (n_old = 0;n_old < gen_nb_const_xmlListPtr;n_old++) {
10825: mem_base = xmlMemBlocks();
10826: cur = gen_xmlListPtr(n_cur, 0);
10827: old = gen_const_xmlListPtr(n_old, 1);
10828:
10829: ret_val = xmlListCopy(cur, (const xmlListPtr)old);
10830: desret_int(ret_val);
10831: call_tests++;
10832: des_xmlListPtr(n_cur, cur, 0);
10833: des_const_xmlListPtr(n_old, (const xmlListPtr)old, 1);
10834: xmlResetLastError();
10835: if (mem_base != xmlMemBlocks()) {
10836: printf("Leak of %d blocks found in xmlListCopy",
10837: xmlMemBlocks() - mem_base);
10838: test_ret++;
10839: printf(" %d", n_cur);
10840: printf(" %d", n_old);
10841: printf("\n");
10842: }
10843: }
10844: }
10845: function_tests++;
10846:
10847: return(test_ret);
10848: }
10849:
10850:
10851: static int
10852: test_xmlListCreate(void) {
10853: int test_ret = 0;
10854:
10855:
10856: /* missing type support */
10857: return(test_ret);
10858: }
10859:
10860:
10861: static int
10862: test_xmlListDup(void) {
10863: int test_ret = 0;
10864:
10865:
10866: /* missing type support */
10867: return(test_ret);
10868: }
10869:
10870:
10871: static int
10872: test_xmlListEmpty(void) {
10873: int test_ret = 0;
10874:
10875: int mem_base;
10876: int ret_val;
10877: xmlListPtr l; /* a list */
10878: int n_l;
10879:
10880: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
10881: mem_base = xmlMemBlocks();
10882: l = gen_xmlListPtr(n_l, 0);
10883:
10884: ret_val = xmlListEmpty(l);
10885: desret_int(ret_val);
10886: call_tests++;
10887: des_xmlListPtr(n_l, l, 0);
10888: xmlResetLastError();
10889: if (mem_base != xmlMemBlocks()) {
10890: printf("Leak of %d blocks found in xmlListEmpty",
10891: xmlMemBlocks() - mem_base);
10892: test_ret++;
10893: printf(" %d", n_l);
10894: printf("\n");
10895: }
10896: }
10897: function_tests++;
10898:
10899: return(test_ret);
10900: }
10901:
10902:
10903: static int
10904: test_xmlListEnd(void) {
10905: int test_ret = 0;
10906:
10907:
10908: /* missing type support */
10909: return(test_ret);
10910: }
10911:
10912:
10913: static int
10914: test_xmlListFront(void) {
10915: int test_ret = 0;
10916:
10917:
10918: /* missing type support */
10919: return(test_ret);
10920: }
10921:
10922:
10923: static int
10924: test_xmlListInsert(void) {
10925: int test_ret = 0;
10926:
10927: int mem_base;
10928: int ret_val;
10929: xmlListPtr l; /* a list */
10930: int n_l;
10931: void * data; /* the data */
10932: int n_data;
10933:
10934: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
10935: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
10936: mem_base = xmlMemBlocks();
10937: l = gen_xmlListPtr(n_l, 0);
10938: data = gen_userdata(n_data, 1);
10939:
10940: ret_val = xmlListInsert(l, data);
10941: desret_int(ret_val);
10942: call_tests++;
10943: des_xmlListPtr(n_l, l, 0);
10944: des_userdata(n_data, data, 1);
10945: xmlResetLastError();
10946: if (mem_base != xmlMemBlocks()) {
10947: printf("Leak of %d blocks found in xmlListInsert",
10948: xmlMemBlocks() - mem_base);
10949: test_ret++;
10950: printf(" %d", n_l);
10951: printf(" %d", n_data);
10952: printf("\n");
10953: }
10954: }
10955: }
10956: function_tests++;
10957:
10958: return(test_ret);
10959: }
10960:
10961:
10962: static int
10963: test_xmlListMerge(void) {
10964: int test_ret = 0;
10965:
10966: int mem_base;
10967: xmlListPtr l1; /* the original list */
10968: int n_l1;
10969: xmlListPtr l2; /* the new list */
10970: int n_l2;
10971:
10972: for (n_l1 = 0;n_l1 < gen_nb_xmlListPtr;n_l1++) {
10973: for (n_l2 = 0;n_l2 < gen_nb_xmlListPtr;n_l2++) {
10974: mem_base = xmlMemBlocks();
10975: l1 = gen_xmlListPtr(n_l1, 0);
10976: l2 = gen_xmlListPtr(n_l2, 1);
10977:
10978: xmlListMerge(l1, l2);
10979: call_tests++;
10980: des_xmlListPtr(n_l1, l1, 0);
10981: des_xmlListPtr(n_l2, l2, 1);
10982: xmlResetLastError();
10983: if (mem_base != xmlMemBlocks()) {
10984: printf("Leak of %d blocks found in xmlListMerge",
10985: xmlMemBlocks() - mem_base);
10986: test_ret++;
10987: printf(" %d", n_l1);
10988: printf(" %d", n_l2);
10989: printf("\n");
10990: }
10991: }
10992: }
10993: function_tests++;
10994:
10995: return(test_ret);
10996: }
10997:
10998:
10999: static int
11000: test_xmlListPopBack(void) {
11001: int test_ret = 0;
11002:
11003: int mem_base;
11004: xmlListPtr l; /* a list */
11005: int n_l;
11006:
11007: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11008: mem_base = xmlMemBlocks();
11009: l = gen_xmlListPtr(n_l, 0);
11010:
11011: xmlListPopBack(l);
11012: call_tests++;
11013: des_xmlListPtr(n_l, l, 0);
11014: xmlResetLastError();
11015: if (mem_base != xmlMemBlocks()) {
11016: printf("Leak of %d blocks found in xmlListPopBack",
11017: xmlMemBlocks() - mem_base);
11018: test_ret++;
11019: printf(" %d", n_l);
11020: printf("\n");
11021: }
11022: }
11023: function_tests++;
11024:
11025: return(test_ret);
11026: }
11027:
11028:
11029: static int
11030: test_xmlListPopFront(void) {
11031: int test_ret = 0;
11032:
11033: int mem_base;
11034: xmlListPtr l; /* a list */
11035: int n_l;
11036:
11037: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11038: mem_base = xmlMemBlocks();
11039: l = gen_xmlListPtr(n_l, 0);
11040:
11041: xmlListPopFront(l);
11042: call_tests++;
11043: des_xmlListPtr(n_l, l, 0);
11044: xmlResetLastError();
11045: if (mem_base != xmlMemBlocks()) {
11046: printf("Leak of %d blocks found in xmlListPopFront",
11047: xmlMemBlocks() - mem_base);
11048: test_ret++;
11049: printf(" %d", n_l);
11050: printf("\n");
11051: }
11052: }
11053: function_tests++;
11054:
11055: return(test_ret);
11056: }
11057:
11058:
11059: static int
11060: test_xmlListPushBack(void) {
11061: int test_ret = 0;
11062:
11063: int mem_base;
11064: int ret_val;
11065: xmlListPtr l; /* a list */
11066: int n_l;
11067: void * data; /* new data */
11068: int n_data;
11069:
11070: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11071: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
11072: mem_base = xmlMemBlocks();
11073: l = gen_xmlListPtr(n_l, 0);
11074: data = gen_userdata(n_data, 1);
11075:
11076: ret_val = xmlListPushBack(l, data);
11077: desret_int(ret_val);
11078: call_tests++;
11079: des_xmlListPtr(n_l, l, 0);
11080: des_userdata(n_data, data, 1);
11081: xmlResetLastError();
11082: if (mem_base != xmlMemBlocks()) {
11083: printf("Leak of %d blocks found in xmlListPushBack",
11084: xmlMemBlocks() - mem_base);
11085: test_ret++;
11086: printf(" %d", n_l);
11087: printf(" %d", n_data);
11088: printf("\n");
11089: }
11090: }
11091: }
11092: function_tests++;
11093:
11094: return(test_ret);
11095: }
11096:
11097:
11098: static int
11099: test_xmlListPushFront(void) {
11100: int test_ret = 0;
11101:
11102: int mem_base;
11103: int ret_val;
11104: xmlListPtr l; /* a list */
11105: int n_l;
11106: void * data; /* new data */
11107: int n_data;
11108:
11109: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11110: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
11111: mem_base = xmlMemBlocks();
11112: l = gen_xmlListPtr(n_l, 0);
11113: data = gen_userdata(n_data, 1);
11114:
11115: ret_val = xmlListPushFront(l, data);
11116: desret_int(ret_val);
11117: call_tests++;
11118: des_xmlListPtr(n_l, l, 0);
11119: des_userdata(n_data, data, 1);
11120: xmlResetLastError();
11121: if (mem_base != xmlMemBlocks()) {
11122: printf("Leak of %d blocks found in xmlListPushFront",
11123: xmlMemBlocks() - mem_base);
11124: test_ret++;
11125: printf(" %d", n_l);
11126: printf(" %d", n_data);
11127: printf("\n");
11128: }
11129: }
11130: }
11131: function_tests++;
11132:
11133: return(test_ret);
11134: }
11135:
11136:
11137: static int
11138: test_xmlListRemoveAll(void) {
11139: int test_ret = 0;
11140:
11141: int mem_base;
11142: int ret_val;
11143: xmlListPtr l; /* a list */
11144: int n_l;
11145: void * data; /* list data */
11146: int n_data;
11147:
11148: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11149: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
11150: mem_base = xmlMemBlocks();
11151: l = gen_xmlListPtr(n_l, 0);
11152: data = gen_userdata(n_data, 1);
11153:
11154: ret_val = xmlListRemoveAll(l, data);
11155: desret_int(ret_val);
11156: call_tests++;
11157: des_xmlListPtr(n_l, l, 0);
11158: des_userdata(n_data, data, 1);
11159: xmlResetLastError();
11160: if (mem_base != xmlMemBlocks()) {
11161: printf("Leak of %d blocks found in xmlListRemoveAll",
11162: xmlMemBlocks() - mem_base);
11163: test_ret++;
11164: printf(" %d", n_l);
11165: printf(" %d", n_data);
11166: printf("\n");
11167: }
11168: }
11169: }
11170: function_tests++;
11171:
11172: return(test_ret);
11173: }
11174:
11175:
11176: static int
11177: test_xmlListRemoveFirst(void) {
11178: int test_ret = 0;
11179:
11180: int mem_base;
11181: int ret_val;
11182: xmlListPtr l; /* a list */
11183: int n_l;
11184: void * data; /* list data */
11185: int n_data;
11186:
11187: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11188: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
11189: mem_base = xmlMemBlocks();
11190: l = gen_xmlListPtr(n_l, 0);
11191: data = gen_userdata(n_data, 1);
11192:
11193: ret_val = xmlListRemoveFirst(l, data);
11194: desret_int(ret_val);
11195: call_tests++;
11196: des_xmlListPtr(n_l, l, 0);
11197: des_userdata(n_data, data, 1);
11198: xmlResetLastError();
11199: if (mem_base != xmlMemBlocks()) {
11200: printf("Leak of %d blocks found in xmlListRemoveFirst",
11201: xmlMemBlocks() - mem_base);
11202: test_ret++;
11203: printf(" %d", n_l);
11204: printf(" %d", n_data);
11205: printf("\n");
11206: }
11207: }
11208: }
11209: function_tests++;
11210:
11211: return(test_ret);
11212: }
11213:
11214:
11215: static int
11216: test_xmlListRemoveLast(void) {
11217: int test_ret = 0;
11218:
11219: int mem_base;
11220: int ret_val;
11221: xmlListPtr l; /* a list */
11222: int n_l;
11223: void * data; /* list data */
11224: int n_data;
11225:
11226: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11227: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
11228: mem_base = xmlMemBlocks();
11229: l = gen_xmlListPtr(n_l, 0);
11230: data = gen_userdata(n_data, 1);
11231:
11232: ret_val = xmlListRemoveLast(l, data);
11233: desret_int(ret_val);
11234: call_tests++;
11235: des_xmlListPtr(n_l, l, 0);
11236: des_userdata(n_data, data, 1);
11237: xmlResetLastError();
11238: if (mem_base != xmlMemBlocks()) {
11239: printf("Leak of %d blocks found in xmlListRemoveLast",
11240: xmlMemBlocks() - mem_base);
11241: test_ret++;
11242: printf(" %d", n_l);
11243: printf(" %d", n_data);
11244: printf("\n");
11245: }
11246: }
11247: }
11248: function_tests++;
11249:
11250: return(test_ret);
11251: }
11252:
11253:
11254: static int
11255: test_xmlListReverse(void) {
11256: int test_ret = 0;
11257:
11258: int mem_base;
11259: xmlListPtr l; /* a list */
11260: int n_l;
11261:
11262: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11263: mem_base = xmlMemBlocks();
11264: l = gen_xmlListPtr(n_l, 0);
11265:
11266: xmlListReverse(l);
11267: call_tests++;
11268: des_xmlListPtr(n_l, l, 0);
11269: xmlResetLastError();
11270: if (mem_base != xmlMemBlocks()) {
11271: printf("Leak of %d blocks found in xmlListReverse",
11272: xmlMemBlocks() - mem_base);
11273: test_ret++;
11274: printf(" %d", n_l);
11275: printf("\n");
11276: }
11277: }
11278: function_tests++;
11279:
11280: return(test_ret);
11281: }
11282:
11283:
11284: static int
11285: test_xmlListReverseSearch(void) {
11286: int test_ret = 0;
11287:
11288: int mem_base;
11289: void * ret_val;
11290: xmlListPtr l; /* a list */
11291: int n_l;
11292: void * data; /* a search value */
11293: int n_data;
11294:
11295: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11296: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
11297: mem_base = xmlMemBlocks();
11298: l = gen_xmlListPtr(n_l, 0);
11299: data = gen_userdata(n_data, 1);
11300:
11301: ret_val = xmlListReverseSearch(l, data);
11302: desret_void_ptr(ret_val);
11303: call_tests++;
11304: des_xmlListPtr(n_l, l, 0);
11305: des_userdata(n_data, data, 1);
11306: xmlResetLastError();
11307: if (mem_base != xmlMemBlocks()) {
11308: printf("Leak of %d blocks found in xmlListReverseSearch",
11309: xmlMemBlocks() - mem_base);
11310: test_ret++;
11311: printf(" %d", n_l);
11312: printf(" %d", n_data);
11313: printf("\n");
11314: }
11315: }
11316: }
11317: function_tests++;
11318:
11319: return(test_ret);
11320: }
11321:
11322:
11323: static int
11324: test_xmlListReverseWalk(void) {
11325: int test_ret = 0;
11326:
11327:
11328: /* missing type support */
11329: return(test_ret);
11330: }
11331:
11332:
11333: static int
11334: test_xmlListSearch(void) {
11335: int test_ret = 0;
11336:
11337: int mem_base;
11338: void * ret_val;
11339: xmlListPtr l; /* a list */
11340: int n_l;
11341: void * data; /* a search value */
11342: int n_data;
11343:
11344: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11345: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
11346: mem_base = xmlMemBlocks();
11347: l = gen_xmlListPtr(n_l, 0);
11348: data = gen_userdata(n_data, 1);
11349:
11350: ret_val = xmlListSearch(l, data);
11351: desret_void_ptr(ret_val);
11352: call_tests++;
11353: des_xmlListPtr(n_l, l, 0);
11354: des_userdata(n_data, data, 1);
11355: xmlResetLastError();
11356: if (mem_base != xmlMemBlocks()) {
11357: printf("Leak of %d blocks found in xmlListSearch",
11358: xmlMemBlocks() - mem_base);
11359: test_ret++;
11360: printf(" %d", n_l);
11361: printf(" %d", n_data);
11362: printf("\n");
11363: }
11364: }
11365: }
11366: function_tests++;
11367:
11368: return(test_ret);
11369: }
11370:
11371:
11372: static int
11373: test_xmlListSize(void) {
11374: int test_ret = 0;
11375:
11376: int mem_base;
11377: int ret_val;
11378: xmlListPtr l; /* a list */
11379: int n_l;
11380:
11381: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11382: mem_base = xmlMemBlocks();
11383: l = gen_xmlListPtr(n_l, 0);
11384:
11385: ret_val = xmlListSize(l);
11386: desret_int(ret_val);
11387: call_tests++;
11388: des_xmlListPtr(n_l, l, 0);
11389: xmlResetLastError();
11390: if (mem_base != xmlMemBlocks()) {
11391: printf("Leak of %d blocks found in xmlListSize",
11392: xmlMemBlocks() - mem_base);
11393: test_ret++;
11394: printf(" %d", n_l);
11395: printf("\n");
11396: }
11397: }
11398: function_tests++;
11399:
11400: return(test_ret);
11401: }
11402:
11403:
11404: static int
11405: test_xmlListSort(void) {
11406: int test_ret = 0;
11407:
11408: int mem_base;
11409: xmlListPtr l; /* a list */
11410: int n_l;
11411:
11412: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11413: mem_base = xmlMemBlocks();
11414: l = gen_xmlListPtr(n_l, 0);
11415:
11416: xmlListSort(l);
11417: call_tests++;
11418: des_xmlListPtr(n_l, l, 0);
11419: xmlResetLastError();
11420: if (mem_base != xmlMemBlocks()) {
11421: printf("Leak of %d blocks found in xmlListSort",
11422: xmlMemBlocks() - mem_base);
11423: test_ret++;
11424: printf(" %d", n_l);
11425: printf("\n");
11426: }
11427: }
11428: function_tests++;
11429:
11430: return(test_ret);
11431: }
11432:
11433:
11434: static int
11435: test_xmlListWalk(void) {
11436: int test_ret = 0;
11437:
11438:
11439: /* missing type support */
11440: return(test_ret);
11441: }
11442:
11443: static int
11444: test_list(void) {
11445: int test_ret = 0;
11446:
11447: if (quiet == 0) printf("Testing list : 19 of 26 functions ...\n");
11448: test_ret += test_xmlLinkGetData();
11449: test_ret += test_xmlListAppend();
11450: test_ret += test_xmlListClear();
11451: test_ret += test_xmlListCopy();
11452: test_ret += test_xmlListCreate();
11453: test_ret += test_xmlListDup();
11454: test_ret += test_xmlListEmpty();
11455: test_ret += test_xmlListEnd();
11456: test_ret += test_xmlListFront();
11457: test_ret += test_xmlListInsert();
11458: test_ret += test_xmlListMerge();
11459: test_ret += test_xmlListPopBack();
11460: test_ret += test_xmlListPopFront();
11461: test_ret += test_xmlListPushBack();
11462: test_ret += test_xmlListPushFront();
11463: test_ret += test_xmlListRemoveAll();
11464: test_ret += test_xmlListRemoveFirst();
11465: test_ret += test_xmlListRemoveLast();
11466: test_ret += test_xmlListReverse();
11467: test_ret += test_xmlListReverseSearch();
11468: test_ret += test_xmlListReverseWalk();
11469: test_ret += test_xmlListSearch();
11470: test_ret += test_xmlListSize();
11471: test_ret += test_xmlListSort();
11472: test_ret += test_xmlListWalk();
11473:
11474: if (test_ret != 0)
11475: printf("Module list: %d errors\n", test_ret);
11476: return(test_ret);
11477: }
11478:
11479: static int
11480: test_xmlNanoFTPCheckResponse(void) {
11481: int test_ret = 0;
11482:
11483: #if defined(LIBXML_FTP_ENABLED)
11484: int mem_base;
11485: int ret_val;
11486: void * ctx; /* an FTP context */
11487: int n_ctx;
11488:
11489: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
11490: mem_base = xmlMemBlocks();
11491: ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
11492:
11493: ret_val = xmlNanoFTPCheckResponse(ctx);
11494: desret_int(ret_val);
11495: call_tests++;
11496: des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
11497: xmlResetLastError();
11498: if (mem_base != xmlMemBlocks()) {
11499: printf("Leak of %d blocks found in xmlNanoFTPCheckResponse",
11500: xmlMemBlocks() - mem_base);
11501: test_ret++;
11502: printf(" %d", n_ctx);
11503: printf("\n");
11504: }
11505: }
11506: function_tests++;
11507: #endif
11508:
11509: return(test_ret);
11510: }
11511:
11512:
11513: static int
11514: test_xmlNanoFTPCleanup(void) {
11515: int test_ret = 0;
11516:
11517: #if defined(LIBXML_FTP_ENABLED)
11518: int mem_base;
11519:
11520: mem_base = xmlMemBlocks();
11521:
11522: xmlNanoFTPCleanup();
11523: call_tests++;
11524: xmlResetLastError();
11525: if (mem_base != xmlMemBlocks()) {
11526: printf("Leak of %d blocks found in xmlNanoFTPCleanup",
11527: xmlMemBlocks() - mem_base);
11528: test_ret++;
11529: printf("\n");
11530: }
11531: function_tests++;
11532: #endif
11533:
11534: return(test_ret);
11535: }
11536:
11537:
11538: static int
11539: test_xmlNanoFTPCloseConnection(void) {
11540: int test_ret = 0;
11541:
11542: #if defined(LIBXML_FTP_ENABLED)
11543: int mem_base;
11544: int ret_val;
11545: void * ctx; /* an FTP context */
11546: int n_ctx;
11547:
11548: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
11549: mem_base = xmlMemBlocks();
11550: ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
11551:
11552: ret_val = xmlNanoFTPCloseConnection(ctx);
11553: desret_int(ret_val);
11554: call_tests++;
11555: des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
11556: xmlResetLastError();
11557: if (mem_base != xmlMemBlocks()) {
11558: printf("Leak of %d blocks found in xmlNanoFTPCloseConnection",
11559: xmlMemBlocks() - mem_base);
11560: test_ret++;
11561: printf(" %d", n_ctx);
11562: printf("\n");
11563: }
11564: }
11565: function_tests++;
11566: #endif
11567:
11568: return(test_ret);
11569: }
11570:
11571:
11572: static int
11573: test_xmlNanoFTPCwd(void) {
11574: int test_ret = 0;
11575:
11576: #if defined(LIBXML_FTP_ENABLED)
11577: int mem_base;
11578: int ret_val;
11579: void * ctx; /* an FTP context */
11580: int n_ctx;
11581: char * directory; /* a directory on the server */
11582: int n_directory;
11583:
11584: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
11585: for (n_directory = 0;n_directory < gen_nb_const_char_ptr;n_directory++) {
11586: mem_base = xmlMemBlocks();
11587: ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
11588: directory = gen_const_char_ptr(n_directory, 1);
11589:
11590: ret_val = xmlNanoFTPCwd(ctx, (const char *)directory);
11591: desret_int(ret_val);
11592: call_tests++;
11593: des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
11594: des_const_char_ptr(n_directory, (const char *)directory, 1);
11595: xmlResetLastError();
11596: if (mem_base != xmlMemBlocks()) {
11597: printf("Leak of %d blocks found in xmlNanoFTPCwd",
11598: xmlMemBlocks() - mem_base);
11599: test_ret++;
11600: printf(" %d", n_ctx);
11601: printf(" %d", n_directory);
11602: printf("\n");
11603: }
11604: }
11605: }
11606: function_tests++;
11607: #endif
11608:
11609: return(test_ret);
11610: }
11611:
11612:
11613: static int
11614: test_xmlNanoFTPDele(void) {
11615: int test_ret = 0;
11616:
11617: #if defined(LIBXML_FTP_ENABLED)
11618: int mem_base;
11619: int ret_val;
11620: void * ctx; /* an FTP context */
11621: int n_ctx;
11622: const char * file; /* a file or directory on the server */
11623: int n_file;
11624:
11625: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
11626: for (n_file = 0;n_file < gen_nb_filepath;n_file++) {
11627: mem_base = xmlMemBlocks();
11628: ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
11629: file = gen_filepath(n_file, 1);
11630:
11631: ret_val = xmlNanoFTPDele(ctx, file);
11632: desret_int(ret_val);
11633: call_tests++;
11634: des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
11635: des_filepath(n_file, file, 1);
11636: xmlResetLastError();
11637: if (mem_base != xmlMemBlocks()) {
11638: printf("Leak of %d blocks found in xmlNanoFTPDele",
11639: xmlMemBlocks() - mem_base);
11640: test_ret++;
11641: printf(" %d", n_ctx);
11642: printf(" %d", n_file);
11643: printf("\n");
11644: }
11645: }
11646: }
11647: function_tests++;
11648: #endif
11649:
11650: return(test_ret);
11651: }
11652:
11653:
11654: static int
11655: test_xmlNanoFTPGet(void) {
11656: int test_ret = 0;
11657:
11658:
11659: /* missing type support */
11660: return(test_ret);
11661: }
11662:
11663:
11664: static int
11665: test_xmlNanoFTPGetConnection(void) {
11666: int test_ret = 0;
11667:
11668:
11669: /* missing type support */
11670: return(test_ret);
11671: }
11672:
11673:
11674: static int
11675: test_xmlNanoFTPGetResponse(void) {
11676: int test_ret = 0;
11677:
11678: #if defined(LIBXML_FTP_ENABLED)
11679: int mem_base;
11680: int ret_val;
11681: void * ctx; /* an FTP context */
11682: int n_ctx;
11683:
11684: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
11685: mem_base = xmlMemBlocks();
11686: ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
11687:
11688: ret_val = xmlNanoFTPGetResponse(ctx);
11689: desret_int(ret_val);
11690: call_tests++;
11691: des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
11692: xmlResetLastError();
11693: if (mem_base != xmlMemBlocks()) {
11694: printf("Leak of %d blocks found in xmlNanoFTPGetResponse",
11695: xmlMemBlocks() - mem_base);
11696: test_ret++;
11697: printf(" %d", n_ctx);
11698: printf("\n");
11699: }
11700: }
11701: function_tests++;
11702: #endif
11703:
11704: return(test_ret);
11705: }
11706:
11707:
11708: static int
11709: test_xmlNanoFTPGetSocket(void) {
11710: int test_ret = 0;
11711:
11712:
11713: /* missing type support */
11714: return(test_ret);
11715: }
11716:
11717:
11718: static int
11719: test_xmlNanoFTPInit(void) {
11720: int test_ret = 0;
11721:
11722: #if defined(LIBXML_FTP_ENABLED)
11723: int mem_base;
11724:
11725: mem_base = xmlMemBlocks();
11726:
11727: xmlNanoFTPInit();
11728: call_tests++;
11729: xmlResetLastError();
11730: if (mem_base != xmlMemBlocks()) {
11731: printf("Leak of %d blocks found in xmlNanoFTPInit",
11732: xmlMemBlocks() - mem_base);
11733: test_ret++;
11734: printf("\n");
11735: }
11736: function_tests++;
11737: #endif
11738:
11739: return(test_ret);
11740: }
11741:
11742:
11743: static int
11744: test_xmlNanoFTPList(void) {
11745: int test_ret = 0;
11746:
11747:
11748: /* missing type support */
11749: return(test_ret);
11750: }
11751:
11752:
11753: static int
11754: test_xmlNanoFTPNewCtxt(void) {
11755: int test_ret = 0;
11756:
11757: #if defined(LIBXML_FTP_ENABLED)
11758: int mem_base;
11759: void * ret_val;
11760: const char * URL; /* The URL used to initialize the context */
11761: int n_URL;
11762:
11763: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
11764: mem_base = xmlMemBlocks();
11765: URL = gen_filepath(n_URL, 0);
11766:
11767: ret_val = xmlNanoFTPNewCtxt(URL);
11768: desret_xmlNanoFTPCtxtPtr(ret_val);
11769: call_tests++;
11770: des_filepath(n_URL, URL, 0);
11771: xmlResetLastError();
11772: if (mem_base != xmlMemBlocks()) {
11773: printf("Leak of %d blocks found in xmlNanoFTPNewCtxt",
11774: xmlMemBlocks() - mem_base);
11775: test_ret++;
11776: printf(" %d", n_URL);
11777: printf("\n");
11778: }
11779: }
11780: function_tests++;
11781: #endif
11782:
11783: return(test_ret);
11784: }
11785:
11786:
11787: static int
11788: test_xmlNanoFTPOpen(void) {
11789: int test_ret = 0;
11790:
11791: #if defined(LIBXML_FTP_ENABLED)
11792: int mem_base;
11793: void * ret_val;
11794: const char * URL; /* the URL to the resource */
11795: int n_URL;
11796:
11797: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
11798: mem_base = xmlMemBlocks();
11799: URL = gen_filepath(n_URL, 0);
11800:
11801: ret_val = xmlNanoFTPOpen(URL);
11802: desret_xmlNanoFTPCtxtPtr(ret_val);
11803: call_tests++;
11804: des_filepath(n_URL, URL, 0);
11805: xmlResetLastError();
11806: if (mem_base != xmlMemBlocks()) {
11807: printf("Leak of %d blocks found in xmlNanoFTPOpen",
11808: xmlMemBlocks() - mem_base);
11809: test_ret++;
11810: printf(" %d", n_URL);
11811: printf("\n");
11812: }
11813: }
11814: function_tests++;
11815: #endif
11816:
11817: return(test_ret);
11818: }
11819:
11820:
11821: static int
11822: test_xmlNanoFTPProxy(void) {
11823: int test_ret = 0;
11824:
11825: #if defined(LIBXML_FTP_ENABLED)
11826: char * host; /* the proxy host name */
11827: int n_host;
11828: int port; /* the proxy port */
11829: int n_port;
11830: char * user; /* the proxy user name */
11831: int n_user;
11832: char * passwd; /* the proxy password */
11833: int n_passwd;
11834: int type; /* the type of proxy 1 for using SITE, 2 for USER a@b */
11835: int n_type;
11836:
11837: for (n_host = 0;n_host < gen_nb_const_char_ptr;n_host++) {
11838: for (n_port = 0;n_port < gen_nb_int;n_port++) {
11839: for (n_user = 0;n_user < gen_nb_const_char_ptr;n_user++) {
11840: for (n_passwd = 0;n_passwd < gen_nb_const_char_ptr;n_passwd++) {
11841: for (n_type = 0;n_type < gen_nb_int;n_type++) {
11842: host = gen_const_char_ptr(n_host, 0);
11843: port = gen_int(n_port, 1);
11844: user = gen_const_char_ptr(n_user, 2);
11845: passwd = gen_const_char_ptr(n_passwd, 3);
11846: type = gen_int(n_type, 4);
11847:
11848: xmlNanoFTPProxy((const char *)host, port, (const char *)user, (const char *)passwd, type);
11849: call_tests++;
11850: des_const_char_ptr(n_host, (const char *)host, 0);
11851: des_int(n_port, port, 1);
11852: des_const_char_ptr(n_user, (const char *)user, 2);
11853: des_const_char_ptr(n_passwd, (const char *)passwd, 3);
11854: des_int(n_type, type, 4);
11855: xmlResetLastError();
11856: }
11857: }
11858: }
11859: }
11860: }
11861: function_tests++;
11862: #endif
11863:
11864: return(test_ret);
11865: }
11866:
11867:
11868: static int
11869: test_xmlNanoFTPQuit(void) {
11870: int test_ret = 0;
11871:
11872: #if defined(LIBXML_FTP_ENABLED)
11873: int mem_base;
11874: int ret_val;
11875: void * ctx; /* an FTP context */
11876: int n_ctx;
11877:
11878: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
11879: mem_base = xmlMemBlocks();
11880: ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
11881:
11882: ret_val = xmlNanoFTPQuit(ctx);
11883: desret_int(ret_val);
11884: call_tests++;
11885: des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
11886: xmlResetLastError();
11887: if (mem_base != xmlMemBlocks()) {
11888: printf("Leak of %d blocks found in xmlNanoFTPQuit",
11889: xmlMemBlocks() - mem_base);
11890: test_ret++;
11891: printf(" %d", n_ctx);
11892: printf("\n");
11893: }
11894: }
11895: function_tests++;
11896: #endif
11897:
11898: return(test_ret);
11899: }
11900:
11901:
11902: static int
11903: test_xmlNanoFTPRead(void) {
11904: int test_ret = 0;
11905:
11906: #if defined(LIBXML_FTP_ENABLED)
11907: int mem_base;
11908: int ret_val;
11909: void * ctx; /* the FTP context */
11910: int n_ctx;
11911: void * dest; /* a buffer */
11912: int n_dest;
11913: int len; /* the buffer length */
11914: int n_len;
11915:
11916: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
11917: for (n_dest = 0;n_dest < gen_nb_void_ptr;n_dest++) {
11918: for (n_len = 0;n_len < gen_nb_int;n_len++) {
11919: mem_base = xmlMemBlocks();
11920: ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
11921: dest = gen_void_ptr(n_dest, 1);
11922: len = gen_int(n_len, 2);
11923:
11924: ret_val = xmlNanoFTPRead(ctx, dest, len);
11925: desret_int(ret_val);
11926: call_tests++;
11927: des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
11928: des_void_ptr(n_dest, dest, 1);
11929: des_int(n_len, len, 2);
11930: xmlResetLastError();
11931: if (mem_base != xmlMemBlocks()) {
11932: printf("Leak of %d blocks found in xmlNanoFTPRead",
11933: xmlMemBlocks() - mem_base);
11934: test_ret++;
11935: printf(" %d", n_ctx);
11936: printf(" %d", n_dest);
11937: printf(" %d", n_len);
11938: printf("\n");
11939: }
11940: }
11941: }
11942: }
11943: function_tests++;
11944: #endif
11945:
11946: return(test_ret);
11947: }
11948:
11949:
11950: static int
11951: test_xmlNanoFTPScanProxy(void) {
11952: int test_ret = 0;
11953:
11954: #if defined(LIBXML_FTP_ENABLED)
11955: const char * URL; /* The proxy URL used to initialize the proxy context */
11956: int n_URL;
11957:
11958: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
11959: URL = gen_filepath(n_URL, 0);
11960:
11961: xmlNanoFTPScanProxy(URL);
11962: call_tests++;
11963: des_filepath(n_URL, URL, 0);
11964: xmlResetLastError();
11965: }
11966: function_tests++;
11967: #endif
11968:
11969: return(test_ret);
11970: }
11971:
11972:
11973: static int
11974: test_xmlNanoFTPUpdateURL(void) {
11975: int test_ret = 0;
11976:
11977: #if defined(LIBXML_FTP_ENABLED)
11978: int mem_base;
11979: int ret_val;
11980: void * ctx; /* an FTP context */
11981: int n_ctx;
11982: const char * URL; /* The URL used to update the context */
11983: int n_URL;
11984:
11985: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
11986: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
11987: mem_base = xmlMemBlocks();
11988: ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
11989: URL = gen_filepath(n_URL, 1);
11990:
11991: ret_val = xmlNanoFTPUpdateURL(ctx, URL);
11992: desret_int(ret_val);
11993: call_tests++;
11994: des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
11995: des_filepath(n_URL, URL, 1);
11996: xmlResetLastError();
11997: if (mem_base != xmlMemBlocks()) {
11998: printf("Leak of %d blocks found in xmlNanoFTPUpdateURL",
11999: xmlMemBlocks() - mem_base);
12000: test_ret++;
12001: printf(" %d", n_ctx);
12002: printf(" %d", n_URL);
12003: printf("\n");
12004: }
12005: }
12006: }
12007: function_tests++;
12008: #endif
12009:
12010: return(test_ret);
12011: }
12012:
12013: static int
12014: test_nanoftp(void) {
12015: int test_ret = 0;
12016:
12017: if (quiet == 0) printf("Testing nanoftp : 14 of 22 functions ...\n");
12018: test_ret += test_xmlNanoFTPCheckResponse();
12019: test_ret += test_xmlNanoFTPCleanup();
12020: test_ret += test_xmlNanoFTPCloseConnection();
12021: test_ret += test_xmlNanoFTPCwd();
12022: test_ret += test_xmlNanoFTPDele();
12023: test_ret += test_xmlNanoFTPGet();
12024: test_ret += test_xmlNanoFTPGetConnection();
12025: test_ret += test_xmlNanoFTPGetResponse();
12026: test_ret += test_xmlNanoFTPGetSocket();
12027: test_ret += test_xmlNanoFTPInit();
12028: test_ret += test_xmlNanoFTPList();
12029: test_ret += test_xmlNanoFTPNewCtxt();
12030: test_ret += test_xmlNanoFTPOpen();
12031: test_ret += test_xmlNanoFTPProxy();
12032: test_ret += test_xmlNanoFTPQuit();
12033: test_ret += test_xmlNanoFTPRead();
12034: test_ret += test_xmlNanoFTPScanProxy();
12035: test_ret += test_xmlNanoFTPUpdateURL();
12036:
12037: if (test_ret != 0)
12038: printf("Module nanoftp: %d errors\n", test_ret);
12039: return(test_ret);
12040: }
12041:
12042: static int
12043: test_xmlNanoHTTPAuthHeader(void) {
12044: int test_ret = 0;
12045:
12046: #if defined(LIBXML_HTTP_ENABLED)
12047: int mem_base;
12048: const char * ret_val;
12049: void * ctx; /* the HTTP context */
12050: int n_ctx;
12051:
12052: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
12053: mem_base = xmlMemBlocks();
12054: ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
12055:
12056: ret_val = xmlNanoHTTPAuthHeader(ctx);
12057: desret_const_char_ptr(ret_val);
12058: call_tests++;
12059: des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
12060: xmlResetLastError();
12061: if (mem_base != xmlMemBlocks()) {
12062: printf("Leak of %d blocks found in xmlNanoHTTPAuthHeader",
12063: xmlMemBlocks() - mem_base);
12064: test_ret++;
12065: printf(" %d", n_ctx);
12066: printf("\n");
12067: }
12068: }
12069: function_tests++;
12070: #endif
12071:
12072: return(test_ret);
12073: }
12074:
12075:
12076: static int
12077: test_xmlNanoHTTPCleanup(void) {
12078: int test_ret = 0;
12079:
12080: #if defined(LIBXML_HTTP_ENABLED)
12081: int mem_base;
12082:
12083: mem_base = xmlMemBlocks();
12084:
12085: xmlNanoHTTPCleanup();
12086: call_tests++;
12087: xmlResetLastError();
12088: if (mem_base != xmlMemBlocks()) {
12089: printf("Leak of %d blocks found in xmlNanoHTTPCleanup",
12090: xmlMemBlocks() - mem_base);
12091: test_ret++;
12092: printf("\n");
12093: }
12094: function_tests++;
12095: #endif
12096:
12097: return(test_ret);
12098: }
12099:
12100:
12101: static int
12102: test_xmlNanoHTTPContentLength(void) {
12103: int test_ret = 0;
12104:
12105: #if defined(LIBXML_HTTP_ENABLED)
12106: int mem_base;
12107: int ret_val;
12108: void * ctx; /* the HTTP context */
12109: int n_ctx;
12110:
12111: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
12112: mem_base = xmlMemBlocks();
12113: ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
12114:
12115: ret_val = xmlNanoHTTPContentLength(ctx);
12116: desret_int(ret_val);
12117: call_tests++;
12118: des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
12119: xmlResetLastError();
12120: if (mem_base != xmlMemBlocks()) {
12121: printf("Leak of %d blocks found in xmlNanoHTTPContentLength",
12122: xmlMemBlocks() - mem_base);
12123: test_ret++;
12124: printf(" %d", n_ctx);
12125: printf("\n");
12126: }
12127: }
12128: function_tests++;
12129: #endif
12130:
12131: return(test_ret);
12132: }
12133:
12134:
12135: static int
12136: test_xmlNanoHTTPEncoding(void) {
12137: int test_ret = 0;
12138:
12139: #if defined(LIBXML_HTTP_ENABLED)
12140: int mem_base;
12141: const char * ret_val;
12142: void * ctx; /* the HTTP context */
12143: int n_ctx;
12144:
12145: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
12146: mem_base = xmlMemBlocks();
12147: ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
12148:
12149: ret_val = xmlNanoHTTPEncoding(ctx);
12150: desret_const_char_ptr(ret_val);
12151: call_tests++;
12152: des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
12153: xmlResetLastError();
12154: if (mem_base != xmlMemBlocks()) {
12155: printf("Leak of %d blocks found in xmlNanoHTTPEncoding",
12156: xmlMemBlocks() - mem_base);
12157: test_ret++;
12158: printf(" %d", n_ctx);
12159: printf("\n");
12160: }
12161: }
12162: function_tests++;
12163: #endif
12164:
12165: return(test_ret);
12166: }
12167:
12168:
12169: #define gen_nb_char_ptr_ptr 1
12170: static char ** gen_char_ptr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
12171: return(NULL);
12172: }
12173: static void des_char_ptr_ptr(int no ATTRIBUTE_UNUSED, char ** val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
12174: }
12175:
12176: static int
12177: test_xmlNanoHTTPFetch(void) {
12178: int test_ret = 0;
12179:
12180: #if defined(LIBXML_HTTP_ENABLED)
12181: int mem_base;
12182: int ret_val;
12183: const char * URL; /* The URL to load */
12184: int n_URL;
12185: const char * filename; /* the filename where the content should be saved */
12186: int n_filename;
12187: char ** contentType; /* if available the Content-Type information will be returned at that location */
12188: int n_contentType;
12189:
12190: for (n_URL = 0;n_URL < gen_nb_fileoutput;n_URL++) {
12191: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
12192: for (n_contentType = 0;n_contentType < gen_nb_char_ptr_ptr;n_contentType++) {
12193: mem_base = xmlMemBlocks();
12194: URL = gen_fileoutput(n_URL, 0);
12195: filename = gen_fileoutput(n_filename, 1);
12196: contentType = gen_char_ptr_ptr(n_contentType, 2);
12197:
12198: ret_val = xmlNanoHTTPFetch(URL, filename, contentType);
12199: desret_int(ret_val);
12200: call_tests++;
12201: des_fileoutput(n_URL, URL, 0);
12202: des_fileoutput(n_filename, filename, 1);
12203: des_char_ptr_ptr(n_contentType, contentType, 2);
12204: xmlResetLastError();
12205: if (mem_base != xmlMemBlocks()) {
12206: printf("Leak of %d blocks found in xmlNanoHTTPFetch",
12207: xmlMemBlocks() - mem_base);
12208: test_ret++;
12209: printf(" %d", n_URL);
12210: printf(" %d", n_filename);
12211: printf(" %d", n_contentType);
12212: printf("\n");
12213: }
12214: }
12215: }
12216: }
12217: function_tests++;
12218: #endif
12219:
12220: return(test_ret);
12221: }
12222:
12223:
12224: static int
12225: test_xmlNanoHTTPInit(void) {
12226: int test_ret = 0;
12227:
12228: #if defined(LIBXML_HTTP_ENABLED)
12229: int mem_base;
12230:
12231: mem_base = xmlMemBlocks();
12232:
12233: xmlNanoHTTPInit();
12234: call_tests++;
12235: xmlResetLastError();
12236: if (mem_base != xmlMemBlocks()) {
12237: printf("Leak of %d blocks found in xmlNanoHTTPInit",
12238: xmlMemBlocks() - mem_base);
12239: test_ret++;
12240: printf("\n");
12241: }
12242: function_tests++;
12243: #endif
12244:
12245: return(test_ret);
12246: }
12247:
12248:
12249: static int
12250: test_xmlNanoHTTPMimeType(void) {
12251: int test_ret = 0;
12252:
12253: #if defined(LIBXML_HTTP_ENABLED)
12254: int mem_base;
12255: const char * ret_val;
12256: void * ctx; /* the HTTP context */
12257: int n_ctx;
12258:
12259: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
12260: mem_base = xmlMemBlocks();
12261: ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
12262:
12263: ret_val = xmlNanoHTTPMimeType(ctx);
12264: desret_const_char_ptr(ret_val);
12265: call_tests++;
12266: des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
12267: xmlResetLastError();
12268: if (mem_base != xmlMemBlocks()) {
12269: printf("Leak of %d blocks found in xmlNanoHTTPMimeType",
12270: xmlMemBlocks() - mem_base);
12271: test_ret++;
12272: printf(" %d", n_ctx);
12273: printf("\n");
12274: }
12275: }
12276: function_tests++;
12277: #endif
12278:
12279: return(test_ret);
12280: }
12281:
12282:
12283: static int
12284: test_xmlNanoHTTPOpen(void) {
12285: int test_ret = 0;
12286:
12287: #if defined(LIBXML_HTTP_ENABLED)
12288: int mem_base;
12289: void * ret_val;
12290: const char * URL; /* The URL to load */
12291: int n_URL;
12292: char ** contentType; /* if available the Content-Type information will be returned at that location */
12293: int n_contentType;
12294:
12295: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
12296: for (n_contentType = 0;n_contentType < gen_nb_char_ptr_ptr;n_contentType++) {
12297: mem_base = xmlMemBlocks();
12298: URL = gen_filepath(n_URL, 0);
12299: contentType = gen_char_ptr_ptr(n_contentType, 1);
12300:
12301: ret_val = xmlNanoHTTPOpen(URL, contentType);
12302: desret_xmlNanoHTTPCtxtPtr(ret_val);
12303: call_tests++;
12304: des_filepath(n_URL, URL, 0);
12305: des_char_ptr_ptr(n_contentType, contentType, 1);
12306: xmlResetLastError();
12307: if (mem_base != xmlMemBlocks()) {
12308: printf("Leak of %d blocks found in xmlNanoHTTPOpen",
12309: xmlMemBlocks() - mem_base);
12310: test_ret++;
12311: printf(" %d", n_URL);
12312: printf(" %d", n_contentType);
12313: printf("\n");
12314: }
12315: }
12316: }
12317: function_tests++;
12318: #endif
12319:
12320: return(test_ret);
12321: }
12322:
12323:
12324: static int
12325: test_xmlNanoHTTPOpenRedir(void) {
12326: int test_ret = 0;
12327:
12328: #if defined(LIBXML_HTTP_ENABLED)
12329: int mem_base;
12330: void * ret_val;
12331: const char * URL; /* The URL to load */
12332: int n_URL;
12333: char ** contentType; /* if available the Content-Type information will be returned at that location */
12334: int n_contentType;
12335: char ** redir; /* if available the redirected URL will be returned */
12336: int n_redir;
12337:
12338: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
12339: for (n_contentType = 0;n_contentType < gen_nb_char_ptr_ptr;n_contentType++) {
12340: for (n_redir = 0;n_redir < gen_nb_char_ptr_ptr;n_redir++) {
12341: mem_base = xmlMemBlocks();
12342: URL = gen_filepath(n_URL, 0);
12343: contentType = gen_char_ptr_ptr(n_contentType, 1);
12344: redir = gen_char_ptr_ptr(n_redir, 2);
12345:
12346: ret_val = xmlNanoHTTPOpenRedir(URL, contentType, redir);
12347: desret_xmlNanoHTTPCtxtPtr(ret_val);
12348: call_tests++;
12349: des_filepath(n_URL, URL, 0);
12350: des_char_ptr_ptr(n_contentType, contentType, 1);
12351: des_char_ptr_ptr(n_redir, redir, 2);
12352: xmlResetLastError();
12353: if (mem_base != xmlMemBlocks()) {
12354: printf("Leak of %d blocks found in xmlNanoHTTPOpenRedir",
12355: xmlMemBlocks() - mem_base);
12356: test_ret++;
12357: printf(" %d", n_URL);
12358: printf(" %d", n_contentType);
12359: printf(" %d", n_redir);
12360: printf("\n");
12361: }
12362: }
12363: }
12364: }
12365: function_tests++;
12366: #endif
12367:
12368: return(test_ret);
12369: }
12370:
12371:
12372: static int
12373: test_xmlNanoHTTPRead(void) {
12374: int test_ret = 0;
12375:
12376: #if defined(LIBXML_HTTP_ENABLED)
12377: int mem_base;
12378: int ret_val;
12379: void * ctx; /* the HTTP context */
12380: int n_ctx;
12381: void * dest; /* a buffer */
12382: int n_dest;
12383: int len; /* the buffer length */
12384: int n_len;
12385:
12386: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
12387: for (n_dest = 0;n_dest < gen_nb_void_ptr;n_dest++) {
12388: for (n_len = 0;n_len < gen_nb_int;n_len++) {
12389: mem_base = xmlMemBlocks();
12390: ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
12391: dest = gen_void_ptr(n_dest, 1);
12392: len = gen_int(n_len, 2);
12393:
12394: ret_val = xmlNanoHTTPRead(ctx, dest, len);
12395: desret_int(ret_val);
12396: call_tests++;
12397: des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
12398: des_void_ptr(n_dest, dest, 1);
12399: des_int(n_len, len, 2);
12400: xmlResetLastError();
12401: if (mem_base != xmlMemBlocks()) {
12402: printf("Leak of %d blocks found in xmlNanoHTTPRead",
12403: xmlMemBlocks() - mem_base);
12404: test_ret++;
12405: printf(" %d", n_ctx);
12406: printf(" %d", n_dest);
12407: printf(" %d", n_len);
12408: printf("\n");
12409: }
12410: }
12411: }
12412: }
12413: function_tests++;
12414: #endif
12415:
12416: return(test_ret);
12417: }
12418:
12419:
12420: static int
12421: test_xmlNanoHTTPRedir(void) {
12422: int test_ret = 0;
12423:
12424:
12425: /* missing type support */
12426: return(test_ret);
12427: }
12428:
12429:
12430: static int
12431: test_xmlNanoHTTPReturnCode(void) {
12432: int test_ret = 0;
12433:
12434: #if defined(LIBXML_HTTP_ENABLED)
12435: int mem_base;
12436: int ret_val;
12437: void * ctx; /* the HTTP context */
12438: int n_ctx;
12439:
12440: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
12441: mem_base = xmlMemBlocks();
12442: ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
12443:
12444: ret_val = xmlNanoHTTPReturnCode(ctx);
12445: desret_int(ret_val);
12446: call_tests++;
12447: des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
12448: xmlResetLastError();
12449: if (mem_base != xmlMemBlocks()) {
12450: printf("Leak of %d blocks found in xmlNanoHTTPReturnCode",
12451: xmlMemBlocks() - mem_base);
12452: test_ret++;
12453: printf(" %d", n_ctx);
12454: printf("\n");
12455: }
12456: }
12457: function_tests++;
12458: #endif
12459:
12460: return(test_ret);
12461: }
12462:
12463:
12464: static int
12465: test_xmlNanoHTTPSave(void) {
12466: int test_ret = 0;
12467:
12468: #if defined(LIBXML_HTTP_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
12469: int mem_base;
12470: int ret_val;
12471: void * ctxt; /* the HTTP context */
12472: int n_ctxt;
12473: const char * filename; /* the filename where the content should be saved */
12474: int n_filename;
12475:
12476: for (n_ctxt = 0;n_ctxt < gen_nb_void_ptr;n_ctxt++) {
12477: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
12478: mem_base = xmlMemBlocks();
12479: ctxt = gen_void_ptr(n_ctxt, 0);
12480: filename = gen_fileoutput(n_filename, 1);
12481:
12482: ret_val = xmlNanoHTTPSave(ctxt, filename);
12483: desret_int(ret_val);
12484: call_tests++;
12485: des_void_ptr(n_ctxt, ctxt, 0);
12486: des_fileoutput(n_filename, filename, 1);
12487: xmlResetLastError();
12488: if (mem_base != xmlMemBlocks()) {
12489: printf("Leak of %d blocks found in xmlNanoHTTPSave",
12490: xmlMemBlocks() - mem_base);
12491: test_ret++;
12492: printf(" %d", n_ctxt);
12493: printf(" %d", n_filename);
12494: printf("\n");
12495: }
12496: }
12497: }
12498: function_tests++;
12499: #endif
12500:
12501: return(test_ret);
12502: }
12503:
12504:
12505: static int
12506: test_xmlNanoHTTPScanProxy(void) {
12507: int test_ret = 0;
12508:
12509: #if defined(LIBXML_HTTP_ENABLED)
12510: const char * URL; /* The proxy URL used to initialize the proxy context */
12511: int n_URL;
12512:
12513: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
12514: URL = gen_filepath(n_URL, 0);
12515:
12516: xmlNanoHTTPScanProxy(URL);
12517: call_tests++;
12518: des_filepath(n_URL, URL, 0);
12519: xmlResetLastError();
12520: }
12521: function_tests++;
12522: #endif
12523:
12524: return(test_ret);
12525: }
12526:
12527: static int
12528: test_nanohttp(void) {
12529: int test_ret = 0;
12530:
12531: if (quiet == 0) printf("Testing nanohttp : 13 of 17 functions ...\n");
12532: test_ret += test_xmlNanoHTTPAuthHeader();
12533: test_ret += test_xmlNanoHTTPCleanup();
12534: test_ret += test_xmlNanoHTTPContentLength();
12535: test_ret += test_xmlNanoHTTPEncoding();
12536: test_ret += test_xmlNanoHTTPFetch();
12537: test_ret += test_xmlNanoHTTPInit();
12538: test_ret += test_xmlNanoHTTPMimeType();
12539: test_ret += test_xmlNanoHTTPOpen();
12540: test_ret += test_xmlNanoHTTPOpenRedir();
12541: test_ret += test_xmlNanoHTTPRead();
12542: test_ret += test_xmlNanoHTTPRedir();
12543: test_ret += test_xmlNanoHTTPReturnCode();
12544: test_ret += test_xmlNanoHTTPSave();
12545: test_ret += test_xmlNanoHTTPScanProxy();
12546:
12547: if (test_ret != 0)
12548: printf("Module nanohttp: %d errors\n", test_ret);
12549: return(test_ret);
12550: }
12551:
12552: static int
12553: test_xmlByteConsumed(void) {
12554: int test_ret = 0;
12555:
12556: int mem_base;
12557: long ret_val;
12558: xmlParserCtxtPtr ctxt; /* an XML parser context */
12559: int n_ctxt;
12560:
12561: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
12562: mem_base = xmlMemBlocks();
12563: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
12564:
12565: ret_val = xmlByteConsumed(ctxt);
12566: desret_long(ret_val);
12567: call_tests++;
12568: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
12569: xmlResetLastError();
12570: if (mem_base != xmlMemBlocks()) {
12571: printf("Leak of %d blocks found in xmlByteConsumed",
12572: xmlMemBlocks() - mem_base);
12573: test_ret++;
12574: printf(" %d", n_ctxt);
12575: printf("\n");
12576: }
12577: }
12578: function_tests++;
12579:
12580: return(test_ret);
12581: }
12582:
12583:
12584: static int
12585: test_xmlClearNodeInfoSeq(void) {
12586: int test_ret = 0;
12587:
12588: int mem_base;
12589: xmlParserNodeInfoSeqPtr seq; /* a node info sequence pointer */
12590: int n_seq;
12591:
12592: for (n_seq = 0;n_seq < gen_nb_xmlParserNodeInfoSeqPtr;n_seq++) {
12593: mem_base = xmlMemBlocks();
12594: seq = gen_xmlParserNodeInfoSeqPtr(n_seq, 0);
12595:
12596: xmlClearNodeInfoSeq(seq);
12597: call_tests++;
12598: des_xmlParserNodeInfoSeqPtr(n_seq, seq, 0);
12599: xmlResetLastError();
12600: if (mem_base != xmlMemBlocks()) {
12601: printf("Leak of %d blocks found in xmlClearNodeInfoSeq",
12602: xmlMemBlocks() - mem_base);
12603: test_ret++;
12604: printf(" %d", n_seq);
12605: printf("\n");
12606: }
12607: }
12608: function_tests++;
12609:
12610: return(test_ret);
12611: }
12612:
12613:
12614: static int
12615: test_xmlClearParserCtxt(void) {
12616: int test_ret = 0;
12617:
12618: int mem_base;
12619: xmlParserCtxtPtr ctxt; /* an XML parser context */
12620: int n_ctxt;
12621:
12622: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
12623: mem_base = xmlMemBlocks();
12624: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
12625:
12626: xmlClearParserCtxt(ctxt);
12627: call_tests++;
12628: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
12629: xmlResetLastError();
12630: if (mem_base != xmlMemBlocks()) {
12631: printf("Leak of %d blocks found in xmlClearParserCtxt",
12632: xmlMemBlocks() - mem_base);
12633: test_ret++;
12634: printf(" %d", n_ctxt);
12635: printf("\n");
12636: }
12637: }
12638: function_tests++;
12639:
12640: return(test_ret);
12641: }
12642:
12643:
12644: static int
12645: test_xmlCreateDocParserCtxt(void) {
12646: int test_ret = 0;
12647:
12648: int mem_base;
12649: xmlParserCtxtPtr ret_val;
12650: xmlChar * cur; /* a pointer to an array of xmlChar */
12651: int n_cur;
12652:
12653: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
12654: mem_base = xmlMemBlocks();
12655: cur = gen_const_xmlChar_ptr(n_cur, 0);
12656:
12657: ret_val = xmlCreateDocParserCtxt((const xmlChar *)cur);
12658: desret_xmlParserCtxtPtr(ret_val);
12659: call_tests++;
12660: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
12661: xmlResetLastError();
12662: if (mem_base != xmlMemBlocks()) {
12663: printf("Leak of %d blocks found in xmlCreateDocParserCtxt",
12664: xmlMemBlocks() - mem_base);
12665: test_ret++;
12666: printf(" %d", n_cur);
12667: printf("\n");
12668: }
12669: }
12670: function_tests++;
12671:
12672: return(test_ret);
12673: }
12674:
12675:
12676: static int
12677: test_xmlCreatePushParserCtxt(void) {
12678: int test_ret = 0;
12679:
12680: #if defined(LIBXML_PUSH_ENABLED)
12681: int mem_base;
12682: xmlParserCtxtPtr ret_val;
12683: xmlSAXHandlerPtr sax; /* a SAX handler */
12684: int n_sax;
12685: void * user_data; /* The user data returned on SAX callbacks */
12686: int n_user_data;
12687: char * chunk; /* a pointer to an array of chars */
12688: int n_chunk;
12689: int size; /* number of chars in the array */
12690: int n_size;
12691: const char * filename; /* an optional file name or URI */
12692: int n_filename;
12693:
12694: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
12695: for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
12696: for (n_chunk = 0;n_chunk < gen_nb_const_char_ptr;n_chunk++) {
12697: for (n_size = 0;n_size < gen_nb_int;n_size++) {
12698: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
12699: mem_base = xmlMemBlocks();
12700: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
12701: user_data = gen_userdata(n_user_data, 1);
12702: chunk = gen_const_char_ptr(n_chunk, 2);
12703: size = gen_int(n_size, 3);
12704: filename = gen_fileoutput(n_filename, 4);
12705:
12706: ret_val = xmlCreatePushParserCtxt(sax, user_data, (const char *)chunk, size, filename);
12707: desret_xmlParserCtxtPtr(ret_val);
12708: call_tests++;
12709: des_xmlSAXHandlerPtr(n_sax, sax, 0);
12710: des_userdata(n_user_data, user_data, 1);
12711: des_const_char_ptr(n_chunk, (const char *)chunk, 2);
12712: des_int(n_size, size, 3);
12713: des_fileoutput(n_filename, filename, 4);
12714: xmlResetLastError();
12715: if (mem_base != xmlMemBlocks()) {
12716: printf("Leak of %d blocks found in xmlCreatePushParserCtxt",
12717: xmlMemBlocks() - mem_base);
12718: test_ret++;
12719: printf(" %d", n_sax);
12720: printf(" %d", n_user_data);
12721: printf(" %d", n_chunk);
12722: printf(" %d", n_size);
12723: printf(" %d", n_filename);
12724: printf("\n");
12725: }
12726: }
12727: }
12728: }
12729: }
12730: }
12731: function_tests++;
12732: #endif
12733:
12734: return(test_ret);
12735: }
12736:
12737:
12738: static int
12739: test_xmlCtxtReadDoc(void) {
12740: int test_ret = 0;
12741:
12742: int mem_base;
12743: xmlDocPtr ret_val;
12744: xmlParserCtxtPtr ctxt; /* an XML parser context */
12745: int n_ctxt;
12746: xmlChar * cur; /* a pointer to a zero terminated string */
12747: int n_cur;
12748: const char * URL; /* the base URL to use for the document */
12749: int n_URL;
12750: char * encoding; /* the document encoding, or NULL */
12751: int n_encoding;
12752: int options; /* a combination of xmlParserOption */
12753: int n_options;
12754:
12755: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
12756: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
12757: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
12758: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
12759: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
12760: mem_base = xmlMemBlocks();
12761: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
12762: cur = gen_const_xmlChar_ptr(n_cur, 1);
12763: URL = gen_filepath(n_URL, 2);
12764: encoding = gen_const_char_ptr(n_encoding, 3);
12765: options = gen_parseroptions(n_options, 4);
12766:
12767: ret_val = xmlCtxtReadDoc(ctxt, (const xmlChar *)cur, URL, (const char *)encoding, options);
12768: desret_xmlDocPtr(ret_val);
12769: call_tests++;
12770: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
12771: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 1);
12772: des_filepath(n_URL, URL, 2);
12773: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
12774: des_parseroptions(n_options, options, 4);
12775: xmlResetLastError();
12776: if (mem_base != xmlMemBlocks()) {
12777: printf("Leak of %d blocks found in xmlCtxtReadDoc",
12778: xmlMemBlocks() - mem_base);
12779: test_ret++;
12780: printf(" %d", n_ctxt);
12781: printf(" %d", n_cur);
12782: printf(" %d", n_URL);
12783: printf(" %d", n_encoding);
12784: printf(" %d", n_options);
12785: printf("\n");
12786: }
12787: }
12788: }
12789: }
12790: }
12791: }
12792: function_tests++;
12793:
12794: return(test_ret);
12795: }
12796:
12797:
12798: static int
12799: test_xmlCtxtReadFile(void) {
12800: int test_ret = 0;
12801:
12802: int mem_base;
12803: xmlDocPtr ret_val;
12804: xmlParserCtxtPtr ctxt; /* an XML parser context */
12805: int n_ctxt;
12806: const char * filename; /* a file or URL */
12807: int n_filename;
12808: char * encoding; /* the document encoding, or NULL */
12809: int n_encoding;
12810: int options; /* a combination of xmlParserOption */
12811: int n_options;
12812:
12813: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
12814: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
12815: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
12816: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
12817: mem_base = xmlMemBlocks();
12818: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
12819: filename = gen_filepath(n_filename, 1);
12820: encoding = gen_const_char_ptr(n_encoding, 2);
12821: options = gen_parseroptions(n_options, 3);
12822:
12823: ret_val = xmlCtxtReadFile(ctxt, filename, (const char *)encoding, options);
12824: desret_xmlDocPtr(ret_val);
12825: call_tests++;
12826: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
12827: des_filepath(n_filename, filename, 1);
12828: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
12829: des_parseroptions(n_options, options, 3);
12830: xmlResetLastError();
12831: if (mem_base != xmlMemBlocks()) {
12832: printf("Leak of %d blocks found in xmlCtxtReadFile",
12833: xmlMemBlocks() - mem_base);
12834: test_ret++;
12835: printf(" %d", n_ctxt);
12836: printf(" %d", n_filename);
12837: printf(" %d", n_encoding);
12838: printf(" %d", n_options);
12839: printf("\n");
12840: }
12841: }
12842: }
12843: }
12844: }
12845: function_tests++;
12846:
12847: return(test_ret);
12848: }
12849:
12850:
12851: static int
12852: test_xmlCtxtReadMemory(void) {
12853: int test_ret = 0;
12854:
12855: int mem_base;
12856: xmlDocPtr ret_val;
12857: xmlParserCtxtPtr ctxt; /* an XML parser context */
12858: int n_ctxt;
12859: char * buffer; /* a pointer to a char array */
12860: int n_buffer;
12861: int size; /* the size of the array */
12862: int n_size;
12863: const char * URL; /* the base URL to use for the document */
12864: int n_URL;
12865: char * encoding; /* the document encoding, or NULL */
12866: int n_encoding;
12867: int options; /* a combination of xmlParserOption */
12868: int n_options;
12869:
12870: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
12871: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
12872: for (n_size = 0;n_size < gen_nb_int;n_size++) {
12873: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
12874: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
12875: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
12876: mem_base = xmlMemBlocks();
12877: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
12878: buffer = gen_const_char_ptr(n_buffer, 1);
12879: size = gen_int(n_size, 2);
12880: URL = gen_filepath(n_URL, 3);
12881: encoding = gen_const_char_ptr(n_encoding, 4);
12882: options = gen_parseroptions(n_options, 5);
12883:
12884: ret_val = xmlCtxtReadMemory(ctxt, (const char *)buffer, size, URL, (const char *)encoding, options);
12885: desret_xmlDocPtr(ret_val);
12886: call_tests++;
12887: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
12888: des_const_char_ptr(n_buffer, (const char *)buffer, 1);
12889: des_int(n_size, size, 2);
12890: des_filepath(n_URL, URL, 3);
12891: des_const_char_ptr(n_encoding, (const char *)encoding, 4);
12892: des_parseroptions(n_options, options, 5);
12893: xmlResetLastError();
12894: if (mem_base != xmlMemBlocks()) {
12895: printf("Leak of %d blocks found in xmlCtxtReadMemory",
12896: xmlMemBlocks() - mem_base);
12897: test_ret++;
12898: printf(" %d", n_ctxt);
12899: printf(" %d", n_buffer);
12900: printf(" %d", n_size);
12901: printf(" %d", n_URL);
12902: printf(" %d", n_encoding);
12903: printf(" %d", n_options);
12904: printf("\n");
12905: }
12906: }
12907: }
12908: }
12909: }
12910: }
12911: }
12912: function_tests++;
12913:
12914: return(test_ret);
12915: }
12916:
12917:
12918: static int
12919: test_xmlCtxtReset(void) {
12920: int test_ret = 0;
12921:
12922: int mem_base;
12923: xmlParserCtxtPtr ctxt; /* an XML parser context */
12924: int n_ctxt;
12925:
12926: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
12927: mem_base = xmlMemBlocks();
12928: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
12929:
12930: xmlCtxtReset(ctxt);
12931: call_tests++;
12932: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
12933: xmlResetLastError();
12934: if (mem_base != xmlMemBlocks()) {
12935: printf("Leak of %d blocks found in xmlCtxtReset",
12936: xmlMemBlocks() - mem_base);
12937: test_ret++;
12938: printf(" %d", n_ctxt);
12939: printf("\n");
12940: }
12941: }
12942: function_tests++;
12943:
12944: return(test_ret);
12945: }
12946:
12947:
12948: static int
12949: test_xmlCtxtResetPush(void) {
12950: int test_ret = 0;
12951:
12952: int mem_base;
12953: int ret_val;
12954: xmlParserCtxtPtr ctxt; /* an XML parser context */
12955: int n_ctxt;
12956: char * chunk; /* a pointer to an array of chars */
12957: int n_chunk;
12958: int size; /* number of chars in the array */
12959: int n_size;
12960: const char * filename; /* an optional file name or URI */
12961: int n_filename;
12962: char * encoding; /* the document encoding, or NULL */
12963: int n_encoding;
12964:
12965: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
12966: for (n_chunk = 0;n_chunk < gen_nb_const_char_ptr;n_chunk++) {
12967: for (n_size = 0;n_size < gen_nb_int;n_size++) {
12968: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
12969: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
12970: mem_base = xmlMemBlocks();
12971: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
12972: chunk = gen_const_char_ptr(n_chunk, 1);
12973: size = gen_int(n_size, 2);
12974: filename = gen_filepath(n_filename, 3);
12975: encoding = gen_const_char_ptr(n_encoding, 4);
12976:
12977: ret_val = xmlCtxtResetPush(ctxt, (const char *)chunk, size, filename, (const char *)encoding);
12978: desret_int(ret_val);
12979: call_tests++;
12980: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
12981: des_const_char_ptr(n_chunk, (const char *)chunk, 1);
12982: des_int(n_size, size, 2);
12983: des_filepath(n_filename, filename, 3);
12984: des_const_char_ptr(n_encoding, (const char *)encoding, 4);
12985: xmlResetLastError();
12986: if (mem_base != xmlMemBlocks()) {
12987: printf("Leak of %d blocks found in xmlCtxtResetPush",
12988: xmlMemBlocks() - mem_base);
12989: test_ret++;
12990: printf(" %d", n_ctxt);
12991: printf(" %d", n_chunk);
12992: printf(" %d", n_size);
12993: printf(" %d", n_filename);
12994: printf(" %d", n_encoding);
12995: printf("\n");
12996: }
12997: }
12998: }
12999: }
13000: }
13001: }
13002: function_tests++;
13003:
13004: return(test_ret);
13005: }
13006:
13007:
13008: static int
13009: test_xmlCtxtUseOptions(void) {
13010: int test_ret = 0;
13011:
13012: int mem_base;
13013: int ret_val;
13014: xmlParserCtxtPtr ctxt; /* an XML parser context */
13015: int n_ctxt;
13016: int options; /* a combination of xmlParserOption */
13017: int n_options;
13018:
13019: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
13020: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
13021: mem_base = xmlMemBlocks();
13022: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
13023: options = gen_parseroptions(n_options, 1);
13024:
13025: ret_val = xmlCtxtUseOptions(ctxt, options);
13026: desret_int(ret_val);
13027: call_tests++;
13028: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
13029: des_parseroptions(n_options, options, 1);
13030: xmlResetLastError();
13031: if (mem_base != xmlMemBlocks()) {
13032: printf("Leak of %d blocks found in xmlCtxtUseOptions",
13033: xmlMemBlocks() - mem_base);
13034: test_ret++;
13035: printf(" %d", n_ctxt);
13036: printf(" %d", n_options);
13037: printf("\n");
13038: }
13039: }
13040: }
13041: function_tests++;
13042:
13043: return(test_ret);
13044: }
13045:
13046:
13047: static int
13048: test_xmlGetExternalEntityLoader(void) {
13049: int test_ret = 0;
13050:
13051:
13052: /* missing type support */
13053: return(test_ret);
13054: }
13055:
13056:
13057: static int
13058: test_xmlGetFeature(void) {
13059: int test_ret = 0;
13060:
13061: #if defined(LIBXML_LEGACY_ENABLED)
13062: #ifdef LIBXML_LEGACY_ENABLED
13063: int mem_base;
13064: int ret_val;
13065: xmlParserCtxtPtr ctxt; /* an XML/HTML parser context */
13066: int n_ctxt;
13067: char * name; /* the feature name */
13068: int n_name;
13069: void * result; /* location to store the result */
13070: int n_result;
13071:
13072: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
13073: for (n_name = 0;n_name < gen_nb_const_char_ptr;n_name++) {
13074: for (n_result = 0;n_result < gen_nb_void_ptr;n_result++) {
13075: mem_base = xmlMemBlocks();
13076: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
13077: name = gen_const_char_ptr(n_name, 1);
13078: result = gen_void_ptr(n_result, 2);
13079:
13080: ret_val = xmlGetFeature(ctxt, (const char *)name, result);
13081: desret_int(ret_val);
13082: call_tests++;
13083: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
13084: des_const_char_ptr(n_name, (const char *)name, 1);
13085: des_void_ptr(n_result, result, 2);
13086: xmlResetLastError();
13087: if (mem_base != xmlMemBlocks()) {
13088: printf("Leak of %d blocks found in xmlGetFeature",
13089: xmlMemBlocks() - mem_base);
13090: test_ret++;
13091: printf(" %d", n_ctxt);
13092: printf(" %d", n_name);
13093: printf(" %d", n_result);
13094: printf("\n");
13095: }
13096: }
13097: }
13098: }
13099: function_tests++;
13100: #endif
13101: #endif
13102:
13103: return(test_ret);
13104: }
13105:
13106:
13107: #define gen_nb_const_char_ptr_ptr 1
13108: static char ** gen_const_char_ptr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
13109: return(NULL);
13110: }
13111: static void des_const_char_ptr_ptr(int no ATTRIBUTE_UNUSED, const char ** val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
13112: }
13113:
13114: static int
13115: test_xmlGetFeaturesList(void) {
13116: int test_ret = 0;
13117:
13118: #if defined(LIBXML_LEGACY_ENABLED)
13119: #ifdef LIBXML_LEGACY_ENABLED
13120: int mem_base;
13121: int ret_val;
13122: int * len; /* the length of the features name array (input/output) */
13123: int n_len;
13124: char ** result; /* an array of string to be filled with the features name. */
13125: int n_result;
13126:
13127: for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
13128: for (n_result = 0;n_result < gen_nb_const_char_ptr_ptr;n_result++) {
13129: mem_base = xmlMemBlocks();
13130: len = gen_int_ptr(n_len, 0);
13131: result = gen_const_char_ptr_ptr(n_result, 1);
13132:
13133: ret_val = xmlGetFeaturesList(len, (const char **)result);
13134: desret_int(ret_val);
13135: call_tests++;
13136: des_int_ptr(n_len, len, 0);
13137: des_const_char_ptr_ptr(n_result, (const char **)result, 1);
13138: xmlResetLastError();
13139: if (mem_base != xmlMemBlocks()) {
13140: printf("Leak of %d blocks found in xmlGetFeaturesList",
13141: xmlMemBlocks() - mem_base);
13142: test_ret++;
13143: printf(" %d", n_len);
13144: printf(" %d", n_result);
13145: printf("\n");
13146: }
13147: }
13148: }
13149: function_tests++;
13150: #endif
13151: #endif
13152:
13153: return(test_ret);
13154: }
13155:
13156:
13157: static int
13158: test_xmlHasFeature(void) {
13159: int test_ret = 0;
13160:
13161: int mem_base;
13162: int ret_val;
13163: xmlFeature feature; /* the feature to be examined */
13164: int n_feature;
13165:
13166: for (n_feature = 0;n_feature < gen_nb_xmlFeature;n_feature++) {
13167: mem_base = xmlMemBlocks();
13168: feature = gen_xmlFeature(n_feature, 0);
13169:
13170: ret_val = xmlHasFeature(feature);
13171: desret_int(ret_val);
13172: call_tests++;
13173: des_xmlFeature(n_feature, feature, 0);
13174: xmlResetLastError();
13175: if (mem_base != xmlMemBlocks()) {
13176: printf("Leak of %d blocks found in xmlHasFeature",
13177: xmlMemBlocks() - mem_base);
13178: test_ret++;
13179: printf(" %d", n_feature);
13180: printf("\n");
13181: }
13182: }
13183: function_tests++;
13184:
13185: return(test_ret);
13186: }
13187:
13188:
13189: static int
13190: test_xmlIOParseDTD(void) {
13191: int test_ret = 0;
13192:
13193: #if defined(LIBXML_VALID_ENABLED)
13194: #ifdef LIBXML_VALID_ENABLED
13195: xmlDtdPtr ret_val;
13196: xmlSAXHandlerPtr sax; /* the SAX handler block or NULL */
13197: int n_sax;
13198: xmlParserInputBufferPtr input; /* an Input Buffer */
13199: int n_input;
13200: xmlCharEncoding enc; /* the charset encoding if known */
13201: int n_enc;
13202:
13203: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
13204: for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) {
13205: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
13206: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
13207: input = gen_xmlParserInputBufferPtr(n_input, 1);
13208: enc = gen_xmlCharEncoding(n_enc, 2);
13209:
13210: ret_val = xmlIOParseDTD(sax, input, enc);
13211: input = NULL;
13212: desret_xmlDtdPtr(ret_val);
13213: call_tests++;
13214: des_xmlSAXHandlerPtr(n_sax, sax, 0);
13215: des_xmlParserInputBufferPtr(n_input, input, 1);
13216: des_xmlCharEncoding(n_enc, enc, 2);
13217: xmlResetLastError();
13218: }
13219: }
13220: }
13221: function_tests++;
13222: #endif
13223: #endif
13224:
13225: return(test_ret);
13226: }
13227:
13228:
13229: static int
13230: test_xmlInitNodeInfoSeq(void) {
13231: int test_ret = 0;
13232:
13233: int mem_base;
13234: xmlParserNodeInfoSeqPtr seq; /* a node info sequence pointer */
13235: int n_seq;
13236:
13237: for (n_seq = 0;n_seq < gen_nb_xmlParserNodeInfoSeqPtr;n_seq++) {
13238: mem_base = xmlMemBlocks();
13239: seq = gen_xmlParserNodeInfoSeqPtr(n_seq, 0);
13240:
13241: xmlInitNodeInfoSeq(seq);
13242: call_tests++;
13243: des_xmlParserNodeInfoSeqPtr(n_seq, seq, 0);
13244: xmlResetLastError();
13245: if (mem_base != xmlMemBlocks()) {
13246: printf("Leak of %d blocks found in xmlInitNodeInfoSeq",
13247: xmlMemBlocks() - mem_base);
13248: test_ret++;
13249: printf(" %d", n_seq);
13250: printf("\n");
13251: }
13252: }
13253: function_tests++;
13254:
13255: return(test_ret);
13256: }
13257:
13258:
13259: static int
13260: test_xmlInitParser(void) {
13261: int test_ret = 0;
13262:
13263: int mem_base;
13264:
13265: mem_base = xmlMemBlocks();
13266:
13267: xmlInitParser();
13268: call_tests++;
13269: xmlResetLastError();
13270: if (mem_base != xmlMemBlocks()) {
13271: printf("Leak of %d blocks found in xmlInitParser",
13272: xmlMemBlocks() - mem_base);
13273: test_ret++;
13274: printf("\n");
13275: }
13276: function_tests++;
13277:
13278: return(test_ret);
13279: }
13280:
13281:
13282: static int
13283: test_xmlInitParserCtxt(void) {
13284: int test_ret = 0;
13285:
13286: int mem_base;
13287: int ret_val;
13288: xmlParserCtxtPtr ctxt; /* an XML parser context */
13289: int n_ctxt;
13290:
13291: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
13292: mem_base = xmlMemBlocks();
13293: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
13294:
13295: ret_val = xmlInitParserCtxt(ctxt);
13296: desret_int(ret_val);
13297: call_tests++;
13298: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
13299: xmlResetLastError();
13300: if (mem_base != xmlMemBlocks()) {
13301: printf("Leak of %d blocks found in xmlInitParserCtxt",
13302: xmlMemBlocks() - mem_base);
13303: test_ret++;
13304: printf(" %d", n_ctxt);
13305: printf("\n");
13306: }
13307: }
13308: function_tests++;
13309:
13310: return(test_ret);
13311: }
13312:
13313:
13314: static int
13315: test_xmlKeepBlanksDefault(void) {
13316: int test_ret = 0;
13317:
13318: int mem_base;
13319: int ret_val;
13320: int val; /* int 0 or 1 */
13321: int n_val;
13322:
13323: for (n_val = 0;n_val < gen_nb_int;n_val++) {
13324: mem_base = xmlMemBlocks();
13325: val = gen_int(n_val, 0);
13326:
13327: ret_val = xmlKeepBlanksDefault(val);
13328: desret_int(ret_val);
13329: call_tests++;
13330: des_int(n_val, val, 0);
13331: xmlResetLastError();
13332: if (mem_base != xmlMemBlocks()) {
13333: printf("Leak of %d blocks found in xmlKeepBlanksDefault",
13334: xmlMemBlocks() - mem_base);
13335: test_ret++;
13336: printf(" %d", n_val);
13337: printf("\n");
13338: }
13339: }
13340: function_tests++;
13341:
13342: return(test_ret);
13343: }
13344:
13345:
13346: static int
13347: test_xmlLineNumbersDefault(void) {
13348: int test_ret = 0;
13349:
13350: int mem_base;
13351: int ret_val;
13352: int val; /* int 0 or 1 */
13353: int n_val;
13354:
13355: for (n_val = 0;n_val < gen_nb_int;n_val++) {
13356: mem_base = xmlMemBlocks();
13357: val = gen_int(n_val, 0);
13358:
13359: ret_val = xmlLineNumbersDefault(val);
13360: desret_int(ret_val);
13361: call_tests++;
13362: des_int(n_val, val, 0);
13363: xmlResetLastError();
13364: if (mem_base != xmlMemBlocks()) {
13365: printf("Leak of %d blocks found in xmlLineNumbersDefault",
13366: xmlMemBlocks() - mem_base);
13367: test_ret++;
13368: printf(" %d", n_val);
13369: printf("\n");
13370: }
13371: }
13372: function_tests++;
13373:
13374: return(test_ret);
13375: }
13376:
13377:
13378: static int
13379: test_xmlLoadExternalEntity(void) {
13380: int test_ret = 0;
13381:
13382: int mem_base;
13383: xmlParserInputPtr ret_val;
13384: const char * URL; /* the URL for the entity to load */
13385: int n_URL;
13386: char * ID; /* the Public ID for the entity to load */
13387: int n_ID;
13388: xmlParserCtxtPtr ctxt; /* the context in which the entity is called or NULL */
13389: int n_ctxt;
13390:
13391: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
13392: for (n_ID = 0;n_ID < gen_nb_const_char_ptr;n_ID++) {
13393: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
13394: mem_base = xmlMemBlocks();
13395: URL = gen_filepath(n_URL, 0);
13396: ID = gen_const_char_ptr(n_ID, 1);
13397: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 2);
13398:
13399: ret_val = xmlLoadExternalEntity(URL, (const char *)ID, ctxt);
13400: desret_xmlParserInputPtr(ret_val);
13401: call_tests++;
13402: des_filepath(n_URL, URL, 0);
13403: des_const_char_ptr(n_ID, (const char *)ID, 1);
13404: des_xmlParserCtxtPtr(n_ctxt, ctxt, 2);
13405: xmlResetLastError();
13406: if (mem_base != xmlMemBlocks()) {
13407: printf("Leak of %d blocks found in xmlLoadExternalEntity",
13408: xmlMemBlocks() - mem_base);
13409: test_ret++;
13410: printf(" %d", n_URL);
13411: printf(" %d", n_ID);
13412: printf(" %d", n_ctxt);
13413: printf("\n");
13414: }
13415: }
13416: }
13417: }
13418: function_tests++;
13419:
13420: return(test_ret);
13421: }
13422:
13423:
13424: static int
13425: test_xmlNewIOInputStream(void) {
13426: int test_ret = 0;
13427:
13428: int mem_base;
13429: xmlParserInputPtr ret_val;
13430: xmlParserCtxtPtr ctxt; /* an XML parser context */
13431: int n_ctxt;
13432: xmlParserInputBufferPtr input; /* an I/O Input */
13433: int n_input;
13434: xmlCharEncoding enc; /* the charset encoding if known */
13435: int n_enc;
13436:
13437: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
13438: for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) {
13439: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
13440: mem_base = xmlMemBlocks();
13441: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
13442: input = gen_xmlParserInputBufferPtr(n_input, 1);
13443: enc = gen_xmlCharEncoding(n_enc, 2);
13444:
13445: ret_val = xmlNewIOInputStream(ctxt, input, enc);
13446: if (ret_val != NULL) input = NULL;
13447: desret_xmlParserInputPtr(ret_val);
13448: call_tests++;
13449: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
13450: des_xmlParserInputBufferPtr(n_input, input, 1);
13451: des_xmlCharEncoding(n_enc, enc, 2);
13452: xmlResetLastError();
13453: if (mem_base != xmlMemBlocks()) {
13454: printf("Leak of %d blocks found in xmlNewIOInputStream",
13455: xmlMemBlocks() - mem_base);
13456: test_ret++;
13457: printf(" %d", n_ctxt);
13458: printf(" %d", n_input);
13459: printf(" %d", n_enc);
13460: printf("\n");
13461: }
13462: }
13463: }
13464: }
13465: function_tests++;
13466:
13467: return(test_ret);
13468: }
13469:
13470:
13471: static int
13472: test_xmlNewParserCtxt(void) {
13473: int test_ret = 0;
13474:
13475: int mem_base;
13476: xmlParserCtxtPtr ret_val;
13477:
13478: mem_base = xmlMemBlocks();
13479:
13480: ret_val = xmlNewParserCtxt();
13481: desret_xmlParserCtxtPtr(ret_val);
13482: call_tests++;
13483: xmlResetLastError();
13484: if (mem_base != xmlMemBlocks()) {
13485: printf("Leak of %d blocks found in xmlNewParserCtxt",
13486: xmlMemBlocks() - mem_base);
13487: test_ret++;
13488: printf("\n");
13489: }
13490: function_tests++;
13491:
13492: return(test_ret);
13493: }
13494:
13495:
13496: #define gen_nb_xmlNodePtr_ptr 1
13497: static xmlNodePtr * gen_xmlNodePtr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
13498: return(NULL);
13499: }
13500: static void des_xmlNodePtr_ptr(int no ATTRIBUTE_UNUSED, xmlNodePtr * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
13501: }
13502:
13503: static int
13504: test_xmlParseBalancedChunkMemory(void) {
13505: int test_ret = 0;
13506:
13507: #if defined(LIBXML_SAX1_ENABLED)
13508: #ifdef LIBXML_SAX1_ENABLED
13509: int mem_base;
13510: int ret_val;
13511: xmlDocPtr doc; /* the document the chunk pertains to */
13512: int n_doc;
13513: xmlSAXHandlerPtr sax; /* the SAX handler bloc (possibly NULL) */
13514: int n_sax;
13515: void * user_data; /* The user data returned on SAX callbacks (possibly NULL) */
13516: int n_user_data;
13517: int depth; /* Used for loop detection, use 0 */
13518: int n_depth;
13519: xmlChar * string; /* the input string in UTF8 or ISO-Latin (zero terminated) */
13520: int n_string;
13521: xmlNodePtr * lst; /* the return value for the set of parsed nodes */
13522: int n_lst;
13523:
13524: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
13525: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
13526: for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
13527: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
13528: for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) {
13529: for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) {
13530: mem_base = xmlMemBlocks();
13531: doc = gen_xmlDocPtr(n_doc, 0);
13532: sax = gen_xmlSAXHandlerPtr(n_sax, 1);
13533: user_data = gen_userdata(n_user_data, 2);
13534: depth = gen_int(n_depth, 3);
13535: string = gen_const_xmlChar_ptr(n_string, 4);
13536: lst = gen_xmlNodePtr_ptr(n_lst, 5);
13537:
13538: #ifdef LIBXML_SAX1_ENABLED
13539: if (sax == (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) user_data = NULL;
13540: #endif
13541:
13542:
13543: ret_val = xmlParseBalancedChunkMemory(doc, sax, user_data, depth, (const xmlChar *)string, lst);
13544: desret_int(ret_val);
13545: call_tests++;
13546: des_xmlDocPtr(n_doc, doc, 0);
13547: des_xmlSAXHandlerPtr(n_sax, sax, 1);
13548: des_userdata(n_user_data, user_data, 2);
13549: des_int(n_depth, depth, 3);
13550: des_const_xmlChar_ptr(n_string, (const xmlChar *)string, 4);
13551: des_xmlNodePtr_ptr(n_lst, lst, 5);
13552: xmlResetLastError();
13553: if (mem_base != xmlMemBlocks()) {
13554: printf("Leak of %d blocks found in xmlParseBalancedChunkMemory",
13555: xmlMemBlocks() - mem_base);
13556: test_ret++;
13557: printf(" %d", n_doc);
13558: printf(" %d", n_sax);
13559: printf(" %d", n_user_data);
13560: printf(" %d", n_depth);
13561: printf(" %d", n_string);
13562: printf(" %d", n_lst);
13563: printf("\n");
13564: }
13565: }
13566: }
13567: }
13568: }
13569: }
13570: }
13571: function_tests++;
13572: #endif
13573: #endif
13574:
13575: return(test_ret);
13576: }
13577:
13578:
13579: static int
13580: test_xmlParseBalancedChunkMemoryRecover(void) {
13581: int test_ret = 0;
13582:
13583: #if defined(LIBXML_SAX1_ENABLED)
13584: #ifdef LIBXML_SAX1_ENABLED
13585: int mem_base;
13586: int ret_val;
13587: xmlDocPtr doc; /* the document the chunk pertains to */
13588: int n_doc;
13589: xmlSAXHandlerPtr sax; /* the SAX handler bloc (possibly NULL) */
13590: int n_sax;
13591: void * user_data; /* The user data returned on SAX callbacks (possibly NULL) */
13592: int n_user_data;
13593: int depth; /* Used for loop detection, use 0 */
13594: int n_depth;
13595: xmlChar * string; /* the input string in UTF8 or ISO-Latin (zero terminated) */
13596: int n_string;
13597: xmlNodePtr * lst; /* the return value for the set of parsed nodes */
13598: int n_lst;
13599: int recover; /* return nodes even if the data is broken (use 0) */
13600: int n_recover;
13601:
13602: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
13603: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
13604: for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
13605: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
13606: for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) {
13607: for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) {
13608: for (n_recover = 0;n_recover < gen_nb_int;n_recover++) {
13609: mem_base = xmlMemBlocks();
13610: doc = gen_xmlDocPtr(n_doc, 0);
13611: sax = gen_xmlSAXHandlerPtr(n_sax, 1);
13612: user_data = gen_userdata(n_user_data, 2);
13613: depth = gen_int(n_depth, 3);
13614: string = gen_const_xmlChar_ptr(n_string, 4);
13615: lst = gen_xmlNodePtr_ptr(n_lst, 5);
13616: recover = gen_int(n_recover, 6);
13617:
13618: #ifdef LIBXML_SAX1_ENABLED
13619: if (sax == (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) user_data = NULL;
13620: #endif
13621:
13622:
13623: ret_val = xmlParseBalancedChunkMemoryRecover(doc, sax, user_data, depth, (const xmlChar *)string, lst, recover);
13624: desret_int(ret_val);
13625: call_tests++;
13626: des_xmlDocPtr(n_doc, doc, 0);
13627: des_xmlSAXHandlerPtr(n_sax, sax, 1);
13628: des_userdata(n_user_data, user_data, 2);
13629: des_int(n_depth, depth, 3);
13630: des_const_xmlChar_ptr(n_string, (const xmlChar *)string, 4);
13631: des_xmlNodePtr_ptr(n_lst, lst, 5);
13632: des_int(n_recover, recover, 6);
13633: xmlResetLastError();
13634: if (mem_base != xmlMemBlocks()) {
13635: printf("Leak of %d blocks found in xmlParseBalancedChunkMemoryRecover",
13636: xmlMemBlocks() - mem_base);
13637: test_ret++;
13638: printf(" %d", n_doc);
13639: printf(" %d", n_sax);
13640: printf(" %d", n_user_data);
13641: printf(" %d", n_depth);
13642: printf(" %d", n_string);
13643: printf(" %d", n_lst);
13644: printf(" %d", n_recover);
13645: printf("\n");
13646: }
13647: }
13648: }
13649: }
13650: }
13651: }
13652: }
13653: }
13654: function_tests++;
13655: #endif
13656: #endif
13657:
13658: return(test_ret);
13659: }
13660:
13661:
13662: static int
13663: test_xmlParseChunk(void) {
13664: int test_ret = 0;
13665:
13666: #if defined(LIBXML_PUSH_ENABLED)
13667: int mem_base;
13668: int ret_val;
13669: xmlParserCtxtPtr ctxt; /* an XML parser context */
13670: int n_ctxt;
13671: char * chunk; /* an char array */
13672: int n_chunk;
13673: int size; /* the size in byte of the chunk */
13674: int n_size;
13675: int terminate; /* last chunk indicator */
13676: int n_terminate;
13677:
13678: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
13679: for (n_chunk = 0;n_chunk < gen_nb_const_char_ptr;n_chunk++) {
13680: for (n_size = 0;n_size < gen_nb_int;n_size++) {
13681: for (n_terminate = 0;n_terminate < gen_nb_int;n_terminate++) {
13682: mem_base = xmlMemBlocks();
13683: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
13684: chunk = gen_const_char_ptr(n_chunk, 1);
13685: size = gen_int(n_size, 2);
13686: terminate = gen_int(n_terminate, 3);
13687:
13688: ret_val = xmlParseChunk(ctxt, (const char *)chunk, size, terminate);
13689: if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;}
13690: desret_int(ret_val);
13691: call_tests++;
13692: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
13693: des_const_char_ptr(n_chunk, (const char *)chunk, 1);
13694: des_int(n_size, size, 2);
13695: des_int(n_terminate, terminate, 3);
13696: xmlResetLastError();
13697: if (mem_base != xmlMemBlocks()) {
13698: printf("Leak of %d blocks found in xmlParseChunk",
13699: xmlMemBlocks() - mem_base);
13700: test_ret++;
13701: printf(" %d", n_ctxt);
13702: printf(" %d", n_chunk);
13703: printf(" %d", n_size);
13704: printf(" %d", n_terminate);
13705: printf("\n");
13706: }
13707: }
13708: }
13709: }
13710: }
13711: function_tests++;
13712: #endif
13713:
13714: return(test_ret);
13715: }
13716:
13717:
13718: static int
13719: test_xmlParseCtxtExternalEntity(void) {
13720: int test_ret = 0;
13721:
13722: int mem_base;
13723: int ret_val;
13724: xmlParserCtxtPtr ctx; /* the existing parsing context */
13725: int n_ctx;
13726: xmlChar * URL; /* the URL for the entity to load */
13727: int n_URL;
13728: xmlChar * ID; /* the System ID for the entity to load */
13729: int n_ID;
13730: xmlNodePtr * lst; /* the return value for the set of parsed nodes */
13731: int n_lst;
13732:
13733: for (n_ctx = 0;n_ctx < gen_nb_xmlParserCtxtPtr;n_ctx++) {
13734: for (n_URL = 0;n_URL < gen_nb_const_xmlChar_ptr;n_URL++) {
13735: for (n_ID = 0;n_ID < gen_nb_const_xmlChar_ptr;n_ID++) {
13736: for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) {
13737: mem_base = xmlMemBlocks();
13738: ctx = gen_xmlParserCtxtPtr(n_ctx, 0);
13739: URL = gen_const_xmlChar_ptr(n_URL, 1);
13740: ID = gen_const_xmlChar_ptr(n_ID, 2);
13741: lst = gen_xmlNodePtr_ptr(n_lst, 3);
13742:
13743: ret_val = xmlParseCtxtExternalEntity(ctx, (const xmlChar *)URL, (const xmlChar *)ID, lst);
13744: desret_int(ret_val);
13745: call_tests++;
13746: des_xmlParserCtxtPtr(n_ctx, ctx, 0);
13747: des_const_xmlChar_ptr(n_URL, (const xmlChar *)URL, 1);
13748: des_const_xmlChar_ptr(n_ID, (const xmlChar *)ID, 2);
13749: des_xmlNodePtr_ptr(n_lst, lst, 3);
13750: xmlResetLastError();
13751: if (mem_base != xmlMemBlocks()) {
13752: printf("Leak of %d blocks found in xmlParseCtxtExternalEntity",
13753: xmlMemBlocks() - mem_base);
13754: test_ret++;
13755: printf(" %d", n_ctx);
13756: printf(" %d", n_URL);
13757: printf(" %d", n_ID);
13758: printf(" %d", n_lst);
13759: printf("\n");
13760: }
13761: }
13762: }
13763: }
13764: }
13765: function_tests++;
13766:
13767: return(test_ret);
13768: }
13769:
13770:
13771: static int
13772: test_xmlParseDTD(void) {
13773: int test_ret = 0;
13774:
13775: #if defined(LIBXML_VALID_ENABLED)
13776: #ifdef LIBXML_VALID_ENABLED
13777: int mem_base;
13778: xmlDtdPtr ret_val;
13779: xmlChar * ExternalID; /* a NAME* containing the External ID of the DTD */
13780: int n_ExternalID;
13781: xmlChar * SystemID; /* a NAME* containing the URL to the DTD */
13782: int n_SystemID;
13783:
13784: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
13785: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
13786: mem_base = xmlMemBlocks();
13787: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 0);
13788: SystemID = gen_const_xmlChar_ptr(n_SystemID, 1);
13789:
13790: ret_val = xmlParseDTD((const xmlChar *)ExternalID, (const xmlChar *)SystemID);
13791: desret_xmlDtdPtr(ret_val);
13792: call_tests++;
13793: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 0);
13794: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 1);
13795: xmlResetLastError();
13796: if (mem_base != xmlMemBlocks()) {
13797: printf("Leak of %d blocks found in xmlParseDTD",
13798: xmlMemBlocks() - mem_base);
13799: test_ret++;
13800: printf(" %d", n_ExternalID);
13801: printf(" %d", n_SystemID);
13802: printf("\n");
13803: }
13804: }
13805: }
13806: function_tests++;
13807: #endif
13808: #endif
13809:
13810: return(test_ret);
13811: }
13812:
13813:
13814: static int
13815: test_xmlParseDoc(void) {
13816: int test_ret = 0;
13817:
13818: #if defined(LIBXML_SAX1_ENABLED)
13819: #ifdef LIBXML_SAX1_ENABLED
13820: int mem_base;
13821: xmlDocPtr ret_val;
13822: xmlChar * cur; /* a pointer to an array of xmlChar */
13823: int n_cur;
13824:
13825: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
13826: mem_base = xmlMemBlocks();
13827: cur = gen_const_xmlChar_ptr(n_cur, 0);
13828:
13829: ret_val = xmlParseDoc((const xmlChar *)cur);
13830: desret_xmlDocPtr(ret_val);
13831: call_tests++;
13832: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
13833: xmlResetLastError();
13834: if (mem_base != xmlMemBlocks()) {
13835: printf("Leak of %d blocks found in xmlParseDoc",
13836: xmlMemBlocks() - mem_base);
13837: test_ret++;
13838: printf(" %d", n_cur);
13839: printf("\n");
13840: }
13841: }
13842: function_tests++;
13843: #endif
13844: #endif
13845:
13846: return(test_ret);
13847: }
13848:
13849:
13850: static int
13851: test_xmlParseDocument(void) {
13852: int test_ret = 0;
13853:
13854: int mem_base;
13855: int ret_val;
13856: xmlParserCtxtPtr ctxt; /* an XML parser context */
13857: int n_ctxt;
13858:
13859: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
13860: mem_base = xmlMemBlocks();
13861: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
13862:
13863: ret_val = xmlParseDocument(ctxt);
13864: if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;}
13865: desret_int(ret_val);
13866: call_tests++;
13867: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
13868: xmlResetLastError();
13869: if (mem_base != xmlMemBlocks()) {
13870: printf("Leak of %d blocks found in xmlParseDocument",
13871: xmlMemBlocks() - mem_base);
13872: test_ret++;
13873: printf(" %d", n_ctxt);
13874: printf("\n");
13875: }
13876: }
13877: function_tests++;
13878:
13879: return(test_ret);
13880: }
13881:
13882:
13883: static int
13884: test_xmlParseEntity(void) {
13885: int test_ret = 0;
13886:
13887: #if defined(LIBXML_SAX1_ENABLED)
13888: #ifdef LIBXML_SAX1_ENABLED
13889: int mem_base;
13890: xmlDocPtr ret_val;
13891: const char * filename; /* the filename */
13892: int n_filename;
13893:
13894: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
13895: mem_base = xmlMemBlocks();
13896: filename = gen_filepath(n_filename, 0);
13897:
13898: ret_val = xmlParseEntity(filename);
13899: desret_xmlDocPtr(ret_val);
13900: call_tests++;
13901: des_filepath(n_filename, filename, 0);
13902: xmlResetLastError();
13903: if (mem_base != xmlMemBlocks()) {
13904: printf("Leak of %d blocks found in xmlParseEntity",
13905: xmlMemBlocks() - mem_base);
13906: test_ret++;
13907: printf(" %d", n_filename);
13908: printf("\n");
13909: }
13910: }
13911: function_tests++;
13912: #endif
13913: #endif
13914:
13915: return(test_ret);
13916: }
13917:
13918:
13919: static int
13920: test_xmlParseExtParsedEnt(void) {
13921: int test_ret = 0;
13922:
13923: int mem_base;
13924: int ret_val;
13925: xmlParserCtxtPtr ctxt; /* an XML parser context */
13926: int n_ctxt;
13927:
13928: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
13929: mem_base = xmlMemBlocks();
13930: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
13931:
13932: ret_val = xmlParseExtParsedEnt(ctxt);
13933: if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;}
13934: desret_int(ret_val);
13935: call_tests++;
13936: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
13937: xmlResetLastError();
13938: if (mem_base != xmlMemBlocks()) {
13939: printf("Leak of %d blocks found in xmlParseExtParsedEnt",
13940: xmlMemBlocks() - mem_base);
13941: test_ret++;
13942: printf(" %d", n_ctxt);
13943: printf("\n");
13944: }
13945: }
13946: function_tests++;
13947:
13948: return(test_ret);
13949: }
13950:
13951:
13952: static int
13953: test_xmlParseExternalEntity(void) {
13954: int test_ret = 0;
13955:
13956: #if defined(LIBXML_SAX1_ENABLED)
13957: #ifdef LIBXML_SAX1_ENABLED
13958: int mem_base;
13959: int ret_val;
13960: xmlDocPtr doc; /* the document the chunk pertains to */
13961: int n_doc;
13962: xmlSAXHandlerPtr sax; /* the SAX handler bloc (possibly NULL) */
13963: int n_sax;
13964: void * user_data; /* The user data returned on SAX callbacks (possibly NULL) */
13965: int n_user_data;
13966: int depth; /* Used for loop detection, use 0 */
13967: int n_depth;
13968: xmlChar * URL; /* the URL for the entity to load */
13969: int n_URL;
13970: xmlChar * ID; /* the System ID for the entity to load */
13971: int n_ID;
13972: xmlNodePtr * lst; /* the return value for the set of parsed nodes */
13973: int n_lst;
13974:
13975: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
13976: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
13977: for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
13978: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
13979: for (n_URL = 0;n_URL < gen_nb_const_xmlChar_ptr;n_URL++) {
13980: for (n_ID = 0;n_ID < gen_nb_const_xmlChar_ptr;n_ID++) {
13981: for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) {
13982: mem_base = xmlMemBlocks();
13983: doc = gen_xmlDocPtr(n_doc, 0);
13984: sax = gen_xmlSAXHandlerPtr(n_sax, 1);
13985: user_data = gen_userdata(n_user_data, 2);
13986: depth = gen_int(n_depth, 3);
13987: URL = gen_const_xmlChar_ptr(n_URL, 4);
13988: ID = gen_const_xmlChar_ptr(n_ID, 5);
13989: lst = gen_xmlNodePtr_ptr(n_lst, 6);
13990:
13991: ret_val = xmlParseExternalEntity(doc, sax, user_data, depth, (const xmlChar *)URL, (const xmlChar *)ID, lst);
13992: desret_int(ret_val);
13993: call_tests++;
13994: des_xmlDocPtr(n_doc, doc, 0);
13995: des_xmlSAXHandlerPtr(n_sax, sax, 1);
13996: des_userdata(n_user_data, user_data, 2);
13997: des_int(n_depth, depth, 3);
13998: des_const_xmlChar_ptr(n_URL, (const xmlChar *)URL, 4);
13999: des_const_xmlChar_ptr(n_ID, (const xmlChar *)ID, 5);
14000: des_xmlNodePtr_ptr(n_lst, lst, 6);
14001: xmlResetLastError();
14002: if (mem_base != xmlMemBlocks()) {
14003: printf("Leak of %d blocks found in xmlParseExternalEntity",
14004: xmlMemBlocks() - mem_base);
14005: test_ret++;
14006: printf(" %d", n_doc);
14007: printf(" %d", n_sax);
14008: printf(" %d", n_user_data);
14009: printf(" %d", n_depth);
14010: printf(" %d", n_URL);
14011: printf(" %d", n_ID);
14012: printf(" %d", n_lst);
14013: printf("\n");
14014: }
14015: }
14016: }
14017: }
14018: }
14019: }
14020: }
14021: }
14022: function_tests++;
14023: #endif
14024: #endif
14025:
14026: return(test_ret);
14027: }
14028:
14029:
14030: static int
14031: test_xmlParseFile(void) {
14032: int test_ret = 0;
14033:
14034: #if defined(LIBXML_SAX1_ENABLED)
14035: #ifdef LIBXML_SAX1_ENABLED
14036: int mem_base;
14037: xmlDocPtr ret_val;
14038: const char * filename; /* the filename */
14039: int n_filename;
14040:
14041: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
14042: mem_base = xmlMemBlocks();
14043: filename = gen_filepath(n_filename, 0);
14044:
14045: ret_val = xmlParseFile(filename);
14046: desret_xmlDocPtr(ret_val);
14047: call_tests++;
14048: des_filepath(n_filename, filename, 0);
14049: xmlResetLastError();
14050: if (mem_base != xmlMemBlocks()) {
14051: printf("Leak of %d blocks found in xmlParseFile",
14052: xmlMemBlocks() - mem_base);
14053: test_ret++;
14054: printf(" %d", n_filename);
14055: printf("\n");
14056: }
14057: }
14058: function_tests++;
14059: #endif
14060: #endif
14061:
14062: return(test_ret);
14063: }
14064:
14065:
14066: static int
14067: test_xmlParseInNodeContext(void) {
14068: int test_ret = 0;
14069:
14070: int mem_base;
14071: xmlParserErrors ret_val;
14072: xmlNodePtr node; /* the context node */
14073: int n_node;
14074: char * data; /* the input string */
14075: int n_data;
14076: int datalen; /* the input string length in bytes */
14077: int n_datalen;
14078: int options; /* a combination of xmlParserOption */
14079: int n_options;
14080: xmlNodePtr * lst; /* the return value for the set of parsed nodes */
14081: int n_lst;
14082:
14083: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
14084: for (n_data = 0;n_data < gen_nb_const_char_ptr;n_data++) {
14085: for (n_datalen = 0;n_datalen < gen_nb_int;n_datalen++) {
14086: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
14087: for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) {
14088: mem_base = xmlMemBlocks();
14089: node = gen_xmlNodePtr(n_node, 0);
14090: data = gen_const_char_ptr(n_data, 1);
14091: datalen = gen_int(n_datalen, 2);
14092: options = gen_parseroptions(n_options, 3);
14093: lst = gen_xmlNodePtr_ptr(n_lst, 4);
14094:
14095: ret_val = xmlParseInNodeContext(node, (const char *)data, datalen, options, lst);
14096: desret_xmlParserErrors(ret_val);
14097: call_tests++;
14098: des_xmlNodePtr(n_node, node, 0);
14099: des_const_char_ptr(n_data, (const char *)data, 1);
14100: des_int(n_datalen, datalen, 2);
14101: des_parseroptions(n_options, options, 3);
14102: des_xmlNodePtr_ptr(n_lst, lst, 4);
14103: xmlResetLastError();
14104: if (mem_base != xmlMemBlocks()) {
14105: printf("Leak of %d blocks found in xmlParseInNodeContext",
14106: xmlMemBlocks() - mem_base);
14107: test_ret++;
14108: printf(" %d", n_node);
14109: printf(" %d", n_data);
14110: printf(" %d", n_datalen);
14111: printf(" %d", n_options);
14112: printf(" %d", n_lst);
14113: printf("\n");
14114: }
14115: }
14116: }
14117: }
14118: }
14119: }
14120: function_tests++;
14121:
14122: return(test_ret);
14123: }
14124:
14125:
14126: static int
14127: test_xmlParseMemory(void) {
14128: int test_ret = 0;
14129:
14130: #if defined(LIBXML_SAX1_ENABLED)
14131: #ifdef LIBXML_SAX1_ENABLED
14132: int mem_base;
14133: xmlDocPtr ret_val;
14134: char * buffer; /* an pointer to a char array */
14135: int n_buffer;
14136: int size; /* the size of the array */
14137: int n_size;
14138:
14139: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
14140: for (n_size = 0;n_size < gen_nb_int;n_size++) {
14141: mem_base = xmlMemBlocks();
14142: buffer = gen_const_char_ptr(n_buffer, 0);
14143: size = gen_int(n_size, 1);
14144:
14145: ret_val = xmlParseMemory((const char *)buffer, size);
14146: desret_xmlDocPtr(ret_val);
14147: call_tests++;
14148: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
14149: des_int(n_size, size, 1);
14150: xmlResetLastError();
14151: if (mem_base != xmlMemBlocks()) {
14152: printf("Leak of %d blocks found in xmlParseMemory",
14153: xmlMemBlocks() - mem_base);
14154: test_ret++;
14155: printf(" %d", n_buffer);
14156: printf(" %d", n_size);
14157: printf("\n");
14158: }
14159: }
14160: }
14161: function_tests++;
14162: #endif
14163: #endif
14164:
14165: return(test_ret);
14166: }
14167:
14168:
14169: #define gen_nb_const_xmlParserNodeInfoPtr 1
14170: static xmlParserNodeInfoPtr gen_const_xmlParserNodeInfoPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14171: return(NULL);
14172: }
14173: static void des_const_xmlParserNodeInfoPtr(int no ATTRIBUTE_UNUSED, const xmlParserNodeInfoPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14174: }
14175:
14176: static int
14177: test_xmlParserAddNodeInfo(void) {
14178: int test_ret = 0;
14179:
14180: int mem_base;
14181: xmlParserCtxtPtr ctxt; /* an XML parser context */
14182: int n_ctxt;
14183: xmlParserNodeInfoPtr info; /* a node info sequence pointer */
14184: int n_info;
14185:
14186: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
14187: for (n_info = 0;n_info < gen_nb_const_xmlParserNodeInfoPtr;n_info++) {
14188: mem_base = xmlMemBlocks();
14189: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
14190: info = gen_const_xmlParserNodeInfoPtr(n_info, 1);
14191:
14192: xmlParserAddNodeInfo(ctxt, (const xmlParserNodeInfoPtr)info);
14193: call_tests++;
14194: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
14195: des_const_xmlParserNodeInfoPtr(n_info, (const xmlParserNodeInfoPtr)info, 1);
14196: xmlResetLastError();
14197: if (mem_base != xmlMemBlocks()) {
14198: printf("Leak of %d blocks found in xmlParserAddNodeInfo",
14199: xmlMemBlocks() - mem_base);
14200: test_ret++;
14201: printf(" %d", n_ctxt);
14202: printf(" %d", n_info);
14203: printf("\n");
14204: }
14205: }
14206: }
14207: function_tests++;
14208:
14209: return(test_ret);
14210: }
14211:
14212:
14213: #define gen_nb_const_xmlParserCtxtPtr 1
14214: static xmlParserCtxtPtr gen_const_xmlParserCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14215: return(NULL);
14216: }
14217: static void des_const_xmlParserCtxtPtr(int no ATTRIBUTE_UNUSED, const xmlParserCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14218: }
14219:
14220: #define gen_nb_const_xmlNodePtr 1
14221: static xmlNodePtr gen_const_xmlNodePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14222: return(NULL);
14223: }
14224: static void des_const_xmlNodePtr(int no ATTRIBUTE_UNUSED, const xmlNodePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14225: }
14226:
14227: static int
14228: test_xmlParserFindNodeInfo(void) {
14229: int test_ret = 0;
14230:
14231: int mem_base;
14232: const xmlParserNodeInfo * ret_val;
14233: xmlParserCtxtPtr ctx; /* an XML parser context */
14234: int n_ctx;
14235: xmlNodePtr node; /* an XML node within the tree */
14236: int n_node;
14237:
14238: for (n_ctx = 0;n_ctx < gen_nb_const_xmlParserCtxtPtr;n_ctx++) {
14239: for (n_node = 0;n_node < gen_nb_const_xmlNodePtr;n_node++) {
14240: mem_base = xmlMemBlocks();
14241: ctx = gen_const_xmlParserCtxtPtr(n_ctx, 0);
14242: node = gen_const_xmlNodePtr(n_node, 1);
14243:
14244: ret_val = xmlParserFindNodeInfo((const xmlParserCtxtPtr)ctx, (const xmlNodePtr)node);
14245: desret_const_xmlParserNodeInfo_ptr(ret_val);
14246: call_tests++;
14247: des_const_xmlParserCtxtPtr(n_ctx, (const xmlParserCtxtPtr)ctx, 0);
14248: des_const_xmlNodePtr(n_node, (const xmlNodePtr)node, 1);
14249: xmlResetLastError();
14250: if (mem_base != xmlMemBlocks()) {
14251: printf("Leak of %d blocks found in xmlParserFindNodeInfo",
14252: xmlMemBlocks() - mem_base);
14253: test_ret++;
14254: printf(" %d", n_ctx);
14255: printf(" %d", n_node);
14256: printf("\n");
14257: }
14258: }
14259: }
14260: function_tests++;
14261:
14262: return(test_ret);
14263: }
14264:
14265:
14266: #define gen_nb_const_xmlParserNodeInfoSeqPtr 1
14267: static xmlParserNodeInfoSeqPtr gen_const_xmlParserNodeInfoSeqPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14268: return(NULL);
14269: }
14270: static void des_const_xmlParserNodeInfoSeqPtr(int no ATTRIBUTE_UNUSED, const xmlParserNodeInfoSeqPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14271: }
14272:
14273: static int
14274: test_xmlParserFindNodeInfoIndex(void) {
14275: int test_ret = 0;
14276:
14277: int mem_base;
14278: unsigned long ret_val;
14279: xmlParserNodeInfoSeqPtr seq; /* a node info sequence pointer */
14280: int n_seq;
14281: xmlNodePtr node; /* an XML node pointer */
14282: int n_node;
14283:
14284: for (n_seq = 0;n_seq < gen_nb_const_xmlParserNodeInfoSeqPtr;n_seq++) {
14285: for (n_node = 0;n_node < gen_nb_const_xmlNodePtr;n_node++) {
14286: mem_base = xmlMemBlocks();
14287: seq = gen_const_xmlParserNodeInfoSeqPtr(n_seq, 0);
14288: node = gen_const_xmlNodePtr(n_node, 1);
14289:
14290: ret_val = xmlParserFindNodeInfoIndex((const xmlParserNodeInfoSeqPtr)seq, (const xmlNodePtr)node);
14291: desret_unsigned_long(ret_val);
14292: call_tests++;
14293: des_const_xmlParserNodeInfoSeqPtr(n_seq, (const xmlParserNodeInfoSeqPtr)seq, 0);
14294: des_const_xmlNodePtr(n_node, (const xmlNodePtr)node, 1);
14295: xmlResetLastError();
14296: if (mem_base != xmlMemBlocks()) {
14297: printf("Leak of %d blocks found in xmlParserFindNodeInfoIndex",
14298: xmlMemBlocks() - mem_base);
14299: test_ret++;
14300: printf(" %d", n_seq);
14301: printf(" %d", n_node);
14302: printf("\n");
14303: }
14304: }
14305: }
14306: function_tests++;
14307:
14308: return(test_ret);
14309: }
14310:
14311:
14312: #define gen_nb_xmlParserInputPtr 1
14313: static xmlParserInputPtr gen_xmlParserInputPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14314: return(NULL);
14315: }
14316: static void des_xmlParserInputPtr(int no ATTRIBUTE_UNUSED, xmlParserInputPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14317: }
14318:
14319: static int
14320: test_xmlParserInputGrow(void) {
14321: int test_ret = 0;
14322:
14323: int mem_base;
14324: int ret_val;
14325: xmlParserInputPtr in; /* an XML parser input */
14326: int n_in;
14327: int len; /* an indicative size for the lookahead */
14328: int n_len;
14329:
14330: for (n_in = 0;n_in < gen_nb_xmlParserInputPtr;n_in++) {
14331: for (n_len = 0;n_len < gen_nb_int;n_len++) {
14332: mem_base = xmlMemBlocks();
14333: in = gen_xmlParserInputPtr(n_in, 0);
14334: len = gen_int(n_len, 1);
14335:
14336: ret_val = xmlParserInputGrow(in, len);
14337: desret_int(ret_val);
14338: call_tests++;
14339: des_xmlParserInputPtr(n_in, in, 0);
14340: des_int(n_len, len, 1);
14341: xmlResetLastError();
14342: if (mem_base != xmlMemBlocks()) {
14343: printf("Leak of %d blocks found in xmlParserInputGrow",
14344: xmlMemBlocks() - mem_base);
14345: test_ret++;
14346: printf(" %d", n_in);
14347: printf(" %d", n_len);
14348: printf("\n");
14349: }
14350: }
14351: }
14352: function_tests++;
14353:
14354: return(test_ret);
14355: }
14356:
14357:
14358: static int
14359: test_xmlParserInputRead(void) {
14360: int test_ret = 0;
14361:
14362: int mem_base;
14363: int ret_val;
14364: xmlParserInputPtr in; /* an XML parser input */
14365: int n_in;
14366: int len; /* an indicative size for the lookahead */
14367: int n_len;
14368:
14369: for (n_in = 0;n_in < gen_nb_xmlParserInputPtr;n_in++) {
14370: for (n_len = 0;n_len < gen_nb_int;n_len++) {
14371: mem_base = xmlMemBlocks();
14372: in = gen_xmlParserInputPtr(n_in, 0);
14373: len = gen_int(n_len, 1);
14374:
14375: ret_val = xmlParserInputRead(in, len);
14376: desret_int(ret_val);
14377: call_tests++;
14378: des_xmlParserInputPtr(n_in, in, 0);
14379: des_int(n_len, len, 1);
14380: xmlResetLastError();
14381: if (mem_base != xmlMemBlocks()) {
14382: printf("Leak of %d blocks found in xmlParserInputRead",
14383: xmlMemBlocks() - mem_base);
14384: test_ret++;
14385: printf(" %d", n_in);
14386: printf(" %d", n_len);
14387: printf("\n");
14388: }
14389: }
14390: }
14391: function_tests++;
14392:
14393: return(test_ret);
14394: }
14395:
14396:
14397: static int
14398: test_xmlPedanticParserDefault(void) {
14399: int test_ret = 0;
14400:
14401: int mem_base;
14402: int ret_val;
14403: int val; /* int 0 or 1 */
14404: int n_val;
14405:
14406: for (n_val = 0;n_val < gen_nb_int;n_val++) {
14407: mem_base = xmlMemBlocks();
14408: val = gen_int(n_val, 0);
14409:
14410: ret_val = xmlPedanticParserDefault(val);
14411: desret_int(ret_val);
14412: call_tests++;
14413: des_int(n_val, val, 0);
14414: xmlResetLastError();
14415: if (mem_base != xmlMemBlocks()) {
14416: printf("Leak of %d blocks found in xmlPedanticParserDefault",
14417: xmlMemBlocks() - mem_base);
14418: test_ret++;
14419: printf(" %d", n_val);
14420: printf("\n");
14421: }
14422: }
14423: function_tests++;
14424:
14425: return(test_ret);
14426: }
14427:
14428:
14429: static int
14430: test_xmlReadDoc(void) {
14431: int test_ret = 0;
14432:
14433: int mem_base;
14434: xmlDocPtr ret_val;
14435: xmlChar * cur; /* a pointer to a zero terminated string */
14436: int n_cur;
14437: const char * URL; /* the base URL to use for the document */
14438: int n_URL;
14439: char * encoding; /* the document encoding, or NULL */
14440: int n_encoding;
14441: int options; /* a combination of xmlParserOption */
14442: int n_options;
14443:
14444: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
14445: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
14446: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
14447: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
14448: mem_base = xmlMemBlocks();
14449: cur = gen_const_xmlChar_ptr(n_cur, 0);
14450: URL = gen_filepath(n_URL, 1);
14451: encoding = gen_const_char_ptr(n_encoding, 2);
14452: options = gen_parseroptions(n_options, 3);
14453:
14454: ret_val = xmlReadDoc((const xmlChar *)cur, URL, (const char *)encoding, options);
14455: desret_xmlDocPtr(ret_val);
14456: call_tests++;
14457: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
14458: des_filepath(n_URL, URL, 1);
14459: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
14460: des_parseroptions(n_options, options, 3);
14461: xmlResetLastError();
14462: if (mem_base != xmlMemBlocks()) {
14463: printf("Leak of %d blocks found in xmlReadDoc",
14464: xmlMemBlocks() - mem_base);
14465: test_ret++;
14466: printf(" %d", n_cur);
14467: printf(" %d", n_URL);
14468: printf(" %d", n_encoding);
14469: printf(" %d", n_options);
14470: printf("\n");
14471: }
14472: }
14473: }
14474: }
14475: }
14476: function_tests++;
14477:
14478: return(test_ret);
14479: }
14480:
14481:
14482: static int
14483: test_xmlReadFile(void) {
14484: int test_ret = 0;
14485:
14486: int mem_base;
14487: xmlDocPtr ret_val;
14488: const char * filename; /* a file or URL */
14489: int n_filename;
14490: char * encoding; /* the document encoding, or NULL */
14491: int n_encoding;
14492: int options; /* a combination of xmlParserOption */
14493: int n_options;
14494:
14495: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
14496: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
14497: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
14498: mem_base = xmlMemBlocks();
14499: filename = gen_filepath(n_filename, 0);
14500: encoding = gen_const_char_ptr(n_encoding, 1);
14501: options = gen_parseroptions(n_options, 2);
14502:
14503: ret_val = xmlReadFile(filename, (const char *)encoding, options);
14504: desret_xmlDocPtr(ret_val);
14505: call_tests++;
14506: des_filepath(n_filename, filename, 0);
14507: des_const_char_ptr(n_encoding, (const char *)encoding, 1);
14508: des_parseroptions(n_options, options, 2);
14509: xmlResetLastError();
14510: if (mem_base != xmlMemBlocks()) {
14511: printf("Leak of %d blocks found in xmlReadFile",
14512: xmlMemBlocks() - mem_base);
14513: test_ret++;
14514: printf(" %d", n_filename);
14515: printf(" %d", n_encoding);
14516: printf(" %d", n_options);
14517: printf("\n");
14518: }
14519: }
14520: }
14521: }
14522: function_tests++;
14523:
14524: return(test_ret);
14525: }
14526:
14527:
14528: static int
14529: test_xmlReadMemory(void) {
14530: int test_ret = 0;
14531:
14532: int mem_base;
14533: xmlDocPtr ret_val;
14534: char * buffer; /* a pointer to a char array */
14535: int n_buffer;
14536: int size; /* the size of the array */
14537: int n_size;
14538: const char * URL; /* the base URL to use for the document */
14539: int n_URL;
14540: char * encoding; /* the document encoding, or NULL */
14541: int n_encoding;
14542: int options; /* a combination of xmlParserOption */
14543: int n_options;
14544:
14545: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
14546: for (n_size = 0;n_size < gen_nb_int;n_size++) {
14547: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
14548: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
14549: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
14550: mem_base = xmlMemBlocks();
14551: buffer = gen_const_char_ptr(n_buffer, 0);
14552: size = gen_int(n_size, 1);
14553: URL = gen_filepath(n_URL, 2);
14554: encoding = gen_const_char_ptr(n_encoding, 3);
14555: options = gen_parseroptions(n_options, 4);
14556:
14557: ret_val = xmlReadMemory((const char *)buffer, size, URL, (const char *)encoding, options);
14558: desret_xmlDocPtr(ret_val);
14559: call_tests++;
14560: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
14561: des_int(n_size, size, 1);
14562: des_filepath(n_URL, URL, 2);
14563: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
14564: des_parseroptions(n_options, options, 4);
14565: xmlResetLastError();
14566: if (mem_base != xmlMemBlocks()) {
14567: printf("Leak of %d blocks found in xmlReadMemory",
14568: xmlMemBlocks() - mem_base);
14569: test_ret++;
14570: printf(" %d", n_buffer);
14571: printf(" %d", n_size);
14572: printf(" %d", n_URL);
14573: printf(" %d", n_encoding);
14574: printf(" %d", n_options);
14575: printf("\n");
14576: }
14577: }
14578: }
14579: }
14580: }
14581: }
14582: function_tests++;
14583:
14584: return(test_ret);
14585: }
14586:
14587:
14588: static int
14589: test_xmlRecoverDoc(void) {
14590: int test_ret = 0;
14591:
14592: #if defined(LIBXML_SAX1_ENABLED)
14593: #ifdef LIBXML_SAX1_ENABLED
14594: int mem_base;
14595: xmlDocPtr ret_val;
14596: xmlChar * cur; /* a pointer to an array of xmlChar */
14597: int n_cur;
14598:
14599: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
14600: mem_base = xmlMemBlocks();
14601: cur = gen_const_xmlChar_ptr(n_cur, 0);
14602:
14603: ret_val = xmlRecoverDoc((const xmlChar *)cur);
14604: desret_xmlDocPtr(ret_val);
14605: call_tests++;
14606: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
14607: xmlResetLastError();
14608: if (mem_base != xmlMemBlocks()) {
14609: printf("Leak of %d blocks found in xmlRecoverDoc",
14610: xmlMemBlocks() - mem_base);
14611: test_ret++;
14612: printf(" %d", n_cur);
14613: printf("\n");
14614: }
14615: }
14616: function_tests++;
14617: #endif
14618: #endif
14619:
14620: return(test_ret);
14621: }
14622:
14623:
14624: static int
14625: test_xmlRecoverFile(void) {
14626: int test_ret = 0;
14627:
14628: #if defined(LIBXML_SAX1_ENABLED)
14629: #ifdef LIBXML_SAX1_ENABLED
14630: int mem_base;
14631: xmlDocPtr ret_val;
14632: const char * filename; /* the filename */
14633: int n_filename;
14634:
14635: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
14636: mem_base = xmlMemBlocks();
14637: filename = gen_filepath(n_filename, 0);
14638:
14639: ret_val = xmlRecoverFile(filename);
14640: desret_xmlDocPtr(ret_val);
14641: call_tests++;
14642: des_filepath(n_filename, filename, 0);
14643: xmlResetLastError();
14644: if (mem_base != xmlMemBlocks()) {
14645: printf("Leak of %d blocks found in xmlRecoverFile",
14646: xmlMemBlocks() - mem_base);
14647: test_ret++;
14648: printf(" %d", n_filename);
14649: printf("\n");
14650: }
14651: }
14652: function_tests++;
14653: #endif
14654: #endif
14655:
14656: return(test_ret);
14657: }
14658:
14659:
14660: static int
14661: test_xmlRecoverMemory(void) {
14662: int test_ret = 0;
14663:
14664: #if defined(LIBXML_SAX1_ENABLED)
14665: #ifdef LIBXML_SAX1_ENABLED
14666: int mem_base;
14667: xmlDocPtr ret_val;
14668: char * buffer; /* an pointer to a char array */
14669: int n_buffer;
14670: int size; /* the size of the array */
14671: int n_size;
14672:
14673: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
14674: for (n_size = 0;n_size < gen_nb_int;n_size++) {
14675: mem_base = xmlMemBlocks();
14676: buffer = gen_const_char_ptr(n_buffer, 0);
14677: size = gen_int(n_size, 1);
14678:
14679: ret_val = xmlRecoverMemory((const char *)buffer, size);
14680: desret_xmlDocPtr(ret_val);
14681: call_tests++;
14682: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
14683: des_int(n_size, size, 1);
14684: xmlResetLastError();
14685: if (mem_base != xmlMemBlocks()) {
14686: printf("Leak of %d blocks found in xmlRecoverMemory",
14687: xmlMemBlocks() - mem_base);
14688: test_ret++;
14689: printf(" %d", n_buffer);
14690: printf(" %d", n_size);
14691: printf("\n");
14692: }
14693: }
14694: }
14695: function_tests++;
14696: #endif
14697: #endif
14698:
14699: return(test_ret);
14700: }
14701:
14702:
14703: static int
14704: test_xmlSAXParseDTD(void) {
14705: int test_ret = 0;
14706:
14707: #if defined(LIBXML_VALID_ENABLED)
14708: #ifdef LIBXML_SAX1_ENABLED
14709: int mem_base;
14710: xmlDtdPtr ret_val;
14711: xmlSAXHandlerPtr sax; /* the SAX handler block */
14712: int n_sax;
14713: xmlChar * ExternalID; /* a NAME* containing the External ID of the DTD */
14714: int n_ExternalID;
14715: xmlChar * SystemID; /* a NAME* containing the URL to the DTD */
14716: int n_SystemID;
14717:
14718: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
14719: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
14720: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
14721: mem_base = xmlMemBlocks();
14722: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
14723: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 1);
14724: SystemID = gen_const_xmlChar_ptr(n_SystemID, 2);
14725:
14726: ret_val = xmlSAXParseDTD(sax, (const xmlChar *)ExternalID, (const xmlChar *)SystemID);
14727: desret_xmlDtdPtr(ret_val);
14728: call_tests++;
14729: des_xmlSAXHandlerPtr(n_sax, sax, 0);
14730: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 1);
14731: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 2);
14732: xmlResetLastError();
14733: if (mem_base != xmlMemBlocks()) {
14734: printf("Leak of %d blocks found in xmlSAXParseDTD",
14735: xmlMemBlocks() - mem_base);
14736: test_ret++;
14737: printf(" %d", n_sax);
14738: printf(" %d", n_ExternalID);
14739: printf(" %d", n_SystemID);
14740: printf("\n");
14741: }
14742: }
14743: }
14744: }
14745: function_tests++;
14746: #endif
14747: #endif
14748:
14749: return(test_ret);
14750: }
14751:
14752:
14753: static int
14754: test_xmlSAXParseDoc(void) {
14755: int test_ret = 0;
14756:
14757: #if defined(LIBXML_SAX1_ENABLED)
14758: #ifdef LIBXML_SAX1_ENABLED
14759: int mem_base;
14760: xmlDocPtr ret_val;
14761: xmlSAXHandlerPtr sax; /* the SAX handler block */
14762: int n_sax;
14763: xmlChar * cur; /* a pointer to an array of xmlChar */
14764: int n_cur;
14765: int recovery; /* work in recovery mode, i.e. tries to read no Well Formed documents */
14766: int n_recovery;
14767:
14768: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
14769: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
14770: for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) {
14771: mem_base = xmlMemBlocks();
14772: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
14773: cur = gen_const_xmlChar_ptr(n_cur, 1);
14774: recovery = gen_int(n_recovery, 2);
14775:
14776: ret_val = xmlSAXParseDoc(sax, (const xmlChar *)cur, recovery);
14777: desret_xmlDocPtr(ret_val);
14778: call_tests++;
14779: des_xmlSAXHandlerPtr(n_sax, sax, 0);
14780: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 1);
14781: des_int(n_recovery, recovery, 2);
14782: xmlResetLastError();
14783: if (mem_base != xmlMemBlocks()) {
14784: printf("Leak of %d blocks found in xmlSAXParseDoc",
14785: xmlMemBlocks() - mem_base);
14786: test_ret++;
14787: printf(" %d", n_sax);
14788: printf(" %d", n_cur);
14789: printf(" %d", n_recovery);
14790: printf("\n");
14791: }
14792: }
14793: }
14794: }
14795: function_tests++;
14796: #endif
14797: #endif
14798:
14799: return(test_ret);
14800: }
14801:
14802:
14803: static int
14804: test_xmlSAXParseEntity(void) {
14805: int test_ret = 0;
14806:
14807: #if defined(LIBXML_SAX1_ENABLED)
14808: #ifdef LIBXML_SAX1_ENABLED
14809: int mem_base;
14810: xmlDocPtr ret_val;
14811: xmlSAXHandlerPtr sax; /* the SAX handler block */
14812: int n_sax;
14813: const char * filename; /* the filename */
14814: int n_filename;
14815:
14816: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
14817: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
14818: mem_base = xmlMemBlocks();
14819: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
14820: filename = gen_filepath(n_filename, 1);
14821:
14822: ret_val = xmlSAXParseEntity(sax, filename);
14823: desret_xmlDocPtr(ret_val);
14824: call_tests++;
14825: des_xmlSAXHandlerPtr(n_sax, sax, 0);
14826: des_filepath(n_filename, filename, 1);
14827: xmlResetLastError();
14828: if (mem_base != xmlMemBlocks()) {
14829: printf("Leak of %d blocks found in xmlSAXParseEntity",
14830: xmlMemBlocks() - mem_base);
14831: test_ret++;
14832: printf(" %d", n_sax);
14833: printf(" %d", n_filename);
14834: printf("\n");
14835: }
14836: }
14837: }
14838: function_tests++;
14839: #endif
14840: #endif
14841:
14842: return(test_ret);
14843: }
14844:
14845:
14846: static int
14847: test_xmlSAXParseFile(void) {
14848: int test_ret = 0;
14849:
14850: #if defined(LIBXML_SAX1_ENABLED)
14851: #ifdef LIBXML_SAX1_ENABLED
14852: int mem_base;
14853: xmlDocPtr ret_val;
14854: xmlSAXHandlerPtr sax; /* the SAX handler block */
14855: int n_sax;
14856: const char * filename; /* the filename */
14857: int n_filename;
14858: int recovery; /* work in recovery mode, i.e. tries to read no Well Formed documents */
14859: int n_recovery;
14860:
14861: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
14862: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
14863: for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) {
14864: mem_base = xmlMemBlocks();
14865: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
14866: filename = gen_filepath(n_filename, 1);
14867: recovery = gen_int(n_recovery, 2);
14868:
14869: ret_val = xmlSAXParseFile(sax, filename, recovery);
14870: desret_xmlDocPtr(ret_val);
14871: call_tests++;
14872: des_xmlSAXHandlerPtr(n_sax, sax, 0);
14873: des_filepath(n_filename, filename, 1);
14874: des_int(n_recovery, recovery, 2);
14875: xmlResetLastError();
14876: if (mem_base != xmlMemBlocks()) {
14877: printf("Leak of %d blocks found in xmlSAXParseFile",
14878: xmlMemBlocks() - mem_base);
14879: test_ret++;
14880: printf(" %d", n_sax);
14881: printf(" %d", n_filename);
14882: printf(" %d", n_recovery);
14883: printf("\n");
14884: }
14885: }
14886: }
14887: }
14888: function_tests++;
14889: #endif
14890: #endif
14891:
14892: return(test_ret);
14893: }
14894:
14895:
14896: static int
14897: test_xmlSAXParseFileWithData(void) {
14898: int test_ret = 0;
14899:
14900: #if defined(LIBXML_SAX1_ENABLED)
14901: #ifdef LIBXML_SAX1_ENABLED
14902: int mem_base;
14903: xmlDocPtr ret_val;
14904: xmlSAXHandlerPtr sax; /* the SAX handler block */
14905: int n_sax;
14906: const char * filename; /* the filename */
14907: int n_filename;
14908: int recovery; /* work in recovery mode, i.e. tries to read no Well Formed documents */
14909: int n_recovery;
14910: void * data; /* the userdata */
14911: int n_data;
14912:
14913: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
14914: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
14915: for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) {
14916: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
14917: mem_base = xmlMemBlocks();
14918: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
14919: filename = gen_filepath(n_filename, 1);
14920: recovery = gen_int(n_recovery, 2);
14921: data = gen_userdata(n_data, 3);
14922:
14923: ret_val = xmlSAXParseFileWithData(sax, filename, recovery, data);
14924: desret_xmlDocPtr(ret_val);
14925: call_tests++;
14926: des_xmlSAXHandlerPtr(n_sax, sax, 0);
14927: des_filepath(n_filename, filename, 1);
14928: des_int(n_recovery, recovery, 2);
14929: des_userdata(n_data, data, 3);
14930: xmlResetLastError();
14931: if (mem_base != xmlMemBlocks()) {
14932: printf("Leak of %d blocks found in xmlSAXParseFileWithData",
14933: xmlMemBlocks() - mem_base);
14934: test_ret++;
14935: printf(" %d", n_sax);
14936: printf(" %d", n_filename);
14937: printf(" %d", n_recovery);
14938: printf(" %d", n_data);
14939: printf("\n");
14940: }
14941: }
14942: }
14943: }
14944: }
14945: function_tests++;
14946: #endif
14947: #endif
14948:
14949: return(test_ret);
14950: }
14951:
14952:
14953: static int
14954: test_xmlSAXParseMemory(void) {
14955: int test_ret = 0;
14956:
14957: #if defined(LIBXML_SAX1_ENABLED)
14958: #ifdef LIBXML_SAX1_ENABLED
14959: int mem_base;
14960: xmlDocPtr ret_val;
14961: xmlSAXHandlerPtr sax; /* the SAX handler block */
14962: int n_sax;
14963: char * buffer; /* an pointer to a char array */
14964: int n_buffer;
14965: int size; /* the size of the array */
14966: int n_size;
14967: int recovery; /* work in recovery mode, i.e. tries to read not Well Formed documents */
14968: int n_recovery;
14969:
14970: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
14971: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
14972: for (n_size = 0;n_size < gen_nb_int;n_size++) {
14973: for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) {
14974: mem_base = xmlMemBlocks();
14975: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
14976: buffer = gen_const_char_ptr(n_buffer, 1);
14977: size = gen_int(n_size, 2);
14978: recovery = gen_int(n_recovery, 3);
14979:
14980: ret_val = xmlSAXParseMemory(sax, (const char *)buffer, size, recovery);
14981: desret_xmlDocPtr(ret_val);
14982: call_tests++;
14983: des_xmlSAXHandlerPtr(n_sax, sax, 0);
14984: des_const_char_ptr(n_buffer, (const char *)buffer, 1);
14985: des_int(n_size, size, 2);
14986: des_int(n_recovery, recovery, 3);
14987: xmlResetLastError();
14988: if (mem_base != xmlMemBlocks()) {
14989: printf("Leak of %d blocks found in xmlSAXParseMemory",
14990: xmlMemBlocks() - mem_base);
14991: test_ret++;
14992: printf(" %d", n_sax);
14993: printf(" %d", n_buffer);
14994: printf(" %d", n_size);
14995: printf(" %d", n_recovery);
14996: printf("\n");
14997: }
14998: }
14999: }
15000: }
15001: }
15002: function_tests++;
15003: #endif
15004: #endif
15005:
15006: return(test_ret);
15007: }
15008:
15009:
15010: static int
15011: test_xmlSAXParseMemoryWithData(void) {
15012: int test_ret = 0;
15013:
15014: #if defined(LIBXML_SAX1_ENABLED)
15015: #ifdef LIBXML_SAX1_ENABLED
15016: int mem_base;
15017: xmlDocPtr ret_val;
15018: xmlSAXHandlerPtr sax; /* the SAX handler block */
15019: int n_sax;
15020: char * buffer; /* an pointer to a char array */
15021: int n_buffer;
15022: int size; /* the size of the array */
15023: int n_size;
15024: int recovery; /* work in recovery mode, i.e. tries to read no Well Formed documents */
15025: int n_recovery;
15026: void * data; /* the userdata */
15027: int n_data;
15028:
15029: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
15030: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
15031: for (n_size = 0;n_size < gen_nb_int;n_size++) {
15032: for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) {
15033: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
15034: mem_base = xmlMemBlocks();
15035: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
15036: buffer = gen_const_char_ptr(n_buffer, 1);
15037: size = gen_int(n_size, 2);
15038: recovery = gen_int(n_recovery, 3);
15039: data = gen_userdata(n_data, 4);
15040:
15041: ret_val = xmlSAXParseMemoryWithData(sax, (const char *)buffer, size, recovery, data);
15042: desret_xmlDocPtr(ret_val);
15043: call_tests++;
15044: des_xmlSAXHandlerPtr(n_sax, sax, 0);
15045: des_const_char_ptr(n_buffer, (const char *)buffer, 1);
15046: des_int(n_size, size, 2);
15047: des_int(n_recovery, recovery, 3);
15048: des_userdata(n_data, data, 4);
15049: xmlResetLastError();
15050: if (mem_base != xmlMemBlocks()) {
15051: printf("Leak of %d blocks found in xmlSAXParseMemoryWithData",
15052: xmlMemBlocks() - mem_base);
15053: test_ret++;
15054: printf(" %d", n_sax);
15055: printf(" %d", n_buffer);
15056: printf(" %d", n_size);
15057: printf(" %d", n_recovery);
15058: printf(" %d", n_data);
15059: printf("\n");
15060: }
15061: }
15062: }
15063: }
15064: }
15065: }
15066: function_tests++;
15067: #endif
15068: #endif
15069:
15070: return(test_ret);
15071: }
15072:
15073:
15074: static int
15075: test_xmlSAXUserParseFile(void) {
15076: int test_ret = 0;
15077:
15078: #if defined(LIBXML_SAX1_ENABLED)
15079: #ifdef LIBXML_SAX1_ENABLED
15080: int mem_base;
15081: int ret_val;
15082: xmlSAXHandlerPtr sax; /* a SAX handler */
15083: int n_sax;
15084: void * user_data; /* The user data returned on SAX callbacks */
15085: int n_user_data;
15086: const char * filename; /* a file name */
15087: int n_filename;
15088:
15089: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
15090: for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
15091: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
15092: mem_base = xmlMemBlocks();
15093: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
15094: user_data = gen_userdata(n_user_data, 1);
15095: filename = gen_filepath(n_filename, 2);
15096:
15097: #ifdef LIBXML_SAX1_ENABLED
15098: if (sax == (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) user_data = NULL;
15099: #endif
15100:
15101:
15102: ret_val = xmlSAXUserParseFile(sax, user_data, filename);
15103: desret_int(ret_val);
15104: call_tests++;
15105: des_xmlSAXHandlerPtr(n_sax, sax, 0);
15106: des_userdata(n_user_data, user_data, 1);
15107: des_filepath(n_filename, filename, 2);
15108: xmlResetLastError();
15109: if (mem_base != xmlMemBlocks()) {
15110: printf("Leak of %d blocks found in xmlSAXUserParseFile",
15111: xmlMemBlocks() - mem_base);
15112: test_ret++;
15113: printf(" %d", n_sax);
15114: printf(" %d", n_user_data);
15115: printf(" %d", n_filename);
15116: printf("\n");
15117: }
15118: }
15119: }
15120: }
15121: function_tests++;
15122: #endif
15123: #endif
15124:
15125: return(test_ret);
15126: }
15127:
15128:
15129: static int
15130: test_xmlSAXUserParseMemory(void) {
15131: int test_ret = 0;
15132:
15133: #if defined(LIBXML_SAX1_ENABLED)
15134: #ifdef LIBXML_SAX1_ENABLED
15135: int mem_base;
15136: int ret_val;
15137: xmlSAXHandlerPtr sax; /* a SAX handler */
15138: int n_sax;
15139: void * user_data; /* The user data returned on SAX callbacks */
15140: int n_user_data;
15141: char * buffer; /* an in-memory XML document input */
15142: int n_buffer;
15143: int size; /* the length of the XML document in bytes */
15144: int n_size;
15145:
15146: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
15147: for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
15148: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
15149: for (n_size = 0;n_size < gen_nb_int;n_size++) {
15150: mem_base = xmlMemBlocks();
15151: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
15152: user_data = gen_userdata(n_user_data, 1);
15153: buffer = gen_const_char_ptr(n_buffer, 2);
15154: size = gen_int(n_size, 3);
15155:
15156: #ifdef LIBXML_SAX1_ENABLED
15157: if (sax == (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) user_data = NULL;
15158: #endif
15159:
15160:
15161: ret_val = xmlSAXUserParseMemory(sax, user_data, (const char *)buffer, size);
15162: desret_int(ret_val);
15163: call_tests++;
15164: des_xmlSAXHandlerPtr(n_sax, sax, 0);
15165: des_userdata(n_user_data, user_data, 1);
15166: des_const_char_ptr(n_buffer, (const char *)buffer, 2);
15167: des_int(n_size, size, 3);
15168: xmlResetLastError();
15169: if (mem_base != xmlMemBlocks()) {
15170: printf("Leak of %d blocks found in xmlSAXUserParseMemory",
15171: xmlMemBlocks() - mem_base);
15172: test_ret++;
15173: printf(" %d", n_sax);
15174: printf(" %d", n_user_data);
15175: printf(" %d", n_buffer);
15176: printf(" %d", n_size);
15177: printf("\n");
15178: }
15179: }
15180: }
15181: }
15182: }
15183: function_tests++;
15184: #endif
15185: #endif
15186:
15187: return(test_ret);
15188: }
15189:
15190:
15191: static int
15192: test_xmlSetExternalEntityLoader(void) {
15193: int test_ret = 0;
15194:
15195:
15196: /* missing type support */
15197: return(test_ret);
15198: }
15199:
15200:
15201: static int
15202: test_xmlSetFeature(void) {
15203: int test_ret = 0;
15204:
15205: #if defined(LIBXML_LEGACY_ENABLED)
15206: #ifdef LIBXML_LEGACY_ENABLED
15207: int mem_base;
15208: int ret_val;
15209: xmlParserCtxtPtr ctxt; /* an XML/HTML parser context */
15210: int n_ctxt;
15211: char * name; /* the feature name */
15212: int n_name;
15213: void * value; /* pointer to the location of the new value */
15214: int n_value;
15215:
15216: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15217: for (n_name = 0;n_name < gen_nb_const_char_ptr;n_name++) {
15218: for (n_value = 0;n_value < gen_nb_void_ptr;n_value++) {
15219: mem_base = xmlMemBlocks();
15220: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15221: name = gen_const_char_ptr(n_name, 1);
15222: value = gen_void_ptr(n_value, 2);
15223:
15224: ret_val = xmlSetFeature(ctxt, (const char *)name, value);
15225: desret_int(ret_val);
15226: call_tests++;
15227: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15228: des_const_char_ptr(n_name, (const char *)name, 1);
15229: des_void_ptr(n_value, value, 2);
15230: xmlResetLastError();
15231: if (mem_base != xmlMemBlocks()) {
15232: printf("Leak of %d blocks found in xmlSetFeature",
15233: xmlMemBlocks() - mem_base);
15234: test_ret++;
15235: printf(" %d", n_ctxt);
15236: printf(" %d", n_name);
15237: printf(" %d", n_value);
15238: printf("\n");
15239: }
15240: }
15241: }
15242: }
15243: function_tests++;
15244: #endif
15245: #endif
15246:
15247: return(test_ret);
15248: }
15249:
15250:
15251: static int
15252: test_xmlSetupParserForBuffer(void) {
15253: int test_ret = 0;
15254:
15255: #if defined(LIBXML_SAX1_ENABLED)
15256: #ifdef LIBXML_SAX1_ENABLED
15257: int mem_base;
15258: xmlParserCtxtPtr ctxt; /* an XML parser context */
15259: int n_ctxt;
15260: xmlChar * buffer; /* a xmlChar * buffer */
15261: int n_buffer;
15262: const char * filename; /* a file name */
15263: int n_filename;
15264:
15265: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15266: for (n_buffer = 0;n_buffer < gen_nb_const_xmlChar_ptr;n_buffer++) {
15267: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
15268: mem_base = xmlMemBlocks();
15269: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15270: buffer = gen_const_xmlChar_ptr(n_buffer, 1);
15271: filename = gen_filepath(n_filename, 2);
15272:
15273: xmlSetupParserForBuffer(ctxt, (const xmlChar *)buffer, filename);
15274: call_tests++;
15275: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15276: des_const_xmlChar_ptr(n_buffer, (const xmlChar *)buffer, 1);
15277: des_filepath(n_filename, filename, 2);
15278: xmlResetLastError();
15279: if (mem_base != xmlMemBlocks()) {
15280: printf("Leak of %d blocks found in xmlSetupParserForBuffer",
15281: xmlMemBlocks() - mem_base);
15282: test_ret++;
15283: printf(" %d", n_ctxt);
15284: printf(" %d", n_buffer);
15285: printf(" %d", n_filename);
15286: printf("\n");
15287: }
15288: }
15289: }
15290: }
15291: function_tests++;
15292: #endif
15293: #endif
15294:
15295: return(test_ret);
15296: }
15297:
15298:
15299: static int
15300: test_xmlStopParser(void) {
15301: int test_ret = 0;
15302:
15303: #ifdef LIBXML_PUSH_ENABLED
15304: int mem_base;
15305: xmlParserCtxtPtr ctxt; /* an XML parser context */
15306: int n_ctxt;
15307:
15308: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15309: mem_base = xmlMemBlocks();
15310: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15311:
15312: xmlStopParser(ctxt);
15313: call_tests++;
15314: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15315: xmlResetLastError();
15316: if (mem_base != xmlMemBlocks()) {
15317: printf("Leak of %d blocks found in xmlStopParser",
15318: xmlMemBlocks() - mem_base);
15319: test_ret++;
15320: printf(" %d", n_ctxt);
15321: printf("\n");
15322: }
15323: }
15324: function_tests++;
15325: #endif
15326:
15327: return(test_ret);
15328: }
15329:
15330:
15331: static int
15332: test_xmlSubstituteEntitiesDefault(void) {
15333: int test_ret = 0;
15334:
15335: int mem_base;
15336: int ret_val;
15337: int val; /* int 0 or 1 */
15338: int n_val;
15339:
15340: for (n_val = 0;n_val < gen_nb_int;n_val++) {
15341: mem_base = xmlMemBlocks();
15342: val = gen_int(n_val, 0);
15343:
15344: ret_val = xmlSubstituteEntitiesDefault(val);
15345: desret_int(ret_val);
15346: call_tests++;
15347: des_int(n_val, val, 0);
15348: xmlResetLastError();
15349: if (mem_base != xmlMemBlocks()) {
15350: printf("Leak of %d blocks found in xmlSubstituteEntitiesDefault",
15351: xmlMemBlocks() - mem_base);
15352: test_ret++;
15353: printf(" %d", n_val);
15354: printf("\n");
15355: }
15356: }
15357: function_tests++;
15358:
15359: return(test_ret);
15360: }
15361:
15362: static int
15363: test_parser(void) {
15364: int test_ret = 0;
15365:
15366: if (quiet == 0) printf("Testing parser : 61 of 70 functions ...\n");
15367: test_ret += test_xmlByteConsumed();
15368: test_ret += test_xmlClearNodeInfoSeq();
15369: test_ret += test_xmlClearParserCtxt();
15370: test_ret += test_xmlCreateDocParserCtxt();
15371: test_ret += test_xmlCreatePushParserCtxt();
15372: test_ret += test_xmlCtxtReadDoc();
15373: test_ret += test_xmlCtxtReadFile();
15374: test_ret += test_xmlCtxtReadMemory();
15375: test_ret += test_xmlCtxtReset();
15376: test_ret += test_xmlCtxtResetPush();
15377: test_ret += test_xmlCtxtUseOptions();
15378: test_ret += test_xmlGetExternalEntityLoader();
15379: test_ret += test_xmlGetFeature();
15380: test_ret += test_xmlGetFeaturesList();
15381: test_ret += test_xmlHasFeature();
15382: test_ret += test_xmlIOParseDTD();
15383: test_ret += test_xmlInitNodeInfoSeq();
15384: test_ret += test_xmlInitParser();
15385: test_ret += test_xmlInitParserCtxt();
15386: test_ret += test_xmlKeepBlanksDefault();
15387: test_ret += test_xmlLineNumbersDefault();
15388: test_ret += test_xmlLoadExternalEntity();
15389: test_ret += test_xmlNewIOInputStream();
15390: test_ret += test_xmlNewParserCtxt();
15391: test_ret += test_xmlParseBalancedChunkMemory();
15392: test_ret += test_xmlParseBalancedChunkMemoryRecover();
15393: test_ret += test_xmlParseChunk();
15394: test_ret += test_xmlParseCtxtExternalEntity();
15395: test_ret += test_xmlParseDTD();
15396: test_ret += test_xmlParseDoc();
15397: test_ret += test_xmlParseDocument();
15398: test_ret += test_xmlParseEntity();
15399: test_ret += test_xmlParseExtParsedEnt();
15400: test_ret += test_xmlParseExternalEntity();
15401: test_ret += test_xmlParseFile();
15402: test_ret += test_xmlParseInNodeContext();
15403: test_ret += test_xmlParseMemory();
15404: test_ret += test_xmlParserAddNodeInfo();
15405: test_ret += test_xmlParserFindNodeInfo();
15406: test_ret += test_xmlParserFindNodeInfoIndex();
15407: test_ret += test_xmlParserInputGrow();
15408: test_ret += test_xmlParserInputRead();
15409: test_ret += test_xmlPedanticParserDefault();
15410: test_ret += test_xmlReadDoc();
15411: test_ret += test_xmlReadFile();
15412: test_ret += test_xmlReadMemory();
15413: test_ret += test_xmlRecoverDoc();
15414: test_ret += test_xmlRecoverFile();
15415: test_ret += test_xmlRecoverMemory();
15416: test_ret += test_xmlSAXParseDTD();
15417: test_ret += test_xmlSAXParseDoc();
15418: test_ret += test_xmlSAXParseEntity();
15419: test_ret += test_xmlSAXParseFile();
15420: test_ret += test_xmlSAXParseFileWithData();
15421: test_ret += test_xmlSAXParseMemory();
15422: test_ret += test_xmlSAXParseMemoryWithData();
15423: test_ret += test_xmlSAXUserParseFile();
15424: test_ret += test_xmlSAXUserParseMemory();
15425: test_ret += test_xmlSetExternalEntityLoader();
15426: test_ret += test_xmlSetFeature();
15427: test_ret += test_xmlSetupParserForBuffer();
15428: test_ret += test_xmlStopParser();
15429: test_ret += test_xmlSubstituteEntitiesDefault();
15430:
15431: if (test_ret != 0)
15432: printf("Module parser: %d errors\n", test_ret);
15433: return(test_ret);
15434: }
15435:
15436: static int
15437: test_htmlCreateFileParserCtxt(void) {
15438: int test_ret = 0;
15439:
15440: #if defined(LIBXML_HTML_ENABLED)
15441: int mem_base;
15442: htmlParserCtxtPtr ret_val;
15443: const char * filename; /* the filename */
15444: int n_filename;
15445: char * encoding; /* a free form C string describing the HTML document encoding, or NULL */
15446: int n_encoding;
15447:
15448: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
15449: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
15450: mem_base = xmlMemBlocks();
15451: filename = gen_fileoutput(n_filename, 0);
15452: encoding = gen_const_char_ptr(n_encoding, 1);
15453:
15454: ret_val = htmlCreateFileParserCtxt(filename, (const char *)encoding);
15455: desret_htmlParserCtxtPtr(ret_val);
15456: call_tests++;
15457: des_fileoutput(n_filename, filename, 0);
15458: des_const_char_ptr(n_encoding, (const char *)encoding, 1);
15459: xmlResetLastError();
15460: if (mem_base != xmlMemBlocks()) {
15461: printf("Leak of %d blocks found in htmlCreateFileParserCtxt",
15462: xmlMemBlocks() - mem_base);
15463: test_ret++;
15464: printf(" %d", n_filename);
15465: printf(" %d", n_encoding);
15466: printf("\n");
15467: }
15468: }
15469: }
15470: function_tests++;
15471: #endif
15472:
15473: return(test_ret);
15474: }
15475:
15476:
15477: static int
15478: test_htmlInitAutoClose(void) {
15479: int test_ret = 0;
15480:
15481: #if defined(LIBXML_HTML_ENABLED)
15482: int mem_base;
15483:
15484: mem_base = xmlMemBlocks();
15485:
15486: htmlInitAutoClose();
15487: call_tests++;
15488: xmlResetLastError();
15489: if (mem_base != xmlMemBlocks()) {
15490: printf("Leak of %d blocks found in htmlInitAutoClose",
15491: xmlMemBlocks() - mem_base);
15492: test_ret++;
15493: printf("\n");
15494: }
15495: function_tests++;
15496: #endif
15497:
15498: return(test_ret);
15499: }
15500:
15501:
15502: static int
15503: test_inputPop(void) {
15504: int test_ret = 0;
15505:
15506: int mem_base;
15507: xmlParserInputPtr ret_val;
15508: xmlParserCtxtPtr ctxt; /* an XML parser context */
15509: int n_ctxt;
15510:
15511: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15512: mem_base = xmlMemBlocks();
15513: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15514:
15515: ret_val = inputPop(ctxt);
15516: desret_xmlParserInputPtr(ret_val);
15517: call_tests++;
15518: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15519: xmlResetLastError();
15520: if (mem_base != xmlMemBlocks()) {
15521: printf("Leak of %d blocks found in inputPop",
15522: xmlMemBlocks() - mem_base);
15523: test_ret++;
15524: printf(" %d", n_ctxt);
15525: printf("\n");
15526: }
15527: }
15528: function_tests++;
15529:
15530: return(test_ret);
15531: }
15532:
15533:
15534: static int
15535: test_inputPush(void) {
15536: int test_ret = 0;
15537:
15538: int mem_base;
15539: int ret_val;
15540: xmlParserCtxtPtr ctxt; /* an XML parser context */
15541: int n_ctxt;
15542: xmlParserInputPtr value; /* the parser input */
15543: int n_value;
15544:
15545: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15546: for (n_value = 0;n_value < gen_nb_xmlParserInputPtr;n_value++) {
15547: mem_base = xmlMemBlocks();
15548: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15549: value = gen_xmlParserInputPtr(n_value, 1);
15550:
15551: ret_val = inputPush(ctxt, value);
15552: desret_int(ret_val);
15553: call_tests++;
15554: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15555: des_xmlParserInputPtr(n_value, value, 1);
15556: xmlResetLastError();
15557: if (mem_base != xmlMemBlocks()) {
15558: printf("Leak of %d blocks found in inputPush",
15559: xmlMemBlocks() - mem_base);
15560: test_ret++;
15561: printf(" %d", n_ctxt);
15562: printf(" %d", n_value);
15563: printf("\n");
15564: }
15565: }
15566: }
15567: function_tests++;
15568:
15569: return(test_ret);
15570: }
15571:
15572:
15573: static int
15574: test_namePop(void) {
15575: int test_ret = 0;
15576:
15577: int mem_base;
15578: const xmlChar * ret_val;
15579: xmlParserCtxtPtr ctxt; /* an XML parser context */
15580: int n_ctxt;
15581:
15582: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15583: mem_base = xmlMemBlocks();
15584: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15585:
15586: ret_val = namePop(ctxt);
15587: desret_const_xmlChar_ptr(ret_val);
15588: call_tests++;
15589: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15590: xmlResetLastError();
15591: if (mem_base != xmlMemBlocks()) {
15592: printf("Leak of %d blocks found in namePop",
15593: xmlMemBlocks() - mem_base);
15594: test_ret++;
15595: printf(" %d", n_ctxt);
15596: printf("\n");
15597: }
15598: }
15599: function_tests++;
15600:
15601: return(test_ret);
15602: }
15603:
15604:
15605: static int
15606: test_namePush(void) {
15607: int test_ret = 0;
15608:
15609: int mem_base;
15610: int ret_val;
15611: xmlParserCtxtPtr ctxt; /* an XML parser context */
15612: int n_ctxt;
15613: xmlChar * value; /* the element name */
15614: int n_value;
15615:
15616: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15617: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
15618: mem_base = xmlMemBlocks();
15619: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15620: value = gen_const_xmlChar_ptr(n_value, 1);
15621:
15622: ret_val = namePush(ctxt, (const xmlChar *)value);
15623: desret_int(ret_val);
15624: call_tests++;
15625: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15626: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
15627: xmlResetLastError();
15628: if (mem_base != xmlMemBlocks()) {
15629: printf("Leak of %d blocks found in namePush",
15630: xmlMemBlocks() - mem_base);
15631: test_ret++;
15632: printf(" %d", n_ctxt);
15633: printf(" %d", n_value);
15634: printf("\n");
15635: }
15636: }
15637: }
15638: function_tests++;
15639:
15640: return(test_ret);
15641: }
15642:
15643:
15644: static int
15645: test_nodePop(void) {
15646: int test_ret = 0;
15647:
15648: int mem_base;
15649: xmlNodePtr ret_val;
15650: xmlParserCtxtPtr ctxt; /* an XML parser context */
15651: int n_ctxt;
15652:
15653: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15654: mem_base = xmlMemBlocks();
15655: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15656:
15657: ret_val = nodePop(ctxt);
15658: desret_xmlNodePtr(ret_val);
15659: call_tests++;
15660: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15661: xmlResetLastError();
15662: if (mem_base != xmlMemBlocks()) {
15663: printf("Leak of %d blocks found in nodePop",
15664: xmlMemBlocks() - mem_base);
15665: test_ret++;
15666: printf(" %d", n_ctxt);
15667: printf("\n");
15668: }
15669: }
15670: function_tests++;
15671:
15672: return(test_ret);
15673: }
15674:
15675:
15676: static int
15677: test_nodePush(void) {
15678: int test_ret = 0;
15679:
15680: int mem_base;
15681: int ret_val;
15682: xmlParserCtxtPtr ctxt; /* an XML parser context */
15683: int n_ctxt;
15684: xmlNodePtr value; /* the element node */
15685: int n_value;
15686:
15687: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15688: for (n_value = 0;n_value < gen_nb_xmlNodePtr;n_value++) {
15689: mem_base = xmlMemBlocks();
15690: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15691: value = gen_xmlNodePtr(n_value, 1);
15692:
15693: ret_val = nodePush(ctxt, value);
15694: desret_int(ret_val);
15695: call_tests++;
15696: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15697: des_xmlNodePtr(n_value, value, 1);
15698: xmlResetLastError();
15699: if (mem_base != xmlMemBlocks()) {
15700: printf("Leak of %d blocks found in nodePush",
15701: xmlMemBlocks() - mem_base);
15702: test_ret++;
15703: printf(" %d", n_ctxt);
15704: printf(" %d", n_value);
15705: printf("\n");
15706: }
15707: }
15708: }
15709: function_tests++;
15710:
15711: return(test_ret);
15712: }
15713:
15714:
15715: static int
15716: test_xmlCheckLanguageID(void) {
15717: int test_ret = 0;
15718:
15719: int mem_base;
15720: int ret_val;
15721: xmlChar * lang; /* pointer to the string value */
15722: int n_lang;
15723:
15724: for (n_lang = 0;n_lang < gen_nb_const_xmlChar_ptr;n_lang++) {
15725: mem_base = xmlMemBlocks();
15726: lang = gen_const_xmlChar_ptr(n_lang, 0);
15727:
15728: ret_val = xmlCheckLanguageID((const xmlChar *)lang);
15729: desret_int(ret_val);
15730: call_tests++;
15731: des_const_xmlChar_ptr(n_lang, (const xmlChar *)lang, 0);
15732: xmlResetLastError();
15733: if (mem_base != xmlMemBlocks()) {
15734: printf("Leak of %d blocks found in xmlCheckLanguageID",
15735: xmlMemBlocks() - mem_base);
15736: test_ret++;
15737: printf(" %d", n_lang);
15738: printf("\n");
15739: }
15740: }
15741: function_tests++;
15742:
15743: return(test_ret);
15744: }
15745:
15746:
15747: static int
15748: test_xmlCopyChar(void) {
15749: int test_ret = 0;
15750:
15751: int mem_base;
15752: int ret_val;
15753: int len; /* Ignored, compatibility */
15754: int n_len;
15755: xmlChar * out; /* pointer to an array of xmlChar */
15756: int n_out;
15757: int val; /* the char value */
15758: int n_val;
15759:
15760: for (n_len = 0;n_len < gen_nb_int;n_len++) {
15761: for (n_out = 0;n_out < gen_nb_xmlChar_ptr;n_out++) {
15762: for (n_val = 0;n_val < gen_nb_int;n_val++) {
15763: mem_base = xmlMemBlocks();
15764: len = gen_int(n_len, 0);
15765: out = gen_xmlChar_ptr(n_out, 1);
15766: val = gen_int(n_val, 2);
15767:
15768: ret_val = xmlCopyChar(len, out, val);
15769: desret_int(ret_val);
15770: call_tests++;
15771: des_int(n_len, len, 0);
15772: des_xmlChar_ptr(n_out, out, 1);
15773: des_int(n_val, val, 2);
15774: xmlResetLastError();
15775: if (mem_base != xmlMemBlocks()) {
15776: printf("Leak of %d blocks found in xmlCopyChar",
15777: xmlMemBlocks() - mem_base);
15778: test_ret++;
15779: printf(" %d", n_len);
15780: printf(" %d", n_out);
15781: printf(" %d", n_val);
15782: printf("\n");
15783: }
15784: }
15785: }
15786: }
15787: function_tests++;
15788:
15789: return(test_ret);
15790: }
15791:
15792:
15793: static int
15794: test_xmlCopyCharMultiByte(void) {
15795: int test_ret = 0;
15796:
15797: int mem_base;
15798: int ret_val;
15799: xmlChar * out; /* pointer to an array of xmlChar */
15800: int n_out;
15801: int val; /* the char value */
15802: int n_val;
15803:
15804: for (n_out = 0;n_out < gen_nb_xmlChar_ptr;n_out++) {
15805: for (n_val = 0;n_val < gen_nb_int;n_val++) {
15806: mem_base = xmlMemBlocks();
15807: out = gen_xmlChar_ptr(n_out, 0);
15808: val = gen_int(n_val, 1);
15809:
15810: ret_val = xmlCopyCharMultiByte(out, val);
15811: desret_int(ret_val);
15812: call_tests++;
15813: des_xmlChar_ptr(n_out, out, 0);
15814: des_int(n_val, val, 1);
15815: xmlResetLastError();
15816: if (mem_base != xmlMemBlocks()) {
15817: printf("Leak of %d blocks found in xmlCopyCharMultiByte",
15818: xmlMemBlocks() - mem_base);
15819: test_ret++;
15820: printf(" %d", n_out);
15821: printf(" %d", n_val);
15822: printf("\n");
15823: }
15824: }
15825: }
15826: function_tests++;
15827:
15828: return(test_ret);
15829: }
15830:
15831:
15832: static int
15833: test_xmlCreateEntityParserCtxt(void) {
15834: int test_ret = 0;
15835:
15836: int mem_base;
15837: xmlParserCtxtPtr ret_val;
15838: xmlChar * URL; /* the entity URL */
15839: int n_URL;
15840: xmlChar * ID; /* the entity PUBLIC ID */
15841: int n_ID;
15842: xmlChar * base; /* a possible base for the target URI */
15843: int n_base;
15844:
15845: for (n_URL = 0;n_URL < gen_nb_const_xmlChar_ptr;n_URL++) {
15846: for (n_ID = 0;n_ID < gen_nb_const_xmlChar_ptr;n_ID++) {
15847: for (n_base = 0;n_base < gen_nb_const_xmlChar_ptr;n_base++) {
15848: mem_base = xmlMemBlocks();
15849: URL = gen_const_xmlChar_ptr(n_URL, 0);
15850: ID = gen_const_xmlChar_ptr(n_ID, 1);
15851: base = gen_const_xmlChar_ptr(n_base, 2);
15852:
15853: ret_val = xmlCreateEntityParserCtxt((const xmlChar *)URL, (const xmlChar *)ID, (const xmlChar *)base);
15854: desret_xmlParserCtxtPtr(ret_val);
15855: call_tests++;
15856: des_const_xmlChar_ptr(n_URL, (const xmlChar *)URL, 0);
15857: des_const_xmlChar_ptr(n_ID, (const xmlChar *)ID, 1);
15858: des_const_xmlChar_ptr(n_base, (const xmlChar *)base, 2);
15859: xmlResetLastError();
15860: if (mem_base != xmlMemBlocks()) {
15861: printf("Leak of %d blocks found in xmlCreateEntityParserCtxt",
15862: xmlMemBlocks() - mem_base);
15863: test_ret++;
15864: printf(" %d", n_URL);
15865: printf(" %d", n_ID);
15866: printf(" %d", n_base);
15867: printf("\n");
15868: }
15869: }
15870: }
15871: }
15872: function_tests++;
15873:
15874: return(test_ret);
15875: }
15876:
15877:
15878: static int
15879: test_xmlCreateFileParserCtxt(void) {
15880: int test_ret = 0;
15881:
15882: int mem_base;
15883: xmlParserCtxtPtr ret_val;
15884: const char * filename; /* the filename */
15885: int n_filename;
15886:
15887: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
15888: mem_base = xmlMemBlocks();
15889: filename = gen_fileoutput(n_filename, 0);
15890:
15891: ret_val = xmlCreateFileParserCtxt(filename);
15892: desret_xmlParserCtxtPtr(ret_val);
15893: call_tests++;
15894: des_fileoutput(n_filename, filename, 0);
15895: xmlResetLastError();
15896: if (mem_base != xmlMemBlocks()) {
15897: printf("Leak of %d blocks found in xmlCreateFileParserCtxt",
15898: xmlMemBlocks() - mem_base);
15899: test_ret++;
15900: printf(" %d", n_filename);
15901: printf("\n");
15902: }
15903: }
15904: function_tests++;
15905:
15906: return(test_ret);
15907: }
15908:
15909:
15910: static int
15911: test_xmlCreateMemoryParserCtxt(void) {
15912: int test_ret = 0;
15913:
15914: int mem_base;
15915: xmlParserCtxtPtr ret_val;
15916: char * buffer; /* a pointer to a char array */
15917: int n_buffer;
15918: int size; /* the size of the array */
15919: int n_size;
15920:
15921: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
15922: for (n_size = 0;n_size < gen_nb_int;n_size++) {
15923: mem_base = xmlMemBlocks();
15924: buffer = gen_const_char_ptr(n_buffer, 0);
15925: size = gen_int(n_size, 1);
15926:
15927: ret_val = xmlCreateMemoryParserCtxt((const char *)buffer, size);
15928: desret_xmlParserCtxtPtr(ret_val);
15929: call_tests++;
15930: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
15931: des_int(n_size, size, 1);
15932: xmlResetLastError();
15933: if (mem_base != xmlMemBlocks()) {
15934: printf("Leak of %d blocks found in xmlCreateMemoryParserCtxt",
15935: xmlMemBlocks() - mem_base);
15936: test_ret++;
15937: printf(" %d", n_buffer);
15938: printf(" %d", n_size);
15939: printf("\n");
15940: }
15941: }
15942: }
15943: function_tests++;
15944:
15945: return(test_ret);
15946: }
15947:
15948:
15949: static int
15950: test_xmlCreateURLParserCtxt(void) {
15951: int test_ret = 0;
15952:
15953: int mem_base;
15954: xmlParserCtxtPtr ret_val;
15955: const char * filename; /* the filename or URL */
15956: int n_filename;
15957: int options; /* a combination of xmlParserOption */
15958: int n_options;
15959:
15960: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
15961: for (n_options = 0;n_options < gen_nb_int;n_options++) {
15962: mem_base = xmlMemBlocks();
15963: filename = gen_fileoutput(n_filename, 0);
15964: options = gen_int(n_options, 1);
15965:
15966: ret_val = xmlCreateURLParserCtxt(filename, options);
15967: desret_xmlParserCtxtPtr(ret_val);
15968: call_tests++;
15969: des_fileoutput(n_filename, filename, 0);
15970: des_int(n_options, options, 1);
15971: xmlResetLastError();
15972: if (mem_base != xmlMemBlocks()) {
15973: printf("Leak of %d blocks found in xmlCreateURLParserCtxt",
15974: xmlMemBlocks() - mem_base);
15975: test_ret++;
15976: printf(" %d", n_filename);
15977: printf(" %d", n_options);
15978: printf("\n");
15979: }
15980: }
15981: }
15982: function_tests++;
15983:
15984: return(test_ret);
15985: }
15986:
15987:
15988: static int
15989: test_xmlCurrentChar(void) {
15990: int test_ret = 0;
15991:
15992: int mem_base;
15993: int ret_val;
15994: xmlParserCtxtPtr ctxt; /* the XML parser context */
15995: int n_ctxt;
15996: int * len; /* pointer to the length of the char read */
15997: int n_len;
15998:
15999: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16000: for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
16001: mem_base = xmlMemBlocks();
16002: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16003: len = gen_int_ptr(n_len, 1);
16004:
16005: ret_val = xmlCurrentChar(ctxt, len);
16006: desret_int(ret_val);
16007: call_tests++;
16008: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16009: des_int_ptr(n_len, len, 1);
16010: xmlResetLastError();
16011: if (mem_base != xmlMemBlocks()) {
16012: printf("Leak of %d blocks found in xmlCurrentChar",
16013: xmlMemBlocks() - mem_base);
16014: test_ret++;
16015: printf(" %d", n_ctxt);
16016: printf(" %d", n_len);
16017: printf("\n");
16018: }
16019: }
16020: }
16021: function_tests++;
16022:
16023: return(test_ret);
16024: }
16025:
16026:
16027: static int
16028: test_xmlErrMemory(void) {
16029: int test_ret = 0;
16030:
16031: int mem_base;
16032: xmlParserCtxtPtr ctxt; /* an XML parser context */
16033: int n_ctxt;
16034: char * extra; /* extra informations */
16035: int n_extra;
16036:
16037: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16038: for (n_extra = 0;n_extra < gen_nb_const_char_ptr;n_extra++) {
16039: mem_base = xmlMemBlocks();
16040: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16041: extra = gen_const_char_ptr(n_extra, 1);
16042:
16043: xmlErrMemory(ctxt, (const char *)extra);
16044: call_tests++;
16045: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16046: des_const_char_ptr(n_extra, (const char *)extra, 1);
16047: xmlResetLastError();
16048: if (mem_base != xmlMemBlocks()) {
16049: printf("Leak of %d blocks found in xmlErrMemory",
16050: xmlMemBlocks() - mem_base);
16051: test_ret++;
16052: printf(" %d", n_ctxt);
16053: printf(" %d", n_extra);
16054: printf("\n");
16055: }
16056: }
16057: }
16058: function_tests++;
16059:
16060: return(test_ret);
16061: }
16062:
16063:
16064: static int
16065: test_xmlIsLetter(void) {
16066: int test_ret = 0;
16067:
16068: int mem_base;
16069: int ret_val;
16070: int c; /* an unicode character (int) */
16071: int n_c;
16072:
16073: for (n_c = 0;n_c < gen_nb_int;n_c++) {
16074: mem_base = xmlMemBlocks();
16075: c = gen_int(n_c, 0);
16076:
16077: ret_val = xmlIsLetter(c);
16078: desret_int(ret_val);
16079: call_tests++;
16080: des_int(n_c, c, 0);
16081: xmlResetLastError();
16082: if (mem_base != xmlMemBlocks()) {
16083: printf("Leak of %d blocks found in xmlIsLetter",
16084: xmlMemBlocks() - mem_base);
16085: test_ret++;
16086: printf(" %d", n_c);
16087: printf("\n");
16088: }
16089: }
16090: function_tests++;
16091:
16092: return(test_ret);
16093: }
16094:
16095:
16096: static int
16097: test_xmlNewEntityInputStream(void) {
16098: int test_ret = 0;
16099:
16100: int mem_base;
16101: xmlParserInputPtr ret_val;
16102: xmlParserCtxtPtr ctxt; /* an XML parser context */
16103: int n_ctxt;
16104: xmlEntityPtr entity; /* an Entity pointer */
16105: int n_entity;
16106:
16107: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16108: for (n_entity = 0;n_entity < gen_nb_xmlEntityPtr;n_entity++) {
16109: mem_base = xmlMemBlocks();
16110: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16111: entity = gen_xmlEntityPtr(n_entity, 1);
16112:
16113: ret_val = xmlNewEntityInputStream(ctxt, entity);
16114: desret_xmlParserInputPtr(ret_val);
16115: call_tests++;
16116: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16117: des_xmlEntityPtr(n_entity, entity, 1);
16118: xmlResetLastError();
16119: if (mem_base != xmlMemBlocks()) {
16120: printf("Leak of %d blocks found in xmlNewEntityInputStream",
16121: xmlMemBlocks() - mem_base);
16122: test_ret++;
16123: printf(" %d", n_ctxt);
16124: printf(" %d", n_entity);
16125: printf("\n");
16126: }
16127: }
16128: }
16129: function_tests++;
16130:
16131: return(test_ret);
16132: }
16133:
16134:
16135: static int
16136: test_xmlNewInputFromFile(void) {
16137: int test_ret = 0;
16138:
16139: int mem_base;
16140: xmlParserInputPtr ret_val;
16141: xmlParserCtxtPtr ctxt; /* an XML parser context */
16142: int n_ctxt;
16143: const char * filename; /* the filename to use as entity */
16144: int n_filename;
16145:
16146: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16147: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
16148: mem_base = xmlMemBlocks();
16149: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16150: filename = gen_filepath(n_filename, 1);
16151:
16152: ret_val = xmlNewInputFromFile(ctxt, filename);
16153: desret_xmlParserInputPtr(ret_val);
16154: call_tests++;
16155: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16156: des_filepath(n_filename, filename, 1);
16157: xmlResetLastError();
16158: if (mem_base != xmlMemBlocks()) {
16159: printf("Leak of %d blocks found in xmlNewInputFromFile",
16160: xmlMemBlocks() - mem_base);
16161: test_ret++;
16162: printf(" %d", n_ctxt);
16163: printf(" %d", n_filename);
16164: printf("\n");
16165: }
16166: }
16167: }
16168: function_tests++;
16169:
16170: return(test_ret);
16171: }
16172:
16173:
16174: static int
16175: test_xmlNewInputStream(void) {
16176: int test_ret = 0;
16177:
16178: int mem_base;
16179: xmlParserInputPtr ret_val;
16180: xmlParserCtxtPtr ctxt; /* an XML parser context */
16181: int n_ctxt;
16182:
16183: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16184: mem_base = xmlMemBlocks();
16185: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16186:
16187: ret_val = xmlNewInputStream(ctxt);
16188: desret_xmlParserInputPtr(ret_val);
16189: call_tests++;
16190: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16191: xmlResetLastError();
16192: if (mem_base != xmlMemBlocks()) {
16193: printf("Leak of %d blocks found in xmlNewInputStream",
16194: xmlMemBlocks() - mem_base);
16195: test_ret++;
16196: printf(" %d", n_ctxt);
16197: printf("\n");
16198: }
16199: }
16200: function_tests++;
16201:
16202: return(test_ret);
16203: }
16204:
16205:
16206: static int
16207: test_xmlNewStringInputStream(void) {
16208: int test_ret = 0;
16209:
16210: int mem_base;
16211: xmlParserInputPtr ret_val;
16212: xmlParserCtxtPtr ctxt; /* an XML parser context */
16213: int n_ctxt;
16214: xmlChar * buffer; /* an memory buffer */
16215: int n_buffer;
16216:
16217: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16218: for (n_buffer = 0;n_buffer < gen_nb_const_xmlChar_ptr;n_buffer++) {
16219: mem_base = xmlMemBlocks();
16220: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16221: buffer = gen_const_xmlChar_ptr(n_buffer, 1);
16222:
16223: ret_val = xmlNewStringInputStream(ctxt, (const xmlChar *)buffer);
16224: desret_xmlParserInputPtr(ret_val);
16225: call_tests++;
16226: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16227: des_const_xmlChar_ptr(n_buffer, (const xmlChar *)buffer, 1);
16228: xmlResetLastError();
16229: if (mem_base != xmlMemBlocks()) {
16230: printf("Leak of %d blocks found in xmlNewStringInputStream",
16231: xmlMemBlocks() - mem_base);
16232: test_ret++;
16233: printf(" %d", n_ctxt);
16234: printf(" %d", n_buffer);
16235: printf("\n");
16236: }
16237: }
16238: }
16239: function_tests++;
16240:
16241: return(test_ret);
16242: }
16243:
16244:
16245: static int
16246: test_xmlNextChar(void) {
16247: int test_ret = 0;
16248:
16249: int mem_base;
16250: xmlParserCtxtPtr ctxt; /* the XML parser context */
16251: int n_ctxt;
16252:
16253: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16254: mem_base = xmlMemBlocks();
16255: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16256:
16257: xmlNextChar(ctxt);
16258: call_tests++;
16259: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16260: xmlResetLastError();
16261: if (mem_base != xmlMemBlocks()) {
16262: printf("Leak of %d blocks found in xmlNextChar",
16263: xmlMemBlocks() - mem_base);
16264: test_ret++;
16265: printf(" %d", n_ctxt);
16266: printf("\n");
16267: }
16268: }
16269: function_tests++;
16270:
16271: return(test_ret);
16272: }
16273:
16274:
16275: static int
16276: test_xmlParserInputShrink(void) {
16277: int test_ret = 0;
16278:
16279: int mem_base;
16280: xmlParserInputPtr in; /* an XML parser input */
16281: int n_in;
16282:
16283: for (n_in = 0;n_in < gen_nb_xmlParserInputPtr;n_in++) {
16284: mem_base = xmlMemBlocks();
16285: in = gen_xmlParserInputPtr(n_in, 0);
16286:
16287: xmlParserInputShrink(in);
16288: call_tests++;
16289: des_xmlParserInputPtr(n_in, in, 0);
16290: xmlResetLastError();
16291: if (mem_base != xmlMemBlocks()) {
16292: printf("Leak of %d blocks found in xmlParserInputShrink",
16293: xmlMemBlocks() - mem_base);
16294: test_ret++;
16295: printf(" %d", n_in);
16296: printf("\n");
16297: }
16298: }
16299: function_tests++;
16300:
16301: return(test_ret);
16302: }
16303:
16304:
16305: static int
16306: test_xmlPopInput(void) {
16307: int test_ret = 0;
16308:
16309: int mem_base;
16310: xmlChar ret_val;
16311: xmlParserCtxtPtr ctxt; /* an XML parser context */
16312: int n_ctxt;
16313:
16314: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16315: mem_base = xmlMemBlocks();
16316: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16317:
16318: ret_val = xmlPopInput(ctxt);
16319: desret_xmlChar(ret_val);
16320: call_tests++;
16321: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16322: xmlResetLastError();
16323: if (mem_base != xmlMemBlocks()) {
16324: printf("Leak of %d blocks found in xmlPopInput",
16325: xmlMemBlocks() - mem_base);
16326: test_ret++;
16327: printf(" %d", n_ctxt);
16328: printf("\n");
16329: }
16330: }
16331: function_tests++;
16332:
16333: return(test_ret);
16334: }
16335:
16336:
16337: static int
16338: test_xmlPushInput(void) {
16339: int test_ret = 0;
16340:
16341: int mem_base;
16342: int ret_val;
16343: xmlParserCtxtPtr ctxt; /* an XML parser context */
16344: int n_ctxt;
16345: xmlParserInputPtr input; /* an XML parser input fragment (entity, XML fragment ...). */
16346: int n_input;
16347:
16348: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16349: for (n_input = 0;n_input < gen_nb_xmlParserInputPtr;n_input++) {
16350: mem_base = xmlMemBlocks();
16351: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16352: input = gen_xmlParserInputPtr(n_input, 1);
16353:
16354: ret_val = xmlPushInput(ctxt, input);
16355: desret_int(ret_val);
16356: call_tests++;
16357: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16358: des_xmlParserInputPtr(n_input, input, 1);
16359: xmlResetLastError();
16360: if (mem_base != xmlMemBlocks()) {
16361: printf("Leak of %d blocks found in xmlPushInput",
16362: xmlMemBlocks() - mem_base);
16363: test_ret++;
16364: printf(" %d", n_ctxt);
16365: printf(" %d", n_input);
16366: printf("\n");
16367: }
16368: }
16369: }
16370: function_tests++;
16371:
16372: return(test_ret);
16373: }
16374:
16375:
16376: static int
16377: test_xmlSetEntityReferenceFunc(void) {
16378: int test_ret = 0;
16379:
16380:
16381: /* missing type support */
16382: return(test_ret);
16383: }
16384:
16385:
16386: static int
16387: test_xmlSplitQName(void) {
16388: int test_ret = 0;
16389:
16390: int mem_base;
16391: xmlChar * ret_val;
16392: xmlParserCtxtPtr ctxt; /* an XML parser context */
16393: int n_ctxt;
16394: xmlChar * name; /* an XML parser context */
16395: int n_name;
16396: xmlChar ** prefix; /* a xmlChar ** */
16397: int n_prefix;
16398:
16399: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16400: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
16401: for (n_prefix = 0;n_prefix < gen_nb_xmlChar_ptr_ptr;n_prefix++) {
16402: mem_base = xmlMemBlocks();
16403: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16404: name = gen_const_xmlChar_ptr(n_name, 1);
16405: prefix = gen_xmlChar_ptr_ptr(n_prefix, 2);
16406:
16407: ret_val = xmlSplitQName(ctxt, (const xmlChar *)name, prefix);
16408: desret_xmlChar_ptr(ret_val);
16409: call_tests++;
16410: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16411: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
16412: des_xmlChar_ptr_ptr(n_prefix, prefix, 2);
16413: xmlResetLastError();
16414: if (mem_base != xmlMemBlocks()) {
16415: printf("Leak of %d blocks found in xmlSplitQName",
16416: xmlMemBlocks() - mem_base);
16417: test_ret++;
16418: printf(" %d", n_ctxt);
16419: printf(" %d", n_name);
16420: printf(" %d", n_prefix);
16421: printf("\n");
16422: }
16423: }
16424: }
16425: }
16426: function_tests++;
16427:
16428: return(test_ret);
16429: }
16430:
16431:
16432: static int
16433: test_xmlStringCurrentChar(void) {
16434: int test_ret = 0;
16435:
16436: int mem_base;
16437: int ret_val;
16438: xmlParserCtxtPtr ctxt; /* the XML parser context */
16439: int n_ctxt;
16440: xmlChar * cur; /* pointer to the beginning of the char */
16441: int n_cur;
16442: int * len; /* pointer to the length of the char read */
16443: int n_len;
16444:
16445: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16446: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
16447: for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
16448: mem_base = xmlMemBlocks();
16449: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16450: cur = gen_const_xmlChar_ptr(n_cur, 1);
16451: len = gen_int_ptr(n_len, 2);
16452:
16453: ret_val = xmlStringCurrentChar(ctxt, (const xmlChar *)cur, len);
16454: desret_int(ret_val);
16455: call_tests++;
16456: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16457: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 1);
16458: des_int_ptr(n_len, len, 2);
16459: xmlResetLastError();
16460: if (mem_base != xmlMemBlocks()) {
16461: printf("Leak of %d blocks found in xmlStringCurrentChar",
16462: xmlMemBlocks() - mem_base);
16463: test_ret++;
16464: printf(" %d", n_ctxt);
16465: printf(" %d", n_cur);
16466: printf(" %d", n_len);
16467: printf("\n");
16468: }
16469: }
16470: }
16471: }
16472: function_tests++;
16473:
16474: return(test_ret);
16475: }
16476:
16477:
16478: static int
16479: test_xmlStringDecodeEntities(void) {
16480: int test_ret = 0;
16481:
16482: int mem_base;
16483: xmlChar * ret_val;
16484: xmlParserCtxtPtr ctxt; /* the parser context */
16485: int n_ctxt;
16486: xmlChar * str; /* the input string */
16487: int n_str;
16488: int what; /* combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF */
16489: int n_what;
16490: xmlChar end; /* an end marker xmlChar, 0 if none */
16491: int n_end;
16492: xmlChar end2; /* an end marker xmlChar, 0 if none */
16493: int n_end2;
16494: xmlChar end3; /* an end marker xmlChar, 0 if none */
16495: int n_end3;
16496:
16497: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16498: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
16499: for (n_what = 0;n_what < gen_nb_int;n_what++) {
16500: for (n_end = 0;n_end < gen_nb_xmlChar;n_end++) {
16501: for (n_end2 = 0;n_end2 < gen_nb_xmlChar;n_end2++) {
16502: for (n_end3 = 0;n_end3 < gen_nb_xmlChar;n_end3++) {
16503: mem_base = xmlMemBlocks();
16504: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16505: str = gen_const_xmlChar_ptr(n_str, 1);
16506: what = gen_int(n_what, 2);
16507: end = gen_xmlChar(n_end, 3);
16508: end2 = gen_xmlChar(n_end2, 4);
16509: end3 = gen_xmlChar(n_end3, 5);
16510:
16511: ret_val = xmlStringDecodeEntities(ctxt, (const xmlChar *)str, what, end, end2, end3);
16512: desret_xmlChar_ptr(ret_val);
16513: call_tests++;
16514: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16515: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
16516: des_int(n_what, what, 2);
16517: des_xmlChar(n_end, end, 3);
16518: des_xmlChar(n_end2, end2, 4);
16519: des_xmlChar(n_end3, end3, 5);
16520: xmlResetLastError();
16521: if (mem_base != xmlMemBlocks()) {
16522: printf("Leak of %d blocks found in xmlStringDecodeEntities",
16523: xmlMemBlocks() - mem_base);
16524: test_ret++;
16525: printf(" %d", n_ctxt);
16526: printf(" %d", n_str);
16527: printf(" %d", n_what);
16528: printf(" %d", n_end);
16529: printf(" %d", n_end2);
16530: printf(" %d", n_end3);
16531: printf("\n");
16532: }
16533: }
16534: }
16535: }
16536: }
16537: }
16538: }
16539: function_tests++;
16540:
16541: return(test_ret);
16542: }
16543:
16544:
16545: static int
16546: test_xmlStringLenDecodeEntities(void) {
16547: int test_ret = 0;
16548:
16549: int mem_base;
16550: xmlChar * ret_val;
16551: xmlParserCtxtPtr ctxt; /* the parser context */
16552: int n_ctxt;
16553: xmlChar * str; /* the input string */
16554: int n_str;
16555: int len; /* the string length */
16556: int n_len;
16557: int what; /* combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF */
16558: int n_what;
16559: xmlChar end; /* an end marker xmlChar, 0 if none */
16560: int n_end;
16561: xmlChar end2; /* an end marker xmlChar, 0 if none */
16562: int n_end2;
16563: xmlChar end3; /* an end marker xmlChar, 0 if none */
16564: int n_end3;
16565:
16566: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16567: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
16568: for (n_len = 0;n_len < gen_nb_int;n_len++) {
16569: for (n_what = 0;n_what < gen_nb_int;n_what++) {
16570: for (n_end = 0;n_end < gen_nb_xmlChar;n_end++) {
16571: for (n_end2 = 0;n_end2 < gen_nb_xmlChar;n_end2++) {
16572: for (n_end3 = 0;n_end3 < gen_nb_xmlChar;n_end3++) {
16573: mem_base = xmlMemBlocks();
16574: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16575: str = gen_const_xmlChar_ptr(n_str, 1);
16576: len = gen_int(n_len, 2);
16577: what = gen_int(n_what, 3);
16578: end = gen_xmlChar(n_end, 4);
16579: end2 = gen_xmlChar(n_end2, 5);
16580: end3 = gen_xmlChar(n_end3, 6);
16581:
16582: ret_val = xmlStringLenDecodeEntities(ctxt, (const xmlChar *)str, len, what, end, end2, end3);
16583: desret_xmlChar_ptr(ret_val);
16584: call_tests++;
16585: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16586: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
16587: des_int(n_len, len, 2);
16588: des_int(n_what, what, 3);
16589: des_xmlChar(n_end, end, 4);
16590: des_xmlChar(n_end2, end2, 5);
16591: des_xmlChar(n_end3, end3, 6);
16592: xmlResetLastError();
16593: if (mem_base != xmlMemBlocks()) {
16594: printf("Leak of %d blocks found in xmlStringLenDecodeEntities",
16595: xmlMemBlocks() - mem_base);
16596: test_ret++;
16597: printf(" %d", n_ctxt);
16598: printf(" %d", n_str);
16599: printf(" %d", n_len);
16600: printf(" %d", n_what);
16601: printf(" %d", n_end);
16602: printf(" %d", n_end2);
16603: printf(" %d", n_end3);
16604: printf("\n");
16605: }
16606: }
16607: }
16608: }
16609: }
16610: }
16611: }
16612: }
16613: function_tests++;
16614:
16615: return(test_ret);
16616: }
16617:
16618:
16619: static int
16620: test_xmlSwitchEncoding(void) {
16621: int test_ret = 0;
16622:
16623: int mem_base;
16624: int ret_val;
16625: xmlParserCtxtPtr ctxt; /* the parser context */
16626: int n_ctxt;
16627: xmlCharEncoding enc; /* the encoding value (number) */
16628: int n_enc;
16629:
16630: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16631: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
16632: mem_base = xmlMemBlocks();
16633: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16634: enc = gen_xmlCharEncoding(n_enc, 1);
16635:
16636: ret_val = xmlSwitchEncoding(ctxt, enc);
16637: desret_int(ret_val);
16638: call_tests++;
16639: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16640: des_xmlCharEncoding(n_enc, enc, 1);
16641: xmlResetLastError();
16642: if (mem_base != xmlMemBlocks()) {
16643: printf("Leak of %d blocks found in xmlSwitchEncoding",
16644: xmlMemBlocks() - mem_base);
16645: test_ret++;
16646: printf(" %d", n_ctxt);
16647: printf(" %d", n_enc);
16648: printf("\n");
16649: }
16650: }
16651: }
16652: function_tests++;
16653:
16654: return(test_ret);
16655: }
16656:
16657:
16658: static int
16659: test_xmlSwitchInputEncoding(void) {
16660: int test_ret = 0;
16661:
16662: int mem_base;
16663: int ret_val;
16664: xmlParserCtxtPtr ctxt; /* the parser context */
16665: int n_ctxt;
16666: xmlParserInputPtr input; /* the input stream */
16667: int n_input;
16668: xmlCharEncodingHandlerPtr handler; /* the encoding handler */
16669: int n_handler;
16670:
16671: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16672: for (n_input = 0;n_input < gen_nb_xmlParserInputPtr;n_input++) {
16673: for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandlerPtr;n_handler++) {
16674: mem_base = xmlMemBlocks();
16675: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16676: input = gen_xmlParserInputPtr(n_input, 1);
16677: handler = gen_xmlCharEncodingHandlerPtr(n_handler, 2);
16678:
16679: ret_val = xmlSwitchInputEncoding(ctxt, input, handler);
16680: desret_int(ret_val);
16681: call_tests++;
16682: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16683: des_xmlParserInputPtr(n_input, input, 1);
16684: des_xmlCharEncodingHandlerPtr(n_handler, handler, 2);
16685: xmlResetLastError();
16686: if (mem_base != xmlMemBlocks()) {
16687: printf("Leak of %d blocks found in xmlSwitchInputEncoding",
16688: xmlMemBlocks() - mem_base);
16689: test_ret++;
16690: printf(" %d", n_ctxt);
16691: printf(" %d", n_input);
16692: printf(" %d", n_handler);
16693: printf("\n");
16694: }
16695: }
16696: }
16697: }
16698: function_tests++;
16699:
16700: return(test_ret);
16701: }
16702:
16703:
16704: static int
16705: test_xmlSwitchToEncoding(void) {
16706: int test_ret = 0;
16707:
16708: int mem_base;
16709: int ret_val;
16710: xmlParserCtxtPtr ctxt; /* the parser context */
16711: int n_ctxt;
16712: xmlCharEncodingHandlerPtr handler; /* the encoding handler */
16713: int n_handler;
16714:
16715: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16716: for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandlerPtr;n_handler++) {
16717: mem_base = xmlMemBlocks();
16718: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16719: handler = gen_xmlCharEncodingHandlerPtr(n_handler, 1);
16720:
16721: ret_val = xmlSwitchToEncoding(ctxt, handler);
16722: desret_int(ret_val);
16723: call_tests++;
16724: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16725: des_xmlCharEncodingHandlerPtr(n_handler, handler, 1);
16726: xmlResetLastError();
16727: if (mem_base != xmlMemBlocks()) {
16728: printf("Leak of %d blocks found in xmlSwitchToEncoding",
16729: xmlMemBlocks() - mem_base);
16730: test_ret++;
16731: printf(" %d", n_ctxt);
16732: printf(" %d", n_handler);
16733: printf("\n");
16734: }
16735: }
16736: }
16737: function_tests++;
16738:
16739: return(test_ret);
16740: }
16741:
16742: static int
16743: test_parserInternals(void) {
16744: int test_ret = 0;
16745:
16746: if (quiet == 0) printf("Testing parserInternals : 33 of 90 functions ...\n");
16747: test_ret += test_htmlCreateFileParserCtxt();
16748: test_ret += test_htmlInitAutoClose();
16749: test_ret += test_inputPop();
16750: test_ret += test_inputPush();
16751: test_ret += test_namePop();
16752: test_ret += test_namePush();
16753: test_ret += test_nodePop();
16754: test_ret += test_nodePush();
16755: test_ret += test_xmlCheckLanguageID();
16756: test_ret += test_xmlCopyChar();
16757: test_ret += test_xmlCopyCharMultiByte();
16758: test_ret += test_xmlCreateEntityParserCtxt();
16759: test_ret += test_xmlCreateFileParserCtxt();
16760: test_ret += test_xmlCreateMemoryParserCtxt();
16761: test_ret += test_xmlCreateURLParserCtxt();
16762: test_ret += test_xmlCurrentChar();
16763: test_ret += test_xmlErrMemory();
16764: test_ret += test_xmlIsLetter();
16765: test_ret += test_xmlNewEntityInputStream();
16766: test_ret += test_xmlNewInputFromFile();
16767: test_ret += test_xmlNewInputStream();
16768: test_ret += test_xmlNewStringInputStream();
16769: test_ret += test_xmlNextChar();
16770: test_ret += test_xmlParserInputShrink();
16771: test_ret += test_xmlPopInput();
16772: test_ret += test_xmlPushInput();
16773: test_ret += test_xmlSetEntityReferenceFunc();
16774: test_ret += test_xmlSplitQName();
16775: test_ret += test_xmlStringCurrentChar();
16776: test_ret += test_xmlStringDecodeEntities();
16777: test_ret += test_xmlStringLenDecodeEntities();
16778: test_ret += test_xmlSwitchEncoding();
16779: test_ret += test_xmlSwitchInputEncoding();
16780: test_ret += test_xmlSwitchToEncoding();
16781:
16782: if (test_ret != 0)
16783: printf("Module parserInternals: %d errors\n", test_ret);
16784: return(test_ret);
16785: }
16786:
16787: static int
16788: test_xmlPatternFromRoot(void) {
16789: int test_ret = 0;
16790:
16791: #if defined(LIBXML_PATTERN_ENABLED)
16792: int mem_base;
16793: int ret_val;
16794: xmlPatternPtr comp; /* the precompiled pattern */
16795: int n_comp;
16796:
16797: for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) {
16798: mem_base = xmlMemBlocks();
16799: comp = gen_xmlPatternPtr(n_comp, 0);
16800:
16801: ret_val = xmlPatternFromRoot(comp);
16802: desret_int(ret_val);
16803: call_tests++;
16804: des_xmlPatternPtr(n_comp, comp, 0);
16805: xmlResetLastError();
16806: if (mem_base != xmlMemBlocks()) {
16807: printf("Leak of %d blocks found in xmlPatternFromRoot",
16808: xmlMemBlocks() - mem_base);
16809: test_ret++;
16810: printf(" %d", n_comp);
16811: printf("\n");
16812: }
16813: }
16814: function_tests++;
16815: #endif
16816:
16817: return(test_ret);
16818: }
16819:
16820:
16821: static int
16822: test_xmlPatternGetStreamCtxt(void) {
16823: int test_ret = 0;
16824:
16825:
16826: /* missing type support */
16827: return(test_ret);
16828: }
16829:
16830:
16831: static int
16832: test_xmlPatternMatch(void) {
16833: int test_ret = 0;
16834:
16835: #if defined(LIBXML_PATTERN_ENABLED)
16836: int mem_base;
16837: int ret_val;
16838: xmlPatternPtr comp; /* the precompiled pattern */
16839: int n_comp;
16840: xmlNodePtr node; /* a node */
16841: int n_node;
16842:
16843: for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) {
16844: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
16845: mem_base = xmlMemBlocks();
16846: comp = gen_xmlPatternPtr(n_comp, 0);
16847: node = gen_xmlNodePtr(n_node, 1);
16848:
16849: ret_val = xmlPatternMatch(comp, node);
16850: desret_int(ret_val);
16851: call_tests++;
16852: des_xmlPatternPtr(n_comp, comp, 0);
16853: des_xmlNodePtr(n_node, node, 1);
16854: xmlResetLastError();
16855: if (mem_base != xmlMemBlocks()) {
16856: printf("Leak of %d blocks found in xmlPatternMatch",
16857: xmlMemBlocks() - mem_base);
16858: test_ret++;
16859: printf(" %d", n_comp);
16860: printf(" %d", n_node);
16861: printf("\n");
16862: }
16863: }
16864: }
16865: function_tests++;
16866: #endif
16867:
16868: return(test_ret);
16869: }
16870:
16871:
16872: static int
16873: test_xmlPatternMaxDepth(void) {
16874: int test_ret = 0;
16875:
16876: #if defined(LIBXML_PATTERN_ENABLED)
16877: int mem_base;
16878: int ret_val;
16879: xmlPatternPtr comp; /* the precompiled pattern */
16880: int n_comp;
16881:
16882: for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) {
16883: mem_base = xmlMemBlocks();
16884: comp = gen_xmlPatternPtr(n_comp, 0);
16885:
16886: ret_val = xmlPatternMaxDepth(comp);
16887: desret_int(ret_val);
16888: call_tests++;
16889: des_xmlPatternPtr(n_comp, comp, 0);
16890: xmlResetLastError();
16891: if (mem_base != xmlMemBlocks()) {
16892: printf("Leak of %d blocks found in xmlPatternMaxDepth",
16893: xmlMemBlocks() - mem_base);
16894: test_ret++;
16895: printf(" %d", n_comp);
16896: printf("\n");
16897: }
16898: }
16899: function_tests++;
16900: #endif
16901:
16902: return(test_ret);
16903: }
16904:
16905:
16906: static int
16907: test_xmlPatternMinDepth(void) {
16908: int test_ret = 0;
16909:
16910: #if defined(LIBXML_PATTERN_ENABLED)
16911: int mem_base;
16912: int ret_val;
16913: xmlPatternPtr comp; /* the precompiled pattern */
16914: int n_comp;
16915:
16916: for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) {
16917: mem_base = xmlMemBlocks();
16918: comp = gen_xmlPatternPtr(n_comp, 0);
16919:
16920: ret_val = xmlPatternMinDepth(comp);
16921: desret_int(ret_val);
16922: call_tests++;
16923: des_xmlPatternPtr(n_comp, comp, 0);
16924: xmlResetLastError();
16925: if (mem_base != xmlMemBlocks()) {
16926: printf("Leak of %d blocks found in xmlPatternMinDepth",
16927: xmlMemBlocks() - mem_base);
16928: test_ret++;
16929: printf(" %d", n_comp);
16930: printf("\n");
16931: }
16932: }
16933: function_tests++;
16934: #endif
16935:
16936: return(test_ret);
16937: }
16938:
16939:
16940: static int
16941: test_xmlPatternStreamable(void) {
16942: int test_ret = 0;
16943:
16944: #if defined(LIBXML_PATTERN_ENABLED)
16945: int mem_base;
16946: int ret_val;
16947: xmlPatternPtr comp; /* the precompiled pattern */
16948: int n_comp;
16949:
16950: for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) {
16951: mem_base = xmlMemBlocks();
16952: comp = gen_xmlPatternPtr(n_comp, 0);
16953:
16954: ret_val = xmlPatternStreamable(comp);
16955: desret_int(ret_val);
16956: call_tests++;
16957: des_xmlPatternPtr(n_comp, comp, 0);
16958: xmlResetLastError();
16959: if (mem_base != xmlMemBlocks()) {
16960: printf("Leak of %d blocks found in xmlPatternStreamable",
16961: xmlMemBlocks() - mem_base);
16962: test_ret++;
16963: printf(" %d", n_comp);
16964: printf("\n");
16965: }
16966: }
16967: function_tests++;
16968: #endif
16969:
16970: return(test_ret);
16971: }
16972:
16973:
16974: static int
16975: test_xmlPatterncompile(void) {
16976: int test_ret = 0;
16977:
16978:
16979: /* missing type support */
16980: return(test_ret);
16981: }
16982:
16983: #ifdef LIBXML_PATTERN_ENABLED
16984:
16985: #define gen_nb_xmlStreamCtxtPtr 1
16986: static xmlStreamCtxtPtr gen_xmlStreamCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
16987: return(NULL);
16988: }
16989: static void des_xmlStreamCtxtPtr(int no ATTRIBUTE_UNUSED, xmlStreamCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
16990: }
16991: #endif
16992:
16993:
16994: static int
16995: test_xmlStreamPop(void) {
16996: int test_ret = 0;
16997:
16998: #if defined(LIBXML_PATTERN_ENABLED)
16999: int mem_base;
17000: int ret_val;
17001: xmlStreamCtxtPtr stream; /* the stream context */
17002: int n_stream;
17003:
17004: for (n_stream = 0;n_stream < gen_nb_xmlStreamCtxtPtr;n_stream++) {
17005: mem_base = xmlMemBlocks();
17006: stream = gen_xmlStreamCtxtPtr(n_stream, 0);
17007:
17008: ret_val = xmlStreamPop(stream);
17009: desret_int(ret_val);
17010: call_tests++;
17011: des_xmlStreamCtxtPtr(n_stream, stream, 0);
17012: xmlResetLastError();
17013: if (mem_base != xmlMemBlocks()) {
17014: printf("Leak of %d blocks found in xmlStreamPop",
17015: xmlMemBlocks() - mem_base);
17016: test_ret++;
17017: printf(" %d", n_stream);
17018: printf("\n");
17019: }
17020: }
17021: function_tests++;
17022: #endif
17023:
17024: return(test_ret);
17025: }
17026:
17027:
17028: static int
17029: test_xmlStreamPush(void) {
17030: int test_ret = 0;
17031:
17032: #if defined(LIBXML_PATTERN_ENABLED)
17033: int mem_base;
17034: int ret_val;
17035: xmlStreamCtxtPtr stream; /* the stream context */
17036: int n_stream;
17037: xmlChar * name; /* the current name */
17038: int n_name;
17039: xmlChar * ns; /* the namespace name */
17040: int n_ns;
17041:
17042: for (n_stream = 0;n_stream < gen_nb_xmlStreamCtxtPtr;n_stream++) {
17043: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
17044: for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) {
17045: mem_base = xmlMemBlocks();
17046: stream = gen_xmlStreamCtxtPtr(n_stream, 0);
17047: name = gen_const_xmlChar_ptr(n_name, 1);
17048: ns = gen_const_xmlChar_ptr(n_ns, 2);
17049:
17050: ret_val = xmlStreamPush(stream, (const xmlChar *)name, (const xmlChar *)ns);
17051: desret_int(ret_val);
17052: call_tests++;
17053: des_xmlStreamCtxtPtr(n_stream, stream, 0);
17054: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
17055: des_const_xmlChar_ptr(n_ns, (const xmlChar *)ns, 2);
17056: xmlResetLastError();
17057: if (mem_base != xmlMemBlocks()) {
17058: printf("Leak of %d blocks found in xmlStreamPush",
17059: xmlMemBlocks() - mem_base);
17060: test_ret++;
17061: printf(" %d", n_stream);
17062: printf(" %d", n_name);
17063: printf(" %d", n_ns);
17064: printf("\n");
17065: }
17066: }
17067: }
17068: }
17069: function_tests++;
17070: #endif
17071:
17072: return(test_ret);
17073: }
17074:
17075:
17076: static int
17077: test_xmlStreamPushAttr(void) {
17078: int test_ret = 0;
17079:
17080: #if defined(LIBXML_PATTERN_ENABLED)
17081: int mem_base;
17082: int ret_val;
17083: xmlStreamCtxtPtr stream; /* the stream context */
17084: int n_stream;
17085: xmlChar * name; /* the current name */
17086: int n_name;
17087: xmlChar * ns; /* the namespace name */
17088: int n_ns;
17089:
17090: for (n_stream = 0;n_stream < gen_nb_xmlStreamCtxtPtr;n_stream++) {
17091: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
17092: for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) {
17093: mem_base = xmlMemBlocks();
17094: stream = gen_xmlStreamCtxtPtr(n_stream, 0);
17095: name = gen_const_xmlChar_ptr(n_name, 1);
17096: ns = gen_const_xmlChar_ptr(n_ns, 2);
17097:
17098: ret_val = xmlStreamPushAttr(stream, (const xmlChar *)name, (const xmlChar *)ns);
17099: desret_int(ret_val);
17100: call_tests++;
17101: des_xmlStreamCtxtPtr(n_stream, stream, 0);
17102: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
17103: des_const_xmlChar_ptr(n_ns, (const xmlChar *)ns, 2);
17104: xmlResetLastError();
17105: if (mem_base != xmlMemBlocks()) {
17106: printf("Leak of %d blocks found in xmlStreamPushAttr",
17107: xmlMemBlocks() - mem_base);
17108: test_ret++;
17109: printf(" %d", n_stream);
17110: printf(" %d", n_name);
17111: printf(" %d", n_ns);
17112: printf("\n");
17113: }
17114: }
17115: }
17116: }
17117: function_tests++;
17118: #endif
17119:
17120: return(test_ret);
17121: }
17122:
17123:
17124: static int
17125: test_xmlStreamPushNode(void) {
17126: int test_ret = 0;
17127:
17128: #if defined(LIBXML_PATTERN_ENABLED)
17129: int mem_base;
17130: int ret_val;
17131: xmlStreamCtxtPtr stream; /* the stream context */
17132: int n_stream;
17133: xmlChar * name; /* the current name */
17134: int n_name;
17135: xmlChar * ns; /* the namespace name */
17136: int n_ns;
17137: int nodeType; /* the type of the node being pushed */
17138: int n_nodeType;
17139:
17140: for (n_stream = 0;n_stream < gen_nb_xmlStreamCtxtPtr;n_stream++) {
17141: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
17142: for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) {
17143: for (n_nodeType = 0;n_nodeType < gen_nb_int;n_nodeType++) {
17144: mem_base = xmlMemBlocks();
17145: stream = gen_xmlStreamCtxtPtr(n_stream, 0);
17146: name = gen_const_xmlChar_ptr(n_name, 1);
17147: ns = gen_const_xmlChar_ptr(n_ns, 2);
17148: nodeType = gen_int(n_nodeType, 3);
17149:
17150: ret_val = xmlStreamPushNode(stream, (const xmlChar *)name, (const xmlChar *)ns, nodeType);
17151: desret_int(ret_val);
17152: call_tests++;
17153: des_xmlStreamCtxtPtr(n_stream, stream, 0);
17154: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
17155: des_const_xmlChar_ptr(n_ns, (const xmlChar *)ns, 2);
17156: des_int(n_nodeType, nodeType, 3);
17157: xmlResetLastError();
17158: if (mem_base != xmlMemBlocks()) {
17159: printf("Leak of %d blocks found in xmlStreamPushNode",
17160: xmlMemBlocks() - mem_base);
17161: test_ret++;
17162: printf(" %d", n_stream);
17163: printf(" %d", n_name);
17164: printf(" %d", n_ns);
17165: printf(" %d", n_nodeType);
17166: printf("\n");
17167: }
17168: }
17169: }
17170: }
17171: }
17172: function_tests++;
17173: #endif
17174:
17175: return(test_ret);
17176: }
17177:
17178:
17179: static int
17180: test_xmlStreamWantsAnyNode(void) {
17181: int test_ret = 0;
17182:
17183: #if defined(LIBXML_PATTERN_ENABLED)
17184: int mem_base;
17185: int ret_val;
17186: xmlStreamCtxtPtr streamCtxt; /* the stream context */
17187: int n_streamCtxt;
17188:
17189: for (n_streamCtxt = 0;n_streamCtxt < gen_nb_xmlStreamCtxtPtr;n_streamCtxt++) {
17190: mem_base = xmlMemBlocks();
17191: streamCtxt = gen_xmlStreamCtxtPtr(n_streamCtxt, 0);
17192:
17193: ret_val = xmlStreamWantsAnyNode(streamCtxt);
17194: desret_int(ret_val);
17195: call_tests++;
17196: des_xmlStreamCtxtPtr(n_streamCtxt, streamCtxt, 0);
17197: xmlResetLastError();
17198: if (mem_base != xmlMemBlocks()) {
17199: printf("Leak of %d blocks found in xmlStreamWantsAnyNode",
17200: xmlMemBlocks() - mem_base);
17201: test_ret++;
17202: printf(" %d", n_streamCtxt);
17203: printf("\n");
17204: }
17205: }
17206: function_tests++;
17207: #endif
17208:
17209: return(test_ret);
17210: }
17211:
17212: static int
17213: test_pattern(void) {
17214: int test_ret = 0;
17215:
17216: if (quiet == 0) printf("Testing pattern : 10 of 15 functions ...\n");
17217: test_ret += test_xmlPatternFromRoot();
17218: test_ret += test_xmlPatternGetStreamCtxt();
17219: test_ret += test_xmlPatternMatch();
17220: test_ret += test_xmlPatternMaxDepth();
17221: test_ret += test_xmlPatternMinDepth();
17222: test_ret += test_xmlPatternStreamable();
17223: test_ret += test_xmlPatterncompile();
17224: test_ret += test_xmlStreamPop();
17225: test_ret += test_xmlStreamPush();
17226: test_ret += test_xmlStreamPushAttr();
17227: test_ret += test_xmlStreamPushNode();
17228: test_ret += test_xmlStreamWantsAnyNode();
17229:
17230: if (test_ret != 0)
17231: printf("Module pattern: %d errors\n", test_ret);
17232: return(test_ret);
17233: }
17234: #ifdef LIBXML_SCHEMAS_ENABLED
17235:
17236: #define gen_nb_xmlRelaxNGPtr 1
17237: static xmlRelaxNGPtr gen_xmlRelaxNGPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17238: return(NULL);
17239: }
17240: static void des_xmlRelaxNGPtr(int no ATTRIBUTE_UNUSED, xmlRelaxNGPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17241: }
17242: #endif
17243:
17244:
17245: static int
17246: test_xmlRelaxNGDump(void) {
17247: int test_ret = 0;
17248:
17249: #if defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
17250: int mem_base;
17251: FILE * output; /* the file output */
17252: int n_output;
17253: xmlRelaxNGPtr schema; /* a schema structure */
17254: int n_schema;
17255:
17256: for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
17257: for (n_schema = 0;n_schema < gen_nb_xmlRelaxNGPtr;n_schema++) {
17258: mem_base = xmlMemBlocks();
17259: output = gen_FILE_ptr(n_output, 0);
17260: schema = gen_xmlRelaxNGPtr(n_schema, 1);
17261:
17262: xmlRelaxNGDump(output, schema);
17263: call_tests++;
17264: des_FILE_ptr(n_output, output, 0);
17265: des_xmlRelaxNGPtr(n_schema, schema, 1);
17266: xmlResetLastError();
17267: if (mem_base != xmlMemBlocks()) {
17268: printf("Leak of %d blocks found in xmlRelaxNGDump",
17269: xmlMemBlocks() - mem_base);
17270: test_ret++;
17271: printf(" %d", n_output);
17272: printf(" %d", n_schema);
17273: printf("\n");
17274: }
17275: }
17276: }
17277: function_tests++;
17278: #endif
17279:
17280: return(test_ret);
17281: }
17282:
17283:
17284: static int
17285: test_xmlRelaxNGDumpTree(void) {
17286: int test_ret = 0;
17287:
17288: #if defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
17289: int mem_base;
17290: FILE * output; /* the file output */
17291: int n_output;
17292: xmlRelaxNGPtr schema; /* a schema structure */
17293: int n_schema;
17294:
17295: for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
17296: for (n_schema = 0;n_schema < gen_nb_xmlRelaxNGPtr;n_schema++) {
17297: mem_base = xmlMemBlocks();
17298: output = gen_FILE_ptr(n_output, 0);
17299: schema = gen_xmlRelaxNGPtr(n_schema, 1);
17300:
17301: xmlRelaxNGDumpTree(output, schema);
17302: call_tests++;
17303: des_FILE_ptr(n_output, output, 0);
17304: des_xmlRelaxNGPtr(n_schema, schema, 1);
17305: xmlResetLastError();
17306: if (mem_base != xmlMemBlocks()) {
17307: printf("Leak of %d blocks found in xmlRelaxNGDumpTree",
17308: xmlMemBlocks() - mem_base);
17309: test_ret++;
17310: printf(" %d", n_output);
17311: printf(" %d", n_schema);
17312: printf("\n");
17313: }
17314: }
17315: }
17316: function_tests++;
17317: #endif
17318:
17319: return(test_ret);
17320: }
17321:
17322: #ifdef LIBXML_SCHEMAS_ENABLED
17323:
17324: #define gen_nb_xmlRelaxNGParserCtxtPtr 1
17325: static xmlRelaxNGParserCtxtPtr gen_xmlRelaxNGParserCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17326: return(NULL);
17327: }
17328: static void des_xmlRelaxNGParserCtxtPtr(int no ATTRIBUTE_UNUSED, xmlRelaxNGParserCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17329: }
17330: #endif
17331:
17332: #ifdef LIBXML_SCHEMAS_ENABLED
17333:
17334: #define gen_nb_xmlRelaxNGValidityErrorFunc_ptr 1
17335: static xmlRelaxNGValidityErrorFunc * gen_xmlRelaxNGValidityErrorFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17336: return(NULL);
17337: }
17338: static void des_xmlRelaxNGValidityErrorFunc_ptr(int no ATTRIBUTE_UNUSED, xmlRelaxNGValidityErrorFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17339: }
17340: #endif
17341:
17342: #ifdef LIBXML_SCHEMAS_ENABLED
17343:
17344: #define gen_nb_xmlRelaxNGValidityWarningFunc_ptr 1
17345: static xmlRelaxNGValidityWarningFunc * gen_xmlRelaxNGValidityWarningFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17346: return(NULL);
17347: }
17348: static void des_xmlRelaxNGValidityWarningFunc_ptr(int no ATTRIBUTE_UNUSED, xmlRelaxNGValidityWarningFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17349: }
17350: #endif
17351:
17352:
17353: static int
17354: test_xmlRelaxNGGetParserErrors(void) {
17355: int test_ret = 0;
17356:
17357: #if defined(LIBXML_SCHEMAS_ENABLED)
17358: int mem_base;
17359: int ret_val;
17360: xmlRelaxNGParserCtxtPtr ctxt; /* a Relax-NG validation context */
17361: int n_ctxt;
17362: xmlRelaxNGValidityErrorFunc * err; /* the error callback result */
17363: int n_err;
17364: xmlRelaxNGValidityWarningFunc * warn; /* the warning callback result */
17365: int n_warn;
17366: void ** ctx; /* contextual data for the callbacks result */
17367: int n_ctx;
17368:
17369: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGParserCtxtPtr;n_ctxt++) {
17370: for (n_err = 0;n_err < gen_nb_xmlRelaxNGValidityErrorFunc_ptr;n_err++) {
17371: for (n_warn = 0;n_warn < gen_nb_xmlRelaxNGValidityWarningFunc_ptr;n_warn++) {
17372: for (n_ctx = 0;n_ctx < gen_nb_void_ptr_ptr;n_ctx++) {
17373: mem_base = xmlMemBlocks();
17374: ctxt = gen_xmlRelaxNGParserCtxtPtr(n_ctxt, 0);
17375: err = gen_xmlRelaxNGValidityErrorFunc_ptr(n_err, 1);
17376: warn = gen_xmlRelaxNGValidityWarningFunc_ptr(n_warn, 2);
17377: ctx = gen_void_ptr_ptr(n_ctx, 3);
17378:
17379: ret_val = xmlRelaxNGGetParserErrors(ctxt, err, warn, ctx);
17380: desret_int(ret_val);
17381: call_tests++;
17382: des_xmlRelaxNGParserCtxtPtr(n_ctxt, ctxt, 0);
17383: des_xmlRelaxNGValidityErrorFunc_ptr(n_err, err, 1);
17384: des_xmlRelaxNGValidityWarningFunc_ptr(n_warn, warn, 2);
17385: des_void_ptr_ptr(n_ctx, ctx, 3);
17386: xmlResetLastError();
17387: if (mem_base != xmlMemBlocks()) {
17388: printf("Leak of %d blocks found in xmlRelaxNGGetParserErrors",
17389: xmlMemBlocks() - mem_base);
17390: test_ret++;
17391: printf(" %d", n_ctxt);
17392: printf(" %d", n_err);
17393: printf(" %d", n_warn);
17394: printf(" %d", n_ctx);
17395: printf("\n");
17396: }
17397: }
17398: }
17399: }
17400: }
17401: function_tests++;
17402: #endif
17403:
17404: return(test_ret);
17405: }
17406:
17407: #ifdef LIBXML_SCHEMAS_ENABLED
17408:
17409: #define gen_nb_xmlRelaxNGValidCtxtPtr 1
17410: static xmlRelaxNGValidCtxtPtr gen_xmlRelaxNGValidCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17411: return(NULL);
17412: }
17413: static void des_xmlRelaxNGValidCtxtPtr(int no ATTRIBUTE_UNUSED, xmlRelaxNGValidCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17414: }
17415: #endif
17416:
17417:
17418: static int
17419: test_xmlRelaxNGGetValidErrors(void) {
17420: int test_ret = 0;
17421:
17422: #if defined(LIBXML_SCHEMAS_ENABLED)
17423: int mem_base;
17424: int ret_val;
17425: xmlRelaxNGValidCtxtPtr ctxt; /* a Relax-NG validation context */
17426: int n_ctxt;
17427: xmlRelaxNGValidityErrorFunc * err; /* the error function result */
17428: int n_err;
17429: xmlRelaxNGValidityWarningFunc * warn; /* the warning function result */
17430: int n_warn;
17431: void ** ctx; /* the functions context result */
17432: int n_ctx;
17433:
17434: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
17435: for (n_err = 0;n_err < gen_nb_xmlRelaxNGValidityErrorFunc_ptr;n_err++) {
17436: for (n_warn = 0;n_warn < gen_nb_xmlRelaxNGValidityWarningFunc_ptr;n_warn++) {
17437: for (n_ctx = 0;n_ctx < gen_nb_void_ptr_ptr;n_ctx++) {
17438: mem_base = xmlMemBlocks();
17439: ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
17440: err = gen_xmlRelaxNGValidityErrorFunc_ptr(n_err, 1);
17441: warn = gen_xmlRelaxNGValidityWarningFunc_ptr(n_warn, 2);
17442: ctx = gen_void_ptr_ptr(n_ctx, 3);
17443:
17444: ret_val = xmlRelaxNGGetValidErrors(ctxt, err, warn, ctx);
17445: desret_int(ret_val);
17446: call_tests++;
17447: des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
17448: des_xmlRelaxNGValidityErrorFunc_ptr(n_err, err, 1);
17449: des_xmlRelaxNGValidityWarningFunc_ptr(n_warn, warn, 2);
17450: des_void_ptr_ptr(n_ctx, ctx, 3);
17451: xmlResetLastError();
17452: if (mem_base != xmlMemBlocks()) {
17453: printf("Leak of %d blocks found in xmlRelaxNGGetValidErrors",
17454: xmlMemBlocks() - mem_base);
17455: test_ret++;
17456: printf(" %d", n_ctxt);
17457: printf(" %d", n_err);
17458: printf(" %d", n_warn);
17459: printf(" %d", n_ctx);
17460: printf("\n");
17461: }
17462: }
17463: }
17464: }
17465: }
17466: function_tests++;
17467: #endif
17468:
17469: return(test_ret);
17470: }
17471:
17472:
17473: static int
17474: test_xmlRelaxNGInitTypes(void) {
17475: int test_ret = 0;
17476:
17477: #if defined(LIBXML_SCHEMAS_ENABLED)
17478: int mem_base;
17479: int ret_val;
17480:
17481: mem_base = xmlMemBlocks();
17482:
17483: ret_val = xmlRelaxNGInitTypes();
17484: desret_int(ret_val);
17485: call_tests++;
17486: xmlResetLastError();
17487: if (mem_base != xmlMemBlocks()) {
17488: printf("Leak of %d blocks found in xmlRelaxNGInitTypes",
17489: xmlMemBlocks() - mem_base);
17490: test_ret++;
17491: printf("\n");
17492: }
17493: function_tests++;
17494: #endif
17495:
17496: return(test_ret);
17497: }
17498:
17499:
17500: static int
17501: test_xmlRelaxNGNewDocParserCtxt(void) {
17502: int test_ret = 0;
17503:
17504: #if defined(LIBXML_SCHEMAS_ENABLED)
17505: int mem_base;
17506: xmlRelaxNGParserCtxtPtr ret_val;
17507: xmlDocPtr doc; /* a preparsed document tree */
17508: int n_doc;
17509:
17510: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
17511: mem_base = xmlMemBlocks();
17512: doc = gen_xmlDocPtr(n_doc, 0);
17513:
17514: ret_val = xmlRelaxNGNewDocParserCtxt(doc);
17515: desret_xmlRelaxNGParserCtxtPtr(ret_val);
17516: call_tests++;
17517: des_xmlDocPtr(n_doc, doc, 0);
17518: xmlResetLastError();
17519: if (mem_base != xmlMemBlocks()) {
17520: printf("Leak of %d blocks found in xmlRelaxNGNewDocParserCtxt",
17521: xmlMemBlocks() - mem_base);
17522: test_ret++;
17523: printf(" %d", n_doc);
17524: printf("\n");
17525: }
17526: }
17527: function_tests++;
17528: #endif
17529:
17530: return(test_ret);
17531: }
17532:
17533:
17534: static int
17535: test_xmlRelaxNGNewMemParserCtxt(void) {
17536: int test_ret = 0;
17537:
17538: #if defined(LIBXML_SCHEMAS_ENABLED)
17539: int mem_base;
17540: xmlRelaxNGParserCtxtPtr ret_val;
17541: char * buffer; /* a pointer to a char array containing the schemas */
17542: int n_buffer;
17543: int size; /* the size of the array */
17544: int n_size;
17545:
17546: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
17547: for (n_size = 0;n_size < gen_nb_int;n_size++) {
17548: mem_base = xmlMemBlocks();
17549: buffer = gen_const_char_ptr(n_buffer, 0);
17550: size = gen_int(n_size, 1);
17551:
17552: ret_val = xmlRelaxNGNewMemParserCtxt((const char *)buffer, size);
17553: desret_xmlRelaxNGParserCtxtPtr(ret_val);
17554: call_tests++;
17555: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
17556: des_int(n_size, size, 1);
17557: xmlResetLastError();
17558: if (mem_base != xmlMemBlocks()) {
17559: printf("Leak of %d blocks found in xmlRelaxNGNewMemParserCtxt",
17560: xmlMemBlocks() - mem_base);
17561: test_ret++;
17562: printf(" %d", n_buffer);
17563: printf(" %d", n_size);
17564: printf("\n");
17565: }
17566: }
17567: }
17568: function_tests++;
17569: #endif
17570:
17571: return(test_ret);
17572: }
17573:
17574:
17575: static int
17576: test_xmlRelaxNGNewParserCtxt(void) {
17577: int test_ret = 0;
17578:
17579: #if defined(LIBXML_SCHEMAS_ENABLED)
17580: int mem_base;
17581: xmlRelaxNGParserCtxtPtr ret_val;
17582: char * URL; /* the location of the schema */
17583: int n_URL;
17584:
17585: for (n_URL = 0;n_URL < gen_nb_const_char_ptr;n_URL++) {
17586: mem_base = xmlMemBlocks();
17587: URL = gen_const_char_ptr(n_URL, 0);
17588:
17589: ret_val = xmlRelaxNGNewParserCtxt((const char *)URL);
17590: desret_xmlRelaxNGParserCtxtPtr(ret_val);
17591: call_tests++;
17592: des_const_char_ptr(n_URL, (const char *)URL, 0);
17593: xmlResetLastError();
17594: if (mem_base != xmlMemBlocks()) {
17595: printf("Leak of %d blocks found in xmlRelaxNGNewParserCtxt",
17596: xmlMemBlocks() - mem_base);
17597: test_ret++;
17598: printf(" %d", n_URL);
17599: printf("\n");
17600: }
17601: }
17602: function_tests++;
17603: #endif
17604:
17605: return(test_ret);
17606: }
17607:
17608:
17609: static int
17610: test_xmlRelaxNGNewValidCtxt(void) {
17611: int test_ret = 0;
17612:
17613:
17614: /* missing type support */
17615: return(test_ret);
17616: }
17617:
17618:
17619: static int
17620: test_xmlRelaxNGParse(void) {
17621: int test_ret = 0;
17622:
17623:
17624: /* missing type support */
17625: return(test_ret);
17626: }
17627:
17628:
17629: static int
17630: test_xmlRelaxNGSetParserErrors(void) {
17631: int test_ret = 0;
17632:
17633:
17634: /* missing type support */
17635: return(test_ret);
17636: }
17637:
17638:
17639: static int
17640: test_xmlRelaxNGSetParserStructuredErrors(void) {
17641: int test_ret = 0;
17642:
17643:
17644: /* missing type support */
17645: return(test_ret);
17646: }
17647:
17648:
17649: static int
17650: test_xmlRelaxNGSetValidErrors(void) {
17651: int test_ret = 0;
17652:
17653:
17654: /* missing type support */
17655: return(test_ret);
17656: }
17657:
17658:
17659: static int
17660: test_xmlRelaxNGSetValidStructuredErrors(void) {
17661: int test_ret = 0;
17662:
17663:
17664: /* missing type support */
17665: return(test_ret);
17666: }
17667:
17668:
17669: static int
17670: test_xmlRelaxNGValidateDoc(void) {
17671: int test_ret = 0;
17672:
17673: #if defined(LIBXML_SCHEMAS_ENABLED)
17674: int mem_base;
17675: int ret_val;
17676: xmlRelaxNGValidCtxtPtr ctxt; /* a Relax-NG validation context */
17677: int n_ctxt;
17678: xmlDocPtr doc; /* a parsed document tree */
17679: int n_doc;
17680:
17681: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
17682: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
17683: mem_base = xmlMemBlocks();
17684: ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
17685: doc = gen_xmlDocPtr(n_doc, 1);
17686:
17687: ret_val = xmlRelaxNGValidateDoc(ctxt, doc);
17688: desret_int(ret_val);
17689: call_tests++;
17690: des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
17691: des_xmlDocPtr(n_doc, doc, 1);
17692: xmlResetLastError();
17693: if (mem_base != xmlMemBlocks()) {
17694: printf("Leak of %d blocks found in xmlRelaxNGValidateDoc",
17695: xmlMemBlocks() - mem_base);
17696: test_ret++;
17697: printf(" %d", n_ctxt);
17698: printf(" %d", n_doc);
17699: printf("\n");
17700: }
17701: }
17702: }
17703: function_tests++;
17704: #endif
17705:
17706: return(test_ret);
17707: }
17708:
17709:
17710: static int
17711: test_xmlRelaxNGValidateFullElement(void) {
17712: int test_ret = 0;
17713:
17714: #if defined(LIBXML_SCHEMAS_ENABLED)
17715: int mem_base;
17716: int ret_val;
17717: xmlRelaxNGValidCtxtPtr ctxt; /* the validation context */
17718: int n_ctxt;
17719: xmlDocPtr doc; /* a document instance */
17720: int n_doc;
17721: xmlNodePtr elem; /* an element instance */
17722: int n_elem;
17723:
17724: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
17725: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
17726: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
17727: mem_base = xmlMemBlocks();
17728: ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
17729: doc = gen_xmlDocPtr(n_doc, 1);
17730: elem = gen_xmlNodePtr(n_elem, 2);
17731:
17732: ret_val = xmlRelaxNGValidateFullElement(ctxt, doc, elem);
17733: desret_int(ret_val);
17734: call_tests++;
17735: des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
17736: des_xmlDocPtr(n_doc, doc, 1);
17737: des_xmlNodePtr(n_elem, elem, 2);
17738: xmlResetLastError();
17739: if (mem_base != xmlMemBlocks()) {
17740: printf("Leak of %d blocks found in xmlRelaxNGValidateFullElement",
17741: xmlMemBlocks() - mem_base);
17742: test_ret++;
17743: printf(" %d", n_ctxt);
17744: printf(" %d", n_doc);
17745: printf(" %d", n_elem);
17746: printf("\n");
17747: }
17748: }
17749: }
17750: }
17751: function_tests++;
17752: #endif
17753:
17754: return(test_ret);
17755: }
17756:
17757:
17758: static int
17759: test_xmlRelaxNGValidatePopElement(void) {
17760: int test_ret = 0;
17761:
17762: #if defined(LIBXML_SCHEMAS_ENABLED)
17763: int mem_base;
17764: int ret_val;
17765: xmlRelaxNGValidCtxtPtr ctxt; /* the RelaxNG validation context */
17766: int n_ctxt;
17767: xmlDocPtr doc; /* a document instance */
17768: int n_doc;
17769: xmlNodePtr elem; /* an element instance */
17770: int n_elem;
17771:
17772: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
17773: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
17774: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
17775: mem_base = xmlMemBlocks();
17776: ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
17777: doc = gen_xmlDocPtr(n_doc, 1);
17778: elem = gen_xmlNodePtr(n_elem, 2);
17779:
17780: ret_val = xmlRelaxNGValidatePopElement(ctxt, doc, elem);
17781: desret_int(ret_val);
17782: call_tests++;
17783: des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
17784: des_xmlDocPtr(n_doc, doc, 1);
17785: des_xmlNodePtr(n_elem, elem, 2);
17786: xmlResetLastError();
17787: if (mem_base != xmlMemBlocks()) {
17788: printf("Leak of %d blocks found in xmlRelaxNGValidatePopElement",
17789: xmlMemBlocks() - mem_base);
17790: test_ret++;
17791: printf(" %d", n_ctxt);
17792: printf(" %d", n_doc);
17793: printf(" %d", n_elem);
17794: printf("\n");
17795: }
17796: }
17797: }
17798: }
17799: function_tests++;
17800: #endif
17801:
17802: return(test_ret);
17803: }
17804:
17805:
17806: static int
17807: test_xmlRelaxNGValidatePushCData(void) {
17808: int test_ret = 0;
17809:
17810: #if defined(LIBXML_SCHEMAS_ENABLED)
17811: int mem_base;
17812: int ret_val;
17813: xmlRelaxNGValidCtxtPtr ctxt; /* the RelaxNG validation context */
17814: int n_ctxt;
17815: xmlChar * data; /* some character data read */
17816: int n_data;
17817: int len; /* the lenght of the data */
17818: int n_len;
17819:
17820: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
17821: for (n_data = 0;n_data < gen_nb_const_xmlChar_ptr;n_data++) {
17822: for (n_len = 0;n_len < gen_nb_int;n_len++) {
17823: mem_base = xmlMemBlocks();
17824: ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
17825: data = gen_const_xmlChar_ptr(n_data, 1);
17826: len = gen_int(n_len, 2);
17827:
17828: ret_val = xmlRelaxNGValidatePushCData(ctxt, (const xmlChar *)data, len);
17829: desret_int(ret_val);
17830: call_tests++;
17831: des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
17832: des_const_xmlChar_ptr(n_data, (const xmlChar *)data, 1);
17833: des_int(n_len, len, 2);
17834: xmlResetLastError();
17835: if (mem_base != xmlMemBlocks()) {
17836: printf("Leak of %d blocks found in xmlRelaxNGValidatePushCData",
17837: xmlMemBlocks() - mem_base);
17838: test_ret++;
17839: printf(" %d", n_ctxt);
17840: printf(" %d", n_data);
17841: printf(" %d", n_len);
17842: printf("\n");
17843: }
17844: }
17845: }
17846: }
17847: function_tests++;
17848: #endif
17849:
17850: return(test_ret);
17851: }
17852:
17853:
17854: static int
17855: test_xmlRelaxNGValidatePushElement(void) {
17856: int test_ret = 0;
17857:
17858: #if defined(LIBXML_SCHEMAS_ENABLED)
17859: int mem_base;
17860: int ret_val;
17861: xmlRelaxNGValidCtxtPtr ctxt; /* the validation context */
17862: int n_ctxt;
17863: xmlDocPtr doc; /* a document instance */
17864: int n_doc;
17865: xmlNodePtr elem; /* an element instance */
17866: int n_elem;
17867:
17868: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
17869: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
17870: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
17871: mem_base = xmlMemBlocks();
17872: ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
17873: doc = gen_xmlDocPtr(n_doc, 1);
17874: elem = gen_xmlNodePtr(n_elem, 2);
17875:
17876: ret_val = xmlRelaxNGValidatePushElement(ctxt, doc, elem);
17877: desret_int(ret_val);
17878: call_tests++;
17879: des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
17880: des_xmlDocPtr(n_doc, doc, 1);
17881: des_xmlNodePtr(n_elem, elem, 2);
17882: xmlResetLastError();
17883: if (mem_base != xmlMemBlocks()) {
17884: printf("Leak of %d blocks found in xmlRelaxNGValidatePushElement",
17885: xmlMemBlocks() - mem_base);
17886: test_ret++;
17887: printf(" %d", n_ctxt);
17888: printf(" %d", n_doc);
17889: printf(" %d", n_elem);
17890: printf("\n");
17891: }
17892: }
17893: }
17894: }
17895: function_tests++;
17896: #endif
17897:
17898: return(test_ret);
17899: }
17900:
17901:
17902: static int
17903: test_xmlRelaxParserSetFlag(void) {
17904: int test_ret = 0;
17905:
17906: #if defined(LIBXML_SCHEMAS_ENABLED)
17907: int mem_base;
17908: int ret_val;
17909: xmlRelaxNGParserCtxtPtr ctxt; /* a RelaxNG parser context */
17910: int n_ctxt;
17911: int flags; /* a set of flags values */
17912: int n_flags;
17913:
17914: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGParserCtxtPtr;n_ctxt++) {
17915: for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
17916: mem_base = xmlMemBlocks();
17917: ctxt = gen_xmlRelaxNGParserCtxtPtr(n_ctxt, 0);
17918: flags = gen_int(n_flags, 1);
17919:
17920: ret_val = xmlRelaxParserSetFlag(ctxt, flags);
17921: desret_int(ret_val);
17922: call_tests++;
17923: des_xmlRelaxNGParserCtxtPtr(n_ctxt, ctxt, 0);
17924: des_int(n_flags, flags, 1);
17925: xmlResetLastError();
17926: if (mem_base != xmlMemBlocks()) {
17927: printf("Leak of %d blocks found in xmlRelaxParserSetFlag",
17928: xmlMemBlocks() - mem_base);
17929: test_ret++;
17930: printf(" %d", n_ctxt);
17931: printf(" %d", n_flags);
17932: printf("\n");
17933: }
17934: }
17935: }
17936: function_tests++;
17937: #endif
17938:
17939: return(test_ret);
17940: }
17941:
17942: static int
17943: test_relaxng(void) {
17944: int test_ret = 0;
17945:
17946: if (quiet == 0) printf("Testing relaxng : 14 of 24 functions ...\n");
17947: test_ret += test_xmlRelaxNGDump();
17948: test_ret += test_xmlRelaxNGDumpTree();
17949: test_ret += test_xmlRelaxNGGetParserErrors();
17950: test_ret += test_xmlRelaxNGGetValidErrors();
17951: test_ret += test_xmlRelaxNGInitTypes();
17952: test_ret += test_xmlRelaxNGNewDocParserCtxt();
17953: test_ret += test_xmlRelaxNGNewMemParserCtxt();
17954: test_ret += test_xmlRelaxNGNewParserCtxt();
17955: test_ret += test_xmlRelaxNGNewValidCtxt();
17956: test_ret += test_xmlRelaxNGParse();
17957: test_ret += test_xmlRelaxNGSetParserErrors();
17958: test_ret += test_xmlRelaxNGSetParserStructuredErrors();
17959: test_ret += test_xmlRelaxNGSetValidErrors();
17960: test_ret += test_xmlRelaxNGSetValidStructuredErrors();
17961: test_ret += test_xmlRelaxNGValidateDoc();
17962: test_ret += test_xmlRelaxNGValidateFullElement();
17963: test_ret += test_xmlRelaxNGValidatePopElement();
17964: test_ret += test_xmlRelaxNGValidatePushCData();
17965: test_ret += test_xmlRelaxNGValidatePushElement();
17966: test_ret += test_xmlRelaxParserSetFlag();
17967:
17968: if (test_ret != 0)
17969: printf("Module relaxng: %d errors\n", test_ret);
17970: return(test_ret);
17971: }
17972: static int
17973: test_schemasInternals(void) {
17974: int test_ret = 0;
17975:
17976: if (quiet == 0) printf("Testing schemasInternals : 0 of 2 functions ...\n");
17977:
17978: if (test_ret != 0)
17979: printf("Module schemasInternals: %d errors\n", test_ret);
17980: return(test_ret);
17981: }
17982:
17983: static int
17984: test_xmlSchematronNewDocParserCtxt(void) {
17985: int test_ret = 0;
17986:
17987:
17988: /* missing type support */
17989: return(test_ret);
17990: }
17991:
17992:
17993: static int
17994: test_xmlSchematronNewMemParserCtxt(void) {
17995: int test_ret = 0;
17996:
17997:
17998: /* missing type support */
17999: return(test_ret);
18000: }
18001:
18002:
18003: static int
18004: test_xmlSchematronNewParserCtxt(void) {
18005: int test_ret = 0;
18006:
18007:
18008: /* missing type support */
18009: return(test_ret);
18010: }
18011:
18012: #ifdef LIBXML_SCHEMATRON_ENABLED
18013:
18014: #define gen_nb_xmlSchematronPtr 1
18015: static xmlSchematronPtr gen_xmlSchematronPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
18016: return(NULL);
18017: }
18018: static void des_xmlSchematronPtr(int no ATTRIBUTE_UNUSED, xmlSchematronPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
18019: }
18020: #endif
18021:
18022:
18023: static int
18024: test_xmlSchematronNewValidCtxt(void) {
18025: int test_ret = 0;
18026:
18027:
18028: /* missing type support */
18029: return(test_ret);
18030: }
18031:
18032: #ifdef LIBXML_SCHEMATRON_ENABLED
18033:
18034: #define gen_nb_xmlSchematronParserCtxtPtr 1
18035: static xmlSchematronParserCtxtPtr gen_xmlSchematronParserCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
18036: return(NULL);
18037: }
18038: static void des_xmlSchematronParserCtxtPtr(int no ATTRIBUTE_UNUSED, xmlSchematronParserCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
18039: }
18040: #endif
18041:
18042:
18043: static int
18044: test_xmlSchematronParse(void) {
18045: int test_ret = 0;
18046:
18047:
18048: /* missing type support */
18049: return(test_ret);
18050: }
18051:
18052: #ifdef LIBXML_SCHEMATRON_ENABLED
18053:
18054: #define gen_nb_xmlSchematronValidCtxtPtr 1
18055: static xmlSchematronValidCtxtPtr gen_xmlSchematronValidCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
18056: return(NULL);
18057: }
18058: static void des_xmlSchematronValidCtxtPtr(int no ATTRIBUTE_UNUSED, xmlSchematronValidCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
18059: }
18060: #endif
18061:
18062:
18063: static int
18064: test_xmlSchematronSetValidStructuredErrors(void) {
18065: int test_ret = 0;
18066:
18067:
18068: /* missing type support */
18069: return(test_ret);
18070: }
18071:
18072:
18073: static int
18074: test_xmlSchematronValidateDoc(void) {
18075: int test_ret = 0;
18076:
18077: #if defined(LIBXML_SCHEMATRON_ENABLED)
18078: int mem_base;
18079: int ret_val;
18080: xmlSchematronValidCtxtPtr ctxt; /* the schema validation context */
18081: int n_ctxt;
18082: xmlDocPtr instance; /* the document instace tree */
18083: int n_instance;
18084:
18085: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchematronValidCtxtPtr;n_ctxt++) {
18086: for (n_instance = 0;n_instance < gen_nb_xmlDocPtr;n_instance++) {
18087: mem_base = xmlMemBlocks();
18088: ctxt = gen_xmlSchematronValidCtxtPtr(n_ctxt, 0);
18089: instance = gen_xmlDocPtr(n_instance, 1);
18090:
18091: ret_val = xmlSchematronValidateDoc(ctxt, instance);
18092: desret_int(ret_val);
18093: call_tests++;
18094: des_xmlSchematronValidCtxtPtr(n_ctxt, ctxt, 0);
18095: des_xmlDocPtr(n_instance, instance, 1);
18096: xmlResetLastError();
18097: if (mem_base != xmlMemBlocks()) {
18098: printf("Leak of %d blocks found in xmlSchematronValidateDoc",
18099: xmlMemBlocks() - mem_base);
18100: test_ret++;
18101: printf(" %d", n_ctxt);
18102: printf(" %d", n_instance);
18103: printf("\n");
18104: }
18105: }
18106: }
18107: function_tests++;
18108: #endif
18109:
18110: return(test_ret);
18111: }
18112:
18113: static int
18114: test_schematron(void) {
18115: int test_ret = 0;
18116:
18117: if (quiet == 0) printf("Testing schematron : 1 of 10 functions ...\n");
18118: test_ret += test_xmlSchematronNewDocParserCtxt();
18119: test_ret += test_xmlSchematronNewMemParserCtxt();
18120: test_ret += test_xmlSchematronNewParserCtxt();
18121: test_ret += test_xmlSchematronNewValidCtxt();
18122: test_ret += test_xmlSchematronParse();
18123: test_ret += test_xmlSchematronSetValidStructuredErrors();
18124: test_ret += test_xmlSchematronValidateDoc();
18125:
18126: if (test_ret != 0)
18127: printf("Module schematron: %d errors\n", test_ret);
18128: return(test_ret);
18129: }
18130:
18131: static int
18132: test_xmlAddChild(void) {
18133: int test_ret = 0;
18134:
18135: int mem_base;
18136: xmlNodePtr ret_val;
18137: xmlNodePtr parent; /* the parent node */
18138: int n_parent;
18139: xmlNodePtr cur; /* the child node */
18140: int n_cur;
18141:
18142: for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
18143: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr_in;n_cur++) {
18144: mem_base = xmlMemBlocks();
18145: parent = gen_xmlNodePtr(n_parent, 0);
18146: cur = gen_xmlNodePtr_in(n_cur, 1);
18147:
18148: ret_val = xmlAddChild(parent, cur);
18149: if (ret_val == NULL) { xmlFreeNode(cur) ; cur = NULL ; }
18150: desret_xmlNodePtr(ret_val);
18151: call_tests++;
18152: des_xmlNodePtr(n_parent, parent, 0);
18153: des_xmlNodePtr_in(n_cur, cur, 1);
18154: xmlResetLastError();
18155: if (mem_base != xmlMemBlocks()) {
18156: printf("Leak of %d blocks found in xmlAddChild",
18157: xmlMemBlocks() - mem_base);
18158: test_ret++;
18159: printf(" %d", n_parent);
18160: printf(" %d", n_cur);
18161: printf("\n");
18162: }
18163: }
18164: }
18165: function_tests++;
18166:
18167: return(test_ret);
18168: }
18169:
18170:
18171: static int
18172: test_xmlAddChildList(void) {
18173: int test_ret = 0;
18174:
18175: int mem_base;
18176: xmlNodePtr ret_val;
18177: xmlNodePtr parent; /* the parent node */
18178: int n_parent;
18179: xmlNodePtr cur; /* the first node in the list */
18180: int n_cur;
18181:
18182: for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
18183: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr_in;n_cur++) {
18184: mem_base = xmlMemBlocks();
18185: parent = gen_xmlNodePtr(n_parent, 0);
18186: cur = gen_xmlNodePtr_in(n_cur, 1);
18187:
18188: ret_val = xmlAddChildList(parent, cur);
18189: if (ret_val == NULL) { xmlFreeNodeList(cur) ; cur = NULL ; }
18190: desret_xmlNodePtr(ret_val);
18191: call_tests++;
18192: des_xmlNodePtr(n_parent, parent, 0);
18193: des_xmlNodePtr_in(n_cur, cur, 1);
18194: xmlResetLastError();
18195: if (mem_base != xmlMemBlocks()) {
18196: printf("Leak of %d blocks found in xmlAddChildList",
18197: xmlMemBlocks() - mem_base);
18198: test_ret++;
18199: printf(" %d", n_parent);
18200: printf(" %d", n_cur);
18201: printf("\n");
18202: }
18203: }
18204: }
18205: function_tests++;
18206:
18207: return(test_ret);
18208: }
18209:
18210:
18211: static int
18212: test_xmlAddNextSibling(void) {
18213: int test_ret = 0;
18214:
18215: int mem_base;
18216: xmlNodePtr ret_val;
18217: xmlNodePtr cur; /* the child node */
18218: int n_cur;
18219: xmlNodePtr elem; /* the new node */
18220: int n_elem;
18221:
18222: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
18223: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr_in;n_elem++) {
18224: mem_base = xmlMemBlocks();
18225: cur = gen_xmlNodePtr(n_cur, 0);
18226: elem = gen_xmlNodePtr_in(n_elem, 1);
18227:
18228: ret_val = xmlAddNextSibling(cur, elem);
18229: if (ret_val == NULL) { xmlFreeNode(elem) ; elem = NULL ; }
18230: desret_xmlNodePtr(ret_val);
18231: call_tests++;
18232: des_xmlNodePtr(n_cur, cur, 0);
18233: des_xmlNodePtr_in(n_elem, elem, 1);
18234: xmlResetLastError();
18235: if (mem_base != xmlMemBlocks()) {
18236: printf("Leak of %d blocks found in xmlAddNextSibling",
18237: xmlMemBlocks() - mem_base);
18238: test_ret++;
18239: printf(" %d", n_cur);
18240: printf(" %d", n_elem);
18241: printf("\n");
18242: }
18243: }
18244: }
18245: function_tests++;
18246:
18247: return(test_ret);
18248: }
18249:
18250:
18251: static int
18252: test_xmlAddPrevSibling(void) {
18253: int test_ret = 0;
18254:
18255: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
18256: int mem_base;
18257: xmlNodePtr ret_val;
18258: xmlNodePtr cur; /* the child node */
18259: int n_cur;
18260: xmlNodePtr elem; /* the new node */
18261: int n_elem;
18262:
18263: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
18264: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr_in;n_elem++) {
18265: mem_base = xmlMemBlocks();
18266: cur = gen_xmlNodePtr(n_cur, 0);
18267: elem = gen_xmlNodePtr_in(n_elem, 1);
18268:
18269: ret_val = xmlAddPrevSibling(cur, elem);
18270: if (ret_val == NULL) { xmlFreeNode(elem) ; elem = NULL ; }
18271: desret_xmlNodePtr(ret_val);
18272: call_tests++;
18273: des_xmlNodePtr(n_cur, cur, 0);
18274: des_xmlNodePtr_in(n_elem, elem, 1);
18275: xmlResetLastError();
18276: if (mem_base != xmlMemBlocks()) {
18277: printf("Leak of %d blocks found in xmlAddPrevSibling",
18278: xmlMemBlocks() - mem_base);
18279: test_ret++;
18280: printf(" %d", n_cur);
18281: printf(" %d", n_elem);
18282: printf("\n");
18283: }
18284: }
18285: }
18286: function_tests++;
18287: #endif
18288:
18289: return(test_ret);
18290: }
18291:
18292:
18293: static int
18294: test_xmlAddSibling(void) {
18295: int test_ret = 0;
18296:
18297: int mem_base;
18298: xmlNodePtr ret_val;
18299: xmlNodePtr cur; /* the child node */
18300: int n_cur;
18301: xmlNodePtr elem; /* the new node */
18302: int n_elem;
18303:
18304: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
18305: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr_in;n_elem++) {
18306: mem_base = xmlMemBlocks();
18307: cur = gen_xmlNodePtr(n_cur, 0);
18308: elem = gen_xmlNodePtr_in(n_elem, 1);
18309:
18310: ret_val = xmlAddSibling(cur, elem);
18311: if (ret_val == NULL) { xmlFreeNode(elem) ; elem = NULL ; }
18312: desret_xmlNodePtr(ret_val);
18313: call_tests++;
18314: des_xmlNodePtr(n_cur, cur, 0);
18315: des_xmlNodePtr_in(n_elem, elem, 1);
18316: xmlResetLastError();
18317: if (mem_base != xmlMemBlocks()) {
18318: printf("Leak of %d blocks found in xmlAddSibling",
18319: xmlMemBlocks() - mem_base);
18320: test_ret++;
18321: printf(" %d", n_cur);
18322: printf(" %d", n_elem);
18323: printf("\n");
18324: }
18325: }
18326: }
18327: function_tests++;
18328:
18329: return(test_ret);
18330: }
18331:
18332:
18333: static int
18334: test_xmlAttrSerializeTxtContent(void) {
18335: int test_ret = 0;
18336:
18337: #if defined(LIBXML_OUTPUT_ENABLED)
18338: #ifdef LIBXML_OUTPUT_ENABLED
18339: int mem_base;
18340: xmlBufferPtr buf; /* the XML buffer output */
18341: int n_buf;
18342: xmlDocPtr doc; /* the document */
18343: int n_doc;
18344: xmlAttrPtr attr; /* the attribute node */
18345: int n_attr;
18346: xmlChar * string; /* the text content */
18347: int n_string;
18348:
18349: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18350: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
18351: for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
18352: for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) {
18353: mem_base = xmlMemBlocks();
18354: buf = gen_xmlBufferPtr(n_buf, 0);
18355: doc = gen_xmlDocPtr(n_doc, 1);
18356: attr = gen_xmlAttrPtr(n_attr, 2);
18357: string = gen_const_xmlChar_ptr(n_string, 3);
18358:
18359: xmlAttrSerializeTxtContent(buf, doc, attr, (const xmlChar *)string);
18360: call_tests++;
18361: des_xmlBufferPtr(n_buf, buf, 0);
18362: des_xmlDocPtr(n_doc, doc, 1);
18363: des_xmlAttrPtr(n_attr, attr, 2);
18364: des_const_xmlChar_ptr(n_string, (const xmlChar *)string, 3);
18365: xmlResetLastError();
18366: if (mem_base != xmlMemBlocks()) {
18367: printf("Leak of %d blocks found in xmlAttrSerializeTxtContent",
18368: xmlMemBlocks() - mem_base);
18369: test_ret++;
18370: printf(" %d", n_buf);
18371: printf(" %d", n_doc);
18372: printf(" %d", n_attr);
18373: printf(" %d", n_string);
18374: printf("\n");
18375: }
18376: }
18377: }
18378: }
18379: }
18380: function_tests++;
18381: #endif
18382: #endif
18383:
18384: return(test_ret);
18385: }
18386:
18387:
18388: static int
18389: test_xmlBufferAdd(void) {
18390: int test_ret = 0;
18391:
18392: int mem_base;
18393: int ret_val;
18394: xmlBufferPtr buf; /* the buffer to dump */
18395: int n_buf;
18396: xmlChar * str; /* the #xmlChar string */
18397: int n_str;
18398: int len; /* the number of #xmlChar to add */
18399: int n_len;
18400:
18401: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18402: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
18403: for (n_len = 0;n_len < gen_nb_int;n_len++) {
18404: mem_base = xmlMemBlocks();
18405: buf = gen_xmlBufferPtr(n_buf, 0);
18406: str = gen_const_xmlChar_ptr(n_str, 1);
18407: len = gen_int(n_len, 2);
18408:
18409: ret_val = xmlBufferAdd(buf, (const xmlChar *)str, len);
18410: desret_int(ret_val);
18411: call_tests++;
18412: des_xmlBufferPtr(n_buf, buf, 0);
18413: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
18414: des_int(n_len, len, 2);
18415: xmlResetLastError();
18416: if (mem_base != xmlMemBlocks()) {
18417: printf("Leak of %d blocks found in xmlBufferAdd",
18418: xmlMemBlocks() - mem_base);
18419: test_ret++;
18420: printf(" %d", n_buf);
18421: printf(" %d", n_str);
18422: printf(" %d", n_len);
18423: printf("\n");
18424: }
18425: }
18426: }
18427: }
18428: function_tests++;
18429:
18430: return(test_ret);
18431: }
18432:
18433:
18434: static int
18435: test_xmlBufferAddHead(void) {
18436: int test_ret = 0;
18437:
18438: int mem_base;
18439: int ret_val;
18440: xmlBufferPtr buf; /* the buffer */
18441: int n_buf;
18442: xmlChar * str; /* the #xmlChar string */
18443: int n_str;
18444: int len; /* the number of #xmlChar to add */
18445: int n_len;
18446:
18447: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18448: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
18449: for (n_len = 0;n_len < gen_nb_int;n_len++) {
18450: mem_base = xmlMemBlocks();
18451: buf = gen_xmlBufferPtr(n_buf, 0);
18452: str = gen_const_xmlChar_ptr(n_str, 1);
18453: len = gen_int(n_len, 2);
18454:
18455: ret_val = xmlBufferAddHead(buf, (const xmlChar *)str, len);
18456: desret_int(ret_val);
18457: call_tests++;
18458: des_xmlBufferPtr(n_buf, buf, 0);
18459: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
18460: des_int(n_len, len, 2);
18461: xmlResetLastError();
18462: if (mem_base != xmlMemBlocks()) {
18463: printf("Leak of %d blocks found in xmlBufferAddHead",
18464: xmlMemBlocks() - mem_base);
18465: test_ret++;
18466: printf(" %d", n_buf);
18467: printf(" %d", n_str);
18468: printf(" %d", n_len);
18469: printf("\n");
18470: }
18471: }
18472: }
18473: }
18474: function_tests++;
18475:
18476: return(test_ret);
18477: }
18478:
18479:
18480: static int
18481: test_xmlBufferCCat(void) {
18482: int test_ret = 0;
18483:
18484: int mem_base;
18485: int ret_val;
18486: xmlBufferPtr buf; /* the buffer to dump */
18487: int n_buf;
18488: char * str; /* the C char string */
18489: int n_str;
18490:
18491: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18492: for (n_str = 0;n_str < gen_nb_const_char_ptr;n_str++) {
18493: mem_base = xmlMemBlocks();
18494: buf = gen_xmlBufferPtr(n_buf, 0);
18495: str = gen_const_char_ptr(n_str, 1);
18496:
18497: ret_val = xmlBufferCCat(buf, (const char *)str);
18498: desret_int(ret_val);
18499: call_tests++;
18500: des_xmlBufferPtr(n_buf, buf, 0);
18501: des_const_char_ptr(n_str, (const char *)str, 1);
18502: xmlResetLastError();
18503: if (mem_base != xmlMemBlocks()) {
18504: printf("Leak of %d blocks found in xmlBufferCCat",
18505: xmlMemBlocks() - mem_base);
18506: test_ret++;
18507: printf(" %d", n_buf);
18508: printf(" %d", n_str);
18509: printf("\n");
18510: }
18511: }
18512: }
18513: function_tests++;
18514:
18515: return(test_ret);
18516: }
18517:
18518:
18519: static int
18520: test_xmlBufferCat(void) {
18521: int test_ret = 0;
18522:
18523: int mem_base;
18524: int ret_val;
18525: xmlBufferPtr buf; /* the buffer to add to */
18526: int n_buf;
18527: xmlChar * str; /* the #xmlChar string */
18528: int n_str;
18529:
18530: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18531: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
18532: mem_base = xmlMemBlocks();
18533: buf = gen_xmlBufferPtr(n_buf, 0);
18534: str = gen_const_xmlChar_ptr(n_str, 1);
18535:
18536: ret_val = xmlBufferCat(buf, (const xmlChar *)str);
18537: desret_int(ret_val);
18538: call_tests++;
18539: des_xmlBufferPtr(n_buf, buf, 0);
18540: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
18541: xmlResetLastError();
18542: if (mem_base != xmlMemBlocks()) {
18543: printf("Leak of %d blocks found in xmlBufferCat",
18544: xmlMemBlocks() - mem_base);
18545: test_ret++;
18546: printf(" %d", n_buf);
18547: printf(" %d", n_str);
18548: printf("\n");
18549: }
18550: }
18551: }
18552: function_tests++;
18553:
18554: return(test_ret);
18555: }
18556:
18557:
18558: #define gen_nb_const_xmlBufferPtr 1
18559: static xmlBufferPtr gen_const_xmlBufferPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
18560: return(NULL);
18561: }
18562: static void des_const_xmlBufferPtr(int no ATTRIBUTE_UNUSED, const xmlBufferPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
18563: }
18564:
18565: static int
18566: test_xmlBufferContent(void) {
18567: int test_ret = 0;
18568:
18569: int mem_base;
18570: const xmlChar * ret_val;
18571: xmlBufferPtr buf; /* the buffer */
18572: int n_buf;
18573:
18574: for (n_buf = 0;n_buf < gen_nb_const_xmlBufferPtr;n_buf++) {
18575: mem_base = xmlMemBlocks();
18576: buf = gen_const_xmlBufferPtr(n_buf, 0);
18577:
18578: ret_val = xmlBufferContent((const xmlBufferPtr)buf);
18579: desret_const_xmlChar_ptr(ret_val);
18580: call_tests++;
18581: des_const_xmlBufferPtr(n_buf, (const xmlBufferPtr)buf, 0);
18582: xmlResetLastError();
18583: if (mem_base != xmlMemBlocks()) {
18584: printf("Leak of %d blocks found in xmlBufferContent",
18585: xmlMemBlocks() - mem_base);
18586: test_ret++;
18587: printf(" %d", n_buf);
18588: printf("\n");
18589: }
18590: }
18591: function_tests++;
18592:
18593: return(test_ret);
18594: }
18595:
18596:
18597: static int
18598: test_xmlBufferCreate(void) {
18599: int test_ret = 0;
18600:
18601: int mem_base;
18602: xmlBufferPtr ret_val;
18603:
18604: mem_base = xmlMemBlocks();
18605:
18606: ret_val = xmlBufferCreate();
18607: desret_xmlBufferPtr(ret_val);
18608: call_tests++;
18609: xmlResetLastError();
18610: if (mem_base != xmlMemBlocks()) {
18611: printf("Leak of %d blocks found in xmlBufferCreate",
18612: xmlMemBlocks() - mem_base);
18613: test_ret++;
18614: printf("\n");
18615: }
18616: function_tests++;
18617:
18618: return(test_ret);
18619: }
18620:
18621:
18622: static int
18623: test_xmlBufferCreateSize(void) {
18624: int test_ret = 0;
18625:
18626:
18627: /* missing type support */
18628: return(test_ret);
18629: }
18630:
18631:
18632: static int
18633: test_xmlBufferCreateStatic(void) {
18634: int test_ret = 0;
18635:
18636:
18637: /* missing type support */
18638: return(test_ret);
18639: }
18640:
18641:
18642: static int
1.1.1.2 ! misho 18643: test_xmlBufferDetach(void) {
! 18644: int test_ret = 0;
! 18645:
! 18646: int mem_base;
! 18647: xmlChar * ret_val;
! 18648: xmlBufferPtr buf; /* the buffer */
! 18649: int n_buf;
! 18650:
! 18651: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
! 18652: mem_base = xmlMemBlocks();
! 18653: buf = gen_xmlBufferPtr(n_buf, 0);
! 18654:
! 18655: ret_val = xmlBufferDetach(buf);
! 18656: desret_xmlChar_ptr(ret_val);
! 18657: call_tests++;
! 18658: des_xmlBufferPtr(n_buf, buf, 0);
! 18659: xmlResetLastError();
! 18660: if (mem_base != xmlMemBlocks()) {
! 18661: printf("Leak of %d blocks found in xmlBufferDetach",
! 18662: xmlMemBlocks() - mem_base);
! 18663: test_ret++;
! 18664: printf(" %d", n_buf);
! 18665: printf("\n");
! 18666: }
! 18667: }
! 18668: function_tests++;
! 18669:
! 18670: return(test_ret);
! 18671: }
! 18672:
! 18673:
! 18674: static int
1.1 misho 18675: test_xmlBufferEmpty(void) {
18676: int test_ret = 0;
18677:
18678: int mem_base;
18679: xmlBufferPtr buf; /* the buffer */
18680: int n_buf;
18681:
18682: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18683: mem_base = xmlMemBlocks();
18684: buf = gen_xmlBufferPtr(n_buf, 0);
18685:
18686: xmlBufferEmpty(buf);
18687: call_tests++;
18688: des_xmlBufferPtr(n_buf, buf, 0);
18689: xmlResetLastError();
18690: if (mem_base != xmlMemBlocks()) {
18691: printf("Leak of %d blocks found in xmlBufferEmpty",
18692: xmlMemBlocks() - mem_base);
18693: test_ret++;
18694: printf(" %d", n_buf);
18695: printf("\n");
18696: }
18697: }
18698: function_tests++;
18699:
18700: return(test_ret);
18701: }
18702:
18703:
18704: static int
18705: test_xmlBufferGrow(void) {
18706: int test_ret = 0;
18707:
18708: int mem_base;
18709: int ret_val;
18710: xmlBufferPtr buf; /* the buffer */
18711: int n_buf;
18712: unsigned int len; /* the minimum free size to allocate */
18713: int n_len;
18714:
18715: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18716: for (n_len = 0;n_len < gen_nb_unsigned_int;n_len++) {
18717: mem_base = xmlMemBlocks();
18718: buf = gen_xmlBufferPtr(n_buf, 0);
18719: len = gen_unsigned_int(n_len, 1);
18720:
18721: ret_val = xmlBufferGrow(buf, len);
18722: desret_int(ret_val);
18723: call_tests++;
18724: des_xmlBufferPtr(n_buf, buf, 0);
18725: des_unsigned_int(n_len, len, 1);
18726: xmlResetLastError();
18727: if (mem_base != xmlMemBlocks()) {
18728: printf("Leak of %d blocks found in xmlBufferGrow",
18729: xmlMemBlocks() - mem_base);
18730: test_ret++;
18731: printf(" %d", n_buf);
18732: printf(" %d", n_len);
18733: printf("\n");
18734: }
18735: }
18736: }
18737: function_tests++;
18738:
18739: return(test_ret);
18740: }
18741:
18742:
18743: static int
18744: test_xmlBufferLength(void) {
18745: int test_ret = 0;
18746:
18747: int mem_base;
18748: int ret_val;
18749: xmlBufferPtr buf; /* the buffer */
18750: int n_buf;
18751:
18752: for (n_buf = 0;n_buf < gen_nb_const_xmlBufferPtr;n_buf++) {
18753: mem_base = xmlMemBlocks();
18754: buf = gen_const_xmlBufferPtr(n_buf, 0);
18755:
18756: ret_val = xmlBufferLength((const xmlBufferPtr)buf);
18757: desret_int(ret_val);
18758: call_tests++;
18759: des_const_xmlBufferPtr(n_buf, (const xmlBufferPtr)buf, 0);
18760: xmlResetLastError();
18761: if (mem_base != xmlMemBlocks()) {
18762: printf("Leak of %d blocks found in xmlBufferLength",
18763: xmlMemBlocks() - mem_base);
18764: test_ret++;
18765: printf(" %d", n_buf);
18766: printf("\n");
18767: }
18768: }
18769: function_tests++;
18770:
18771: return(test_ret);
18772: }
18773:
18774:
18775: static int
18776: test_xmlBufferResize(void) {
18777: int test_ret = 0;
18778:
18779: int mem_base;
18780: int ret_val;
18781: xmlBufferPtr buf; /* the buffer to resize */
18782: int n_buf;
18783: unsigned int size; /* the desired size */
18784: int n_size;
18785:
18786: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18787: for (n_size = 0;n_size < gen_nb_unsigned_int;n_size++) {
18788: mem_base = xmlMemBlocks();
18789: buf = gen_xmlBufferPtr(n_buf, 0);
18790: size = gen_unsigned_int(n_size, 1);
18791:
18792: ret_val = xmlBufferResize(buf, size);
18793: desret_int(ret_val);
18794: call_tests++;
18795: des_xmlBufferPtr(n_buf, buf, 0);
18796: des_unsigned_int(n_size, size, 1);
18797: xmlResetLastError();
18798: if (mem_base != xmlMemBlocks()) {
18799: printf("Leak of %d blocks found in xmlBufferResize",
18800: xmlMemBlocks() - mem_base);
18801: test_ret++;
18802: printf(" %d", n_buf);
18803: printf(" %d", n_size);
18804: printf("\n");
18805: }
18806: }
18807: }
18808: function_tests++;
18809:
18810: return(test_ret);
18811: }
18812:
18813:
18814: static int
18815: test_xmlBufferSetAllocationScheme(void) {
18816: int test_ret = 0;
18817:
18818: int mem_base;
18819: xmlBufferPtr buf; /* the buffer to tune */
18820: int n_buf;
18821: xmlBufferAllocationScheme scheme; /* allocation scheme to use */
18822: int n_scheme;
18823:
18824: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18825: for (n_scheme = 0;n_scheme < gen_nb_xmlBufferAllocationScheme;n_scheme++) {
18826: mem_base = xmlMemBlocks();
18827: buf = gen_xmlBufferPtr(n_buf, 0);
18828: scheme = gen_xmlBufferAllocationScheme(n_scheme, 1);
18829:
18830: xmlBufferSetAllocationScheme(buf, scheme);
18831: if ((buf != NULL) && (scheme == XML_BUFFER_ALLOC_IMMUTABLE) && (buf->content != NULL) && (buf->content != static_buf_content)) { xmlFree(buf->content); buf->content = NULL;}
18832: call_tests++;
18833: des_xmlBufferPtr(n_buf, buf, 0);
18834: des_xmlBufferAllocationScheme(n_scheme, scheme, 1);
18835: xmlResetLastError();
18836: if (mem_base != xmlMemBlocks()) {
18837: printf("Leak of %d blocks found in xmlBufferSetAllocationScheme",
18838: xmlMemBlocks() - mem_base);
18839: test_ret++;
18840: printf(" %d", n_buf);
18841: printf(" %d", n_scheme);
18842: printf("\n");
18843: }
18844: }
18845: }
18846: function_tests++;
18847:
18848: return(test_ret);
18849: }
18850:
18851:
18852: static int
18853: test_xmlBufferShrink(void) {
18854: int test_ret = 0;
18855:
18856: int mem_base;
18857: int ret_val;
18858: xmlBufferPtr buf; /* the buffer to dump */
18859: int n_buf;
18860: unsigned int len; /* the number of xmlChar to remove */
18861: int n_len;
18862:
18863: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18864: for (n_len = 0;n_len < gen_nb_unsigned_int;n_len++) {
18865: mem_base = xmlMemBlocks();
18866: buf = gen_xmlBufferPtr(n_buf, 0);
18867: len = gen_unsigned_int(n_len, 1);
18868:
18869: ret_val = xmlBufferShrink(buf, len);
18870: desret_int(ret_val);
18871: call_tests++;
18872: des_xmlBufferPtr(n_buf, buf, 0);
18873: des_unsigned_int(n_len, len, 1);
18874: xmlResetLastError();
18875: if (mem_base != xmlMemBlocks()) {
18876: printf("Leak of %d blocks found in xmlBufferShrink",
18877: xmlMemBlocks() - mem_base);
18878: test_ret++;
18879: printf(" %d", n_buf);
18880: printf(" %d", n_len);
18881: printf("\n");
18882: }
18883: }
18884: }
18885: function_tests++;
18886:
18887: return(test_ret);
18888: }
18889:
18890:
18891: static int
18892: test_xmlBufferWriteCHAR(void) {
18893: int test_ret = 0;
18894:
18895: int mem_base;
18896: xmlBufferPtr buf; /* the XML buffer */
18897: int n_buf;
18898: xmlChar * string; /* the string to add */
18899: int n_string;
18900:
18901: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18902: for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) {
18903: mem_base = xmlMemBlocks();
18904: buf = gen_xmlBufferPtr(n_buf, 0);
18905: string = gen_const_xmlChar_ptr(n_string, 1);
18906:
18907: xmlBufferWriteCHAR(buf, (const xmlChar *)string);
18908: call_tests++;
18909: des_xmlBufferPtr(n_buf, buf, 0);
18910: des_const_xmlChar_ptr(n_string, (const xmlChar *)string, 1);
18911: xmlResetLastError();
18912: if (mem_base != xmlMemBlocks()) {
18913: printf("Leak of %d blocks found in xmlBufferWriteCHAR",
18914: xmlMemBlocks() - mem_base);
18915: test_ret++;
18916: printf(" %d", n_buf);
18917: printf(" %d", n_string);
18918: printf("\n");
18919: }
18920: }
18921: }
18922: function_tests++;
18923:
18924: return(test_ret);
18925: }
18926:
18927:
18928: static int
18929: test_xmlBufferWriteChar(void) {
18930: int test_ret = 0;
18931:
18932: int mem_base;
18933: xmlBufferPtr buf; /* the XML buffer output */
18934: int n_buf;
18935: char * string; /* the string to add */
18936: int n_string;
18937:
18938: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18939: for (n_string = 0;n_string < gen_nb_const_char_ptr;n_string++) {
18940: mem_base = xmlMemBlocks();
18941: buf = gen_xmlBufferPtr(n_buf, 0);
18942: string = gen_const_char_ptr(n_string, 1);
18943:
18944: xmlBufferWriteChar(buf, (const char *)string);
18945: call_tests++;
18946: des_xmlBufferPtr(n_buf, buf, 0);
18947: des_const_char_ptr(n_string, (const char *)string, 1);
18948: xmlResetLastError();
18949: if (mem_base != xmlMemBlocks()) {
18950: printf("Leak of %d blocks found in xmlBufferWriteChar",
18951: xmlMemBlocks() - mem_base);
18952: test_ret++;
18953: printf(" %d", n_buf);
18954: printf(" %d", n_string);
18955: printf("\n");
18956: }
18957: }
18958: }
18959: function_tests++;
18960:
18961: return(test_ret);
18962: }
18963:
18964:
18965: static int
18966: test_xmlBufferWriteQuotedString(void) {
18967: int test_ret = 0;
18968:
18969: int mem_base;
18970: xmlBufferPtr buf; /* the XML buffer output */
18971: int n_buf;
18972: xmlChar * string; /* the string to add */
18973: int n_string;
18974:
18975: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18976: for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) {
18977: mem_base = xmlMemBlocks();
18978: buf = gen_xmlBufferPtr(n_buf, 0);
18979: string = gen_const_xmlChar_ptr(n_string, 1);
18980:
18981: xmlBufferWriteQuotedString(buf, (const xmlChar *)string);
18982: call_tests++;
18983: des_xmlBufferPtr(n_buf, buf, 0);
18984: des_const_xmlChar_ptr(n_string, (const xmlChar *)string, 1);
18985: xmlResetLastError();
18986: if (mem_base != xmlMemBlocks()) {
18987: printf("Leak of %d blocks found in xmlBufferWriteQuotedString",
18988: xmlMemBlocks() - mem_base);
18989: test_ret++;
18990: printf(" %d", n_buf);
18991: printf(" %d", n_string);
18992: printf("\n");
18993: }
18994: }
18995: }
18996: function_tests++;
18997:
18998: return(test_ret);
18999: }
19000:
19001:
19002: static int
19003: test_xmlBuildQName(void) {
19004: int test_ret = 0;
19005:
19006: int mem_base;
19007: xmlChar * ret_val;
19008: xmlChar * ncname; /* the Name */
19009: int n_ncname;
19010: xmlChar * prefix; /* the prefix */
19011: int n_prefix;
19012: xmlChar * memory; /* preallocated memory */
19013: int n_memory;
19014: int len; /* preallocated memory length */
19015: int n_len;
19016:
19017: for (n_ncname = 0;n_ncname < gen_nb_const_xmlChar_ptr;n_ncname++) {
19018: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
19019: for (n_memory = 0;n_memory < gen_nb_xmlChar_ptr;n_memory++) {
19020: for (n_len = 0;n_len < gen_nb_int;n_len++) {
19021: mem_base = xmlMemBlocks();
19022: ncname = gen_const_xmlChar_ptr(n_ncname, 0);
19023: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
19024: memory = gen_xmlChar_ptr(n_memory, 2);
19025: len = gen_int(n_len, 3);
19026:
19027: ret_val = xmlBuildQName((const xmlChar *)ncname, (const xmlChar *)prefix, memory, len);
19028: if ((ret_val != NULL) && (ret_val != ncname) &&
19029: (ret_val != prefix) && (ret_val != memory))
19030: xmlFree(ret_val);
19031: ret_val = NULL;
19032: desret_xmlChar_ptr(ret_val);
19033: call_tests++;
19034: des_const_xmlChar_ptr(n_ncname, (const xmlChar *)ncname, 0);
19035: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
19036: des_xmlChar_ptr(n_memory, memory, 2);
19037: des_int(n_len, len, 3);
19038: xmlResetLastError();
19039: if (mem_base != xmlMemBlocks()) {
19040: printf("Leak of %d blocks found in xmlBuildQName",
19041: xmlMemBlocks() - mem_base);
19042: test_ret++;
19043: printf(" %d", n_ncname);
19044: printf(" %d", n_prefix);
19045: printf(" %d", n_memory);
19046: printf(" %d", n_len);
19047: printf("\n");
19048: }
19049: }
19050: }
19051: }
19052: }
19053: function_tests++;
19054:
19055: return(test_ret);
19056: }
19057:
19058:
19059: static int
19060: test_xmlChildElementCount(void) {
19061: int test_ret = 0;
19062:
19063: #if defined(LIBXML_TREE_ENABLED)
19064: int mem_base;
19065: unsigned long ret_val;
19066: xmlNodePtr parent; /* the parent node */
19067: int n_parent;
19068:
19069: for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
19070: mem_base = xmlMemBlocks();
19071: parent = gen_xmlNodePtr(n_parent, 0);
19072:
19073: ret_val = xmlChildElementCount(parent);
19074: desret_unsigned_long(ret_val);
19075: call_tests++;
19076: des_xmlNodePtr(n_parent, parent, 0);
19077: xmlResetLastError();
19078: if (mem_base != xmlMemBlocks()) {
19079: printf("Leak of %d blocks found in xmlChildElementCount",
19080: xmlMemBlocks() - mem_base);
19081: test_ret++;
19082: printf(" %d", n_parent);
19083: printf("\n");
19084: }
19085: }
19086: function_tests++;
19087: #endif
19088:
19089: return(test_ret);
19090: }
19091:
19092:
19093: static int
19094: test_xmlCopyDoc(void) {
19095: int test_ret = 0;
19096:
19097: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
19098: int mem_base;
19099: xmlDocPtr ret_val;
19100: xmlDocPtr doc; /* the document */
19101: int n_doc;
19102: int recursive; /* if not zero do a recursive copy. */
19103: int n_recursive;
19104:
19105: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
19106: for (n_recursive = 0;n_recursive < gen_nb_int;n_recursive++) {
19107: mem_base = xmlMemBlocks();
19108: doc = gen_xmlDocPtr(n_doc, 0);
19109: recursive = gen_int(n_recursive, 1);
19110:
19111: ret_val = xmlCopyDoc(doc, recursive);
19112: desret_xmlDocPtr(ret_val);
19113: call_tests++;
19114: des_xmlDocPtr(n_doc, doc, 0);
19115: des_int(n_recursive, recursive, 1);
19116: xmlResetLastError();
19117: if (mem_base != xmlMemBlocks()) {
19118: printf("Leak of %d blocks found in xmlCopyDoc",
19119: xmlMemBlocks() - mem_base);
19120: test_ret++;
19121: printf(" %d", n_doc);
19122: printf(" %d", n_recursive);
19123: printf("\n");
19124: }
19125: }
19126: }
19127: function_tests++;
19128: #endif
19129:
19130: return(test_ret);
19131: }
19132:
19133:
19134: static int
19135: test_xmlCopyDtd(void) {
19136: int test_ret = 0;
19137:
19138: #if defined(LIBXML_TREE_ENABLED)
19139: int mem_base;
19140: xmlDtdPtr ret_val;
19141: xmlDtdPtr dtd; /* the dtd */
19142: int n_dtd;
19143:
19144: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
19145: mem_base = xmlMemBlocks();
19146: dtd = gen_xmlDtdPtr(n_dtd, 0);
19147:
19148: ret_val = xmlCopyDtd(dtd);
19149: desret_xmlDtdPtr(ret_val);
19150: call_tests++;
19151: des_xmlDtdPtr(n_dtd, dtd, 0);
19152: xmlResetLastError();
19153: if (mem_base != xmlMemBlocks()) {
19154: printf("Leak of %d blocks found in xmlCopyDtd",
19155: xmlMemBlocks() - mem_base);
19156: test_ret++;
19157: printf(" %d", n_dtd);
19158: printf("\n");
19159: }
19160: }
19161: function_tests++;
19162: #endif
19163:
19164: return(test_ret);
19165: }
19166:
19167:
19168: static int
19169: test_xmlCopyNamespace(void) {
19170: int test_ret = 0;
19171:
19172: int mem_base;
19173: xmlNsPtr ret_val;
19174: xmlNsPtr cur; /* the namespace */
19175: int n_cur;
19176:
19177: for (n_cur = 0;n_cur < gen_nb_xmlNsPtr;n_cur++) {
19178: mem_base = xmlMemBlocks();
19179: cur = gen_xmlNsPtr(n_cur, 0);
19180:
19181: ret_val = xmlCopyNamespace(cur);
19182: if (ret_val != NULL) xmlFreeNs(ret_val);
19183: desret_xmlNsPtr(ret_val);
19184: call_tests++;
19185: des_xmlNsPtr(n_cur, cur, 0);
19186: xmlResetLastError();
19187: if (mem_base != xmlMemBlocks()) {
19188: printf("Leak of %d blocks found in xmlCopyNamespace",
19189: xmlMemBlocks() - mem_base);
19190: test_ret++;
19191: printf(" %d", n_cur);
19192: printf("\n");
19193: }
19194: }
19195: function_tests++;
19196:
19197: return(test_ret);
19198: }
19199:
19200:
19201: static int
19202: test_xmlCopyNamespaceList(void) {
19203: int test_ret = 0;
19204:
19205: int mem_base;
19206: xmlNsPtr ret_val;
19207: xmlNsPtr cur; /* the first namespace */
19208: int n_cur;
19209:
19210: for (n_cur = 0;n_cur < gen_nb_xmlNsPtr;n_cur++) {
19211: mem_base = xmlMemBlocks();
19212: cur = gen_xmlNsPtr(n_cur, 0);
19213:
19214: ret_val = xmlCopyNamespaceList(cur);
19215: if (ret_val != NULL) xmlFreeNsList(ret_val);
19216: desret_xmlNsPtr(ret_val);
19217: call_tests++;
19218: des_xmlNsPtr(n_cur, cur, 0);
19219: xmlResetLastError();
19220: if (mem_base != xmlMemBlocks()) {
19221: printf("Leak of %d blocks found in xmlCopyNamespaceList",
19222: xmlMemBlocks() - mem_base);
19223: test_ret++;
19224: printf(" %d", n_cur);
19225: printf("\n");
19226: }
19227: }
19228: function_tests++;
19229:
19230: return(test_ret);
19231: }
19232:
19233:
19234: static int
19235: test_xmlCopyNode(void) {
19236: int test_ret = 0;
19237:
19238: int mem_base;
19239: xmlNodePtr ret_val;
19240: xmlNodePtr node; /* the node */
19241: int n_node;
19242: int extended; /* if 1 do a recursive copy (properties, namespaces and children when applicable) if 2 copy properties and namespaces (when applicable) */
19243: int n_extended;
19244:
19245: for (n_node = 0;n_node < gen_nb_const_xmlNodePtr;n_node++) {
19246: for (n_extended = 0;n_extended < gen_nb_int;n_extended++) {
19247: mem_base = xmlMemBlocks();
19248: node = gen_const_xmlNodePtr(n_node, 0);
19249: extended = gen_int(n_extended, 1);
19250:
19251: ret_val = xmlCopyNode((const xmlNodePtr)node, extended);
19252: desret_xmlNodePtr(ret_val);
19253: call_tests++;
19254: des_const_xmlNodePtr(n_node, (const xmlNodePtr)node, 0);
19255: des_int(n_extended, extended, 1);
19256: xmlResetLastError();
19257: if (mem_base != xmlMemBlocks()) {
19258: printf("Leak of %d blocks found in xmlCopyNode",
19259: xmlMemBlocks() - mem_base);
19260: test_ret++;
19261: printf(" %d", n_node);
19262: printf(" %d", n_extended);
19263: printf("\n");
19264: }
19265: }
19266: }
19267: function_tests++;
19268:
19269: return(test_ret);
19270: }
19271:
19272:
19273: static int
19274: test_xmlCopyNodeList(void) {
19275: int test_ret = 0;
19276:
19277: int mem_base;
19278: xmlNodePtr ret_val;
19279: xmlNodePtr node; /* the first node in the list. */
19280: int n_node;
19281:
19282: for (n_node = 0;n_node < gen_nb_const_xmlNodePtr;n_node++) {
19283: mem_base = xmlMemBlocks();
19284: node = gen_const_xmlNodePtr(n_node, 0);
19285:
19286: ret_val = xmlCopyNodeList((const xmlNodePtr)node);
19287: desret_xmlNodePtr(ret_val);
19288: call_tests++;
19289: des_const_xmlNodePtr(n_node, (const xmlNodePtr)node, 0);
19290: xmlResetLastError();
19291: if (mem_base != xmlMemBlocks()) {
19292: printf("Leak of %d blocks found in xmlCopyNodeList",
19293: xmlMemBlocks() - mem_base);
19294: test_ret++;
19295: printf(" %d", n_node);
19296: printf("\n");
19297: }
19298: }
19299: function_tests++;
19300:
19301: return(test_ret);
19302: }
19303:
19304:
19305: static int
19306: test_xmlCopyProp(void) {
19307: int test_ret = 0;
19308:
19309: int mem_base;
19310: xmlAttrPtr ret_val;
19311: xmlNodePtr target; /* the element where the attribute will be grafted */
19312: int n_target;
19313: xmlAttrPtr cur; /* the attribute */
19314: int n_cur;
19315:
19316: for (n_target = 0;n_target < gen_nb_xmlNodePtr;n_target++) {
19317: for (n_cur = 0;n_cur < gen_nb_xmlAttrPtr;n_cur++) {
19318: mem_base = xmlMemBlocks();
19319: target = gen_xmlNodePtr(n_target, 0);
19320: cur = gen_xmlAttrPtr(n_cur, 1);
19321:
19322: ret_val = xmlCopyProp(target, cur);
19323: desret_xmlAttrPtr(ret_val);
19324: call_tests++;
19325: des_xmlNodePtr(n_target, target, 0);
19326: des_xmlAttrPtr(n_cur, cur, 1);
19327: xmlResetLastError();
19328: if (mem_base != xmlMemBlocks()) {
19329: printf("Leak of %d blocks found in xmlCopyProp",
19330: xmlMemBlocks() - mem_base);
19331: test_ret++;
19332: printf(" %d", n_target);
19333: printf(" %d", n_cur);
19334: printf("\n");
19335: }
19336: }
19337: }
19338: function_tests++;
19339:
19340: return(test_ret);
19341: }
19342:
19343:
19344: static int
19345: test_xmlCopyPropList(void) {
19346: int test_ret = 0;
19347:
19348: int mem_base;
19349: xmlAttrPtr ret_val;
19350: xmlNodePtr target; /* the element where the attributes will be grafted */
19351: int n_target;
19352: xmlAttrPtr cur; /* the first attribute */
19353: int n_cur;
19354:
19355: for (n_target = 0;n_target < gen_nb_xmlNodePtr;n_target++) {
19356: for (n_cur = 0;n_cur < gen_nb_xmlAttrPtr;n_cur++) {
19357: mem_base = xmlMemBlocks();
19358: target = gen_xmlNodePtr(n_target, 0);
19359: cur = gen_xmlAttrPtr(n_cur, 1);
19360:
19361: ret_val = xmlCopyPropList(target, cur);
19362: desret_xmlAttrPtr(ret_val);
19363: call_tests++;
19364: des_xmlNodePtr(n_target, target, 0);
19365: des_xmlAttrPtr(n_cur, cur, 1);
19366: xmlResetLastError();
19367: if (mem_base != xmlMemBlocks()) {
19368: printf("Leak of %d blocks found in xmlCopyPropList",
19369: xmlMemBlocks() - mem_base);
19370: test_ret++;
19371: printf(" %d", n_target);
19372: printf(" %d", n_cur);
19373: printf("\n");
19374: }
19375: }
19376: }
19377: function_tests++;
19378:
19379: return(test_ret);
19380: }
19381:
19382:
19383: static int
19384: test_xmlCreateIntSubset(void) {
19385: int test_ret = 0;
19386:
19387: int mem_base;
19388: xmlDtdPtr ret_val;
19389: xmlDocPtr doc; /* the document pointer */
19390: int n_doc;
19391: xmlChar * name; /* the DTD name */
19392: int n_name;
19393: xmlChar * ExternalID; /* the external (PUBLIC) ID */
19394: int n_ExternalID;
19395: xmlChar * SystemID; /* the system ID */
19396: int n_SystemID;
19397:
19398: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
19399: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
19400: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
19401: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
19402: mem_base = xmlMemBlocks();
19403: doc = gen_xmlDocPtr(n_doc, 0);
19404: name = gen_const_xmlChar_ptr(n_name, 1);
19405: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 2);
19406: SystemID = gen_const_xmlChar_ptr(n_SystemID, 3);
19407:
19408: ret_val = xmlCreateIntSubset(doc, (const xmlChar *)name, (const xmlChar *)ExternalID, (const xmlChar *)SystemID);
19409: desret_xmlDtdPtr(ret_val);
19410: call_tests++;
19411: des_xmlDocPtr(n_doc, doc, 0);
19412: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
19413: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 2);
19414: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 3);
19415: xmlResetLastError();
19416: if (mem_base != xmlMemBlocks()) {
19417: printf("Leak of %d blocks found in xmlCreateIntSubset",
19418: xmlMemBlocks() - mem_base);
19419: test_ret++;
19420: printf(" %d", n_doc);
19421: printf(" %d", n_name);
19422: printf(" %d", n_ExternalID);
19423: printf(" %d", n_SystemID);
19424: printf("\n");
19425: }
19426: }
19427: }
19428: }
19429: }
19430: function_tests++;
19431:
19432: return(test_ret);
19433: }
19434:
19435:
19436: #define gen_nb_xmlDOMWrapCtxtPtr 1
19437: static xmlDOMWrapCtxtPtr gen_xmlDOMWrapCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
19438: return(NULL);
19439: }
19440: static void des_xmlDOMWrapCtxtPtr(int no ATTRIBUTE_UNUSED, xmlDOMWrapCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
19441: }
19442:
19443: static int
19444: test_xmlDOMWrapAdoptNode(void) {
19445: int test_ret = 0;
19446:
19447: int mem_base;
19448: int ret_val;
19449: xmlDOMWrapCtxtPtr ctxt; /* the optional context for custom processing */
19450: int n_ctxt;
19451: xmlDocPtr sourceDoc; /* the optional sourceDoc */
19452: int n_sourceDoc;
19453: xmlNodePtr node; /* the node to start with */
19454: int n_node;
19455: xmlDocPtr destDoc; /* the destination doc */
19456: int n_destDoc;
19457: xmlNodePtr destParent; /* the optional new parent of @node in @destDoc */
19458: int n_destParent;
19459: int options; /* option flags */
19460: int n_options;
19461:
19462: for (n_ctxt = 0;n_ctxt < gen_nb_xmlDOMWrapCtxtPtr;n_ctxt++) {
19463: for (n_sourceDoc = 0;n_sourceDoc < gen_nb_xmlDocPtr;n_sourceDoc++) {
19464: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
19465: for (n_destDoc = 0;n_destDoc < gen_nb_xmlDocPtr;n_destDoc++) {
19466: for (n_destParent = 0;n_destParent < gen_nb_xmlNodePtr;n_destParent++) {
19467: for (n_options = 0;n_options < gen_nb_int;n_options++) {
19468: mem_base = xmlMemBlocks();
19469: ctxt = gen_xmlDOMWrapCtxtPtr(n_ctxt, 0);
19470: sourceDoc = gen_xmlDocPtr(n_sourceDoc, 1);
19471: node = gen_xmlNodePtr(n_node, 2);
19472: destDoc = gen_xmlDocPtr(n_destDoc, 3);
19473: destParent = gen_xmlNodePtr(n_destParent, 4);
19474: options = gen_int(n_options, 5);
19475:
19476: ret_val = xmlDOMWrapAdoptNode(ctxt, sourceDoc, node, destDoc, destParent, options);
19477: if ((node != NULL) && (node->parent == NULL)) {xmlUnlinkNode(node);xmlFreeNode(node);node = NULL;}
19478: desret_int(ret_val);
19479: call_tests++;
19480: des_xmlDOMWrapCtxtPtr(n_ctxt, ctxt, 0);
19481: des_xmlDocPtr(n_sourceDoc, sourceDoc, 1);
19482: des_xmlNodePtr(n_node, node, 2);
19483: des_xmlDocPtr(n_destDoc, destDoc, 3);
19484: des_xmlNodePtr(n_destParent, destParent, 4);
19485: des_int(n_options, options, 5);
19486: xmlResetLastError();
19487: if (mem_base != xmlMemBlocks()) {
19488: printf("Leak of %d blocks found in xmlDOMWrapAdoptNode",
19489: xmlMemBlocks() - mem_base);
19490: test_ret++;
19491: printf(" %d", n_ctxt);
19492: printf(" %d", n_sourceDoc);
19493: printf(" %d", n_node);
19494: printf(" %d", n_destDoc);
19495: printf(" %d", n_destParent);
19496: printf(" %d", n_options);
19497: printf("\n");
19498: }
19499: }
19500: }
19501: }
19502: }
19503: }
19504: }
19505: function_tests++;
19506:
19507: return(test_ret);
19508: }
19509:
19510:
19511: static int
19512: test_xmlDOMWrapCloneNode(void) {
19513: int test_ret = 0;
19514:
19515: int mem_base;
19516: int ret_val;
19517: xmlDOMWrapCtxtPtr ctxt; /* the optional context for custom processing */
19518: int n_ctxt;
19519: xmlDocPtr sourceDoc; /* the optional sourceDoc */
19520: int n_sourceDoc;
19521: xmlNodePtr node; /* the node to start with */
19522: int n_node;
19523: xmlNodePtr * resNode; /* the clone of the given @node */
19524: int n_resNode;
19525: xmlDocPtr destDoc; /* the destination doc */
19526: int n_destDoc;
19527: xmlNodePtr destParent; /* the optional new parent of @node in @destDoc */
19528: int n_destParent;
19529: int deep; /* descend into child if set */
19530: int n_deep;
19531: int options; /* option flags */
19532: int n_options;
19533:
19534: for (n_ctxt = 0;n_ctxt < gen_nb_xmlDOMWrapCtxtPtr;n_ctxt++) {
19535: for (n_sourceDoc = 0;n_sourceDoc < gen_nb_xmlDocPtr;n_sourceDoc++) {
19536: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
19537: for (n_resNode = 0;n_resNode < gen_nb_xmlNodePtr_ptr;n_resNode++) {
19538: for (n_destDoc = 0;n_destDoc < gen_nb_xmlDocPtr;n_destDoc++) {
19539: for (n_destParent = 0;n_destParent < gen_nb_xmlNodePtr;n_destParent++) {
19540: for (n_deep = 0;n_deep < gen_nb_int;n_deep++) {
19541: for (n_options = 0;n_options < gen_nb_int;n_options++) {
19542: mem_base = xmlMemBlocks();
19543: ctxt = gen_xmlDOMWrapCtxtPtr(n_ctxt, 0);
19544: sourceDoc = gen_xmlDocPtr(n_sourceDoc, 1);
19545: node = gen_xmlNodePtr(n_node, 2);
19546: resNode = gen_xmlNodePtr_ptr(n_resNode, 3);
19547: destDoc = gen_xmlDocPtr(n_destDoc, 4);
19548: destParent = gen_xmlNodePtr(n_destParent, 5);
19549: deep = gen_int(n_deep, 6);
19550: options = gen_int(n_options, 7);
19551:
19552: ret_val = xmlDOMWrapCloneNode(ctxt, sourceDoc, node, resNode, destDoc, destParent, deep, options);
19553: desret_int(ret_val);
19554: call_tests++;
19555: des_xmlDOMWrapCtxtPtr(n_ctxt, ctxt, 0);
19556: des_xmlDocPtr(n_sourceDoc, sourceDoc, 1);
19557: des_xmlNodePtr(n_node, node, 2);
19558: des_xmlNodePtr_ptr(n_resNode, resNode, 3);
19559: des_xmlDocPtr(n_destDoc, destDoc, 4);
19560: des_xmlNodePtr(n_destParent, destParent, 5);
19561: des_int(n_deep, deep, 6);
19562: des_int(n_options, options, 7);
19563: xmlResetLastError();
19564: if (mem_base != xmlMemBlocks()) {
19565: printf("Leak of %d blocks found in xmlDOMWrapCloneNode",
19566: xmlMemBlocks() - mem_base);
19567: test_ret++;
19568: printf(" %d", n_ctxt);
19569: printf(" %d", n_sourceDoc);
19570: printf(" %d", n_node);
19571: printf(" %d", n_resNode);
19572: printf(" %d", n_destDoc);
19573: printf(" %d", n_destParent);
19574: printf(" %d", n_deep);
19575: printf(" %d", n_options);
19576: printf("\n");
19577: }
19578: }
19579: }
19580: }
19581: }
19582: }
19583: }
19584: }
19585: }
19586: function_tests++;
19587:
19588: return(test_ret);
19589: }
19590:
19591:
19592: static int
19593: test_xmlDOMWrapNewCtxt(void) {
19594: int test_ret = 0;
19595:
19596:
19597: /* missing type support */
19598: return(test_ret);
19599: }
19600:
19601:
19602: static int
19603: test_xmlDOMWrapReconcileNamespaces(void) {
19604: int test_ret = 0;
19605:
19606: int mem_base;
19607: int ret_val;
19608: xmlDOMWrapCtxtPtr ctxt; /* DOM wrapper context, unused at the moment */
19609: int n_ctxt;
19610: xmlNodePtr elem; /* the element-node */
19611: int n_elem;
19612: int options; /* option flags */
19613: int n_options;
19614:
19615: for (n_ctxt = 0;n_ctxt < gen_nb_xmlDOMWrapCtxtPtr;n_ctxt++) {
19616: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
19617: for (n_options = 0;n_options < gen_nb_int;n_options++) {
19618: mem_base = xmlMemBlocks();
19619: ctxt = gen_xmlDOMWrapCtxtPtr(n_ctxt, 0);
19620: elem = gen_xmlNodePtr(n_elem, 1);
19621: options = gen_int(n_options, 2);
19622:
19623: ret_val = xmlDOMWrapReconcileNamespaces(ctxt, elem, options);
19624: desret_int(ret_val);
19625: call_tests++;
19626: des_xmlDOMWrapCtxtPtr(n_ctxt, ctxt, 0);
19627: des_xmlNodePtr(n_elem, elem, 1);
19628: des_int(n_options, options, 2);
19629: xmlResetLastError();
19630: if (mem_base != xmlMemBlocks()) {
19631: printf("Leak of %d blocks found in xmlDOMWrapReconcileNamespaces",
19632: xmlMemBlocks() - mem_base);
19633: test_ret++;
19634: printf(" %d", n_ctxt);
19635: printf(" %d", n_elem);
19636: printf(" %d", n_options);
19637: printf("\n");
19638: }
19639: }
19640: }
19641: }
19642: function_tests++;
19643:
19644: return(test_ret);
19645: }
19646:
19647:
19648: static int
19649: test_xmlDOMWrapRemoveNode(void) {
19650: int test_ret = 0;
19651:
19652: int mem_base;
19653: int ret_val;
19654: xmlDOMWrapCtxtPtr ctxt; /* a DOM wrapper context */
19655: int n_ctxt;
19656: xmlDocPtr doc; /* the doc */
19657: int n_doc;
19658: xmlNodePtr node; /* the node to be removed. */
19659: int n_node;
19660: int options; /* set of options, unused at the moment */
19661: int n_options;
19662:
19663: for (n_ctxt = 0;n_ctxt < gen_nb_xmlDOMWrapCtxtPtr;n_ctxt++) {
19664: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
19665: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
19666: for (n_options = 0;n_options < gen_nb_int;n_options++) {
19667: mem_base = xmlMemBlocks();
19668: ctxt = gen_xmlDOMWrapCtxtPtr(n_ctxt, 0);
19669: doc = gen_xmlDocPtr(n_doc, 1);
19670: node = gen_xmlNodePtr(n_node, 2);
19671: options = gen_int(n_options, 3);
19672:
19673: ret_val = xmlDOMWrapRemoveNode(ctxt, doc, node, options);
19674: desret_int(ret_val);
19675: call_tests++;
19676: des_xmlDOMWrapCtxtPtr(n_ctxt, ctxt, 0);
19677: des_xmlDocPtr(n_doc, doc, 1);
19678: des_xmlNodePtr(n_node, node, 2);
19679: des_int(n_options, options, 3);
19680: xmlResetLastError();
19681: if (mem_base != xmlMemBlocks()) {
19682: printf("Leak of %d blocks found in xmlDOMWrapRemoveNode",
19683: xmlMemBlocks() - mem_base);
19684: test_ret++;
19685: printf(" %d", n_ctxt);
19686: printf(" %d", n_doc);
19687: printf(" %d", n_node);
19688: printf(" %d", n_options);
19689: printf("\n");
19690: }
19691: }
19692: }
19693: }
19694: }
19695: function_tests++;
19696:
19697: return(test_ret);
19698: }
19699:
19700:
19701: static int
19702: test_xmlDocCopyNode(void) {
19703: int test_ret = 0;
19704:
19705: int mem_base;
19706: xmlNodePtr ret_val;
19707: xmlNodePtr node; /* the node */
19708: int n_node;
19709: xmlDocPtr doc; /* the document */
19710: int n_doc;
19711: int extended; /* if 1 do a recursive copy (properties, namespaces and children when applicable) if 2 copy properties and namespaces (when applicable) */
19712: int n_extended;
19713:
19714: for (n_node = 0;n_node < gen_nb_const_xmlNodePtr;n_node++) {
19715: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
19716: for (n_extended = 0;n_extended < gen_nb_int;n_extended++) {
19717: mem_base = xmlMemBlocks();
19718: node = gen_const_xmlNodePtr(n_node, 0);
19719: doc = gen_xmlDocPtr(n_doc, 1);
19720: extended = gen_int(n_extended, 2);
19721:
19722: ret_val = xmlDocCopyNode((const xmlNodePtr)node, doc, extended);
19723: desret_xmlNodePtr(ret_val);
19724: call_tests++;
19725: des_const_xmlNodePtr(n_node, (const xmlNodePtr)node, 0);
19726: des_xmlDocPtr(n_doc, doc, 1);
19727: des_int(n_extended, extended, 2);
19728: xmlResetLastError();
19729: if (mem_base != xmlMemBlocks()) {
19730: printf("Leak of %d blocks found in xmlDocCopyNode",
19731: xmlMemBlocks() - mem_base);
19732: test_ret++;
19733: printf(" %d", n_node);
19734: printf(" %d", n_doc);
19735: printf(" %d", n_extended);
19736: printf("\n");
19737: }
19738: }
19739: }
19740: }
19741: function_tests++;
19742:
19743: return(test_ret);
19744: }
19745:
19746:
19747: static int
19748: test_xmlDocCopyNodeList(void) {
19749: int test_ret = 0;
19750:
19751: int mem_base;
19752: xmlNodePtr ret_val;
19753: xmlDocPtr doc; /* the target document */
19754: int n_doc;
19755: xmlNodePtr node; /* the first node in the list. */
19756: int n_node;
19757:
19758: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
19759: for (n_node = 0;n_node < gen_nb_const_xmlNodePtr;n_node++) {
19760: mem_base = xmlMemBlocks();
19761: doc = gen_xmlDocPtr(n_doc, 0);
19762: node = gen_const_xmlNodePtr(n_node, 1);
19763:
19764: ret_val = xmlDocCopyNodeList(doc, (const xmlNodePtr)node);
19765: desret_xmlNodePtr(ret_val);
19766: call_tests++;
19767: des_xmlDocPtr(n_doc, doc, 0);
19768: des_const_xmlNodePtr(n_node, (const xmlNodePtr)node, 1);
19769: xmlResetLastError();
19770: if (mem_base != xmlMemBlocks()) {
19771: printf("Leak of %d blocks found in xmlDocCopyNodeList",
19772: xmlMemBlocks() - mem_base);
19773: test_ret++;
19774: printf(" %d", n_doc);
19775: printf(" %d", n_node);
19776: printf("\n");
19777: }
19778: }
19779: }
19780: function_tests++;
19781:
19782: return(test_ret);
19783: }
19784:
19785:
19786: static int
19787: test_xmlDocDump(void) {
19788: int test_ret = 0;
19789:
19790: #if defined(LIBXML_OUTPUT_ENABLED)
19791: int mem_base;
19792: int ret_val;
19793: FILE * f; /* the FILE* */
19794: int n_f;
19795: xmlDocPtr cur; /* the document */
19796: int n_cur;
19797:
19798: for (n_f = 0;n_f < gen_nb_FILE_ptr;n_f++) {
19799: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
19800: mem_base = xmlMemBlocks();
19801: f = gen_FILE_ptr(n_f, 0);
19802: cur = gen_xmlDocPtr(n_cur, 1);
19803:
19804: ret_val = xmlDocDump(f, cur);
19805: desret_int(ret_val);
19806: call_tests++;
19807: des_FILE_ptr(n_f, f, 0);
19808: des_xmlDocPtr(n_cur, cur, 1);
19809: xmlResetLastError();
19810: if (mem_base != xmlMemBlocks()) {
19811: printf("Leak of %d blocks found in xmlDocDump",
19812: xmlMemBlocks() - mem_base);
19813: test_ret++;
19814: printf(" %d", n_f);
19815: printf(" %d", n_cur);
19816: printf("\n");
19817: }
19818: }
19819: }
19820: function_tests++;
19821: #endif
19822:
19823: return(test_ret);
19824: }
19825:
19826:
19827: static int
19828: test_xmlDocDumpFormatMemory(void) {
19829: int test_ret = 0;
19830:
19831: #if defined(LIBXML_OUTPUT_ENABLED)
19832: int mem_base;
19833: xmlDocPtr cur; /* the document */
19834: int n_cur;
19835: xmlChar ** mem; /* OUT: the memory pointer */
19836: int n_mem;
19837: int * size; /* OUT: the memory length */
19838: int n_size;
19839: int format; /* should formatting spaces been added */
19840: int n_format;
19841:
19842: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
19843: for (n_mem = 0;n_mem < gen_nb_xmlChar_ptr_ptr;n_mem++) {
19844: for (n_size = 0;n_size < gen_nb_int_ptr;n_size++) {
19845: for (n_format = 0;n_format < gen_nb_int;n_format++) {
19846: mem_base = xmlMemBlocks();
19847: cur = gen_xmlDocPtr(n_cur, 0);
19848: mem = gen_xmlChar_ptr_ptr(n_mem, 1);
19849: size = gen_int_ptr(n_size, 2);
19850: format = gen_int(n_format, 3);
19851:
19852: xmlDocDumpFormatMemory(cur, mem, size, format);
19853: call_tests++;
19854: des_xmlDocPtr(n_cur, cur, 0);
19855: des_xmlChar_ptr_ptr(n_mem, mem, 1);
19856: des_int_ptr(n_size, size, 2);
19857: des_int(n_format, format, 3);
19858: xmlResetLastError();
19859: if (mem_base != xmlMemBlocks()) {
19860: printf("Leak of %d blocks found in xmlDocDumpFormatMemory",
19861: xmlMemBlocks() - mem_base);
19862: test_ret++;
19863: printf(" %d", n_cur);
19864: printf(" %d", n_mem);
19865: printf(" %d", n_size);
19866: printf(" %d", n_format);
19867: printf("\n");
19868: }
19869: }
19870: }
19871: }
19872: }
19873: function_tests++;
19874: #endif
19875:
19876: return(test_ret);
19877: }
19878:
19879:
19880: static int
19881: test_xmlDocDumpFormatMemoryEnc(void) {
19882: int test_ret = 0;
19883:
19884: #if defined(LIBXML_OUTPUT_ENABLED)
19885: int mem_base;
19886: xmlDocPtr out_doc; /* Document to generate XML text from */
19887: int n_out_doc;
19888: xmlChar ** doc_txt_ptr; /* Memory pointer for allocated XML text */
19889: int n_doc_txt_ptr;
19890: int * doc_txt_len; /* Length of the generated XML text */
19891: int n_doc_txt_len;
19892: char * txt_encoding; /* Character encoding to use when generating XML text */
19893: int n_txt_encoding;
19894: int format; /* should formatting spaces been added */
19895: int n_format;
19896:
19897: for (n_out_doc = 0;n_out_doc < gen_nb_xmlDocPtr;n_out_doc++) {
19898: for (n_doc_txt_ptr = 0;n_doc_txt_ptr < gen_nb_xmlChar_ptr_ptr;n_doc_txt_ptr++) {
19899: for (n_doc_txt_len = 0;n_doc_txt_len < gen_nb_int_ptr;n_doc_txt_len++) {
19900: for (n_txt_encoding = 0;n_txt_encoding < gen_nb_const_char_ptr;n_txt_encoding++) {
19901: for (n_format = 0;n_format < gen_nb_int;n_format++) {
19902: mem_base = xmlMemBlocks();
19903: out_doc = gen_xmlDocPtr(n_out_doc, 0);
19904: doc_txt_ptr = gen_xmlChar_ptr_ptr(n_doc_txt_ptr, 1);
19905: doc_txt_len = gen_int_ptr(n_doc_txt_len, 2);
19906: txt_encoding = gen_const_char_ptr(n_txt_encoding, 3);
19907: format = gen_int(n_format, 4);
19908:
19909: xmlDocDumpFormatMemoryEnc(out_doc, doc_txt_ptr, doc_txt_len, (const char *)txt_encoding, format);
19910: call_tests++;
19911: des_xmlDocPtr(n_out_doc, out_doc, 0);
19912: des_xmlChar_ptr_ptr(n_doc_txt_ptr, doc_txt_ptr, 1);
19913: des_int_ptr(n_doc_txt_len, doc_txt_len, 2);
19914: des_const_char_ptr(n_txt_encoding, (const char *)txt_encoding, 3);
19915: des_int(n_format, format, 4);
19916: xmlResetLastError();
19917: if (mem_base != xmlMemBlocks()) {
19918: printf("Leak of %d blocks found in xmlDocDumpFormatMemoryEnc",
19919: xmlMemBlocks() - mem_base);
19920: test_ret++;
19921: printf(" %d", n_out_doc);
19922: printf(" %d", n_doc_txt_ptr);
19923: printf(" %d", n_doc_txt_len);
19924: printf(" %d", n_txt_encoding);
19925: printf(" %d", n_format);
19926: printf("\n");
19927: }
19928: }
19929: }
19930: }
19931: }
19932: }
19933: function_tests++;
19934: #endif
19935:
19936: return(test_ret);
19937: }
19938:
19939:
19940: static int
19941: test_xmlDocDumpMemory(void) {
19942: int test_ret = 0;
19943:
19944: #if defined(LIBXML_OUTPUT_ENABLED)
19945: int mem_base;
19946: xmlDocPtr cur; /* the document */
19947: int n_cur;
19948: xmlChar ** mem; /* OUT: the memory pointer */
19949: int n_mem;
19950: int * size; /* OUT: the memory length */
19951: int n_size;
19952:
19953: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
19954: for (n_mem = 0;n_mem < gen_nb_xmlChar_ptr_ptr;n_mem++) {
19955: for (n_size = 0;n_size < gen_nb_int_ptr;n_size++) {
19956: mem_base = xmlMemBlocks();
19957: cur = gen_xmlDocPtr(n_cur, 0);
19958: mem = gen_xmlChar_ptr_ptr(n_mem, 1);
19959: size = gen_int_ptr(n_size, 2);
19960:
19961: xmlDocDumpMemory(cur, mem, size);
19962: call_tests++;
19963: des_xmlDocPtr(n_cur, cur, 0);
19964: des_xmlChar_ptr_ptr(n_mem, mem, 1);
19965: des_int_ptr(n_size, size, 2);
19966: xmlResetLastError();
19967: if (mem_base != xmlMemBlocks()) {
19968: printf("Leak of %d blocks found in xmlDocDumpMemory",
19969: xmlMemBlocks() - mem_base);
19970: test_ret++;
19971: printf(" %d", n_cur);
19972: printf(" %d", n_mem);
19973: printf(" %d", n_size);
19974: printf("\n");
19975: }
19976: }
19977: }
19978: }
19979: function_tests++;
19980: #endif
19981:
19982: return(test_ret);
19983: }
19984:
19985:
19986: static int
19987: test_xmlDocDumpMemoryEnc(void) {
19988: int test_ret = 0;
19989:
19990: #if defined(LIBXML_OUTPUT_ENABLED)
19991: int mem_base;
19992: xmlDocPtr out_doc; /* Document to generate XML text from */
19993: int n_out_doc;
19994: xmlChar ** doc_txt_ptr; /* Memory pointer for allocated XML text */
19995: int n_doc_txt_ptr;
19996: int * doc_txt_len; /* Length of the generated XML text */
19997: int n_doc_txt_len;
19998: char * txt_encoding; /* Character encoding to use when generating XML text */
19999: int n_txt_encoding;
20000:
20001: for (n_out_doc = 0;n_out_doc < gen_nb_xmlDocPtr;n_out_doc++) {
20002: for (n_doc_txt_ptr = 0;n_doc_txt_ptr < gen_nb_xmlChar_ptr_ptr;n_doc_txt_ptr++) {
20003: for (n_doc_txt_len = 0;n_doc_txt_len < gen_nb_int_ptr;n_doc_txt_len++) {
20004: for (n_txt_encoding = 0;n_txt_encoding < gen_nb_const_char_ptr;n_txt_encoding++) {
20005: mem_base = xmlMemBlocks();
20006: out_doc = gen_xmlDocPtr(n_out_doc, 0);
20007: doc_txt_ptr = gen_xmlChar_ptr_ptr(n_doc_txt_ptr, 1);
20008: doc_txt_len = gen_int_ptr(n_doc_txt_len, 2);
20009: txt_encoding = gen_const_char_ptr(n_txt_encoding, 3);
20010:
20011: xmlDocDumpMemoryEnc(out_doc, doc_txt_ptr, doc_txt_len, (const char *)txt_encoding);
20012: call_tests++;
20013: des_xmlDocPtr(n_out_doc, out_doc, 0);
20014: des_xmlChar_ptr_ptr(n_doc_txt_ptr, doc_txt_ptr, 1);
20015: des_int_ptr(n_doc_txt_len, doc_txt_len, 2);
20016: des_const_char_ptr(n_txt_encoding, (const char *)txt_encoding, 3);
20017: xmlResetLastError();
20018: if (mem_base != xmlMemBlocks()) {
20019: printf("Leak of %d blocks found in xmlDocDumpMemoryEnc",
20020: xmlMemBlocks() - mem_base);
20021: test_ret++;
20022: printf(" %d", n_out_doc);
20023: printf(" %d", n_doc_txt_ptr);
20024: printf(" %d", n_doc_txt_len);
20025: printf(" %d", n_txt_encoding);
20026: printf("\n");
20027: }
20028: }
20029: }
20030: }
20031: }
20032: function_tests++;
20033: #endif
20034:
20035: return(test_ret);
20036: }
20037:
20038:
20039: static int
20040: test_xmlDocFormatDump(void) {
20041: int test_ret = 0;
20042:
20043: #if defined(LIBXML_OUTPUT_ENABLED)
20044: int mem_base;
20045: int ret_val;
20046: FILE * f; /* the FILE* */
20047: int n_f;
20048: xmlDocPtr cur; /* the document */
20049: int n_cur;
20050: int format; /* should formatting spaces been added */
20051: int n_format;
20052:
20053: for (n_f = 0;n_f < gen_nb_FILE_ptr;n_f++) {
20054: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
20055: for (n_format = 0;n_format < gen_nb_int;n_format++) {
20056: mem_base = xmlMemBlocks();
20057: f = gen_FILE_ptr(n_f, 0);
20058: cur = gen_xmlDocPtr(n_cur, 1);
20059: format = gen_int(n_format, 2);
20060:
20061: ret_val = xmlDocFormatDump(f, cur, format);
20062: desret_int(ret_val);
20063: call_tests++;
20064: des_FILE_ptr(n_f, f, 0);
20065: des_xmlDocPtr(n_cur, cur, 1);
20066: des_int(n_format, format, 2);
20067: xmlResetLastError();
20068: if (mem_base != xmlMemBlocks()) {
20069: printf("Leak of %d blocks found in xmlDocFormatDump",
20070: xmlMemBlocks() - mem_base);
20071: test_ret++;
20072: printf(" %d", n_f);
20073: printf(" %d", n_cur);
20074: printf(" %d", n_format);
20075: printf("\n");
20076: }
20077: }
20078: }
20079: }
20080: function_tests++;
20081: #endif
20082:
20083: return(test_ret);
20084: }
20085:
20086:
20087: static int
20088: test_xmlDocGetRootElement(void) {
20089: int test_ret = 0;
20090:
20091: int mem_base;
20092: xmlNodePtr ret_val;
20093: xmlDocPtr doc; /* the document */
20094: int n_doc;
20095:
20096: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
20097: mem_base = xmlMemBlocks();
20098: doc = gen_xmlDocPtr(n_doc, 0);
20099:
20100: ret_val = xmlDocGetRootElement(doc);
20101: desret_xmlNodePtr(ret_val);
20102: call_tests++;
20103: des_xmlDocPtr(n_doc, doc, 0);
20104: xmlResetLastError();
20105: if (mem_base != xmlMemBlocks()) {
20106: printf("Leak of %d blocks found in xmlDocGetRootElement",
20107: xmlMemBlocks() - mem_base);
20108: test_ret++;
20109: printf(" %d", n_doc);
20110: printf("\n");
20111: }
20112: }
20113: function_tests++;
20114:
20115: return(test_ret);
20116: }
20117:
20118:
20119: static int
20120: test_xmlDocSetRootElement(void) {
20121: int test_ret = 0;
20122:
20123: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
20124: int mem_base;
20125: xmlNodePtr ret_val;
20126: xmlDocPtr doc; /* the document */
20127: int n_doc;
20128: 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. */
20129: int n_root;
20130:
20131: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
20132: for (n_root = 0;n_root < gen_nb_xmlNodePtr_in;n_root++) {
20133: mem_base = xmlMemBlocks();
20134: doc = gen_xmlDocPtr(n_doc, 0);
20135: root = gen_xmlNodePtr_in(n_root, 1);
20136:
20137: ret_val = xmlDocSetRootElement(doc, root);
20138: if (doc == NULL) { xmlFreeNode(root) ; root = NULL ; }
20139: desret_xmlNodePtr(ret_val);
20140: call_tests++;
20141: des_xmlDocPtr(n_doc, doc, 0);
20142: des_xmlNodePtr_in(n_root, root, 1);
20143: xmlResetLastError();
20144: if (mem_base != xmlMemBlocks()) {
20145: printf("Leak of %d blocks found in xmlDocSetRootElement",
20146: xmlMemBlocks() - mem_base);
20147: test_ret++;
20148: printf(" %d", n_doc);
20149: printf(" %d", n_root);
20150: printf("\n");
20151: }
20152: }
20153: }
20154: function_tests++;
20155: #endif
20156:
20157: return(test_ret);
20158: }
20159:
20160:
20161: static int
20162: test_xmlElemDump(void) {
20163: int test_ret = 0;
20164:
20165: #if defined(LIBXML_OUTPUT_ENABLED)
20166: int mem_base;
20167: FILE * f; /* the FILE * for the output */
20168: int n_f;
20169: xmlDocPtr doc; /* the document */
20170: int n_doc;
20171: xmlNodePtr cur; /* the current node */
20172: int n_cur;
20173:
20174: for (n_f = 0;n_f < gen_nb_FILE_ptr;n_f++) {
20175: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
20176: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
20177: mem_base = xmlMemBlocks();
20178: f = gen_FILE_ptr(n_f, 0);
20179: doc = gen_xmlDocPtr(n_doc, 1);
20180: cur = gen_xmlNodePtr(n_cur, 2);
20181:
20182: xmlElemDump(f, doc, cur);
20183: call_tests++;
20184: des_FILE_ptr(n_f, f, 0);
20185: des_xmlDocPtr(n_doc, doc, 1);
20186: des_xmlNodePtr(n_cur, cur, 2);
20187: xmlResetLastError();
20188: if (mem_base != xmlMemBlocks()) {
20189: printf("Leak of %d blocks found in xmlElemDump",
20190: xmlMemBlocks() - mem_base);
20191: test_ret++;
20192: printf(" %d", n_f);
20193: printf(" %d", n_doc);
20194: printf(" %d", n_cur);
20195: printf("\n");
20196: }
20197: }
20198: }
20199: }
20200: function_tests++;
20201: #endif
20202:
20203: return(test_ret);
20204: }
20205:
20206:
20207: static int
20208: test_xmlFirstElementChild(void) {
20209: int test_ret = 0;
20210:
20211: #if defined(LIBXML_TREE_ENABLED)
20212: int mem_base;
20213: xmlNodePtr ret_val;
20214: xmlNodePtr parent; /* the parent node */
20215: int n_parent;
20216:
20217: for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
20218: mem_base = xmlMemBlocks();
20219: parent = gen_xmlNodePtr(n_parent, 0);
20220:
20221: ret_val = xmlFirstElementChild(parent);
20222: desret_xmlNodePtr(ret_val);
20223: call_tests++;
20224: des_xmlNodePtr(n_parent, parent, 0);
20225: xmlResetLastError();
20226: if (mem_base != xmlMemBlocks()) {
20227: printf("Leak of %d blocks found in xmlFirstElementChild",
20228: xmlMemBlocks() - mem_base);
20229: test_ret++;
20230: printf(" %d", n_parent);
20231: printf("\n");
20232: }
20233: }
20234: function_tests++;
20235: #endif
20236:
20237: return(test_ret);
20238: }
20239:
20240:
20241: static int
20242: test_xmlGetBufferAllocationScheme(void) {
20243: int test_ret = 0;
20244:
20245: int mem_base;
20246: xmlBufferAllocationScheme ret_val;
20247:
20248: mem_base = xmlMemBlocks();
20249:
20250: ret_val = xmlGetBufferAllocationScheme();
20251: desret_xmlBufferAllocationScheme(ret_val);
20252: call_tests++;
20253: xmlResetLastError();
20254: if (mem_base != xmlMemBlocks()) {
20255: printf("Leak of %d blocks found in xmlGetBufferAllocationScheme",
20256: xmlMemBlocks() - mem_base);
20257: test_ret++;
20258: printf("\n");
20259: }
20260: function_tests++;
20261:
20262: return(test_ret);
20263: }
20264:
20265:
20266: static int
20267: test_xmlGetCompressMode(void) {
20268: int test_ret = 0;
20269:
20270: int mem_base;
20271: int ret_val;
20272:
20273: mem_base = xmlMemBlocks();
20274:
20275: ret_val = xmlGetCompressMode();
20276: desret_int(ret_val);
20277: call_tests++;
20278: xmlResetLastError();
20279: if (mem_base != xmlMemBlocks()) {
20280: printf("Leak of %d blocks found in xmlGetCompressMode",
20281: xmlMemBlocks() - mem_base);
20282: test_ret++;
20283: printf("\n");
20284: }
20285: function_tests++;
20286:
20287: return(test_ret);
20288: }
20289:
20290:
20291: static int
20292: test_xmlGetDocCompressMode(void) {
20293: int test_ret = 0;
20294:
20295: int mem_base;
20296: int ret_val;
20297: xmlDocPtr doc; /* the document */
20298: int n_doc;
20299:
20300: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
20301: mem_base = xmlMemBlocks();
20302: doc = gen_xmlDocPtr(n_doc, 0);
20303:
20304: ret_val = xmlGetDocCompressMode(doc);
20305: desret_int(ret_val);
20306: call_tests++;
20307: des_xmlDocPtr(n_doc, doc, 0);
20308: xmlResetLastError();
20309: if (mem_base != xmlMemBlocks()) {
20310: printf("Leak of %d blocks found in xmlGetDocCompressMode",
20311: xmlMemBlocks() - mem_base);
20312: test_ret++;
20313: printf(" %d", n_doc);
20314: printf("\n");
20315: }
20316: }
20317: function_tests++;
20318:
20319: return(test_ret);
20320: }
20321:
20322:
20323: static int
20324: test_xmlGetIntSubset(void) {
20325: int test_ret = 0;
20326:
20327: int mem_base;
20328: xmlDtdPtr ret_val;
20329: xmlDocPtr doc; /* the document pointer */
20330: int n_doc;
20331:
20332: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
20333: mem_base = xmlMemBlocks();
20334: doc = gen_xmlDocPtr(n_doc, 0);
20335:
20336: ret_val = xmlGetIntSubset(doc);
20337: desret_xmlDtdPtr(ret_val);
20338: call_tests++;
20339: des_xmlDocPtr(n_doc, doc, 0);
20340: xmlResetLastError();
20341: if (mem_base != xmlMemBlocks()) {
20342: printf("Leak of %d blocks found in xmlGetIntSubset",
20343: xmlMemBlocks() - mem_base);
20344: test_ret++;
20345: printf(" %d", n_doc);
20346: printf("\n");
20347: }
20348: }
20349: function_tests++;
20350:
20351: return(test_ret);
20352: }
20353:
20354:
20355: static int
20356: test_xmlGetLastChild(void) {
20357: int test_ret = 0;
20358:
20359: int mem_base;
20360: xmlNodePtr ret_val;
20361: xmlNodePtr parent; /* the parent node */
20362: int n_parent;
20363:
20364: for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
20365: mem_base = xmlMemBlocks();
20366: parent = gen_xmlNodePtr(n_parent, 0);
20367:
20368: ret_val = xmlGetLastChild(parent);
20369: desret_xmlNodePtr(ret_val);
20370: call_tests++;
20371: des_xmlNodePtr(n_parent, parent, 0);
20372: xmlResetLastError();
20373: if (mem_base != xmlMemBlocks()) {
20374: printf("Leak of %d blocks found in xmlGetLastChild",
20375: xmlMemBlocks() - mem_base);
20376: test_ret++;
20377: printf(" %d", n_parent);
20378: printf("\n");
20379: }
20380: }
20381: function_tests++;
20382:
20383: return(test_ret);
20384: }
20385:
20386:
20387: static int
20388: test_xmlGetLineNo(void) {
20389: int test_ret = 0;
20390:
20391: int mem_base;
20392: long ret_val;
20393: xmlNodePtr node; /* valid node */
20394: int n_node;
20395:
20396: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
20397: mem_base = xmlMemBlocks();
20398: node = gen_xmlNodePtr(n_node, 0);
20399:
20400: ret_val = xmlGetLineNo(node);
20401: desret_long(ret_val);
20402: call_tests++;
20403: des_xmlNodePtr(n_node, node, 0);
20404: xmlResetLastError();
20405: if (mem_base != xmlMemBlocks()) {
20406: printf("Leak of %d blocks found in xmlGetLineNo",
20407: xmlMemBlocks() - mem_base);
20408: test_ret++;
20409: printf(" %d", n_node);
20410: printf("\n");
20411: }
20412: }
20413: function_tests++;
20414:
20415: return(test_ret);
20416: }
20417:
20418:
20419: static int
20420: test_xmlGetNoNsProp(void) {
20421: int test_ret = 0;
20422:
20423: int mem_base;
20424: xmlChar * ret_val;
20425: xmlNodePtr node; /* the node */
20426: int n_node;
20427: xmlChar * name; /* the attribute name */
20428: int n_name;
20429:
20430: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
20431: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
20432: mem_base = xmlMemBlocks();
20433: node = gen_xmlNodePtr(n_node, 0);
20434: name = gen_const_xmlChar_ptr(n_name, 1);
20435:
20436: ret_val = xmlGetNoNsProp(node, (const xmlChar *)name);
20437: desret_xmlChar_ptr(ret_val);
20438: call_tests++;
20439: des_xmlNodePtr(n_node, node, 0);
20440: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
20441: xmlResetLastError();
20442: if (mem_base != xmlMemBlocks()) {
20443: printf("Leak of %d blocks found in xmlGetNoNsProp",
20444: xmlMemBlocks() - mem_base);
20445: test_ret++;
20446: printf(" %d", n_node);
20447: printf(" %d", n_name);
20448: printf("\n");
20449: }
20450: }
20451: }
20452: function_tests++;
20453:
20454: return(test_ret);
20455: }
20456:
20457:
20458: static int
20459: test_xmlGetNodePath(void) {
20460: int test_ret = 0;
20461:
20462: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED)
20463: int mem_base;
20464: xmlChar * ret_val;
20465: xmlNodePtr node; /* a node */
20466: int n_node;
20467:
20468: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
20469: mem_base = xmlMemBlocks();
20470: node = gen_xmlNodePtr(n_node, 0);
20471:
20472: ret_val = xmlGetNodePath(node);
20473: desret_xmlChar_ptr(ret_val);
20474: call_tests++;
20475: des_xmlNodePtr(n_node, node, 0);
20476: xmlResetLastError();
20477: if (mem_base != xmlMemBlocks()) {
20478: printf("Leak of %d blocks found in xmlGetNodePath",
20479: xmlMemBlocks() - mem_base);
20480: test_ret++;
20481: printf(" %d", n_node);
20482: printf("\n");
20483: }
20484: }
20485: function_tests++;
20486: #endif
20487:
20488: return(test_ret);
20489: }
20490:
20491:
20492: static int
20493: test_xmlGetNsList(void) {
20494: int test_ret = 0;
20495:
20496:
20497: /* missing type support */
20498: return(test_ret);
20499: }
20500:
20501:
20502: static int
20503: test_xmlGetNsProp(void) {
20504: int test_ret = 0;
20505:
20506: int mem_base;
20507: xmlChar * ret_val;
20508: xmlNodePtr node; /* the node */
20509: int n_node;
20510: xmlChar * name; /* the attribute name */
20511: int n_name;
20512: xmlChar * nameSpace; /* the URI of the namespace */
20513: int n_nameSpace;
20514:
20515: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
20516: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
20517: for (n_nameSpace = 0;n_nameSpace < gen_nb_const_xmlChar_ptr;n_nameSpace++) {
20518: mem_base = xmlMemBlocks();
20519: node = gen_xmlNodePtr(n_node, 0);
20520: name = gen_const_xmlChar_ptr(n_name, 1);
20521: nameSpace = gen_const_xmlChar_ptr(n_nameSpace, 2);
20522:
20523: ret_val = xmlGetNsProp(node, (const xmlChar *)name, (const xmlChar *)nameSpace);
20524: desret_xmlChar_ptr(ret_val);
20525: call_tests++;
20526: des_xmlNodePtr(n_node, node, 0);
20527: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
20528: des_const_xmlChar_ptr(n_nameSpace, (const xmlChar *)nameSpace, 2);
20529: xmlResetLastError();
20530: if (mem_base != xmlMemBlocks()) {
20531: printf("Leak of %d blocks found in xmlGetNsProp",
20532: xmlMemBlocks() - mem_base);
20533: test_ret++;
20534: printf(" %d", n_node);
20535: printf(" %d", n_name);
20536: printf(" %d", n_nameSpace);
20537: printf("\n");
20538: }
20539: }
20540: }
20541: }
20542: function_tests++;
20543:
20544: return(test_ret);
20545: }
20546:
20547:
20548: static int
20549: test_xmlGetProp(void) {
20550: int test_ret = 0;
20551:
20552: int mem_base;
20553: xmlChar * ret_val;
20554: xmlNodePtr node; /* the node */
20555: int n_node;
20556: xmlChar * name; /* the attribute name */
20557: int n_name;
20558:
20559: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
20560: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
20561: mem_base = xmlMemBlocks();
20562: node = gen_xmlNodePtr(n_node, 0);
20563: name = gen_const_xmlChar_ptr(n_name, 1);
20564:
20565: ret_val = xmlGetProp(node, (const xmlChar *)name);
20566: desret_xmlChar_ptr(ret_val);
20567: call_tests++;
20568: des_xmlNodePtr(n_node, node, 0);
20569: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
20570: xmlResetLastError();
20571: if (mem_base != xmlMemBlocks()) {
20572: printf("Leak of %d blocks found in xmlGetProp",
20573: xmlMemBlocks() - mem_base);
20574: test_ret++;
20575: printf(" %d", n_node);
20576: printf(" %d", n_name);
20577: printf("\n");
20578: }
20579: }
20580: }
20581: function_tests++;
20582:
20583: return(test_ret);
20584: }
20585:
20586:
20587: static int
20588: test_xmlHasNsProp(void) {
20589: int test_ret = 0;
20590:
20591: int mem_base;
20592: xmlAttrPtr ret_val;
20593: xmlNodePtr node; /* the node */
20594: int n_node;
20595: xmlChar * name; /* the attribute name */
20596: int n_name;
20597: xmlChar * nameSpace; /* the URI of the namespace */
20598: int n_nameSpace;
20599:
20600: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
20601: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
20602: for (n_nameSpace = 0;n_nameSpace < gen_nb_const_xmlChar_ptr;n_nameSpace++) {
20603: mem_base = xmlMemBlocks();
20604: node = gen_xmlNodePtr(n_node, 0);
20605: name = gen_const_xmlChar_ptr(n_name, 1);
20606: nameSpace = gen_const_xmlChar_ptr(n_nameSpace, 2);
20607:
20608: ret_val = xmlHasNsProp(node, (const xmlChar *)name, (const xmlChar *)nameSpace);
20609: desret_xmlAttrPtr(ret_val);
20610: call_tests++;
20611: des_xmlNodePtr(n_node, node, 0);
20612: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
20613: des_const_xmlChar_ptr(n_nameSpace, (const xmlChar *)nameSpace, 2);
20614: xmlResetLastError();
20615: if (mem_base != xmlMemBlocks()) {
20616: printf("Leak of %d blocks found in xmlHasNsProp",
20617: xmlMemBlocks() - mem_base);
20618: test_ret++;
20619: printf(" %d", n_node);
20620: printf(" %d", n_name);
20621: printf(" %d", n_nameSpace);
20622: printf("\n");
20623: }
20624: }
20625: }
20626: }
20627: function_tests++;
20628:
20629: return(test_ret);
20630: }
20631:
20632:
20633: static int
20634: test_xmlHasProp(void) {
20635: int test_ret = 0;
20636:
20637: int mem_base;
20638: xmlAttrPtr ret_val;
20639: xmlNodePtr node; /* the node */
20640: int n_node;
20641: xmlChar * name; /* the attribute name */
20642: int n_name;
20643:
20644: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
20645: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
20646: mem_base = xmlMemBlocks();
20647: node = gen_xmlNodePtr(n_node, 0);
20648: name = gen_const_xmlChar_ptr(n_name, 1);
20649:
20650: ret_val = xmlHasProp(node, (const xmlChar *)name);
20651: desret_xmlAttrPtr(ret_val);
20652: call_tests++;
20653: des_xmlNodePtr(n_node, node, 0);
20654: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
20655: xmlResetLastError();
20656: if (mem_base != xmlMemBlocks()) {
20657: printf("Leak of %d blocks found in xmlHasProp",
20658: xmlMemBlocks() - mem_base);
20659: test_ret++;
20660: printf(" %d", n_node);
20661: printf(" %d", n_name);
20662: printf("\n");
20663: }
20664: }
20665: }
20666: function_tests++;
20667:
20668: return(test_ret);
20669: }
20670:
20671:
20672: static int
20673: test_xmlIsBlankNode(void) {
20674: int test_ret = 0;
20675:
20676: int mem_base;
20677: int ret_val;
20678: xmlNodePtr node; /* the node */
20679: int n_node;
20680:
20681: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
20682: mem_base = xmlMemBlocks();
20683: node = gen_xmlNodePtr(n_node, 0);
20684:
20685: ret_val = xmlIsBlankNode(node);
20686: desret_int(ret_val);
20687: call_tests++;
20688: des_xmlNodePtr(n_node, node, 0);
20689: xmlResetLastError();
20690: if (mem_base != xmlMemBlocks()) {
20691: printf("Leak of %d blocks found in xmlIsBlankNode",
20692: xmlMemBlocks() - mem_base);
20693: test_ret++;
20694: printf(" %d", n_node);
20695: printf("\n");
20696: }
20697: }
20698: function_tests++;
20699:
20700: return(test_ret);
20701: }
20702:
20703:
20704: static int
20705: test_xmlIsXHTML(void) {
20706: int test_ret = 0;
20707:
20708: int mem_base;
20709: int ret_val;
20710: xmlChar * systemID; /* the system identifier */
20711: int n_systemID;
20712: xmlChar * publicID; /* the public identifier */
20713: int n_publicID;
20714:
20715: for (n_systemID = 0;n_systemID < gen_nb_const_xmlChar_ptr;n_systemID++) {
20716: for (n_publicID = 0;n_publicID < gen_nb_const_xmlChar_ptr;n_publicID++) {
20717: mem_base = xmlMemBlocks();
20718: systemID = gen_const_xmlChar_ptr(n_systemID, 0);
20719: publicID = gen_const_xmlChar_ptr(n_publicID, 1);
20720:
20721: ret_val = xmlIsXHTML((const xmlChar *)systemID, (const xmlChar *)publicID);
20722: desret_int(ret_val);
20723: call_tests++;
20724: des_const_xmlChar_ptr(n_systemID, (const xmlChar *)systemID, 0);
20725: des_const_xmlChar_ptr(n_publicID, (const xmlChar *)publicID, 1);
20726: xmlResetLastError();
20727: if (mem_base != xmlMemBlocks()) {
20728: printf("Leak of %d blocks found in xmlIsXHTML",
20729: xmlMemBlocks() - mem_base);
20730: test_ret++;
20731: printf(" %d", n_systemID);
20732: printf(" %d", n_publicID);
20733: printf("\n");
20734: }
20735: }
20736: }
20737: function_tests++;
20738:
20739: return(test_ret);
20740: }
20741:
20742:
20743: static int
20744: test_xmlLastElementChild(void) {
20745: int test_ret = 0;
20746:
20747: #if defined(LIBXML_TREE_ENABLED)
20748: int mem_base;
20749: xmlNodePtr ret_val;
20750: xmlNodePtr parent; /* the parent node */
20751: int n_parent;
20752:
20753: for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
20754: mem_base = xmlMemBlocks();
20755: parent = gen_xmlNodePtr(n_parent, 0);
20756:
20757: ret_val = xmlLastElementChild(parent);
20758: desret_xmlNodePtr(ret_val);
20759: call_tests++;
20760: des_xmlNodePtr(n_parent, parent, 0);
20761: xmlResetLastError();
20762: if (mem_base != xmlMemBlocks()) {
20763: printf("Leak of %d blocks found in xmlLastElementChild",
20764: xmlMemBlocks() - mem_base);
20765: test_ret++;
20766: printf(" %d", n_parent);
20767: printf("\n");
20768: }
20769: }
20770: function_tests++;
20771: #endif
20772:
20773: return(test_ret);
20774: }
20775:
20776:
20777: static int
20778: test_xmlNewCDataBlock(void) {
20779: int test_ret = 0;
20780:
20781: int mem_base;
20782: xmlNodePtr ret_val;
20783: xmlDocPtr doc; /* the document */
20784: int n_doc;
20785: xmlChar * content; /* the CDATA block content content */
20786: int n_content;
20787: int len; /* the length of the block */
20788: int n_len;
20789:
20790: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
20791: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
20792: for (n_len = 0;n_len < gen_nb_int;n_len++) {
20793: mem_base = xmlMemBlocks();
20794: doc = gen_xmlDocPtr(n_doc, 0);
20795: content = gen_const_xmlChar_ptr(n_content, 1);
20796: len = gen_int(n_len, 2);
20797:
20798: ret_val = xmlNewCDataBlock(doc, (const xmlChar *)content, len);
20799: desret_xmlNodePtr(ret_val);
20800: call_tests++;
20801: des_xmlDocPtr(n_doc, doc, 0);
20802: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
20803: des_int(n_len, len, 2);
20804: xmlResetLastError();
20805: if (mem_base != xmlMemBlocks()) {
20806: printf("Leak of %d blocks found in xmlNewCDataBlock",
20807: xmlMemBlocks() - mem_base);
20808: test_ret++;
20809: printf(" %d", n_doc);
20810: printf(" %d", n_content);
20811: printf(" %d", n_len);
20812: printf("\n");
20813: }
20814: }
20815: }
20816: }
20817: function_tests++;
20818:
20819: return(test_ret);
20820: }
20821:
20822:
20823: static int
20824: test_xmlNewCharRef(void) {
20825: int test_ret = 0;
20826:
20827: int mem_base;
20828: xmlNodePtr ret_val;
20829: xmlDocPtr doc; /* the document */
20830: int n_doc;
20831: xmlChar * name; /* the char ref string, starting with # or "&# ... ;" */
20832: int n_name;
20833:
20834: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
20835: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
20836: mem_base = xmlMemBlocks();
20837: doc = gen_xmlDocPtr(n_doc, 0);
20838: name = gen_const_xmlChar_ptr(n_name, 1);
20839:
20840: ret_val = xmlNewCharRef(doc, (const xmlChar *)name);
20841: desret_xmlNodePtr(ret_val);
20842: call_tests++;
20843: des_xmlDocPtr(n_doc, doc, 0);
20844: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
20845: xmlResetLastError();
20846: if (mem_base != xmlMemBlocks()) {
20847: printf("Leak of %d blocks found in xmlNewCharRef",
20848: xmlMemBlocks() - mem_base);
20849: test_ret++;
20850: printf(" %d", n_doc);
20851: printf(" %d", n_name);
20852: printf("\n");
20853: }
20854: }
20855: }
20856: function_tests++;
20857:
20858: return(test_ret);
20859: }
20860:
20861:
20862: static int
20863: test_xmlNewChild(void) {
20864: int test_ret = 0;
20865:
20866: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
20867: #ifdef LIBXML_TREE_ENABLED
20868: int mem_base;
20869: xmlNodePtr ret_val;
20870: xmlNodePtr parent; /* the parent node */
20871: int n_parent;
20872: xmlNsPtr ns; /* a namespace if any */
20873: int n_ns;
20874: xmlChar * name; /* the name of the child */
20875: int n_name;
20876: xmlChar * content; /* the XML content of the child if any. */
20877: int n_content;
20878:
20879: for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
20880: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
20881: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
20882: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
20883: mem_base = xmlMemBlocks();
20884: parent = gen_xmlNodePtr(n_parent, 0);
20885: ns = gen_xmlNsPtr(n_ns, 1);
20886: name = gen_const_xmlChar_ptr(n_name, 2);
20887: content = gen_const_xmlChar_ptr(n_content, 3);
20888:
20889: ret_val = xmlNewChild(parent, ns, (const xmlChar *)name, (const xmlChar *)content);
20890: desret_xmlNodePtr(ret_val);
20891: call_tests++;
20892: des_xmlNodePtr(n_parent, parent, 0);
20893: des_xmlNsPtr(n_ns, ns, 1);
20894: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
20895: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3);
20896: xmlResetLastError();
20897: if (mem_base != xmlMemBlocks()) {
20898: printf("Leak of %d blocks found in xmlNewChild",
20899: xmlMemBlocks() - mem_base);
20900: test_ret++;
20901: printf(" %d", n_parent);
20902: printf(" %d", n_ns);
20903: printf(" %d", n_name);
20904: printf(" %d", n_content);
20905: printf("\n");
20906: }
20907: }
20908: }
20909: }
20910: }
20911: function_tests++;
20912: #endif
20913: #endif
20914:
20915: return(test_ret);
20916: }
20917:
20918:
20919: static int
20920: test_xmlNewComment(void) {
20921: int test_ret = 0;
20922:
20923: int mem_base;
20924: xmlNodePtr ret_val;
20925: xmlChar * content; /* the comment content */
20926: int n_content;
20927:
20928: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
20929: mem_base = xmlMemBlocks();
20930: content = gen_const_xmlChar_ptr(n_content, 0);
20931:
20932: ret_val = xmlNewComment((const xmlChar *)content);
20933: desret_xmlNodePtr(ret_val);
20934: call_tests++;
20935: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 0);
20936: xmlResetLastError();
20937: if (mem_base != xmlMemBlocks()) {
20938: printf("Leak of %d blocks found in xmlNewComment",
20939: xmlMemBlocks() - mem_base);
20940: test_ret++;
20941: printf(" %d", n_content);
20942: printf("\n");
20943: }
20944: }
20945: function_tests++;
20946:
20947: return(test_ret);
20948: }
20949:
20950:
20951: static int
20952: test_xmlNewDoc(void) {
20953: int test_ret = 0;
20954:
20955: int mem_base;
20956: xmlDocPtr ret_val;
20957: xmlChar * version; /* xmlChar string giving the version of XML "1.0" */
20958: int n_version;
20959:
20960: for (n_version = 0;n_version < gen_nb_const_xmlChar_ptr;n_version++) {
20961: mem_base = xmlMemBlocks();
20962: version = gen_const_xmlChar_ptr(n_version, 0);
20963:
20964: ret_val = xmlNewDoc((const xmlChar *)version);
20965: desret_xmlDocPtr(ret_val);
20966: call_tests++;
20967: des_const_xmlChar_ptr(n_version, (const xmlChar *)version, 0);
20968: xmlResetLastError();
20969: if (mem_base != xmlMemBlocks()) {
20970: printf("Leak of %d blocks found in xmlNewDoc",
20971: xmlMemBlocks() - mem_base);
20972: test_ret++;
20973: printf(" %d", n_version);
20974: printf("\n");
20975: }
20976: }
20977: function_tests++;
20978:
20979: return(test_ret);
20980: }
20981:
20982:
20983: static int
20984: test_xmlNewDocComment(void) {
20985: int test_ret = 0;
20986:
20987: int mem_base;
20988: xmlNodePtr ret_val;
20989: xmlDocPtr doc; /* the document */
20990: int n_doc;
20991: xmlChar * content; /* the comment content */
20992: int n_content;
20993:
20994: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
20995: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
20996: mem_base = xmlMemBlocks();
20997: doc = gen_xmlDocPtr(n_doc, 0);
20998: content = gen_const_xmlChar_ptr(n_content, 1);
20999:
21000: ret_val = xmlNewDocComment(doc, (const xmlChar *)content);
21001: desret_xmlNodePtr(ret_val);
21002: call_tests++;
21003: des_xmlDocPtr(n_doc, doc, 0);
21004: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
21005: xmlResetLastError();
21006: if (mem_base != xmlMemBlocks()) {
21007: printf("Leak of %d blocks found in xmlNewDocComment",
21008: xmlMemBlocks() - mem_base);
21009: test_ret++;
21010: printf(" %d", n_doc);
21011: printf(" %d", n_content);
21012: printf("\n");
21013: }
21014: }
21015: }
21016: function_tests++;
21017:
21018: return(test_ret);
21019: }
21020:
21021:
21022: static int
21023: test_xmlNewDocFragment(void) {
21024: int test_ret = 0;
21025:
21026: #if defined(LIBXML_TREE_ENABLED)
21027: int mem_base;
21028: xmlNodePtr ret_val;
21029: xmlDocPtr doc; /* the document owning the fragment */
21030: int n_doc;
21031:
21032: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21033: mem_base = xmlMemBlocks();
21034: doc = gen_xmlDocPtr(n_doc, 0);
21035:
21036: ret_val = xmlNewDocFragment(doc);
21037: desret_xmlNodePtr(ret_val);
21038: call_tests++;
21039: des_xmlDocPtr(n_doc, doc, 0);
21040: xmlResetLastError();
21041: if (mem_base != xmlMemBlocks()) {
21042: printf("Leak of %d blocks found in xmlNewDocFragment",
21043: xmlMemBlocks() - mem_base);
21044: test_ret++;
21045: printf(" %d", n_doc);
21046: printf("\n");
21047: }
21048: }
21049: function_tests++;
21050: #endif
21051:
21052: return(test_ret);
21053: }
21054:
21055:
21056: static int
21057: test_xmlNewDocNode(void) {
21058: int test_ret = 0;
21059:
21060: int mem_base;
21061: xmlNodePtr ret_val;
21062: xmlDocPtr doc; /* the document */
21063: int n_doc;
21064: xmlNsPtr ns; /* namespace if any */
21065: int n_ns;
21066: xmlChar * name; /* the node name */
21067: int n_name;
21068: xmlChar * content; /* the XML text content if any */
21069: int n_content;
21070:
21071: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21072: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
21073: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21074: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21075: mem_base = xmlMemBlocks();
21076: doc = gen_xmlDocPtr(n_doc, 0);
21077: ns = gen_xmlNsPtr(n_ns, 1);
21078: name = gen_const_xmlChar_ptr(n_name, 2);
21079: content = gen_const_xmlChar_ptr(n_content, 3);
21080:
21081: ret_val = xmlNewDocNode(doc, ns, (const xmlChar *)name, (const xmlChar *)content);
21082: desret_xmlNodePtr(ret_val);
21083: call_tests++;
21084: des_xmlDocPtr(n_doc, doc, 0);
21085: des_xmlNsPtr(n_ns, ns, 1);
21086: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
21087: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3);
21088: xmlResetLastError();
21089: if (mem_base != xmlMemBlocks()) {
21090: printf("Leak of %d blocks found in xmlNewDocNode",
21091: xmlMemBlocks() - mem_base);
21092: test_ret++;
21093: printf(" %d", n_doc);
21094: printf(" %d", n_ns);
21095: printf(" %d", n_name);
21096: printf(" %d", n_content);
21097: printf("\n");
21098: }
21099: }
21100: }
21101: }
21102: }
21103: function_tests++;
21104:
21105: return(test_ret);
21106: }
21107:
21108:
21109: static int
21110: test_xmlNewDocNodeEatName(void) {
21111: int test_ret = 0;
21112:
21113: int mem_base;
21114: xmlNodePtr ret_val;
21115: xmlDocPtr doc; /* the document */
21116: int n_doc;
21117: xmlNsPtr ns; /* namespace if any */
21118: int n_ns;
21119: xmlChar * name; /* the node name */
21120: int n_name;
21121: xmlChar * content; /* the XML text content if any */
21122: int n_content;
21123:
21124: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21125: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
21126: for (n_name = 0;n_name < gen_nb_eaten_name;n_name++) {
21127: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21128: mem_base = xmlMemBlocks();
21129: doc = gen_xmlDocPtr(n_doc, 0);
21130: ns = gen_xmlNsPtr(n_ns, 1);
21131: name = gen_eaten_name(n_name, 2);
21132: content = gen_const_xmlChar_ptr(n_content, 3);
21133:
21134: ret_val = xmlNewDocNodeEatName(doc, ns, name, (const xmlChar *)content);
21135: desret_xmlNodePtr(ret_val);
21136: call_tests++;
21137: des_xmlDocPtr(n_doc, doc, 0);
21138: des_xmlNsPtr(n_ns, ns, 1);
21139: des_eaten_name(n_name, name, 2);
21140: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3);
21141: xmlResetLastError();
21142: if (mem_base != xmlMemBlocks()) {
21143: printf("Leak of %d blocks found in xmlNewDocNodeEatName",
21144: xmlMemBlocks() - mem_base);
21145: test_ret++;
21146: printf(" %d", n_doc);
21147: printf(" %d", n_ns);
21148: printf(" %d", n_name);
21149: printf(" %d", n_content);
21150: printf("\n");
21151: }
21152: }
21153: }
21154: }
21155: }
21156: function_tests++;
21157:
21158: return(test_ret);
21159: }
21160:
21161:
21162: static int
21163: test_xmlNewDocPI(void) {
21164: int test_ret = 0;
21165:
21166: int mem_base;
21167: xmlNodePtr ret_val;
21168: xmlDocPtr doc; /* the target document */
21169: int n_doc;
21170: xmlChar * name; /* the processing instruction name */
21171: int n_name;
21172: xmlChar * content; /* the PI content */
21173: int n_content;
21174:
21175: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21176: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21177: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21178: mem_base = xmlMemBlocks();
21179: doc = gen_xmlDocPtr(n_doc, 0);
21180: name = gen_const_xmlChar_ptr(n_name, 1);
21181: content = gen_const_xmlChar_ptr(n_content, 2);
21182:
21183: ret_val = xmlNewDocPI(doc, (const xmlChar *)name, (const xmlChar *)content);
21184: desret_xmlNodePtr(ret_val);
21185: call_tests++;
21186: des_xmlDocPtr(n_doc, doc, 0);
21187: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
21188: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2);
21189: xmlResetLastError();
21190: if (mem_base != xmlMemBlocks()) {
21191: printf("Leak of %d blocks found in xmlNewDocPI",
21192: xmlMemBlocks() - mem_base);
21193: test_ret++;
21194: printf(" %d", n_doc);
21195: printf(" %d", n_name);
21196: printf(" %d", n_content);
21197: printf("\n");
21198: }
21199: }
21200: }
21201: }
21202: function_tests++;
21203:
21204: return(test_ret);
21205: }
21206:
21207:
21208: static int
21209: test_xmlNewDocProp(void) {
21210: int test_ret = 0;
21211:
21212: int mem_base;
21213: xmlAttrPtr ret_val;
21214: xmlDocPtr doc; /* the document */
21215: int n_doc;
21216: xmlChar * name; /* the name of the attribute */
21217: int n_name;
21218: xmlChar * value; /* the value of the attribute */
21219: int n_value;
21220:
21221: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21222: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21223: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
21224: mem_base = xmlMemBlocks();
21225: doc = gen_xmlDocPtr(n_doc, 0);
21226: name = gen_const_xmlChar_ptr(n_name, 1);
21227: value = gen_const_xmlChar_ptr(n_value, 2);
21228:
21229: ret_val = xmlNewDocProp(doc, (const xmlChar *)name, (const xmlChar *)value);
21230: desret_xmlAttrPtr(ret_val);
21231: call_tests++;
21232: des_xmlDocPtr(n_doc, doc, 0);
21233: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
21234: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2);
21235: xmlResetLastError();
21236: if (mem_base != xmlMemBlocks()) {
21237: printf("Leak of %d blocks found in xmlNewDocProp",
21238: xmlMemBlocks() - mem_base);
21239: test_ret++;
21240: printf(" %d", n_doc);
21241: printf(" %d", n_name);
21242: printf(" %d", n_value);
21243: printf("\n");
21244: }
21245: }
21246: }
21247: }
21248: function_tests++;
21249:
21250: return(test_ret);
21251: }
21252:
21253:
21254: static int
21255: test_xmlNewDocRawNode(void) {
21256: int test_ret = 0;
21257:
21258: #if defined(LIBXML_TREE_ENABLED)
21259: #ifdef LIBXML_TREE_ENABLED
21260: int mem_base;
21261: xmlNodePtr ret_val;
21262: xmlDocPtr doc; /* the document */
21263: int n_doc;
21264: xmlNsPtr ns; /* namespace if any */
21265: int n_ns;
21266: xmlChar * name; /* the node name */
21267: int n_name;
21268: xmlChar * content; /* the text content if any */
21269: int n_content;
21270:
21271: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21272: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
21273: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21274: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21275: mem_base = xmlMemBlocks();
21276: doc = gen_xmlDocPtr(n_doc, 0);
21277: ns = gen_xmlNsPtr(n_ns, 1);
21278: name = gen_const_xmlChar_ptr(n_name, 2);
21279: content = gen_const_xmlChar_ptr(n_content, 3);
21280:
21281: ret_val = xmlNewDocRawNode(doc, ns, (const xmlChar *)name, (const xmlChar *)content);
21282: desret_xmlNodePtr(ret_val);
21283: call_tests++;
21284: des_xmlDocPtr(n_doc, doc, 0);
21285: des_xmlNsPtr(n_ns, ns, 1);
21286: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
21287: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3);
21288: xmlResetLastError();
21289: if (mem_base != xmlMemBlocks()) {
21290: printf("Leak of %d blocks found in xmlNewDocRawNode",
21291: xmlMemBlocks() - mem_base);
21292: test_ret++;
21293: printf(" %d", n_doc);
21294: printf(" %d", n_ns);
21295: printf(" %d", n_name);
21296: printf(" %d", n_content);
21297: printf("\n");
21298: }
21299: }
21300: }
21301: }
21302: }
21303: function_tests++;
21304: #endif
21305: #endif
21306:
21307: return(test_ret);
21308: }
21309:
21310:
21311: static int
21312: test_xmlNewDocText(void) {
21313: int test_ret = 0;
21314:
21315: int mem_base;
21316: xmlNodePtr ret_val;
21317: xmlDocPtr doc; /* the document */
21318: int n_doc;
21319: xmlChar * content; /* the text content */
21320: int n_content;
21321:
21322: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21323: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21324: mem_base = xmlMemBlocks();
21325: doc = gen_xmlDocPtr(n_doc, 0);
21326: content = gen_const_xmlChar_ptr(n_content, 1);
21327:
21328: ret_val = xmlNewDocText(doc, (const xmlChar *)content);
21329: desret_xmlNodePtr(ret_val);
21330: call_tests++;
21331: des_xmlDocPtr(n_doc, doc, 0);
21332: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
21333: xmlResetLastError();
21334: if (mem_base != xmlMemBlocks()) {
21335: printf("Leak of %d blocks found in xmlNewDocText",
21336: xmlMemBlocks() - mem_base);
21337: test_ret++;
21338: printf(" %d", n_doc);
21339: printf(" %d", n_content);
21340: printf("\n");
21341: }
21342: }
21343: }
21344: function_tests++;
21345:
21346: return(test_ret);
21347: }
21348:
21349:
21350: static int
21351: test_xmlNewDocTextLen(void) {
21352: int test_ret = 0;
21353:
21354: int mem_base;
21355: xmlNodePtr ret_val;
21356: xmlDocPtr doc; /* the document */
21357: int n_doc;
21358: xmlChar * content; /* the text content */
21359: int n_content;
21360: int len; /* the text len. */
21361: int n_len;
21362:
21363: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21364: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21365: for (n_len = 0;n_len < gen_nb_int;n_len++) {
21366: mem_base = xmlMemBlocks();
21367: doc = gen_xmlDocPtr(n_doc, 0);
21368: content = gen_const_xmlChar_ptr(n_content, 1);
21369: len = gen_int(n_len, 2);
21370:
21371: ret_val = xmlNewDocTextLen(doc, (const xmlChar *)content, len);
21372: desret_xmlNodePtr(ret_val);
21373: call_tests++;
21374: des_xmlDocPtr(n_doc, doc, 0);
21375: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
21376: des_int(n_len, len, 2);
21377: xmlResetLastError();
21378: if (mem_base != xmlMemBlocks()) {
21379: printf("Leak of %d blocks found in xmlNewDocTextLen",
21380: xmlMemBlocks() - mem_base);
21381: test_ret++;
21382: printf(" %d", n_doc);
21383: printf(" %d", n_content);
21384: printf(" %d", n_len);
21385: printf("\n");
21386: }
21387: }
21388: }
21389: }
21390: function_tests++;
21391:
21392: return(test_ret);
21393: }
21394:
21395:
21396: static int
21397: test_xmlNewDtd(void) {
21398: int test_ret = 0;
21399:
21400: int mem_base;
21401: xmlDtdPtr ret_val;
21402: xmlDocPtr doc; /* the document pointer */
21403: int n_doc;
21404: xmlChar * name; /* the DTD name */
21405: int n_name;
21406: xmlChar * ExternalID; /* the external ID */
21407: int n_ExternalID;
21408: xmlChar * SystemID; /* the system ID */
21409: int n_SystemID;
21410:
21411: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21412: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21413: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
21414: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
21415: mem_base = xmlMemBlocks();
21416: doc = gen_xmlDocPtr(n_doc, 0);
21417: name = gen_const_xmlChar_ptr(n_name, 1);
21418: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 2);
21419: SystemID = gen_const_xmlChar_ptr(n_SystemID, 3);
21420:
21421: ret_val = xmlNewDtd(doc, (const xmlChar *)name, (const xmlChar *)ExternalID, (const xmlChar *)SystemID);
21422: desret_xmlDtdPtr(ret_val);
21423: call_tests++;
21424: des_xmlDocPtr(n_doc, doc, 0);
21425: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
21426: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 2);
21427: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 3);
21428: xmlResetLastError();
21429: if (mem_base != xmlMemBlocks()) {
21430: printf("Leak of %d blocks found in xmlNewDtd",
21431: xmlMemBlocks() - mem_base);
21432: test_ret++;
21433: printf(" %d", n_doc);
21434: printf(" %d", n_name);
21435: printf(" %d", n_ExternalID);
21436: printf(" %d", n_SystemID);
21437: printf("\n");
21438: }
21439: }
21440: }
21441: }
21442: }
21443: function_tests++;
21444:
21445: return(test_ret);
21446: }
21447:
21448:
21449: static int
21450: test_xmlNewNode(void) {
21451: int test_ret = 0;
21452:
21453: int mem_base;
21454: xmlNodePtr ret_val;
21455: xmlNsPtr ns; /* namespace if any */
21456: int n_ns;
21457: xmlChar * name; /* the node name */
21458: int n_name;
21459:
21460: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
21461: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21462: mem_base = xmlMemBlocks();
21463: ns = gen_xmlNsPtr(n_ns, 0);
21464: name = gen_const_xmlChar_ptr(n_name, 1);
21465:
21466: ret_val = xmlNewNode(ns, (const xmlChar *)name);
21467: desret_xmlNodePtr(ret_val);
21468: call_tests++;
21469: des_xmlNsPtr(n_ns, ns, 0);
21470: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
21471: xmlResetLastError();
21472: if (mem_base != xmlMemBlocks()) {
21473: printf("Leak of %d blocks found in xmlNewNode",
21474: xmlMemBlocks() - mem_base);
21475: test_ret++;
21476: printf(" %d", n_ns);
21477: printf(" %d", n_name);
21478: printf("\n");
21479: }
21480: }
21481: }
21482: function_tests++;
21483:
21484: return(test_ret);
21485: }
21486:
21487:
21488: static int
21489: test_xmlNewNodeEatName(void) {
21490: int test_ret = 0;
21491:
21492: int mem_base;
21493: xmlNodePtr ret_val;
21494: xmlNsPtr ns; /* namespace if any */
21495: int n_ns;
21496: xmlChar * name; /* the node name */
21497: int n_name;
21498:
21499: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
21500: for (n_name = 0;n_name < gen_nb_eaten_name;n_name++) {
21501: mem_base = xmlMemBlocks();
21502: ns = gen_xmlNsPtr(n_ns, 0);
21503: name = gen_eaten_name(n_name, 1);
21504:
21505: ret_val = xmlNewNodeEatName(ns, name);
21506: desret_xmlNodePtr(ret_val);
21507: call_tests++;
21508: des_xmlNsPtr(n_ns, ns, 0);
21509: des_eaten_name(n_name, name, 1);
21510: xmlResetLastError();
21511: if (mem_base != xmlMemBlocks()) {
21512: printf("Leak of %d blocks found in xmlNewNodeEatName",
21513: xmlMemBlocks() - mem_base);
21514: test_ret++;
21515: printf(" %d", n_ns);
21516: printf(" %d", n_name);
21517: printf("\n");
21518: }
21519: }
21520: }
21521: function_tests++;
21522:
21523: return(test_ret);
21524: }
21525:
21526:
21527: static int
21528: test_xmlNewNs(void) {
21529: int test_ret = 0;
21530:
21531: int mem_base;
21532: xmlNsPtr ret_val;
21533: xmlNodePtr node; /* the element carrying the namespace */
21534: int n_node;
21535: xmlChar * href; /* the URI associated */
21536: int n_href;
21537: xmlChar * prefix; /* the prefix for the namespace */
21538: int n_prefix;
21539:
21540: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
21541: for (n_href = 0;n_href < gen_nb_const_xmlChar_ptr;n_href++) {
21542: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
21543: mem_base = xmlMemBlocks();
21544: node = gen_xmlNodePtr(n_node, 0);
21545: href = gen_const_xmlChar_ptr(n_href, 1);
21546: prefix = gen_const_xmlChar_ptr(n_prefix, 2);
21547:
21548: ret_val = xmlNewNs(node, (const xmlChar *)href, (const xmlChar *)prefix);
21549: if ((node == NULL) && (ret_val != NULL)) xmlFreeNs(ret_val);
21550: desret_xmlNsPtr(ret_val);
21551: call_tests++;
21552: des_xmlNodePtr(n_node, node, 0);
21553: des_const_xmlChar_ptr(n_href, (const xmlChar *)href, 1);
21554: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 2);
21555: xmlResetLastError();
21556: if (mem_base != xmlMemBlocks()) {
21557: printf("Leak of %d blocks found in xmlNewNs",
21558: xmlMemBlocks() - mem_base);
21559: test_ret++;
21560: printf(" %d", n_node);
21561: printf(" %d", n_href);
21562: printf(" %d", n_prefix);
21563: printf("\n");
21564: }
21565: }
21566: }
21567: }
21568: function_tests++;
21569:
21570: return(test_ret);
21571: }
21572:
21573:
21574: static int
21575: test_xmlNewNsProp(void) {
21576: int test_ret = 0;
21577:
21578: int mem_base;
21579: xmlAttrPtr ret_val;
21580: xmlNodePtr node; /* the holding node */
21581: int n_node;
21582: xmlNsPtr ns; /* the namespace */
21583: int n_ns;
21584: xmlChar * name; /* the name of the attribute */
21585: int n_name;
21586: xmlChar * value; /* the value of the attribute */
21587: int n_value;
21588:
21589: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
21590: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
21591: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21592: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
21593: mem_base = xmlMemBlocks();
21594: node = gen_xmlNodePtr(n_node, 0);
21595: ns = gen_xmlNsPtr(n_ns, 1);
21596: name = gen_const_xmlChar_ptr(n_name, 2);
21597: value = gen_const_xmlChar_ptr(n_value, 3);
21598:
21599: ret_val = xmlNewNsProp(node, ns, (const xmlChar *)name, (const xmlChar *)value);
21600: desret_xmlAttrPtr(ret_val);
21601: call_tests++;
21602: des_xmlNodePtr(n_node, node, 0);
21603: des_xmlNsPtr(n_ns, ns, 1);
21604: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
21605: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 3);
21606: xmlResetLastError();
21607: if (mem_base != xmlMemBlocks()) {
21608: printf("Leak of %d blocks found in xmlNewNsProp",
21609: xmlMemBlocks() - mem_base);
21610: test_ret++;
21611: printf(" %d", n_node);
21612: printf(" %d", n_ns);
21613: printf(" %d", n_name);
21614: printf(" %d", n_value);
21615: printf("\n");
21616: }
21617: }
21618: }
21619: }
21620: }
21621: function_tests++;
21622:
21623: return(test_ret);
21624: }
21625:
21626:
21627: static int
21628: test_xmlNewNsPropEatName(void) {
21629: int test_ret = 0;
21630:
21631: int mem_base;
21632: xmlAttrPtr ret_val;
21633: xmlNodePtr node; /* the holding node */
21634: int n_node;
21635: xmlNsPtr ns; /* the namespace */
21636: int n_ns;
21637: xmlChar * name; /* the name of the attribute */
21638: int n_name;
21639: xmlChar * value; /* the value of the attribute */
21640: int n_value;
21641:
21642: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
21643: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
21644: for (n_name = 0;n_name < gen_nb_eaten_name;n_name++) {
21645: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
21646: mem_base = xmlMemBlocks();
21647: node = gen_xmlNodePtr(n_node, 0);
21648: ns = gen_xmlNsPtr(n_ns, 1);
21649: name = gen_eaten_name(n_name, 2);
21650: value = gen_const_xmlChar_ptr(n_value, 3);
21651:
21652: ret_val = xmlNewNsPropEatName(node, ns, name, (const xmlChar *)value);
21653: desret_xmlAttrPtr(ret_val);
21654: call_tests++;
21655: des_xmlNodePtr(n_node, node, 0);
21656: des_xmlNsPtr(n_ns, ns, 1);
21657: des_eaten_name(n_name, name, 2);
21658: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 3);
21659: xmlResetLastError();
21660: if (mem_base != xmlMemBlocks()) {
21661: printf("Leak of %d blocks found in xmlNewNsPropEatName",
21662: xmlMemBlocks() - mem_base);
21663: test_ret++;
21664: printf(" %d", n_node);
21665: printf(" %d", n_ns);
21666: printf(" %d", n_name);
21667: printf(" %d", n_value);
21668: printf("\n");
21669: }
21670: }
21671: }
21672: }
21673: }
21674: function_tests++;
21675:
21676: return(test_ret);
21677: }
21678:
21679:
21680: static int
21681: test_xmlNewPI(void) {
21682: int test_ret = 0;
21683:
21684: int mem_base;
21685: xmlNodePtr ret_val;
21686: xmlChar * name; /* the processing instruction name */
21687: int n_name;
21688: xmlChar * content; /* the PI content */
21689: int n_content;
21690:
21691: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21692: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21693: mem_base = xmlMemBlocks();
21694: name = gen_const_xmlChar_ptr(n_name, 0);
21695: content = gen_const_xmlChar_ptr(n_content, 1);
21696:
21697: ret_val = xmlNewPI((const xmlChar *)name, (const xmlChar *)content);
21698: desret_xmlNodePtr(ret_val);
21699: call_tests++;
21700: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
21701: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
21702: xmlResetLastError();
21703: if (mem_base != xmlMemBlocks()) {
21704: printf("Leak of %d blocks found in xmlNewPI",
21705: xmlMemBlocks() - mem_base);
21706: test_ret++;
21707: printf(" %d", n_name);
21708: printf(" %d", n_content);
21709: printf("\n");
21710: }
21711: }
21712: }
21713: function_tests++;
21714:
21715: return(test_ret);
21716: }
21717:
21718:
21719: static int
21720: test_xmlNewProp(void) {
21721: int test_ret = 0;
21722:
21723: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
21724: #ifdef LIBXML_TREE_ENABLED
21725: int mem_base;
21726: xmlAttrPtr ret_val;
21727: xmlNodePtr node; /* the holding node */
21728: int n_node;
21729: xmlChar * name; /* the name of the attribute */
21730: int n_name;
21731: xmlChar * value; /* the value of the attribute */
21732: int n_value;
21733:
21734: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
21735: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21736: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
21737: mem_base = xmlMemBlocks();
21738: node = gen_xmlNodePtr(n_node, 0);
21739: name = gen_const_xmlChar_ptr(n_name, 1);
21740: value = gen_const_xmlChar_ptr(n_value, 2);
21741:
21742: ret_val = xmlNewProp(node, (const xmlChar *)name, (const xmlChar *)value);
21743: desret_xmlAttrPtr(ret_val);
21744: call_tests++;
21745: des_xmlNodePtr(n_node, node, 0);
21746: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
21747: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2);
21748: xmlResetLastError();
21749: if (mem_base != xmlMemBlocks()) {
21750: printf("Leak of %d blocks found in xmlNewProp",
21751: xmlMemBlocks() - mem_base);
21752: test_ret++;
21753: printf(" %d", n_node);
21754: printf(" %d", n_name);
21755: printf(" %d", n_value);
21756: printf("\n");
21757: }
21758: }
21759: }
21760: }
21761: function_tests++;
21762: #endif
21763: #endif
21764:
21765: return(test_ret);
21766: }
21767:
21768:
21769: static int
21770: test_xmlNewReference(void) {
21771: int test_ret = 0;
21772:
21773: int mem_base;
21774: xmlNodePtr ret_val;
21775: xmlDocPtr doc; /* the document */
21776: int n_doc;
21777: xmlChar * name; /* the reference name, or the reference string with & and ; */
21778: int n_name;
21779:
21780: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21781: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21782: mem_base = xmlMemBlocks();
21783: doc = gen_xmlDocPtr(n_doc, 0);
21784: name = gen_const_xmlChar_ptr(n_name, 1);
21785:
21786: ret_val = xmlNewReference(doc, (const xmlChar *)name);
21787: desret_xmlNodePtr(ret_val);
21788: call_tests++;
21789: des_xmlDocPtr(n_doc, doc, 0);
21790: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
21791: xmlResetLastError();
21792: if (mem_base != xmlMemBlocks()) {
21793: printf("Leak of %d blocks found in xmlNewReference",
21794: xmlMemBlocks() - mem_base);
21795: test_ret++;
21796: printf(" %d", n_doc);
21797: printf(" %d", n_name);
21798: printf("\n");
21799: }
21800: }
21801: }
21802: function_tests++;
21803:
21804: return(test_ret);
21805: }
21806:
21807:
21808: static int
21809: test_xmlNewText(void) {
21810: int test_ret = 0;
21811:
21812: int mem_base;
21813: xmlNodePtr ret_val;
21814: xmlChar * content; /* the text content */
21815: int n_content;
21816:
21817: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21818: mem_base = xmlMemBlocks();
21819: content = gen_const_xmlChar_ptr(n_content, 0);
21820:
21821: ret_val = xmlNewText((const xmlChar *)content);
21822: desret_xmlNodePtr(ret_val);
21823: call_tests++;
21824: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 0);
21825: xmlResetLastError();
21826: if (mem_base != xmlMemBlocks()) {
21827: printf("Leak of %d blocks found in xmlNewText",
21828: xmlMemBlocks() - mem_base);
21829: test_ret++;
21830: printf(" %d", n_content);
21831: printf("\n");
21832: }
21833: }
21834: function_tests++;
21835:
21836: return(test_ret);
21837: }
21838:
21839:
21840: static int
21841: test_xmlNewTextChild(void) {
21842: int test_ret = 0;
21843:
21844: #if defined(LIBXML_TREE_ENABLED)
21845: #ifdef LIBXML_TREE_ENABLED
21846: int mem_base;
21847: xmlNodePtr ret_val;
21848: xmlNodePtr parent; /* the parent node */
21849: int n_parent;
21850: xmlNsPtr ns; /* a namespace if any */
21851: int n_ns;
21852: xmlChar * name; /* the name of the child */
21853: int n_name;
21854: xmlChar * content; /* the text content of the child if any. */
21855: int n_content;
21856:
21857: for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
21858: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
21859: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21860: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21861: mem_base = xmlMemBlocks();
21862: parent = gen_xmlNodePtr(n_parent, 0);
21863: ns = gen_xmlNsPtr(n_ns, 1);
21864: name = gen_const_xmlChar_ptr(n_name, 2);
21865: content = gen_const_xmlChar_ptr(n_content, 3);
21866:
21867: ret_val = xmlNewTextChild(parent, ns, (const xmlChar *)name, (const xmlChar *)content);
21868: desret_xmlNodePtr(ret_val);
21869: call_tests++;
21870: des_xmlNodePtr(n_parent, parent, 0);
21871: des_xmlNsPtr(n_ns, ns, 1);
21872: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
21873: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3);
21874: xmlResetLastError();
21875: if (mem_base != xmlMemBlocks()) {
21876: printf("Leak of %d blocks found in xmlNewTextChild",
21877: xmlMemBlocks() - mem_base);
21878: test_ret++;
21879: printf(" %d", n_parent);
21880: printf(" %d", n_ns);
21881: printf(" %d", n_name);
21882: printf(" %d", n_content);
21883: printf("\n");
21884: }
21885: }
21886: }
21887: }
21888: }
21889: function_tests++;
21890: #endif
21891: #endif
21892:
21893: return(test_ret);
21894: }
21895:
21896:
21897: static int
21898: test_xmlNewTextLen(void) {
21899: int test_ret = 0;
21900:
21901: int mem_base;
21902: xmlNodePtr ret_val;
21903: xmlChar * content; /* the text content */
21904: int n_content;
21905: int len; /* the text len. */
21906: int n_len;
21907:
21908: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21909: for (n_len = 0;n_len < gen_nb_int;n_len++) {
21910: mem_base = xmlMemBlocks();
21911: content = gen_const_xmlChar_ptr(n_content, 0);
21912: len = gen_int(n_len, 1);
21913:
21914: ret_val = xmlNewTextLen((const xmlChar *)content, len);
21915: desret_xmlNodePtr(ret_val);
21916: call_tests++;
21917: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 0);
21918: des_int(n_len, len, 1);
21919: xmlResetLastError();
21920: if (mem_base != xmlMemBlocks()) {
21921: printf("Leak of %d blocks found in xmlNewTextLen",
21922: xmlMemBlocks() - mem_base);
21923: test_ret++;
21924: printf(" %d", n_content);
21925: printf(" %d", n_len);
21926: printf("\n");
21927: }
21928: }
21929: }
21930: function_tests++;
21931:
21932: return(test_ret);
21933: }
21934:
21935:
21936: static int
21937: test_xmlNextElementSibling(void) {
21938: int test_ret = 0;
21939:
21940: #if defined(LIBXML_TREE_ENABLED)
21941: int mem_base;
21942: xmlNodePtr ret_val;
21943: xmlNodePtr node; /* the current node */
21944: int n_node;
21945:
21946: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
21947: mem_base = xmlMemBlocks();
21948: node = gen_xmlNodePtr(n_node, 0);
21949:
21950: ret_val = xmlNextElementSibling(node);
21951: desret_xmlNodePtr(ret_val);
21952: call_tests++;
21953: des_xmlNodePtr(n_node, node, 0);
21954: xmlResetLastError();
21955: if (mem_base != xmlMemBlocks()) {
21956: printf("Leak of %d blocks found in xmlNextElementSibling",
21957: xmlMemBlocks() - mem_base);
21958: test_ret++;
21959: printf(" %d", n_node);
21960: printf("\n");
21961: }
21962: }
21963: function_tests++;
21964: #endif
21965:
21966: return(test_ret);
21967: }
21968:
21969:
21970: static int
21971: test_xmlNodeAddContent(void) {
21972: int test_ret = 0;
21973:
21974: int mem_base;
21975: xmlNodePtr cur; /* the node being modified */
21976: int n_cur;
21977: xmlChar * content; /* extra content */
21978: int n_content;
21979:
21980: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
21981: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21982: mem_base = xmlMemBlocks();
21983: cur = gen_xmlNodePtr(n_cur, 0);
21984: content = gen_const_xmlChar_ptr(n_content, 1);
21985:
21986: xmlNodeAddContent(cur, (const xmlChar *)content);
21987: call_tests++;
21988: des_xmlNodePtr(n_cur, cur, 0);
21989: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
21990: xmlResetLastError();
21991: if (mem_base != xmlMemBlocks()) {
21992: printf("Leak of %d blocks found in xmlNodeAddContent",
21993: xmlMemBlocks() - mem_base);
21994: test_ret++;
21995: printf(" %d", n_cur);
21996: printf(" %d", n_content);
21997: printf("\n");
21998: }
21999: }
22000: }
22001: function_tests++;
22002:
22003: return(test_ret);
22004: }
22005:
22006:
22007: static int
22008: test_xmlNodeAddContentLen(void) {
22009: int test_ret = 0;
22010:
22011: int mem_base;
22012: xmlNodePtr cur; /* the node being modified */
22013: int n_cur;
22014: xmlChar * content; /* extra content */
22015: int n_content;
22016: int len; /* the size of @content */
22017: int n_len;
22018:
22019: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22020: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
22021: for (n_len = 0;n_len < gen_nb_int;n_len++) {
22022: mem_base = xmlMemBlocks();
22023: cur = gen_xmlNodePtr(n_cur, 0);
22024: content = gen_const_xmlChar_ptr(n_content, 1);
22025: len = gen_int(n_len, 2);
22026:
22027: xmlNodeAddContentLen(cur, (const xmlChar *)content, len);
22028: call_tests++;
22029: des_xmlNodePtr(n_cur, cur, 0);
22030: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
22031: des_int(n_len, len, 2);
22032: xmlResetLastError();
22033: if (mem_base != xmlMemBlocks()) {
22034: printf("Leak of %d blocks found in xmlNodeAddContentLen",
22035: xmlMemBlocks() - mem_base);
22036: test_ret++;
22037: printf(" %d", n_cur);
22038: printf(" %d", n_content);
22039: printf(" %d", n_len);
22040: printf("\n");
22041: }
22042: }
22043: }
22044: }
22045: function_tests++;
22046:
22047: return(test_ret);
22048: }
22049:
22050:
22051: static int
22052: test_xmlNodeBufGetContent(void) {
22053: int test_ret = 0;
22054:
22055: int mem_base;
22056: int ret_val;
22057: xmlBufferPtr buffer; /* a buffer */
22058: int n_buffer;
22059: xmlNodePtr cur; /* the node being read */
22060: int n_cur;
22061:
22062: for (n_buffer = 0;n_buffer < gen_nb_xmlBufferPtr;n_buffer++) {
22063: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22064: mem_base = xmlMemBlocks();
22065: buffer = gen_xmlBufferPtr(n_buffer, 0);
22066: cur = gen_xmlNodePtr(n_cur, 1);
22067:
22068: ret_val = xmlNodeBufGetContent(buffer, cur);
22069: desret_int(ret_val);
22070: call_tests++;
22071: des_xmlBufferPtr(n_buffer, buffer, 0);
22072: des_xmlNodePtr(n_cur, cur, 1);
22073: xmlResetLastError();
22074: if (mem_base != xmlMemBlocks()) {
22075: printf("Leak of %d blocks found in xmlNodeBufGetContent",
22076: xmlMemBlocks() - mem_base);
22077: test_ret++;
22078: printf(" %d", n_buffer);
22079: printf(" %d", n_cur);
22080: printf("\n");
22081: }
22082: }
22083: }
22084: function_tests++;
22085:
22086: return(test_ret);
22087: }
22088:
22089:
22090: static int
22091: test_xmlNodeDump(void) {
22092: int test_ret = 0;
22093:
22094: #if defined(LIBXML_OUTPUT_ENABLED)
22095: int mem_base;
22096: int ret_val;
22097: xmlBufferPtr buf; /* the XML buffer output */
22098: int n_buf;
22099: xmlDocPtr doc; /* the document */
22100: int n_doc;
22101: xmlNodePtr cur; /* the current node */
22102: int n_cur;
22103: int level; /* the imbrication level for indenting */
22104: int n_level;
22105: int format; /* is formatting allowed */
22106: int n_format;
22107:
22108: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
22109: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
22110: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22111: for (n_level = 0;n_level < gen_nb_int;n_level++) {
22112: for (n_format = 0;n_format < gen_nb_int;n_format++) {
22113: mem_base = xmlMemBlocks();
22114: buf = gen_xmlBufferPtr(n_buf, 0);
22115: doc = gen_xmlDocPtr(n_doc, 1);
22116: cur = gen_xmlNodePtr(n_cur, 2);
22117: level = gen_int(n_level, 3);
22118: format = gen_int(n_format, 4);
22119:
22120: ret_val = xmlNodeDump(buf, doc, cur, level, format);
22121: desret_int(ret_val);
22122: call_tests++;
22123: des_xmlBufferPtr(n_buf, buf, 0);
22124: des_xmlDocPtr(n_doc, doc, 1);
22125: des_xmlNodePtr(n_cur, cur, 2);
22126: des_int(n_level, level, 3);
22127: des_int(n_format, format, 4);
22128: xmlResetLastError();
22129: if (mem_base != xmlMemBlocks()) {
22130: printf("Leak of %d blocks found in xmlNodeDump",
22131: xmlMemBlocks() - mem_base);
22132: test_ret++;
22133: printf(" %d", n_buf);
22134: printf(" %d", n_doc);
22135: printf(" %d", n_cur);
22136: printf(" %d", n_level);
22137: printf(" %d", n_format);
22138: printf("\n");
22139: }
22140: }
22141: }
22142: }
22143: }
22144: }
22145: function_tests++;
22146: #endif
22147:
22148: return(test_ret);
22149: }
22150:
22151:
22152: static int
22153: test_xmlNodeDumpOutput(void) {
22154: int test_ret = 0;
22155:
22156: #if defined(LIBXML_OUTPUT_ENABLED)
22157: int mem_base;
22158: xmlOutputBufferPtr buf; /* the XML buffer output */
22159: int n_buf;
22160: xmlDocPtr doc; /* the document */
22161: int n_doc;
22162: xmlNodePtr cur; /* the current node */
22163: int n_cur;
22164: int level; /* the imbrication level for indenting */
22165: int n_level;
22166: int format; /* is formatting allowed */
22167: int n_format;
22168: char * encoding; /* an optional encoding string */
22169: int n_encoding;
22170:
22171: for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
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: for (n_level = 0;n_level < gen_nb_int;n_level++) {
22175: for (n_format = 0;n_format < gen_nb_int;n_format++) {
22176: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
22177: mem_base = xmlMemBlocks();
22178: buf = gen_xmlOutputBufferPtr(n_buf, 0);
22179: doc = gen_xmlDocPtr(n_doc, 1);
22180: cur = gen_xmlNodePtr(n_cur, 2);
22181: level = gen_int(n_level, 3);
22182: format = gen_int(n_format, 4);
22183: encoding = gen_const_char_ptr(n_encoding, 5);
22184:
22185: xmlNodeDumpOutput(buf, doc, cur, level, format, (const char *)encoding);
22186: call_tests++;
22187: des_xmlOutputBufferPtr(n_buf, buf, 0);
22188: des_xmlDocPtr(n_doc, doc, 1);
22189: des_xmlNodePtr(n_cur, cur, 2);
22190: des_int(n_level, level, 3);
22191: des_int(n_format, format, 4);
22192: des_const_char_ptr(n_encoding, (const char *)encoding, 5);
22193: xmlResetLastError();
22194: if (mem_base != xmlMemBlocks()) {
22195: printf("Leak of %d blocks found in xmlNodeDumpOutput",
22196: xmlMemBlocks() - mem_base);
22197: test_ret++;
22198: printf(" %d", n_buf);
22199: printf(" %d", n_doc);
22200: printf(" %d", n_cur);
22201: printf(" %d", n_level);
22202: printf(" %d", n_format);
22203: printf(" %d", n_encoding);
22204: printf("\n");
22205: }
22206: }
22207: }
22208: }
22209: }
22210: }
22211: }
22212: function_tests++;
22213: #endif
22214:
22215: return(test_ret);
22216: }
22217:
22218:
22219: static int
22220: test_xmlNodeGetBase(void) {
22221: int test_ret = 0;
22222:
22223: int mem_base;
22224: xmlChar * ret_val;
22225: xmlDocPtr doc; /* the document the node pertains to */
22226: int n_doc;
22227: xmlNodePtr cur; /* the node being checked */
22228: int n_cur;
22229:
22230: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
22231: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22232: mem_base = xmlMemBlocks();
22233: doc = gen_xmlDocPtr(n_doc, 0);
22234: cur = gen_xmlNodePtr(n_cur, 1);
22235:
22236: ret_val = xmlNodeGetBase(doc, cur);
22237: desret_xmlChar_ptr(ret_val);
22238: call_tests++;
22239: des_xmlDocPtr(n_doc, doc, 0);
22240: des_xmlNodePtr(n_cur, cur, 1);
22241: xmlResetLastError();
22242: if (mem_base != xmlMemBlocks()) {
22243: printf("Leak of %d blocks found in xmlNodeGetBase",
22244: xmlMemBlocks() - mem_base);
22245: test_ret++;
22246: printf(" %d", n_doc);
22247: printf(" %d", n_cur);
22248: printf("\n");
22249: }
22250: }
22251: }
22252: function_tests++;
22253:
22254: return(test_ret);
22255: }
22256:
22257:
22258: static int
22259: test_xmlNodeGetContent(void) {
22260: int test_ret = 0;
22261:
22262: int mem_base;
22263: xmlChar * ret_val;
22264: xmlNodePtr cur; /* the node being read */
22265: int n_cur;
22266:
22267: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22268: mem_base = xmlMemBlocks();
22269: cur = gen_xmlNodePtr(n_cur, 0);
22270:
22271: ret_val = xmlNodeGetContent(cur);
22272: desret_xmlChar_ptr(ret_val);
22273: call_tests++;
22274: des_xmlNodePtr(n_cur, cur, 0);
22275: xmlResetLastError();
22276: if (mem_base != xmlMemBlocks()) {
22277: printf("Leak of %d blocks found in xmlNodeGetContent",
22278: xmlMemBlocks() - mem_base);
22279: test_ret++;
22280: printf(" %d", n_cur);
22281: printf("\n");
22282: }
22283: }
22284: function_tests++;
22285:
22286: return(test_ret);
22287: }
22288:
22289:
22290: static int
22291: test_xmlNodeGetLang(void) {
22292: int test_ret = 0;
22293:
22294: int mem_base;
22295: xmlChar * ret_val;
22296: xmlNodePtr cur; /* the node being checked */
22297: int n_cur;
22298:
22299: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22300: mem_base = xmlMemBlocks();
22301: cur = gen_xmlNodePtr(n_cur, 0);
22302:
22303: ret_val = xmlNodeGetLang(cur);
22304: desret_xmlChar_ptr(ret_val);
22305: call_tests++;
22306: des_xmlNodePtr(n_cur, cur, 0);
22307: xmlResetLastError();
22308: if (mem_base != xmlMemBlocks()) {
22309: printf("Leak of %d blocks found in xmlNodeGetLang",
22310: xmlMemBlocks() - mem_base);
22311: test_ret++;
22312: printf(" %d", n_cur);
22313: printf("\n");
22314: }
22315: }
22316: function_tests++;
22317:
22318: return(test_ret);
22319: }
22320:
22321:
22322: static int
22323: test_xmlNodeGetSpacePreserve(void) {
22324: int test_ret = 0;
22325:
22326: int mem_base;
22327: int ret_val;
22328: xmlNodePtr cur; /* the node being checked */
22329: int n_cur;
22330:
22331: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22332: mem_base = xmlMemBlocks();
22333: cur = gen_xmlNodePtr(n_cur, 0);
22334:
22335: ret_val = xmlNodeGetSpacePreserve(cur);
22336: desret_int(ret_val);
22337: call_tests++;
22338: des_xmlNodePtr(n_cur, cur, 0);
22339: xmlResetLastError();
22340: if (mem_base != xmlMemBlocks()) {
22341: printf("Leak of %d blocks found in xmlNodeGetSpacePreserve",
22342: xmlMemBlocks() - mem_base);
22343: test_ret++;
22344: printf(" %d", n_cur);
22345: printf("\n");
22346: }
22347: }
22348: function_tests++;
22349:
22350: return(test_ret);
22351: }
22352:
22353:
22354: static int
22355: test_xmlNodeIsText(void) {
22356: int test_ret = 0;
22357:
22358: int mem_base;
22359: int ret_val;
22360: xmlNodePtr node; /* the node */
22361: int n_node;
22362:
22363: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
22364: mem_base = xmlMemBlocks();
22365: node = gen_xmlNodePtr(n_node, 0);
22366:
22367: ret_val = xmlNodeIsText(node);
22368: desret_int(ret_val);
22369: call_tests++;
22370: des_xmlNodePtr(n_node, node, 0);
22371: xmlResetLastError();
22372: if (mem_base != xmlMemBlocks()) {
22373: printf("Leak of %d blocks found in xmlNodeIsText",
22374: xmlMemBlocks() - mem_base);
22375: test_ret++;
22376: printf(" %d", n_node);
22377: printf("\n");
22378: }
22379: }
22380: function_tests++;
22381:
22382: return(test_ret);
22383: }
22384:
22385:
22386: static int
22387: test_xmlNodeListGetRawString(void) {
22388: int test_ret = 0;
22389:
22390: #if defined(LIBXML_TREE_ENABLED)
22391: int mem_base;
22392: xmlChar * ret_val;
22393: xmlDocPtr doc; /* the document */
22394: int n_doc;
22395: xmlNodePtr list; /* a Node list */
22396: int n_list;
22397: int inLine; /* should we replace entity contents or show their external form */
22398: int n_inLine;
22399:
22400: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
22401: for (n_list = 0;n_list < gen_nb_xmlNodePtr;n_list++) {
22402: for (n_inLine = 0;n_inLine < gen_nb_int;n_inLine++) {
22403: mem_base = xmlMemBlocks();
22404: doc = gen_xmlDocPtr(n_doc, 0);
22405: list = gen_xmlNodePtr(n_list, 1);
22406: inLine = gen_int(n_inLine, 2);
22407:
22408: ret_val = xmlNodeListGetRawString(doc, list, inLine);
22409: desret_xmlChar_ptr(ret_val);
22410: call_tests++;
22411: des_xmlDocPtr(n_doc, doc, 0);
22412: des_xmlNodePtr(n_list, list, 1);
22413: des_int(n_inLine, inLine, 2);
22414: xmlResetLastError();
22415: if (mem_base != xmlMemBlocks()) {
22416: printf("Leak of %d blocks found in xmlNodeListGetRawString",
22417: xmlMemBlocks() - mem_base);
22418: test_ret++;
22419: printf(" %d", n_doc);
22420: printf(" %d", n_list);
22421: printf(" %d", n_inLine);
22422: printf("\n");
22423: }
22424: }
22425: }
22426: }
22427: function_tests++;
22428: #endif
22429:
22430: return(test_ret);
22431: }
22432:
22433:
22434: static int
22435: test_xmlNodeListGetString(void) {
22436: int test_ret = 0;
22437:
22438: int mem_base;
22439: xmlChar * ret_val;
22440: xmlDocPtr doc; /* the document */
22441: int n_doc;
22442: xmlNodePtr list; /* a Node list */
22443: int n_list;
22444: int inLine; /* should we replace entity contents or show their external form */
22445: int n_inLine;
22446:
22447: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
22448: for (n_list = 0;n_list < gen_nb_xmlNodePtr;n_list++) {
22449: for (n_inLine = 0;n_inLine < gen_nb_int;n_inLine++) {
22450: mem_base = xmlMemBlocks();
22451: doc = gen_xmlDocPtr(n_doc, 0);
22452: list = gen_xmlNodePtr(n_list, 1);
22453: inLine = gen_int(n_inLine, 2);
22454:
22455: ret_val = xmlNodeListGetString(doc, list, inLine);
22456: desret_xmlChar_ptr(ret_val);
22457: call_tests++;
22458: des_xmlDocPtr(n_doc, doc, 0);
22459: des_xmlNodePtr(n_list, list, 1);
22460: des_int(n_inLine, inLine, 2);
22461: xmlResetLastError();
22462: if (mem_base != xmlMemBlocks()) {
22463: printf("Leak of %d blocks found in xmlNodeListGetString",
22464: xmlMemBlocks() - mem_base);
22465: test_ret++;
22466: printf(" %d", n_doc);
22467: printf(" %d", n_list);
22468: printf(" %d", n_inLine);
22469: printf("\n");
22470: }
22471: }
22472: }
22473: }
22474: function_tests++;
22475:
22476: return(test_ret);
22477: }
22478:
22479:
22480: static int
22481: test_xmlNodeSetBase(void) {
22482: int test_ret = 0;
22483:
22484: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED)
22485: int mem_base;
22486: xmlNodePtr cur; /* the node being changed */
22487: int n_cur;
22488: xmlChar * uri; /* the new base URI */
22489: int n_uri;
22490:
22491: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22492: for (n_uri = 0;n_uri < gen_nb_const_xmlChar_ptr;n_uri++) {
22493: mem_base = xmlMemBlocks();
22494: cur = gen_xmlNodePtr(n_cur, 0);
22495: uri = gen_const_xmlChar_ptr(n_uri, 1);
22496:
22497: xmlNodeSetBase(cur, (const xmlChar *)uri);
22498: call_tests++;
22499: des_xmlNodePtr(n_cur, cur, 0);
22500: des_const_xmlChar_ptr(n_uri, (const xmlChar *)uri, 1);
22501: xmlResetLastError();
22502: if (mem_base != xmlMemBlocks()) {
22503: printf("Leak of %d blocks found in xmlNodeSetBase",
22504: xmlMemBlocks() - mem_base);
22505: test_ret++;
22506: printf(" %d", n_cur);
22507: printf(" %d", n_uri);
22508: printf("\n");
22509: }
22510: }
22511: }
22512: function_tests++;
22513: #endif
22514:
22515: return(test_ret);
22516: }
22517:
22518:
22519: static int
22520: test_xmlNodeSetContent(void) {
22521: int test_ret = 0;
22522:
22523: int mem_base;
22524: xmlNodePtr cur; /* the node being modified */
22525: int n_cur;
22526: xmlChar * content; /* the new value of the content */
22527: int n_content;
22528:
22529: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22530: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
22531: mem_base = xmlMemBlocks();
22532: cur = gen_xmlNodePtr(n_cur, 0);
22533: content = gen_const_xmlChar_ptr(n_content, 1);
22534:
22535: xmlNodeSetContent(cur, (const xmlChar *)content);
22536: call_tests++;
22537: des_xmlNodePtr(n_cur, cur, 0);
22538: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
22539: xmlResetLastError();
22540: if (mem_base != xmlMemBlocks()) {
22541: printf("Leak of %d blocks found in xmlNodeSetContent",
22542: xmlMemBlocks() - mem_base);
22543: test_ret++;
22544: printf(" %d", n_cur);
22545: printf(" %d", n_content);
22546: printf("\n");
22547: }
22548: }
22549: }
22550: function_tests++;
22551:
22552: return(test_ret);
22553: }
22554:
22555:
22556: static int
22557: test_xmlNodeSetContentLen(void) {
22558: int test_ret = 0;
22559:
22560: #if defined(LIBXML_TREE_ENABLED)
22561: int mem_base;
22562: xmlNodePtr cur; /* the node being modified */
22563: int n_cur;
22564: xmlChar * content; /* the new value of the content */
22565: int n_content;
22566: int len; /* the size of @content */
22567: int n_len;
22568:
22569: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22570: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
22571: for (n_len = 0;n_len < gen_nb_int;n_len++) {
22572: mem_base = xmlMemBlocks();
22573: cur = gen_xmlNodePtr(n_cur, 0);
22574: content = gen_const_xmlChar_ptr(n_content, 1);
22575: len = gen_int(n_len, 2);
22576:
22577: xmlNodeSetContentLen(cur, (const xmlChar *)content, len);
22578: call_tests++;
22579: des_xmlNodePtr(n_cur, cur, 0);
22580: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
22581: des_int(n_len, len, 2);
22582: xmlResetLastError();
22583: if (mem_base != xmlMemBlocks()) {
22584: printf("Leak of %d blocks found in xmlNodeSetContentLen",
22585: xmlMemBlocks() - mem_base);
22586: test_ret++;
22587: printf(" %d", n_cur);
22588: printf(" %d", n_content);
22589: printf(" %d", n_len);
22590: printf("\n");
22591: }
22592: }
22593: }
22594: }
22595: function_tests++;
22596: #endif
22597:
22598: return(test_ret);
22599: }
22600:
22601:
22602: static int
22603: test_xmlNodeSetLang(void) {
22604: int test_ret = 0;
22605:
22606: #if defined(LIBXML_TREE_ENABLED)
22607: int mem_base;
22608: xmlNodePtr cur; /* the node being changed */
22609: int n_cur;
22610: xmlChar * lang; /* the language description */
22611: int n_lang;
22612:
22613: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22614: for (n_lang = 0;n_lang < gen_nb_const_xmlChar_ptr;n_lang++) {
22615: mem_base = xmlMemBlocks();
22616: cur = gen_xmlNodePtr(n_cur, 0);
22617: lang = gen_const_xmlChar_ptr(n_lang, 1);
22618:
22619: xmlNodeSetLang(cur, (const xmlChar *)lang);
22620: call_tests++;
22621: des_xmlNodePtr(n_cur, cur, 0);
22622: des_const_xmlChar_ptr(n_lang, (const xmlChar *)lang, 1);
22623: xmlResetLastError();
22624: if (mem_base != xmlMemBlocks()) {
22625: printf("Leak of %d blocks found in xmlNodeSetLang",
22626: xmlMemBlocks() - mem_base);
22627: test_ret++;
22628: printf(" %d", n_cur);
22629: printf(" %d", n_lang);
22630: printf("\n");
22631: }
22632: }
22633: }
22634: function_tests++;
22635: #endif
22636:
22637: return(test_ret);
22638: }
22639:
22640:
22641: static int
22642: test_xmlNodeSetName(void) {
22643: int test_ret = 0;
22644:
22645: #if defined(LIBXML_TREE_ENABLED)
22646: int mem_base;
22647: xmlNodePtr cur; /* the node being changed */
22648: int n_cur;
22649: xmlChar * name; /* the new tag name */
22650: int n_name;
22651:
22652: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22653: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
22654: mem_base = xmlMemBlocks();
22655: cur = gen_xmlNodePtr(n_cur, 0);
22656: name = gen_const_xmlChar_ptr(n_name, 1);
22657:
22658: xmlNodeSetName(cur, (const xmlChar *)name);
22659: call_tests++;
22660: des_xmlNodePtr(n_cur, cur, 0);
22661: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
22662: xmlResetLastError();
22663: if (mem_base != xmlMemBlocks()) {
22664: printf("Leak of %d blocks found in xmlNodeSetName",
22665: xmlMemBlocks() - mem_base);
22666: test_ret++;
22667: printf(" %d", n_cur);
22668: printf(" %d", n_name);
22669: printf("\n");
22670: }
22671: }
22672: }
22673: function_tests++;
22674: #endif
22675:
22676: return(test_ret);
22677: }
22678:
22679:
22680: static int
22681: test_xmlNodeSetSpacePreserve(void) {
22682: int test_ret = 0;
22683:
22684: #if defined(LIBXML_TREE_ENABLED)
22685: int mem_base;
22686: xmlNodePtr cur; /* the node being changed */
22687: int n_cur;
22688: int val; /* the xml:space value ("0": default, 1: "preserve") */
22689: int n_val;
22690:
22691: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22692: for (n_val = 0;n_val < gen_nb_int;n_val++) {
22693: mem_base = xmlMemBlocks();
22694: cur = gen_xmlNodePtr(n_cur, 0);
22695: val = gen_int(n_val, 1);
22696:
22697: xmlNodeSetSpacePreserve(cur, val);
22698: call_tests++;
22699: des_xmlNodePtr(n_cur, cur, 0);
22700: des_int(n_val, val, 1);
22701: xmlResetLastError();
22702: if (mem_base != xmlMemBlocks()) {
22703: printf("Leak of %d blocks found in xmlNodeSetSpacePreserve",
22704: xmlMemBlocks() - mem_base);
22705: test_ret++;
22706: printf(" %d", n_cur);
22707: printf(" %d", n_val);
22708: printf("\n");
22709: }
22710: }
22711: }
22712: function_tests++;
22713: #endif
22714:
22715: return(test_ret);
22716: }
22717:
22718:
22719: static int
22720: test_xmlPreviousElementSibling(void) {
22721: int test_ret = 0;
22722:
22723: #if defined(LIBXML_TREE_ENABLED)
22724: int mem_base;
22725: xmlNodePtr ret_val;
22726: xmlNodePtr node; /* the current node */
22727: int n_node;
22728:
22729: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
22730: mem_base = xmlMemBlocks();
22731: node = gen_xmlNodePtr(n_node, 0);
22732:
22733: ret_val = xmlPreviousElementSibling(node);
22734: desret_xmlNodePtr(ret_val);
22735: call_tests++;
22736: des_xmlNodePtr(n_node, node, 0);
22737: xmlResetLastError();
22738: if (mem_base != xmlMemBlocks()) {
22739: printf("Leak of %d blocks found in xmlPreviousElementSibling",
22740: xmlMemBlocks() - mem_base);
22741: test_ret++;
22742: printf(" %d", n_node);
22743: printf("\n");
22744: }
22745: }
22746: function_tests++;
22747: #endif
22748:
22749: return(test_ret);
22750: }
22751:
22752:
22753: static int
22754: test_xmlReconciliateNs(void) {
22755: int test_ret = 0;
22756:
22757: #if defined(LIBXML_TREE_ENABLED)
22758: #ifdef LIBXML_TREE_ENABLED
22759: int mem_base;
22760: int ret_val;
22761: xmlDocPtr doc; /* the document */
22762: int n_doc;
22763: xmlNodePtr tree; /* a node defining the subtree to reconciliate */
22764: int n_tree;
22765:
22766: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
22767: for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) {
22768: mem_base = xmlMemBlocks();
22769: doc = gen_xmlDocPtr(n_doc, 0);
22770: tree = gen_xmlNodePtr(n_tree, 1);
22771:
22772: ret_val = xmlReconciliateNs(doc, tree);
22773: desret_int(ret_val);
22774: call_tests++;
22775: des_xmlDocPtr(n_doc, doc, 0);
22776: des_xmlNodePtr(n_tree, tree, 1);
22777: xmlResetLastError();
22778: if (mem_base != xmlMemBlocks()) {
22779: printf("Leak of %d blocks found in xmlReconciliateNs",
22780: xmlMemBlocks() - mem_base);
22781: test_ret++;
22782: printf(" %d", n_doc);
22783: printf(" %d", n_tree);
22784: printf("\n");
22785: }
22786: }
22787: }
22788: function_tests++;
22789: #endif
22790: #endif
22791:
22792: return(test_ret);
22793: }
22794:
22795:
22796: static int
22797: test_xmlRemoveProp(void) {
22798: int test_ret = 0;
22799:
22800: int mem_base;
22801: int ret_val;
22802: xmlAttrPtr cur; /* an attribute */
22803: int n_cur;
22804:
22805: for (n_cur = 0;n_cur < gen_nb_xmlAttrPtr;n_cur++) {
22806: mem_base = xmlMemBlocks();
22807: cur = gen_xmlAttrPtr(n_cur, 0);
22808:
22809: ret_val = xmlRemoveProp(cur);
22810: cur = NULL;
22811: desret_int(ret_val);
22812: call_tests++;
22813: des_xmlAttrPtr(n_cur, cur, 0);
22814: xmlResetLastError();
22815: if (mem_base != xmlMemBlocks()) {
22816: printf("Leak of %d blocks found in xmlRemoveProp",
22817: xmlMemBlocks() - mem_base);
22818: test_ret++;
22819: printf(" %d", n_cur);
22820: printf("\n");
22821: }
22822: }
22823: function_tests++;
22824:
22825: return(test_ret);
22826: }
22827:
22828:
22829: static int
22830: test_xmlReplaceNode(void) {
22831: int test_ret = 0;
22832:
22833: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
22834: int mem_base;
22835: xmlNodePtr ret_val;
22836: xmlNodePtr old; /* the old node */
22837: int n_old;
22838: xmlNodePtr cur; /* the node */
22839: int n_cur;
22840:
22841: for (n_old = 0;n_old < gen_nb_xmlNodePtr;n_old++) {
22842: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr_in;n_cur++) {
22843: mem_base = xmlMemBlocks();
22844: old = gen_xmlNodePtr(n_old, 0);
22845: cur = gen_xmlNodePtr_in(n_cur, 1);
22846:
22847: ret_val = xmlReplaceNode(old, cur);
22848: if (cur != NULL) {
22849: xmlUnlinkNode(cur);
22850: xmlFreeNode(cur) ; cur = NULL ; }
22851: if (old != NULL) {
22852: xmlUnlinkNode(old);
22853: xmlFreeNode(old) ; old = NULL ; }
22854: ret_val = NULL;
22855: desret_xmlNodePtr(ret_val);
22856: call_tests++;
22857: des_xmlNodePtr(n_old, old, 0);
22858: des_xmlNodePtr_in(n_cur, cur, 1);
22859: xmlResetLastError();
22860: if (mem_base != xmlMemBlocks()) {
22861: printf("Leak of %d blocks found in xmlReplaceNode",
22862: xmlMemBlocks() - mem_base);
22863: test_ret++;
22864: printf(" %d", n_old);
22865: printf(" %d", n_cur);
22866: printf("\n");
22867: }
22868: }
22869: }
22870: function_tests++;
22871: #endif
22872:
22873: return(test_ret);
22874: }
22875:
22876:
22877: static int
22878: test_xmlSaveFile(void) {
22879: int test_ret = 0;
22880:
22881: #if defined(LIBXML_OUTPUT_ENABLED)
22882: int mem_base;
22883: int ret_val;
22884: const char * filename; /* the filename (or URL) */
22885: int n_filename;
22886: xmlDocPtr cur; /* the document */
22887: int n_cur;
22888:
22889: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
22890: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
22891: mem_base = xmlMemBlocks();
22892: filename = gen_fileoutput(n_filename, 0);
22893: cur = gen_xmlDocPtr(n_cur, 1);
22894:
22895: ret_val = xmlSaveFile(filename, cur);
22896: desret_int(ret_val);
22897: call_tests++;
22898: des_fileoutput(n_filename, filename, 0);
22899: des_xmlDocPtr(n_cur, cur, 1);
22900: xmlResetLastError();
22901: if (mem_base != xmlMemBlocks()) {
22902: printf("Leak of %d blocks found in xmlSaveFile",
22903: xmlMemBlocks() - mem_base);
22904: test_ret++;
22905: printf(" %d", n_filename);
22906: printf(" %d", n_cur);
22907: printf("\n");
22908: }
22909: }
22910: }
22911: function_tests++;
22912: #endif
22913:
22914: return(test_ret);
22915: }
22916:
22917:
22918: static int
22919: test_xmlSaveFileEnc(void) {
22920: int test_ret = 0;
22921:
22922: #if defined(LIBXML_OUTPUT_ENABLED)
22923: int mem_base;
22924: int ret_val;
22925: const char * filename; /* the filename (or URL) */
22926: int n_filename;
22927: xmlDocPtr cur; /* the document */
22928: int n_cur;
22929: char * encoding; /* the name of an encoding (or NULL) */
22930: int n_encoding;
22931:
22932: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
22933: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
22934: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
22935: mem_base = xmlMemBlocks();
22936: filename = gen_fileoutput(n_filename, 0);
22937: cur = gen_xmlDocPtr(n_cur, 1);
22938: encoding = gen_const_char_ptr(n_encoding, 2);
22939:
22940: ret_val = xmlSaveFileEnc(filename, cur, (const char *)encoding);
22941: desret_int(ret_val);
22942: call_tests++;
22943: des_fileoutput(n_filename, filename, 0);
22944: des_xmlDocPtr(n_cur, cur, 1);
22945: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
22946: xmlResetLastError();
22947: if (mem_base != xmlMemBlocks()) {
22948: printf("Leak of %d blocks found in xmlSaveFileEnc",
22949: xmlMemBlocks() - mem_base);
22950: test_ret++;
22951: printf(" %d", n_filename);
22952: printf(" %d", n_cur);
22953: printf(" %d", n_encoding);
22954: printf("\n");
22955: }
22956: }
22957: }
22958: }
22959: function_tests++;
22960: #endif
22961:
22962: return(test_ret);
22963: }
22964:
22965:
22966: static int
22967: test_xmlSaveFileTo(void) {
22968: int test_ret = 0;
22969:
22970: #if defined(LIBXML_OUTPUT_ENABLED)
22971: int mem_base;
22972: int ret_val;
22973: xmlOutputBufferPtr buf; /* an output I/O buffer */
22974: int n_buf;
22975: xmlDocPtr cur; /* the document */
22976: int n_cur;
22977: char * encoding; /* the encoding if any assuming the I/O layer handles the trancoding */
22978: int n_encoding;
22979:
22980: for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
22981: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
22982: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
22983: mem_base = xmlMemBlocks();
22984: buf = gen_xmlOutputBufferPtr(n_buf, 0);
22985: cur = gen_xmlDocPtr(n_cur, 1);
22986: encoding = gen_const_char_ptr(n_encoding, 2);
22987:
22988: ret_val = xmlSaveFileTo(buf, cur, (const char *)encoding);
22989: buf = NULL;
22990: desret_int(ret_val);
22991: call_tests++;
22992: des_xmlOutputBufferPtr(n_buf, buf, 0);
22993: des_xmlDocPtr(n_cur, cur, 1);
22994: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
22995: xmlResetLastError();
22996: if (mem_base != xmlMemBlocks()) {
22997: printf("Leak of %d blocks found in xmlSaveFileTo",
22998: xmlMemBlocks() - mem_base);
22999: test_ret++;
23000: printf(" %d", n_buf);
23001: printf(" %d", n_cur);
23002: printf(" %d", n_encoding);
23003: printf("\n");
23004: }
23005: }
23006: }
23007: }
23008: function_tests++;
23009: #endif
23010:
23011: return(test_ret);
23012: }
23013:
23014:
23015: static int
23016: test_xmlSaveFormatFile(void) {
23017: int test_ret = 0;
23018:
23019: #if defined(LIBXML_OUTPUT_ENABLED)
23020: int mem_base;
23021: int ret_val;
23022: const char * filename; /* the filename (or URL) */
23023: int n_filename;
23024: xmlDocPtr cur; /* the document */
23025: int n_cur;
23026: int format; /* should formatting spaces been added */
23027: int n_format;
23028:
23029: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
23030: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
23031: for (n_format = 0;n_format < gen_nb_int;n_format++) {
23032: mem_base = xmlMemBlocks();
23033: filename = gen_fileoutput(n_filename, 0);
23034: cur = gen_xmlDocPtr(n_cur, 1);
23035: format = gen_int(n_format, 2);
23036:
23037: ret_val = xmlSaveFormatFile(filename, cur, format);
23038: desret_int(ret_val);
23039: call_tests++;
23040: des_fileoutput(n_filename, filename, 0);
23041: des_xmlDocPtr(n_cur, cur, 1);
23042: des_int(n_format, format, 2);
23043: xmlResetLastError();
23044: if (mem_base != xmlMemBlocks()) {
23045: printf("Leak of %d blocks found in xmlSaveFormatFile",
23046: xmlMemBlocks() - mem_base);
23047: test_ret++;
23048: printf(" %d", n_filename);
23049: printf(" %d", n_cur);
23050: printf(" %d", n_format);
23051: printf("\n");
23052: }
23053: }
23054: }
23055: }
23056: function_tests++;
23057: #endif
23058:
23059: return(test_ret);
23060: }
23061:
23062:
23063: static int
23064: test_xmlSaveFormatFileEnc(void) {
23065: int test_ret = 0;
23066:
23067: #if defined(LIBXML_OUTPUT_ENABLED)
23068: int mem_base;
23069: int ret_val;
23070: const char * filename; /* the filename or URL to output */
23071: int n_filename;
23072: xmlDocPtr cur; /* the document being saved */
23073: int n_cur;
23074: char * encoding; /* the name of the encoding to use or NULL. */
23075: int n_encoding;
23076: int format; /* should formatting spaces be added. */
23077: int n_format;
23078:
23079: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
23080: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
23081: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
23082: for (n_format = 0;n_format < gen_nb_int;n_format++) {
23083: mem_base = xmlMemBlocks();
23084: filename = gen_fileoutput(n_filename, 0);
23085: cur = gen_xmlDocPtr(n_cur, 1);
23086: encoding = gen_const_char_ptr(n_encoding, 2);
23087: format = gen_int(n_format, 3);
23088:
23089: ret_val = xmlSaveFormatFileEnc(filename, cur, (const char *)encoding, format);
23090: desret_int(ret_val);
23091: call_tests++;
23092: des_fileoutput(n_filename, filename, 0);
23093: des_xmlDocPtr(n_cur, cur, 1);
23094: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
23095: des_int(n_format, format, 3);
23096: xmlResetLastError();
23097: if (mem_base != xmlMemBlocks()) {
23098: printf("Leak of %d blocks found in xmlSaveFormatFileEnc",
23099: xmlMemBlocks() - mem_base);
23100: test_ret++;
23101: printf(" %d", n_filename);
23102: printf(" %d", n_cur);
23103: printf(" %d", n_encoding);
23104: printf(" %d", n_format);
23105: printf("\n");
23106: }
23107: }
23108: }
23109: }
23110: }
23111: function_tests++;
23112: #endif
23113:
23114: return(test_ret);
23115: }
23116:
23117:
23118: static int
23119: test_xmlSaveFormatFileTo(void) {
23120: int test_ret = 0;
23121:
23122: #if defined(LIBXML_OUTPUT_ENABLED)
23123: int mem_base;
23124: int ret_val;
23125: xmlOutputBufferPtr buf; /* an output I/O buffer */
23126: int n_buf;
23127: xmlDocPtr cur; /* the document */
23128: int n_cur;
23129: char * encoding; /* the encoding if any assuming the I/O layer handles the trancoding */
23130: int n_encoding;
23131: int format; /* should formatting spaces been added */
23132: int n_format;
23133:
23134: for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
23135: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
23136: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
23137: for (n_format = 0;n_format < gen_nb_int;n_format++) {
23138: mem_base = xmlMemBlocks();
23139: buf = gen_xmlOutputBufferPtr(n_buf, 0);
23140: cur = gen_xmlDocPtr(n_cur, 1);
23141: encoding = gen_const_char_ptr(n_encoding, 2);
23142: format = gen_int(n_format, 3);
23143:
23144: ret_val = xmlSaveFormatFileTo(buf, cur, (const char *)encoding, format);
23145: buf = NULL;
23146: desret_int(ret_val);
23147: call_tests++;
23148: des_xmlOutputBufferPtr(n_buf, buf, 0);
23149: des_xmlDocPtr(n_cur, cur, 1);
23150: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
23151: des_int(n_format, format, 3);
23152: xmlResetLastError();
23153: if (mem_base != xmlMemBlocks()) {
23154: printf("Leak of %d blocks found in xmlSaveFormatFileTo",
23155: xmlMemBlocks() - mem_base);
23156: test_ret++;
23157: printf(" %d", n_buf);
23158: printf(" %d", n_cur);
23159: printf(" %d", n_encoding);
23160: printf(" %d", n_format);
23161: printf("\n");
23162: }
23163: }
23164: }
23165: }
23166: }
23167: function_tests++;
23168: #endif
23169:
23170: return(test_ret);
23171: }
23172:
23173:
23174: static int
23175: test_xmlSearchNs(void) {
23176: int test_ret = 0;
23177:
23178: int mem_base;
23179: xmlNsPtr ret_val;
23180: xmlDocPtr doc; /* the document */
23181: int n_doc;
23182: xmlNodePtr node; /* the current node */
23183: int n_node;
23184: xmlChar * nameSpace; /* the namespace prefix */
23185: int n_nameSpace;
23186:
23187: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
23188: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
23189: for (n_nameSpace = 0;n_nameSpace < gen_nb_const_xmlChar_ptr;n_nameSpace++) {
23190: mem_base = xmlMemBlocks();
23191: doc = gen_xmlDocPtr(n_doc, 0);
23192: node = gen_xmlNodePtr(n_node, 1);
23193: nameSpace = gen_const_xmlChar_ptr(n_nameSpace, 2);
23194:
23195: ret_val = xmlSearchNs(doc, node, (const xmlChar *)nameSpace);
23196: desret_xmlNsPtr(ret_val);
23197: call_tests++;
23198: des_xmlDocPtr(n_doc, doc, 0);
23199: des_xmlNodePtr(n_node, node, 1);
23200: des_const_xmlChar_ptr(n_nameSpace, (const xmlChar *)nameSpace, 2);
23201: xmlResetLastError();
23202: if (mem_base != xmlMemBlocks()) {
23203: printf("Leak of %d blocks found in xmlSearchNs",
23204: xmlMemBlocks() - mem_base);
23205: test_ret++;
23206: printf(" %d", n_doc);
23207: printf(" %d", n_node);
23208: printf(" %d", n_nameSpace);
23209: printf("\n");
23210: }
23211: }
23212: }
23213: }
23214: function_tests++;
23215:
23216: return(test_ret);
23217: }
23218:
23219:
23220: static int
23221: test_xmlSearchNsByHref(void) {
23222: int test_ret = 0;
23223:
23224: int mem_base;
23225: xmlNsPtr ret_val;
23226: xmlDocPtr doc; /* the document */
23227: int n_doc;
23228: xmlNodePtr node; /* the current node */
23229: int n_node;
23230: xmlChar * href; /* the namespace value */
23231: int n_href;
23232:
23233: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
23234: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
23235: for (n_href = 0;n_href < gen_nb_const_xmlChar_ptr;n_href++) {
23236: mem_base = xmlMemBlocks();
23237: doc = gen_xmlDocPtr(n_doc, 0);
23238: node = gen_xmlNodePtr(n_node, 1);
23239: href = gen_const_xmlChar_ptr(n_href, 2);
23240:
23241: ret_val = xmlSearchNsByHref(doc, node, (const xmlChar *)href);
23242: desret_xmlNsPtr(ret_val);
23243: call_tests++;
23244: des_xmlDocPtr(n_doc, doc, 0);
23245: des_xmlNodePtr(n_node, node, 1);
23246: des_const_xmlChar_ptr(n_href, (const xmlChar *)href, 2);
23247: xmlResetLastError();
23248: if (mem_base != xmlMemBlocks()) {
23249: printf("Leak of %d blocks found in xmlSearchNsByHref",
23250: xmlMemBlocks() - mem_base);
23251: test_ret++;
23252: printf(" %d", n_doc);
23253: printf(" %d", n_node);
23254: printf(" %d", n_href);
23255: printf("\n");
23256: }
23257: }
23258: }
23259: }
23260: function_tests++;
23261:
23262: return(test_ret);
23263: }
23264:
23265:
23266: static int
23267: test_xmlSetBufferAllocationScheme(void) {
23268: int test_ret = 0;
23269:
23270: int mem_base;
23271: xmlBufferAllocationScheme scheme; /* allocation method to use */
23272: int n_scheme;
23273:
23274: for (n_scheme = 0;n_scheme < gen_nb_xmlBufferAllocationScheme;n_scheme++) {
23275: mem_base = xmlMemBlocks();
23276: scheme = gen_xmlBufferAllocationScheme(n_scheme, 0);
23277:
23278: xmlSetBufferAllocationScheme(scheme);
23279: call_tests++;
23280: des_xmlBufferAllocationScheme(n_scheme, scheme, 0);
23281: xmlResetLastError();
23282: if (mem_base != xmlMemBlocks()) {
23283: printf("Leak of %d blocks found in xmlSetBufferAllocationScheme",
23284: xmlMemBlocks() - mem_base);
23285: test_ret++;
23286: printf(" %d", n_scheme);
23287: printf("\n");
23288: }
23289: }
23290: function_tests++;
23291:
23292: return(test_ret);
23293: }
23294:
23295:
23296: static int
23297: test_xmlSetCompressMode(void) {
23298: int test_ret = 0;
23299:
23300: int mem_base;
23301: int mode; /* the compression ratio */
23302: int n_mode;
23303:
23304: for (n_mode = 0;n_mode < gen_nb_int;n_mode++) {
23305: mem_base = xmlMemBlocks();
23306: mode = gen_int(n_mode, 0);
23307:
23308: xmlSetCompressMode(mode);
23309: call_tests++;
23310: des_int(n_mode, mode, 0);
23311: xmlResetLastError();
23312: if (mem_base != xmlMemBlocks()) {
23313: printf("Leak of %d blocks found in xmlSetCompressMode",
23314: xmlMemBlocks() - mem_base);
23315: test_ret++;
23316: printf(" %d", n_mode);
23317: printf("\n");
23318: }
23319: }
23320: function_tests++;
23321:
23322: return(test_ret);
23323: }
23324:
23325:
23326: static int
23327: test_xmlSetDocCompressMode(void) {
23328: int test_ret = 0;
23329:
23330: int mem_base;
23331: xmlDocPtr doc; /* the document */
23332: int n_doc;
23333: int mode; /* the compression ratio */
23334: int n_mode;
23335:
23336: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
23337: for (n_mode = 0;n_mode < gen_nb_int;n_mode++) {
23338: mem_base = xmlMemBlocks();
23339: doc = gen_xmlDocPtr(n_doc, 0);
23340: mode = gen_int(n_mode, 1);
23341:
23342: xmlSetDocCompressMode(doc, mode);
23343: call_tests++;
23344: des_xmlDocPtr(n_doc, doc, 0);
23345: des_int(n_mode, mode, 1);
23346: xmlResetLastError();
23347: if (mem_base != xmlMemBlocks()) {
23348: printf("Leak of %d blocks found in xmlSetDocCompressMode",
23349: xmlMemBlocks() - mem_base);
23350: test_ret++;
23351: printf(" %d", n_doc);
23352: printf(" %d", n_mode);
23353: printf("\n");
23354: }
23355: }
23356: }
23357: function_tests++;
23358:
23359: return(test_ret);
23360: }
23361:
23362:
23363: static int
23364: test_xmlSetNs(void) {
23365: int test_ret = 0;
23366:
23367: int mem_base;
23368: xmlNodePtr node; /* a node in the document */
23369: int n_node;
23370: xmlNsPtr ns; /* a namespace pointer */
23371: int n_ns;
23372:
23373: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
23374: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
23375: mem_base = xmlMemBlocks();
23376: node = gen_xmlNodePtr(n_node, 0);
23377: ns = gen_xmlNsPtr(n_ns, 1);
23378:
23379: xmlSetNs(node, ns);
23380: call_tests++;
23381: des_xmlNodePtr(n_node, node, 0);
23382: des_xmlNsPtr(n_ns, ns, 1);
23383: xmlResetLastError();
23384: if (mem_base != xmlMemBlocks()) {
23385: printf("Leak of %d blocks found in xmlSetNs",
23386: xmlMemBlocks() - mem_base);
23387: test_ret++;
23388: printf(" %d", n_node);
23389: printf(" %d", n_ns);
23390: printf("\n");
23391: }
23392: }
23393: }
23394: function_tests++;
23395:
23396: return(test_ret);
23397: }
23398:
23399:
23400: static int
23401: test_xmlSetNsProp(void) {
23402: int test_ret = 0;
23403:
23404: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
23405: int mem_base;
23406: xmlAttrPtr ret_val;
23407: xmlNodePtr node; /* the node */
23408: int n_node;
23409: xmlNsPtr ns; /* the namespace definition */
23410: int n_ns;
23411: xmlChar * name; /* the attribute name */
23412: int n_name;
23413: xmlChar * value; /* the attribute value */
23414: int n_value;
23415:
23416: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
23417: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
23418: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
23419: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
23420: mem_base = xmlMemBlocks();
23421: node = gen_xmlNodePtr(n_node, 0);
23422: ns = gen_xmlNsPtr(n_ns, 1);
23423: name = gen_const_xmlChar_ptr(n_name, 2);
23424: value = gen_const_xmlChar_ptr(n_value, 3);
23425:
23426: ret_val = xmlSetNsProp(node, ns, (const xmlChar *)name, (const xmlChar *)value);
23427: desret_xmlAttrPtr(ret_val);
23428: call_tests++;
23429: des_xmlNodePtr(n_node, node, 0);
23430: des_xmlNsPtr(n_ns, ns, 1);
23431: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
23432: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 3);
23433: xmlResetLastError();
23434: if (mem_base != xmlMemBlocks()) {
23435: printf("Leak of %d blocks found in xmlSetNsProp",
23436: xmlMemBlocks() - mem_base);
23437: test_ret++;
23438: printf(" %d", n_node);
23439: printf(" %d", n_ns);
23440: printf(" %d", n_name);
23441: printf(" %d", n_value);
23442: printf("\n");
23443: }
23444: }
23445: }
23446: }
23447: }
23448: function_tests++;
23449: #endif
23450:
23451: return(test_ret);
23452: }
23453:
23454:
23455: static int
23456: test_xmlSetProp(void) {
23457: int test_ret = 0;
23458:
23459: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
23460: int mem_base;
23461: xmlAttrPtr ret_val;
23462: xmlNodePtr node; /* the node */
23463: int n_node;
23464: xmlChar * name; /* the attribute name (a QName) */
23465: int n_name;
23466: xmlChar * value; /* the attribute value */
23467: int n_value;
23468:
23469: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
23470: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
23471: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
23472: mem_base = xmlMemBlocks();
23473: node = gen_xmlNodePtr(n_node, 0);
23474: name = gen_const_xmlChar_ptr(n_name, 1);
23475: value = gen_const_xmlChar_ptr(n_value, 2);
23476:
23477: ret_val = xmlSetProp(node, (const xmlChar *)name, (const xmlChar *)value);
23478: desret_xmlAttrPtr(ret_val);
23479: call_tests++;
23480: des_xmlNodePtr(n_node, node, 0);
23481: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
23482: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2);
23483: xmlResetLastError();
23484: if (mem_base != xmlMemBlocks()) {
23485: printf("Leak of %d blocks found in xmlSetProp",
23486: xmlMemBlocks() - mem_base);
23487: test_ret++;
23488: printf(" %d", n_node);
23489: printf(" %d", n_name);
23490: printf(" %d", n_value);
23491: printf("\n");
23492: }
23493: }
23494: }
23495: }
23496: function_tests++;
23497: #endif
23498:
23499: return(test_ret);
23500: }
23501:
23502:
23503: static int
23504: test_xmlSplitQName2(void) {
23505: int test_ret = 0;
23506:
23507: int mem_base;
23508: xmlChar * ret_val;
23509: xmlChar * name; /* the full QName */
23510: int n_name;
23511: xmlChar ** prefix; /* a xmlChar ** */
23512: int n_prefix;
23513:
23514: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
23515: for (n_prefix = 0;n_prefix < gen_nb_xmlChar_ptr_ptr;n_prefix++) {
23516: mem_base = xmlMemBlocks();
23517: name = gen_const_xmlChar_ptr(n_name, 0);
23518: prefix = gen_xmlChar_ptr_ptr(n_prefix, 1);
23519:
23520: ret_val = xmlSplitQName2((const xmlChar *)name, prefix);
23521: desret_xmlChar_ptr(ret_val);
23522: call_tests++;
23523: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
23524: des_xmlChar_ptr_ptr(n_prefix, prefix, 1);
23525: xmlResetLastError();
23526: if (mem_base != xmlMemBlocks()) {
23527: printf("Leak of %d blocks found in xmlSplitQName2",
23528: xmlMemBlocks() - mem_base);
23529: test_ret++;
23530: printf(" %d", n_name);
23531: printf(" %d", n_prefix);
23532: printf("\n");
23533: }
23534: }
23535: }
23536: function_tests++;
23537:
23538: return(test_ret);
23539: }
23540:
23541:
23542: static int
23543: test_xmlSplitQName3(void) {
23544: int test_ret = 0;
23545:
23546: int mem_base;
23547: const xmlChar * ret_val;
23548: xmlChar * name; /* the full QName */
23549: int n_name;
23550: int * len; /* an int * */
23551: int n_len;
23552:
23553: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
23554: for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
23555: mem_base = xmlMemBlocks();
23556: name = gen_const_xmlChar_ptr(n_name, 0);
23557: len = gen_int_ptr(n_len, 1);
23558:
23559: ret_val = xmlSplitQName3((const xmlChar *)name, len);
23560: desret_const_xmlChar_ptr(ret_val);
23561: call_tests++;
23562: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
23563: des_int_ptr(n_len, len, 1);
23564: xmlResetLastError();
23565: if (mem_base != xmlMemBlocks()) {
23566: printf("Leak of %d blocks found in xmlSplitQName3",
23567: xmlMemBlocks() - mem_base);
23568: test_ret++;
23569: printf(" %d", n_name);
23570: printf(" %d", n_len);
23571: printf("\n");
23572: }
23573: }
23574: }
23575: function_tests++;
23576:
23577: return(test_ret);
23578: }
23579:
23580:
23581: static int
23582: test_xmlStringGetNodeList(void) {
23583: int test_ret = 0;
23584:
23585: int mem_base;
23586: xmlNodePtr ret_val;
23587: xmlDocPtr doc; /* the document */
23588: int n_doc;
23589: xmlChar * value; /* the value of the attribute */
23590: int n_value;
23591:
23592: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
23593: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
23594: mem_base = xmlMemBlocks();
23595: doc = gen_xmlDocPtr(n_doc, 0);
23596: value = gen_const_xmlChar_ptr(n_value, 1);
23597:
23598: ret_val = xmlStringGetNodeList(doc, (const xmlChar *)value);
23599: desret_xmlNodePtr(ret_val);
23600: call_tests++;
23601: des_xmlDocPtr(n_doc, doc, 0);
23602: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
23603: xmlResetLastError();
23604: if (mem_base != xmlMemBlocks()) {
23605: printf("Leak of %d blocks found in xmlStringGetNodeList",
23606: xmlMemBlocks() - mem_base);
23607: test_ret++;
23608: printf(" %d", n_doc);
23609: printf(" %d", n_value);
23610: printf("\n");
23611: }
23612: }
23613: }
23614: function_tests++;
23615:
23616: return(test_ret);
23617: }
23618:
23619:
23620: static int
23621: test_xmlStringLenGetNodeList(void) {
23622: int test_ret = 0;
23623:
23624: int mem_base;
23625: xmlNodePtr ret_val;
23626: xmlDocPtr doc; /* the document */
23627: int n_doc;
23628: xmlChar * value; /* the value of the text */
23629: int n_value;
23630: int len; /* the length of the string value */
23631: int n_len;
23632:
23633: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
23634: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
23635: for (n_len = 0;n_len < gen_nb_int;n_len++) {
23636: mem_base = xmlMemBlocks();
23637: doc = gen_xmlDocPtr(n_doc, 0);
23638: value = gen_const_xmlChar_ptr(n_value, 1);
23639: len = gen_int(n_len, 2);
23640:
23641: ret_val = xmlStringLenGetNodeList(doc, (const xmlChar *)value, len);
23642: desret_xmlNodePtr(ret_val);
23643: call_tests++;
23644: des_xmlDocPtr(n_doc, doc, 0);
23645: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
23646: des_int(n_len, len, 2);
23647: xmlResetLastError();
23648: if (mem_base != xmlMemBlocks()) {
23649: printf("Leak of %d blocks found in xmlStringLenGetNodeList",
23650: xmlMemBlocks() - mem_base);
23651: test_ret++;
23652: printf(" %d", n_doc);
23653: printf(" %d", n_value);
23654: printf(" %d", n_len);
23655: printf("\n");
23656: }
23657: }
23658: }
23659: }
23660: function_tests++;
23661:
23662: return(test_ret);
23663: }
23664:
23665:
23666: static int
23667: test_xmlTextConcat(void) {
23668: int test_ret = 0;
23669:
23670: int mem_base;
23671: int ret_val;
23672: xmlNodePtr node; /* the node */
23673: int n_node;
23674: xmlChar * content; /* the content */
23675: int n_content;
23676: int len; /* @content length */
23677: int n_len;
23678:
23679: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
23680: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
23681: for (n_len = 0;n_len < gen_nb_int;n_len++) {
23682: mem_base = xmlMemBlocks();
23683: node = gen_xmlNodePtr(n_node, 0);
23684: content = gen_const_xmlChar_ptr(n_content, 1);
23685: len = gen_int(n_len, 2);
23686:
23687: ret_val = xmlTextConcat(node, (const xmlChar *)content, len);
23688: desret_int(ret_val);
23689: call_tests++;
23690: des_xmlNodePtr(n_node, node, 0);
23691: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
23692: des_int(n_len, len, 2);
23693: xmlResetLastError();
23694: if (mem_base != xmlMemBlocks()) {
23695: printf("Leak of %d blocks found in xmlTextConcat",
23696: xmlMemBlocks() - mem_base);
23697: test_ret++;
23698: printf(" %d", n_node);
23699: printf(" %d", n_content);
23700: printf(" %d", n_len);
23701: printf("\n");
23702: }
23703: }
23704: }
23705: }
23706: function_tests++;
23707:
23708: return(test_ret);
23709: }
23710:
23711:
23712: static int
23713: test_xmlTextMerge(void) {
23714: int test_ret = 0;
23715:
23716: int mem_base;
23717: xmlNodePtr ret_val;
23718: xmlNodePtr first; /* the first text node */
23719: int n_first;
23720: xmlNodePtr second; /* the second text node being merged */
23721: int n_second;
23722:
23723: for (n_first = 0;n_first < gen_nb_xmlNodePtr_in;n_first++) {
23724: for (n_second = 0;n_second < gen_nb_xmlNodePtr_in;n_second++) {
23725: mem_base = xmlMemBlocks();
23726: first = gen_xmlNodePtr_in(n_first, 0);
23727: second = gen_xmlNodePtr_in(n_second, 1);
23728:
23729: ret_val = xmlTextMerge(first, second);
23730: if ((first != NULL) && (first->type != XML_TEXT_NODE)) {
23731: xmlUnlinkNode(second);
23732: xmlFreeNode(second) ; second = NULL ; }
23733: desret_xmlNodePtr(ret_val);
23734: call_tests++;
23735: des_xmlNodePtr_in(n_first, first, 0);
23736: des_xmlNodePtr_in(n_second, second, 1);
23737: xmlResetLastError();
23738: if (mem_base != xmlMemBlocks()) {
23739: printf("Leak of %d blocks found in xmlTextMerge",
23740: xmlMemBlocks() - mem_base);
23741: test_ret++;
23742: printf(" %d", n_first);
23743: printf(" %d", n_second);
23744: printf("\n");
23745: }
23746: }
23747: }
23748: function_tests++;
23749:
23750: return(test_ret);
23751: }
23752:
23753:
23754: static int
23755: test_xmlUnsetNsProp(void) {
23756: int test_ret = 0;
23757:
23758: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
23759: int mem_base;
23760: int ret_val;
23761: xmlNodePtr node; /* the node */
23762: int n_node;
23763: xmlNsPtr ns; /* the namespace definition */
23764: int n_ns;
23765: xmlChar * name; /* the attribute name */
23766: int n_name;
23767:
23768: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
23769: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
23770: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
23771: mem_base = xmlMemBlocks();
23772: node = gen_xmlNodePtr(n_node, 0);
23773: ns = gen_xmlNsPtr(n_ns, 1);
23774: name = gen_const_xmlChar_ptr(n_name, 2);
23775:
23776: ret_val = xmlUnsetNsProp(node, ns, (const xmlChar *)name);
23777: desret_int(ret_val);
23778: call_tests++;
23779: des_xmlNodePtr(n_node, node, 0);
23780: des_xmlNsPtr(n_ns, ns, 1);
23781: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
23782: xmlResetLastError();
23783: if (mem_base != xmlMemBlocks()) {
23784: printf("Leak of %d blocks found in xmlUnsetNsProp",
23785: xmlMemBlocks() - mem_base);
23786: test_ret++;
23787: printf(" %d", n_node);
23788: printf(" %d", n_ns);
23789: printf(" %d", n_name);
23790: printf("\n");
23791: }
23792: }
23793: }
23794: }
23795: function_tests++;
23796: #endif
23797:
23798: return(test_ret);
23799: }
23800:
23801:
23802: static int
23803: test_xmlUnsetProp(void) {
23804: int test_ret = 0;
23805:
23806: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
23807: int mem_base;
23808: int ret_val;
23809: xmlNodePtr node; /* the node */
23810: int n_node;
23811: xmlChar * name; /* the attribute name */
23812: int n_name;
23813:
23814: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
23815: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
23816: mem_base = xmlMemBlocks();
23817: node = gen_xmlNodePtr(n_node, 0);
23818: name = gen_const_xmlChar_ptr(n_name, 1);
23819:
23820: ret_val = xmlUnsetProp(node, (const xmlChar *)name);
23821: desret_int(ret_val);
23822: call_tests++;
23823: des_xmlNodePtr(n_node, node, 0);
23824: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
23825: xmlResetLastError();
23826: if (mem_base != xmlMemBlocks()) {
23827: printf("Leak of %d blocks found in xmlUnsetProp",
23828: xmlMemBlocks() - mem_base);
23829: test_ret++;
23830: printf(" %d", n_node);
23831: printf(" %d", n_name);
23832: printf("\n");
23833: }
23834: }
23835: }
23836: function_tests++;
23837: #endif
23838:
23839: return(test_ret);
23840: }
23841:
23842:
23843: static int
23844: test_xmlValidateNCName(void) {
23845: int test_ret = 0;
23846:
23847: #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)
23848: #ifdef LIBXML_TREE_ENABLED
23849: int mem_base;
23850: int ret_val;
23851: xmlChar * value; /* the value to check */
23852: int n_value;
23853: int space; /* allow spaces in front and end of the string */
23854: int n_space;
23855:
23856: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
23857: for (n_space = 0;n_space < gen_nb_int;n_space++) {
23858: mem_base = xmlMemBlocks();
23859: value = gen_const_xmlChar_ptr(n_value, 0);
23860: space = gen_int(n_space, 1);
23861:
23862: ret_val = xmlValidateNCName((const xmlChar *)value, space);
23863: desret_int(ret_val);
23864: call_tests++;
23865: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
23866: des_int(n_space, space, 1);
23867: xmlResetLastError();
23868: if (mem_base != xmlMemBlocks()) {
23869: printf("Leak of %d blocks found in xmlValidateNCName",
23870: xmlMemBlocks() - mem_base);
23871: test_ret++;
23872: printf(" %d", n_value);
23873: printf(" %d", n_space);
23874: printf("\n");
23875: }
23876: }
23877: }
23878: function_tests++;
23879: #endif
23880: #endif
23881:
23882: return(test_ret);
23883: }
23884:
23885:
23886: static int
23887: test_xmlValidateNMToken(void) {
23888: int test_ret = 0;
23889:
23890: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
23891: #ifdef LIBXML_TREE_ENABLED
23892: int mem_base;
23893: int ret_val;
23894: xmlChar * value; /* the value to check */
23895: int n_value;
23896: int space; /* allow spaces in front and end of the string */
23897: int n_space;
23898:
23899: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
23900: for (n_space = 0;n_space < gen_nb_int;n_space++) {
23901: mem_base = xmlMemBlocks();
23902: value = gen_const_xmlChar_ptr(n_value, 0);
23903: space = gen_int(n_space, 1);
23904:
23905: ret_val = xmlValidateNMToken((const xmlChar *)value, space);
23906: desret_int(ret_val);
23907: call_tests++;
23908: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
23909: des_int(n_space, space, 1);
23910: xmlResetLastError();
23911: if (mem_base != xmlMemBlocks()) {
23912: printf("Leak of %d blocks found in xmlValidateNMToken",
23913: xmlMemBlocks() - mem_base);
23914: test_ret++;
23915: printf(" %d", n_value);
23916: printf(" %d", n_space);
23917: printf("\n");
23918: }
23919: }
23920: }
23921: function_tests++;
23922: #endif
23923: #endif
23924:
23925: return(test_ret);
23926: }
23927:
23928:
23929: static int
23930: test_xmlValidateName(void) {
23931: int test_ret = 0;
23932:
23933: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
23934: #ifdef LIBXML_TREE_ENABLED
23935: int mem_base;
23936: int ret_val;
23937: xmlChar * value; /* the value to check */
23938: int n_value;
23939: int space; /* allow spaces in front and end of the string */
23940: int n_space;
23941:
23942: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
23943: for (n_space = 0;n_space < gen_nb_int;n_space++) {
23944: mem_base = xmlMemBlocks();
23945: value = gen_const_xmlChar_ptr(n_value, 0);
23946: space = gen_int(n_space, 1);
23947:
23948: ret_val = xmlValidateName((const xmlChar *)value, space);
23949: desret_int(ret_val);
23950: call_tests++;
23951: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
23952: des_int(n_space, space, 1);
23953: xmlResetLastError();
23954: if (mem_base != xmlMemBlocks()) {
23955: printf("Leak of %d blocks found in xmlValidateName",
23956: xmlMemBlocks() - mem_base);
23957: test_ret++;
23958: printf(" %d", n_value);
23959: printf(" %d", n_space);
23960: printf("\n");
23961: }
23962: }
23963: }
23964: function_tests++;
23965: #endif
23966: #endif
23967:
23968: return(test_ret);
23969: }
23970:
23971:
23972: static int
23973: test_xmlValidateQName(void) {
23974: int test_ret = 0;
23975:
23976: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
23977: #ifdef LIBXML_TREE_ENABLED
23978: int mem_base;
23979: int ret_val;
23980: xmlChar * value; /* the value to check */
23981: int n_value;
23982: int space; /* allow spaces in front and end of the string */
23983: int n_space;
23984:
23985: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
23986: for (n_space = 0;n_space < gen_nb_int;n_space++) {
23987: mem_base = xmlMemBlocks();
23988: value = gen_const_xmlChar_ptr(n_value, 0);
23989: space = gen_int(n_space, 1);
23990:
23991: ret_val = xmlValidateQName((const xmlChar *)value, space);
23992: desret_int(ret_val);
23993: call_tests++;
23994: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
23995: des_int(n_space, space, 1);
23996: xmlResetLastError();
23997: if (mem_base != xmlMemBlocks()) {
23998: printf("Leak of %d blocks found in xmlValidateQName",
23999: xmlMemBlocks() - mem_base);
24000: test_ret++;
24001: printf(" %d", n_value);
24002: printf(" %d", n_space);
24003: printf("\n");
24004: }
24005: }
24006: }
24007: function_tests++;
24008: #endif
24009: #endif
24010:
24011: return(test_ret);
24012: }
24013:
24014: static int
24015: test_tree(void) {
24016: int test_ret = 0;
24017:
1.1.1.2 ! misho 24018: if (quiet == 0) printf("Testing tree : 139 of 158 functions ...\n");
1.1 misho 24019: test_ret += test_xmlAddChild();
24020: test_ret += test_xmlAddChildList();
24021: test_ret += test_xmlAddNextSibling();
24022: test_ret += test_xmlAddPrevSibling();
24023: test_ret += test_xmlAddSibling();
24024: test_ret += test_xmlAttrSerializeTxtContent();
24025: test_ret += test_xmlBufferAdd();
24026: test_ret += test_xmlBufferAddHead();
24027: test_ret += test_xmlBufferCCat();
24028: test_ret += test_xmlBufferCat();
24029: test_ret += test_xmlBufferContent();
24030: test_ret += test_xmlBufferCreate();
24031: test_ret += test_xmlBufferCreateSize();
24032: test_ret += test_xmlBufferCreateStatic();
1.1.1.2 ! misho 24033: test_ret += test_xmlBufferDetach();
1.1 misho 24034: test_ret += test_xmlBufferEmpty();
24035: test_ret += test_xmlBufferGrow();
24036: test_ret += test_xmlBufferLength();
24037: test_ret += test_xmlBufferResize();
24038: test_ret += test_xmlBufferSetAllocationScheme();
24039: test_ret += test_xmlBufferShrink();
24040: test_ret += test_xmlBufferWriteCHAR();
24041: test_ret += test_xmlBufferWriteChar();
24042: test_ret += test_xmlBufferWriteQuotedString();
24043: test_ret += test_xmlBuildQName();
24044: test_ret += test_xmlChildElementCount();
24045: test_ret += test_xmlCopyDoc();
24046: test_ret += test_xmlCopyDtd();
24047: test_ret += test_xmlCopyNamespace();
24048: test_ret += test_xmlCopyNamespaceList();
24049: test_ret += test_xmlCopyNode();
24050: test_ret += test_xmlCopyNodeList();
24051: test_ret += test_xmlCopyProp();
24052: test_ret += test_xmlCopyPropList();
24053: test_ret += test_xmlCreateIntSubset();
24054: test_ret += test_xmlDOMWrapAdoptNode();
24055: test_ret += test_xmlDOMWrapCloneNode();
24056: test_ret += test_xmlDOMWrapNewCtxt();
24057: test_ret += test_xmlDOMWrapReconcileNamespaces();
24058: test_ret += test_xmlDOMWrapRemoveNode();
24059: test_ret += test_xmlDocCopyNode();
24060: test_ret += test_xmlDocCopyNodeList();
24061: test_ret += test_xmlDocDump();
24062: test_ret += test_xmlDocDumpFormatMemory();
24063: test_ret += test_xmlDocDumpFormatMemoryEnc();
24064: test_ret += test_xmlDocDumpMemory();
24065: test_ret += test_xmlDocDumpMemoryEnc();
24066: test_ret += test_xmlDocFormatDump();
24067: test_ret += test_xmlDocGetRootElement();
24068: test_ret += test_xmlDocSetRootElement();
24069: test_ret += test_xmlElemDump();
24070: test_ret += test_xmlFirstElementChild();
24071: test_ret += test_xmlGetBufferAllocationScheme();
24072: test_ret += test_xmlGetCompressMode();
24073: test_ret += test_xmlGetDocCompressMode();
24074: test_ret += test_xmlGetIntSubset();
24075: test_ret += test_xmlGetLastChild();
24076: test_ret += test_xmlGetLineNo();
24077: test_ret += test_xmlGetNoNsProp();
24078: test_ret += test_xmlGetNodePath();
24079: test_ret += test_xmlGetNsList();
24080: test_ret += test_xmlGetNsProp();
24081: test_ret += test_xmlGetProp();
24082: test_ret += test_xmlHasNsProp();
24083: test_ret += test_xmlHasProp();
24084: test_ret += test_xmlIsBlankNode();
24085: test_ret += test_xmlIsXHTML();
24086: test_ret += test_xmlLastElementChild();
24087: test_ret += test_xmlNewCDataBlock();
24088: test_ret += test_xmlNewCharRef();
24089: test_ret += test_xmlNewChild();
24090: test_ret += test_xmlNewComment();
24091: test_ret += test_xmlNewDoc();
24092: test_ret += test_xmlNewDocComment();
24093: test_ret += test_xmlNewDocFragment();
24094: test_ret += test_xmlNewDocNode();
24095: test_ret += test_xmlNewDocNodeEatName();
24096: test_ret += test_xmlNewDocPI();
24097: test_ret += test_xmlNewDocProp();
24098: test_ret += test_xmlNewDocRawNode();
24099: test_ret += test_xmlNewDocText();
24100: test_ret += test_xmlNewDocTextLen();
24101: test_ret += test_xmlNewDtd();
24102: test_ret += test_xmlNewNode();
24103: test_ret += test_xmlNewNodeEatName();
24104: test_ret += test_xmlNewNs();
24105: test_ret += test_xmlNewNsProp();
24106: test_ret += test_xmlNewNsPropEatName();
24107: test_ret += test_xmlNewPI();
24108: test_ret += test_xmlNewProp();
24109: test_ret += test_xmlNewReference();
24110: test_ret += test_xmlNewText();
24111: test_ret += test_xmlNewTextChild();
24112: test_ret += test_xmlNewTextLen();
24113: test_ret += test_xmlNextElementSibling();
24114: test_ret += test_xmlNodeAddContent();
24115: test_ret += test_xmlNodeAddContentLen();
24116: test_ret += test_xmlNodeBufGetContent();
24117: test_ret += test_xmlNodeDump();
24118: test_ret += test_xmlNodeDumpOutput();
24119: test_ret += test_xmlNodeGetBase();
24120: test_ret += test_xmlNodeGetContent();
24121: test_ret += test_xmlNodeGetLang();
24122: test_ret += test_xmlNodeGetSpacePreserve();
24123: test_ret += test_xmlNodeIsText();
24124: test_ret += test_xmlNodeListGetRawString();
24125: test_ret += test_xmlNodeListGetString();
24126: test_ret += test_xmlNodeSetBase();
24127: test_ret += test_xmlNodeSetContent();
24128: test_ret += test_xmlNodeSetContentLen();
24129: test_ret += test_xmlNodeSetLang();
24130: test_ret += test_xmlNodeSetName();
24131: test_ret += test_xmlNodeSetSpacePreserve();
24132: test_ret += test_xmlPreviousElementSibling();
24133: test_ret += test_xmlReconciliateNs();
24134: test_ret += test_xmlRemoveProp();
24135: test_ret += test_xmlReplaceNode();
24136: test_ret += test_xmlSaveFile();
24137: test_ret += test_xmlSaveFileEnc();
24138: test_ret += test_xmlSaveFileTo();
24139: test_ret += test_xmlSaveFormatFile();
24140: test_ret += test_xmlSaveFormatFileEnc();
24141: test_ret += test_xmlSaveFormatFileTo();
24142: test_ret += test_xmlSearchNs();
24143: test_ret += test_xmlSearchNsByHref();
24144: test_ret += test_xmlSetBufferAllocationScheme();
24145: test_ret += test_xmlSetCompressMode();
24146: test_ret += test_xmlSetDocCompressMode();
24147: test_ret += test_xmlSetNs();
24148: test_ret += test_xmlSetNsProp();
24149: test_ret += test_xmlSetProp();
24150: test_ret += test_xmlSplitQName2();
24151: test_ret += test_xmlSplitQName3();
24152: test_ret += test_xmlStringGetNodeList();
24153: test_ret += test_xmlStringLenGetNodeList();
24154: test_ret += test_xmlTextConcat();
24155: test_ret += test_xmlTextMerge();
24156: test_ret += test_xmlUnsetNsProp();
24157: test_ret += test_xmlUnsetProp();
24158: test_ret += test_xmlValidateNCName();
24159: test_ret += test_xmlValidateNMToken();
24160: test_ret += test_xmlValidateName();
24161: test_ret += test_xmlValidateQName();
24162:
24163: if (test_ret != 0)
24164: printf("Module tree: %d errors\n", test_ret);
24165: return(test_ret);
24166: }
24167:
24168: static int
24169: test_xmlBuildRelativeURI(void) {
24170: int test_ret = 0;
24171:
24172: int mem_base;
24173: xmlChar * ret_val;
24174: xmlChar * URI; /* the URI reference under consideration */
24175: int n_URI;
24176: xmlChar * base; /* the base value */
24177: int n_base;
24178:
24179: for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
24180: for (n_base = 0;n_base < gen_nb_const_xmlChar_ptr;n_base++) {
24181: mem_base = xmlMemBlocks();
24182: URI = gen_const_xmlChar_ptr(n_URI, 0);
24183: base = gen_const_xmlChar_ptr(n_base, 1);
24184:
24185: ret_val = xmlBuildRelativeURI((const xmlChar *)URI, (const xmlChar *)base);
24186: desret_xmlChar_ptr(ret_val);
24187: call_tests++;
24188: des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 0);
24189: des_const_xmlChar_ptr(n_base, (const xmlChar *)base, 1);
24190: xmlResetLastError();
24191: if (mem_base != xmlMemBlocks()) {
24192: printf("Leak of %d blocks found in xmlBuildRelativeURI",
24193: xmlMemBlocks() - mem_base);
24194: test_ret++;
24195: printf(" %d", n_URI);
24196: printf(" %d", n_base);
24197: printf("\n");
24198: }
24199: }
24200: }
24201: function_tests++;
24202:
24203: return(test_ret);
24204: }
24205:
24206:
24207: static int
24208: test_xmlBuildURI(void) {
24209: int test_ret = 0;
24210:
24211: int mem_base;
24212: xmlChar * ret_val;
24213: xmlChar * URI; /* the URI instance found in the document */
24214: int n_URI;
24215: xmlChar * base; /* the base value */
24216: int n_base;
24217:
24218: for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
24219: for (n_base = 0;n_base < gen_nb_const_xmlChar_ptr;n_base++) {
24220: mem_base = xmlMemBlocks();
24221: URI = gen_const_xmlChar_ptr(n_URI, 0);
24222: base = gen_const_xmlChar_ptr(n_base, 1);
24223:
24224: ret_val = xmlBuildURI((const xmlChar *)URI, (const xmlChar *)base);
24225: desret_xmlChar_ptr(ret_val);
24226: call_tests++;
24227: des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 0);
24228: des_const_xmlChar_ptr(n_base, (const xmlChar *)base, 1);
24229: xmlResetLastError();
24230: if (mem_base != xmlMemBlocks()) {
24231: printf("Leak of %d blocks found in xmlBuildURI",
24232: xmlMemBlocks() - mem_base);
24233: test_ret++;
24234: printf(" %d", n_URI);
24235: printf(" %d", n_base);
24236: printf("\n");
24237: }
24238: }
24239: }
24240: function_tests++;
24241:
24242: return(test_ret);
24243: }
24244:
24245:
24246: static int
24247: test_xmlCanonicPath(void) {
24248: int test_ret = 0;
24249:
24250: int mem_base;
24251: xmlChar * ret_val;
24252: xmlChar * path; /* the resource locator in a filesystem notation */
24253: int n_path;
24254:
24255: for (n_path = 0;n_path < gen_nb_const_xmlChar_ptr;n_path++) {
24256: mem_base = xmlMemBlocks();
24257: path = gen_const_xmlChar_ptr(n_path, 0);
24258:
24259: ret_val = xmlCanonicPath((const xmlChar *)path);
24260: desret_xmlChar_ptr(ret_val);
24261: call_tests++;
24262: des_const_xmlChar_ptr(n_path, (const xmlChar *)path, 0);
24263: xmlResetLastError();
24264: if (mem_base != xmlMemBlocks()) {
24265: printf("Leak of %d blocks found in xmlCanonicPath",
24266: xmlMemBlocks() - mem_base);
24267: test_ret++;
24268: printf(" %d", n_path);
24269: printf("\n");
24270: }
24271: }
24272: function_tests++;
24273:
24274: return(test_ret);
24275: }
24276:
24277:
24278: static int
24279: test_xmlCreateURI(void) {
24280: int test_ret = 0;
24281:
24282:
24283: /* missing type support */
24284: return(test_ret);
24285: }
24286:
24287:
24288: static int
24289: test_xmlNormalizeURIPath(void) {
24290: int test_ret = 0;
24291:
24292: int mem_base;
24293: int ret_val;
24294: char * path; /* pointer to the path string */
24295: int n_path;
24296:
24297: for (n_path = 0;n_path < gen_nb_char_ptr;n_path++) {
24298: mem_base = xmlMemBlocks();
24299: path = gen_char_ptr(n_path, 0);
24300:
24301: ret_val = xmlNormalizeURIPath(path);
24302: desret_int(ret_val);
24303: call_tests++;
24304: des_char_ptr(n_path, path, 0);
24305: xmlResetLastError();
24306: if (mem_base != xmlMemBlocks()) {
24307: printf("Leak of %d blocks found in xmlNormalizeURIPath",
24308: xmlMemBlocks() - mem_base);
24309: test_ret++;
24310: printf(" %d", n_path);
24311: printf("\n");
24312: }
24313: }
24314: function_tests++;
24315:
24316: return(test_ret);
24317: }
24318:
24319:
24320: static int
24321: test_xmlParseURI(void) {
24322: int test_ret = 0;
24323:
24324:
24325: /* missing type support */
24326: return(test_ret);
24327: }
24328:
24329:
24330: static int
24331: test_xmlParseURIRaw(void) {
24332: int test_ret = 0;
24333:
24334:
24335: /* missing type support */
24336: return(test_ret);
24337: }
24338:
24339:
24340: #define gen_nb_xmlURIPtr 1
24341: static xmlURIPtr gen_xmlURIPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24342: return(NULL);
24343: }
24344: static void des_xmlURIPtr(int no ATTRIBUTE_UNUSED, xmlURIPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24345: }
24346:
24347: static int
24348: test_xmlParseURIReference(void) {
24349: int test_ret = 0;
24350:
24351: int mem_base;
24352: int ret_val;
24353: xmlURIPtr uri; /* pointer to an URI structure */
24354: int n_uri;
24355: char * str; /* the string to analyze */
24356: int n_str;
24357:
24358: for (n_uri = 0;n_uri < gen_nb_xmlURIPtr;n_uri++) {
24359: for (n_str = 0;n_str < gen_nb_const_char_ptr;n_str++) {
24360: mem_base = xmlMemBlocks();
24361: uri = gen_xmlURIPtr(n_uri, 0);
24362: str = gen_const_char_ptr(n_str, 1);
24363:
24364: ret_val = xmlParseURIReference(uri, (const char *)str);
24365: desret_int(ret_val);
24366: call_tests++;
24367: des_xmlURIPtr(n_uri, uri, 0);
24368: des_const_char_ptr(n_str, (const char *)str, 1);
24369: xmlResetLastError();
24370: if (mem_base != xmlMemBlocks()) {
24371: printf("Leak of %d blocks found in xmlParseURIReference",
24372: xmlMemBlocks() - mem_base);
24373: test_ret++;
24374: printf(" %d", n_uri);
24375: printf(" %d", n_str);
24376: printf("\n");
24377: }
24378: }
24379: }
24380: function_tests++;
24381:
24382: return(test_ret);
24383: }
24384:
24385:
24386: static int
24387: test_xmlPathToURI(void) {
24388: int test_ret = 0;
24389:
24390: int mem_base;
24391: xmlChar * ret_val;
24392: xmlChar * path; /* the resource locator in a filesystem notation */
24393: int n_path;
24394:
24395: for (n_path = 0;n_path < gen_nb_const_xmlChar_ptr;n_path++) {
24396: mem_base = xmlMemBlocks();
24397: path = gen_const_xmlChar_ptr(n_path, 0);
24398:
24399: ret_val = xmlPathToURI((const xmlChar *)path);
24400: desret_xmlChar_ptr(ret_val);
24401: call_tests++;
24402: des_const_xmlChar_ptr(n_path, (const xmlChar *)path, 0);
24403: xmlResetLastError();
24404: if (mem_base != xmlMemBlocks()) {
24405: printf("Leak of %d blocks found in xmlPathToURI",
24406: xmlMemBlocks() - mem_base);
24407: test_ret++;
24408: printf(" %d", n_path);
24409: printf("\n");
24410: }
24411: }
24412: function_tests++;
24413:
24414: return(test_ret);
24415: }
24416:
24417:
24418: static int
24419: test_xmlPrintURI(void) {
24420: int test_ret = 0;
24421:
24422: int mem_base;
24423: FILE * stream; /* a FILE* for the output */
24424: int n_stream;
24425: xmlURIPtr uri; /* pointer to an xmlURI */
24426: int n_uri;
24427:
24428: for (n_stream = 0;n_stream < gen_nb_FILE_ptr;n_stream++) {
24429: for (n_uri = 0;n_uri < gen_nb_xmlURIPtr;n_uri++) {
24430: mem_base = xmlMemBlocks();
24431: stream = gen_FILE_ptr(n_stream, 0);
24432: uri = gen_xmlURIPtr(n_uri, 1);
24433:
24434: xmlPrintURI(stream, uri);
24435: call_tests++;
24436: des_FILE_ptr(n_stream, stream, 0);
24437: des_xmlURIPtr(n_uri, uri, 1);
24438: xmlResetLastError();
24439: if (mem_base != xmlMemBlocks()) {
24440: printf("Leak of %d blocks found in xmlPrintURI",
24441: xmlMemBlocks() - mem_base);
24442: test_ret++;
24443: printf(" %d", n_stream);
24444: printf(" %d", n_uri);
24445: printf("\n");
24446: }
24447: }
24448: }
24449: function_tests++;
24450:
24451: return(test_ret);
24452: }
24453:
24454:
24455: static int
24456: test_xmlSaveUri(void) {
24457: int test_ret = 0;
24458:
24459: int mem_base;
24460: xmlChar * ret_val;
24461: xmlURIPtr uri; /* pointer to an xmlURI */
24462: int n_uri;
24463:
24464: for (n_uri = 0;n_uri < gen_nb_xmlURIPtr;n_uri++) {
24465: mem_base = xmlMemBlocks();
24466: uri = gen_xmlURIPtr(n_uri, 0);
24467:
24468: ret_val = xmlSaveUri(uri);
24469: desret_xmlChar_ptr(ret_val);
24470: call_tests++;
24471: des_xmlURIPtr(n_uri, uri, 0);
24472: xmlResetLastError();
24473: if (mem_base != xmlMemBlocks()) {
24474: printf("Leak of %d blocks found in xmlSaveUri",
24475: xmlMemBlocks() - mem_base);
24476: test_ret++;
24477: printf(" %d", n_uri);
24478: printf("\n");
24479: }
24480: }
24481: function_tests++;
24482:
24483: return(test_ret);
24484: }
24485:
24486:
24487: static int
24488: test_xmlURIEscape(void) {
24489: int test_ret = 0;
24490:
24491: int mem_base;
24492: xmlChar * ret_val;
24493: xmlChar * str; /* the string of the URI to escape */
24494: int n_str;
24495:
24496: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
24497: mem_base = xmlMemBlocks();
24498: str = gen_const_xmlChar_ptr(n_str, 0);
24499:
24500: ret_val = xmlURIEscape((const xmlChar *)str);
24501: desret_xmlChar_ptr(ret_val);
24502: call_tests++;
24503: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
24504: xmlResetLastError();
24505: if (mem_base != xmlMemBlocks()) {
24506: printf("Leak of %d blocks found in xmlURIEscape",
24507: xmlMemBlocks() - mem_base);
24508: test_ret++;
24509: printf(" %d", n_str);
24510: printf("\n");
24511: }
24512: }
24513: function_tests++;
24514:
24515: return(test_ret);
24516: }
24517:
24518:
24519: static int
24520: test_xmlURIEscapeStr(void) {
24521: int test_ret = 0;
24522:
24523: int mem_base;
24524: xmlChar * ret_val;
24525: xmlChar * str; /* string to escape */
24526: int n_str;
24527: xmlChar * list; /* exception list string of chars not to escape */
24528: int n_list;
24529:
24530: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
24531: for (n_list = 0;n_list < gen_nb_const_xmlChar_ptr;n_list++) {
24532: mem_base = xmlMemBlocks();
24533: str = gen_const_xmlChar_ptr(n_str, 0);
24534: list = gen_const_xmlChar_ptr(n_list, 1);
24535:
24536: ret_val = xmlURIEscapeStr((const xmlChar *)str, (const xmlChar *)list);
24537: desret_xmlChar_ptr(ret_val);
24538: call_tests++;
24539: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
24540: des_const_xmlChar_ptr(n_list, (const xmlChar *)list, 1);
24541: xmlResetLastError();
24542: if (mem_base != xmlMemBlocks()) {
24543: printf("Leak of %d blocks found in xmlURIEscapeStr",
24544: xmlMemBlocks() - mem_base);
24545: test_ret++;
24546: printf(" %d", n_str);
24547: printf(" %d", n_list);
24548: printf("\n");
24549: }
24550: }
24551: }
24552: function_tests++;
24553:
24554: return(test_ret);
24555: }
24556:
24557:
24558: static int
24559: test_xmlURIUnescapeString(void) {
24560: int test_ret = 0;
24561:
24562:
24563: /* missing type support */
24564: return(test_ret);
24565: }
24566:
24567: static int
24568: test_uri(void) {
24569: int test_ret = 0;
24570:
24571: if (quiet == 0) printf("Testing uri : 10 of 15 functions ...\n");
24572: test_ret += test_xmlBuildRelativeURI();
24573: test_ret += test_xmlBuildURI();
24574: test_ret += test_xmlCanonicPath();
24575: test_ret += test_xmlCreateURI();
24576: test_ret += test_xmlNormalizeURIPath();
24577: test_ret += test_xmlParseURI();
24578: test_ret += test_xmlParseURIRaw();
24579: test_ret += test_xmlParseURIReference();
24580: test_ret += test_xmlPathToURI();
24581: test_ret += test_xmlPrintURI();
24582: test_ret += test_xmlSaveUri();
24583: test_ret += test_xmlURIEscape();
24584: test_ret += test_xmlURIEscapeStr();
24585: test_ret += test_xmlURIUnescapeString();
24586:
24587: if (test_ret != 0)
24588: printf("Module uri: %d errors\n", test_ret);
24589: return(test_ret);
24590: }
24591:
24592: static int
24593: test_xmlAddAttributeDecl(void) {
24594: int test_ret = 0;
24595:
24596: int mem_base;
24597: xmlAttributePtr ret_val;
24598: xmlValidCtxtPtr ctxt; /* the validation context */
24599: int n_ctxt;
24600: xmlDtdPtr dtd; /* pointer to the DTD */
24601: int n_dtd;
24602: xmlChar * elem; /* the element name */
24603: int n_elem;
24604: xmlChar * name; /* the attribute name */
24605: int n_name;
24606: xmlChar * ns; /* the attribute namespace prefix */
24607: int n_ns;
24608: xmlAttributeType type; /* the attribute type */
24609: int n_type;
24610: xmlAttributeDefault def; /* the attribute default type */
24611: int n_def;
24612: xmlChar * defaultValue; /* the attribute default value */
24613: int n_defaultValue;
24614: xmlEnumerationPtr tree; /* if it's an enumeration, the associated list */
24615: int n_tree;
24616:
24617: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
24618: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
24619: for (n_elem = 0;n_elem < gen_nb_const_xmlChar_ptr;n_elem++) {
24620: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
24621: for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) {
24622: for (n_type = 0;n_type < gen_nb_xmlAttributeType;n_type++) {
24623: for (n_def = 0;n_def < gen_nb_xmlAttributeDefault;n_def++) {
24624: for (n_defaultValue = 0;n_defaultValue < gen_nb_const_xmlChar_ptr;n_defaultValue++) {
24625: for (n_tree = 0;n_tree < gen_nb_xmlEnumerationPtr;n_tree++) {
24626: mem_base = xmlMemBlocks();
24627: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
24628: dtd = gen_xmlDtdPtr(n_dtd, 1);
24629: elem = gen_const_xmlChar_ptr(n_elem, 2);
24630: name = gen_const_xmlChar_ptr(n_name, 3);
24631: ns = gen_const_xmlChar_ptr(n_ns, 4);
24632: type = gen_xmlAttributeType(n_type, 5);
24633: def = gen_xmlAttributeDefault(n_def, 6);
24634: defaultValue = gen_const_xmlChar_ptr(n_defaultValue, 7);
24635: tree = gen_xmlEnumerationPtr(n_tree, 8);
24636:
24637: ret_val = xmlAddAttributeDecl(ctxt, dtd, (const xmlChar *)elem, (const xmlChar *)name, (const xmlChar *)ns, type, def, (const xmlChar *)defaultValue, tree);
24638: desret_xmlAttributePtr(ret_val);
24639: call_tests++;
24640: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
24641: des_xmlDtdPtr(n_dtd, dtd, 1);
24642: des_const_xmlChar_ptr(n_elem, (const xmlChar *)elem, 2);
24643: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 3);
24644: des_const_xmlChar_ptr(n_ns, (const xmlChar *)ns, 4);
24645: des_xmlAttributeType(n_type, type, 5);
24646: des_xmlAttributeDefault(n_def, def, 6);
24647: des_const_xmlChar_ptr(n_defaultValue, (const xmlChar *)defaultValue, 7);
24648: des_xmlEnumerationPtr(n_tree, tree, 8);
24649: xmlResetLastError();
24650: if (mem_base != xmlMemBlocks()) {
24651: printf("Leak of %d blocks found in xmlAddAttributeDecl",
24652: xmlMemBlocks() - mem_base);
24653: test_ret++;
24654: printf(" %d", n_ctxt);
24655: printf(" %d", n_dtd);
24656: printf(" %d", n_elem);
24657: printf(" %d", n_name);
24658: printf(" %d", n_ns);
24659: printf(" %d", n_type);
24660: printf(" %d", n_def);
24661: printf(" %d", n_defaultValue);
24662: printf(" %d", n_tree);
24663: printf("\n");
24664: }
24665: }
24666: }
24667: }
24668: }
24669: }
24670: }
24671: }
24672: }
24673: }
24674: function_tests++;
24675:
24676: return(test_ret);
24677: }
24678:
24679:
24680: static int
24681: test_xmlAddElementDecl(void) {
24682: int test_ret = 0;
24683:
24684: int mem_base;
24685: xmlElementPtr ret_val;
24686: xmlValidCtxtPtr ctxt; /* the validation context */
24687: int n_ctxt;
24688: xmlDtdPtr dtd; /* pointer to the DTD */
24689: int n_dtd;
24690: xmlChar * name; /* the entity name */
24691: int n_name;
24692: xmlElementTypeVal type; /* the element type */
24693: int n_type;
24694: xmlElementContentPtr content; /* the element content tree or NULL */
24695: int n_content;
24696:
24697: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
24698: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
24699: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
24700: for (n_type = 0;n_type < gen_nb_xmlElementTypeVal;n_type++) {
24701: for (n_content = 0;n_content < gen_nb_xmlElementContentPtr;n_content++) {
24702: mem_base = xmlMemBlocks();
24703: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
24704: dtd = gen_xmlDtdPtr(n_dtd, 1);
24705: name = gen_const_xmlChar_ptr(n_name, 2);
24706: type = gen_xmlElementTypeVal(n_type, 3);
24707: content = gen_xmlElementContentPtr(n_content, 4);
24708:
24709: ret_val = xmlAddElementDecl(ctxt, dtd, (const xmlChar *)name, type, content);
24710: desret_xmlElementPtr(ret_val);
24711: call_tests++;
24712: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
24713: des_xmlDtdPtr(n_dtd, dtd, 1);
24714: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
24715: des_xmlElementTypeVal(n_type, type, 3);
24716: des_xmlElementContentPtr(n_content, content, 4);
24717: xmlResetLastError();
24718: if (mem_base != xmlMemBlocks()) {
24719: printf("Leak of %d blocks found in xmlAddElementDecl",
24720: xmlMemBlocks() - mem_base);
24721: test_ret++;
24722: printf(" %d", n_ctxt);
24723: printf(" %d", n_dtd);
24724: printf(" %d", n_name);
24725: printf(" %d", n_type);
24726: printf(" %d", n_content);
24727: printf("\n");
24728: }
24729: }
24730: }
24731: }
24732: }
24733: }
24734: function_tests++;
24735:
24736: return(test_ret);
24737: }
24738:
24739:
24740: static int
24741: test_xmlAddID(void) {
24742: int test_ret = 0;
24743:
24744:
24745: /* missing type support */
24746: return(test_ret);
24747: }
24748:
24749:
24750: static int
24751: test_xmlAddNotationDecl(void) {
24752: int test_ret = 0;
24753:
24754:
24755: /* missing type support */
24756: return(test_ret);
24757: }
24758:
24759:
24760: static int
24761: test_xmlAddRef(void) {
24762: int test_ret = 0;
24763:
24764:
24765: /* missing type support */
24766: return(test_ret);
24767: }
24768:
24769:
24770: #define gen_nb_xmlAttributeTablePtr 1
24771: static xmlAttributeTablePtr gen_xmlAttributeTablePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24772: return(NULL);
24773: }
24774: static void des_xmlAttributeTablePtr(int no ATTRIBUTE_UNUSED, xmlAttributeTablePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24775: }
24776:
24777: static int
24778: test_xmlCopyAttributeTable(void) {
24779: int test_ret = 0;
24780:
24781:
24782: /* missing type support */
24783: return(test_ret);
24784: }
24785:
24786:
24787: static int
24788: test_xmlCopyDocElementContent(void) {
24789: int test_ret = 0;
24790:
24791: int mem_base;
24792: xmlElementContentPtr ret_val;
24793: xmlDocPtr doc; /* the document owning the element declaration */
24794: int n_doc;
24795: xmlElementContentPtr cur; /* An element content pointer. */
24796: int n_cur;
24797:
24798: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
24799: for (n_cur = 0;n_cur < gen_nb_xmlElementContentPtr;n_cur++) {
24800: mem_base = xmlMemBlocks();
24801: doc = gen_xmlDocPtr(n_doc, 0);
24802: cur = gen_xmlElementContentPtr(n_cur, 1);
24803:
24804: ret_val = xmlCopyDocElementContent(doc, cur);
24805: desret_xmlElementContentPtr(ret_val);
24806: call_tests++;
24807: des_xmlDocPtr(n_doc, doc, 0);
24808: des_xmlElementContentPtr(n_cur, cur, 1);
24809: xmlResetLastError();
24810: if (mem_base != xmlMemBlocks()) {
24811: printf("Leak of %d blocks found in xmlCopyDocElementContent",
24812: xmlMemBlocks() - mem_base);
24813: test_ret++;
24814: printf(" %d", n_doc);
24815: printf(" %d", n_cur);
24816: printf("\n");
24817: }
24818: }
24819: }
24820: function_tests++;
24821:
24822: return(test_ret);
24823: }
24824:
24825:
24826: static int
24827: test_xmlCopyElementContent(void) {
24828: int test_ret = 0;
24829:
24830: int mem_base;
24831: xmlElementContentPtr ret_val;
24832: xmlElementContentPtr cur; /* An element content pointer. */
24833: int n_cur;
24834:
24835: for (n_cur = 0;n_cur < gen_nb_xmlElementContentPtr;n_cur++) {
24836: mem_base = xmlMemBlocks();
24837: cur = gen_xmlElementContentPtr(n_cur, 0);
24838:
24839: ret_val = xmlCopyElementContent(cur);
24840: desret_xmlElementContentPtr(ret_val);
24841: call_tests++;
24842: des_xmlElementContentPtr(n_cur, cur, 0);
24843: xmlResetLastError();
24844: if (mem_base != xmlMemBlocks()) {
24845: printf("Leak of %d blocks found in xmlCopyElementContent",
24846: xmlMemBlocks() - mem_base);
24847: test_ret++;
24848: printf(" %d", n_cur);
24849: printf("\n");
24850: }
24851: }
24852: function_tests++;
24853:
24854: return(test_ret);
24855: }
24856:
24857:
24858: #define gen_nb_xmlElementTablePtr 1
24859: static xmlElementTablePtr gen_xmlElementTablePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24860: return(NULL);
24861: }
24862: static void des_xmlElementTablePtr(int no ATTRIBUTE_UNUSED, xmlElementTablePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24863: }
24864:
24865: static int
24866: test_xmlCopyElementTable(void) {
24867: int test_ret = 0;
24868:
24869:
24870: /* missing type support */
24871: return(test_ret);
24872: }
24873:
24874:
24875: static int
24876: test_xmlCopyEnumeration(void) {
24877: int test_ret = 0;
24878:
24879:
24880: /* missing type support */
24881: return(test_ret);
24882: }
24883:
24884:
24885: #define gen_nb_xmlNotationTablePtr 1
24886: static xmlNotationTablePtr gen_xmlNotationTablePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24887: return(NULL);
24888: }
24889: static void des_xmlNotationTablePtr(int no ATTRIBUTE_UNUSED, xmlNotationTablePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24890: }
24891:
24892: static int
24893: test_xmlCopyNotationTable(void) {
24894: int test_ret = 0;
24895:
24896:
24897: /* missing type support */
24898: return(test_ret);
24899: }
24900:
24901:
24902: static int
24903: test_xmlCreateEnumeration(void) {
24904: int test_ret = 0;
24905:
24906:
24907: /* missing type support */
24908: return(test_ret);
24909: }
24910:
24911:
24912: #define gen_nb_xmlAttributePtr 1
24913: static xmlAttributePtr gen_xmlAttributePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24914: return(NULL);
24915: }
24916: static void des_xmlAttributePtr(int no ATTRIBUTE_UNUSED, xmlAttributePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24917: }
24918:
24919: static int
24920: test_xmlDumpAttributeDecl(void) {
24921: int test_ret = 0;
24922:
24923: #if defined(LIBXML_OUTPUT_ENABLED)
24924: int mem_base;
24925: xmlBufferPtr buf; /* the XML buffer output */
24926: int n_buf;
24927: xmlAttributePtr attr; /* An attribute declaration */
24928: int n_attr;
24929:
24930: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
24931: for (n_attr = 0;n_attr < gen_nb_xmlAttributePtr;n_attr++) {
24932: mem_base = xmlMemBlocks();
24933: buf = gen_xmlBufferPtr(n_buf, 0);
24934: attr = gen_xmlAttributePtr(n_attr, 1);
24935:
24936: xmlDumpAttributeDecl(buf, attr);
24937: call_tests++;
24938: des_xmlBufferPtr(n_buf, buf, 0);
24939: des_xmlAttributePtr(n_attr, attr, 1);
24940: xmlResetLastError();
24941: if (mem_base != xmlMemBlocks()) {
24942: printf("Leak of %d blocks found in xmlDumpAttributeDecl",
24943: xmlMemBlocks() - mem_base);
24944: test_ret++;
24945: printf(" %d", n_buf);
24946: printf(" %d", n_attr);
24947: printf("\n");
24948: }
24949: }
24950: }
24951: function_tests++;
24952: #endif
24953:
24954: return(test_ret);
24955: }
24956:
24957:
24958: static int
24959: test_xmlDumpAttributeTable(void) {
24960: int test_ret = 0;
24961:
24962: #if defined(LIBXML_OUTPUT_ENABLED)
24963: int mem_base;
24964: xmlBufferPtr buf; /* the XML buffer output */
24965: int n_buf;
24966: xmlAttributeTablePtr table; /* An attribute table */
24967: int n_table;
24968:
24969: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
24970: for (n_table = 0;n_table < gen_nb_xmlAttributeTablePtr;n_table++) {
24971: mem_base = xmlMemBlocks();
24972: buf = gen_xmlBufferPtr(n_buf, 0);
24973: table = gen_xmlAttributeTablePtr(n_table, 1);
24974:
24975: xmlDumpAttributeTable(buf, table);
24976: call_tests++;
24977: des_xmlBufferPtr(n_buf, buf, 0);
24978: des_xmlAttributeTablePtr(n_table, table, 1);
24979: xmlResetLastError();
24980: if (mem_base != xmlMemBlocks()) {
24981: printf("Leak of %d blocks found in xmlDumpAttributeTable",
24982: xmlMemBlocks() - mem_base);
24983: test_ret++;
24984: printf(" %d", n_buf);
24985: printf(" %d", n_table);
24986: printf("\n");
24987: }
24988: }
24989: }
24990: function_tests++;
24991: #endif
24992:
24993: return(test_ret);
24994: }
24995:
24996:
24997: #define gen_nb_xmlElementPtr 1
24998: static xmlElementPtr gen_xmlElementPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24999: return(NULL);
25000: }
25001: static void des_xmlElementPtr(int no ATTRIBUTE_UNUSED, xmlElementPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
25002: }
25003:
25004: static int
25005: test_xmlDumpElementDecl(void) {
25006: int test_ret = 0;
25007:
25008: #if defined(LIBXML_OUTPUT_ENABLED)
25009: int mem_base;
25010: xmlBufferPtr buf; /* the XML buffer output */
25011: int n_buf;
25012: xmlElementPtr elem; /* An element table */
25013: int n_elem;
25014:
25015: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
25016: for (n_elem = 0;n_elem < gen_nb_xmlElementPtr;n_elem++) {
25017: mem_base = xmlMemBlocks();
25018: buf = gen_xmlBufferPtr(n_buf, 0);
25019: elem = gen_xmlElementPtr(n_elem, 1);
25020:
25021: xmlDumpElementDecl(buf, elem);
25022: call_tests++;
25023: des_xmlBufferPtr(n_buf, buf, 0);
25024: des_xmlElementPtr(n_elem, elem, 1);
25025: xmlResetLastError();
25026: if (mem_base != xmlMemBlocks()) {
25027: printf("Leak of %d blocks found in xmlDumpElementDecl",
25028: xmlMemBlocks() - mem_base);
25029: test_ret++;
25030: printf(" %d", n_buf);
25031: printf(" %d", n_elem);
25032: printf("\n");
25033: }
25034: }
25035: }
25036: function_tests++;
25037: #endif
25038:
25039: return(test_ret);
25040: }
25041:
25042:
25043: static int
25044: test_xmlDumpElementTable(void) {
25045: int test_ret = 0;
25046:
25047: #if defined(LIBXML_OUTPUT_ENABLED)
25048: int mem_base;
25049: xmlBufferPtr buf; /* the XML buffer output */
25050: int n_buf;
25051: xmlElementTablePtr table; /* An element table */
25052: int n_table;
25053:
25054: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
25055: for (n_table = 0;n_table < gen_nb_xmlElementTablePtr;n_table++) {
25056: mem_base = xmlMemBlocks();
25057: buf = gen_xmlBufferPtr(n_buf, 0);
25058: table = gen_xmlElementTablePtr(n_table, 1);
25059:
25060: xmlDumpElementTable(buf, table);
25061: call_tests++;
25062: des_xmlBufferPtr(n_buf, buf, 0);
25063: des_xmlElementTablePtr(n_table, table, 1);
25064: xmlResetLastError();
25065: if (mem_base != xmlMemBlocks()) {
25066: printf("Leak of %d blocks found in xmlDumpElementTable",
25067: xmlMemBlocks() - mem_base);
25068: test_ret++;
25069: printf(" %d", n_buf);
25070: printf(" %d", n_table);
25071: printf("\n");
25072: }
25073: }
25074: }
25075: function_tests++;
25076: #endif
25077:
25078: return(test_ret);
25079: }
25080:
25081:
25082: #define gen_nb_xmlNotationPtr 1
25083: static xmlNotationPtr gen_xmlNotationPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
25084: return(NULL);
25085: }
25086: static void des_xmlNotationPtr(int no ATTRIBUTE_UNUSED, xmlNotationPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
25087: }
25088:
25089: static int
25090: test_xmlDumpNotationDecl(void) {
25091: int test_ret = 0;
25092:
25093: #if defined(LIBXML_OUTPUT_ENABLED)
25094: int mem_base;
25095: xmlBufferPtr buf; /* the XML buffer output */
25096: int n_buf;
25097: xmlNotationPtr nota; /* A notation declaration */
25098: int n_nota;
25099:
25100: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
25101: for (n_nota = 0;n_nota < gen_nb_xmlNotationPtr;n_nota++) {
25102: mem_base = xmlMemBlocks();
25103: buf = gen_xmlBufferPtr(n_buf, 0);
25104: nota = gen_xmlNotationPtr(n_nota, 1);
25105:
25106: xmlDumpNotationDecl(buf, nota);
25107: call_tests++;
25108: des_xmlBufferPtr(n_buf, buf, 0);
25109: des_xmlNotationPtr(n_nota, nota, 1);
25110: xmlResetLastError();
25111: if (mem_base != xmlMemBlocks()) {
25112: printf("Leak of %d blocks found in xmlDumpNotationDecl",
25113: xmlMemBlocks() - mem_base);
25114: test_ret++;
25115: printf(" %d", n_buf);
25116: printf(" %d", n_nota);
25117: printf("\n");
25118: }
25119: }
25120: }
25121: function_tests++;
25122: #endif
25123:
25124: return(test_ret);
25125: }
25126:
25127:
25128: static int
25129: test_xmlDumpNotationTable(void) {
25130: int test_ret = 0;
25131:
25132: #if defined(LIBXML_OUTPUT_ENABLED)
25133: int mem_base;
25134: xmlBufferPtr buf; /* the XML buffer output */
25135: int n_buf;
25136: xmlNotationTablePtr table; /* A notation table */
25137: int n_table;
25138:
25139: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
25140: for (n_table = 0;n_table < gen_nb_xmlNotationTablePtr;n_table++) {
25141: mem_base = xmlMemBlocks();
25142: buf = gen_xmlBufferPtr(n_buf, 0);
25143: table = gen_xmlNotationTablePtr(n_table, 1);
25144:
25145: xmlDumpNotationTable(buf, table);
25146: call_tests++;
25147: des_xmlBufferPtr(n_buf, buf, 0);
25148: des_xmlNotationTablePtr(n_table, table, 1);
25149: xmlResetLastError();
25150: if (mem_base != xmlMemBlocks()) {
25151: printf("Leak of %d blocks found in xmlDumpNotationTable",
25152: xmlMemBlocks() - mem_base);
25153: test_ret++;
25154: printf(" %d", n_buf);
25155: printf(" %d", n_table);
25156: printf("\n");
25157: }
25158: }
25159: }
25160: function_tests++;
25161: #endif
25162:
25163: return(test_ret);
25164: }
25165:
25166:
25167: static int
25168: test_xmlGetDtdAttrDesc(void) {
25169: int test_ret = 0;
25170:
25171: int mem_base;
25172: xmlAttributePtr ret_val;
25173: xmlDtdPtr dtd; /* a pointer to the DtD to search */
25174: int n_dtd;
25175: xmlChar * elem; /* the element name */
25176: int n_elem;
25177: xmlChar * name; /* the attribute name */
25178: int n_name;
25179:
25180: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
25181: for (n_elem = 0;n_elem < gen_nb_const_xmlChar_ptr;n_elem++) {
25182: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
25183: mem_base = xmlMemBlocks();
25184: dtd = gen_xmlDtdPtr(n_dtd, 0);
25185: elem = gen_const_xmlChar_ptr(n_elem, 1);
25186: name = gen_const_xmlChar_ptr(n_name, 2);
25187:
25188: ret_val = xmlGetDtdAttrDesc(dtd, (const xmlChar *)elem, (const xmlChar *)name);
25189: desret_xmlAttributePtr(ret_val);
25190: call_tests++;
25191: des_xmlDtdPtr(n_dtd, dtd, 0);
25192: des_const_xmlChar_ptr(n_elem, (const xmlChar *)elem, 1);
25193: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
25194: xmlResetLastError();
25195: if (mem_base != xmlMemBlocks()) {
25196: printf("Leak of %d blocks found in xmlGetDtdAttrDesc",
25197: xmlMemBlocks() - mem_base);
25198: test_ret++;
25199: printf(" %d", n_dtd);
25200: printf(" %d", n_elem);
25201: printf(" %d", n_name);
25202: printf("\n");
25203: }
25204: }
25205: }
25206: }
25207: function_tests++;
25208:
25209: return(test_ret);
25210: }
25211:
25212:
25213: static int
25214: test_xmlGetDtdElementDesc(void) {
25215: int test_ret = 0;
25216:
25217: int mem_base;
25218: xmlElementPtr ret_val;
25219: xmlDtdPtr dtd; /* a pointer to the DtD to search */
25220: int n_dtd;
25221: xmlChar * name; /* the element name */
25222: int n_name;
25223:
25224: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
25225: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
25226: mem_base = xmlMemBlocks();
25227: dtd = gen_xmlDtdPtr(n_dtd, 0);
25228: name = gen_const_xmlChar_ptr(n_name, 1);
25229:
25230: ret_val = xmlGetDtdElementDesc(dtd, (const xmlChar *)name);
25231: desret_xmlElementPtr(ret_val);
25232: call_tests++;
25233: des_xmlDtdPtr(n_dtd, dtd, 0);
25234: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
25235: xmlResetLastError();
25236: if (mem_base != xmlMemBlocks()) {
25237: printf("Leak of %d blocks found in xmlGetDtdElementDesc",
25238: xmlMemBlocks() - mem_base);
25239: test_ret++;
25240: printf(" %d", n_dtd);
25241: printf(" %d", n_name);
25242: printf("\n");
25243: }
25244: }
25245: }
25246: function_tests++;
25247:
25248: return(test_ret);
25249: }
25250:
25251:
25252: static int
25253: test_xmlGetDtdNotationDesc(void) {
25254: int test_ret = 0;
25255:
25256:
25257: /* missing type support */
25258: return(test_ret);
25259: }
25260:
25261:
25262: static int
25263: test_xmlGetDtdQAttrDesc(void) {
25264: int test_ret = 0;
25265:
25266: int mem_base;
25267: xmlAttributePtr ret_val;
25268: xmlDtdPtr dtd; /* a pointer to the DtD to search */
25269: int n_dtd;
25270: xmlChar * elem; /* the element name */
25271: int n_elem;
25272: xmlChar * name; /* the attribute name */
25273: int n_name;
25274: xmlChar * prefix; /* the attribute namespace prefix */
25275: int n_prefix;
25276:
25277: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
25278: for (n_elem = 0;n_elem < gen_nb_const_xmlChar_ptr;n_elem++) {
25279: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
25280: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
25281: mem_base = xmlMemBlocks();
25282: dtd = gen_xmlDtdPtr(n_dtd, 0);
25283: elem = gen_const_xmlChar_ptr(n_elem, 1);
25284: name = gen_const_xmlChar_ptr(n_name, 2);
25285: prefix = gen_const_xmlChar_ptr(n_prefix, 3);
25286:
25287: ret_val = xmlGetDtdQAttrDesc(dtd, (const xmlChar *)elem, (const xmlChar *)name, (const xmlChar *)prefix);
25288: desret_xmlAttributePtr(ret_val);
25289: call_tests++;
25290: des_xmlDtdPtr(n_dtd, dtd, 0);
25291: des_const_xmlChar_ptr(n_elem, (const xmlChar *)elem, 1);
25292: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
25293: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 3);
25294: xmlResetLastError();
25295: if (mem_base != xmlMemBlocks()) {
25296: printf("Leak of %d blocks found in xmlGetDtdQAttrDesc",
25297: xmlMemBlocks() - mem_base);
25298: test_ret++;
25299: printf(" %d", n_dtd);
25300: printf(" %d", n_elem);
25301: printf(" %d", n_name);
25302: printf(" %d", n_prefix);
25303: printf("\n");
25304: }
25305: }
25306: }
25307: }
25308: }
25309: function_tests++;
25310:
25311: return(test_ret);
25312: }
25313:
25314:
25315: static int
25316: test_xmlGetDtdQElementDesc(void) {
25317: int test_ret = 0;
25318:
25319: int mem_base;
25320: xmlElementPtr ret_val;
25321: xmlDtdPtr dtd; /* a pointer to the DtD to search */
25322: int n_dtd;
25323: xmlChar * name; /* the element name */
25324: int n_name;
25325: xmlChar * prefix; /* the element namespace prefix */
25326: int n_prefix;
25327:
25328: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
25329: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
25330: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
25331: mem_base = xmlMemBlocks();
25332: dtd = gen_xmlDtdPtr(n_dtd, 0);
25333: name = gen_const_xmlChar_ptr(n_name, 1);
25334: prefix = gen_const_xmlChar_ptr(n_prefix, 2);
25335:
25336: ret_val = xmlGetDtdQElementDesc(dtd, (const xmlChar *)name, (const xmlChar *)prefix);
25337: desret_xmlElementPtr(ret_val);
25338: call_tests++;
25339: des_xmlDtdPtr(n_dtd, dtd, 0);
25340: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
25341: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 2);
25342: xmlResetLastError();
25343: if (mem_base != xmlMemBlocks()) {
25344: printf("Leak of %d blocks found in xmlGetDtdQElementDesc",
25345: xmlMemBlocks() - mem_base);
25346: test_ret++;
25347: printf(" %d", n_dtd);
25348: printf(" %d", n_name);
25349: printf(" %d", n_prefix);
25350: printf("\n");
25351: }
25352: }
25353: }
25354: }
25355: function_tests++;
25356:
25357: return(test_ret);
25358: }
25359:
25360:
25361: static int
25362: test_xmlGetID(void) {
25363: int test_ret = 0;
25364:
25365: int mem_base;
25366: xmlAttrPtr ret_val;
25367: xmlDocPtr doc; /* pointer to the document */
25368: int n_doc;
25369: xmlChar * ID; /* the ID value */
25370: int n_ID;
25371:
25372: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
25373: for (n_ID = 0;n_ID < gen_nb_const_xmlChar_ptr;n_ID++) {
25374: mem_base = xmlMemBlocks();
25375: doc = gen_xmlDocPtr(n_doc, 0);
25376: ID = gen_const_xmlChar_ptr(n_ID, 1);
25377:
25378: ret_val = xmlGetID(doc, (const xmlChar *)ID);
25379: desret_xmlAttrPtr(ret_val);
25380: call_tests++;
25381: des_xmlDocPtr(n_doc, doc, 0);
25382: des_const_xmlChar_ptr(n_ID, (const xmlChar *)ID, 1);
25383: xmlResetLastError();
25384: if (mem_base != xmlMemBlocks()) {
25385: printf("Leak of %d blocks found in xmlGetID",
25386: xmlMemBlocks() - mem_base);
25387: test_ret++;
25388: printf(" %d", n_doc);
25389: printf(" %d", n_ID);
25390: printf("\n");
25391: }
25392: }
25393: }
25394: function_tests++;
25395:
25396: return(test_ret);
25397: }
25398:
25399:
25400: static int
25401: test_xmlGetRefs(void) {
25402: int test_ret = 0;
25403:
25404:
25405: /* missing type support */
25406: return(test_ret);
25407: }
25408:
25409:
25410: static int
25411: test_xmlIsID(void) {
25412: int test_ret = 0;
25413:
25414: int mem_base;
25415: int ret_val;
25416: xmlDocPtr doc; /* the document */
25417: int n_doc;
25418: xmlNodePtr elem; /* the element carrying the attribute */
25419: int n_elem;
25420: xmlAttrPtr attr; /* the attribute */
25421: int n_attr;
25422:
25423: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
25424: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
25425: for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
25426: mem_base = xmlMemBlocks();
25427: doc = gen_xmlDocPtr(n_doc, 0);
25428: elem = gen_xmlNodePtr(n_elem, 1);
25429: attr = gen_xmlAttrPtr(n_attr, 2);
25430:
25431: ret_val = xmlIsID(doc, elem, attr);
25432: desret_int(ret_val);
25433: call_tests++;
25434: des_xmlDocPtr(n_doc, doc, 0);
25435: des_xmlNodePtr(n_elem, elem, 1);
25436: des_xmlAttrPtr(n_attr, attr, 2);
25437: xmlResetLastError();
25438: if (mem_base != xmlMemBlocks()) {
25439: printf("Leak of %d blocks found in xmlIsID",
25440: xmlMemBlocks() - mem_base);
25441: test_ret++;
25442: printf(" %d", n_doc);
25443: printf(" %d", n_elem);
25444: printf(" %d", n_attr);
25445: printf("\n");
25446: }
25447: }
25448: }
25449: }
25450: function_tests++;
25451:
25452: return(test_ret);
25453: }
25454:
25455:
25456: static int
25457: test_xmlIsMixedElement(void) {
25458: int test_ret = 0;
25459:
25460: int mem_base;
25461: int ret_val;
25462: xmlDocPtr doc; /* the document */
25463: int n_doc;
25464: xmlChar * name; /* the element name */
25465: int n_name;
25466:
25467: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
25468: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
25469: mem_base = xmlMemBlocks();
25470: doc = gen_xmlDocPtr(n_doc, 0);
25471: name = gen_const_xmlChar_ptr(n_name, 1);
25472:
25473: ret_val = xmlIsMixedElement(doc, (const xmlChar *)name);
25474: desret_int(ret_val);
25475: call_tests++;
25476: des_xmlDocPtr(n_doc, doc, 0);
25477: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
25478: xmlResetLastError();
25479: if (mem_base != xmlMemBlocks()) {
25480: printf("Leak of %d blocks found in xmlIsMixedElement",
25481: xmlMemBlocks() - mem_base);
25482: test_ret++;
25483: printf(" %d", n_doc);
25484: printf(" %d", n_name);
25485: printf("\n");
25486: }
25487: }
25488: }
25489: function_tests++;
25490:
25491: return(test_ret);
25492: }
25493:
25494:
25495: static int
25496: test_xmlIsRef(void) {
25497: int test_ret = 0;
25498:
25499: int mem_base;
25500: int ret_val;
25501: xmlDocPtr doc; /* the document */
25502: int n_doc;
25503: xmlNodePtr elem; /* the element carrying the attribute */
25504: int n_elem;
25505: xmlAttrPtr attr; /* the attribute */
25506: int n_attr;
25507:
25508: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
25509: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
25510: for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
25511: mem_base = xmlMemBlocks();
25512: doc = gen_xmlDocPtr(n_doc, 0);
25513: elem = gen_xmlNodePtr(n_elem, 1);
25514: attr = gen_xmlAttrPtr(n_attr, 2);
25515:
25516: ret_val = xmlIsRef(doc, elem, attr);
25517: desret_int(ret_val);
25518: call_tests++;
25519: des_xmlDocPtr(n_doc, doc, 0);
25520: des_xmlNodePtr(n_elem, elem, 1);
25521: des_xmlAttrPtr(n_attr, attr, 2);
25522: xmlResetLastError();
25523: if (mem_base != xmlMemBlocks()) {
25524: printf("Leak of %d blocks found in xmlIsRef",
25525: xmlMemBlocks() - mem_base);
25526: test_ret++;
25527: printf(" %d", n_doc);
25528: printf(" %d", n_elem);
25529: printf(" %d", n_attr);
25530: printf("\n");
25531: }
25532: }
25533: }
25534: }
25535: function_tests++;
25536:
25537: return(test_ret);
25538: }
25539:
25540:
25541: static int
25542: test_xmlNewDocElementContent(void) {
25543: int test_ret = 0;
25544:
25545: int mem_base;
25546: xmlElementContentPtr ret_val;
25547: xmlDocPtr doc; /* the document */
25548: int n_doc;
25549: xmlChar * name; /* the subelement name or NULL */
25550: int n_name;
25551: xmlElementContentType type; /* the type of element content decl */
25552: int n_type;
25553:
25554: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
25555: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
25556: for (n_type = 0;n_type < gen_nb_xmlElementContentType;n_type++) {
25557: mem_base = xmlMemBlocks();
25558: doc = gen_xmlDocPtr(n_doc, 0);
25559: name = gen_const_xmlChar_ptr(n_name, 1);
25560: type = gen_xmlElementContentType(n_type, 2);
25561:
25562: ret_val = xmlNewDocElementContent(doc, (const xmlChar *)name, type);
25563: xmlFreeDocElementContent(doc, ret_val); ret_val = NULL;
25564: desret_xmlElementContentPtr(ret_val);
25565: call_tests++;
25566: des_xmlDocPtr(n_doc, doc, 0);
25567: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
25568: des_xmlElementContentType(n_type, type, 2);
25569: xmlResetLastError();
25570: if (mem_base != xmlMemBlocks()) {
25571: printf("Leak of %d blocks found in xmlNewDocElementContent",
25572: xmlMemBlocks() - mem_base);
25573: test_ret++;
25574: printf(" %d", n_doc);
25575: printf(" %d", n_name);
25576: printf(" %d", n_type);
25577: printf("\n");
25578: }
25579: }
25580: }
25581: }
25582: function_tests++;
25583:
25584: return(test_ret);
25585: }
25586:
25587:
25588: static int
25589: test_xmlNewElementContent(void) {
25590: int test_ret = 0;
25591:
25592: int mem_base;
25593: xmlElementContentPtr ret_val;
25594: xmlChar * name; /* the subelement name or NULL */
25595: int n_name;
25596: xmlElementContentType type; /* the type of element content decl */
25597: int n_type;
25598:
25599: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
25600: for (n_type = 0;n_type < gen_nb_xmlElementContentType;n_type++) {
25601: mem_base = xmlMemBlocks();
25602: name = gen_const_xmlChar_ptr(n_name, 0);
25603: type = gen_xmlElementContentType(n_type, 1);
25604:
25605: ret_val = xmlNewElementContent((const xmlChar *)name, type);
25606: desret_xmlElementContentPtr(ret_val);
25607: call_tests++;
25608: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
25609: des_xmlElementContentType(n_type, type, 1);
25610: xmlResetLastError();
25611: if (mem_base != xmlMemBlocks()) {
25612: printf("Leak of %d blocks found in xmlNewElementContent",
25613: xmlMemBlocks() - mem_base);
25614: test_ret++;
25615: printf(" %d", n_name);
25616: printf(" %d", n_type);
25617: printf("\n");
25618: }
25619: }
25620: }
25621: function_tests++;
25622:
25623: return(test_ret);
25624: }
25625:
25626:
25627: static int
25628: test_xmlNewValidCtxt(void) {
25629: int test_ret = 0;
25630:
25631:
25632: /* missing type support */
25633: return(test_ret);
25634: }
25635:
25636:
25637: static int
25638: test_xmlRemoveID(void) {
25639: int test_ret = 0;
25640:
25641: int mem_base;
25642: int ret_val;
25643: xmlDocPtr doc; /* the document */
25644: int n_doc;
25645: xmlAttrPtr attr; /* the attribute */
25646: int n_attr;
25647:
25648: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
25649: for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
25650: mem_base = xmlMemBlocks();
25651: doc = gen_xmlDocPtr(n_doc, 0);
25652: attr = gen_xmlAttrPtr(n_attr, 1);
25653:
25654: ret_val = xmlRemoveID(doc, attr);
25655: desret_int(ret_val);
25656: call_tests++;
25657: des_xmlDocPtr(n_doc, doc, 0);
25658: des_xmlAttrPtr(n_attr, attr, 1);
25659: xmlResetLastError();
25660: if (mem_base != xmlMemBlocks()) {
25661: printf("Leak of %d blocks found in xmlRemoveID",
25662: xmlMemBlocks() - mem_base);
25663: test_ret++;
25664: printf(" %d", n_doc);
25665: printf(" %d", n_attr);
25666: printf("\n");
25667: }
25668: }
25669: }
25670: function_tests++;
25671:
25672: return(test_ret);
25673: }
25674:
25675:
25676: static int
25677: test_xmlRemoveRef(void) {
25678: int test_ret = 0;
25679:
25680: int mem_base;
25681: int ret_val;
25682: xmlDocPtr doc; /* the document */
25683: int n_doc;
25684: xmlAttrPtr attr; /* the attribute */
25685: int n_attr;
25686:
25687: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
25688: for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
25689: mem_base = xmlMemBlocks();
25690: doc = gen_xmlDocPtr(n_doc, 0);
25691: attr = gen_xmlAttrPtr(n_attr, 1);
25692:
25693: ret_val = xmlRemoveRef(doc, attr);
25694: desret_int(ret_val);
25695: call_tests++;
25696: des_xmlDocPtr(n_doc, doc, 0);
25697: des_xmlAttrPtr(n_attr, attr, 1);
25698: xmlResetLastError();
25699: if (mem_base != xmlMemBlocks()) {
25700: printf("Leak of %d blocks found in xmlRemoveRef",
25701: xmlMemBlocks() - mem_base);
25702: test_ret++;
25703: printf(" %d", n_doc);
25704: printf(" %d", n_attr);
25705: printf("\n");
25706: }
25707: }
25708: }
25709: function_tests++;
25710:
25711: return(test_ret);
25712: }
25713:
25714:
25715: static int
25716: test_xmlSnprintfElementContent(void) {
25717: int test_ret = 0;
25718:
25719: int mem_base;
25720: char * buf; /* an output buffer */
25721: int n_buf;
25722: int size; /* the buffer size */
25723: int n_size;
25724: xmlElementContentPtr content; /* An element table */
25725: int n_content;
25726: int englob; /* 1 if one must print the englobing parenthesis, 0 otherwise */
25727: int n_englob;
25728:
25729: for (n_buf = 0;n_buf < gen_nb_char_ptr;n_buf++) {
25730: for (n_size = 0;n_size < gen_nb_int;n_size++) {
25731: for (n_content = 0;n_content < gen_nb_xmlElementContentPtr;n_content++) {
25732: for (n_englob = 0;n_englob < gen_nb_int;n_englob++) {
25733: mem_base = xmlMemBlocks();
25734: buf = gen_char_ptr(n_buf, 0);
25735: size = gen_int(n_size, 1);
25736: content = gen_xmlElementContentPtr(n_content, 2);
25737: englob = gen_int(n_englob, 3);
25738:
25739: xmlSnprintfElementContent(buf, size, content, englob);
25740: call_tests++;
25741: des_char_ptr(n_buf, buf, 0);
25742: des_int(n_size, size, 1);
25743: des_xmlElementContentPtr(n_content, content, 2);
25744: des_int(n_englob, englob, 3);
25745: xmlResetLastError();
25746: if (mem_base != xmlMemBlocks()) {
25747: printf("Leak of %d blocks found in xmlSnprintfElementContent",
25748: xmlMemBlocks() - mem_base);
25749: test_ret++;
25750: printf(" %d", n_buf);
25751: printf(" %d", n_size);
25752: printf(" %d", n_content);
25753: printf(" %d", n_englob);
25754: printf("\n");
25755: }
25756: }
25757: }
25758: }
25759: }
25760: function_tests++;
25761:
25762: return(test_ret);
25763: }
25764:
25765:
25766: static int
25767: test_xmlSprintfElementContent(void) {
25768: int test_ret = 0;
25769:
25770: #if defined(LIBXML_OUTPUT_ENABLED)
25771: #ifdef LIBXML_OUTPUT_ENABLED
25772: int mem_base;
25773: char * buf; /* an output buffer */
25774: int n_buf;
25775: xmlElementContentPtr content; /* An element table */
25776: int n_content;
25777: int englob; /* 1 if one must print the englobing parenthesis, 0 otherwise */
25778: int n_englob;
25779:
25780: for (n_buf = 0;n_buf < gen_nb_char_ptr;n_buf++) {
25781: for (n_content = 0;n_content < gen_nb_xmlElementContentPtr;n_content++) {
25782: for (n_englob = 0;n_englob < gen_nb_int;n_englob++) {
25783: mem_base = xmlMemBlocks();
25784: buf = gen_char_ptr(n_buf, 0);
25785: content = gen_xmlElementContentPtr(n_content, 1);
25786: englob = gen_int(n_englob, 2);
25787:
25788: xmlSprintfElementContent(buf, content, englob);
25789: call_tests++;
25790: des_char_ptr(n_buf, buf, 0);
25791: des_xmlElementContentPtr(n_content, content, 1);
25792: des_int(n_englob, englob, 2);
25793: xmlResetLastError();
25794: if (mem_base != xmlMemBlocks()) {
25795: printf("Leak of %d blocks found in xmlSprintfElementContent",
25796: xmlMemBlocks() - mem_base);
25797: test_ret++;
25798: printf(" %d", n_buf);
25799: printf(" %d", n_content);
25800: printf(" %d", n_englob);
25801: printf("\n");
25802: }
25803: }
25804: }
25805: }
25806: function_tests++;
25807: #endif
25808: #endif
25809:
25810: return(test_ret);
25811: }
25812:
25813:
25814: static int
25815: test_xmlValidBuildContentModel(void) {
25816: int test_ret = 0;
25817:
25818: #if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED)
25819: int mem_base;
25820: int ret_val;
25821: xmlValidCtxtPtr ctxt; /* a validation context */
25822: int n_ctxt;
25823: xmlElementPtr elem; /* an element declaration node */
25824: int n_elem;
25825:
25826: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
25827: for (n_elem = 0;n_elem < gen_nb_xmlElementPtr;n_elem++) {
25828: mem_base = xmlMemBlocks();
25829: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
25830: elem = gen_xmlElementPtr(n_elem, 1);
25831:
25832: ret_val = xmlValidBuildContentModel(ctxt, elem);
25833: desret_int(ret_val);
25834: call_tests++;
25835: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
25836: des_xmlElementPtr(n_elem, elem, 1);
25837: xmlResetLastError();
25838: if (mem_base != xmlMemBlocks()) {
25839: printf("Leak of %d blocks found in xmlValidBuildContentModel",
25840: xmlMemBlocks() - mem_base);
25841: test_ret++;
25842: printf(" %d", n_ctxt);
25843: printf(" %d", n_elem);
25844: printf("\n");
25845: }
25846: }
25847: }
25848: function_tests++;
25849: #endif
25850:
25851: return(test_ret);
25852: }
25853:
25854:
25855: static int
25856: test_xmlValidCtxtNormalizeAttributeValue(void) {
25857: int test_ret = 0;
25858:
25859: #if defined(LIBXML_VALID_ENABLED)
25860: int mem_base;
25861: xmlChar * ret_val;
25862: xmlValidCtxtPtr ctxt; /* the validation context or NULL */
25863: int n_ctxt;
25864: xmlDocPtr doc; /* the document */
25865: int n_doc;
25866: xmlNodePtr elem; /* the parent */
25867: int n_elem;
25868: xmlChar * name; /* the attribute name */
25869: int n_name;
25870: xmlChar * value; /* the attribute value */
25871: int n_value;
25872:
25873: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
25874: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
25875: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
25876: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
25877: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
25878: mem_base = xmlMemBlocks();
25879: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
25880: doc = gen_xmlDocPtr(n_doc, 1);
25881: elem = gen_xmlNodePtr(n_elem, 2);
25882: name = gen_const_xmlChar_ptr(n_name, 3);
25883: value = gen_const_xmlChar_ptr(n_value, 4);
25884:
25885: ret_val = xmlValidCtxtNormalizeAttributeValue(ctxt, doc, elem, (const xmlChar *)name, (const xmlChar *)value);
25886: desret_xmlChar_ptr(ret_val);
25887: call_tests++;
25888: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
25889: des_xmlDocPtr(n_doc, doc, 1);
25890: des_xmlNodePtr(n_elem, elem, 2);
25891: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 3);
25892: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 4);
25893: xmlResetLastError();
25894: if (mem_base != xmlMemBlocks()) {
25895: printf("Leak of %d blocks found in xmlValidCtxtNormalizeAttributeValue",
25896: xmlMemBlocks() - mem_base);
25897: test_ret++;
25898: printf(" %d", n_ctxt);
25899: printf(" %d", n_doc);
25900: printf(" %d", n_elem);
25901: printf(" %d", n_name);
25902: printf(" %d", n_value);
25903: printf("\n");
25904: }
25905: }
25906: }
25907: }
25908: }
25909: }
25910: function_tests++;
25911: #endif
25912:
25913: return(test_ret);
25914: }
25915:
25916:
25917: #define gen_nb_xmlElementContent_ptr 1
25918: static xmlElementContent * gen_xmlElementContent_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
25919: return(NULL);
25920: }
25921: static void des_xmlElementContent_ptr(int no ATTRIBUTE_UNUSED, xmlElementContent * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
25922: }
25923:
25924: static int
25925: test_xmlValidGetPotentialChildren(void) {
25926: int test_ret = 0;
25927:
25928: #if defined(LIBXML_VALID_ENABLED)
25929: #ifdef LIBXML_VALID_ENABLED
25930: int mem_base;
25931: int ret_val;
25932: xmlElementContent * ctree; /* an element content tree */
25933: int n_ctree;
25934: xmlChar ** names; /* an array to store the list of child names */
25935: int n_names;
25936: int * len; /* a pointer to the number of element in the list */
25937: int n_len;
25938: int max; /* the size of the array */
25939: int n_max;
25940:
25941: for (n_ctree = 0;n_ctree < gen_nb_xmlElementContent_ptr;n_ctree++) {
25942: for (n_names = 0;n_names < gen_nb_const_xmlChar_ptr_ptr;n_names++) {
25943: for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
25944: for (n_max = 0;n_max < gen_nb_int;n_max++) {
25945: mem_base = xmlMemBlocks();
25946: ctree = gen_xmlElementContent_ptr(n_ctree, 0);
25947: names = gen_const_xmlChar_ptr_ptr(n_names, 1);
25948: len = gen_int_ptr(n_len, 2);
25949: max = gen_int(n_max, 3);
25950:
25951: ret_val = xmlValidGetPotentialChildren(ctree, (const xmlChar **)names, len, max);
25952: desret_int(ret_val);
25953: call_tests++;
25954: des_xmlElementContent_ptr(n_ctree, ctree, 0);
25955: des_const_xmlChar_ptr_ptr(n_names, (const xmlChar **)names, 1);
25956: des_int_ptr(n_len, len, 2);
25957: des_int(n_max, max, 3);
25958: xmlResetLastError();
25959: if (mem_base != xmlMemBlocks()) {
25960: printf("Leak of %d blocks found in xmlValidGetPotentialChildren",
25961: xmlMemBlocks() - mem_base);
25962: test_ret++;
25963: printf(" %d", n_ctree);
25964: printf(" %d", n_names);
25965: printf(" %d", n_len);
25966: printf(" %d", n_max);
25967: printf("\n");
25968: }
25969: }
25970: }
25971: }
25972: }
25973: function_tests++;
25974: #endif
25975: #endif
25976:
25977: return(test_ret);
25978: }
25979:
25980:
25981: static int
25982: test_xmlValidGetValidElements(void) {
25983: int test_ret = 0;
25984:
25985: #if defined(LIBXML_VALID_ENABLED)
25986: #ifdef LIBXML_VALID_ENABLED
25987: int mem_base;
25988: int ret_val;
25989: xmlNode * prev; /* an element to insert after */
25990: int n_prev;
25991: xmlNode * next; /* an element to insert next */
25992: int n_next;
25993: xmlChar ** names; /* an array to store the list of child names */
25994: int n_names;
25995: int max; /* the size of the array */
25996: int n_max;
25997:
25998: for (n_prev = 0;n_prev < gen_nb_xmlNodePtr;n_prev++) {
25999: for (n_next = 0;n_next < gen_nb_xmlNodePtr;n_next++) {
26000: for (n_names = 0;n_names < gen_nb_const_xmlChar_ptr_ptr;n_names++) {
26001: for (n_max = 0;n_max < gen_nb_int;n_max++) {
26002: mem_base = xmlMemBlocks();
26003: prev = gen_xmlNodePtr(n_prev, 0);
26004: next = gen_xmlNodePtr(n_next, 1);
26005: names = gen_const_xmlChar_ptr_ptr(n_names, 2);
26006: max = gen_int(n_max, 3);
26007:
26008: ret_val = xmlValidGetValidElements(prev, next, (const xmlChar **)names, max);
26009: desret_int(ret_val);
26010: call_tests++;
26011: des_xmlNodePtr(n_prev, prev, 0);
26012: des_xmlNodePtr(n_next, next, 1);
26013: des_const_xmlChar_ptr_ptr(n_names, (const xmlChar **)names, 2);
26014: des_int(n_max, max, 3);
26015: xmlResetLastError();
26016: if (mem_base != xmlMemBlocks()) {
26017: printf("Leak of %d blocks found in xmlValidGetValidElements",
26018: xmlMemBlocks() - mem_base);
26019: test_ret++;
26020: printf(" %d", n_prev);
26021: printf(" %d", n_next);
26022: printf(" %d", n_names);
26023: printf(" %d", n_max);
26024: printf("\n");
26025: }
26026: }
26027: }
26028: }
26029: }
26030: function_tests++;
26031: #endif
26032: #endif
26033:
26034: return(test_ret);
26035: }
26036:
26037:
26038: static int
26039: test_xmlValidNormalizeAttributeValue(void) {
26040: int test_ret = 0;
26041:
26042: #if defined(LIBXML_VALID_ENABLED)
26043: int mem_base;
26044: xmlChar * ret_val;
26045: xmlDocPtr doc; /* the document */
26046: int n_doc;
26047: xmlNodePtr elem; /* the parent */
26048: int n_elem;
26049: xmlChar * name; /* the attribute name */
26050: int n_name;
26051: xmlChar * value; /* the attribute value */
26052: int n_value;
26053:
26054: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26055: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
26056: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
26057: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
26058: mem_base = xmlMemBlocks();
26059: doc = gen_xmlDocPtr(n_doc, 0);
26060: elem = gen_xmlNodePtr(n_elem, 1);
26061: name = gen_const_xmlChar_ptr(n_name, 2);
26062: value = gen_const_xmlChar_ptr(n_value, 3);
26063:
26064: ret_val = xmlValidNormalizeAttributeValue(doc, elem, (const xmlChar *)name, (const xmlChar *)value);
26065: desret_xmlChar_ptr(ret_val);
26066: call_tests++;
26067: des_xmlDocPtr(n_doc, doc, 0);
26068: des_xmlNodePtr(n_elem, elem, 1);
26069: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
26070: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 3);
26071: xmlResetLastError();
26072: if (mem_base != xmlMemBlocks()) {
26073: printf("Leak of %d blocks found in xmlValidNormalizeAttributeValue",
26074: xmlMemBlocks() - mem_base);
26075: test_ret++;
26076: printf(" %d", n_doc);
26077: printf(" %d", n_elem);
26078: printf(" %d", n_name);
26079: printf(" %d", n_value);
26080: printf("\n");
26081: }
26082: }
26083: }
26084: }
26085: }
26086: function_tests++;
26087: #endif
26088:
26089: return(test_ret);
26090: }
26091:
26092:
26093: static int
26094: test_xmlValidateAttributeDecl(void) {
26095: int test_ret = 0;
26096:
26097: #if defined(LIBXML_VALID_ENABLED)
26098: int mem_base;
26099: int ret_val;
26100: xmlValidCtxtPtr ctxt; /* the validation context */
26101: int n_ctxt;
26102: xmlDocPtr doc; /* a document instance */
26103: int n_doc;
26104: xmlAttributePtr attr; /* an attribute definition */
26105: int n_attr;
26106:
26107: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26108: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26109: for (n_attr = 0;n_attr < gen_nb_xmlAttributePtr;n_attr++) {
26110: mem_base = xmlMemBlocks();
26111: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26112: doc = gen_xmlDocPtr(n_doc, 1);
26113: attr = gen_xmlAttributePtr(n_attr, 2);
26114:
26115: ret_val = xmlValidateAttributeDecl(ctxt, doc, attr);
26116: desret_int(ret_val);
26117: call_tests++;
26118: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26119: des_xmlDocPtr(n_doc, doc, 1);
26120: des_xmlAttributePtr(n_attr, attr, 2);
26121: xmlResetLastError();
26122: if (mem_base != xmlMemBlocks()) {
26123: printf("Leak of %d blocks found in xmlValidateAttributeDecl",
26124: xmlMemBlocks() - mem_base);
26125: test_ret++;
26126: printf(" %d", n_ctxt);
26127: printf(" %d", n_doc);
26128: printf(" %d", n_attr);
26129: printf("\n");
26130: }
26131: }
26132: }
26133: }
26134: function_tests++;
26135: #endif
26136:
26137: return(test_ret);
26138: }
26139:
26140:
26141: static int
26142: test_xmlValidateAttributeValue(void) {
26143: int test_ret = 0;
26144:
26145: #if defined(LIBXML_VALID_ENABLED)
26146: int mem_base;
26147: int ret_val;
26148: xmlAttributeType type; /* an attribute type */
26149: int n_type;
26150: xmlChar * value; /* an attribute value */
26151: int n_value;
26152:
26153: for (n_type = 0;n_type < gen_nb_xmlAttributeType;n_type++) {
26154: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
26155: mem_base = xmlMemBlocks();
26156: type = gen_xmlAttributeType(n_type, 0);
26157: value = gen_const_xmlChar_ptr(n_value, 1);
26158:
26159: ret_val = xmlValidateAttributeValue(type, (const xmlChar *)value);
26160: desret_int(ret_val);
26161: call_tests++;
26162: des_xmlAttributeType(n_type, type, 0);
26163: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
26164: xmlResetLastError();
26165: if (mem_base != xmlMemBlocks()) {
26166: printf("Leak of %d blocks found in xmlValidateAttributeValue",
26167: xmlMemBlocks() - mem_base);
26168: test_ret++;
26169: printf(" %d", n_type);
26170: printf(" %d", n_value);
26171: printf("\n");
26172: }
26173: }
26174: }
26175: function_tests++;
26176: #endif
26177:
26178: return(test_ret);
26179: }
26180:
26181:
26182: static int
26183: test_xmlValidateDocument(void) {
26184: int test_ret = 0;
26185:
26186: #if defined(LIBXML_VALID_ENABLED)
26187: int mem_base;
26188: int ret_val;
26189: xmlValidCtxtPtr ctxt; /* the validation context */
26190: int n_ctxt;
26191: xmlDocPtr doc; /* a document instance */
26192: int n_doc;
26193:
26194: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26195: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26196: mem_base = xmlMemBlocks();
26197: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26198: doc = gen_xmlDocPtr(n_doc, 1);
26199:
26200: ret_val = xmlValidateDocument(ctxt, doc);
26201: desret_int(ret_val);
26202: call_tests++;
26203: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26204: des_xmlDocPtr(n_doc, doc, 1);
26205: xmlResetLastError();
26206: if (mem_base != xmlMemBlocks()) {
26207: printf("Leak of %d blocks found in xmlValidateDocument",
26208: xmlMemBlocks() - mem_base);
26209: test_ret++;
26210: printf(" %d", n_ctxt);
26211: printf(" %d", n_doc);
26212: printf("\n");
26213: }
26214: }
26215: }
26216: function_tests++;
26217: #endif
26218:
26219: return(test_ret);
26220: }
26221:
26222:
26223: static int
26224: test_xmlValidateDocumentFinal(void) {
26225: int test_ret = 0;
26226:
26227: #if defined(LIBXML_VALID_ENABLED)
26228: int mem_base;
26229: int ret_val;
26230: xmlValidCtxtPtr ctxt; /* the validation context */
26231: int n_ctxt;
26232: xmlDocPtr doc; /* a document instance */
26233: int n_doc;
26234:
26235: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26236: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26237: mem_base = xmlMemBlocks();
26238: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26239: doc = gen_xmlDocPtr(n_doc, 1);
26240:
26241: ret_val = xmlValidateDocumentFinal(ctxt, doc);
26242: desret_int(ret_val);
26243: call_tests++;
26244: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26245: des_xmlDocPtr(n_doc, doc, 1);
26246: xmlResetLastError();
26247: if (mem_base != xmlMemBlocks()) {
26248: printf("Leak of %d blocks found in xmlValidateDocumentFinal",
26249: xmlMemBlocks() - mem_base);
26250: test_ret++;
26251: printf(" %d", n_ctxt);
26252: printf(" %d", n_doc);
26253: printf("\n");
26254: }
26255: }
26256: }
26257: function_tests++;
26258: #endif
26259:
26260: return(test_ret);
26261: }
26262:
26263:
26264: static int
26265: test_xmlValidateDtd(void) {
26266: int test_ret = 0;
26267:
26268: #if defined(LIBXML_VALID_ENABLED)
26269: int mem_base;
26270: int ret_val;
26271: xmlValidCtxtPtr ctxt; /* the validation context */
26272: int n_ctxt;
26273: xmlDocPtr doc; /* a document instance */
26274: int n_doc;
26275: xmlDtdPtr dtd; /* a dtd instance */
26276: int n_dtd;
26277:
26278: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26279: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26280: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
26281: mem_base = xmlMemBlocks();
26282: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26283: doc = gen_xmlDocPtr(n_doc, 1);
26284: dtd = gen_xmlDtdPtr(n_dtd, 2);
26285:
26286: ret_val = xmlValidateDtd(ctxt, doc, dtd);
26287: desret_int(ret_val);
26288: call_tests++;
26289: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26290: des_xmlDocPtr(n_doc, doc, 1);
26291: des_xmlDtdPtr(n_dtd, dtd, 2);
26292: xmlResetLastError();
26293: if (mem_base != xmlMemBlocks()) {
26294: printf("Leak of %d blocks found in xmlValidateDtd",
26295: xmlMemBlocks() - mem_base);
26296: test_ret++;
26297: printf(" %d", n_ctxt);
26298: printf(" %d", n_doc);
26299: printf(" %d", n_dtd);
26300: printf("\n");
26301: }
26302: }
26303: }
26304: }
26305: function_tests++;
26306: #endif
26307:
26308: return(test_ret);
26309: }
26310:
26311:
26312: static int
26313: test_xmlValidateDtdFinal(void) {
26314: int test_ret = 0;
26315:
26316: #if defined(LIBXML_VALID_ENABLED)
26317: int mem_base;
26318: int ret_val;
26319: xmlValidCtxtPtr ctxt; /* the validation context */
26320: int n_ctxt;
26321: xmlDocPtr doc; /* a document instance */
26322: int n_doc;
26323:
26324: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26325: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26326: mem_base = xmlMemBlocks();
26327: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26328: doc = gen_xmlDocPtr(n_doc, 1);
26329:
26330: ret_val = xmlValidateDtdFinal(ctxt, doc);
26331: desret_int(ret_val);
26332: call_tests++;
26333: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26334: des_xmlDocPtr(n_doc, doc, 1);
26335: xmlResetLastError();
26336: if (mem_base != xmlMemBlocks()) {
26337: printf("Leak of %d blocks found in xmlValidateDtdFinal",
26338: xmlMemBlocks() - mem_base);
26339: test_ret++;
26340: printf(" %d", n_ctxt);
26341: printf(" %d", n_doc);
26342: printf("\n");
26343: }
26344: }
26345: }
26346: function_tests++;
26347: #endif
26348:
26349: return(test_ret);
26350: }
26351:
26352:
26353: static int
26354: test_xmlValidateElement(void) {
26355: int test_ret = 0;
26356:
26357: #if defined(LIBXML_VALID_ENABLED)
26358: int mem_base;
26359: int ret_val;
26360: xmlValidCtxtPtr ctxt; /* the validation context */
26361: int n_ctxt;
26362: xmlDocPtr doc; /* a document instance */
26363: int n_doc;
26364: xmlNodePtr elem; /* an element instance */
26365: int n_elem;
26366:
26367: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26368: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26369: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
26370: mem_base = xmlMemBlocks();
26371: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26372: doc = gen_xmlDocPtr(n_doc, 1);
26373: elem = gen_xmlNodePtr(n_elem, 2);
26374:
26375: ret_val = xmlValidateElement(ctxt, doc, elem);
26376: desret_int(ret_val);
26377: call_tests++;
26378: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26379: des_xmlDocPtr(n_doc, doc, 1);
26380: des_xmlNodePtr(n_elem, elem, 2);
26381: xmlResetLastError();
26382: if (mem_base != xmlMemBlocks()) {
26383: printf("Leak of %d blocks found in xmlValidateElement",
26384: xmlMemBlocks() - mem_base);
26385: test_ret++;
26386: printf(" %d", n_ctxt);
26387: printf(" %d", n_doc);
26388: printf(" %d", n_elem);
26389: printf("\n");
26390: }
26391: }
26392: }
26393: }
26394: function_tests++;
26395: #endif
26396:
26397: return(test_ret);
26398: }
26399:
26400:
26401: static int
26402: test_xmlValidateElementDecl(void) {
26403: int test_ret = 0;
26404:
26405: #if defined(LIBXML_VALID_ENABLED)
26406: int mem_base;
26407: int ret_val;
26408: xmlValidCtxtPtr ctxt; /* the validation context */
26409: int n_ctxt;
26410: xmlDocPtr doc; /* a document instance */
26411: int n_doc;
26412: xmlElementPtr elem; /* an element definition */
26413: int n_elem;
26414:
26415: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26416: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26417: for (n_elem = 0;n_elem < gen_nb_xmlElementPtr;n_elem++) {
26418: mem_base = xmlMemBlocks();
26419: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26420: doc = gen_xmlDocPtr(n_doc, 1);
26421: elem = gen_xmlElementPtr(n_elem, 2);
26422:
26423: ret_val = xmlValidateElementDecl(ctxt, doc, elem);
26424: desret_int(ret_val);
26425: call_tests++;
26426: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26427: des_xmlDocPtr(n_doc, doc, 1);
26428: des_xmlElementPtr(n_elem, elem, 2);
26429: xmlResetLastError();
26430: if (mem_base != xmlMemBlocks()) {
26431: printf("Leak of %d blocks found in xmlValidateElementDecl",
26432: xmlMemBlocks() - mem_base);
26433: test_ret++;
26434: printf(" %d", n_ctxt);
26435: printf(" %d", n_doc);
26436: printf(" %d", n_elem);
26437: printf("\n");
26438: }
26439: }
26440: }
26441: }
26442: function_tests++;
26443: #endif
26444:
26445: return(test_ret);
26446: }
26447:
26448:
26449: static int
26450: test_xmlValidateNameValue(void) {
26451: int test_ret = 0;
26452:
26453: #if defined(LIBXML_VALID_ENABLED)
26454: int mem_base;
26455: int ret_val;
26456: xmlChar * value; /* an Name value */
26457: int n_value;
26458:
26459: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
26460: mem_base = xmlMemBlocks();
26461: value = gen_const_xmlChar_ptr(n_value, 0);
26462:
26463: ret_val = xmlValidateNameValue((const xmlChar *)value);
26464: desret_int(ret_val);
26465: call_tests++;
26466: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
26467: xmlResetLastError();
26468: if (mem_base != xmlMemBlocks()) {
26469: printf("Leak of %d blocks found in xmlValidateNameValue",
26470: xmlMemBlocks() - mem_base);
26471: test_ret++;
26472: printf(" %d", n_value);
26473: printf("\n");
26474: }
26475: }
26476: function_tests++;
26477: #endif
26478:
26479: return(test_ret);
26480: }
26481:
26482:
26483: static int
26484: test_xmlValidateNamesValue(void) {
26485: int test_ret = 0;
26486:
26487: #if defined(LIBXML_VALID_ENABLED)
26488: int mem_base;
26489: int ret_val;
26490: xmlChar * value; /* an Names value */
26491: int n_value;
26492:
26493: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
26494: mem_base = xmlMemBlocks();
26495: value = gen_const_xmlChar_ptr(n_value, 0);
26496:
26497: ret_val = xmlValidateNamesValue((const xmlChar *)value);
26498: desret_int(ret_val);
26499: call_tests++;
26500: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
26501: xmlResetLastError();
26502: if (mem_base != xmlMemBlocks()) {
26503: printf("Leak of %d blocks found in xmlValidateNamesValue",
26504: xmlMemBlocks() - mem_base);
26505: test_ret++;
26506: printf(" %d", n_value);
26507: printf("\n");
26508: }
26509: }
26510: function_tests++;
26511: #endif
26512:
26513: return(test_ret);
26514: }
26515:
26516:
26517: static int
26518: test_xmlValidateNmtokenValue(void) {
26519: int test_ret = 0;
26520:
26521: #if defined(LIBXML_VALID_ENABLED)
26522: int mem_base;
26523: int ret_val;
26524: xmlChar * value; /* an Nmtoken value */
26525: int n_value;
26526:
26527: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
26528: mem_base = xmlMemBlocks();
26529: value = gen_const_xmlChar_ptr(n_value, 0);
26530:
26531: ret_val = xmlValidateNmtokenValue((const xmlChar *)value);
26532: desret_int(ret_val);
26533: call_tests++;
26534: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
26535: xmlResetLastError();
26536: if (mem_base != xmlMemBlocks()) {
26537: printf("Leak of %d blocks found in xmlValidateNmtokenValue",
26538: xmlMemBlocks() - mem_base);
26539: test_ret++;
26540: printf(" %d", n_value);
26541: printf("\n");
26542: }
26543: }
26544: function_tests++;
26545: #endif
26546:
26547: return(test_ret);
26548: }
26549:
26550:
26551: static int
26552: test_xmlValidateNmtokensValue(void) {
26553: int test_ret = 0;
26554:
26555: #if defined(LIBXML_VALID_ENABLED)
26556: int mem_base;
26557: int ret_val;
26558: xmlChar * value; /* an Nmtokens value */
26559: int n_value;
26560:
26561: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
26562: mem_base = xmlMemBlocks();
26563: value = gen_const_xmlChar_ptr(n_value, 0);
26564:
26565: ret_val = xmlValidateNmtokensValue((const xmlChar *)value);
26566: desret_int(ret_val);
26567: call_tests++;
26568: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
26569: xmlResetLastError();
26570: if (mem_base != xmlMemBlocks()) {
26571: printf("Leak of %d blocks found in xmlValidateNmtokensValue",
26572: xmlMemBlocks() - mem_base);
26573: test_ret++;
26574: printf(" %d", n_value);
26575: printf("\n");
26576: }
26577: }
26578: function_tests++;
26579: #endif
26580:
26581: return(test_ret);
26582: }
26583:
26584:
26585: static int
26586: test_xmlValidateNotationDecl(void) {
26587: int test_ret = 0;
26588:
26589: #if defined(LIBXML_VALID_ENABLED)
26590: int mem_base;
26591: int ret_val;
26592: xmlValidCtxtPtr ctxt; /* the validation context */
26593: int n_ctxt;
26594: xmlDocPtr doc; /* a document instance */
26595: int n_doc;
26596: xmlNotationPtr nota; /* a notation definition */
26597: int n_nota;
26598:
26599: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26600: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26601: for (n_nota = 0;n_nota < gen_nb_xmlNotationPtr;n_nota++) {
26602: mem_base = xmlMemBlocks();
26603: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26604: doc = gen_xmlDocPtr(n_doc, 1);
26605: nota = gen_xmlNotationPtr(n_nota, 2);
26606:
26607: ret_val = xmlValidateNotationDecl(ctxt, doc, nota);
26608: desret_int(ret_val);
26609: call_tests++;
26610: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26611: des_xmlDocPtr(n_doc, doc, 1);
26612: des_xmlNotationPtr(n_nota, nota, 2);
26613: xmlResetLastError();
26614: if (mem_base != xmlMemBlocks()) {
26615: printf("Leak of %d blocks found in xmlValidateNotationDecl",
26616: xmlMemBlocks() - mem_base);
26617: test_ret++;
26618: printf(" %d", n_ctxt);
26619: printf(" %d", n_doc);
26620: printf(" %d", n_nota);
26621: printf("\n");
26622: }
26623: }
26624: }
26625: }
26626: function_tests++;
26627: #endif
26628:
26629: return(test_ret);
26630: }
26631:
26632:
26633: static int
26634: test_xmlValidateNotationUse(void) {
26635: int test_ret = 0;
26636:
26637: #if defined(LIBXML_VALID_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
26638: int mem_base;
26639: int ret_val;
26640: xmlValidCtxtPtr ctxt; /* the validation context */
26641: int n_ctxt;
26642: xmlDocPtr doc; /* the document */
26643: int n_doc;
26644: xmlChar * notationName; /* the notation name to check */
26645: int n_notationName;
26646:
26647: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26648: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26649: for (n_notationName = 0;n_notationName < gen_nb_const_xmlChar_ptr;n_notationName++) {
26650: mem_base = xmlMemBlocks();
26651: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26652: doc = gen_xmlDocPtr(n_doc, 1);
26653: notationName = gen_const_xmlChar_ptr(n_notationName, 2);
26654:
26655: ret_val = xmlValidateNotationUse(ctxt, doc, (const xmlChar *)notationName);
26656: desret_int(ret_val);
26657: call_tests++;
26658: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26659: des_xmlDocPtr(n_doc, doc, 1);
26660: des_const_xmlChar_ptr(n_notationName, (const xmlChar *)notationName, 2);
26661: xmlResetLastError();
26662: if (mem_base != xmlMemBlocks()) {
26663: printf("Leak of %d blocks found in xmlValidateNotationUse",
26664: xmlMemBlocks() - mem_base);
26665: test_ret++;
26666: printf(" %d", n_ctxt);
26667: printf(" %d", n_doc);
26668: printf(" %d", n_notationName);
26669: printf("\n");
26670: }
26671: }
26672: }
26673: }
26674: function_tests++;
26675: #endif
26676:
26677: return(test_ret);
26678: }
26679:
26680:
26681: static int
26682: test_xmlValidateOneAttribute(void) {
26683: int test_ret = 0;
26684:
26685: #if defined(LIBXML_VALID_ENABLED)
26686: int mem_base;
26687: int ret_val;
26688: xmlValidCtxtPtr ctxt; /* the validation context */
26689: int n_ctxt;
26690: xmlDocPtr doc; /* a document instance */
26691: int n_doc;
26692: xmlNodePtr elem; /* an element instance */
26693: int n_elem;
26694: xmlAttrPtr attr; /* an attribute instance */
26695: int n_attr;
26696: xmlChar * value; /* the attribute value (without entities processing) */
26697: int n_value;
26698:
26699: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26700: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26701: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
26702: for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
26703: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
26704: mem_base = xmlMemBlocks();
26705: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26706: doc = gen_xmlDocPtr(n_doc, 1);
26707: elem = gen_xmlNodePtr(n_elem, 2);
26708: attr = gen_xmlAttrPtr(n_attr, 3);
26709: value = gen_const_xmlChar_ptr(n_value, 4);
26710:
26711: ret_val = xmlValidateOneAttribute(ctxt, doc, elem, attr, (const xmlChar *)value);
26712: desret_int(ret_val);
26713: call_tests++;
26714: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26715: des_xmlDocPtr(n_doc, doc, 1);
26716: des_xmlNodePtr(n_elem, elem, 2);
26717: des_xmlAttrPtr(n_attr, attr, 3);
26718: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 4);
26719: xmlResetLastError();
26720: if (mem_base != xmlMemBlocks()) {
26721: printf("Leak of %d blocks found in xmlValidateOneAttribute",
26722: xmlMemBlocks() - mem_base);
26723: test_ret++;
26724: printf(" %d", n_ctxt);
26725: printf(" %d", n_doc);
26726: printf(" %d", n_elem);
26727: printf(" %d", n_attr);
26728: printf(" %d", n_value);
26729: printf("\n");
26730: }
26731: }
26732: }
26733: }
26734: }
26735: }
26736: function_tests++;
26737: #endif
26738:
26739: return(test_ret);
26740: }
26741:
26742:
26743: static int
26744: test_xmlValidateOneElement(void) {
26745: int test_ret = 0;
26746:
26747: #if defined(LIBXML_VALID_ENABLED)
26748: int mem_base;
26749: int ret_val;
26750: xmlValidCtxtPtr ctxt; /* the validation context */
26751: int n_ctxt;
26752: xmlDocPtr doc; /* a document instance */
26753: int n_doc;
26754: xmlNodePtr elem; /* an element instance */
26755: int n_elem;
26756:
26757: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26758: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26759: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
26760: mem_base = xmlMemBlocks();
26761: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26762: doc = gen_xmlDocPtr(n_doc, 1);
26763: elem = gen_xmlNodePtr(n_elem, 2);
26764:
26765: ret_val = xmlValidateOneElement(ctxt, doc, elem);
26766: desret_int(ret_val);
26767: call_tests++;
26768: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26769: des_xmlDocPtr(n_doc, doc, 1);
26770: des_xmlNodePtr(n_elem, elem, 2);
26771: xmlResetLastError();
26772: if (mem_base != xmlMemBlocks()) {
26773: printf("Leak of %d blocks found in xmlValidateOneElement",
26774: xmlMemBlocks() - mem_base);
26775: test_ret++;
26776: printf(" %d", n_ctxt);
26777: printf(" %d", n_doc);
26778: printf(" %d", n_elem);
26779: printf("\n");
26780: }
26781: }
26782: }
26783: }
26784: function_tests++;
26785: #endif
26786:
26787: return(test_ret);
26788: }
26789:
26790:
26791: static int
26792: test_xmlValidateOneNamespace(void) {
26793: int test_ret = 0;
26794:
26795: #if defined(LIBXML_VALID_ENABLED)
26796: int mem_base;
26797: int ret_val;
26798: xmlValidCtxtPtr ctxt; /* the validation context */
26799: int n_ctxt;
26800: xmlDocPtr doc; /* a document instance */
26801: int n_doc;
26802: xmlNodePtr elem; /* an element instance */
26803: int n_elem;
26804: xmlChar * prefix; /* the namespace prefix */
26805: int n_prefix;
26806: xmlNsPtr ns; /* an namespace declaration instance */
26807: int n_ns;
26808: xmlChar * value; /* the attribute value (without entities processing) */
26809: int n_value;
26810:
26811: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26812: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26813: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
26814: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
26815: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
26816: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
26817: mem_base = xmlMemBlocks();
26818: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26819: doc = gen_xmlDocPtr(n_doc, 1);
26820: elem = gen_xmlNodePtr(n_elem, 2);
26821: prefix = gen_const_xmlChar_ptr(n_prefix, 3);
26822: ns = gen_xmlNsPtr(n_ns, 4);
26823: value = gen_const_xmlChar_ptr(n_value, 5);
26824:
26825: ret_val = xmlValidateOneNamespace(ctxt, doc, elem, (const xmlChar *)prefix, ns, (const xmlChar *)value);
26826: desret_int(ret_val);
26827: call_tests++;
26828: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26829: des_xmlDocPtr(n_doc, doc, 1);
26830: des_xmlNodePtr(n_elem, elem, 2);
26831: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 3);
26832: des_xmlNsPtr(n_ns, ns, 4);
26833: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 5);
26834: xmlResetLastError();
26835: if (mem_base != xmlMemBlocks()) {
26836: printf("Leak of %d blocks found in xmlValidateOneNamespace",
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_prefix);
26843: printf(" %d", n_ns);
26844: printf(" %d", n_value);
26845: printf("\n");
26846: }
26847: }
26848: }
26849: }
26850: }
26851: }
26852: }
26853: function_tests++;
26854: #endif
26855:
26856: return(test_ret);
26857: }
26858:
26859:
26860: static int
26861: test_xmlValidatePopElement(void) {
26862: int test_ret = 0;
26863:
26864: #if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED)
26865: int mem_base;
26866: int ret_val;
26867: xmlValidCtxtPtr ctxt; /* the validation context */
26868: int n_ctxt;
26869: xmlDocPtr doc; /* a document instance */
26870: int n_doc;
26871: xmlNodePtr elem; /* an element instance */
26872: int n_elem;
26873: xmlChar * qname; /* the qualified name as appearing in the serialization */
26874: int n_qname;
26875:
26876: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26877: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26878: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
26879: for (n_qname = 0;n_qname < gen_nb_const_xmlChar_ptr;n_qname++) {
26880: mem_base = xmlMemBlocks();
26881: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26882: doc = gen_xmlDocPtr(n_doc, 1);
26883: elem = gen_xmlNodePtr(n_elem, 2);
26884: qname = gen_const_xmlChar_ptr(n_qname, 3);
26885:
26886: ret_val = xmlValidatePopElement(ctxt, doc, elem, (const xmlChar *)qname);
26887: desret_int(ret_val);
26888: call_tests++;
26889: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26890: des_xmlDocPtr(n_doc, doc, 1);
26891: des_xmlNodePtr(n_elem, elem, 2);
26892: des_const_xmlChar_ptr(n_qname, (const xmlChar *)qname, 3);
26893: xmlResetLastError();
26894: if (mem_base != xmlMemBlocks()) {
26895: printf("Leak of %d blocks found in xmlValidatePopElement",
26896: xmlMemBlocks() - mem_base);
26897: test_ret++;
26898: printf(" %d", n_ctxt);
26899: printf(" %d", n_doc);
26900: printf(" %d", n_elem);
26901: printf(" %d", n_qname);
26902: printf("\n");
26903: }
26904: }
26905: }
26906: }
26907: }
26908: function_tests++;
26909: #endif
26910:
26911: return(test_ret);
26912: }
26913:
26914:
26915: static int
26916: test_xmlValidatePushCData(void) {
26917: int test_ret = 0;
26918:
26919: #if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED)
26920: int mem_base;
26921: int ret_val;
26922: xmlValidCtxtPtr ctxt; /* the validation context */
26923: int n_ctxt;
26924: xmlChar * data; /* some character data read */
26925: int n_data;
26926: int len; /* the lenght of the data */
26927: int n_len;
26928:
26929: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26930: for (n_data = 0;n_data < gen_nb_const_xmlChar_ptr;n_data++) {
26931: for (n_len = 0;n_len < gen_nb_int;n_len++) {
26932: mem_base = xmlMemBlocks();
26933: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26934: data = gen_const_xmlChar_ptr(n_data, 1);
26935: len = gen_int(n_len, 2);
26936:
26937: ret_val = xmlValidatePushCData(ctxt, (const xmlChar *)data, len);
26938: desret_int(ret_val);
26939: call_tests++;
26940: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26941: des_const_xmlChar_ptr(n_data, (const xmlChar *)data, 1);
26942: des_int(n_len, len, 2);
26943: xmlResetLastError();
26944: if (mem_base != xmlMemBlocks()) {
26945: printf("Leak of %d blocks found in xmlValidatePushCData",
26946: xmlMemBlocks() - mem_base);
26947: test_ret++;
26948: printf(" %d", n_ctxt);
26949: printf(" %d", n_data);
26950: printf(" %d", n_len);
26951: printf("\n");
26952: }
26953: }
26954: }
26955: }
26956: function_tests++;
26957: #endif
26958:
26959: return(test_ret);
26960: }
26961:
26962:
26963: static int
26964: test_xmlValidatePushElement(void) {
26965: int test_ret = 0;
26966:
26967: #if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED)
26968: int mem_base;
26969: int ret_val;
26970: xmlValidCtxtPtr ctxt; /* the validation context */
26971: int n_ctxt;
26972: xmlDocPtr doc; /* a document instance */
26973: int n_doc;
26974: xmlNodePtr elem; /* an element instance */
26975: int n_elem;
26976: xmlChar * qname; /* the qualified name as appearing in the serialization */
26977: int n_qname;
26978:
26979: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26980: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26981: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
26982: for (n_qname = 0;n_qname < gen_nb_const_xmlChar_ptr;n_qname++) {
26983: mem_base = xmlMemBlocks();
26984: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26985: doc = gen_xmlDocPtr(n_doc, 1);
26986: elem = gen_xmlNodePtr(n_elem, 2);
26987: qname = gen_const_xmlChar_ptr(n_qname, 3);
26988:
26989: ret_val = xmlValidatePushElement(ctxt, doc, elem, (const xmlChar *)qname);
26990: desret_int(ret_val);
26991: call_tests++;
26992: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26993: des_xmlDocPtr(n_doc, doc, 1);
26994: des_xmlNodePtr(n_elem, elem, 2);
26995: des_const_xmlChar_ptr(n_qname, (const xmlChar *)qname, 3);
26996: xmlResetLastError();
26997: if (mem_base != xmlMemBlocks()) {
26998: printf("Leak of %d blocks found in xmlValidatePushElement",
26999: xmlMemBlocks() - mem_base);
27000: test_ret++;
27001: printf(" %d", n_ctxt);
27002: printf(" %d", n_doc);
27003: printf(" %d", n_elem);
27004: printf(" %d", n_qname);
27005: printf("\n");
27006: }
27007: }
27008: }
27009: }
27010: }
27011: function_tests++;
27012: #endif
27013:
27014: return(test_ret);
27015: }
27016:
27017:
27018: static int
27019: test_xmlValidateRoot(void) {
27020: int test_ret = 0;
27021:
27022: #if defined(LIBXML_VALID_ENABLED)
27023: int mem_base;
27024: int ret_val;
27025: xmlValidCtxtPtr ctxt; /* the validation context */
27026: int n_ctxt;
27027: xmlDocPtr doc; /* a document instance */
27028: int n_doc;
27029:
27030: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
27031: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
27032: mem_base = xmlMemBlocks();
27033: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
27034: doc = gen_xmlDocPtr(n_doc, 1);
27035:
27036: ret_val = xmlValidateRoot(ctxt, doc);
27037: desret_int(ret_val);
27038: call_tests++;
27039: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
27040: des_xmlDocPtr(n_doc, doc, 1);
27041: xmlResetLastError();
27042: if (mem_base != xmlMemBlocks()) {
27043: printf("Leak of %d blocks found in xmlValidateRoot",
27044: xmlMemBlocks() - mem_base);
27045: test_ret++;
27046: printf(" %d", n_ctxt);
27047: printf(" %d", n_doc);
27048: printf("\n");
27049: }
27050: }
27051: }
27052: function_tests++;
27053: #endif
27054:
27055: return(test_ret);
27056: }
27057:
27058: static int
27059: test_valid(void) {
27060: int test_ret = 0;
27061:
27062: if (quiet == 0) printf("Testing valid : 50 of 70 functions ...\n");
27063: test_ret += test_xmlAddAttributeDecl();
27064: test_ret += test_xmlAddElementDecl();
27065: test_ret += test_xmlAddID();
27066: test_ret += test_xmlAddNotationDecl();
27067: test_ret += test_xmlAddRef();
27068: test_ret += test_xmlCopyAttributeTable();
27069: test_ret += test_xmlCopyDocElementContent();
27070: test_ret += test_xmlCopyElementContent();
27071: test_ret += test_xmlCopyElementTable();
27072: test_ret += test_xmlCopyEnumeration();
27073: test_ret += test_xmlCopyNotationTable();
27074: test_ret += test_xmlCreateEnumeration();
27075: test_ret += test_xmlDumpAttributeDecl();
27076: test_ret += test_xmlDumpAttributeTable();
27077: test_ret += test_xmlDumpElementDecl();
27078: test_ret += test_xmlDumpElementTable();
27079: test_ret += test_xmlDumpNotationDecl();
27080: test_ret += test_xmlDumpNotationTable();
27081: test_ret += test_xmlGetDtdAttrDesc();
27082: test_ret += test_xmlGetDtdElementDesc();
27083: test_ret += test_xmlGetDtdNotationDesc();
27084: test_ret += test_xmlGetDtdQAttrDesc();
27085: test_ret += test_xmlGetDtdQElementDesc();
27086: test_ret += test_xmlGetID();
27087: test_ret += test_xmlGetRefs();
27088: test_ret += test_xmlIsID();
27089: test_ret += test_xmlIsMixedElement();
27090: test_ret += test_xmlIsRef();
27091: test_ret += test_xmlNewDocElementContent();
27092: test_ret += test_xmlNewElementContent();
27093: test_ret += test_xmlNewValidCtxt();
27094: test_ret += test_xmlRemoveID();
27095: test_ret += test_xmlRemoveRef();
27096: test_ret += test_xmlSnprintfElementContent();
27097: test_ret += test_xmlSprintfElementContent();
27098: test_ret += test_xmlValidBuildContentModel();
27099: test_ret += test_xmlValidCtxtNormalizeAttributeValue();
27100: test_ret += test_xmlValidGetPotentialChildren();
27101: test_ret += test_xmlValidGetValidElements();
27102: test_ret += test_xmlValidNormalizeAttributeValue();
27103: test_ret += test_xmlValidateAttributeDecl();
27104: test_ret += test_xmlValidateAttributeValue();
27105: test_ret += test_xmlValidateDocument();
27106: test_ret += test_xmlValidateDocumentFinal();
27107: test_ret += test_xmlValidateDtd();
27108: test_ret += test_xmlValidateDtdFinal();
27109: test_ret += test_xmlValidateElement();
27110: test_ret += test_xmlValidateElementDecl();
27111: test_ret += test_xmlValidateNameValue();
27112: test_ret += test_xmlValidateNamesValue();
27113: test_ret += test_xmlValidateNmtokenValue();
27114: test_ret += test_xmlValidateNmtokensValue();
27115: test_ret += test_xmlValidateNotationDecl();
27116: test_ret += test_xmlValidateNotationUse();
27117: test_ret += test_xmlValidateOneAttribute();
27118: test_ret += test_xmlValidateOneElement();
27119: test_ret += test_xmlValidateOneNamespace();
27120: test_ret += test_xmlValidatePopElement();
27121: test_ret += test_xmlValidatePushCData();
27122: test_ret += test_xmlValidatePushElement();
27123: test_ret += test_xmlValidateRoot();
27124:
27125: if (test_ret != 0)
27126: printf("Module valid: %d errors\n", test_ret);
27127: return(test_ret);
27128: }
27129:
27130: static int
27131: test_xmlXIncludeNewContext(void) {
27132: int test_ret = 0;
27133:
27134:
27135: /* missing type support */
27136: return(test_ret);
27137: }
27138:
27139:
27140: static int
27141: test_xmlXIncludeProcess(void) {
27142: int test_ret = 0;
27143:
27144: #if defined(LIBXML_XINCLUDE_ENABLED)
27145: int mem_base;
27146: int ret_val;
27147: xmlDocPtr doc; /* an XML document */
27148: int n_doc;
27149:
27150: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
27151: mem_base = xmlMemBlocks();
27152: doc = gen_xmlDocPtr(n_doc, 0);
27153:
27154: ret_val = xmlXIncludeProcess(doc);
27155: desret_int(ret_val);
27156: call_tests++;
27157: des_xmlDocPtr(n_doc, doc, 0);
27158: xmlResetLastError();
27159: if (mem_base != xmlMemBlocks()) {
27160: printf("Leak of %d blocks found in xmlXIncludeProcess",
27161: xmlMemBlocks() - mem_base);
27162: test_ret++;
27163: printf(" %d", n_doc);
27164: printf("\n");
27165: }
27166: }
27167: function_tests++;
27168: #endif
27169:
27170: return(test_ret);
27171: }
27172:
27173:
27174: static int
27175: test_xmlXIncludeProcessFlags(void) {
27176: int test_ret = 0;
27177:
27178: #if defined(LIBXML_XINCLUDE_ENABLED)
27179: int mem_base;
27180: int ret_val;
27181: xmlDocPtr doc; /* an XML document */
27182: int n_doc;
27183: int flags; /* a set of xmlParserOption used for parsing XML includes */
27184: int n_flags;
27185:
27186: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
27187: for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
27188: mem_base = xmlMemBlocks();
27189: doc = gen_xmlDocPtr(n_doc, 0);
27190: flags = gen_int(n_flags, 1);
27191:
27192: ret_val = xmlXIncludeProcessFlags(doc, flags);
27193: desret_int(ret_val);
27194: call_tests++;
27195: des_xmlDocPtr(n_doc, doc, 0);
27196: des_int(n_flags, flags, 1);
27197: xmlResetLastError();
27198: if (mem_base != xmlMemBlocks()) {
27199: printf("Leak of %d blocks found in xmlXIncludeProcessFlags",
27200: xmlMemBlocks() - mem_base);
27201: test_ret++;
27202: printf(" %d", n_doc);
27203: printf(" %d", n_flags);
27204: printf("\n");
27205: }
27206: }
27207: }
27208: function_tests++;
27209: #endif
27210:
27211: return(test_ret);
27212: }
27213:
27214:
27215: static int
27216: test_xmlXIncludeProcessFlagsData(void) {
27217: int test_ret = 0;
27218:
27219: #if defined(LIBXML_XINCLUDE_ENABLED)
27220: int mem_base;
27221: int ret_val;
27222: xmlDocPtr doc; /* an XML document */
27223: int n_doc;
27224: int flags; /* a set of xmlParserOption used for parsing XML includes */
27225: int n_flags;
27226: void * data; /* application data that will be passed to the parser context in the _private field of the parser context(s) */
27227: int n_data;
27228:
27229: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
27230: for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
27231: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
27232: mem_base = xmlMemBlocks();
27233: doc = gen_xmlDocPtr(n_doc, 0);
27234: flags = gen_int(n_flags, 1);
27235: data = gen_userdata(n_data, 2);
27236:
27237: ret_val = xmlXIncludeProcessFlagsData(doc, flags, data);
27238: desret_int(ret_val);
27239: call_tests++;
27240: des_xmlDocPtr(n_doc, doc, 0);
27241: des_int(n_flags, flags, 1);
27242: des_userdata(n_data, data, 2);
27243: xmlResetLastError();
27244: if (mem_base != xmlMemBlocks()) {
27245: printf("Leak of %d blocks found in xmlXIncludeProcessFlagsData",
27246: xmlMemBlocks() - mem_base);
27247: test_ret++;
27248: printf(" %d", n_doc);
27249: printf(" %d", n_flags);
27250: printf(" %d", n_data);
27251: printf("\n");
27252: }
27253: }
27254: }
27255: }
27256: function_tests++;
27257: #endif
27258:
27259: return(test_ret);
27260: }
27261:
27262: #ifdef LIBXML_XINCLUDE_ENABLED
27263:
27264: #define gen_nb_xmlXIncludeCtxtPtr 1
27265: static xmlXIncludeCtxtPtr gen_xmlXIncludeCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
27266: return(NULL);
27267: }
27268: static void des_xmlXIncludeCtxtPtr(int no ATTRIBUTE_UNUSED, xmlXIncludeCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
27269: }
27270: #endif
27271:
27272:
27273: static int
27274: test_xmlXIncludeProcessNode(void) {
27275: int test_ret = 0;
27276:
27277: #if defined(LIBXML_XINCLUDE_ENABLED)
27278: int mem_base;
27279: int ret_val;
27280: xmlXIncludeCtxtPtr ctxt; /* an existing XInclude context */
27281: int n_ctxt;
27282: xmlNodePtr node; /* a node in an XML document */
27283: int n_node;
27284:
27285: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXIncludeCtxtPtr;n_ctxt++) {
27286: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
27287: mem_base = xmlMemBlocks();
27288: ctxt = gen_xmlXIncludeCtxtPtr(n_ctxt, 0);
27289: node = gen_xmlNodePtr(n_node, 1);
27290:
27291: ret_val = xmlXIncludeProcessNode(ctxt, node);
27292: desret_int(ret_val);
27293: call_tests++;
27294: des_xmlXIncludeCtxtPtr(n_ctxt, ctxt, 0);
27295: des_xmlNodePtr(n_node, node, 1);
27296: xmlResetLastError();
27297: if (mem_base != xmlMemBlocks()) {
27298: printf("Leak of %d blocks found in xmlXIncludeProcessNode",
27299: xmlMemBlocks() - mem_base);
27300: test_ret++;
27301: printf(" %d", n_ctxt);
27302: printf(" %d", n_node);
27303: printf("\n");
27304: }
27305: }
27306: }
27307: function_tests++;
27308: #endif
27309:
27310: return(test_ret);
27311: }
27312:
27313:
27314: static int
27315: test_xmlXIncludeProcessTree(void) {
27316: int test_ret = 0;
27317:
27318: #if defined(LIBXML_XINCLUDE_ENABLED)
27319: int mem_base;
27320: int ret_val;
27321: xmlNodePtr tree; /* a node in an XML document */
27322: int n_tree;
27323:
27324: for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) {
27325: mem_base = xmlMemBlocks();
27326: tree = gen_xmlNodePtr(n_tree, 0);
27327:
27328: ret_val = xmlXIncludeProcessTree(tree);
27329: desret_int(ret_val);
27330: call_tests++;
27331: des_xmlNodePtr(n_tree, tree, 0);
27332: xmlResetLastError();
27333: if (mem_base != xmlMemBlocks()) {
27334: printf("Leak of %d blocks found in xmlXIncludeProcessTree",
27335: xmlMemBlocks() - mem_base);
27336: test_ret++;
27337: printf(" %d", n_tree);
27338: printf("\n");
27339: }
27340: }
27341: function_tests++;
27342: #endif
27343:
27344: return(test_ret);
27345: }
27346:
27347:
27348: static int
27349: test_xmlXIncludeProcessTreeFlags(void) {
27350: int test_ret = 0;
27351:
27352: #if defined(LIBXML_XINCLUDE_ENABLED)
27353: int mem_base;
27354: int ret_val;
27355: xmlNodePtr tree; /* a node in an XML document */
27356: int n_tree;
27357: int flags; /* a set of xmlParserOption used for parsing XML includes */
27358: int n_flags;
27359:
27360: for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) {
27361: for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
27362: mem_base = xmlMemBlocks();
27363: tree = gen_xmlNodePtr(n_tree, 0);
27364: flags = gen_int(n_flags, 1);
27365:
27366: ret_val = xmlXIncludeProcessTreeFlags(tree, flags);
27367: desret_int(ret_val);
27368: call_tests++;
27369: des_xmlNodePtr(n_tree, tree, 0);
27370: des_int(n_flags, flags, 1);
27371: xmlResetLastError();
27372: if (mem_base != xmlMemBlocks()) {
27373: printf("Leak of %d blocks found in xmlXIncludeProcessTreeFlags",
27374: xmlMemBlocks() - mem_base);
27375: test_ret++;
27376: printf(" %d", n_tree);
27377: printf(" %d", n_flags);
27378: printf("\n");
27379: }
27380: }
27381: }
27382: function_tests++;
27383: #endif
27384:
27385: return(test_ret);
27386: }
27387:
27388:
27389: static int
27390: test_xmlXIncludeProcessTreeFlagsData(void) {
27391: int test_ret = 0;
27392:
27393: #if defined(LIBXML_XINCLUDE_ENABLED)
27394: int mem_base;
27395: int ret_val;
27396: xmlNodePtr tree; /* an XML node */
27397: int n_tree;
27398: int flags; /* a set of xmlParserOption used for parsing XML includes */
27399: int n_flags;
27400: void * data; /* application data that will be passed to the parser context in the _private field of the parser context(s) */
27401: int n_data;
27402:
27403: for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) {
27404: for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
27405: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
27406: mem_base = xmlMemBlocks();
27407: tree = gen_xmlNodePtr(n_tree, 0);
27408: flags = gen_int(n_flags, 1);
27409: data = gen_userdata(n_data, 2);
27410:
27411: ret_val = xmlXIncludeProcessTreeFlagsData(tree, flags, data);
27412: desret_int(ret_val);
27413: call_tests++;
27414: des_xmlNodePtr(n_tree, tree, 0);
27415: des_int(n_flags, flags, 1);
27416: des_userdata(n_data, data, 2);
27417: xmlResetLastError();
27418: if (mem_base != xmlMemBlocks()) {
27419: printf("Leak of %d blocks found in xmlXIncludeProcessTreeFlagsData",
27420: xmlMemBlocks() - mem_base);
27421: test_ret++;
27422: printf(" %d", n_tree);
27423: printf(" %d", n_flags);
27424: printf(" %d", n_data);
27425: printf("\n");
27426: }
27427: }
27428: }
27429: }
27430: function_tests++;
27431: #endif
27432:
27433: return(test_ret);
27434: }
27435:
27436:
27437: static int
27438: test_xmlXIncludeSetFlags(void) {
27439: int test_ret = 0;
27440:
27441: #if defined(LIBXML_XINCLUDE_ENABLED)
27442: int mem_base;
27443: int ret_val;
27444: xmlXIncludeCtxtPtr ctxt; /* an XInclude processing context */
27445: int n_ctxt;
27446: int flags; /* a set of xmlParserOption used for parsing XML includes */
27447: int n_flags;
27448:
27449: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXIncludeCtxtPtr;n_ctxt++) {
27450: for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
27451: mem_base = xmlMemBlocks();
27452: ctxt = gen_xmlXIncludeCtxtPtr(n_ctxt, 0);
27453: flags = gen_int(n_flags, 1);
27454:
27455: ret_val = xmlXIncludeSetFlags(ctxt, flags);
27456: desret_int(ret_val);
27457: call_tests++;
27458: des_xmlXIncludeCtxtPtr(n_ctxt, ctxt, 0);
27459: des_int(n_flags, flags, 1);
27460: xmlResetLastError();
27461: if (mem_base != xmlMemBlocks()) {
27462: printf("Leak of %d blocks found in xmlXIncludeSetFlags",
27463: xmlMemBlocks() - mem_base);
27464: test_ret++;
27465: printf(" %d", n_ctxt);
27466: printf(" %d", n_flags);
27467: printf("\n");
27468: }
27469: }
27470: }
27471: function_tests++;
27472: #endif
27473:
27474: return(test_ret);
27475: }
27476:
27477: static int
27478: test_xinclude(void) {
27479: int test_ret = 0;
27480:
27481: if (quiet == 0) printf("Testing xinclude : 8 of 10 functions ...\n");
27482: test_ret += test_xmlXIncludeNewContext();
27483: test_ret += test_xmlXIncludeProcess();
27484: test_ret += test_xmlXIncludeProcessFlags();
27485: test_ret += test_xmlXIncludeProcessFlagsData();
27486: test_ret += test_xmlXIncludeProcessNode();
27487: test_ret += test_xmlXIncludeProcessTree();
27488: test_ret += test_xmlXIncludeProcessTreeFlags();
27489: test_ret += test_xmlXIncludeProcessTreeFlagsData();
27490: test_ret += test_xmlXIncludeSetFlags();
27491:
27492: if (test_ret != 0)
27493: printf("Module xinclude: %d errors\n", test_ret);
27494: return(test_ret);
27495: }
27496:
27497: static int
27498: test_xmlAllocOutputBuffer(void) {
27499: int test_ret = 0;
27500:
27501: #if defined(LIBXML_OUTPUT_ENABLED)
27502: int mem_base;
27503: xmlOutputBufferPtr ret_val;
27504: xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */
27505: int n_encoder;
27506:
27507: for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) {
27508: mem_base = xmlMemBlocks();
27509: encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 0);
27510:
27511: ret_val = xmlAllocOutputBuffer(encoder);
27512: desret_xmlOutputBufferPtr(ret_val);
27513: call_tests++;
27514: des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 0);
27515: xmlResetLastError();
27516: if (mem_base != xmlMemBlocks()) {
27517: printf("Leak of %d blocks found in xmlAllocOutputBuffer",
27518: xmlMemBlocks() - mem_base);
27519: test_ret++;
27520: printf(" %d", n_encoder);
27521: printf("\n");
27522: }
27523: }
27524: function_tests++;
27525: #endif
27526:
27527: return(test_ret);
27528: }
27529:
27530:
27531: static int
27532: test_xmlAllocParserInputBuffer(void) {
27533: int test_ret = 0;
27534:
27535: int mem_base;
27536: xmlParserInputBufferPtr ret_val;
27537: xmlCharEncoding enc; /* the charset encoding if known */
27538: int n_enc;
27539:
27540: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
27541: mem_base = xmlMemBlocks();
27542: enc = gen_xmlCharEncoding(n_enc, 0);
27543:
27544: ret_val = xmlAllocParserInputBuffer(enc);
27545: desret_xmlParserInputBufferPtr(ret_val);
27546: call_tests++;
27547: des_xmlCharEncoding(n_enc, enc, 0);
27548: xmlResetLastError();
27549: if (mem_base != xmlMemBlocks()) {
27550: printf("Leak of %d blocks found in xmlAllocParserInputBuffer",
27551: xmlMemBlocks() - mem_base);
27552: test_ret++;
27553: printf(" %d", n_enc);
27554: printf("\n");
27555: }
27556: }
27557: function_tests++;
27558:
27559: return(test_ret);
27560: }
27561:
27562:
27563: static int
27564: test_xmlCheckFilename(void) {
27565: int test_ret = 0;
27566:
27567: int mem_base;
27568: int ret_val;
27569: char * path; /* the path to check */
27570: int n_path;
27571:
27572: for (n_path = 0;n_path < gen_nb_const_char_ptr;n_path++) {
27573: mem_base = xmlMemBlocks();
27574: path = gen_const_char_ptr(n_path, 0);
27575:
27576: ret_val = xmlCheckFilename((const char *)path);
27577: desret_int(ret_val);
27578: call_tests++;
27579: des_const_char_ptr(n_path, (const char *)path, 0);
27580: xmlResetLastError();
27581: if (mem_base != xmlMemBlocks()) {
27582: printf("Leak of %d blocks found in xmlCheckFilename",
27583: xmlMemBlocks() - mem_base);
27584: test_ret++;
27585: printf(" %d", n_path);
27586: printf("\n");
27587: }
27588: }
27589: function_tests++;
27590:
27591: return(test_ret);
27592: }
27593:
27594:
27595: static int
27596: test_xmlCheckHTTPInput(void) {
27597: int test_ret = 0;
27598:
27599: int mem_base;
27600: xmlParserInputPtr ret_val;
27601: xmlParserCtxtPtr ctxt; /* an XML parser context */
27602: int n_ctxt;
27603: xmlParserInputPtr ret; /* an XML parser input */
27604: int n_ret;
27605:
27606: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
27607: for (n_ret = 0;n_ret < gen_nb_xmlParserInputPtr;n_ret++) {
27608: mem_base = xmlMemBlocks();
27609: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
27610: ret = gen_xmlParserInputPtr(n_ret, 1);
27611:
27612: ret_val = xmlCheckHTTPInput(ctxt, ret);
27613: desret_xmlParserInputPtr(ret_val);
27614: call_tests++;
27615: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
27616: des_xmlParserInputPtr(n_ret, ret, 1);
27617: xmlResetLastError();
27618: if (mem_base != xmlMemBlocks()) {
27619: printf("Leak of %d blocks found in xmlCheckHTTPInput",
27620: xmlMemBlocks() - mem_base);
27621: test_ret++;
27622: printf(" %d", n_ctxt);
27623: printf(" %d", n_ret);
27624: printf("\n");
27625: }
27626: }
27627: }
27628: function_tests++;
27629:
27630: return(test_ret);
27631: }
27632:
27633:
27634: static int
27635: test_xmlCleanupInputCallbacks(void) {
27636: int test_ret = 0;
27637:
27638: int mem_base;
27639:
27640: mem_base = xmlMemBlocks();
27641:
27642: xmlCleanupInputCallbacks();
27643: call_tests++;
27644: xmlResetLastError();
27645: if (mem_base != xmlMemBlocks()) {
27646: printf("Leak of %d blocks found in xmlCleanupInputCallbacks",
27647: xmlMemBlocks() - mem_base);
27648: test_ret++;
27649: printf("\n");
27650: }
27651: function_tests++;
27652:
27653: return(test_ret);
27654: }
27655:
27656:
27657: static int
27658: test_xmlCleanupOutputCallbacks(void) {
27659: int test_ret = 0;
27660:
27661: #if defined(LIBXML_OUTPUT_ENABLED)
27662: int mem_base;
27663:
27664: mem_base = xmlMemBlocks();
27665:
27666: xmlCleanupOutputCallbacks();
27667: call_tests++;
27668: xmlResetLastError();
27669: if (mem_base != xmlMemBlocks()) {
27670: printf("Leak of %d blocks found in xmlCleanupOutputCallbacks",
27671: xmlMemBlocks() - mem_base);
27672: test_ret++;
27673: printf("\n");
27674: }
27675: function_tests++;
27676: #endif
27677:
27678: return(test_ret);
27679: }
27680:
27681:
27682: static int
27683: test_xmlFileClose(void) {
27684: int test_ret = 0;
27685:
27686: int mem_base;
27687: int ret_val;
27688: void * context; /* the I/O context */
27689: int n_context;
27690:
27691: for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
27692: mem_base = xmlMemBlocks();
27693: context = gen_void_ptr(n_context, 0);
27694:
27695: ret_val = xmlFileClose(context);
27696: desret_int(ret_val);
27697: call_tests++;
27698: des_void_ptr(n_context, context, 0);
27699: xmlResetLastError();
27700: if (mem_base != xmlMemBlocks()) {
27701: printf("Leak of %d blocks found in xmlFileClose",
27702: xmlMemBlocks() - mem_base);
27703: test_ret++;
27704: printf(" %d", n_context);
27705: printf("\n");
27706: }
27707: }
27708: function_tests++;
27709:
27710: return(test_ret);
27711: }
27712:
27713:
27714: static int
27715: test_xmlFileMatch(void) {
27716: int test_ret = 0;
27717:
27718: int mem_base;
27719: int ret_val;
27720: const char * filename; /* the URI for matching */
27721: int n_filename;
27722:
27723: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
27724: mem_base = xmlMemBlocks();
27725: filename = gen_filepath(n_filename, 0);
27726:
27727: ret_val = xmlFileMatch(filename);
27728: desret_int(ret_val);
27729: call_tests++;
27730: des_filepath(n_filename, filename, 0);
27731: xmlResetLastError();
27732: if (mem_base != xmlMemBlocks()) {
27733: printf("Leak of %d blocks found in xmlFileMatch",
27734: xmlMemBlocks() - mem_base);
27735: test_ret++;
27736: printf(" %d", n_filename);
27737: printf("\n");
27738: }
27739: }
27740: function_tests++;
27741:
27742: return(test_ret);
27743: }
27744:
27745:
27746: static int
27747: test_xmlFileOpen(void) {
27748: int test_ret = 0;
27749:
27750: int mem_base;
27751: void * ret_val;
27752: const char * filename; /* the URI for matching */
27753: int n_filename;
27754:
27755: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
27756: mem_base = xmlMemBlocks();
27757: filename = gen_filepath(n_filename, 0);
27758:
27759: ret_val = xmlFileOpen(filename);
27760: desret_void_ptr(ret_val);
27761: call_tests++;
27762: des_filepath(n_filename, filename, 0);
27763: xmlResetLastError();
27764: if (mem_base != xmlMemBlocks()) {
27765: printf("Leak of %d blocks found in xmlFileOpen",
27766: xmlMemBlocks() - mem_base);
27767: test_ret++;
27768: printf(" %d", n_filename);
27769: printf("\n");
27770: }
27771: }
27772: function_tests++;
27773:
27774: return(test_ret);
27775: }
27776:
27777:
27778: static int
27779: test_xmlFileRead(void) {
27780: int test_ret = 0;
27781:
27782: int mem_base;
27783: int ret_val;
27784: void * context; /* the I/O context */
27785: int n_context;
27786: char * buffer; /* where to drop data */
27787: int n_buffer;
27788: int len; /* number of bytes to write */
27789: int n_len;
27790:
27791: for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
27792: for (n_buffer = 0;n_buffer < gen_nb_char_ptr;n_buffer++) {
27793: for (n_len = 0;n_len < gen_nb_int;n_len++) {
27794: mem_base = xmlMemBlocks();
27795: context = gen_void_ptr(n_context, 0);
27796: buffer = gen_char_ptr(n_buffer, 1);
27797: len = gen_int(n_len, 2);
27798:
27799: ret_val = xmlFileRead(context, buffer, len);
27800: desret_int(ret_val);
27801: call_tests++;
27802: des_void_ptr(n_context, context, 0);
27803: des_char_ptr(n_buffer, buffer, 1);
27804: des_int(n_len, len, 2);
27805: xmlResetLastError();
27806: if (mem_base != xmlMemBlocks()) {
27807: printf("Leak of %d blocks found in xmlFileRead",
27808: xmlMemBlocks() - mem_base);
27809: test_ret++;
27810: printf(" %d", n_context);
27811: printf(" %d", n_buffer);
27812: printf(" %d", n_len);
27813: printf("\n");
27814: }
27815: }
27816: }
27817: }
27818: function_tests++;
27819:
27820: return(test_ret);
27821: }
27822:
27823:
27824: static int
27825: test_xmlIOFTPClose(void) {
27826: int test_ret = 0;
27827:
27828: #if defined(LIBXML_FTP_ENABLED)
27829: int mem_base;
27830: int ret_val;
27831: void * context; /* the I/O context */
27832: int n_context;
27833:
27834: for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
27835: mem_base = xmlMemBlocks();
27836: context = gen_void_ptr(n_context, 0);
27837:
27838: ret_val = xmlIOFTPClose(context);
27839: desret_int(ret_val);
27840: call_tests++;
27841: des_void_ptr(n_context, context, 0);
27842: xmlResetLastError();
27843: if (mem_base != xmlMemBlocks()) {
27844: printf("Leak of %d blocks found in xmlIOFTPClose",
27845: xmlMemBlocks() - mem_base);
27846: test_ret++;
27847: printf(" %d", n_context);
27848: printf("\n");
27849: }
27850: }
27851: function_tests++;
27852: #endif
27853:
27854: return(test_ret);
27855: }
27856:
27857:
27858: static int
27859: test_xmlIOFTPMatch(void) {
27860: int test_ret = 0;
27861:
27862: #if defined(LIBXML_FTP_ENABLED)
27863: int mem_base;
27864: int ret_val;
27865: const char * filename; /* the URI for matching */
27866: int n_filename;
27867:
27868: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
27869: mem_base = xmlMemBlocks();
27870: filename = gen_filepath(n_filename, 0);
27871:
27872: ret_val = xmlIOFTPMatch(filename);
27873: desret_int(ret_val);
27874: call_tests++;
27875: des_filepath(n_filename, filename, 0);
27876: xmlResetLastError();
27877: if (mem_base != xmlMemBlocks()) {
27878: printf("Leak of %d blocks found in xmlIOFTPMatch",
27879: xmlMemBlocks() - mem_base);
27880: test_ret++;
27881: printf(" %d", n_filename);
27882: printf("\n");
27883: }
27884: }
27885: function_tests++;
27886: #endif
27887:
27888: return(test_ret);
27889: }
27890:
27891:
27892: static int
27893: test_xmlIOFTPOpen(void) {
27894: int test_ret = 0;
27895:
27896: #if defined(LIBXML_FTP_ENABLED)
27897: int mem_base;
27898: void * ret_val;
27899: const char * filename; /* the URI for matching */
27900: int n_filename;
27901:
27902: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
27903: mem_base = xmlMemBlocks();
27904: filename = gen_filepath(n_filename, 0);
27905:
27906: ret_val = xmlIOFTPOpen(filename);
27907: desret_void_ptr(ret_val);
27908: call_tests++;
27909: des_filepath(n_filename, filename, 0);
27910: xmlResetLastError();
27911: if (mem_base != xmlMemBlocks()) {
27912: printf("Leak of %d blocks found in xmlIOFTPOpen",
27913: xmlMemBlocks() - mem_base);
27914: test_ret++;
27915: printf(" %d", n_filename);
27916: printf("\n");
27917: }
27918: }
27919: function_tests++;
27920: #endif
27921:
27922: return(test_ret);
27923: }
27924:
27925:
27926: static int
27927: test_xmlIOFTPRead(void) {
27928: int test_ret = 0;
27929:
27930: #if defined(LIBXML_FTP_ENABLED)
27931: int mem_base;
27932: int ret_val;
27933: void * context; /* the I/O context */
27934: int n_context;
27935: char * buffer; /* where to drop data */
27936: int n_buffer;
27937: int len; /* number of bytes to write */
27938: int n_len;
27939:
27940: for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
27941: for (n_buffer = 0;n_buffer < gen_nb_char_ptr;n_buffer++) {
27942: for (n_len = 0;n_len < gen_nb_int;n_len++) {
27943: mem_base = xmlMemBlocks();
27944: context = gen_void_ptr(n_context, 0);
27945: buffer = gen_char_ptr(n_buffer, 1);
27946: len = gen_int(n_len, 2);
27947:
27948: ret_val = xmlIOFTPRead(context, buffer, len);
27949: desret_int(ret_val);
27950: call_tests++;
27951: des_void_ptr(n_context, context, 0);
27952: des_char_ptr(n_buffer, buffer, 1);
27953: des_int(n_len, len, 2);
27954: xmlResetLastError();
27955: if (mem_base != xmlMemBlocks()) {
27956: printf("Leak of %d blocks found in xmlIOFTPRead",
27957: xmlMemBlocks() - mem_base);
27958: test_ret++;
27959: printf(" %d", n_context);
27960: printf(" %d", n_buffer);
27961: printf(" %d", n_len);
27962: printf("\n");
27963: }
27964: }
27965: }
27966: }
27967: function_tests++;
27968: #endif
27969:
27970: return(test_ret);
27971: }
27972:
27973:
27974: static int
27975: test_xmlIOHTTPClose(void) {
27976: int test_ret = 0;
27977:
27978: #if defined(LIBXML_HTTP_ENABLED)
27979: int mem_base;
27980: int ret_val;
27981: void * context; /* the I/O context */
27982: int n_context;
27983:
27984: for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
27985: mem_base = xmlMemBlocks();
27986: context = gen_void_ptr(n_context, 0);
27987:
27988: ret_val = xmlIOHTTPClose(context);
27989: desret_int(ret_val);
27990: call_tests++;
27991: des_void_ptr(n_context, context, 0);
27992: xmlResetLastError();
27993: if (mem_base != xmlMemBlocks()) {
27994: printf("Leak of %d blocks found in xmlIOHTTPClose",
27995: xmlMemBlocks() - mem_base);
27996: test_ret++;
27997: printf(" %d", n_context);
27998: printf("\n");
27999: }
28000: }
28001: function_tests++;
28002: #endif
28003:
28004: return(test_ret);
28005: }
28006:
28007:
28008: static int
28009: test_xmlIOHTTPMatch(void) {
28010: int test_ret = 0;
28011:
28012: #if defined(LIBXML_HTTP_ENABLED)
28013: int mem_base;
28014: int ret_val;
28015: const char * filename; /* the URI for matching */
28016: int n_filename;
28017:
28018: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
28019: mem_base = xmlMemBlocks();
28020: filename = gen_filepath(n_filename, 0);
28021:
28022: ret_val = xmlIOHTTPMatch(filename);
28023: desret_int(ret_val);
28024: call_tests++;
28025: des_filepath(n_filename, filename, 0);
28026: xmlResetLastError();
28027: if (mem_base != xmlMemBlocks()) {
28028: printf("Leak of %d blocks found in xmlIOHTTPMatch",
28029: xmlMemBlocks() - mem_base);
28030: test_ret++;
28031: printf(" %d", n_filename);
28032: printf("\n");
28033: }
28034: }
28035: function_tests++;
28036: #endif
28037:
28038: return(test_ret);
28039: }
28040:
28041:
28042: static int
28043: test_xmlIOHTTPOpen(void) {
28044: int test_ret = 0;
28045:
28046: #if defined(LIBXML_HTTP_ENABLED)
28047: int mem_base;
28048: void * ret_val;
28049: const char * filename; /* the URI for matching */
28050: int n_filename;
28051:
28052: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
28053: mem_base = xmlMemBlocks();
28054: filename = gen_filepath(n_filename, 0);
28055:
28056: ret_val = xmlIOHTTPOpen(filename);
28057: desret_xmlNanoHTTPCtxtPtr(ret_val);
28058: call_tests++;
28059: des_filepath(n_filename, filename, 0);
28060: xmlResetLastError();
28061: if (mem_base != xmlMemBlocks()) {
28062: printf("Leak of %d blocks found in xmlIOHTTPOpen",
28063: xmlMemBlocks() - mem_base);
28064: test_ret++;
28065: printf(" %d", n_filename);
28066: printf("\n");
28067: }
28068: }
28069: function_tests++;
28070: #endif
28071:
28072: return(test_ret);
28073: }
28074:
28075:
28076: static int
28077: test_xmlIOHTTPRead(void) {
28078: int test_ret = 0;
28079:
28080: #if defined(LIBXML_HTTP_ENABLED)
28081: int mem_base;
28082: int ret_val;
28083: void * context; /* the I/O context */
28084: int n_context;
28085: char * buffer; /* where to drop data */
28086: int n_buffer;
28087: int len; /* number of bytes to write */
28088: int n_len;
28089:
28090: for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
28091: for (n_buffer = 0;n_buffer < gen_nb_char_ptr;n_buffer++) {
28092: for (n_len = 0;n_len < gen_nb_int;n_len++) {
28093: mem_base = xmlMemBlocks();
28094: context = gen_void_ptr(n_context, 0);
28095: buffer = gen_char_ptr(n_buffer, 1);
28096: len = gen_int(n_len, 2);
28097:
28098: ret_val = xmlIOHTTPRead(context, buffer, len);
28099: desret_int(ret_val);
28100: call_tests++;
28101: des_void_ptr(n_context, context, 0);
28102: des_char_ptr(n_buffer, buffer, 1);
28103: des_int(n_len, len, 2);
28104: xmlResetLastError();
28105: if (mem_base != xmlMemBlocks()) {
28106: printf("Leak of %d blocks found in xmlIOHTTPRead",
28107: xmlMemBlocks() - mem_base);
28108: test_ret++;
28109: printf(" %d", n_context);
28110: printf(" %d", n_buffer);
28111: printf(" %d", n_len);
28112: printf("\n");
28113: }
28114: }
28115: }
28116: }
28117: function_tests++;
28118: #endif
28119:
28120: return(test_ret);
28121: }
28122:
28123:
28124: static int
28125: test_xmlNoNetExternalEntityLoader(void) {
28126: int test_ret = 0;
28127:
28128: int mem_base;
28129: xmlParserInputPtr ret_val;
28130: const char * URL; /* the URL for the entity to load */
28131: int n_URL;
28132: char * ID; /* the System ID for the entity to load */
28133: int n_ID;
28134: xmlParserCtxtPtr ctxt; /* the context in which the entity is called or NULL */
28135: int n_ctxt;
28136:
28137: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
28138: for (n_ID = 0;n_ID < gen_nb_const_char_ptr;n_ID++) {
28139: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
28140: mem_base = xmlMemBlocks();
28141: URL = gen_filepath(n_URL, 0);
28142: ID = gen_const_char_ptr(n_ID, 1);
28143: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 2);
28144:
28145: ret_val = xmlNoNetExternalEntityLoader(URL, (const char *)ID, ctxt);
28146: desret_xmlParserInputPtr(ret_val);
28147: call_tests++;
28148: des_filepath(n_URL, URL, 0);
28149: des_const_char_ptr(n_ID, (const char *)ID, 1);
28150: des_xmlParserCtxtPtr(n_ctxt, ctxt, 2);
28151: xmlResetLastError();
28152: if (mem_base != xmlMemBlocks()) {
28153: printf("Leak of %d blocks found in xmlNoNetExternalEntityLoader",
28154: xmlMemBlocks() - mem_base);
28155: test_ret++;
28156: printf(" %d", n_URL);
28157: printf(" %d", n_ID);
28158: printf(" %d", n_ctxt);
28159: printf("\n");
28160: }
28161: }
28162: }
28163: }
28164: function_tests++;
28165:
28166: return(test_ret);
28167: }
28168:
28169:
28170: static int
28171: test_xmlNormalizeWindowsPath(void) {
28172: int test_ret = 0;
28173:
28174: int mem_base;
28175: xmlChar * ret_val;
28176: xmlChar * path; /* the input file path */
28177: int n_path;
28178:
28179: for (n_path = 0;n_path < gen_nb_const_xmlChar_ptr;n_path++) {
28180: mem_base = xmlMemBlocks();
28181: path = gen_const_xmlChar_ptr(n_path, 0);
28182:
28183: ret_val = xmlNormalizeWindowsPath((const xmlChar *)path);
28184: desret_xmlChar_ptr(ret_val);
28185: call_tests++;
28186: des_const_xmlChar_ptr(n_path, (const xmlChar *)path, 0);
28187: xmlResetLastError();
28188: if (mem_base != xmlMemBlocks()) {
28189: printf("Leak of %d blocks found in xmlNormalizeWindowsPath",
28190: xmlMemBlocks() - mem_base);
28191: test_ret++;
28192: printf(" %d", n_path);
28193: printf("\n");
28194: }
28195: }
28196: function_tests++;
28197:
28198: return(test_ret);
28199: }
28200:
28201:
28202: static int
28203: test_xmlOutputBufferCreateBuffer(void) {
28204: int test_ret = 0;
28205:
28206: #if defined(LIBXML_OUTPUT_ENABLED)
28207: int mem_base;
28208: xmlOutputBufferPtr ret_val;
28209: xmlBufferPtr buffer; /* a xmlBufferPtr */
28210: int n_buffer;
28211: xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */
28212: int n_encoder;
28213:
28214: for (n_buffer = 0;n_buffer < gen_nb_xmlBufferPtr;n_buffer++) {
28215: for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) {
28216: mem_base = xmlMemBlocks();
28217: buffer = gen_xmlBufferPtr(n_buffer, 0);
28218: encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 1);
28219:
28220: ret_val = xmlOutputBufferCreateBuffer(buffer, encoder);
28221: desret_xmlOutputBufferPtr(ret_val);
28222: call_tests++;
28223: des_xmlBufferPtr(n_buffer, buffer, 0);
28224: des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 1);
28225: xmlResetLastError();
28226: if (mem_base != xmlMemBlocks()) {
28227: printf("Leak of %d blocks found in xmlOutputBufferCreateBuffer",
28228: xmlMemBlocks() - mem_base);
28229: test_ret++;
28230: printf(" %d", n_buffer);
28231: printf(" %d", n_encoder);
28232: printf("\n");
28233: }
28234: }
28235: }
28236: function_tests++;
28237: #endif
28238:
28239: return(test_ret);
28240: }
28241:
28242:
28243: static int
28244: test_xmlOutputBufferCreateFd(void) {
28245: int test_ret = 0;
28246:
28247: #if defined(LIBXML_OUTPUT_ENABLED)
28248: int mem_base;
28249: xmlOutputBufferPtr ret_val;
28250: int fd; /* a file descriptor number */
28251: int n_fd;
28252: xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */
28253: int n_encoder;
28254:
28255: for (n_fd = 0;n_fd < gen_nb_int;n_fd++) {
28256: for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) {
28257: mem_base = xmlMemBlocks();
28258: fd = gen_int(n_fd, 0);
28259: encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 1);
28260:
28261: ret_val = xmlOutputBufferCreateFd(fd, encoder);
28262: desret_xmlOutputBufferPtr(ret_val);
28263: call_tests++;
28264: des_int(n_fd, fd, 0);
28265: des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 1);
28266: xmlResetLastError();
28267: if (mem_base != xmlMemBlocks()) {
28268: printf("Leak of %d blocks found in xmlOutputBufferCreateFd",
28269: xmlMemBlocks() - mem_base);
28270: test_ret++;
28271: printf(" %d", n_fd);
28272: printf(" %d", n_encoder);
28273: printf("\n");
28274: }
28275: }
28276: }
28277: function_tests++;
28278: #endif
28279:
28280: return(test_ret);
28281: }
28282:
28283:
28284: static int
28285: test_xmlOutputBufferCreateFile(void) {
28286: int test_ret = 0;
28287:
28288: #if defined(LIBXML_OUTPUT_ENABLED)
28289: int mem_base;
28290: xmlOutputBufferPtr ret_val;
28291: FILE * file; /* a FILE* */
28292: int n_file;
28293: xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */
28294: int n_encoder;
28295:
28296: for (n_file = 0;n_file < gen_nb_FILE_ptr;n_file++) {
28297: for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) {
28298: mem_base = xmlMemBlocks();
28299: file = gen_FILE_ptr(n_file, 0);
28300: encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 1);
28301:
28302: ret_val = xmlOutputBufferCreateFile(file, encoder);
28303: desret_xmlOutputBufferPtr(ret_val);
28304: call_tests++;
28305: des_FILE_ptr(n_file, file, 0);
28306: des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 1);
28307: xmlResetLastError();
28308: if (mem_base != xmlMemBlocks()) {
28309: printf("Leak of %d blocks found in xmlOutputBufferCreateFile",
28310: xmlMemBlocks() - mem_base);
28311: test_ret++;
28312: printf(" %d", n_file);
28313: printf(" %d", n_encoder);
28314: printf("\n");
28315: }
28316: }
28317: }
28318: function_tests++;
28319: #endif
28320:
28321: return(test_ret);
28322: }
28323:
28324:
28325: static int
28326: test_xmlOutputBufferCreateFilename(void) {
28327: int test_ret = 0;
28328:
28329: #if defined(LIBXML_OUTPUT_ENABLED)
28330: int mem_base;
28331: xmlOutputBufferPtr ret_val;
28332: const char * URI; /* a C string containing the URI or filename */
28333: int n_URI;
28334: xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */
28335: int n_encoder;
28336: int compression; /* the compression ration (0 none, 9 max). */
28337: int n_compression;
28338:
28339: for (n_URI = 0;n_URI < gen_nb_fileoutput;n_URI++) {
28340: for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) {
28341: for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
28342: mem_base = xmlMemBlocks();
28343: URI = gen_fileoutput(n_URI, 0);
28344: encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 1);
28345: compression = gen_int(n_compression, 2);
28346:
28347: ret_val = xmlOutputBufferCreateFilename(URI, encoder, compression);
28348: desret_xmlOutputBufferPtr(ret_val);
28349: call_tests++;
28350: des_fileoutput(n_URI, URI, 0);
28351: des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 1);
28352: des_int(n_compression, compression, 2);
28353: xmlResetLastError();
28354: if (mem_base != xmlMemBlocks()) {
28355: printf("Leak of %d blocks found in xmlOutputBufferCreateFilename",
28356: xmlMemBlocks() - mem_base);
28357: test_ret++;
28358: printf(" %d", n_URI);
28359: printf(" %d", n_encoder);
28360: printf(" %d", n_compression);
28361: printf("\n");
28362: }
28363: }
28364: }
28365: }
28366: function_tests++;
28367: #endif
28368:
28369: return(test_ret);
28370: }
28371:
28372:
28373: static int
28374: test_xmlOutputBufferFlush(void) {
28375: int test_ret = 0;
28376:
28377: #if defined(LIBXML_OUTPUT_ENABLED)
28378: int mem_base;
28379: int ret_val;
28380: xmlOutputBufferPtr out; /* a buffered output */
28381: int n_out;
28382:
28383: for (n_out = 0;n_out < gen_nb_xmlOutputBufferPtr;n_out++) {
28384: mem_base = xmlMemBlocks();
28385: out = gen_xmlOutputBufferPtr(n_out, 0);
28386:
28387: ret_val = xmlOutputBufferFlush(out);
28388: desret_int(ret_val);
28389: call_tests++;
28390: des_xmlOutputBufferPtr(n_out, out, 0);
28391: xmlResetLastError();
28392: if (mem_base != xmlMemBlocks()) {
28393: printf("Leak of %d blocks found in xmlOutputBufferFlush",
28394: xmlMemBlocks() - mem_base);
28395: test_ret++;
28396: printf(" %d", n_out);
28397: printf("\n");
28398: }
28399: }
28400: function_tests++;
28401: #endif
28402:
28403: return(test_ret);
28404: }
28405:
28406:
28407: static int
28408: test_xmlOutputBufferWrite(void) {
28409: int test_ret = 0;
28410:
28411: #if defined(LIBXML_OUTPUT_ENABLED)
28412: int mem_base;
28413: int ret_val;
28414: xmlOutputBufferPtr out; /* a buffered parser output */
28415: int n_out;
28416: int len; /* the size in bytes of the array. */
28417: int n_len;
28418: char * buf; /* an char array */
28419: int n_buf;
28420:
28421: for (n_out = 0;n_out < gen_nb_xmlOutputBufferPtr;n_out++) {
28422: for (n_len = 0;n_len < gen_nb_int;n_len++) {
28423: for (n_buf = 0;n_buf < gen_nb_const_char_ptr;n_buf++) {
28424: mem_base = xmlMemBlocks();
28425: out = gen_xmlOutputBufferPtr(n_out, 0);
28426: len = gen_int(n_len, 1);
28427: buf = gen_const_char_ptr(n_buf, 2);
28428:
28429: ret_val = xmlOutputBufferWrite(out, len, (const char *)buf);
28430: desret_int(ret_val);
28431: call_tests++;
28432: des_xmlOutputBufferPtr(n_out, out, 0);
28433: des_int(n_len, len, 1);
28434: des_const_char_ptr(n_buf, (const char *)buf, 2);
28435: xmlResetLastError();
28436: if (mem_base != xmlMemBlocks()) {
28437: printf("Leak of %d blocks found in xmlOutputBufferWrite",
28438: xmlMemBlocks() - mem_base);
28439: test_ret++;
28440: printf(" %d", n_out);
28441: printf(" %d", n_len);
28442: printf(" %d", n_buf);
28443: printf("\n");
28444: }
28445: }
28446: }
28447: }
28448: function_tests++;
28449: #endif
28450:
28451: return(test_ret);
28452: }
28453:
28454:
28455: static int
28456: test_xmlOutputBufferWriteEscape(void) {
28457: int test_ret = 0;
28458:
28459:
28460: /* missing type support */
28461: return(test_ret);
28462: }
28463:
28464:
28465: static int
28466: test_xmlOutputBufferWriteString(void) {
28467: int test_ret = 0;
28468:
28469: #if defined(LIBXML_OUTPUT_ENABLED)
28470: int mem_base;
28471: int ret_val;
28472: xmlOutputBufferPtr out; /* a buffered parser output */
28473: int n_out;
28474: char * str; /* a zero terminated C string */
28475: int n_str;
28476:
28477: for (n_out = 0;n_out < gen_nb_xmlOutputBufferPtr;n_out++) {
28478: for (n_str = 0;n_str < gen_nb_const_char_ptr;n_str++) {
28479: mem_base = xmlMemBlocks();
28480: out = gen_xmlOutputBufferPtr(n_out, 0);
28481: str = gen_const_char_ptr(n_str, 1);
28482:
28483: ret_val = xmlOutputBufferWriteString(out, (const char *)str);
28484: desret_int(ret_val);
28485: call_tests++;
28486: des_xmlOutputBufferPtr(n_out, out, 0);
28487: des_const_char_ptr(n_str, (const char *)str, 1);
28488: xmlResetLastError();
28489: if (mem_base != xmlMemBlocks()) {
28490: printf("Leak of %d blocks found in xmlOutputBufferWriteString",
28491: xmlMemBlocks() - mem_base);
28492: test_ret++;
28493: printf(" %d", n_out);
28494: printf(" %d", n_str);
28495: printf("\n");
28496: }
28497: }
28498: }
28499: function_tests++;
28500: #endif
28501:
28502: return(test_ret);
28503: }
28504:
28505:
28506: static int
28507: test_xmlParserGetDirectory(void) {
28508: int test_ret = 0;
28509:
28510:
28511: /* missing type support */
28512: return(test_ret);
28513: }
28514:
28515:
28516: static int
28517: test_xmlParserInputBufferCreateFd(void) {
28518: int test_ret = 0;
28519:
28520: int mem_base;
28521: xmlParserInputBufferPtr ret_val;
28522: int fd; /* a file descriptor number */
28523: int n_fd;
28524: xmlCharEncoding enc; /* the charset encoding if known */
28525: int n_enc;
28526:
28527: for (n_fd = 0;n_fd < gen_nb_int;n_fd++) {
28528: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
28529: mem_base = xmlMemBlocks();
28530: fd = gen_int(n_fd, 0);
28531: enc = gen_xmlCharEncoding(n_enc, 1);
28532: if (fd >= 0) fd = -1;
28533:
28534: ret_val = xmlParserInputBufferCreateFd(fd, enc);
28535: desret_xmlParserInputBufferPtr(ret_val);
28536: call_tests++;
28537: des_int(n_fd, fd, 0);
28538: des_xmlCharEncoding(n_enc, enc, 1);
28539: xmlResetLastError();
28540: if (mem_base != xmlMemBlocks()) {
28541: printf("Leak of %d blocks found in xmlParserInputBufferCreateFd",
28542: xmlMemBlocks() - mem_base);
28543: test_ret++;
28544: printf(" %d", n_fd);
28545: printf(" %d", n_enc);
28546: printf("\n");
28547: }
28548: }
28549: }
28550: function_tests++;
28551:
28552: return(test_ret);
28553: }
28554:
28555:
28556: static int
28557: test_xmlParserInputBufferCreateFile(void) {
28558: int test_ret = 0;
28559:
28560: int mem_base;
28561: xmlParserInputBufferPtr ret_val;
28562: FILE * file; /* a FILE* */
28563: int n_file;
28564: xmlCharEncoding enc; /* the charset encoding if known */
28565: int n_enc;
28566:
28567: for (n_file = 0;n_file < gen_nb_FILE_ptr;n_file++) {
28568: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
28569: mem_base = xmlMemBlocks();
28570: file = gen_FILE_ptr(n_file, 0);
28571: enc = gen_xmlCharEncoding(n_enc, 1);
28572:
28573: ret_val = xmlParserInputBufferCreateFile(file, enc);
28574: desret_xmlParserInputBufferPtr(ret_val);
28575: call_tests++;
28576: des_FILE_ptr(n_file, file, 0);
28577: des_xmlCharEncoding(n_enc, enc, 1);
28578: xmlResetLastError();
28579: if (mem_base != xmlMemBlocks()) {
28580: printf("Leak of %d blocks found in xmlParserInputBufferCreateFile",
28581: xmlMemBlocks() - mem_base);
28582: test_ret++;
28583: printf(" %d", n_file);
28584: printf(" %d", n_enc);
28585: printf("\n");
28586: }
28587: }
28588: }
28589: function_tests++;
28590:
28591: return(test_ret);
28592: }
28593:
28594:
28595: static int
28596: test_xmlParserInputBufferCreateFilename(void) {
28597: int test_ret = 0;
28598:
28599: int mem_base;
28600: xmlParserInputBufferPtr ret_val;
28601: const char * URI; /* a C string containing the URI or filename */
28602: int n_URI;
28603: xmlCharEncoding enc; /* the charset encoding if known */
28604: int n_enc;
28605:
28606: for (n_URI = 0;n_URI < gen_nb_fileoutput;n_URI++) {
28607: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
28608: mem_base = xmlMemBlocks();
28609: URI = gen_fileoutput(n_URI, 0);
28610: enc = gen_xmlCharEncoding(n_enc, 1);
28611:
28612: ret_val = xmlParserInputBufferCreateFilename(URI, enc);
28613: desret_xmlParserInputBufferPtr(ret_val);
28614: call_tests++;
28615: des_fileoutput(n_URI, URI, 0);
28616: des_xmlCharEncoding(n_enc, enc, 1);
28617: xmlResetLastError();
28618: if (mem_base != xmlMemBlocks()) {
28619: printf("Leak of %d blocks found in xmlParserInputBufferCreateFilename",
28620: xmlMemBlocks() - mem_base);
28621: test_ret++;
28622: printf(" %d", n_URI);
28623: printf(" %d", n_enc);
28624: printf("\n");
28625: }
28626: }
28627: }
28628: function_tests++;
28629:
28630: return(test_ret);
28631: }
28632:
28633:
28634: static int
28635: test_xmlParserInputBufferCreateMem(void) {
28636: int test_ret = 0;
28637:
28638: int mem_base;
28639: xmlParserInputBufferPtr ret_val;
28640: char * mem; /* the memory input */
28641: int n_mem;
28642: int size; /* the length of the memory block */
28643: int n_size;
28644: xmlCharEncoding enc; /* the charset encoding if known */
28645: int n_enc;
28646:
28647: for (n_mem = 0;n_mem < gen_nb_const_char_ptr;n_mem++) {
28648: for (n_size = 0;n_size < gen_nb_int;n_size++) {
28649: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
28650: mem_base = xmlMemBlocks();
28651: mem = gen_const_char_ptr(n_mem, 0);
28652: size = gen_int(n_size, 1);
28653: enc = gen_xmlCharEncoding(n_enc, 2);
28654:
28655: ret_val = xmlParserInputBufferCreateMem((const char *)mem, size, enc);
28656: desret_xmlParserInputBufferPtr(ret_val);
28657: call_tests++;
28658: des_const_char_ptr(n_mem, (const char *)mem, 0);
28659: des_int(n_size, size, 1);
28660: des_xmlCharEncoding(n_enc, enc, 2);
28661: xmlResetLastError();
28662: if (mem_base != xmlMemBlocks()) {
28663: printf("Leak of %d blocks found in xmlParserInputBufferCreateMem",
28664: xmlMemBlocks() - mem_base);
28665: test_ret++;
28666: printf(" %d", n_mem);
28667: printf(" %d", n_size);
28668: printf(" %d", n_enc);
28669: printf("\n");
28670: }
28671: }
28672: }
28673: }
28674: function_tests++;
28675:
28676: return(test_ret);
28677: }
28678:
28679:
28680: static int
28681: test_xmlParserInputBufferCreateStatic(void) {
28682: int test_ret = 0;
28683:
28684: int mem_base;
28685: xmlParserInputBufferPtr ret_val;
28686: char * mem; /* the memory input */
28687: int n_mem;
28688: int size; /* the length of the memory block */
28689: int n_size;
28690: xmlCharEncoding enc; /* the charset encoding if known */
28691: int n_enc;
28692:
28693: for (n_mem = 0;n_mem < gen_nb_const_char_ptr;n_mem++) {
28694: for (n_size = 0;n_size < gen_nb_int;n_size++) {
28695: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
28696: mem_base = xmlMemBlocks();
28697: mem = gen_const_char_ptr(n_mem, 0);
28698: size = gen_int(n_size, 1);
28699: enc = gen_xmlCharEncoding(n_enc, 2);
28700:
28701: ret_val = xmlParserInputBufferCreateStatic((const char *)mem, size, enc);
28702: desret_xmlParserInputBufferPtr(ret_val);
28703: call_tests++;
28704: des_const_char_ptr(n_mem, (const char *)mem, 0);
28705: des_int(n_size, size, 1);
28706: des_xmlCharEncoding(n_enc, enc, 2);
28707: xmlResetLastError();
28708: if (mem_base != xmlMemBlocks()) {
28709: printf("Leak of %d blocks found in xmlParserInputBufferCreateStatic",
28710: xmlMemBlocks() - mem_base);
28711: test_ret++;
28712: printf(" %d", n_mem);
28713: printf(" %d", n_size);
28714: printf(" %d", n_enc);
28715: printf("\n");
28716: }
28717: }
28718: }
28719: }
28720: function_tests++;
28721:
28722: return(test_ret);
28723: }
28724:
28725:
28726: static int
28727: test_xmlParserInputBufferGrow(void) {
28728: int test_ret = 0;
28729:
28730: int mem_base;
28731: int ret_val;
28732: xmlParserInputBufferPtr in; /* a buffered parser input */
28733: int n_in;
28734: int len; /* indicative value of the amount of chars to read */
28735: int n_len;
28736:
28737: for (n_in = 0;n_in < gen_nb_xmlParserInputBufferPtr;n_in++) {
28738: for (n_len = 0;n_len < gen_nb_int;n_len++) {
28739: mem_base = xmlMemBlocks();
28740: in = gen_xmlParserInputBufferPtr(n_in, 0);
28741: len = gen_int(n_len, 1);
28742:
28743: ret_val = xmlParserInputBufferGrow(in, len);
28744: desret_int(ret_val);
28745: call_tests++;
28746: des_xmlParserInputBufferPtr(n_in, in, 0);
28747: des_int(n_len, len, 1);
28748: xmlResetLastError();
28749: if (mem_base != xmlMemBlocks()) {
28750: printf("Leak of %d blocks found in xmlParserInputBufferGrow",
28751: xmlMemBlocks() - mem_base);
28752: test_ret++;
28753: printf(" %d", n_in);
28754: printf(" %d", n_len);
28755: printf("\n");
28756: }
28757: }
28758: }
28759: function_tests++;
28760:
28761: return(test_ret);
28762: }
28763:
28764:
28765: static int
28766: test_xmlParserInputBufferPush(void) {
28767: int test_ret = 0;
28768:
28769: int mem_base;
28770: int ret_val;
28771: xmlParserInputBufferPtr in; /* a buffered parser input */
28772: int n_in;
28773: int len; /* the size in bytes of the array. */
28774: int n_len;
28775: char * buf; /* an char array */
28776: int n_buf;
28777:
28778: for (n_in = 0;n_in < gen_nb_xmlParserInputBufferPtr;n_in++) {
28779: for (n_len = 0;n_len < gen_nb_int;n_len++) {
28780: for (n_buf = 0;n_buf < gen_nb_const_char_ptr;n_buf++) {
28781: mem_base = xmlMemBlocks();
28782: in = gen_xmlParserInputBufferPtr(n_in, 0);
28783: len = gen_int(n_len, 1);
28784: buf = gen_const_char_ptr(n_buf, 2);
28785:
28786: ret_val = xmlParserInputBufferPush(in, len, (const char *)buf);
28787: desret_int(ret_val);
28788: call_tests++;
28789: des_xmlParserInputBufferPtr(n_in, in, 0);
28790: des_int(n_len, len, 1);
28791: des_const_char_ptr(n_buf, (const char *)buf, 2);
28792: xmlResetLastError();
28793: if (mem_base != xmlMemBlocks()) {
28794: printf("Leak of %d blocks found in xmlParserInputBufferPush",
28795: xmlMemBlocks() - mem_base);
28796: test_ret++;
28797: printf(" %d", n_in);
28798: printf(" %d", n_len);
28799: printf(" %d", n_buf);
28800: printf("\n");
28801: }
28802: }
28803: }
28804: }
28805: function_tests++;
28806:
28807: return(test_ret);
28808: }
28809:
28810:
28811: static int
28812: test_xmlParserInputBufferRead(void) {
28813: int test_ret = 0;
28814:
28815: int mem_base;
28816: int ret_val;
28817: xmlParserInputBufferPtr in; /* a buffered parser input */
28818: int n_in;
28819: int len; /* indicative value of the amount of chars to read */
28820: int n_len;
28821:
28822: for (n_in = 0;n_in < gen_nb_xmlParserInputBufferPtr;n_in++) {
28823: for (n_len = 0;n_len < gen_nb_int;n_len++) {
28824: mem_base = xmlMemBlocks();
28825: in = gen_xmlParserInputBufferPtr(n_in, 0);
28826: len = gen_int(n_len, 1);
28827:
28828: ret_val = xmlParserInputBufferRead(in, len);
28829: desret_int(ret_val);
28830: call_tests++;
28831: des_xmlParserInputBufferPtr(n_in, in, 0);
28832: des_int(n_len, len, 1);
28833: xmlResetLastError();
28834: if (mem_base != xmlMemBlocks()) {
28835: printf("Leak of %d blocks found in xmlParserInputBufferRead",
28836: xmlMemBlocks() - mem_base);
28837: test_ret++;
28838: printf(" %d", n_in);
28839: printf(" %d", n_len);
28840: printf("\n");
28841: }
28842: }
28843: }
28844: function_tests++;
28845:
28846: return(test_ret);
28847: }
28848:
28849:
28850: static int
28851: test_xmlPopInputCallbacks(void) {
28852: int test_ret = 0;
28853:
28854: int mem_base;
28855: int ret_val;
28856:
28857: mem_base = xmlMemBlocks();
28858:
28859: ret_val = xmlPopInputCallbacks();
28860: desret_int(ret_val);
28861: call_tests++;
28862: xmlResetLastError();
28863: if (mem_base != xmlMemBlocks()) {
28864: printf("Leak of %d blocks found in xmlPopInputCallbacks",
28865: xmlMemBlocks() - mem_base);
28866: test_ret++;
28867: printf("\n");
28868: }
28869: function_tests++;
28870:
28871: return(test_ret);
28872: }
28873:
28874:
28875: static int
28876: test_xmlRegisterDefaultInputCallbacks(void) {
28877: int test_ret = 0;
28878:
28879: int mem_base;
28880:
28881: mem_base = xmlMemBlocks();
28882:
28883: xmlRegisterDefaultInputCallbacks();
28884: call_tests++;
28885: xmlResetLastError();
28886: if (mem_base != xmlMemBlocks()) {
28887: printf("Leak of %d blocks found in xmlRegisterDefaultInputCallbacks",
28888: xmlMemBlocks() - mem_base);
28889: test_ret++;
28890: printf("\n");
28891: }
28892: function_tests++;
28893:
28894: return(test_ret);
28895: }
28896:
28897:
28898: static int
28899: test_xmlRegisterDefaultOutputCallbacks(void) {
28900: int test_ret = 0;
28901:
28902: #if defined(LIBXML_OUTPUT_ENABLED)
28903: int mem_base;
28904:
28905: mem_base = xmlMemBlocks();
28906:
28907: xmlRegisterDefaultOutputCallbacks();
28908: call_tests++;
28909: xmlResetLastError();
28910: if (mem_base != xmlMemBlocks()) {
28911: printf("Leak of %d blocks found in xmlRegisterDefaultOutputCallbacks",
28912: xmlMemBlocks() - mem_base);
28913: test_ret++;
28914: printf("\n");
28915: }
28916: function_tests++;
28917: #endif
28918:
28919: return(test_ret);
28920: }
28921:
28922:
28923: static int
28924: test_xmlRegisterHTTPPostCallbacks(void) {
28925: int test_ret = 0;
28926:
28927: #if defined(LIBXML_OUTPUT_ENABLED) && defined(LIBXML_HTTP_ENABLED)
28928: int mem_base;
28929:
28930: mem_base = xmlMemBlocks();
28931:
28932: xmlRegisterHTTPPostCallbacks();
28933: call_tests++;
28934: xmlResetLastError();
28935: if (mem_base != xmlMemBlocks()) {
28936: printf("Leak of %d blocks found in xmlRegisterHTTPPostCallbacks",
28937: xmlMemBlocks() - mem_base);
28938: test_ret++;
28939: printf("\n");
28940: }
28941: function_tests++;
28942: #endif
28943:
28944: return(test_ret);
28945: }
28946:
28947: static int
28948: test_xmlIO(void) {
28949: int test_ret = 0;
28950:
28951: if (quiet == 0) printf("Testing xmlIO : 39 of 48 functions ...\n");
28952: test_ret += test_xmlAllocOutputBuffer();
28953: test_ret += test_xmlAllocParserInputBuffer();
28954: test_ret += test_xmlCheckFilename();
28955: test_ret += test_xmlCheckHTTPInput();
28956: test_ret += test_xmlCleanupInputCallbacks();
28957: test_ret += test_xmlCleanupOutputCallbacks();
28958: test_ret += test_xmlFileClose();
28959: test_ret += test_xmlFileMatch();
28960: test_ret += test_xmlFileOpen();
28961: test_ret += test_xmlFileRead();
28962: test_ret += test_xmlIOFTPClose();
28963: test_ret += test_xmlIOFTPMatch();
28964: test_ret += test_xmlIOFTPOpen();
28965: test_ret += test_xmlIOFTPRead();
28966: test_ret += test_xmlIOHTTPClose();
28967: test_ret += test_xmlIOHTTPMatch();
28968: test_ret += test_xmlIOHTTPOpen();
28969: test_ret += test_xmlIOHTTPRead();
28970: test_ret += test_xmlNoNetExternalEntityLoader();
28971: test_ret += test_xmlNormalizeWindowsPath();
28972: test_ret += test_xmlOutputBufferCreateBuffer();
28973: test_ret += test_xmlOutputBufferCreateFd();
28974: test_ret += test_xmlOutputBufferCreateFile();
28975: test_ret += test_xmlOutputBufferCreateFilename();
28976: test_ret += test_xmlOutputBufferFlush();
28977: test_ret += test_xmlOutputBufferWrite();
28978: test_ret += test_xmlOutputBufferWriteEscape();
28979: test_ret += test_xmlOutputBufferWriteString();
28980: test_ret += test_xmlParserGetDirectory();
28981: test_ret += test_xmlParserInputBufferCreateFd();
28982: test_ret += test_xmlParserInputBufferCreateFile();
28983: test_ret += test_xmlParserInputBufferCreateFilename();
28984: test_ret += test_xmlParserInputBufferCreateMem();
28985: test_ret += test_xmlParserInputBufferCreateStatic();
28986: test_ret += test_xmlParserInputBufferGrow();
28987: test_ret += test_xmlParserInputBufferPush();
28988: test_ret += test_xmlParserInputBufferRead();
28989: test_ret += test_xmlPopInputCallbacks();
28990: test_ret += test_xmlRegisterDefaultInputCallbacks();
28991: test_ret += test_xmlRegisterDefaultOutputCallbacks();
28992: test_ret += test_xmlRegisterHTTPPostCallbacks();
28993:
28994: if (test_ret != 0)
28995: printf("Module xmlIO: %d errors\n", test_ret);
28996: return(test_ret);
28997: }
28998: #ifdef LIBXML_AUTOMATA_ENABLED
28999:
29000: #define gen_nb_xmlAutomataPtr 1
29001: static xmlAutomataPtr gen_xmlAutomataPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29002: return(NULL);
29003: }
29004: static void des_xmlAutomataPtr(int no ATTRIBUTE_UNUSED, xmlAutomataPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29005: }
29006: #endif
29007:
29008:
29009: static int
29010: test_xmlAutomataCompile(void) {
29011: int test_ret = 0;
29012:
29013:
29014: /* missing type support */
29015: return(test_ret);
29016: }
29017:
29018:
29019: static int
29020: test_xmlAutomataGetInitState(void) {
29021: int test_ret = 0;
29022:
29023:
29024: /* missing type support */
29025: return(test_ret);
29026: }
29027:
29028:
29029: static int
29030: test_xmlAutomataIsDeterminist(void) {
29031: int test_ret = 0;
29032:
29033: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_AUTOMATA_ENABLED)
29034: int mem_base;
29035: int ret_val;
29036: xmlAutomataPtr am; /* an automata */
29037: int n_am;
29038:
29039: for (n_am = 0;n_am < gen_nb_xmlAutomataPtr;n_am++) {
29040: mem_base = xmlMemBlocks();
29041: am = gen_xmlAutomataPtr(n_am, 0);
29042:
29043: ret_val = xmlAutomataIsDeterminist(am);
29044: desret_int(ret_val);
29045: call_tests++;
29046: des_xmlAutomataPtr(n_am, am, 0);
29047: xmlResetLastError();
29048: if (mem_base != xmlMemBlocks()) {
29049: printf("Leak of %d blocks found in xmlAutomataIsDeterminist",
29050: xmlMemBlocks() - mem_base);
29051: test_ret++;
29052: printf(" %d", n_am);
29053: printf("\n");
29054: }
29055: }
29056: function_tests++;
29057: #endif
29058:
29059: return(test_ret);
29060: }
29061:
29062: #ifdef LIBXML_AUTOMATA_ENABLED
29063:
29064: #define gen_nb_xmlAutomataStatePtr 1
29065: static xmlAutomataStatePtr gen_xmlAutomataStatePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29066: return(NULL);
29067: }
29068: static void des_xmlAutomataStatePtr(int no ATTRIBUTE_UNUSED, xmlAutomataStatePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29069: }
29070: #endif
29071:
29072:
29073: static int
29074: test_xmlAutomataNewAllTrans(void) {
29075: int test_ret = 0;
29076:
29077:
29078: /* missing type support */
29079: return(test_ret);
29080: }
29081:
29082:
29083: static int
29084: test_xmlAutomataNewCountTrans(void) {
29085: int test_ret = 0;
29086:
29087:
29088: /* missing type support */
29089: return(test_ret);
29090: }
29091:
29092:
29093: static int
29094: test_xmlAutomataNewCountTrans2(void) {
29095: int test_ret = 0;
29096:
29097:
29098: /* missing type support */
29099: return(test_ret);
29100: }
29101:
29102:
29103: static int
29104: test_xmlAutomataNewCountedTrans(void) {
29105: int test_ret = 0;
29106:
29107:
29108: /* missing type support */
29109: return(test_ret);
29110: }
29111:
29112:
29113: static int
29114: test_xmlAutomataNewCounter(void) {
29115: int test_ret = 0;
29116:
29117: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_AUTOMATA_ENABLED)
29118: int mem_base;
29119: int ret_val;
29120: xmlAutomataPtr am; /* an automata */
29121: int n_am;
29122: int min; /* the minimal value on the counter */
29123: int n_min;
29124: int max; /* the maximal value on the counter */
29125: int n_max;
29126:
29127: for (n_am = 0;n_am < gen_nb_xmlAutomataPtr;n_am++) {
29128: for (n_min = 0;n_min < gen_nb_int;n_min++) {
29129: for (n_max = 0;n_max < gen_nb_int;n_max++) {
29130: mem_base = xmlMemBlocks();
29131: am = gen_xmlAutomataPtr(n_am, 0);
29132: min = gen_int(n_min, 1);
29133: max = gen_int(n_max, 2);
29134:
29135: ret_val = xmlAutomataNewCounter(am, min, max);
29136: desret_int(ret_val);
29137: call_tests++;
29138: des_xmlAutomataPtr(n_am, am, 0);
29139: des_int(n_min, min, 1);
29140: des_int(n_max, max, 2);
29141: xmlResetLastError();
29142: if (mem_base != xmlMemBlocks()) {
29143: printf("Leak of %d blocks found in xmlAutomataNewCounter",
29144: xmlMemBlocks() - mem_base);
29145: test_ret++;
29146: printf(" %d", n_am);
29147: printf(" %d", n_min);
29148: printf(" %d", n_max);
29149: printf("\n");
29150: }
29151: }
29152: }
29153: }
29154: function_tests++;
29155: #endif
29156:
29157: return(test_ret);
29158: }
29159:
29160:
29161: static int
29162: test_xmlAutomataNewCounterTrans(void) {
29163: int test_ret = 0;
29164:
29165:
29166: /* missing type support */
29167: return(test_ret);
29168: }
29169:
29170:
29171: static int
29172: test_xmlAutomataNewEpsilon(void) {
29173: int test_ret = 0;
29174:
29175:
29176: /* missing type support */
29177: return(test_ret);
29178: }
29179:
29180:
29181: static int
29182: test_xmlAutomataNewNegTrans(void) {
29183: int test_ret = 0;
29184:
29185:
29186: /* missing type support */
29187: return(test_ret);
29188: }
29189:
29190:
29191: static int
29192: test_xmlAutomataNewOnceTrans(void) {
29193: int test_ret = 0;
29194:
29195:
29196: /* missing type support */
29197: return(test_ret);
29198: }
29199:
29200:
29201: static int
29202: test_xmlAutomataNewOnceTrans2(void) {
29203: int test_ret = 0;
29204:
29205:
29206: /* missing type support */
29207: return(test_ret);
29208: }
29209:
29210:
29211: static int
29212: test_xmlAutomataNewState(void) {
29213: int test_ret = 0;
29214:
29215:
29216: /* missing type support */
29217: return(test_ret);
29218: }
29219:
29220:
29221: static int
29222: test_xmlAutomataNewTransition(void) {
29223: int test_ret = 0;
29224:
29225:
29226: /* missing type support */
29227: return(test_ret);
29228: }
29229:
29230:
29231: static int
29232: test_xmlAutomataNewTransition2(void) {
29233: int test_ret = 0;
29234:
29235:
29236: /* missing type support */
29237: return(test_ret);
29238: }
29239:
29240:
29241: static int
29242: test_xmlAutomataSetFinalState(void) {
29243: int test_ret = 0;
29244:
29245: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_AUTOMATA_ENABLED)
29246: int mem_base;
29247: int ret_val;
29248: xmlAutomataPtr am; /* an automata */
29249: int n_am;
29250: xmlAutomataStatePtr state; /* a state in this automata */
29251: int n_state;
29252:
29253: for (n_am = 0;n_am < gen_nb_xmlAutomataPtr;n_am++) {
29254: for (n_state = 0;n_state < gen_nb_xmlAutomataStatePtr;n_state++) {
29255: mem_base = xmlMemBlocks();
29256: am = gen_xmlAutomataPtr(n_am, 0);
29257: state = gen_xmlAutomataStatePtr(n_state, 1);
29258:
29259: ret_val = xmlAutomataSetFinalState(am, state);
29260: desret_int(ret_val);
29261: call_tests++;
29262: des_xmlAutomataPtr(n_am, am, 0);
29263: des_xmlAutomataStatePtr(n_state, state, 1);
29264: xmlResetLastError();
29265: if (mem_base != xmlMemBlocks()) {
29266: printf("Leak of %d blocks found in xmlAutomataSetFinalState",
29267: xmlMemBlocks() - mem_base);
29268: test_ret++;
29269: printf(" %d", n_am);
29270: printf(" %d", n_state);
29271: printf("\n");
29272: }
29273: }
29274: }
29275: function_tests++;
29276: #endif
29277:
29278: return(test_ret);
29279: }
29280:
29281:
29282: static int
29283: test_xmlNewAutomata(void) {
29284: int test_ret = 0;
29285:
29286:
29287: /* missing type support */
29288: return(test_ret);
29289: }
29290:
29291: static int
29292: test_xmlautomata(void) {
29293: int test_ret = 0;
29294:
29295: if (quiet == 0) printf("Testing xmlautomata : 3 of 19 functions ...\n");
29296: test_ret += test_xmlAutomataCompile();
29297: test_ret += test_xmlAutomataGetInitState();
29298: test_ret += test_xmlAutomataIsDeterminist();
29299: test_ret += test_xmlAutomataNewAllTrans();
29300: test_ret += test_xmlAutomataNewCountTrans();
29301: test_ret += test_xmlAutomataNewCountTrans2();
29302: test_ret += test_xmlAutomataNewCountedTrans();
29303: test_ret += test_xmlAutomataNewCounter();
29304: test_ret += test_xmlAutomataNewCounterTrans();
29305: test_ret += test_xmlAutomataNewEpsilon();
29306: test_ret += test_xmlAutomataNewNegTrans();
29307: test_ret += test_xmlAutomataNewOnceTrans();
29308: test_ret += test_xmlAutomataNewOnceTrans2();
29309: test_ret += test_xmlAutomataNewState();
29310: test_ret += test_xmlAutomataNewTransition();
29311: test_ret += test_xmlAutomataNewTransition2();
29312: test_ret += test_xmlAutomataSetFinalState();
29313: test_ret += test_xmlNewAutomata();
29314:
29315: if (test_ret != 0)
29316: printf("Module xmlautomata: %d errors\n", test_ret);
29317: return(test_ret);
29318: }
29319:
29320: #define gen_nb_xmlGenericErrorFunc_ptr 1
29321: static xmlGenericErrorFunc * gen_xmlGenericErrorFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29322: return(NULL);
29323: }
29324: static void des_xmlGenericErrorFunc_ptr(int no ATTRIBUTE_UNUSED, xmlGenericErrorFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29325: }
29326:
29327: static int
29328: test_initGenericErrorDefaultFunc(void) {
29329: int test_ret = 0;
29330:
29331: int mem_base;
29332: xmlGenericErrorFunc * handler; /* the handler */
29333: int n_handler;
29334:
29335: for (n_handler = 0;n_handler < gen_nb_xmlGenericErrorFunc_ptr;n_handler++) {
29336: mem_base = xmlMemBlocks();
29337: handler = gen_xmlGenericErrorFunc_ptr(n_handler, 0);
29338:
29339: initGenericErrorDefaultFunc(handler);
29340: call_tests++;
29341: des_xmlGenericErrorFunc_ptr(n_handler, handler, 0);
29342: xmlResetLastError();
29343: if (mem_base != xmlMemBlocks()) {
29344: printf("Leak of %d blocks found in initGenericErrorDefaultFunc",
29345: xmlMemBlocks() - mem_base);
29346: test_ret++;
29347: printf(" %d", n_handler);
29348: printf("\n");
29349: }
29350: }
29351: function_tests++;
29352:
29353: return(test_ret);
29354: }
29355:
29356:
29357: #define gen_nb_xmlErrorPtr 1
29358: static xmlErrorPtr gen_xmlErrorPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29359: return(NULL);
29360: }
29361: static void des_xmlErrorPtr(int no ATTRIBUTE_UNUSED, xmlErrorPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29362: }
29363:
29364: static int
29365: test_xmlCopyError(void) {
29366: int test_ret = 0;
29367:
29368: int mem_base;
29369: int ret_val;
29370: xmlErrorPtr from; /* a source error */
29371: int n_from;
29372: xmlErrorPtr to; /* a target error */
29373: int n_to;
29374:
29375: for (n_from = 0;n_from < gen_nb_xmlErrorPtr;n_from++) {
29376: for (n_to = 0;n_to < gen_nb_xmlErrorPtr;n_to++) {
29377: mem_base = xmlMemBlocks();
29378: from = gen_xmlErrorPtr(n_from, 0);
29379: to = gen_xmlErrorPtr(n_to, 1);
29380:
29381: ret_val = xmlCopyError(from, to);
29382: desret_int(ret_val);
29383: call_tests++;
29384: des_xmlErrorPtr(n_from, from, 0);
29385: des_xmlErrorPtr(n_to, to, 1);
29386: xmlResetLastError();
29387: if (mem_base != xmlMemBlocks()) {
29388: printf("Leak of %d blocks found in xmlCopyError",
29389: xmlMemBlocks() - mem_base);
29390: test_ret++;
29391: printf(" %d", n_from);
29392: printf(" %d", n_to);
29393: printf("\n");
29394: }
29395: }
29396: }
29397: function_tests++;
29398:
29399: return(test_ret);
29400: }
29401:
29402:
29403: static int
29404: test_xmlCtxtGetLastError(void) {
29405: int test_ret = 0;
29406:
29407:
29408: /* missing type support */
29409: return(test_ret);
29410: }
29411:
29412:
29413: static int
29414: test_xmlCtxtResetLastError(void) {
29415: int test_ret = 0;
29416:
29417: int mem_base;
29418: void * ctx; /* an XML parser context */
29419: int n_ctx;
29420:
29421: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
29422: mem_base = xmlMemBlocks();
29423: ctx = gen_void_ptr(n_ctx, 0);
29424:
29425: xmlCtxtResetLastError(ctx);
29426: call_tests++;
29427: des_void_ptr(n_ctx, ctx, 0);
29428: xmlResetLastError();
29429: if (mem_base != xmlMemBlocks()) {
29430: printf("Leak of %d blocks found in xmlCtxtResetLastError",
29431: xmlMemBlocks() - mem_base);
29432: test_ret++;
29433: printf(" %d", n_ctx);
29434: printf("\n");
29435: }
29436: }
29437: function_tests++;
29438:
29439: return(test_ret);
29440: }
29441:
29442:
29443: static int
29444: test_xmlGetLastError(void) {
29445: int test_ret = 0;
29446:
29447:
29448: /* missing type support */
29449: return(test_ret);
29450: }
29451:
29452:
29453: static int
29454: test_xmlParserError(void) {
29455: int test_ret = 0;
29456:
29457:
29458: /* missing type support */
29459: return(test_ret);
29460: }
29461:
29462:
29463: static int
29464: test_xmlParserPrintFileContext(void) {
29465: int test_ret = 0;
29466:
29467: int mem_base;
29468: xmlParserInputPtr input; /* an xmlParserInputPtr input */
29469: int n_input;
29470:
29471: for (n_input = 0;n_input < gen_nb_xmlParserInputPtr;n_input++) {
29472: mem_base = xmlMemBlocks();
29473: input = gen_xmlParserInputPtr(n_input, 0);
29474:
29475: xmlParserPrintFileContext(input);
29476: call_tests++;
29477: des_xmlParserInputPtr(n_input, input, 0);
29478: xmlResetLastError();
29479: if (mem_base != xmlMemBlocks()) {
29480: printf("Leak of %d blocks found in xmlParserPrintFileContext",
29481: xmlMemBlocks() - mem_base);
29482: test_ret++;
29483: printf(" %d", n_input);
29484: printf("\n");
29485: }
29486: }
29487: function_tests++;
29488:
29489: return(test_ret);
29490: }
29491:
29492:
29493: static int
29494: test_xmlParserPrintFileInfo(void) {
29495: int test_ret = 0;
29496:
29497: int mem_base;
29498: xmlParserInputPtr input; /* an xmlParserInputPtr input */
29499: int n_input;
29500:
29501: for (n_input = 0;n_input < gen_nb_xmlParserInputPtr;n_input++) {
29502: mem_base = xmlMemBlocks();
29503: input = gen_xmlParserInputPtr(n_input, 0);
29504:
29505: xmlParserPrintFileInfo(input);
29506: call_tests++;
29507: des_xmlParserInputPtr(n_input, input, 0);
29508: xmlResetLastError();
29509: if (mem_base != xmlMemBlocks()) {
29510: printf("Leak of %d blocks found in xmlParserPrintFileInfo",
29511: xmlMemBlocks() - mem_base);
29512: test_ret++;
29513: printf(" %d", n_input);
29514: printf("\n");
29515: }
29516: }
29517: function_tests++;
29518:
29519: return(test_ret);
29520: }
29521:
29522:
29523: static int
29524: test_xmlParserValidityError(void) {
29525: int test_ret = 0;
29526:
29527:
29528: /* missing type support */
29529: return(test_ret);
29530: }
29531:
29532:
29533: static int
29534: test_xmlParserValidityWarning(void) {
29535: int test_ret = 0;
29536:
29537:
29538: /* missing type support */
29539: return(test_ret);
29540: }
29541:
29542:
29543: static int
29544: test_xmlParserWarning(void) {
29545: int test_ret = 0;
29546:
29547:
29548: /* missing type support */
29549: return(test_ret);
29550: }
29551:
29552:
29553: static int
29554: test_xmlResetError(void) {
29555: int test_ret = 0;
29556:
29557: int mem_base;
29558: xmlErrorPtr err; /* pointer to the error. */
29559: int n_err;
29560:
29561: for (n_err = 0;n_err < gen_nb_xmlErrorPtr;n_err++) {
29562: mem_base = xmlMemBlocks();
29563: err = gen_xmlErrorPtr(n_err, 0);
29564:
29565: xmlResetError(err);
29566: call_tests++;
29567: des_xmlErrorPtr(n_err, err, 0);
29568: xmlResetLastError();
29569: if (mem_base != xmlMemBlocks()) {
29570: printf("Leak of %d blocks found in xmlResetError",
29571: xmlMemBlocks() - mem_base);
29572: test_ret++;
29573: printf(" %d", n_err);
29574: printf("\n");
29575: }
29576: }
29577: function_tests++;
29578:
29579: return(test_ret);
29580: }
29581:
29582:
29583: static int
29584: test_xmlResetLastError(void) {
29585: int test_ret = 0;
29586:
29587:
29588:
29589: xmlResetLastError();
29590: call_tests++;
29591: xmlResetLastError();
29592: function_tests++;
29593:
29594: return(test_ret);
29595: }
29596:
29597:
29598: static int
29599: test_xmlSetGenericErrorFunc(void) {
29600: int test_ret = 0;
29601:
29602:
29603: /* missing type support */
29604: return(test_ret);
29605: }
29606:
29607:
29608: static int
29609: test_xmlSetStructuredErrorFunc(void) {
29610: int test_ret = 0;
29611:
29612:
29613: /* missing type support */
29614: return(test_ret);
29615: }
29616:
29617: static int
29618: test_xmlerror(void) {
29619: int test_ret = 0;
29620:
29621: if (quiet == 0) printf("Testing xmlerror : 7 of 15 functions ...\n");
29622: test_ret += test_initGenericErrorDefaultFunc();
29623: test_ret += test_xmlCopyError();
29624: test_ret += test_xmlCtxtGetLastError();
29625: test_ret += test_xmlCtxtResetLastError();
29626: test_ret += test_xmlGetLastError();
29627: test_ret += test_xmlParserError();
29628: test_ret += test_xmlParserPrintFileContext();
29629: test_ret += test_xmlParserPrintFileInfo();
29630: test_ret += test_xmlParserValidityError();
29631: test_ret += test_xmlParserValidityWarning();
29632: test_ret += test_xmlParserWarning();
29633: test_ret += test_xmlResetError();
29634: test_ret += test_xmlResetLastError();
29635: test_ret += test_xmlSetGenericErrorFunc();
29636: test_ret += test_xmlSetStructuredErrorFunc();
29637:
29638: if (test_ret != 0)
29639: printf("Module xmlerror: %d errors\n", test_ret);
29640: return(test_ret);
29641: }
29642: #ifdef LIBXML_MODULES_ENABLED
29643:
29644: #define gen_nb_xmlModulePtr 1
29645: static xmlModulePtr gen_xmlModulePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29646: return(NULL);
29647: }
29648: static void des_xmlModulePtr(int no ATTRIBUTE_UNUSED, xmlModulePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29649: }
29650: #endif
29651:
29652:
29653: static int
29654: test_xmlModuleClose(void) {
29655: int test_ret = 0;
29656:
29657: #if defined(LIBXML_MODULES_ENABLED)
29658: int mem_base;
29659: int ret_val;
29660: xmlModulePtr module; /* the module handle */
29661: int n_module;
29662:
29663: for (n_module = 0;n_module < gen_nb_xmlModulePtr;n_module++) {
29664: mem_base = xmlMemBlocks();
29665: module = gen_xmlModulePtr(n_module, 0);
29666:
29667: ret_val = xmlModuleClose(module);
29668: desret_int(ret_val);
29669: call_tests++;
29670: des_xmlModulePtr(n_module, module, 0);
29671: xmlResetLastError();
29672: if (mem_base != xmlMemBlocks()) {
29673: printf("Leak of %d blocks found in xmlModuleClose",
29674: xmlMemBlocks() - mem_base);
29675: test_ret++;
29676: printf(" %d", n_module);
29677: printf("\n");
29678: }
29679: }
29680: function_tests++;
29681: #endif
29682:
29683: return(test_ret);
29684: }
29685:
29686:
29687: static int
29688: test_xmlModuleOpen(void) {
29689: int test_ret = 0;
29690:
29691:
29692: /* missing type support */
29693: return(test_ret);
29694: }
29695:
29696:
29697: static int
29698: test_xmlModuleSymbol(void) {
29699: int test_ret = 0;
29700:
29701: #if defined(LIBXML_MODULES_ENABLED)
29702: int mem_base;
29703: int ret_val;
29704: xmlModulePtr module; /* the module */
29705: int n_module;
29706: char * name; /* the name of the symbol */
29707: int n_name;
29708: void ** symbol; /* the resulting symbol address */
29709: int n_symbol;
29710:
29711: for (n_module = 0;n_module < gen_nb_xmlModulePtr;n_module++) {
29712: for (n_name = 0;n_name < gen_nb_const_char_ptr;n_name++) {
29713: for (n_symbol = 0;n_symbol < gen_nb_void_ptr_ptr;n_symbol++) {
29714: mem_base = xmlMemBlocks();
29715: module = gen_xmlModulePtr(n_module, 0);
29716: name = gen_const_char_ptr(n_name, 1);
29717: symbol = gen_void_ptr_ptr(n_symbol, 2);
29718:
29719: ret_val = xmlModuleSymbol(module, (const char *)name, symbol);
29720: desret_int(ret_val);
29721: call_tests++;
29722: des_xmlModulePtr(n_module, module, 0);
29723: des_const_char_ptr(n_name, (const char *)name, 1);
29724: des_void_ptr_ptr(n_symbol, symbol, 2);
29725: xmlResetLastError();
29726: if (mem_base != xmlMemBlocks()) {
29727: printf("Leak of %d blocks found in xmlModuleSymbol",
29728: xmlMemBlocks() - mem_base);
29729: test_ret++;
29730: printf(" %d", n_module);
29731: printf(" %d", n_name);
29732: printf(" %d", n_symbol);
29733: printf("\n");
29734: }
29735: }
29736: }
29737: }
29738: function_tests++;
29739: #endif
29740:
29741: return(test_ret);
29742: }
29743:
29744: static int
29745: test_xmlmodule(void) {
29746: int test_ret = 0;
29747:
29748: if (quiet == 0) printf("Testing xmlmodule : 2 of 4 functions ...\n");
29749: test_ret += test_xmlModuleClose();
29750: test_ret += test_xmlModuleOpen();
29751: test_ret += test_xmlModuleSymbol();
29752:
29753: if (test_ret != 0)
29754: printf("Module xmlmodule: %d errors\n", test_ret);
29755: return(test_ret);
29756: }
29757:
29758: static int
29759: test_xmlNewTextReader(void) {
29760: int test_ret = 0;
29761:
29762: #if defined(LIBXML_READER_ENABLED)
29763: int mem_base;
29764: xmlTextReaderPtr ret_val;
29765: xmlParserInputBufferPtr input; /* the xmlParserInputBufferPtr used to read data */
29766: int n_input;
29767: const char * URI; /* the URI information for the source if available */
29768: int n_URI;
29769:
29770: for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) {
29771: for (n_URI = 0;n_URI < gen_nb_filepath;n_URI++) {
29772: mem_base = xmlMemBlocks();
29773: input = gen_xmlParserInputBufferPtr(n_input, 0);
29774: URI = gen_filepath(n_URI, 1);
29775:
29776: ret_val = xmlNewTextReader(input, URI);
29777: desret_xmlTextReaderPtr(ret_val);
29778: call_tests++;
29779: des_xmlParserInputBufferPtr(n_input, input, 0);
29780: des_filepath(n_URI, URI, 1);
29781: xmlResetLastError();
29782: if (mem_base != xmlMemBlocks()) {
29783: printf("Leak of %d blocks found in xmlNewTextReader",
29784: xmlMemBlocks() - mem_base);
29785: test_ret++;
29786: printf(" %d", n_input);
29787: printf(" %d", n_URI);
29788: printf("\n");
29789: }
29790: }
29791: }
29792: function_tests++;
29793: #endif
29794:
29795: return(test_ret);
29796: }
29797:
29798:
29799: static int
29800: test_xmlNewTextReaderFilename(void) {
29801: int test_ret = 0;
29802:
29803: #if defined(LIBXML_READER_ENABLED)
29804: int mem_base;
29805: xmlTextReaderPtr ret_val;
29806: const char * URI; /* the URI of the resource to process */
29807: int n_URI;
29808:
29809: for (n_URI = 0;n_URI < gen_nb_filepath;n_URI++) {
29810: mem_base = xmlMemBlocks();
29811: URI = gen_filepath(n_URI, 0);
29812:
29813: ret_val = xmlNewTextReaderFilename(URI);
29814: desret_xmlTextReaderPtr(ret_val);
29815: call_tests++;
29816: des_filepath(n_URI, URI, 0);
29817: xmlResetLastError();
29818: if (mem_base != xmlMemBlocks()) {
29819: printf("Leak of %d blocks found in xmlNewTextReaderFilename",
29820: xmlMemBlocks() - mem_base);
29821: test_ret++;
29822: printf(" %d", n_URI);
29823: printf("\n");
29824: }
29825: }
29826: function_tests++;
29827: #endif
29828:
29829: return(test_ret);
29830: }
29831:
29832:
29833: static int
29834: test_xmlReaderForDoc(void) {
29835: int test_ret = 0;
29836:
29837: #if defined(LIBXML_READER_ENABLED)
29838: int mem_base;
29839: xmlTextReaderPtr ret_val;
29840: xmlChar * cur; /* a pointer to a zero terminated string */
29841: int n_cur;
29842: const char * URL; /* the base URL to use for the document */
29843: int n_URL;
29844: char * encoding; /* the document encoding, or NULL */
29845: int n_encoding;
29846: int options; /* a combination of xmlParserOption */
29847: int n_options;
29848:
29849: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
29850: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
29851: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
29852: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
29853: mem_base = xmlMemBlocks();
29854: cur = gen_const_xmlChar_ptr(n_cur, 0);
29855: URL = gen_filepath(n_URL, 1);
29856: encoding = gen_const_char_ptr(n_encoding, 2);
29857: options = gen_parseroptions(n_options, 3);
29858:
29859: ret_val = xmlReaderForDoc((const xmlChar *)cur, URL, (const char *)encoding, options);
29860: desret_xmlTextReaderPtr(ret_val);
29861: call_tests++;
29862: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
29863: des_filepath(n_URL, URL, 1);
29864: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
29865: des_parseroptions(n_options, options, 3);
29866: xmlResetLastError();
29867: if (mem_base != xmlMemBlocks()) {
29868: printf("Leak of %d blocks found in xmlReaderForDoc",
29869: xmlMemBlocks() - mem_base);
29870: test_ret++;
29871: printf(" %d", n_cur);
29872: printf(" %d", n_URL);
29873: printf(" %d", n_encoding);
29874: printf(" %d", n_options);
29875: printf("\n");
29876: }
29877: }
29878: }
29879: }
29880: }
29881: function_tests++;
29882: #endif
29883:
29884: return(test_ret);
29885: }
29886:
29887:
29888: static int
29889: test_xmlReaderForFile(void) {
29890: int test_ret = 0;
29891:
29892: #if defined(LIBXML_READER_ENABLED)
29893: int mem_base;
29894: xmlTextReaderPtr ret_val;
29895: const char * filename; /* a file or URL */
29896: int n_filename;
29897: char * encoding; /* the document encoding, or NULL */
29898: int n_encoding;
29899: int options; /* a combination of xmlParserOption */
29900: int n_options;
29901:
29902: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
29903: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
29904: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
29905: mem_base = xmlMemBlocks();
29906: filename = gen_filepath(n_filename, 0);
29907: encoding = gen_const_char_ptr(n_encoding, 1);
29908: options = gen_parseroptions(n_options, 2);
29909:
29910: ret_val = xmlReaderForFile(filename, (const char *)encoding, options);
29911: desret_xmlTextReaderPtr(ret_val);
29912: call_tests++;
29913: des_filepath(n_filename, filename, 0);
29914: des_const_char_ptr(n_encoding, (const char *)encoding, 1);
29915: des_parseroptions(n_options, options, 2);
29916: xmlResetLastError();
29917: if (mem_base != xmlMemBlocks()) {
29918: printf("Leak of %d blocks found in xmlReaderForFile",
29919: xmlMemBlocks() - mem_base);
29920: test_ret++;
29921: printf(" %d", n_filename);
29922: printf(" %d", n_encoding);
29923: printf(" %d", n_options);
29924: printf("\n");
29925: }
29926: }
29927: }
29928: }
29929: function_tests++;
29930: #endif
29931:
29932: return(test_ret);
29933: }
29934:
29935:
29936: static int
29937: test_xmlReaderForMemory(void) {
29938: int test_ret = 0;
29939:
29940: #if defined(LIBXML_READER_ENABLED)
29941: int mem_base;
29942: xmlTextReaderPtr ret_val;
29943: char * buffer; /* a pointer to a char array */
29944: int n_buffer;
29945: int size; /* the size of the array */
29946: int n_size;
29947: const char * URL; /* the base URL to use for the document */
29948: int n_URL;
29949: char * encoding; /* the document encoding, or NULL */
29950: int n_encoding;
29951: int options; /* a combination of xmlParserOption */
29952: int n_options;
29953:
29954: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
29955: for (n_size = 0;n_size < gen_nb_int;n_size++) {
29956: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
29957: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
29958: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
29959: mem_base = xmlMemBlocks();
29960: buffer = gen_const_char_ptr(n_buffer, 0);
29961: size = gen_int(n_size, 1);
29962: URL = gen_filepath(n_URL, 2);
29963: encoding = gen_const_char_ptr(n_encoding, 3);
29964: options = gen_parseroptions(n_options, 4);
29965:
29966: ret_val = xmlReaderForMemory((const char *)buffer, size, URL, (const char *)encoding, options);
29967: desret_xmlTextReaderPtr(ret_val);
29968: call_tests++;
29969: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
29970: des_int(n_size, size, 1);
29971: des_filepath(n_URL, URL, 2);
29972: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
29973: des_parseroptions(n_options, options, 4);
29974: xmlResetLastError();
29975: if (mem_base != xmlMemBlocks()) {
29976: printf("Leak of %d blocks found in xmlReaderForMemory",
29977: xmlMemBlocks() - mem_base);
29978: test_ret++;
29979: printf(" %d", n_buffer);
29980: printf(" %d", n_size);
29981: printf(" %d", n_URL);
29982: printf(" %d", n_encoding);
29983: printf(" %d", n_options);
29984: printf("\n");
29985: }
29986: }
29987: }
29988: }
29989: }
29990: }
29991: function_tests++;
29992: #endif
29993:
29994: return(test_ret);
29995: }
29996:
29997:
29998: static int
29999: test_xmlReaderNewDoc(void) {
30000: int test_ret = 0;
30001:
30002: #if defined(LIBXML_READER_ENABLED)
30003: int mem_base;
30004: int ret_val;
30005: xmlTextReaderPtr reader; /* an XML reader */
30006: int n_reader;
30007: xmlChar * cur; /* a pointer to a zero terminated string */
30008: int n_cur;
30009: const char * URL; /* the base URL to use for the document */
30010: int n_URL;
30011: char * encoding; /* the document encoding, or NULL */
30012: int n_encoding;
30013: int options; /* a combination of xmlParserOption */
30014: int n_options;
30015:
30016: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30017: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
30018: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
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: cur = gen_const_xmlChar_ptr(n_cur, 1);
30024: URL = gen_filepath(n_URL, 2);
30025: encoding = gen_const_char_ptr(n_encoding, 3);
30026: options = gen_parseroptions(n_options, 4);
30027:
30028: ret_val = xmlReaderNewDoc(reader, (const xmlChar *)cur, URL, (const char *)encoding, options);
30029: desret_int(ret_val);
30030: call_tests++;
30031: des_xmlTextReaderPtr(n_reader, reader, 0);
30032: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 1);
30033: des_filepath(n_URL, URL, 2);
30034: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
30035: des_parseroptions(n_options, options, 4);
30036: xmlResetLastError();
30037: if (mem_base != xmlMemBlocks()) {
30038: printf("Leak of %d blocks found in xmlReaderNewDoc",
30039: xmlMemBlocks() - mem_base);
30040: test_ret++;
30041: printf(" %d", n_reader);
30042: printf(" %d", n_cur);
30043: printf(" %d", n_URL);
30044: printf(" %d", n_encoding);
30045: printf(" %d", n_options);
30046: printf("\n");
30047: }
30048: }
30049: }
30050: }
30051: }
30052: }
30053: function_tests++;
30054: #endif
30055:
30056: return(test_ret);
30057: }
30058:
30059:
30060: static int
30061: test_xmlReaderNewFile(void) {
30062: int test_ret = 0;
30063:
30064: #if defined(LIBXML_READER_ENABLED)
30065: int mem_base;
30066: int ret_val;
30067: xmlTextReaderPtr reader; /* an XML reader */
30068: int n_reader;
30069: const char * filename; /* a file or URL */
30070: int n_filename;
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_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
30078: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
30079: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
30080: mem_base = xmlMemBlocks();
30081: reader = gen_xmlTextReaderPtr(n_reader, 0);
30082: filename = gen_filepath(n_filename, 1);
30083: encoding = gen_const_char_ptr(n_encoding, 2);
30084: options = gen_parseroptions(n_options, 3);
30085:
30086: ret_val = xmlReaderNewFile(reader, filename, (const char *)encoding, options);
30087: desret_int(ret_val);
30088: call_tests++;
30089: des_xmlTextReaderPtr(n_reader, reader, 0);
30090: des_filepath(n_filename, filename, 1);
30091: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
30092: des_parseroptions(n_options, options, 3);
30093: xmlResetLastError();
30094: if (mem_base != xmlMemBlocks()) {
30095: printf("Leak of %d blocks found in xmlReaderNewFile",
30096: xmlMemBlocks() - mem_base);
30097: test_ret++;
30098: printf(" %d", n_reader);
30099: printf(" %d", n_filename);
30100: printf(" %d", n_encoding);
30101: printf(" %d", n_options);
30102: printf("\n");
30103: }
30104: }
30105: }
30106: }
30107: }
30108: function_tests++;
30109: #endif
30110:
30111: return(test_ret);
30112: }
30113:
30114:
30115: static int
30116: test_xmlReaderNewMemory(void) {
30117: int test_ret = 0;
30118:
30119: #if defined(LIBXML_READER_ENABLED)
30120: int mem_base;
30121: int ret_val;
30122: xmlTextReaderPtr reader; /* an XML reader */
30123: int n_reader;
30124: char * buffer; /* a pointer to a char array */
30125: int n_buffer;
30126: int size; /* the size of the array */
30127: int n_size;
30128: const char * URL; /* the base URL to use for the document */
30129: int n_URL;
30130: char * encoding; /* the document encoding, or NULL */
30131: int n_encoding;
30132: int options; /* a combination of xmlParserOption */
30133: int n_options;
30134:
30135: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30136: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
30137: for (n_size = 0;n_size < gen_nb_int;n_size++) {
30138: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
30139: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
30140: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
30141: mem_base = xmlMemBlocks();
30142: reader = gen_xmlTextReaderPtr(n_reader, 0);
30143: buffer = gen_const_char_ptr(n_buffer, 1);
30144: size = gen_int(n_size, 2);
30145: URL = gen_filepath(n_URL, 3);
30146: encoding = gen_const_char_ptr(n_encoding, 4);
30147: options = gen_parseroptions(n_options, 5);
30148:
30149: ret_val = xmlReaderNewMemory(reader, (const char *)buffer, size, URL, (const char *)encoding, options);
30150: desret_int(ret_val);
30151: call_tests++;
30152: des_xmlTextReaderPtr(n_reader, reader, 0);
30153: des_const_char_ptr(n_buffer, (const char *)buffer, 1);
30154: des_int(n_size, size, 2);
30155: des_filepath(n_URL, URL, 3);
30156: des_const_char_ptr(n_encoding, (const char *)encoding, 4);
30157: des_parseroptions(n_options, options, 5);
30158: xmlResetLastError();
30159: if (mem_base != xmlMemBlocks()) {
30160: printf("Leak of %d blocks found in xmlReaderNewMemory",
30161: xmlMemBlocks() - mem_base);
30162: test_ret++;
30163: printf(" %d", n_reader);
30164: printf(" %d", n_buffer);
30165: printf(" %d", n_size);
30166: printf(" %d", n_URL);
30167: printf(" %d", n_encoding);
30168: printf(" %d", n_options);
30169: printf("\n");
30170: }
30171: }
30172: }
30173: }
30174: }
30175: }
30176: }
30177: function_tests++;
30178: #endif
30179:
30180: return(test_ret);
30181: }
30182:
30183:
30184: static int
30185: test_xmlReaderNewWalker(void) {
30186: int test_ret = 0;
30187:
30188: #if defined(LIBXML_READER_ENABLED)
30189: int mem_base;
30190: int ret_val;
30191: xmlTextReaderPtr reader; /* an XML reader */
30192: int n_reader;
30193: xmlDocPtr doc; /* a preparsed document */
30194: int n_doc;
30195:
30196: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30197: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
30198: mem_base = xmlMemBlocks();
30199: reader = gen_xmlTextReaderPtr(n_reader, 0);
30200: doc = gen_xmlDocPtr(n_doc, 1);
30201:
30202: ret_val = xmlReaderNewWalker(reader, doc);
30203: desret_int(ret_val);
30204: call_tests++;
30205: des_xmlTextReaderPtr(n_reader, reader, 0);
30206: des_xmlDocPtr(n_doc, doc, 1);
30207: xmlResetLastError();
30208: if (mem_base != xmlMemBlocks()) {
30209: printf("Leak of %d blocks found in xmlReaderNewWalker",
30210: xmlMemBlocks() - mem_base);
30211: test_ret++;
30212: printf(" %d", n_reader);
30213: printf(" %d", n_doc);
30214: printf("\n");
30215: }
30216: }
30217: }
30218: function_tests++;
30219: #endif
30220:
30221: return(test_ret);
30222: }
30223:
30224:
30225: static int
30226: test_xmlReaderWalker(void) {
30227: int test_ret = 0;
30228:
30229: #if defined(LIBXML_READER_ENABLED)
30230: int mem_base;
30231: xmlTextReaderPtr ret_val;
30232: xmlDocPtr doc; /* a preparsed document */
30233: int n_doc;
30234:
30235: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
30236: mem_base = xmlMemBlocks();
30237: doc = gen_xmlDocPtr(n_doc, 0);
30238:
30239: ret_val = xmlReaderWalker(doc);
30240: desret_xmlTextReaderPtr(ret_val);
30241: call_tests++;
30242: des_xmlDocPtr(n_doc, doc, 0);
30243: xmlResetLastError();
30244: if (mem_base != xmlMemBlocks()) {
30245: printf("Leak of %d blocks found in xmlReaderWalker",
30246: xmlMemBlocks() - mem_base);
30247: test_ret++;
30248: printf(" %d", n_doc);
30249: printf("\n");
30250: }
30251: }
30252: function_tests++;
30253: #endif
30254:
30255: return(test_ret);
30256: }
30257:
30258:
30259: static int
30260: test_xmlTextReaderAttributeCount(void) {
30261: int test_ret = 0;
30262:
30263: #if defined(LIBXML_READER_ENABLED)
30264: int mem_base;
30265: int ret_val;
30266: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30267: int n_reader;
30268:
30269: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30270: mem_base = xmlMemBlocks();
30271: reader = gen_xmlTextReaderPtr(n_reader, 0);
30272:
30273: ret_val = xmlTextReaderAttributeCount(reader);
30274: desret_int(ret_val);
30275: call_tests++;
30276: des_xmlTextReaderPtr(n_reader, reader, 0);
30277: xmlResetLastError();
30278: if (mem_base != xmlMemBlocks()) {
30279: printf("Leak of %d blocks found in xmlTextReaderAttributeCount",
30280: xmlMemBlocks() - mem_base);
30281: test_ret++;
30282: printf(" %d", n_reader);
30283: printf("\n");
30284: }
30285: }
30286: function_tests++;
30287: #endif
30288:
30289: return(test_ret);
30290: }
30291:
30292:
30293: static int
30294: test_xmlTextReaderBaseUri(void) {
30295: int test_ret = 0;
30296:
30297: #if defined(LIBXML_READER_ENABLED)
30298: int mem_base;
30299: xmlChar * ret_val;
30300: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30301: int n_reader;
30302:
30303: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30304: mem_base = xmlMemBlocks();
30305: reader = gen_xmlTextReaderPtr(n_reader, 0);
30306:
30307: ret_val = xmlTextReaderBaseUri(reader);
30308: desret_xmlChar_ptr(ret_val);
30309: call_tests++;
30310: des_xmlTextReaderPtr(n_reader, reader, 0);
30311: xmlResetLastError();
30312: if (mem_base != xmlMemBlocks()) {
30313: printf("Leak of %d blocks found in xmlTextReaderBaseUri",
30314: xmlMemBlocks() - mem_base);
30315: test_ret++;
30316: printf(" %d", n_reader);
30317: printf("\n");
30318: }
30319: }
30320: function_tests++;
30321: #endif
30322:
30323: return(test_ret);
30324: }
30325:
30326:
30327: static int
30328: test_xmlTextReaderByteConsumed(void) {
30329: int test_ret = 0;
30330:
30331: #if defined(LIBXML_READER_ENABLED)
30332: int mem_base;
30333: long ret_val;
30334: xmlTextReaderPtr reader; /* an XML reader */
30335: int n_reader;
30336:
30337: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30338: mem_base = xmlMemBlocks();
30339: reader = gen_xmlTextReaderPtr(n_reader, 0);
30340:
30341: ret_val = xmlTextReaderByteConsumed(reader);
30342: desret_long(ret_val);
30343: call_tests++;
30344: des_xmlTextReaderPtr(n_reader, reader, 0);
30345: xmlResetLastError();
30346: if (mem_base != xmlMemBlocks()) {
30347: printf("Leak of %d blocks found in xmlTextReaderByteConsumed",
30348: xmlMemBlocks() - mem_base);
30349: test_ret++;
30350: printf(" %d", n_reader);
30351: printf("\n");
30352: }
30353: }
30354: function_tests++;
30355: #endif
30356:
30357: return(test_ret);
30358: }
30359:
30360:
30361: static int
30362: test_xmlTextReaderClose(void) {
30363: int test_ret = 0;
30364:
30365: #if defined(LIBXML_READER_ENABLED)
30366: int mem_base;
30367: int ret_val;
30368: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30369: int n_reader;
30370:
30371: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30372: mem_base = xmlMemBlocks();
30373: reader = gen_xmlTextReaderPtr(n_reader, 0);
30374:
30375: ret_val = xmlTextReaderClose(reader);
30376: desret_int(ret_val);
30377: call_tests++;
30378: des_xmlTextReaderPtr(n_reader, reader, 0);
30379: xmlResetLastError();
30380: if (mem_base != xmlMemBlocks()) {
30381: printf("Leak of %d blocks found in xmlTextReaderClose",
30382: xmlMemBlocks() - mem_base);
30383: test_ret++;
30384: printf(" %d", n_reader);
30385: printf("\n");
30386: }
30387: }
30388: function_tests++;
30389: #endif
30390:
30391: return(test_ret);
30392: }
30393:
30394:
30395: static int
30396: test_xmlTextReaderConstBaseUri(void) {
30397: int test_ret = 0;
30398:
30399: #if defined(LIBXML_READER_ENABLED)
30400: int mem_base;
30401: const xmlChar * ret_val;
30402: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30403: int n_reader;
30404:
30405: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30406: mem_base = xmlMemBlocks();
30407: reader = gen_xmlTextReaderPtr(n_reader, 0);
30408:
30409: ret_val = xmlTextReaderConstBaseUri(reader);
30410: desret_const_xmlChar_ptr(ret_val);
30411: call_tests++;
30412: des_xmlTextReaderPtr(n_reader, reader, 0);
30413: xmlResetLastError();
30414: if (mem_base != xmlMemBlocks()) {
30415: printf("Leak of %d blocks found in xmlTextReaderConstBaseUri",
30416: xmlMemBlocks() - mem_base);
30417: test_ret++;
30418: printf(" %d", n_reader);
30419: printf("\n");
30420: }
30421: }
30422: function_tests++;
30423: #endif
30424:
30425: return(test_ret);
30426: }
30427:
30428:
30429: static int
30430: test_xmlTextReaderConstEncoding(void) {
30431: int test_ret = 0;
30432:
30433: #if defined(LIBXML_READER_ENABLED)
30434: int mem_base;
30435: const xmlChar * ret_val;
30436: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30437: int n_reader;
30438:
30439: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30440: mem_base = xmlMemBlocks();
30441: reader = gen_xmlTextReaderPtr(n_reader, 0);
30442:
30443: ret_val = xmlTextReaderConstEncoding(reader);
30444: desret_const_xmlChar_ptr(ret_val);
30445: call_tests++;
30446: des_xmlTextReaderPtr(n_reader, reader, 0);
30447: xmlResetLastError();
30448: if (mem_base != xmlMemBlocks()) {
30449: printf("Leak of %d blocks found in xmlTextReaderConstEncoding",
30450: xmlMemBlocks() - mem_base);
30451: test_ret++;
30452: printf(" %d", n_reader);
30453: printf("\n");
30454: }
30455: }
30456: function_tests++;
30457: #endif
30458:
30459: return(test_ret);
30460: }
30461:
30462:
30463: static int
30464: test_xmlTextReaderConstLocalName(void) {
30465: int test_ret = 0;
30466:
30467: #if defined(LIBXML_READER_ENABLED)
30468: int mem_base;
30469: const xmlChar * ret_val;
30470: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30471: int n_reader;
30472:
30473: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30474: mem_base = xmlMemBlocks();
30475: reader = gen_xmlTextReaderPtr(n_reader, 0);
30476:
30477: ret_val = xmlTextReaderConstLocalName(reader);
30478: desret_const_xmlChar_ptr(ret_val);
30479: call_tests++;
30480: des_xmlTextReaderPtr(n_reader, reader, 0);
30481: xmlResetLastError();
30482: if (mem_base != xmlMemBlocks()) {
30483: printf("Leak of %d blocks found in xmlTextReaderConstLocalName",
30484: xmlMemBlocks() - mem_base);
30485: test_ret++;
30486: printf(" %d", n_reader);
30487: printf("\n");
30488: }
30489: }
30490: function_tests++;
30491: #endif
30492:
30493: return(test_ret);
30494: }
30495:
30496:
30497: static int
30498: test_xmlTextReaderConstName(void) {
30499: int test_ret = 0;
30500:
30501: #if defined(LIBXML_READER_ENABLED)
30502: int mem_base;
30503: const xmlChar * ret_val;
30504: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30505: int n_reader;
30506:
30507: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30508: mem_base = xmlMemBlocks();
30509: reader = gen_xmlTextReaderPtr(n_reader, 0);
30510:
30511: ret_val = xmlTextReaderConstName(reader);
30512: desret_const_xmlChar_ptr(ret_val);
30513: call_tests++;
30514: des_xmlTextReaderPtr(n_reader, reader, 0);
30515: xmlResetLastError();
30516: if (mem_base != xmlMemBlocks()) {
30517: printf("Leak of %d blocks found in xmlTextReaderConstName",
30518: xmlMemBlocks() - mem_base);
30519: test_ret++;
30520: printf(" %d", n_reader);
30521: printf("\n");
30522: }
30523: }
30524: function_tests++;
30525: #endif
30526:
30527: return(test_ret);
30528: }
30529:
30530:
30531: static int
30532: test_xmlTextReaderConstNamespaceUri(void) {
30533: int test_ret = 0;
30534:
30535: #if defined(LIBXML_READER_ENABLED)
30536: int mem_base;
30537: const xmlChar * ret_val;
30538: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30539: int n_reader;
30540:
30541: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30542: mem_base = xmlMemBlocks();
30543: reader = gen_xmlTextReaderPtr(n_reader, 0);
30544:
30545: ret_val = xmlTextReaderConstNamespaceUri(reader);
30546: desret_const_xmlChar_ptr(ret_val);
30547: call_tests++;
30548: des_xmlTextReaderPtr(n_reader, reader, 0);
30549: xmlResetLastError();
30550: if (mem_base != xmlMemBlocks()) {
30551: printf("Leak of %d blocks found in xmlTextReaderConstNamespaceUri",
30552: xmlMemBlocks() - mem_base);
30553: test_ret++;
30554: printf(" %d", n_reader);
30555: printf("\n");
30556: }
30557: }
30558: function_tests++;
30559: #endif
30560:
30561: return(test_ret);
30562: }
30563:
30564:
30565: static int
30566: test_xmlTextReaderConstPrefix(void) {
30567: int test_ret = 0;
30568:
30569: #if defined(LIBXML_READER_ENABLED)
30570: int mem_base;
30571: const xmlChar * ret_val;
30572: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30573: int n_reader;
30574:
30575: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30576: mem_base = xmlMemBlocks();
30577: reader = gen_xmlTextReaderPtr(n_reader, 0);
30578:
30579: ret_val = xmlTextReaderConstPrefix(reader);
30580: desret_const_xmlChar_ptr(ret_val);
30581: call_tests++;
30582: des_xmlTextReaderPtr(n_reader, reader, 0);
30583: xmlResetLastError();
30584: if (mem_base != xmlMemBlocks()) {
30585: printf("Leak of %d blocks found in xmlTextReaderConstPrefix",
30586: xmlMemBlocks() - mem_base);
30587: test_ret++;
30588: printf(" %d", n_reader);
30589: printf("\n");
30590: }
30591: }
30592: function_tests++;
30593: #endif
30594:
30595: return(test_ret);
30596: }
30597:
30598:
30599: static int
30600: test_xmlTextReaderConstString(void) {
30601: int test_ret = 0;
30602:
30603: #if defined(LIBXML_READER_ENABLED)
30604: int mem_base;
30605: const xmlChar * ret_val;
30606: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30607: int n_reader;
30608: xmlChar * str; /* the string to intern. */
30609: int n_str;
30610:
30611: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30612: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
30613: mem_base = xmlMemBlocks();
30614: reader = gen_xmlTextReaderPtr(n_reader, 0);
30615: str = gen_const_xmlChar_ptr(n_str, 1);
30616:
30617: ret_val = xmlTextReaderConstString(reader, (const xmlChar *)str);
30618: desret_const_xmlChar_ptr(ret_val);
30619: call_tests++;
30620: des_xmlTextReaderPtr(n_reader, reader, 0);
30621: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
30622: xmlResetLastError();
30623: if (mem_base != xmlMemBlocks()) {
30624: printf("Leak of %d blocks found in xmlTextReaderConstString",
30625: xmlMemBlocks() - mem_base);
30626: test_ret++;
30627: printf(" %d", n_reader);
30628: printf(" %d", n_str);
30629: printf("\n");
30630: }
30631: }
30632: }
30633: function_tests++;
30634: #endif
30635:
30636: return(test_ret);
30637: }
30638:
30639:
30640: static int
30641: test_xmlTextReaderConstValue(void) {
30642: int test_ret = 0;
30643:
30644: #if defined(LIBXML_READER_ENABLED)
30645: int mem_base;
30646: const xmlChar * ret_val;
30647: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30648: int n_reader;
30649:
30650: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30651: mem_base = xmlMemBlocks();
30652: reader = gen_xmlTextReaderPtr(n_reader, 0);
30653:
30654: ret_val = xmlTextReaderConstValue(reader);
30655: desret_const_xmlChar_ptr(ret_val);
30656: call_tests++;
30657: des_xmlTextReaderPtr(n_reader, reader, 0);
30658: xmlResetLastError();
30659: if (mem_base != xmlMemBlocks()) {
30660: printf("Leak of %d blocks found in xmlTextReaderConstValue",
30661: xmlMemBlocks() - mem_base);
30662: test_ret++;
30663: printf(" %d", n_reader);
30664: printf("\n");
30665: }
30666: }
30667: function_tests++;
30668: #endif
30669:
30670: return(test_ret);
30671: }
30672:
30673:
30674: static int
30675: test_xmlTextReaderConstXmlLang(void) {
30676: int test_ret = 0;
30677:
30678: #if defined(LIBXML_READER_ENABLED)
30679: int mem_base;
30680: const xmlChar * ret_val;
30681: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30682: int n_reader;
30683:
30684: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30685: mem_base = xmlMemBlocks();
30686: reader = gen_xmlTextReaderPtr(n_reader, 0);
30687:
30688: ret_val = xmlTextReaderConstXmlLang(reader);
30689: desret_const_xmlChar_ptr(ret_val);
30690: call_tests++;
30691: des_xmlTextReaderPtr(n_reader, reader, 0);
30692: xmlResetLastError();
30693: if (mem_base != xmlMemBlocks()) {
30694: printf("Leak of %d blocks found in xmlTextReaderConstXmlLang",
30695: xmlMemBlocks() - mem_base);
30696: test_ret++;
30697: printf(" %d", n_reader);
30698: printf("\n");
30699: }
30700: }
30701: function_tests++;
30702: #endif
30703:
30704: return(test_ret);
30705: }
30706:
30707:
30708: static int
30709: test_xmlTextReaderConstXmlVersion(void) {
30710: int test_ret = 0;
30711:
30712: #if defined(LIBXML_READER_ENABLED)
30713: int mem_base;
30714: const xmlChar * ret_val;
30715: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30716: int n_reader;
30717:
30718: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30719: mem_base = xmlMemBlocks();
30720: reader = gen_xmlTextReaderPtr(n_reader, 0);
30721:
30722: ret_val = xmlTextReaderConstXmlVersion(reader);
30723: desret_const_xmlChar_ptr(ret_val);
30724: call_tests++;
30725: des_xmlTextReaderPtr(n_reader, reader, 0);
30726: xmlResetLastError();
30727: if (mem_base != xmlMemBlocks()) {
30728: printf("Leak of %d blocks found in xmlTextReaderConstXmlVersion",
30729: xmlMemBlocks() - mem_base);
30730: test_ret++;
30731: printf(" %d", n_reader);
30732: printf("\n");
30733: }
30734: }
30735: function_tests++;
30736: #endif
30737:
30738: return(test_ret);
30739: }
30740:
30741:
30742: static int
30743: test_xmlTextReaderCurrentDoc(void) {
30744: int test_ret = 0;
30745:
30746: #if defined(LIBXML_READER_ENABLED)
30747: int mem_base;
30748: xmlDocPtr ret_val;
30749: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30750: int n_reader;
30751:
30752: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30753: mem_base = xmlMemBlocks();
30754: reader = gen_xmlTextReaderPtr(n_reader, 0);
30755:
30756: ret_val = xmlTextReaderCurrentDoc(reader);
30757: desret_xmlDocPtr(ret_val);
30758: call_tests++;
30759: des_xmlTextReaderPtr(n_reader, reader, 0);
30760: xmlResetLastError();
30761: if (mem_base != xmlMemBlocks()) {
30762: printf("Leak of %d blocks found in xmlTextReaderCurrentDoc",
30763: xmlMemBlocks() - mem_base);
30764: test_ret++;
30765: printf(" %d", n_reader);
30766: printf("\n");
30767: }
30768: }
30769: function_tests++;
30770: #endif
30771:
30772: return(test_ret);
30773: }
30774:
30775:
30776: static int
30777: test_xmlTextReaderCurrentNode(void) {
30778: int test_ret = 0;
30779:
30780: #if defined(LIBXML_READER_ENABLED)
30781: int mem_base;
30782: xmlNodePtr ret_val;
30783: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30784: int n_reader;
30785:
30786: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30787: mem_base = xmlMemBlocks();
30788: reader = gen_xmlTextReaderPtr(n_reader, 0);
30789:
30790: ret_val = xmlTextReaderCurrentNode(reader);
30791: desret_xmlNodePtr(ret_val);
30792: call_tests++;
30793: des_xmlTextReaderPtr(n_reader, reader, 0);
30794: xmlResetLastError();
30795: if (mem_base != xmlMemBlocks()) {
30796: printf("Leak of %d blocks found in xmlTextReaderCurrentNode",
30797: xmlMemBlocks() - mem_base);
30798: test_ret++;
30799: printf(" %d", n_reader);
30800: printf("\n");
30801: }
30802: }
30803: function_tests++;
30804: #endif
30805:
30806: return(test_ret);
30807: }
30808:
30809:
30810: static int
30811: test_xmlTextReaderDepth(void) {
30812: int test_ret = 0;
30813:
30814: #if defined(LIBXML_READER_ENABLED)
30815: int mem_base;
30816: int ret_val;
30817: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30818: int n_reader;
30819:
30820: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30821: mem_base = xmlMemBlocks();
30822: reader = gen_xmlTextReaderPtr(n_reader, 0);
30823:
30824: ret_val = xmlTextReaderDepth(reader);
30825: desret_int(ret_val);
30826: call_tests++;
30827: des_xmlTextReaderPtr(n_reader, reader, 0);
30828: xmlResetLastError();
30829: if (mem_base != xmlMemBlocks()) {
30830: printf("Leak of %d blocks found in xmlTextReaderDepth",
30831: xmlMemBlocks() - mem_base);
30832: test_ret++;
30833: printf(" %d", n_reader);
30834: printf("\n");
30835: }
30836: }
30837: function_tests++;
30838: #endif
30839:
30840: return(test_ret);
30841: }
30842:
30843:
30844: static int
30845: test_xmlTextReaderExpand(void) {
30846: int test_ret = 0;
30847:
30848: #if defined(LIBXML_READER_ENABLED)
30849: int mem_base;
30850: xmlNodePtr ret_val;
30851: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30852: int n_reader;
30853:
30854: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30855: mem_base = xmlMemBlocks();
30856: reader = gen_xmlTextReaderPtr(n_reader, 0);
30857:
30858: ret_val = xmlTextReaderExpand(reader);
30859: desret_xmlNodePtr(ret_val);
30860: call_tests++;
30861: des_xmlTextReaderPtr(n_reader, reader, 0);
30862: xmlResetLastError();
30863: if (mem_base != xmlMemBlocks()) {
30864: printf("Leak of %d blocks found in xmlTextReaderExpand",
30865: xmlMemBlocks() - mem_base);
30866: test_ret++;
30867: printf(" %d", n_reader);
30868: printf("\n");
30869: }
30870: }
30871: function_tests++;
30872: #endif
30873:
30874: return(test_ret);
30875: }
30876:
30877:
30878: static int
30879: test_xmlTextReaderGetAttribute(void) {
30880: int test_ret = 0;
30881:
30882: #if defined(LIBXML_READER_ENABLED)
30883: int mem_base;
30884: xmlChar * ret_val;
30885: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30886: int n_reader;
30887: xmlChar * name; /* the qualified name of the attribute. */
30888: int n_name;
30889:
30890: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30891: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
30892: mem_base = xmlMemBlocks();
30893: reader = gen_xmlTextReaderPtr(n_reader, 0);
30894: name = gen_const_xmlChar_ptr(n_name, 1);
30895:
30896: ret_val = xmlTextReaderGetAttribute(reader, (const xmlChar *)name);
30897: desret_xmlChar_ptr(ret_val);
30898: call_tests++;
30899: des_xmlTextReaderPtr(n_reader, reader, 0);
30900: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
30901: xmlResetLastError();
30902: if (mem_base != xmlMemBlocks()) {
30903: printf("Leak of %d blocks found in xmlTextReaderGetAttribute",
30904: xmlMemBlocks() - mem_base);
30905: test_ret++;
30906: printf(" %d", n_reader);
30907: printf(" %d", n_name);
30908: printf("\n");
30909: }
30910: }
30911: }
30912: function_tests++;
30913: #endif
30914:
30915: return(test_ret);
30916: }
30917:
30918:
30919: static int
30920: test_xmlTextReaderGetAttributeNo(void) {
30921: int test_ret = 0;
30922:
30923: #if defined(LIBXML_READER_ENABLED)
30924: int mem_base;
30925: xmlChar * ret_val;
30926: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30927: int n_reader;
30928: int no; /* the zero-based index of the attribute relative to the containing element */
30929: int n_no;
30930:
30931: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30932: for (n_no = 0;n_no < gen_nb_int;n_no++) {
30933: mem_base = xmlMemBlocks();
30934: reader = gen_xmlTextReaderPtr(n_reader, 0);
30935: no = gen_int(n_no, 1);
30936:
30937: ret_val = xmlTextReaderGetAttributeNo(reader, no);
30938: desret_xmlChar_ptr(ret_val);
30939: call_tests++;
30940: des_xmlTextReaderPtr(n_reader, reader, 0);
30941: des_int(n_no, no, 1);
30942: xmlResetLastError();
30943: if (mem_base != xmlMemBlocks()) {
30944: printf("Leak of %d blocks found in xmlTextReaderGetAttributeNo",
30945: xmlMemBlocks() - mem_base);
30946: test_ret++;
30947: printf(" %d", n_reader);
30948: printf(" %d", n_no);
30949: printf("\n");
30950: }
30951: }
30952: }
30953: function_tests++;
30954: #endif
30955:
30956: return(test_ret);
30957: }
30958:
30959:
30960: static int
30961: test_xmlTextReaderGetAttributeNs(void) {
30962: int test_ret = 0;
30963:
30964: #if defined(LIBXML_READER_ENABLED)
30965: int mem_base;
30966: xmlChar * ret_val;
30967: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30968: int n_reader;
30969: xmlChar * localName; /* the local name of the attribute. */
30970: int n_localName;
30971: xmlChar * namespaceURI; /* the namespace URI of the attribute. */
30972: int n_namespaceURI;
30973:
30974: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30975: for (n_localName = 0;n_localName < gen_nb_const_xmlChar_ptr;n_localName++) {
30976: for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
30977: mem_base = xmlMemBlocks();
30978: reader = gen_xmlTextReaderPtr(n_reader, 0);
30979: localName = gen_const_xmlChar_ptr(n_localName, 1);
30980: namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 2);
30981:
30982: ret_val = xmlTextReaderGetAttributeNs(reader, (const xmlChar *)localName, (const xmlChar *)namespaceURI);
30983: desret_xmlChar_ptr(ret_val);
30984: call_tests++;
30985: des_xmlTextReaderPtr(n_reader, reader, 0);
30986: des_const_xmlChar_ptr(n_localName, (const xmlChar *)localName, 1);
30987: des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 2);
30988: xmlResetLastError();
30989: if (mem_base != xmlMemBlocks()) {
30990: printf("Leak of %d blocks found in xmlTextReaderGetAttributeNs",
30991: xmlMemBlocks() - mem_base);
30992: test_ret++;
30993: printf(" %d", n_reader);
30994: printf(" %d", n_localName);
30995: printf(" %d", n_namespaceURI);
30996: printf("\n");
30997: }
30998: }
30999: }
31000: }
31001: function_tests++;
31002: #endif
31003:
31004: return(test_ret);
31005: }
31006:
31007: #ifdef LIBXML_READER_ENABLED
31008:
31009: #define gen_nb_xmlTextReaderErrorFunc_ptr 1
31010: static xmlTextReaderErrorFunc * gen_xmlTextReaderErrorFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
31011: return(NULL);
31012: }
31013: static void des_xmlTextReaderErrorFunc_ptr(int no ATTRIBUTE_UNUSED, xmlTextReaderErrorFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
31014: }
31015: #endif
31016:
31017:
31018: static int
31019: test_xmlTextReaderGetErrorHandler(void) {
31020: int test_ret = 0;
31021:
31022: #if defined(LIBXML_READER_ENABLED)
31023: int mem_base;
31024: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31025: int n_reader;
31026: xmlTextReaderErrorFunc * f; /* the callback function or NULL is no callback has been registered */
31027: int n_f;
31028: void ** arg; /* a user argument */
31029: int n_arg;
31030:
31031: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31032: for (n_f = 0;n_f < gen_nb_xmlTextReaderErrorFunc_ptr;n_f++) {
31033: for (n_arg = 0;n_arg < gen_nb_void_ptr_ptr;n_arg++) {
31034: mem_base = xmlMemBlocks();
31035: reader = gen_xmlTextReaderPtr(n_reader, 0);
31036: f = gen_xmlTextReaderErrorFunc_ptr(n_f, 1);
31037: arg = gen_void_ptr_ptr(n_arg, 2);
31038:
31039: xmlTextReaderGetErrorHandler(reader, f, arg);
31040: call_tests++;
31041: des_xmlTextReaderPtr(n_reader, reader, 0);
31042: des_xmlTextReaderErrorFunc_ptr(n_f, f, 1);
31043: des_void_ptr_ptr(n_arg, arg, 2);
31044: xmlResetLastError();
31045: if (mem_base != xmlMemBlocks()) {
31046: printf("Leak of %d blocks found in xmlTextReaderGetErrorHandler",
31047: xmlMemBlocks() - mem_base);
31048: test_ret++;
31049: printf(" %d", n_reader);
31050: printf(" %d", n_f);
31051: printf(" %d", n_arg);
31052: printf("\n");
31053: }
31054: }
31055: }
31056: }
31057: function_tests++;
31058: #endif
31059:
31060: return(test_ret);
31061: }
31062:
31063:
31064: static int
31065: test_xmlTextReaderGetParserColumnNumber(void) {
31066: int test_ret = 0;
31067:
31068: #if defined(LIBXML_READER_ENABLED)
31069: int mem_base;
31070: int ret_val;
31071: xmlTextReaderPtr reader; /* the user data (XML reader context) */
31072: int n_reader;
31073:
31074: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31075: mem_base = xmlMemBlocks();
31076: reader = gen_xmlTextReaderPtr(n_reader, 0);
31077:
31078: ret_val = xmlTextReaderGetParserColumnNumber(reader);
31079: desret_int(ret_val);
31080: call_tests++;
31081: des_xmlTextReaderPtr(n_reader, reader, 0);
31082: xmlResetLastError();
31083: if (mem_base != xmlMemBlocks()) {
31084: printf("Leak of %d blocks found in xmlTextReaderGetParserColumnNumber",
31085: xmlMemBlocks() - mem_base);
31086: test_ret++;
31087: printf(" %d", n_reader);
31088: printf("\n");
31089: }
31090: }
31091: function_tests++;
31092: #endif
31093:
31094: return(test_ret);
31095: }
31096:
31097:
31098: static int
31099: test_xmlTextReaderGetParserLineNumber(void) {
31100: int test_ret = 0;
31101:
31102: #if defined(LIBXML_READER_ENABLED)
31103: int mem_base;
31104: int ret_val;
31105: xmlTextReaderPtr reader; /* the user data (XML reader context) */
31106: int n_reader;
31107:
31108: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31109: mem_base = xmlMemBlocks();
31110: reader = gen_xmlTextReaderPtr(n_reader, 0);
31111:
31112: ret_val = xmlTextReaderGetParserLineNumber(reader);
31113: desret_int(ret_val);
31114: call_tests++;
31115: des_xmlTextReaderPtr(n_reader, reader, 0);
31116: xmlResetLastError();
31117: if (mem_base != xmlMemBlocks()) {
31118: printf("Leak of %d blocks found in xmlTextReaderGetParserLineNumber",
31119: xmlMemBlocks() - mem_base);
31120: test_ret++;
31121: printf(" %d", n_reader);
31122: printf("\n");
31123: }
31124: }
31125: function_tests++;
31126: #endif
31127:
31128: return(test_ret);
31129: }
31130:
31131:
31132: static int
31133: test_xmlTextReaderGetParserProp(void) {
31134: int test_ret = 0;
31135:
31136: #if defined(LIBXML_READER_ENABLED)
31137: int mem_base;
31138: int ret_val;
31139: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31140: int n_reader;
31141: int prop; /* the xmlParserProperties to get */
31142: int n_prop;
31143:
31144: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31145: for (n_prop = 0;n_prop < gen_nb_int;n_prop++) {
31146: mem_base = xmlMemBlocks();
31147: reader = gen_xmlTextReaderPtr(n_reader, 0);
31148: prop = gen_int(n_prop, 1);
31149:
31150: ret_val = xmlTextReaderGetParserProp(reader, prop);
31151: desret_int(ret_val);
31152: call_tests++;
31153: des_xmlTextReaderPtr(n_reader, reader, 0);
31154: des_int(n_prop, prop, 1);
31155: xmlResetLastError();
31156: if (mem_base != xmlMemBlocks()) {
31157: printf("Leak of %d blocks found in xmlTextReaderGetParserProp",
31158: xmlMemBlocks() - mem_base);
31159: test_ret++;
31160: printf(" %d", n_reader);
31161: printf(" %d", n_prop);
31162: printf("\n");
31163: }
31164: }
31165: }
31166: function_tests++;
31167: #endif
31168:
31169: return(test_ret);
31170: }
31171:
31172:
31173: static int
31174: test_xmlTextReaderGetRemainder(void) {
31175: int test_ret = 0;
31176:
31177: #if defined(LIBXML_READER_ENABLED)
31178: int mem_base;
31179: xmlParserInputBufferPtr ret_val;
31180: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31181: int n_reader;
31182:
31183: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31184: mem_base = xmlMemBlocks();
31185: reader = gen_xmlTextReaderPtr(n_reader, 0);
31186:
31187: ret_val = xmlTextReaderGetRemainder(reader);
31188: desret_xmlParserInputBufferPtr(ret_val);
31189: call_tests++;
31190: des_xmlTextReaderPtr(n_reader, reader, 0);
31191: xmlResetLastError();
31192: if (mem_base != xmlMemBlocks()) {
31193: printf("Leak of %d blocks found in xmlTextReaderGetRemainder",
31194: xmlMemBlocks() - mem_base);
31195: test_ret++;
31196: printf(" %d", n_reader);
31197: printf("\n");
31198: }
31199: }
31200: function_tests++;
31201: #endif
31202:
31203: return(test_ret);
31204: }
31205:
31206:
31207: static int
31208: test_xmlTextReaderHasAttributes(void) {
31209: int test_ret = 0;
31210:
31211: #if defined(LIBXML_READER_ENABLED)
31212: int mem_base;
31213: int ret_val;
31214: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31215: int n_reader;
31216:
31217: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31218: mem_base = xmlMemBlocks();
31219: reader = gen_xmlTextReaderPtr(n_reader, 0);
31220:
31221: ret_val = xmlTextReaderHasAttributes(reader);
31222: desret_int(ret_val);
31223: call_tests++;
31224: des_xmlTextReaderPtr(n_reader, reader, 0);
31225: xmlResetLastError();
31226: if (mem_base != xmlMemBlocks()) {
31227: printf("Leak of %d blocks found in xmlTextReaderHasAttributes",
31228: xmlMemBlocks() - mem_base);
31229: test_ret++;
31230: printf(" %d", n_reader);
31231: printf("\n");
31232: }
31233: }
31234: function_tests++;
31235: #endif
31236:
31237: return(test_ret);
31238: }
31239:
31240:
31241: static int
31242: test_xmlTextReaderHasValue(void) {
31243: int test_ret = 0;
31244:
31245: #if defined(LIBXML_READER_ENABLED)
31246: int mem_base;
31247: int ret_val;
31248: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31249: int n_reader;
31250:
31251: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31252: mem_base = xmlMemBlocks();
31253: reader = gen_xmlTextReaderPtr(n_reader, 0);
31254:
31255: ret_val = xmlTextReaderHasValue(reader);
31256: desret_int(ret_val);
31257: call_tests++;
31258: des_xmlTextReaderPtr(n_reader, reader, 0);
31259: xmlResetLastError();
31260: if (mem_base != xmlMemBlocks()) {
31261: printf("Leak of %d blocks found in xmlTextReaderHasValue",
31262: xmlMemBlocks() - mem_base);
31263: test_ret++;
31264: printf(" %d", n_reader);
31265: printf("\n");
31266: }
31267: }
31268: function_tests++;
31269: #endif
31270:
31271: return(test_ret);
31272: }
31273:
31274:
31275: static int
31276: test_xmlTextReaderIsDefault(void) {
31277: int test_ret = 0;
31278:
31279: #if defined(LIBXML_READER_ENABLED)
31280: int mem_base;
31281: int ret_val;
31282: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31283: int n_reader;
31284:
31285: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31286: mem_base = xmlMemBlocks();
31287: reader = gen_xmlTextReaderPtr(n_reader, 0);
31288:
31289: ret_val = xmlTextReaderIsDefault(reader);
31290: desret_int(ret_val);
31291: call_tests++;
31292: des_xmlTextReaderPtr(n_reader, reader, 0);
31293: xmlResetLastError();
31294: if (mem_base != xmlMemBlocks()) {
31295: printf("Leak of %d blocks found in xmlTextReaderIsDefault",
31296: xmlMemBlocks() - mem_base);
31297: test_ret++;
31298: printf(" %d", n_reader);
31299: printf("\n");
31300: }
31301: }
31302: function_tests++;
31303: #endif
31304:
31305: return(test_ret);
31306: }
31307:
31308:
31309: static int
31310: test_xmlTextReaderIsEmptyElement(void) {
31311: int test_ret = 0;
31312:
31313: #if defined(LIBXML_READER_ENABLED)
31314: int mem_base;
31315: int ret_val;
31316: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31317: int n_reader;
31318:
31319: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31320: mem_base = xmlMemBlocks();
31321: reader = gen_xmlTextReaderPtr(n_reader, 0);
31322:
31323: ret_val = xmlTextReaderIsEmptyElement(reader);
31324: desret_int(ret_val);
31325: call_tests++;
31326: des_xmlTextReaderPtr(n_reader, reader, 0);
31327: xmlResetLastError();
31328: if (mem_base != xmlMemBlocks()) {
31329: printf("Leak of %d blocks found in xmlTextReaderIsEmptyElement",
31330: xmlMemBlocks() - mem_base);
31331: test_ret++;
31332: printf(" %d", n_reader);
31333: printf("\n");
31334: }
31335: }
31336: function_tests++;
31337: #endif
31338:
31339: return(test_ret);
31340: }
31341:
31342:
31343: static int
31344: test_xmlTextReaderIsNamespaceDecl(void) {
31345: int test_ret = 0;
31346:
31347: #if defined(LIBXML_READER_ENABLED)
31348: int mem_base;
31349: int ret_val;
31350: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31351: int n_reader;
31352:
31353: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31354: mem_base = xmlMemBlocks();
31355: reader = gen_xmlTextReaderPtr(n_reader, 0);
31356:
31357: ret_val = xmlTextReaderIsNamespaceDecl(reader);
31358: desret_int(ret_val);
31359: call_tests++;
31360: des_xmlTextReaderPtr(n_reader, reader, 0);
31361: xmlResetLastError();
31362: if (mem_base != xmlMemBlocks()) {
31363: printf("Leak of %d blocks found in xmlTextReaderIsNamespaceDecl",
31364: xmlMemBlocks() - mem_base);
31365: test_ret++;
31366: printf(" %d", n_reader);
31367: printf("\n");
31368: }
31369: }
31370: function_tests++;
31371: #endif
31372:
31373: return(test_ret);
31374: }
31375:
31376:
31377: static int
31378: test_xmlTextReaderIsValid(void) {
31379: int test_ret = 0;
31380:
31381: #if defined(LIBXML_READER_ENABLED)
31382: int mem_base;
31383: int ret_val;
31384: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31385: int n_reader;
31386:
31387: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31388: mem_base = xmlMemBlocks();
31389: reader = gen_xmlTextReaderPtr(n_reader, 0);
31390:
31391: ret_val = xmlTextReaderIsValid(reader);
31392: desret_int(ret_val);
31393: call_tests++;
31394: des_xmlTextReaderPtr(n_reader, reader, 0);
31395: xmlResetLastError();
31396: if (mem_base != xmlMemBlocks()) {
31397: printf("Leak of %d blocks found in xmlTextReaderIsValid",
31398: xmlMemBlocks() - mem_base);
31399: test_ret++;
31400: printf(" %d", n_reader);
31401: printf("\n");
31402: }
31403: }
31404: function_tests++;
31405: #endif
31406:
31407: return(test_ret);
31408: }
31409:
31410:
31411: static int
31412: test_xmlTextReaderLocalName(void) {
31413: int test_ret = 0;
31414:
31415: #if defined(LIBXML_READER_ENABLED)
31416: int mem_base;
31417: xmlChar * ret_val;
31418: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31419: int n_reader;
31420:
31421: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31422: mem_base = xmlMemBlocks();
31423: reader = gen_xmlTextReaderPtr(n_reader, 0);
31424:
31425: ret_val = xmlTextReaderLocalName(reader);
31426: desret_xmlChar_ptr(ret_val);
31427: call_tests++;
31428: des_xmlTextReaderPtr(n_reader, reader, 0);
31429: xmlResetLastError();
31430: if (mem_base != xmlMemBlocks()) {
31431: printf("Leak of %d blocks found in xmlTextReaderLocalName",
31432: xmlMemBlocks() - mem_base);
31433: test_ret++;
31434: printf(" %d", n_reader);
31435: printf("\n");
31436: }
31437: }
31438: function_tests++;
31439: #endif
31440:
31441: return(test_ret);
31442: }
31443:
31444: #ifdef LIBXML_READER_ENABLED
31445:
31446: #define gen_nb_xmlTextReaderLocatorPtr 1
31447: static xmlTextReaderLocatorPtr gen_xmlTextReaderLocatorPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
31448: return(NULL);
31449: }
31450: static void des_xmlTextReaderLocatorPtr(int no ATTRIBUTE_UNUSED, xmlTextReaderLocatorPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
31451: }
31452: #endif
31453:
31454:
31455: static int
31456: test_xmlTextReaderLocatorBaseURI(void) {
31457: int test_ret = 0;
31458:
31459: #if defined(LIBXML_READER_ENABLED)
31460: int mem_base;
31461: xmlChar * ret_val;
31462: xmlTextReaderLocatorPtr locator; /* the xmlTextReaderLocatorPtr used */
31463: int n_locator;
31464:
31465: for (n_locator = 0;n_locator < gen_nb_xmlTextReaderLocatorPtr;n_locator++) {
31466: mem_base = xmlMemBlocks();
31467: locator = gen_xmlTextReaderLocatorPtr(n_locator, 0);
31468:
31469: ret_val = xmlTextReaderLocatorBaseURI(locator);
31470: desret_xmlChar_ptr(ret_val);
31471: call_tests++;
31472: des_xmlTextReaderLocatorPtr(n_locator, locator, 0);
31473: xmlResetLastError();
31474: if (mem_base != xmlMemBlocks()) {
31475: printf("Leak of %d blocks found in xmlTextReaderLocatorBaseURI",
31476: xmlMemBlocks() - mem_base);
31477: test_ret++;
31478: printf(" %d", n_locator);
31479: printf("\n");
31480: }
31481: }
31482: function_tests++;
31483: #endif
31484:
31485: return(test_ret);
31486: }
31487:
31488:
31489: static int
31490: test_xmlTextReaderLocatorLineNumber(void) {
31491: int test_ret = 0;
31492:
31493: #if defined(LIBXML_READER_ENABLED)
31494: int mem_base;
31495: int ret_val;
31496: xmlTextReaderLocatorPtr locator; /* the xmlTextReaderLocatorPtr used */
31497: int n_locator;
31498:
31499: for (n_locator = 0;n_locator < gen_nb_xmlTextReaderLocatorPtr;n_locator++) {
31500: mem_base = xmlMemBlocks();
31501: locator = gen_xmlTextReaderLocatorPtr(n_locator, 0);
31502:
31503: ret_val = xmlTextReaderLocatorLineNumber(locator);
31504: desret_int(ret_val);
31505: call_tests++;
31506: des_xmlTextReaderLocatorPtr(n_locator, locator, 0);
31507: xmlResetLastError();
31508: if (mem_base != xmlMemBlocks()) {
31509: printf("Leak of %d blocks found in xmlTextReaderLocatorLineNumber",
31510: xmlMemBlocks() - mem_base);
31511: test_ret++;
31512: printf(" %d", n_locator);
31513: printf("\n");
31514: }
31515: }
31516: function_tests++;
31517: #endif
31518:
31519: return(test_ret);
31520: }
31521:
31522:
31523: static int
31524: test_xmlTextReaderLookupNamespace(void) {
31525: int test_ret = 0;
31526:
31527: #if defined(LIBXML_READER_ENABLED)
31528: int mem_base;
31529: xmlChar * ret_val;
31530: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31531: int n_reader;
31532: xmlChar * prefix; /* the prefix whose namespace URI is to be resolved. To return the default namespace, specify NULL */
31533: int n_prefix;
31534:
31535: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31536: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
31537: mem_base = xmlMemBlocks();
31538: reader = gen_xmlTextReaderPtr(n_reader, 0);
31539: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
31540:
31541: ret_val = xmlTextReaderLookupNamespace(reader, (const xmlChar *)prefix);
31542: desret_xmlChar_ptr(ret_val);
31543: call_tests++;
31544: des_xmlTextReaderPtr(n_reader, reader, 0);
31545: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
31546: xmlResetLastError();
31547: if (mem_base != xmlMemBlocks()) {
31548: printf("Leak of %d blocks found in xmlTextReaderLookupNamespace",
31549: xmlMemBlocks() - mem_base);
31550: test_ret++;
31551: printf(" %d", n_reader);
31552: printf(" %d", n_prefix);
31553: printf("\n");
31554: }
31555: }
31556: }
31557: function_tests++;
31558: #endif
31559:
31560: return(test_ret);
31561: }
31562:
31563:
31564: static int
31565: test_xmlTextReaderMoveToAttribute(void) {
31566: int test_ret = 0;
31567:
31568: #if defined(LIBXML_READER_ENABLED)
31569: int mem_base;
31570: int ret_val;
31571: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31572: int n_reader;
31573: xmlChar * name; /* the qualified name of the attribute. */
31574: int n_name;
31575:
31576: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31577: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
31578: mem_base = xmlMemBlocks();
31579: reader = gen_xmlTextReaderPtr(n_reader, 0);
31580: name = gen_const_xmlChar_ptr(n_name, 1);
31581:
31582: ret_val = xmlTextReaderMoveToAttribute(reader, (const xmlChar *)name);
31583: desret_int(ret_val);
31584: call_tests++;
31585: des_xmlTextReaderPtr(n_reader, reader, 0);
31586: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
31587: xmlResetLastError();
31588: if (mem_base != xmlMemBlocks()) {
31589: printf("Leak of %d blocks found in xmlTextReaderMoveToAttribute",
31590: xmlMemBlocks() - mem_base);
31591: test_ret++;
31592: printf(" %d", n_reader);
31593: printf(" %d", n_name);
31594: printf("\n");
31595: }
31596: }
31597: }
31598: function_tests++;
31599: #endif
31600:
31601: return(test_ret);
31602: }
31603:
31604:
31605: static int
31606: test_xmlTextReaderMoveToAttributeNo(void) {
31607: int test_ret = 0;
31608:
31609: #if defined(LIBXML_READER_ENABLED)
31610: int mem_base;
31611: int ret_val;
31612: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31613: int n_reader;
31614: int no; /* the zero-based index of the attribute relative to the containing element. */
31615: int n_no;
31616:
31617: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31618: for (n_no = 0;n_no < gen_nb_int;n_no++) {
31619: mem_base = xmlMemBlocks();
31620: reader = gen_xmlTextReaderPtr(n_reader, 0);
31621: no = gen_int(n_no, 1);
31622:
31623: ret_val = xmlTextReaderMoveToAttributeNo(reader, no);
31624: desret_int(ret_val);
31625: call_tests++;
31626: des_xmlTextReaderPtr(n_reader, reader, 0);
31627: des_int(n_no, no, 1);
31628: xmlResetLastError();
31629: if (mem_base != xmlMemBlocks()) {
31630: printf("Leak of %d blocks found in xmlTextReaderMoveToAttributeNo",
31631: xmlMemBlocks() - mem_base);
31632: test_ret++;
31633: printf(" %d", n_reader);
31634: printf(" %d", n_no);
31635: printf("\n");
31636: }
31637: }
31638: }
31639: function_tests++;
31640: #endif
31641:
31642: return(test_ret);
31643: }
31644:
31645:
31646: static int
31647: test_xmlTextReaderMoveToAttributeNs(void) {
31648: int test_ret = 0;
31649:
31650: #if defined(LIBXML_READER_ENABLED)
31651: int mem_base;
31652: int ret_val;
31653: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31654: int n_reader;
31655: xmlChar * localName; /* the local name of the attribute. */
31656: int n_localName;
31657: xmlChar * namespaceURI; /* the namespace URI of the attribute. */
31658: int n_namespaceURI;
31659:
31660: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31661: for (n_localName = 0;n_localName < gen_nb_const_xmlChar_ptr;n_localName++) {
31662: for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
31663: mem_base = xmlMemBlocks();
31664: reader = gen_xmlTextReaderPtr(n_reader, 0);
31665: localName = gen_const_xmlChar_ptr(n_localName, 1);
31666: namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 2);
31667:
31668: ret_val = xmlTextReaderMoveToAttributeNs(reader, (const xmlChar *)localName, (const xmlChar *)namespaceURI);
31669: desret_int(ret_val);
31670: call_tests++;
31671: des_xmlTextReaderPtr(n_reader, reader, 0);
31672: des_const_xmlChar_ptr(n_localName, (const xmlChar *)localName, 1);
31673: des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 2);
31674: xmlResetLastError();
31675: if (mem_base != xmlMemBlocks()) {
31676: printf("Leak of %d blocks found in xmlTextReaderMoveToAttributeNs",
31677: xmlMemBlocks() - mem_base);
31678: test_ret++;
31679: printf(" %d", n_reader);
31680: printf(" %d", n_localName);
31681: printf(" %d", n_namespaceURI);
31682: printf("\n");
31683: }
31684: }
31685: }
31686: }
31687: function_tests++;
31688: #endif
31689:
31690: return(test_ret);
31691: }
31692:
31693:
31694: static int
31695: test_xmlTextReaderMoveToElement(void) {
31696: int test_ret = 0;
31697:
31698: #if defined(LIBXML_READER_ENABLED)
31699: int mem_base;
31700: int ret_val;
31701: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31702: int n_reader;
31703:
31704: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31705: mem_base = xmlMemBlocks();
31706: reader = gen_xmlTextReaderPtr(n_reader, 0);
31707:
31708: ret_val = xmlTextReaderMoveToElement(reader);
31709: desret_int(ret_val);
31710: call_tests++;
31711: des_xmlTextReaderPtr(n_reader, reader, 0);
31712: xmlResetLastError();
31713: if (mem_base != xmlMemBlocks()) {
31714: printf("Leak of %d blocks found in xmlTextReaderMoveToElement",
31715: xmlMemBlocks() - mem_base);
31716: test_ret++;
31717: printf(" %d", n_reader);
31718: printf("\n");
31719: }
31720: }
31721: function_tests++;
31722: #endif
31723:
31724: return(test_ret);
31725: }
31726:
31727:
31728: static int
31729: test_xmlTextReaderMoveToFirstAttribute(void) {
31730: int test_ret = 0;
31731:
31732: #if defined(LIBXML_READER_ENABLED)
31733: int mem_base;
31734: int ret_val;
31735: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31736: int n_reader;
31737:
31738: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31739: mem_base = xmlMemBlocks();
31740: reader = gen_xmlTextReaderPtr(n_reader, 0);
31741:
31742: ret_val = xmlTextReaderMoveToFirstAttribute(reader);
31743: desret_int(ret_val);
31744: call_tests++;
31745: des_xmlTextReaderPtr(n_reader, reader, 0);
31746: xmlResetLastError();
31747: if (mem_base != xmlMemBlocks()) {
31748: printf("Leak of %d blocks found in xmlTextReaderMoveToFirstAttribute",
31749: xmlMemBlocks() - mem_base);
31750: test_ret++;
31751: printf(" %d", n_reader);
31752: printf("\n");
31753: }
31754: }
31755: function_tests++;
31756: #endif
31757:
31758: return(test_ret);
31759: }
31760:
31761:
31762: static int
31763: test_xmlTextReaderMoveToNextAttribute(void) {
31764: int test_ret = 0;
31765:
31766: #if defined(LIBXML_READER_ENABLED)
31767: int mem_base;
31768: int ret_val;
31769: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31770: int n_reader;
31771:
31772: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31773: mem_base = xmlMemBlocks();
31774: reader = gen_xmlTextReaderPtr(n_reader, 0);
31775:
31776: ret_val = xmlTextReaderMoveToNextAttribute(reader);
31777: desret_int(ret_val);
31778: call_tests++;
31779: des_xmlTextReaderPtr(n_reader, reader, 0);
31780: xmlResetLastError();
31781: if (mem_base != xmlMemBlocks()) {
31782: printf("Leak of %d blocks found in xmlTextReaderMoveToNextAttribute",
31783: xmlMemBlocks() - mem_base);
31784: test_ret++;
31785: printf(" %d", n_reader);
31786: printf("\n");
31787: }
31788: }
31789: function_tests++;
31790: #endif
31791:
31792: return(test_ret);
31793: }
31794:
31795:
31796: static int
31797: test_xmlTextReaderName(void) {
31798: int test_ret = 0;
31799:
31800: #if defined(LIBXML_READER_ENABLED)
31801: int mem_base;
31802: xmlChar * ret_val;
31803: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31804: int n_reader;
31805:
31806: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31807: mem_base = xmlMemBlocks();
31808: reader = gen_xmlTextReaderPtr(n_reader, 0);
31809:
31810: ret_val = xmlTextReaderName(reader);
31811: desret_xmlChar_ptr(ret_val);
31812: call_tests++;
31813: des_xmlTextReaderPtr(n_reader, reader, 0);
31814: xmlResetLastError();
31815: if (mem_base != xmlMemBlocks()) {
31816: printf("Leak of %d blocks found in xmlTextReaderName",
31817: xmlMemBlocks() - mem_base);
31818: test_ret++;
31819: printf(" %d", n_reader);
31820: printf("\n");
31821: }
31822: }
31823: function_tests++;
31824: #endif
31825:
31826: return(test_ret);
31827: }
31828:
31829:
31830: static int
31831: test_xmlTextReaderNamespaceUri(void) {
31832: int test_ret = 0;
31833:
31834: #if defined(LIBXML_READER_ENABLED)
31835: int mem_base;
31836: xmlChar * ret_val;
31837: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31838: int n_reader;
31839:
31840: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31841: mem_base = xmlMemBlocks();
31842: reader = gen_xmlTextReaderPtr(n_reader, 0);
31843:
31844: ret_val = xmlTextReaderNamespaceUri(reader);
31845: desret_xmlChar_ptr(ret_val);
31846: call_tests++;
31847: des_xmlTextReaderPtr(n_reader, reader, 0);
31848: xmlResetLastError();
31849: if (mem_base != xmlMemBlocks()) {
31850: printf("Leak of %d blocks found in xmlTextReaderNamespaceUri",
31851: xmlMemBlocks() - mem_base);
31852: test_ret++;
31853: printf(" %d", n_reader);
31854: printf("\n");
31855: }
31856: }
31857: function_tests++;
31858: #endif
31859:
31860: return(test_ret);
31861: }
31862:
31863:
31864: static int
31865: test_xmlTextReaderNext(void) {
31866: int test_ret = 0;
31867:
31868: #if defined(LIBXML_READER_ENABLED)
31869: int mem_base;
31870: int ret_val;
31871: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31872: int n_reader;
31873:
31874: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31875: mem_base = xmlMemBlocks();
31876: reader = gen_xmlTextReaderPtr(n_reader, 0);
31877:
31878: ret_val = xmlTextReaderNext(reader);
31879: desret_int(ret_val);
31880: call_tests++;
31881: des_xmlTextReaderPtr(n_reader, reader, 0);
31882: xmlResetLastError();
31883: if (mem_base != xmlMemBlocks()) {
31884: printf("Leak of %d blocks found in xmlTextReaderNext",
31885: xmlMemBlocks() - mem_base);
31886: test_ret++;
31887: printf(" %d", n_reader);
31888: printf("\n");
31889: }
31890: }
31891: function_tests++;
31892: #endif
31893:
31894: return(test_ret);
31895: }
31896:
31897:
31898: static int
31899: test_xmlTextReaderNextSibling(void) {
31900: int test_ret = 0;
31901:
31902: #if defined(LIBXML_READER_ENABLED)
31903: int mem_base;
31904: int ret_val;
31905: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31906: int n_reader;
31907:
31908: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31909: mem_base = xmlMemBlocks();
31910: reader = gen_xmlTextReaderPtr(n_reader, 0);
31911:
31912: ret_val = xmlTextReaderNextSibling(reader);
31913: desret_int(ret_val);
31914: call_tests++;
31915: des_xmlTextReaderPtr(n_reader, reader, 0);
31916: xmlResetLastError();
31917: if (mem_base != xmlMemBlocks()) {
31918: printf("Leak of %d blocks found in xmlTextReaderNextSibling",
31919: xmlMemBlocks() - mem_base);
31920: test_ret++;
31921: printf(" %d", n_reader);
31922: printf("\n");
31923: }
31924: }
31925: function_tests++;
31926: #endif
31927:
31928: return(test_ret);
31929: }
31930:
31931:
31932: static int
31933: test_xmlTextReaderNodeType(void) {
31934: int test_ret = 0;
31935:
31936: #if defined(LIBXML_READER_ENABLED)
31937: int mem_base;
31938: int ret_val;
31939: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31940: int n_reader;
31941:
31942: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31943: mem_base = xmlMemBlocks();
31944: reader = gen_xmlTextReaderPtr(n_reader, 0);
31945:
31946: ret_val = xmlTextReaderNodeType(reader);
31947: desret_int(ret_val);
31948: call_tests++;
31949: des_xmlTextReaderPtr(n_reader, reader, 0);
31950: xmlResetLastError();
31951: if (mem_base != xmlMemBlocks()) {
31952: printf("Leak of %d blocks found in xmlTextReaderNodeType",
31953: xmlMemBlocks() - mem_base);
31954: test_ret++;
31955: printf(" %d", n_reader);
31956: printf("\n");
31957: }
31958: }
31959: function_tests++;
31960: #endif
31961:
31962: return(test_ret);
31963: }
31964:
31965:
31966: static int
31967: test_xmlTextReaderNormalization(void) {
31968: int test_ret = 0;
31969:
31970: #if defined(LIBXML_READER_ENABLED)
31971: int mem_base;
31972: int ret_val;
31973: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31974: int n_reader;
31975:
31976: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31977: mem_base = xmlMemBlocks();
31978: reader = gen_xmlTextReaderPtr(n_reader, 0);
31979:
31980: ret_val = xmlTextReaderNormalization(reader);
31981: desret_int(ret_val);
31982: call_tests++;
31983: des_xmlTextReaderPtr(n_reader, reader, 0);
31984: xmlResetLastError();
31985: if (mem_base != xmlMemBlocks()) {
31986: printf("Leak of %d blocks found in xmlTextReaderNormalization",
31987: xmlMemBlocks() - mem_base);
31988: test_ret++;
31989: printf(" %d", n_reader);
31990: printf("\n");
31991: }
31992: }
31993: function_tests++;
31994: #endif
31995:
31996: return(test_ret);
31997: }
31998:
31999:
32000: static int
32001: test_xmlTextReaderPrefix(void) {
32002: int test_ret = 0;
32003:
32004: #if defined(LIBXML_READER_ENABLED)
32005: int mem_base;
32006: xmlChar * ret_val;
32007: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32008: int n_reader;
32009:
32010: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32011: mem_base = xmlMemBlocks();
32012: reader = gen_xmlTextReaderPtr(n_reader, 0);
32013:
32014: ret_val = xmlTextReaderPrefix(reader);
32015: desret_xmlChar_ptr(ret_val);
32016: call_tests++;
32017: des_xmlTextReaderPtr(n_reader, reader, 0);
32018: xmlResetLastError();
32019: if (mem_base != xmlMemBlocks()) {
32020: printf("Leak of %d blocks found in xmlTextReaderPrefix",
32021: xmlMemBlocks() - mem_base);
32022: test_ret++;
32023: printf(" %d", n_reader);
32024: printf("\n");
32025: }
32026: }
32027: function_tests++;
32028: #endif
32029:
32030: return(test_ret);
32031: }
32032:
32033:
32034: static int
32035: test_xmlTextReaderPreserve(void) {
32036: int test_ret = 0;
32037:
32038: #if defined(LIBXML_READER_ENABLED)
32039: int mem_base;
32040: xmlNodePtr ret_val;
32041: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32042: int n_reader;
32043:
32044: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32045: mem_base = xmlMemBlocks();
32046: reader = gen_xmlTextReaderPtr(n_reader, 0);
32047:
32048: ret_val = xmlTextReaderPreserve(reader);
32049: desret_xmlNodePtr(ret_val);
32050: call_tests++;
32051: des_xmlTextReaderPtr(n_reader, reader, 0);
32052: xmlResetLastError();
32053: if (mem_base != xmlMemBlocks()) {
32054: printf("Leak of %d blocks found in xmlTextReaderPreserve",
32055: xmlMemBlocks() - mem_base);
32056: test_ret++;
32057: printf(" %d", n_reader);
32058: printf("\n");
32059: }
32060: }
32061: function_tests++;
32062: #endif
32063:
32064: return(test_ret);
32065: }
32066:
32067:
32068: static int
32069: test_xmlTextReaderPreservePattern(void) {
32070: int test_ret = 0;
32071:
32072: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_PATTERN_ENABLED)
32073: #ifdef LIBXML_PATTERN_ENABLED
32074: int mem_base;
32075: int ret_val;
32076: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32077: int n_reader;
32078: xmlChar * pattern; /* an XPath subset pattern */
32079: int n_pattern;
32080: xmlChar ** namespaces; /* the prefix definitions, array of [URI, prefix] or NULL */
32081: int n_namespaces;
32082:
32083: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32084: for (n_pattern = 0;n_pattern < gen_nb_const_xmlChar_ptr;n_pattern++) {
32085: for (n_namespaces = 0;n_namespaces < gen_nb_const_xmlChar_ptr_ptr;n_namespaces++) {
32086: mem_base = xmlMemBlocks();
32087: reader = gen_xmlTextReaderPtr(n_reader, 0);
32088: pattern = gen_const_xmlChar_ptr(n_pattern, 1);
32089: namespaces = gen_const_xmlChar_ptr_ptr(n_namespaces, 2);
32090:
32091: ret_val = xmlTextReaderPreservePattern(reader, (const xmlChar *)pattern, (const xmlChar **)namespaces);
32092: desret_int(ret_val);
32093: call_tests++;
32094: des_xmlTextReaderPtr(n_reader, reader, 0);
32095: des_const_xmlChar_ptr(n_pattern, (const xmlChar *)pattern, 1);
32096: des_const_xmlChar_ptr_ptr(n_namespaces, (const xmlChar **)namespaces, 2);
32097: xmlResetLastError();
32098: if (mem_base != xmlMemBlocks()) {
32099: printf("Leak of %d blocks found in xmlTextReaderPreservePattern",
32100: xmlMemBlocks() - mem_base);
32101: test_ret++;
32102: printf(" %d", n_reader);
32103: printf(" %d", n_pattern);
32104: printf(" %d", n_namespaces);
32105: printf("\n");
32106: }
32107: }
32108: }
32109: }
32110: function_tests++;
32111: #endif
32112: #endif
32113:
32114: return(test_ret);
32115: }
32116:
32117:
32118: static int
32119: test_xmlTextReaderQuoteChar(void) {
32120: int test_ret = 0;
32121:
32122: #if defined(LIBXML_READER_ENABLED)
32123: int mem_base;
32124: int ret_val;
32125: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32126: int n_reader;
32127:
32128: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32129: mem_base = xmlMemBlocks();
32130: reader = gen_xmlTextReaderPtr(n_reader, 0);
32131:
32132: ret_val = xmlTextReaderQuoteChar(reader);
32133: desret_int(ret_val);
32134: call_tests++;
32135: des_xmlTextReaderPtr(n_reader, reader, 0);
32136: xmlResetLastError();
32137: if (mem_base != xmlMemBlocks()) {
32138: printf("Leak of %d blocks found in xmlTextReaderQuoteChar",
32139: xmlMemBlocks() - mem_base);
32140: test_ret++;
32141: printf(" %d", n_reader);
32142: printf("\n");
32143: }
32144: }
32145: function_tests++;
32146: #endif
32147:
32148: return(test_ret);
32149: }
32150:
32151:
32152: static int
32153: test_xmlTextReaderRead(void) {
32154: int test_ret = 0;
32155:
32156: #if defined(LIBXML_READER_ENABLED)
32157: int mem_base;
32158: int ret_val;
32159: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32160: int n_reader;
32161:
32162: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32163: mem_base = xmlMemBlocks();
32164: reader = gen_xmlTextReaderPtr(n_reader, 0);
32165:
32166: ret_val = xmlTextReaderRead(reader);
32167: desret_int(ret_val);
32168: call_tests++;
32169: des_xmlTextReaderPtr(n_reader, reader, 0);
32170: xmlResetLastError();
32171: if (mem_base != xmlMemBlocks()) {
32172: printf("Leak of %d blocks found in xmlTextReaderRead",
32173: xmlMemBlocks() - mem_base);
32174: test_ret++;
32175: printf(" %d", n_reader);
32176: printf("\n");
32177: }
32178: }
32179: function_tests++;
32180: #endif
32181:
32182: return(test_ret);
32183: }
32184:
32185:
32186: static int
32187: test_xmlTextReaderReadAttributeValue(void) {
32188: int test_ret = 0;
32189:
32190: #if defined(LIBXML_READER_ENABLED)
32191: int mem_base;
32192: int ret_val;
32193: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32194: int n_reader;
32195:
32196: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32197: mem_base = xmlMemBlocks();
32198: reader = gen_xmlTextReaderPtr(n_reader, 0);
32199:
32200: ret_val = xmlTextReaderReadAttributeValue(reader);
32201: desret_int(ret_val);
32202: call_tests++;
32203: des_xmlTextReaderPtr(n_reader, reader, 0);
32204: xmlResetLastError();
32205: if (mem_base != xmlMemBlocks()) {
32206: printf("Leak of %d blocks found in xmlTextReaderReadAttributeValue",
32207: xmlMemBlocks() - mem_base);
32208: test_ret++;
32209: printf(" %d", n_reader);
32210: printf("\n");
32211: }
32212: }
32213: function_tests++;
32214: #endif
32215:
32216: return(test_ret);
32217: }
32218:
32219:
32220: static int
32221: test_xmlTextReaderReadState(void) {
32222: int test_ret = 0;
32223:
32224: #if defined(LIBXML_READER_ENABLED)
32225: int mem_base;
32226: int ret_val;
32227: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32228: int n_reader;
32229:
32230: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32231: mem_base = xmlMemBlocks();
32232: reader = gen_xmlTextReaderPtr(n_reader, 0);
32233:
32234: ret_val = xmlTextReaderReadState(reader);
32235: desret_int(ret_val);
32236: call_tests++;
32237: des_xmlTextReaderPtr(n_reader, reader, 0);
32238: xmlResetLastError();
32239: if (mem_base != xmlMemBlocks()) {
32240: printf("Leak of %d blocks found in xmlTextReaderReadState",
32241: xmlMemBlocks() - mem_base);
32242: test_ret++;
32243: printf(" %d", n_reader);
32244: printf("\n");
32245: }
32246: }
32247: function_tests++;
32248: #endif
32249:
32250: return(test_ret);
32251: }
32252:
32253:
32254: static int
32255: test_xmlTextReaderRelaxNGSetSchema(void) {
32256: int test_ret = 0;
32257:
32258: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
32259: int mem_base;
32260: int ret_val;
32261: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32262: int n_reader;
32263: xmlRelaxNGPtr schema; /* a precompiled RelaxNG schema */
32264: int n_schema;
32265:
32266: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32267: for (n_schema = 0;n_schema < gen_nb_xmlRelaxNGPtr;n_schema++) {
32268: mem_base = xmlMemBlocks();
32269: reader = gen_xmlTextReaderPtr(n_reader, 0);
32270: schema = gen_xmlRelaxNGPtr(n_schema, 1);
32271:
32272: ret_val = xmlTextReaderRelaxNGSetSchema(reader, schema);
32273: desret_int(ret_val);
32274: call_tests++;
32275: des_xmlTextReaderPtr(n_reader, reader, 0);
32276: des_xmlRelaxNGPtr(n_schema, schema, 1);
32277: xmlResetLastError();
32278: if (mem_base != xmlMemBlocks()) {
32279: printf("Leak of %d blocks found in xmlTextReaderRelaxNGSetSchema",
32280: xmlMemBlocks() - mem_base);
32281: test_ret++;
32282: printf(" %d", n_reader);
32283: printf(" %d", n_schema);
32284: printf("\n");
32285: }
32286: }
32287: }
32288: function_tests++;
32289: #endif
32290:
32291: return(test_ret);
32292: }
32293:
32294:
32295: static int
32296: test_xmlTextReaderRelaxNGValidate(void) {
32297: int test_ret = 0;
32298:
32299: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
32300: int mem_base;
32301: int ret_val;
32302: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32303: int n_reader;
32304: char * rng; /* the path to a RelaxNG schema or NULL */
32305: int n_rng;
32306:
32307: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32308: for (n_rng = 0;n_rng < gen_nb_const_char_ptr;n_rng++) {
32309: mem_base = xmlMemBlocks();
32310: reader = gen_xmlTextReaderPtr(n_reader, 0);
32311: rng = gen_const_char_ptr(n_rng, 1);
32312:
32313: ret_val = xmlTextReaderRelaxNGValidate(reader, (const char *)rng);
32314: desret_int(ret_val);
32315: call_tests++;
32316: des_xmlTextReaderPtr(n_reader, reader, 0);
32317: des_const_char_ptr(n_rng, (const char *)rng, 1);
32318: xmlResetLastError();
32319: if (mem_base != xmlMemBlocks()) {
32320: printf("Leak of %d blocks found in xmlTextReaderRelaxNGValidate",
32321: xmlMemBlocks() - mem_base);
32322: test_ret++;
32323: printf(" %d", n_reader);
32324: printf(" %d", n_rng);
32325: printf("\n");
32326: }
32327: }
32328: }
32329: function_tests++;
32330: #endif
32331:
32332: return(test_ret);
32333: }
32334:
32335:
32336: static int
1.1.1.2 ! misho 32337: test_xmlTextReaderRelaxNGValidateCtxt(void) {
! 32338: int test_ret = 0;
! 32339:
! 32340: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
! 32341: int mem_base;
! 32342: int ret_val;
! 32343: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
! 32344: int n_reader;
! 32345: xmlRelaxNGValidCtxtPtr ctxt; /* the RelaxNG schema validation context or NULL */
! 32346: int n_ctxt;
! 32347: int options; /* options (not used yet) */
! 32348: int n_options;
! 32349:
! 32350: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
! 32351: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
! 32352: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
! 32353: mem_base = xmlMemBlocks();
! 32354: reader = gen_xmlTextReaderPtr(n_reader, 0);
! 32355: ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 1);
! 32356: options = gen_parseroptions(n_options, 2);
! 32357:
! 32358: ret_val = xmlTextReaderRelaxNGValidateCtxt(reader, ctxt, options);
! 32359: desret_int(ret_val);
! 32360: call_tests++;
! 32361: des_xmlTextReaderPtr(n_reader, reader, 0);
! 32362: des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 1);
! 32363: des_parseroptions(n_options, options, 2);
! 32364: xmlResetLastError();
! 32365: if (mem_base != xmlMemBlocks()) {
! 32366: printf("Leak of %d blocks found in xmlTextReaderRelaxNGValidateCtxt",
! 32367: xmlMemBlocks() - mem_base);
! 32368: test_ret++;
! 32369: printf(" %d", n_reader);
! 32370: printf(" %d", n_ctxt);
! 32371: printf(" %d", n_options);
! 32372: printf("\n");
! 32373: }
! 32374: }
! 32375: }
! 32376: }
! 32377: function_tests++;
! 32378: #endif
! 32379:
! 32380: return(test_ret);
! 32381: }
! 32382:
! 32383:
! 32384: static int
1.1 misho 32385: test_xmlTextReaderSchemaValidate(void) {
32386: int test_ret = 0;
32387:
32388: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
32389: int ret_val;
32390: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32391: int n_reader;
32392: char * xsd; /* the path to a W3C XSD schema or NULL */
32393: int n_xsd;
32394:
32395: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32396: for (n_xsd = 0;n_xsd < gen_nb_const_char_ptr;n_xsd++) {
32397: reader = gen_xmlTextReaderPtr(n_reader, 0);
32398: xsd = gen_const_char_ptr(n_xsd, 1);
32399:
32400: ret_val = xmlTextReaderSchemaValidate(reader, (const char *)xsd);
32401: desret_int(ret_val);
32402: call_tests++;
32403: des_xmlTextReaderPtr(n_reader, reader, 0);
32404: des_const_char_ptr(n_xsd, (const char *)xsd, 1);
32405: xmlResetLastError();
32406: }
32407: }
32408: function_tests++;
32409: #endif
32410:
32411: return(test_ret);
32412: }
32413:
32414:
32415: static int
32416: test_xmlTextReaderSchemaValidateCtxt(void) {
32417: int test_ret = 0;
32418:
32419: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
32420: int mem_base;
32421: int ret_val;
32422: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32423: int n_reader;
32424: xmlSchemaValidCtxtPtr ctxt; /* the XML Schema validation context or NULL */
32425: int n_ctxt;
32426: int options; /* options (not used yet) */
32427: int n_options;
32428:
32429: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32430: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
32431: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
32432: mem_base = xmlMemBlocks();
32433: reader = gen_xmlTextReaderPtr(n_reader, 0);
32434: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 1);
32435: options = gen_parseroptions(n_options, 2);
32436:
32437: ret_val = xmlTextReaderSchemaValidateCtxt(reader, ctxt, options);
32438: desret_int(ret_val);
32439: call_tests++;
32440: des_xmlTextReaderPtr(n_reader, reader, 0);
32441: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 1);
32442: des_parseroptions(n_options, options, 2);
32443: xmlResetLastError();
32444: if (mem_base != xmlMemBlocks()) {
32445: printf("Leak of %d blocks found in xmlTextReaderSchemaValidateCtxt",
32446: xmlMemBlocks() - mem_base);
32447: test_ret++;
32448: printf(" %d", n_reader);
32449: printf(" %d", n_ctxt);
32450: printf(" %d", n_options);
32451: printf("\n");
32452: }
32453: }
32454: }
32455: }
32456: function_tests++;
32457: #endif
32458:
32459: return(test_ret);
32460: }
32461:
32462:
32463: static int
32464: test_xmlTextReaderSetErrorHandler(void) {
32465: int test_ret = 0;
32466:
32467:
32468: /* missing type support */
32469: return(test_ret);
32470: }
32471:
32472:
32473: static int
32474: test_xmlTextReaderSetParserProp(void) {
32475: int test_ret = 0;
32476:
32477: #if defined(LIBXML_READER_ENABLED)
32478: int mem_base;
32479: int ret_val;
32480: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32481: int n_reader;
32482: int prop; /* the xmlParserProperties to set */
32483: int n_prop;
32484: int value; /* usually 0 or 1 to (de)activate it */
32485: int n_value;
32486:
32487: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32488: for (n_prop = 0;n_prop < gen_nb_int;n_prop++) {
32489: for (n_value = 0;n_value < gen_nb_int;n_value++) {
32490: mem_base = xmlMemBlocks();
32491: reader = gen_xmlTextReaderPtr(n_reader, 0);
32492: prop = gen_int(n_prop, 1);
32493: value = gen_int(n_value, 2);
32494:
32495: ret_val = xmlTextReaderSetParserProp(reader, prop, value);
32496: desret_int(ret_val);
32497: call_tests++;
32498: des_xmlTextReaderPtr(n_reader, reader, 0);
32499: des_int(n_prop, prop, 1);
32500: des_int(n_value, value, 2);
32501: xmlResetLastError();
32502: if (mem_base != xmlMemBlocks()) {
32503: printf("Leak of %d blocks found in xmlTextReaderSetParserProp",
32504: xmlMemBlocks() - mem_base);
32505: test_ret++;
32506: printf(" %d", n_reader);
32507: printf(" %d", n_prop);
32508: printf(" %d", n_value);
32509: printf("\n");
32510: }
32511: }
32512: }
32513: }
32514: function_tests++;
32515: #endif
32516:
32517: return(test_ret);
32518: }
32519:
32520:
32521: static int
32522: test_xmlTextReaderSetSchema(void) {
32523: int test_ret = 0;
32524:
32525: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
32526: int mem_base;
32527: int ret_val;
32528: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32529: int n_reader;
32530: xmlSchemaPtr schema; /* a precompiled Schema schema */
32531: int n_schema;
32532:
32533: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32534: for (n_schema = 0;n_schema < gen_nb_xmlSchemaPtr;n_schema++) {
32535: mem_base = xmlMemBlocks();
32536: reader = gen_xmlTextReaderPtr(n_reader, 0);
32537: schema = gen_xmlSchemaPtr(n_schema, 1);
32538:
32539: ret_val = xmlTextReaderSetSchema(reader, schema);
32540: desret_int(ret_val);
32541: call_tests++;
32542: des_xmlTextReaderPtr(n_reader, reader, 0);
32543: des_xmlSchemaPtr(n_schema, schema, 1);
32544: xmlResetLastError();
32545: if (mem_base != xmlMemBlocks()) {
32546: printf("Leak of %d blocks found in xmlTextReaderSetSchema",
32547: xmlMemBlocks() - mem_base);
32548: test_ret++;
32549: printf(" %d", n_reader);
32550: printf(" %d", n_schema);
32551: printf("\n");
32552: }
32553: }
32554: }
32555: function_tests++;
32556: #endif
32557:
32558: return(test_ret);
32559: }
32560:
32561:
32562: static int
32563: test_xmlTextReaderSetStructuredErrorHandler(void) {
32564: int test_ret = 0;
32565:
32566:
32567: /* missing type support */
32568: return(test_ret);
32569: }
32570:
32571:
32572: static int
32573: test_xmlTextReaderSetup(void) {
32574: int test_ret = 0;
32575:
32576: #if defined(LIBXML_READER_ENABLED)
32577: int mem_base;
32578: int ret_val;
32579: xmlTextReaderPtr reader; /* an XML reader */
32580: int n_reader;
32581: xmlParserInputBufferPtr input; /* xmlParserInputBufferPtr used to feed the reader, will be destroyed with it. */
32582: int n_input;
32583: const char * URL; /* the base URL to use for the document */
32584: int n_URL;
32585: char * encoding; /* the document encoding, or NULL */
32586: int n_encoding;
32587: int options; /* a combination of xmlParserOption */
32588: int n_options;
32589:
32590: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32591: for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) {
32592: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
32593: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
32594: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
32595: mem_base = xmlMemBlocks();
32596: reader = gen_xmlTextReaderPtr(n_reader, 0);
32597: input = gen_xmlParserInputBufferPtr(n_input, 1);
32598: URL = gen_filepath(n_URL, 2);
32599: encoding = gen_const_char_ptr(n_encoding, 3);
32600: options = gen_parseroptions(n_options, 4);
32601:
32602: ret_val = xmlTextReaderSetup(reader, input, URL, (const char *)encoding, options);
32603: desret_int(ret_val);
32604: call_tests++;
32605: des_xmlTextReaderPtr(n_reader, reader, 0);
32606: des_filepath(n_URL, URL, 2);
32607: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
32608: des_parseroptions(n_options, options, 4);
32609: xmlResetLastError();
32610: if (mem_base != xmlMemBlocks()) {
32611: printf("Leak of %d blocks found in xmlTextReaderSetup",
32612: xmlMemBlocks() - mem_base);
32613: test_ret++;
32614: printf(" %d", n_reader);
32615: printf(" %d", n_input);
32616: printf(" %d", n_URL);
32617: printf(" %d", n_encoding);
32618: printf(" %d", n_options);
32619: printf("\n");
32620: }
32621: }
32622: }
32623: }
32624: }
32625: }
32626: function_tests++;
32627: #endif
32628:
32629: return(test_ret);
32630: }
32631:
32632:
32633: static int
32634: test_xmlTextReaderStandalone(void) {
32635: int test_ret = 0;
32636:
32637: #if defined(LIBXML_READER_ENABLED)
32638: int mem_base;
32639: int ret_val;
32640: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32641: int n_reader;
32642:
32643: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32644: mem_base = xmlMemBlocks();
32645: reader = gen_xmlTextReaderPtr(n_reader, 0);
32646:
32647: ret_val = xmlTextReaderStandalone(reader);
32648: desret_int(ret_val);
32649: call_tests++;
32650: des_xmlTextReaderPtr(n_reader, reader, 0);
32651: xmlResetLastError();
32652: if (mem_base != xmlMemBlocks()) {
32653: printf("Leak of %d blocks found in xmlTextReaderStandalone",
32654: xmlMemBlocks() - mem_base);
32655: test_ret++;
32656: printf(" %d", n_reader);
32657: printf("\n");
32658: }
32659: }
32660: function_tests++;
32661: #endif
32662:
32663: return(test_ret);
32664: }
32665:
32666:
32667: static int
32668: test_xmlTextReaderValue(void) {
32669: int test_ret = 0;
32670:
32671: #if defined(LIBXML_READER_ENABLED)
32672: int mem_base;
32673: xmlChar * ret_val;
32674: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32675: int n_reader;
32676:
32677: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32678: mem_base = xmlMemBlocks();
32679: reader = gen_xmlTextReaderPtr(n_reader, 0);
32680:
32681: ret_val = xmlTextReaderValue(reader);
32682: desret_xmlChar_ptr(ret_val);
32683: call_tests++;
32684: des_xmlTextReaderPtr(n_reader, reader, 0);
32685: xmlResetLastError();
32686: if (mem_base != xmlMemBlocks()) {
32687: printf("Leak of %d blocks found in xmlTextReaderValue",
32688: xmlMemBlocks() - mem_base);
32689: test_ret++;
32690: printf(" %d", n_reader);
32691: printf("\n");
32692: }
32693: }
32694: function_tests++;
32695: #endif
32696:
32697: return(test_ret);
32698: }
32699:
32700:
32701: static int
32702: test_xmlTextReaderXmlLang(void) {
32703: int test_ret = 0;
32704:
32705: #if defined(LIBXML_READER_ENABLED)
32706: int mem_base;
32707: xmlChar * ret_val;
32708: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32709: int n_reader;
32710:
32711: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32712: mem_base = xmlMemBlocks();
32713: reader = gen_xmlTextReaderPtr(n_reader, 0);
32714:
32715: ret_val = xmlTextReaderXmlLang(reader);
32716: desret_xmlChar_ptr(ret_val);
32717: call_tests++;
32718: des_xmlTextReaderPtr(n_reader, reader, 0);
32719: xmlResetLastError();
32720: if (mem_base != xmlMemBlocks()) {
32721: printf("Leak of %d blocks found in xmlTextReaderXmlLang",
32722: xmlMemBlocks() - mem_base);
32723: test_ret++;
32724: printf(" %d", n_reader);
32725: printf("\n");
32726: }
32727: }
32728: function_tests++;
32729: #endif
32730:
32731: return(test_ret);
32732: }
32733:
32734: static int
32735: test_xmlreader(void) {
32736: int test_ret = 0;
32737:
1.1.1.2 ! misho 32738: if (quiet == 0) printf("Testing xmlreader : 76 of 86 functions ...\n");
1.1 misho 32739: test_ret += test_xmlNewTextReader();
32740: test_ret += test_xmlNewTextReaderFilename();
32741: test_ret += test_xmlReaderForDoc();
32742: test_ret += test_xmlReaderForFile();
32743: test_ret += test_xmlReaderForMemory();
32744: test_ret += test_xmlReaderNewDoc();
32745: test_ret += test_xmlReaderNewFile();
32746: test_ret += test_xmlReaderNewMemory();
32747: test_ret += test_xmlReaderNewWalker();
32748: test_ret += test_xmlReaderWalker();
32749: test_ret += test_xmlTextReaderAttributeCount();
32750: test_ret += test_xmlTextReaderBaseUri();
32751: test_ret += test_xmlTextReaderByteConsumed();
32752: test_ret += test_xmlTextReaderClose();
32753: test_ret += test_xmlTextReaderConstBaseUri();
32754: test_ret += test_xmlTextReaderConstEncoding();
32755: test_ret += test_xmlTextReaderConstLocalName();
32756: test_ret += test_xmlTextReaderConstName();
32757: test_ret += test_xmlTextReaderConstNamespaceUri();
32758: test_ret += test_xmlTextReaderConstPrefix();
32759: test_ret += test_xmlTextReaderConstString();
32760: test_ret += test_xmlTextReaderConstValue();
32761: test_ret += test_xmlTextReaderConstXmlLang();
32762: test_ret += test_xmlTextReaderConstXmlVersion();
32763: test_ret += test_xmlTextReaderCurrentDoc();
32764: test_ret += test_xmlTextReaderCurrentNode();
32765: test_ret += test_xmlTextReaderDepth();
32766: test_ret += test_xmlTextReaderExpand();
32767: test_ret += test_xmlTextReaderGetAttribute();
32768: test_ret += test_xmlTextReaderGetAttributeNo();
32769: test_ret += test_xmlTextReaderGetAttributeNs();
32770: test_ret += test_xmlTextReaderGetErrorHandler();
32771: test_ret += test_xmlTextReaderGetParserColumnNumber();
32772: test_ret += test_xmlTextReaderGetParserLineNumber();
32773: test_ret += test_xmlTextReaderGetParserProp();
32774: test_ret += test_xmlTextReaderGetRemainder();
32775: test_ret += test_xmlTextReaderHasAttributes();
32776: test_ret += test_xmlTextReaderHasValue();
32777: test_ret += test_xmlTextReaderIsDefault();
32778: test_ret += test_xmlTextReaderIsEmptyElement();
32779: test_ret += test_xmlTextReaderIsNamespaceDecl();
32780: test_ret += test_xmlTextReaderIsValid();
32781: test_ret += test_xmlTextReaderLocalName();
32782: test_ret += test_xmlTextReaderLocatorBaseURI();
32783: test_ret += test_xmlTextReaderLocatorLineNumber();
32784: test_ret += test_xmlTextReaderLookupNamespace();
32785: test_ret += test_xmlTextReaderMoveToAttribute();
32786: test_ret += test_xmlTextReaderMoveToAttributeNo();
32787: test_ret += test_xmlTextReaderMoveToAttributeNs();
32788: test_ret += test_xmlTextReaderMoveToElement();
32789: test_ret += test_xmlTextReaderMoveToFirstAttribute();
32790: test_ret += test_xmlTextReaderMoveToNextAttribute();
32791: test_ret += test_xmlTextReaderName();
32792: test_ret += test_xmlTextReaderNamespaceUri();
32793: test_ret += test_xmlTextReaderNext();
32794: test_ret += test_xmlTextReaderNextSibling();
32795: test_ret += test_xmlTextReaderNodeType();
32796: test_ret += test_xmlTextReaderNormalization();
32797: test_ret += test_xmlTextReaderPrefix();
32798: test_ret += test_xmlTextReaderPreserve();
32799: test_ret += test_xmlTextReaderPreservePattern();
32800: test_ret += test_xmlTextReaderQuoteChar();
32801: test_ret += test_xmlTextReaderRead();
32802: test_ret += test_xmlTextReaderReadAttributeValue();
32803: test_ret += test_xmlTextReaderReadState();
32804: test_ret += test_xmlTextReaderRelaxNGSetSchema();
32805: test_ret += test_xmlTextReaderRelaxNGValidate();
1.1.1.2 ! misho 32806: test_ret += test_xmlTextReaderRelaxNGValidateCtxt();
1.1 misho 32807: test_ret += test_xmlTextReaderSchemaValidate();
32808: test_ret += test_xmlTextReaderSchemaValidateCtxt();
32809: test_ret += test_xmlTextReaderSetErrorHandler();
32810: test_ret += test_xmlTextReaderSetParserProp();
32811: test_ret += test_xmlTextReaderSetSchema();
32812: test_ret += test_xmlTextReaderSetStructuredErrorHandler();
32813: test_ret += test_xmlTextReaderSetup();
32814: test_ret += test_xmlTextReaderStandalone();
32815: test_ret += test_xmlTextReaderValue();
32816: test_ret += test_xmlTextReaderXmlLang();
32817:
32818: if (test_ret != 0)
32819: printf("Module xmlreader: %d errors\n", test_ret);
32820: return(test_ret);
32821: }
32822:
32823: static int
32824: test_xmlExpCtxtNbCons(void) {
32825: int test_ret = 0;
32826:
32827: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
32828: int mem_base;
32829: int ret_val;
32830: xmlExpCtxtPtr ctxt; /* an expression context */
32831: int n_ctxt;
32832:
32833: for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) {
32834: mem_base = xmlMemBlocks();
32835: ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0);
32836:
32837: ret_val = xmlExpCtxtNbCons(ctxt);
32838: desret_int(ret_val);
32839: call_tests++;
32840: des_xmlExpCtxtPtr(n_ctxt, ctxt, 0);
32841: xmlResetLastError();
32842: if (mem_base != xmlMemBlocks()) {
32843: printf("Leak of %d blocks found in xmlExpCtxtNbCons",
32844: xmlMemBlocks() - mem_base);
32845: test_ret++;
32846: printf(" %d", n_ctxt);
32847: printf("\n");
32848: }
32849: }
32850: function_tests++;
32851: #endif
32852:
32853: return(test_ret);
32854: }
32855:
32856:
32857: static int
32858: test_xmlExpCtxtNbNodes(void) {
32859: int test_ret = 0;
32860:
32861: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
32862: int mem_base;
32863: int ret_val;
32864: xmlExpCtxtPtr ctxt; /* an expression context */
32865: int n_ctxt;
32866:
32867: for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) {
32868: mem_base = xmlMemBlocks();
32869: ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0);
32870:
32871: ret_val = xmlExpCtxtNbNodes(ctxt);
32872: desret_int(ret_val);
32873: call_tests++;
32874: des_xmlExpCtxtPtr(n_ctxt, ctxt, 0);
32875: xmlResetLastError();
32876: if (mem_base != xmlMemBlocks()) {
32877: printf("Leak of %d blocks found in xmlExpCtxtNbNodes",
32878: xmlMemBlocks() - mem_base);
32879: test_ret++;
32880: printf(" %d", n_ctxt);
32881: printf("\n");
32882: }
32883: }
32884: function_tests++;
32885: #endif
32886:
32887: return(test_ret);
32888: }
32889:
32890:
32891: static int
32892: test_xmlExpDump(void) {
32893: int test_ret = 0;
32894:
32895: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
32896: int mem_base;
32897: xmlBufferPtr buf; /* a buffer to receive the output */
32898: int n_buf;
32899: xmlExpNodePtr expr; /* the compiled expression */
32900: int n_expr;
32901:
32902: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
32903: for (n_expr = 0;n_expr < gen_nb_xmlExpNodePtr;n_expr++) {
32904: mem_base = xmlMemBlocks();
32905: buf = gen_xmlBufferPtr(n_buf, 0);
32906: expr = gen_xmlExpNodePtr(n_expr, 1);
32907:
32908: xmlExpDump(buf, expr);
32909: call_tests++;
32910: des_xmlBufferPtr(n_buf, buf, 0);
32911: des_xmlExpNodePtr(n_expr, expr, 1);
32912: xmlResetLastError();
32913: if (mem_base != xmlMemBlocks()) {
32914: printf("Leak of %d blocks found in xmlExpDump",
32915: xmlMemBlocks() - mem_base);
32916: test_ret++;
32917: printf(" %d", n_buf);
32918: printf(" %d", n_expr);
32919: printf("\n");
32920: }
32921: }
32922: }
32923: function_tests++;
32924: #endif
32925:
32926: return(test_ret);
32927: }
32928:
32929:
32930: static int
32931: test_xmlExpExpDerive(void) {
32932: int test_ret = 0;
32933:
32934:
32935: /* missing type support */
32936: return(test_ret);
32937: }
32938:
32939:
32940: static int
32941: test_xmlExpGetLanguage(void) {
32942: int test_ret = 0;
32943:
32944: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
32945: int mem_base;
32946: int ret_val;
32947: xmlExpCtxtPtr ctxt; /* the expression context */
32948: int n_ctxt;
32949: xmlExpNodePtr exp; /* the expression */
32950: int n_exp;
32951: xmlChar ** langList; /* where to store the tokens */
32952: int n_langList;
32953: int len; /* the allocated lenght of @list */
32954: int n_len;
32955:
32956: for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) {
32957: for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) {
32958: for (n_langList = 0;n_langList < gen_nb_const_xmlChar_ptr_ptr;n_langList++) {
32959: for (n_len = 0;n_len < gen_nb_int;n_len++) {
32960: mem_base = xmlMemBlocks();
32961: ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0);
32962: exp = gen_xmlExpNodePtr(n_exp, 1);
32963: langList = gen_const_xmlChar_ptr_ptr(n_langList, 2);
32964: len = gen_int(n_len, 3);
32965:
32966: ret_val = xmlExpGetLanguage(ctxt, exp, (const xmlChar **)langList, len);
32967: desret_int(ret_val);
32968: call_tests++;
32969: des_xmlExpCtxtPtr(n_ctxt, ctxt, 0);
32970: des_xmlExpNodePtr(n_exp, exp, 1);
32971: des_const_xmlChar_ptr_ptr(n_langList, (const xmlChar **)langList, 2);
32972: des_int(n_len, len, 3);
32973: xmlResetLastError();
32974: if (mem_base != xmlMemBlocks()) {
32975: printf("Leak of %d blocks found in xmlExpGetLanguage",
32976: xmlMemBlocks() - mem_base);
32977: test_ret++;
32978: printf(" %d", n_ctxt);
32979: printf(" %d", n_exp);
32980: printf(" %d", n_langList);
32981: printf(" %d", n_len);
32982: printf("\n");
32983: }
32984: }
32985: }
32986: }
32987: }
32988: function_tests++;
32989: #endif
32990:
32991: return(test_ret);
32992: }
32993:
32994:
32995: static int
32996: test_xmlExpGetStart(void) {
32997: int test_ret = 0;
32998:
32999: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
33000: int mem_base;
33001: int ret_val;
33002: xmlExpCtxtPtr ctxt; /* the expression context */
33003: int n_ctxt;
33004: xmlExpNodePtr exp; /* the expression */
33005: int n_exp;
33006: xmlChar ** tokList; /* where to store the tokens */
33007: int n_tokList;
33008: int len; /* the allocated lenght of @list */
33009: int n_len;
33010:
33011: for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) {
33012: for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) {
33013: for (n_tokList = 0;n_tokList < gen_nb_const_xmlChar_ptr_ptr;n_tokList++) {
33014: for (n_len = 0;n_len < gen_nb_int;n_len++) {
33015: mem_base = xmlMemBlocks();
33016: ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0);
33017: exp = gen_xmlExpNodePtr(n_exp, 1);
33018: tokList = gen_const_xmlChar_ptr_ptr(n_tokList, 2);
33019: len = gen_int(n_len, 3);
33020:
33021: ret_val = xmlExpGetStart(ctxt, exp, (const xmlChar **)tokList, len);
33022: desret_int(ret_val);
33023: call_tests++;
33024: des_xmlExpCtxtPtr(n_ctxt, ctxt, 0);
33025: des_xmlExpNodePtr(n_exp, exp, 1);
33026: des_const_xmlChar_ptr_ptr(n_tokList, (const xmlChar **)tokList, 2);
33027: des_int(n_len, len, 3);
33028: xmlResetLastError();
33029: if (mem_base != xmlMemBlocks()) {
33030: printf("Leak of %d blocks found in xmlExpGetStart",
33031: xmlMemBlocks() - mem_base);
33032: test_ret++;
33033: printf(" %d", n_ctxt);
33034: printf(" %d", n_exp);
33035: printf(" %d", n_tokList);
33036: printf(" %d", n_len);
33037: printf("\n");
33038: }
33039: }
33040: }
33041: }
33042: }
33043: function_tests++;
33044: #endif
33045:
33046: return(test_ret);
33047: }
33048:
33049:
33050: static int
33051: test_xmlExpIsNillable(void) {
33052: int test_ret = 0;
33053:
33054: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
33055: int mem_base;
33056: int ret_val;
33057: xmlExpNodePtr exp; /* the expression */
33058: int n_exp;
33059:
33060: for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) {
33061: mem_base = xmlMemBlocks();
33062: exp = gen_xmlExpNodePtr(n_exp, 0);
33063:
33064: ret_val = xmlExpIsNillable(exp);
33065: desret_int(ret_val);
33066: call_tests++;
33067: des_xmlExpNodePtr(n_exp, exp, 0);
33068: xmlResetLastError();
33069: if (mem_base != xmlMemBlocks()) {
33070: printf("Leak of %d blocks found in xmlExpIsNillable",
33071: xmlMemBlocks() - mem_base);
33072: test_ret++;
33073: printf(" %d", n_exp);
33074: printf("\n");
33075: }
33076: }
33077: function_tests++;
33078: #endif
33079:
33080: return(test_ret);
33081: }
33082:
33083:
33084: static int
33085: test_xmlExpMaxToken(void) {
33086: int test_ret = 0;
33087:
33088: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
33089: int mem_base;
33090: int ret_val;
33091: xmlExpNodePtr expr; /* a compiled expression */
33092: int n_expr;
33093:
33094: for (n_expr = 0;n_expr < gen_nb_xmlExpNodePtr;n_expr++) {
33095: mem_base = xmlMemBlocks();
33096: expr = gen_xmlExpNodePtr(n_expr, 0);
33097:
33098: ret_val = xmlExpMaxToken(expr);
33099: desret_int(ret_val);
33100: call_tests++;
33101: des_xmlExpNodePtr(n_expr, expr, 0);
33102: xmlResetLastError();
33103: if (mem_base != xmlMemBlocks()) {
33104: printf("Leak of %d blocks found in xmlExpMaxToken",
33105: xmlMemBlocks() - mem_base);
33106: test_ret++;
33107: printf(" %d", n_expr);
33108: printf("\n");
33109: }
33110: }
33111: function_tests++;
33112: #endif
33113:
33114: return(test_ret);
33115: }
33116:
33117:
33118: static int
33119: test_xmlExpNewAtom(void) {
33120: int test_ret = 0;
33121:
33122:
33123: /* missing type support */
33124: return(test_ret);
33125: }
33126:
33127:
33128: static int
33129: test_xmlExpNewCtxt(void) {
33130: int test_ret = 0;
33131:
33132:
33133: /* missing type support */
33134: return(test_ret);
33135: }
33136:
33137:
33138: static int
33139: test_xmlExpNewOr(void) {
33140: int test_ret = 0;
33141:
33142:
33143: /* missing type support */
33144: return(test_ret);
33145: }
33146:
33147:
33148: static int
33149: test_xmlExpNewRange(void) {
33150: int test_ret = 0;
33151:
33152:
33153: /* missing type support */
33154: return(test_ret);
33155: }
33156:
33157:
33158: static int
33159: test_xmlExpNewSeq(void) {
33160: int test_ret = 0;
33161:
33162:
33163: /* missing type support */
33164: return(test_ret);
33165: }
33166:
33167:
33168: static int
33169: test_xmlExpParse(void) {
33170: int test_ret = 0;
33171:
33172:
33173: /* missing type support */
33174: return(test_ret);
33175: }
33176:
33177:
33178: static int
33179: test_xmlExpRef(void) {
33180: int test_ret = 0;
33181:
33182: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
33183: int mem_base;
33184: xmlExpNodePtr exp; /* the expression */
33185: int n_exp;
33186:
33187: for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) {
33188: mem_base = xmlMemBlocks();
33189: exp = gen_xmlExpNodePtr(n_exp, 0);
33190:
33191: xmlExpRef(exp);
33192: call_tests++;
33193: des_xmlExpNodePtr(n_exp, exp, 0);
33194: xmlResetLastError();
33195: if (mem_base != xmlMemBlocks()) {
33196: printf("Leak of %d blocks found in xmlExpRef",
33197: xmlMemBlocks() - mem_base);
33198: test_ret++;
33199: printf(" %d", n_exp);
33200: printf("\n");
33201: }
33202: }
33203: function_tests++;
33204: #endif
33205:
33206: return(test_ret);
33207: }
33208:
33209:
33210: static int
33211: test_xmlExpStringDerive(void) {
33212: int test_ret = 0;
33213:
33214:
33215: /* missing type support */
33216: return(test_ret);
33217: }
33218:
33219:
33220: static int
33221: test_xmlExpSubsume(void) {
33222: int test_ret = 0;
33223:
33224: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
33225: int mem_base;
33226: int ret_val;
33227: xmlExpCtxtPtr ctxt; /* the expressions context */
33228: int n_ctxt;
33229: xmlExpNodePtr exp; /* the englobing expression */
33230: int n_exp;
33231: xmlExpNodePtr sub; /* the subexpression */
33232: int n_sub;
33233:
33234: for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) {
33235: for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) {
33236: for (n_sub = 0;n_sub < gen_nb_xmlExpNodePtr;n_sub++) {
33237: mem_base = xmlMemBlocks();
33238: ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0);
33239: exp = gen_xmlExpNodePtr(n_exp, 1);
33240: sub = gen_xmlExpNodePtr(n_sub, 2);
33241:
33242: ret_val = xmlExpSubsume(ctxt, exp, sub);
33243: desret_int(ret_val);
33244: call_tests++;
33245: des_xmlExpCtxtPtr(n_ctxt, ctxt, 0);
33246: des_xmlExpNodePtr(n_exp, exp, 1);
33247: des_xmlExpNodePtr(n_sub, sub, 2);
33248: xmlResetLastError();
33249: if (mem_base != xmlMemBlocks()) {
33250: printf("Leak of %d blocks found in xmlExpSubsume",
33251: xmlMemBlocks() - mem_base);
33252: test_ret++;
33253: printf(" %d", n_ctxt);
33254: printf(" %d", n_exp);
33255: printf(" %d", n_sub);
33256: printf("\n");
33257: }
33258: }
33259: }
33260: }
33261: function_tests++;
33262: #endif
33263:
33264: return(test_ret);
33265: }
33266:
33267: #ifdef LIBXML_REGEXP_ENABLED
33268:
33269: #define gen_nb_xmlRegExecCtxtPtr 1
33270: static xmlRegExecCtxtPtr gen_xmlRegExecCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33271: return(NULL);
33272: }
33273: static void des_xmlRegExecCtxtPtr(int no ATTRIBUTE_UNUSED, xmlRegExecCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33274: }
33275: #endif
33276:
33277:
33278: static int
33279: test_xmlRegExecErrInfo(void) {
33280: int test_ret = 0;
33281:
33282: #if defined(LIBXML_REGEXP_ENABLED)
33283: int mem_base;
33284: int ret_val;
33285: xmlRegExecCtxtPtr exec; /* a regexp execution context generating an error */
33286: int n_exec;
33287: xmlChar ** string; /* return value for the error string */
33288: int n_string;
33289: int * nbval; /* pointer to the number of accepted values IN/OUT */
33290: int n_nbval;
33291: int * nbneg; /* return number of negative transitions */
33292: int n_nbneg;
33293: xmlChar ** values; /* pointer to the array of acceptable values */
33294: int n_values;
33295: int * terminal; /* return value if this was a terminal state */
33296: int n_terminal;
33297:
33298: for (n_exec = 0;n_exec < gen_nb_xmlRegExecCtxtPtr;n_exec++) {
33299: for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr_ptr;n_string++) {
33300: for (n_nbval = 0;n_nbval < gen_nb_int_ptr;n_nbval++) {
33301: for (n_nbneg = 0;n_nbneg < gen_nb_int_ptr;n_nbneg++) {
33302: for (n_values = 0;n_values < gen_nb_xmlChar_ptr_ptr;n_values++) {
33303: for (n_terminal = 0;n_terminal < gen_nb_int_ptr;n_terminal++) {
33304: mem_base = xmlMemBlocks();
33305: exec = gen_xmlRegExecCtxtPtr(n_exec, 0);
33306: string = gen_const_xmlChar_ptr_ptr(n_string, 1);
33307: nbval = gen_int_ptr(n_nbval, 2);
33308: nbneg = gen_int_ptr(n_nbneg, 3);
33309: values = gen_xmlChar_ptr_ptr(n_values, 4);
33310: terminal = gen_int_ptr(n_terminal, 5);
33311:
33312: ret_val = xmlRegExecErrInfo(exec, (const xmlChar **)string, nbval, nbneg, values, terminal);
33313: desret_int(ret_val);
33314: call_tests++;
33315: des_xmlRegExecCtxtPtr(n_exec, exec, 0);
33316: des_const_xmlChar_ptr_ptr(n_string, (const xmlChar **)string, 1);
33317: des_int_ptr(n_nbval, nbval, 2);
33318: des_int_ptr(n_nbneg, nbneg, 3);
33319: des_xmlChar_ptr_ptr(n_values, values, 4);
33320: des_int_ptr(n_terminal, terminal, 5);
33321: xmlResetLastError();
33322: if (mem_base != xmlMemBlocks()) {
33323: printf("Leak of %d blocks found in xmlRegExecErrInfo",
33324: xmlMemBlocks() - mem_base);
33325: test_ret++;
33326: printf(" %d", n_exec);
33327: printf(" %d", n_string);
33328: printf(" %d", n_nbval);
33329: printf(" %d", n_nbneg);
33330: printf(" %d", n_values);
33331: printf(" %d", n_terminal);
33332: printf("\n");
33333: }
33334: }
33335: }
33336: }
33337: }
33338: }
33339: }
33340: function_tests++;
33341: #endif
33342:
33343: return(test_ret);
33344: }
33345:
33346:
33347: static int
33348: test_xmlRegExecNextValues(void) {
33349: int test_ret = 0;
33350:
33351: #if defined(LIBXML_REGEXP_ENABLED)
33352: int mem_base;
33353: int ret_val;
33354: xmlRegExecCtxtPtr exec; /* a regexp execution context */
33355: int n_exec;
33356: int * nbval; /* pointer to the number of accepted values IN/OUT */
33357: int n_nbval;
33358: int * nbneg; /* return number of negative transitions */
33359: int n_nbneg;
33360: xmlChar ** values; /* pointer to the array of acceptable values */
33361: int n_values;
33362: int * terminal; /* return value if this was a terminal state */
33363: int n_terminal;
33364:
33365: for (n_exec = 0;n_exec < gen_nb_xmlRegExecCtxtPtr;n_exec++) {
33366: for (n_nbval = 0;n_nbval < gen_nb_int_ptr;n_nbval++) {
33367: for (n_nbneg = 0;n_nbneg < gen_nb_int_ptr;n_nbneg++) {
33368: for (n_values = 0;n_values < gen_nb_xmlChar_ptr_ptr;n_values++) {
33369: for (n_terminal = 0;n_terminal < gen_nb_int_ptr;n_terminal++) {
33370: mem_base = xmlMemBlocks();
33371: exec = gen_xmlRegExecCtxtPtr(n_exec, 0);
33372: nbval = gen_int_ptr(n_nbval, 1);
33373: nbneg = gen_int_ptr(n_nbneg, 2);
33374: values = gen_xmlChar_ptr_ptr(n_values, 3);
33375: terminal = gen_int_ptr(n_terminal, 4);
33376:
33377: ret_val = xmlRegExecNextValues(exec, nbval, nbneg, values, terminal);
33378: desret_int(ret_val);
33379: call_tests++;
33380: des_xmlRegExecCtxtPtr(n_exec, exec, 0);
33381: des_int_ptr(n_nbval, nbval, 1);
33382: des_int_ptr(n_nbneg, nbneg, 2);
33383: des_xmlChar_ptr_ptr(n_values, values, 3);
33384: des_int_ptr(n_terminal, terminal, 4);
33385: xmlResetLastError();
33386: if (mem_base != xmlMemBlocks()) {
33387: printf("Leak of %d blocks found in xmlRegExecNextValues",
33388: xmlMemBlocks() - mem_base);
33389: test_ret++;
33390: printf(" %d", n_exec);
33391: printf(" %d", n_nbval);
33392: printf(" %d", n_nbneg);
33393: printf(" %d", n_values);
33394: printf(" %d", n_terminal);
33395: printf("\n");
33396: }
33397: }
33398: }
33399: }
33400: }
33401: }
33402: function_tests++;
33403: #endif
33404:
33405: return(test_ret);
33406: }
33407:
33408:
33409: static int
33410: test_xmlRegExecPushString(void) {
33411: int test_ret = 0;
33412:
33413: #if defined(LIBXML_REGEXP_ENABLED)
33414: int mem_base;
33415: int ret_val;
33416: xmlRegExecCtxtPtr exec; /* a regexp execution context or NULL to indicate the end */
33417: int n_exec;
33418: xmlChar * value; /* a string token input */
33419: int n_value;
33420: void * data; /* data associated to the token to reuse in callbacks */
33421: int n_data;
33422:
33423: for (n_exec = 0;n_exec < gen_nb_xmlRegExecCtxtPtr;n_exec++) {
33424: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
33425: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
33426: mem_base = xmlMemBlocks();
33427: exec = gen_xmlRegExecCtxtPtr(n_exec, 0);
33428: value = gen_const_xmlChar_ptr(n_value, 1);
33429: data = gen_userdata(n_data, 2);
33430:
33431: ret_val = xmlRegExecPushString(exec, (const xmlChar *)value, data);
33432: desret_int(ret_val);
33433: call_tests++;
33434: des_xmlRegExecCtxtPtr(n_exec, exec, 0);
33435: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
33436: des_userdata(n_data, data, 2);
33437: xmlResetLastError();
33438: if (mem_base != xmlMemBlocks()) {
33439: printf("Leak of %d blocks found in xmlRegExecPushString",
33440: xmlMemBlocks() - mem_base);
33441: test_ret++;
33442: printf(" %d", n_exec);
33443: printf(" %d", n_value);
33444: printf(" %d", n_data);
33445: printf("\n");
33446: }
33447: }
33448: }
33449: }
33450: function_tests++;
33451: #endif
33452:
33453: return(test_ret);
33454: }
33455:
33456:
33457: static int
33458: test_xmlRegExecPushString2(void) {
33459: int test_ret = 0;
33460:
33461: #if defined(LIBXML_REGEXP_ENABLED)
33462: int mem_base;
33463: int ret_val;
33464: xmlRegExecCtxtPtr exec; /* a regexp execution context or NULL to indicate the end */
33465: int n_exec;
33466: xmlChar * value; /* the first string token input */
33467: int n_value;
33468: xmlChar * value2; /* the second string token input */
33469: int n_value2;
33470: void * data; /* data associated to the token to reuse in callbacks */
33471: int n_data;
33472:
33473: for (n_exec = 0;n_exec < gen_nb_xmlRegExecCtxtPtr;n_exec++) {
33474: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
33475: for (n_value2 = 0;n_value2 < gen_nb_const_xmlChar_ptr;n_value2++) {
33476: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
33477: mem_base = xmlMemBlocks();
33478: exec = gen_xmlRegExecCtxtPtr(n_exec, 0);
33479: value = gen_const_xmlChar_ptr(n_value, 1);
33480: value2 = gen_const_xmlChar_ptr(n_value2, 2);
33481: data = gen_userdata(n_data, 3);
33482:
33483: ret_val = xmlRegExecPushString2(exec, (const xmlChar *)value, (const xmlChar *)value2, data);
33484: desret_int(ret_val);
33485: call_tests++;
33486: des_xmlRegExecCtxtPtr(n_exec, exec, 0);
33487: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
33488: des_const_xmlChar_ptr(n_value2, (const xmlChar *)value2, 2);
33489: des_userdata(n_data, data, 3);
33490: xmlResetLastError();
33491: if (mem_base != xmlMemBlocks()) {
33492: printf("Leak of %d blocks found in xmlRegExecPushString2",
33493: xmlMemBlocks() - mem_base);
33494: test_ret++;
33495: printf(" %d", n_exec);
33496: printf(" %d", n_value);
33497: printf(" %d", n_value2);
33498: printf(" %d", n_data);
33499: printf("\n");
33500: }
33501: }
33502: }
33503: }
33504: }
33505: function_tests++;
33506: #endif
33507:
33508: return(test_ret);
33509: }
33510:
33511: #ifdef LIBXML_REGEXP_ENABLED
33512:
33513: #define gen_nb_xmlRegexpPtr 1
33514: static xmlRegexpPtr gen_xmlRegexpPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33515: return(NULL);
33516: }
33517: static void des_xmlRegexpPtr(int no ATTRIBUTE_UNUSED, xmlRegexpPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33518: }
33519: #endif
33520:
33521:
33522: static int
33523: test_xmlRegNewExecCtxt(void) {
33524: int test_ret = 0;
33525:
33526:
33527: /* missing type support */
33528: return(test_ret);
33529: }
33530:
33531:
33532: static int
33533: test_xmlRegexpCompile(void) {
33534: int test_ret = 0;
33535:
33536:
33537: /* missing type support */
33538: return(test_ret);
33539: }
33540:
33541:
33542: static int
33543: test_xmlRegexpExec(void) {
33544: int test_ret = 0;
33545:
33546: #if defined(LIBXML_REGEXP_ENABLED)
33547: int mem_base;
33548: int ret_val;
33549: xmlRegexpPtr comp; /* the compiled regular expression */
33550: int n_comp;
33551: xmlChar * content; /* the value to check against the regular expression */
33552: int n_content;
33553:
33554: for (n_comp = 0;n_comp < gen_nb_xmlRegexpPtr;n_comp++) {
33555: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
33556: mem_base = xmlMemBlocks();
33557: comp = gen_xmlRegexpPtr(n_comp, 0);
33558: content = gen_const_xmlChar_ptr(n_content, 1);
33559:
33560: ret_val = xmlRegexpExec(comp, (const xmlChar *)content);
33561: desret_int(ret_val);
33562: call_tests++;
33563: des_xmlRegexpPtr(n_comp, comp, 0);
33564: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
33565: xmlResetLastError();
33566: if (mem_base != xmlMemBlocks()) {
33567: printf("Leak of %d blocks found in xmlRegexpExec",
33568: xmlMemBlocks() - mem_base);
33569: test_ret++;
33570: printf(" %d", n_comp);
33571: printf(" %d", n_content);
33572: printf("\n");
33573: }
33574: }
33575: }
33576: function_tests++;
33577: #endif
33578:
33579: return(test_ret);
33580: }
33581:
33582:
33583: static int
33584: test_xmlRegexpIsDeterminist(void) {
33585: int test_ret = 0;
33586:
33587: #if defined(LIBXML_REGEXP_ENABLED)
33588: int mem_base;
33589: int ret_val;
33590: xmlRegexpPtr comp; /* the compiled regular expression */
33591: int n_comp;
33592:
33593: for (n_comp = 0;n_comp < gen_nb_xmlRegexpPtr;n_comp++) {
33594: mem_base = xmlMemBlocks();
33595: comp = gen_xmlRegexpPtr(n_comp, 0);
33596:
33597: ret_val = xmlRegexpIsDeterminist(comp);
33598: desret_int(ret_val);
33599: call_tests++;
33600: des_xmlRegexpPtr(n_comp, comp, 0);
33601: xmlResetLastError();
33602: if (mem_base != xmlMemBlocks()) {
33603: printf("Leak of %d blocks found in xmlRegexpIsDeterminist",
33604: xmlMemBlocks() - mem_base);
33605: test_ret++;
33606: printf(" %d", n_comp);
33607: printf("\n");
33608: }
33609: }
33610: function_tests++;
33611: #endif
33612:
33613: return(test_ret);
33614: }
33615:
33616:
33617: static int
33618: test_xmlRegexpPrint(void) {
33619: int test_ret = 0;
33620:
33621: #if defined(LIBXML_REGEXP_ENABLED)
33622: int mem_base;
33623: FILE * output; /* the file for the output debug */
33624: int n_output;
33625: xmlRegexpPtr regexp; /* the compiled regexp */
33626: int n_regexp;
33627:
33628: for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
33629: for (n_regexp = 0;n_regexp < gen_nb_xmlRegexpPtr;n_regexp++) {
33630: mem_base = xmlMemBlocks();
33631: output = gen_FILE_ptr(n_output, 0);
33632: regexp = gen_xmlRegexpPtr(n_regexp, 1);
33633:
33634: xmlRegexpPrint(output, regexp);
33635: call_tests++;
33636: des_FILE_ptr(n_output, output, 0);
33637: des_xmlRegexpPtr(n_regexp, regexp, 1);
33638: xmlResetLastError();
33639: if (mem_base != xmlMemBlocks()) {
33640: printf("Leak of %d blocks found in xmlRegexpPrint",
33641: xmlMemBlocks() - mem_base);
33642: test_ret++;
33643: printf(" %d", n_output);
33644: printf(" %d", n_regexp);
33645: printf("\n");
33646: }
33647: }
33648: }
33649: function_tests++;
33650: #endif
33651:
33652: return(test_ret);
33653: }
33654:
33655: static int
33656: test_xmlregexp(void) {
33657: int test_ret = 0;
33658:
33659: if (quiet == 0) printf("Testing xmlregexp : 16 of 30 functions ...\n");
33660: test_ret += test_xmlExpCtxtNbCons();
33661: test_ret += test_xmlExpCtxtNbNodes();
33662: test_ret += test_xmlExpDump();
33663: test_ret += test_xmlExpExpDerive();
33664: test_ret += test_xmlExpGetLanguage();
33665: test_ret += test_xmlExpGetStart();
33666: test_ret += test_xmlExpIsNillable();
33667: test_ret += test_xmlExpMaxToken();
33668: test_ret += test_xmlExpNewAtom();
33669: test_ret += test_xmlExpNewCtxt();
33670: test_ret += test_xmlExpNewOr();
33671: test_ret += test_xmlExpNewRange();
33672: test_ret += test_xmlExpNewSeq();
33673: test_ret += test_xmlExpParse();
33674: test_ret += test_xmlExpRef();
33675: test_ret += test_xmlExpStringDerive();
33676: test_ret += test_xmlExpSubsume();
33677: test_ret += test_xmlRegExecErrInfo();
33678: test_ret += test_xmlRegExecNextValues();
33679: test_ret += test_xmlRegExecPushString();
33680: test_ret += test_xmlRegExecPushString2();
33681: test_ret += test_xmlRegNewExecCtxt();
33682: test_ret += test_xmlRegexpCompile();
33683: test_ret += test_xmlRegexpExec();
33684: test_ret += test_xmlRegexpIsDeterminist();
33685: test_ret += test_xmlRegexpPrint();
33686:
33687: if (test_ret != 0)
33688: printf("Module xmlregexp: %d errors\n", test_ret);
33689: return(test_ret);
33690: }
33691: #ifdef LIBXML_OUTPUT_ENABLED
33692:
33693: #define gen_nb_xmlSaveCtxtPtr 1
33694: static xmlSaveCtxtPtr gen_xmlSaveCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33695: return(NULL);
33696: }
33697: static void des_xmlSaveCtxtPtr(int no ATTRIBUTE_UNUSED, xmlSaveCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33698: }
33699: #endif
33700:
33701:
33702: static int
33703: test_xmlSaveClose(void) {
33704: int test_ret = 0;
33705:
33706: #if defined(LIBXML_OUTPUT_ENABLED)
33707: int mem_base;
33708: int ret_val;
33709: xmlSaveCtxtPtr ctxt; /* a document saving context */
33710: int n_ctxt;
33711:
33712: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSaveCtxtPtr;n_ctxt++) {
33713: mem_base = xmlMemBlocks();
33714: ctxt = gen_xmlSaveCtxtPtr(n_ctxt, 0);
33715:
33716: ret_val = xmlSaveClose(ctxt);
33717: desret_int(ret_val);
33718: call_tests++;
33719: des_xmlSaveCtxtPtr(n_ctxt, ctxt, 0);
33720: xmlResetLastError();
33721: if (mem_base != xmlMemBlocks()) {
33722: printf("Leak of %d blocks found in xmlSaveClose",
33723: xmlMemBlocks() - mem_base);
33724: test_ret++;
33725: printf(" %d", n_ctxt);
33726: printf("\n");
33727: }
33728: }
33729: function_tests++;
33730: #endif
33731:
33732: return(test_ret);
33733: }
33734:
33735:
33736: static int
33737: test_xmlSaveDoc(void) {
33738: int test_ret = 0;
33739:
33740: #if defined(LIBXML_OUTPUT_ENABLED)
33741: int mem_base;
33742: long ret_val;
33743: xmlSaveCtxtPtr ctxt; /* a document saving context */
33744: int n_ctxt;
33745: xmlDocPtr doc; /* a document */
33746: int n_doc;
33747:
33748: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSaveCtxtPtr;n_ctxt++) {
33749: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
33750: mem_base = xmlMemBlocks();
33751: ctxt = gen_xmlSaveCtxtPtr(n_ctxt, 0);
33752: doc = gen_xmlDocPtr(n_doc, 1);
33753:
33754: ret_val = xmlSaveDoc(ctxt, doc);
33755: desret_long(ret_val);
33756: call_tests++;
33757: des_xmlSaveCtxtPtr(n_ctxt, ctxt, 0);
33758: des_xmlDocPtr(n_doc, doc, 1);
33759: xmlResetLastError();
33760: if (mem_base != xmlMemBlocks()) {
33761: printf("Leak of %d blocks found in xmlSaveDoc",
33762: xmlMemBlocks() - mem_base);
33763: test_ret++;
33764: printf(" %d", n_ctxt);
33765: printf(" %d", n_doc);
33766: printf("\n");
33767: }
33768: }
33769: }
33770: function_tests++;
33771: #endif
33772:
33773: return(test_ret);
33774: }
33775:
33776:
33777: static int
33778: test_xmlSaveFlush(void) {
33779: int test_ret = 0;
33780:
33781: #if defined(LIBXML_OUTPUT_ENABLED)
33782: int mem_base;
33783: int ret_val;
33784: xmlSaveCtxtPtr ctxt; /* a document saving context */
33785: int n_ctxt;
33786:
33787: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSaveCtxtPtr;n_ctxt++) {
33788: mem_base = xmlMemBlocks();
33789: ctxt = gen_xmlSaveCtxtPtr(n_ctxt, 0);
33790:
33791: ret_val = xmlSaveFlush(ctxt);
33792: desret_int(ret_val);
33793: call_tests++;
33794: des_xmlSaveCtxtPtr(n_ctxt, ctxt, 0);
33795: xmlResetLastError();
33796: if (mem_base != xmlMemBlocks()) {
33797: printf("Leak of %d blocks found in xmlSaveFlush",
33798: xmlMemBlocks() - mem_base);
33799: test_ret++;
33800: printf(" %d", n_ctxt);
33801: printf("\n");
33802: }
33803: }
33804: function_tests++;
33805: #endif
33806:
33807: return(test_ret);
33808: }
33809:
33810:
33811: static int
33812: test_xmlSaveSetAttrEscape(void) {
33813: int test_ret = 0;
33814:
33815:
33816: /* missing type support */
33817: return(test_ret);
33818: }
33819:
33820:
33821: static int
33822: test_xmlSaveSetEscape(void) {
33823: int test_ret = 0;
33824:
33825:
33826: /* missing type support */
33827: return(test_ret);
33828: }
33829:
33830:
33831: static int
33832: test_xmlSaveToBuffer(void) {
33833: int test_ret = 0;
33834:
33835:
33836: /* missing type support */
33837: return(test_ret);
33838: }
33839:
33840:
33841: static int
33842: test_xmlSaveToFd(void) {
33843: int test_ret = 0;
33844:
33845:
33846: /* missing type support */
33847: return(test_ret);
33848: }
33849:
33850:
33851: static int
33852: test_xmlSaveToFilename(void) {
33853: int test_ret = 0;
33854:
33855:
33856: /* missing type support */
33857: return(test_ret);
33858: }
33859:
33860:
33861: static int
33862: test_xmlSaveTree(void) {
33863: int test_ret = 0;
33864:
33865: #if defined(LIBXML_OUTPUT_ENABLED)
33866: int mem_base;
33867: long ret_val;
33868: xmlSaveCtxtPtr ctxt; /* a document saving context */
33869: int n_ctxt;
33870: xmlNodePtr node; /* the top node of the subtree to save */
33871: int n_node;
33872:
33873: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSaveCtxtPtr;n_ctxt++) {
33874: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
33875: mem_base = xmlMemBlocks();
33876: ctxt = gen_xmlSaveCtxtPtr(n_ctxt, 0);
33877: node = gen_xmlNodePtr(n_node, 1);
33878:
33879: ret_val = xmlSaveTree(ctxt, node);
33880: desret_long(ret_val);
33881: call_tests++;
33882: des_xmlSaveCtxtPtr(n_ctxt, ctxt, 0);
33883: des_xmlNodePtr(n_node, node, 1);
33884: xmlResetLastError();
33885: if (mem_base != xmlMemBlocks()) {
33886: printf("Leak of %d blocks found in xmlSaveTree",
33887: xmlMemBlocks() - mem_base);
33888: test_ret++;
33889: printf(" %d", n_ctxt);
33890: printf(" %d", n_node);
33891: printf("\n");
33892: }
33893: }
33894: }
33895: function_tests++;
33896: #endif
33897:
33898: return(test_ret);
33899: }
33900:
33901: static int
33902: test_xmlsave(void) {
33903: int test_ret = 0;
33904:
33905: if (quiet == 0) printf("Testing xmlsave : 4 of 10 functions ...\n");
33906: test_ret += test_xmlSaveClose();
33907: test_ret += test_xmlSaveDoc();
33908: test_ret += test_xmlSaveFlush();
33909: test_ret += test_xmlSaveSetAttrEscape();
33910: test_ret += test_xmlSaveSetEscape();
33911: test_ret += test_xmlSaveToBuffer();
33912: test_ret += test_xmlSaveToFd();
33913: test_ret += test_xmlSaveToFilename();
33914: test_ret += test_xmlSaveTree();
33915:
33916: if (test_ret != 0)
33917: printf("Module xmlsave: %d errors\n", test_ret);
33918: return(test_ret);
33919: }
33920:
33921: static int
33922: test_xmlSchemaDump(void) {
33923: int test_ret = 0;
33924:
33925: #if defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
33926: int mem_base;
33927: FILE * output; /* the file output */
33928: int n_output;
33929: xmlSchemaPtr schema; /* a schema structure */
33930: int n_schema;
33931:
33932: for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
33933: for (n_schema = 0;n_schema < gen_nb_xmlSchemaPtr;n_schema++) {
33934: mem_base = xmlMemBlocks();
33935: output = gen_FILE_ptr(n_output, 0);
33936: schema = gen_xmlSchemaPtr(n_schema, 1);
33937:
33938: xmlSchemaDump(output, schema);
33939: call_tests++;
33940: des_FILE_ptr(n_output, output, 0);
33941: des_xmlSchemaPtr(n_schema, schema, 1);
33942: xmlResetLastError();
33943: if (mem_base != xmlMemBlocks()) {
33944: printf("Leak of %d blocks found in xmlSchemaDump",
33945: xmlMemBlocks() - mem_base);
33946: test_ret++;
33947: printf(" %d", n_output);
33948: printf(" %d", n_schema);
33949: printf("\n");
33950: }
33951: }
33952: }
33953: function_tests++;
33954: #endif
33955:
33956: return(test_ret);
33957: }
33958:
33959: #ifdef LIBXML_SCHEMAS_ENABLED
33960:
33961: #define gen_nb_xmlSchemaParserCtxtPtr 1
33962: static xmlSchemaParserCtxtPtr gen_xmlSchemaParserCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33963: return(NULL);
33964: }
33965: static void des_xmlSchemaParserCtxtPtr(int no ATTRIBUTE_UNUSED, xmlSchemaParserCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33966: }
33967: #endif
33968:
33969: #ifdef LIBXML_SCHEMAS_ENABLED
33970:
33971: #define gen_nb_xmlSchemaValidityErrorFunc_ptr 1
33972: static xmlSchemaValidityErrorFunc * gen_xmlSchemaValidityErrorFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33973: return(NULL);
33974: }
33975: static void des_xmlSchemaValidityErrorFunc_ptr(int no ATTRIBUTE_UNUSED, xmlSchemaValidityErrorFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33976: }
33977: #endif
33978:
33979: #ifdef LIBXML_SCHEMAS_ENABLED
33980:
33981: #define gen_nb_xmlSchemaValidityWarningFunc_ptr 1
33982: static xmlSchemaValidityWarningFunc * gen_xmlSchemaValidityWarningFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33983: return(NULL);
33984: }
33985: static void des_xmlSchemaValidityWarningFunc_ptr(int no ATTRIBUTE_UNUSED, xmlSchemaValidityWarningFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33986: }
33987: #endif
33988:
33989:
33990: static int
33991: test_xmlSchemaGetParserErrors(void) {
33992: int test_ret = 0;
33993:
33994: #if defined(LIBXML_SCHEMAS_ENABLED)
33995: int mem_base;
33996: int ret_val;
33997: xmlSchemaParserCtxtPtr ctxt; /* a XMl-Schema parser context */
33998: int n_ctxt;
33999: xmlSchemaValidityErrorFunc * err; /* the error callback result */
34000: int n_err;
34001: xmlSchemaValidityWarningFunc * warn; /* the warning callback result */
34002: int n_warn;
34003: void ** ctx; /* contextual data for the callbacks result */
34004: int n_ctx;
34005:
34006: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaParserCtxtPtr;n_ctxt++) {
34007: for (n_err = 0;n_err < gen_nb_xmlSchemaValidityErrorFunc_ptr;n_err++) {
34008: for (n_warn = 0;n_warn < gen_nb_xmlSchemaValidityWarningFunc_ptr;n_warn++) {
34009: for (n_ctx = 0;n_ctx < gen_nb_void_ptr_ptr;n_ctx++) {
34010: mem_base = xmlMemBlocks();
34011: ctxt = gen_xmlSchemaParserCtxtPtr(n_ctxt, 0);
34012: err = gen_xmlSchemaValidityErrorFunc_ptr(n_err, 1);
34013: warn = gen_xmlSchemaValidityWarningFunc_ptr(n_warn, 2);
34014: ctx = gen_void_ptr_ptr(n_ctx, 3);
34015:
34016: ret_val = xmlSchemaGetParserErrors(ctxt, err, warn, ctx);
34017: desret_int(ret_val);
34018: call_tests++;
34019: des_xmlSchemaParserCtxtPtr(n_ctxt, ctxt, 0);
34020: des_xmlSchemaValidityErrorFunc_ptr(n_err, err, 1);
34021: des_xmlSchemaValidityWarningFunc_ptr(n_warn, warn, 2);
34022: des_void_ptr_ptr(n_ctx, ctx, 3);
34023: xmlResetLastError();
34024: if (mem_base != xmlMemBlocks()) {
34025: printf("Leak of %d blocks found in xmlSchemaGetParserErrors",
34026: xmlMemBlocks() - mem_base);
34027: test_ret++;
34028: printf(" %d", n_ctxt);
34029: printf(" %d", n_err);
34030: printf(" %d", n_warn);
34031: printf(" %d", n_ctx);
34032: printf("\n");
34033: }
34034: }
34035: }
34036: }
34037: }
34038: function_tests++;
34039: #endif
34040:
34041: return(test_ret);
34042: }
34043:
34044:
34045: static int
34046: test_xmlSchemaGetValidErrors(void) {
34047: int test_ret = 0;
34048:
34049: #if defined(LIBXML_SCHEMAS_ENABLED)
34050: int mem_base;
34051: int ret_val;
34052: xmlSchemaValidCtxtPtr ctxt; /* a XML-Schema validation context */
34053: int n_ctxt;
34054: xmlSchemaValidityErrorFunc * err; /* the error function result */
34055: int n_err;
34056: xmlSchemaValidityWarningFunc * warn; /* the warning function result */
34057: int n_warn;
34058: void ** ctx; /* the functions context result */
34059: int n_ctx;
34060:
34061: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34062: for (n_err = 0;n_err < gen_nb_xmlSchemaValidityErrorFunc_ptr;n_err++) {
34063: for (n_warn = 0;n_warn < gen_nb_xmlSchemaValidityWarningFunc_ptr;n_warn++) {
34064: for (n_ctx = 0;n_ctx < gen_nb_void_ptr_ptr;n_ctx++) {
34065: mem_base = xmlMemBlocks();
34066: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34067: err = gen_xmlSchemaValidityErrorFunc_ptr(n_err, 1);
34068: warn = gen_xmlSchemaValidityWarningFunc_ptr(n_warn, 2);
34069: ctx = gen_void_ptr_ptr(n_ctx, 3);
34070:
34071: ret_val = xmlSchemaGetValidErrors(ctxt, err, warn, ctx);
34072: desret_int(ret_val);
34073: call_tests++;
34074: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34075: des_xmlSchemaValidityErrorFunc_ptr(n_err, err, 1);
34076: des_xmlSchemaValidityWarningFunc_ptr(n_warn, warn, 2);
34077: des_void_ptr_ptr(n_ctx, ctx, 3);
34078: xmlResetLastError();
34079: if (mem_base != xmlMemBlocks()) {
34080: printf("Leak of %d blocks found in xmlSchemaGetValidErrors",
34081: xmlMemBlocks() - mem_base);
34082: test_ret++;
34083: printf(" %d", n_ctxt);
34084: printf(" %d", n_err);
34085: printf(" %d", n_warn);
34086: printf(" %d", n_ctx);
34087: printf("\n");
34088: }
34089: }
34090: }
34091: }
34092: }
34093: function_tests++;
34094: #endif
34095:
34096: return(test_ret);
34097: }
34098:
34099:
34100: static int
34101: test_xmlSchemaIsValid(void) {
34102: int test_ret = 0;
34103:
34104: #if defined(LIBXML_SCHEMAS_ENABLED)
34105: int mem_base;
34106: int ret_val;
34107: xmlSchemaValidCtxtPtr ctxt; /* the schema validation context */
34108: int n_ctxt;
34109:
34110: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34111: mem_base = xmlMemBlocks();
34112: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34113:
34114: ret_val = xmlSchemaIsValid(ctxt);
34115: desret_int(ret_val);
34116: call_tests++;
34117: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34118: xmlResetLastError();
34119: if (mem_base != xmlMemBlocks()) {
34120: printf("Leak of %d blocks found in xmlSchemaIsValid",
34121: xmlMemBlocks() - mem_base);
34122: test_ret++;
34123: printf(" %d", n_ctxt);
34124: printf("\n");
34125: }
34126: }
34127: function_tests++;
34128: #endif
34129:
34130: return(test_ret);
34131: }
34132:
34133:
34134: static int
34135: test_xmlSchemaNewDocParserCtxt(void) {
34136: int test_ret = 0;
34137:
34138: #if defined(LIBXML_SCHEMAS_ENABLED)
34139: int mem_base;
34140: xmlSchemaParserCtxtPtr ret_val;
34141: xmlDocPtr doc; /* a preparsed document tree */
34142: int n_doc;
34143:
34144: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
34145: mem_base = xmlMemBlocks();
34146: doc = gen_xmlDocPtr(n_doc, 0);
34147:
34148: ret_val = xmlSchemaNewDocParserCtxt(doc);
34149: desret_xmlSchemaParserCtxtPtr(ret_val);
34150: call_tests++;
34151: des_xmlDocPtr(n_doc, doc, 0);
34152: xmlResetLastError();
34153: if (mem_base != xmlMemBlocks()) {
34154: printf("Leak of %d blocks found in xmlSchemaNewDocParserCtxt",
34155: xmlMemBlocks() - mem_base);
34156: test_ret++;
34157: printf(" %d", n_doc);
34158: printf("\n");
34159: }
34160: }
34161: function_tests++;
34162: #endif
34163:
34164: return(test_ret);
34165: }
34166:
34167:
34168: static int
34169: test_xmlSchemaNewMemParserCtxt(void) {
34170: int test_ret = 0;
34171:
34172: #if defined(LIBXML_SCHEMAS_ENABLED)
34173: int mem_base;
34174: xmlSchemaParserCtxtPtr ret_val;
34175: char * buffer; /* a pointer to a char array containing the schemas */
34176: int n_buffer;
34177: int size; /* the size of the array */
34178: int n_size;
34179:
34180: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
34181: for (n_size = 0;n_size < gen_nb_int;n_size++) {
34182: mem_base = xmlMemBlocks();
34183: buffer = gen_const_char_ptr(n_buffer, 0);
34184: size = gen_int(n_size, 1);
34185:
34186: ret_val = xmlSchemaNewMemParserCtxt((const char *)buffer, size);
34187: desret_xmlSchemaParserCtxtPtr(ret_val);
34188: call_tests++;
34189: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
34190: des_int(n_size, size, 1);
34191: xmlResetLastError();
34192: if (mem_base != xmlMemBlocks()) {
34193: printf("Leak of %d blocks found in xmlSchemaNewMemParserCtxt",
34194: xmlMemBlocks() - mem_base);
34195: test_ret++;
34196: printf(" %d", n_buffer);
34197: printf(" %d", n_size);
34198: printf("\n");
34199: }
34200: }
34201: }
34202: function_tests++;
34203: #endif
34204:
34205: return(test_ret);
34206: }
34207:
34208:
34209: static int
34210: test_xmlSchemaNewParserCtxt(void) {
34211: int test_ret = 0;
34212:
34213: #if defined(LIBXML_SCHEMAS_ENABLED)
34214: int mem_base;
34215: xmlSchemaParserCtxtPtr ret_val;
34216: char * URL; /* the location of the schema */
34217: int n_URL;
34218:
34219: for (n_URL = 0;n_URL < gen_nb_const_char_ptr;n_URL++) {
34220: mem_base = xmlMemBlocks();
34221: URL = gen_const_char_ptr(n_URL, 0);
34222:
34223: ret_val = xmlSchemaNewParserCtxt((const char *)URL);
34224: desret_xmlSchemaParserCtxtPtr(ret_val);
34225: call_tests++;
34226: des_const_char_ptr(n_URL, (const char *)URL, 0);
34227: xmlResetLastError();
34228: if (mem_base != xmlMemBlocks()) {
34229: printf("Leak of %d blocks found in xmlSchemaNewParserCtxt",
34230: xmlMemBlocks() - mem_base);
34231: test_ret++;
34232: printf(" %d", n_URL);
34233: printf("\n");
34234: }
34235: }
34236: function_tests++;
34237: #endif
34238:
34239: return(test_ret);
34240: }
34241:
34242:
34243: static int
34244: test_xmlSchemaNewValidCtxt(void) {
34245: int test_ret = 0;
34246:
34247:
34248: /* missing type support */
34249: return(test_ret);
34250: }
34251:
34252:
34253: static int
34254: test_xmlSchemaParse(void) {
34255: int test_ret = 0;
34256:
34257:
34258: /* missing type support */
34259: return(test_ret);
34260: }
34261:
34262: #ifdef LIBXML_SCHEMAS_ENABLED
34263:
34264: #define gen_nb_xmlSAXHandlerPtr_ptr 1
34265: static xmlSAXHandlerPtr * gen_xmlSAXHandlerPtr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34266: return(NULL);
34267: }
34268: static void des_xmlSAXHandlerPtr_ptr(int no ATTRIBUTE_UNUSED, xmlSAXHandlerPtr * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34269: }
34270: #endif
34271:
34272:
34273: static int
34274: test_xmlSchemaSAXPlug(void) {
34275: int test_ret = 0;
34276:
34277:
34278: /* missing type support */
34279: return(test_ret);
34280: }
34281:
34282: #ifdef LIBXML_SCHEMAS_ENABLED
34283:
34284: #define gen_nb_xmlSchemaSAXPlugPtr 1
34285: static xmlSchemaSAXPlugPtr gen_xmlSchemaSAXPlugPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34286: return(NULL);
34287: }
34288: static void des_xmlSchemaSAXPlugPtr(int no ATTRIBUTE_UNUSED, xmlSchemaSAXPlugPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34289: }
34290: #endif
34291:
34292:
34293: static int
34294: test_xmlSchemaSAXUnplug(void) {
34295: int test_ret = 0;
34296:
34297: #if defined(LIBXML_SCHEMAS_ENABLED)
34298: int mem_base;
34299: int ret_val;
34300: xmlSchemaSAXPlugPtr plug; /* a data structure returned by xmlSchemaSAXPlug */
34301: int n_plug;
34302:
34303: for (n_plug = 0;n_plug < gen_nb_xmlSchemaSAXPlugPtr;n_plug++) {
34304: mem_base = xmlMemBlocks();
34305: plug = gen_xmlSchemaSAXPlugPtr(n_plug, 0);
34306:
34307: ret_val = xmlSchemaSAXUnplug(plug);
34308: desret_int(ret_val);
34309: call_tests++;
34310: des_xmlSchemaSAXPlugPtr(n_plug, plug, 0);
34311: xmlResetLastError();
34312: if (mem_base != xmlMemBlocks()) {
34313: printf("Leak of %d blocks found in xmlSchemaSAXUnplug",
34314: xmlMemBlocks() - mem_base);
34315: test_ret++;
34316: printf(" %d", n_plug);
34317: printf("\n");
34318: }
34319: }
34320: function_tests++;
34321: #endif
34322:
34323: return(test_ret);
34324: }
34325:
34326:
34327: static int
34328: test_xmlSchemaSetParserErrors(void) {
34329: int test_ret = 0;
34330:
34331:
34332: /* missing type support */
34333: return(test_ret);
34334: }
34335:
34336:
34337: static int
34338: test_xmlSchemaSetParserStructuredErrors(void) {
34339: int test_ret = 0;
34340:
34341:
34342: /* missing type support */
34343: return(test_ret);
34344: }
34345:
34346:
34347: static int
34348: test_xmlSchemaSetValidErrors(void) {
34349: int test_ret = 0;
34350:
34351:
34352: /* missing type support */
34353: return(test_ret);
34354: }
34355:
34356:
34357: static int
34358: test_xmlSchemaSetValidOptions(void) {
34359: int test_ret = 0;
34360:
34361: #if defined(LIBXML_SCHEMAS_ENABLED)
34362: int mem_base;
34363: int ret_val;
34364: xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
34365: int n_ctxt;
34366: int options; /* a combination of xmlSchemaValidOption */
34367: int n_options;
34368:
34369: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34370: for (n_options = 0;n_options < gen_nb_int;n_options++) {
34371: mem_base = xmlMemBlocks();
34372: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34373: options = gen_int(n_options, 1);
34374:
34375: ret_val = xmlSchemaSetValidOptions(ctxt, options);
34376: desret_int(ret_val);
34377: call_tests++;
34378: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34379: des_int(n_options, options, 1);
34380: xmlResetLastError();
34381: if (mem_base != xmlMemBlocks()) {
34382: printf("Leak of %d blocks found in xmlSchemaSetValidOptions",
34383: xmlMemBlocks() - mem_base);
34384: test_ret++;
34385: printf(" %d", n_ctxt);
34386: printf(" %d", n_options);
34387: printf("\n");
34388: }
34389: }
34390: }
34391: function_tests++;
34392: #endif
34393:
34394: return(test_ret);
34395: }
34396:
34397:
34398: static int
34399: test_xmlSchemaSetValidStructuredErrors(void) {
34400: int test_ret = 0;
34401:
34402:
34403: /* missing type support */
34404: return(test_ret);
34405: }
34406:
34407:
34408: static int
34409: test_xmlSchemaValidCtxtGetOptions(void) {
34410: int test_ret = 0;
34411:
34412: #if defined(LIBXML_SCHEMAS_ENABLED)
34413: int mem_base;
34414: int ret_val;
34415: xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
34416: int n_ctxt;
34417:
34418: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34419: mem_base = xmlMemBlocks();
34420: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34421:
34422: ret_val = xmlSchemaValidCtxtGetOptions(ctxt);
34423: desret_int(ret_val);
34424: call_tests++;
34425: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34426: xmlResetLastError();
34427: if (mem_base != xmlMemBlocks()) {
34428: printf("Leak of %d blocks found in xmlSchemaValidCtxtGetOptions",
34429: xmlMemBlocks() - mem_base);
34430: test_ret++;
34431: printf(" %d", n_ctxt);
34432: printf("\n");
34433: }
34434: }
34435: function_tests++;
34436: #endif
34437:
34438: return(test_ret);
34439: }
34440:
34441:
34442: static int
34443: test_xmlSchemaValidCtxtGetParserCtxt(void) {
34444: int test_ret = 0;
34445:
34446: #if defined(LIBXML_SCHEMAS_ENABLED)
34447: int mem_base;
34448: xmlParserCtxtPtr ret_val;
34449: xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
34450: int n_ctxt;
34451:
34452: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34453: mem_base = xmlMemBlocks();
34454: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34455:
34456: ret_val = xmlSchemaValidCtxtGetParserCtxt(ctxt);
34457: desret_xmlParserCtxtPtr(ret_val);
34458: call_tests++;
34459: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34460: xmlResetLastError();
34461: if (mem_base != xmlMemBlocks()) {
34462: printf("Leak of %d blocks found in xmlSchemaValidCtxtGetParserCtxt",
34463: xmlMemBlocks() - mem_base);
34464: test_ret++;
34465: printf(" %d", n_ctxt);
34466: printf("\n");
34467: }
34468: }
34469: function_tests++;
34470: #endif
34471:
34472: return(test_ret);
34473: }
34474:
34475:
34476: static int
34477: test_xmlSchemaValidateDoc(void) {
34478: int test_ret = 0;
34479:
34480: #if defined(LIBXML_SCHEMAS_ENABLED)
34481: int mem_base;
34482: int ret_val;
34483: xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
34484: int n_ctxt;
34485: xmlDocPtr doc; /* a parsed document tree */
34486: int n_doc;
34487:
34488: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34489: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
34490: mem_base = xmlMemBlocks();
34491: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34492: doc = gen_xmlDocPtr(n_doc, 1);
34493:
34494: ret_val = xmlSchemaValidateDoc(ctxt, doc);
34495: desret_int(ret_val);
34496: call_tests++;
34497: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34498: des_xmlDocPtr(n_doc, doc, 1);
34499: xmlResetLastError();
34500: if (mem_base != xmlMemBlocks()) {
34501: printf("Leak of %d blocks found in xmlSchemaValidateDoc",
34502: xmlMemBlocks() - mem_base);
34503: test_ret++;
34504: printf(" %d", n_ctxt);
34505: printf(" %d", n_doc);
34506: printf("\n");
34507: }
34508: }
34509: }
34510: function_tests++;
34511: #endif
34512:
34513: return(test_ret);
34514: }
34515:
34516:
34517: static int
34518: test_xmlSchemaValidateFile(void) {
34519: int test_ret = 0;
34520:
34521: #if defined(LIBXML_SCHEMAS_ENABLED)
34522: int mem_base;
34523: int ret_val;
34524: xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
34525: int n_ctxt;
34526: const char * filename; /* the URI of the instance */
34527: int n_filename;
34528: int options; /* a future set of options, currently unused */
34529: int n_options;
34530:
34531: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34532: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
34533: for (n_options = 0;n_options < gen_nb_int;n_options++) {
34534: mem_base = xmlMemBlocks();
34535: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34536: filename = gen_filepath(n_filename, 1);
34537: options = gen_int(n_options, 2);
34538:
34539: ret_val = xmlSchemaValidateFile(ctxt, filename, options);
34540: desret_int(ret_val);
34541: call_tests++;
34542: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34543: des_filepath(n_filename, filename, 1);
34544: des_int(n_options, options, 2);
34545: xmlResetLastError();
34546: if (mem_base != xmlMemBlocks()) {
34547: printf("Leak of %d blocks found in xmlSchemaValidateFile",
34548: xmlMemBlocks() - mem_base);
34549: test_ret++;
34550: printf(" %d", n_ctxt);
34551: printf(" %d", n_filename);
34552: printf(" %d", n_options);
34553: printf("\n");
34554: }
34555: }
34556: }
34557: }
34558: function_tests++;
34559: #endif
34560:
34561: return(test_ret);
34562: }
34563:
34564:
34565: static int
34566: test_xmlSchemaValidateOneElement(void) {
34567: int test_ret = 0;
34568:
34569: #if defined(LIBXML_SCHEMAS_ENABLED)
34570: int mem_base;
34571: int ret_val;
34572: xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
34573: int n_ctxt;
34574: xmlNodePtr elem; /* an element node */
34575: int n_elem;
34576:
34577: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34578: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
34579: mem_base = xmlMemBlocks();
34580: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34581: elem = gen_xmlNodePtr(n_elem, 1);
34582:
34583: ret_val = xmlSchemaValidateOneElement(ctxt, elem);
34584: desret_int(ret_val);
34585: call_tests++;
34586: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34587: des_xmlNodePtr(n_elem, elem, 1);
34588: xmlResetLastError();
34589: if (mem_base != xmlMemBlocks()) {
34590: printf("Leak of %d blocks found in xmlSchemaValidateOneElement",
34591: xmlMemBlocks() - mem_base);
34592: test_ret++;
34593: printf(" %d", n_ctxt);
34594: printf(" %d", n_elem);
34595: printf("\n");
34596: }
34597: }
34598: }
34599: function_tests++;
34600: #endif
34601:
34602: return(test_ret);
34603: }
34604:
34605:
34606: static int
34607: test_xmlSchemaValidateStream(void) {
34608: int test_ret = 0;
34609:
34610: #if defined(LIBXML_SCHEMAS_ENABLED)
34611: int mem_base;
34612: int ret_val;
34613: xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
34614: int n_ctxt;
34615: xmlParserInputBufferPtr input; /* the input to use for reading the data */
34616: int n_input;
34617: xmlCharEncoding enc; /* an optional encoding information */
34618: int n_enc;
34619: xmlSAXHandlerPtr sax; /* a SAX handler for the resulting events */
34620: int n_sax;
34621: void * user_data; /* the context to provide to the SAX handler. */
34622: int n_user_data;
34623:
34624: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34625: for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) {
34626: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
34627: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
34628: for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
34629: mem_base = xmlMemBlocks();
34630: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34631: input = gen_xmlParserInputBufferPtr(n_input, 1);
34632: enc = gen_xmlCharEncoding(n_enc, 2);
34633: sax = gen_xmlSAXHandlerPtr(n_sax, 3);
34634: user_data = gen_userdata(n_user_data, 4);
34635:
34636: ret_val = xmlSchemaValidateStream(ctxt, input, enc, sax, user_data);
34637: desret_int(ret_val);
34638: call_tests++;
34639: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34640: des_xmlParserInputBufferPtr(n_input, input, 1);
34641: des_xmlCharEncoding(n_enc, enc, 2);
34642: des_xmlSAXHandlerPtr(n_sax, sax, 3);
34643: des_userdata(n_user_data, user_data, 4);
34644: xmlResetLastError();
34645: if (mem_base != xmlMemBlocks()) {
34646: printf("Leak of %d blocks found in xmlSchemaValidateStream",
34647: xmlMemBlocks() - mem_base);
34648: test_ret++;
34649: printf(" %d", n_ctxt);
34650: printf(" %d", n_input);
34651: printf(" %d", n_enc);
34652: printf(" %d", n_sax);
34653: printf(" %d", n_user_data);
34654: printf("\n");
34655: }
34656: }
34657: }
34658: }
34659: }
34660: }
34661: function_tests++;
34662: #endif
34663:
34664: return(test_ret);
34665: }
34666:
34667: static int
34668: test_xmlschemas(void) {
34669: int test_ret = 0;
34670:
34671: if (quiet == 0) printf("Testing xmlschemas : 15 of 25 functions ...\n");
34672: test_ret += test_xmlSchemaDump();
34673: test_ret += test_xmlSchemaGetParserErrors();
34674: test_ret += test_xmlSchemaGetValidErrors();
34675: test_ret += test_xmlSchemaIsValid();
34676: test_ret += test_xmlSchemaNewDocParserCtxt();
34677: test_ret += test_xmlSchemaNewMemParserCtxt();
34678: test_ret += test_xmlSchemaNewParserCtxt();
34679: test_ret += test_xmlSchemaNewValidCtxt();
34680: test_ret += test_xmlSchemaParse();
34681: test_ret += test_xmlSchemaSAXPlug();
34682: test_ret += test_xmlSchemaSAXUnplug();
34683: test_ret += test_xmlSchemaSetParserErrors();
34684: test_ret += test_xmlSchemaSetParserStructuredErrors();
34685: test_ret += test_xmlSchemaSetValidErrors();
34686: test_ret += test_xmlSchemaSetValidOptions();
34687: test_ret += test_xmlSchemaSetValidStructuredErrors();
34688: test_ret += test_xmlSchemaValidCtxtGetOptions();
34689: test_ret += test_xmlSchemaValidCtxtGetParserCtxt();
34690: test_ret += test_xmlSchemaValidateDoc();
34691: test_ret += test_xmlSchemaValidateFile();
34692: test_ret += test_xmlSchemaValidateOneElement();
34693: test_ret += test_xmlSchemaValidateStream();
34694:
34695: if (test_ret != 0)
34696: printf("Module xmlschemas: %d errors\n", test_ret);
34697: return(test_ret);
34698: }
34699: #ifdef LIBXML_SCHEMAS_ENABLED
34700:
34701: #define gen_nb_xmlSchemaFacetPtr 1
34702: static xmlSchemaFacetPtr gen_xmlSchemaFacetPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34703: return(NULL);
34704: }
34705: static void des_xmlSchemaFacetPtr(int no ATTRIBUTE_UNUSED, xmlSchemaFacetPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34706: }
34707: #endif
34708:
34709: #ifdef LIBXML_SCHEMAS_ENABLED
34710:
34711: #define gen_nb_xmlSchemaTypePtr 1
34712: static xmlSchemaTypePtr gen_xmlSchemaTypePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34713: return(NULL);
34714: }
34715: static void des_xmlSchemaTypePtr(int no ATTRIBUTE_UNUSED, xmlSchemaTypePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34716: }
34717: #endif
34718:
34719:
34720: static int
34721: test_xmlSchemaCheckFacet(void) {
34722: int test_ret = 0;
34723:
34724: #if defined(LIBXML_SCHEMAS_ENABLED)
34725: int mem_base;
34726: int ret_val;
34727: xmlSchemaFacetPtr facet; /* the facet */
34728: int n_facet;
34729: xmlSchemaTypePtr typeDecl; /* the schema type definition */
34730: int n_typeDecl;
34731: xmlSchemaParserCtxtPtr pctxt; /* the schema parser context or NULL */
34732: int n_pctxt;
34733: xmlChar * name; /* the optional name of the type */
34734: int n_name;
34735:
34736: for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
34737: for (n_typeDecl = 0;n_typeDecl < gen_nb_xmlSchemaTypePtr;n_typeDecl++) {
34738: for (n_pctxt = 0;n_pctxt < gen_nb_xmlSchemaParserCtxtPtr;n_pctxt++) {
34739: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
34740: mem_base = xmlMemBlocks();
34741: facet = gen_xmlSchemaFacetPtr(n_facet, 0);
34742: typeDecl = gen_xmlSchemaTypePtr(n_typeDecl, 1);
34743: pctxt = gen_xmlSchemaParserCtxtPtr(n_pctxt, 2);
34744: name = gen_const_xmlChar_ptr(n_name, 3);
34745:
34746: ret_val = xmlSchemaCheckFacet(facet, typeDecl, pctxt, (const xmlChar *)name);
34747: desret_int(ret_val);
34748: call_tests++;
34749: des_xmlSchemaFacetPtr(n_facet, facet, 0);
34750: des_xmlSchemaTypePtr(n_typeDecl, typeDecl, 1);
34751: des_xmlSchemaParserCtxtPtr(n_pctxt, pctxt, 2);
34752: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 3);
34753: xmlResetLastError();
34754: if (mem_base != xmlMemBlocks()) {
34755: printf("Leak of %d blocks found in xmlSchemaCheckFacet",
34756: xmlMemBlocks() - mem_base);
34757: test_ret++;
34758: printf(" %d", n_facet);
34759: printf(" %d", n_typeDecl);
34760: printf(" %d", n_pctxt);
34761: printf(" %d", n_name);
34762: printf("\n");
34763: }
34764: }
34765: }
34766: }
34767: }
34768: function_tests++;
34769: #endif
34770:
34771: return(test_ret);
34772: }
34773:
34774:
34775: static int
34776: test_xmlSchemaCleanupTypes(void) {
34777: int test_ret = 0;
34778:
34779: #if defined(LIBXML_SCHEMAS_ENABLED)
34780:
34781:
34782: xmlSchemaCleanupTypes();
34783: call_tests++;
34784: xmlResetLastError();
34785: function_tests++;
34786: #endif
34787:
34788: return(test_ret);
34789: }
34790:
34791:
34792: static int
34793: test_xmlSchemaCollapseString(void) {
34794: int test_ret = 0;
34795:
34796: #if defined(LIBXML_SCHEMAS_ENABLED)
34797: int mem_base;
34798: xmlChar * ret_val;
34799: xmlChar * value; /* a value */
34800: int n_value;
34801:
34802: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
34803: mem_base = xmlMemBlocks();
34804: value = gen_const_xmlChar_ptr(n_value, 0);
34805:
34806: ret_val = xmlSchemaCollapseString((const xmlChar *)value);
34807: desret_xmlChar_ptr(ret_val);
34808: call_tests++;
34809: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
34810: xmlResetLastError();
34811: if (mem_base != xmlMemBlocks()) {
34812: printf("Leak of %d blocks found in xmlSchemaCollapseString",
34813: xmlMemBlocks() - mem_base);
34814: test_ret++;
34815: printf(" %d", n_value);
34816: printf("\n");
34817: }
34818: }
34819: function_tests++;
34820: #endif
34821:
34822: return(test_ret);
34823: }
34824:
34825: #ifdef LIBXML_SCHEMAS_ENABLED
34826:
34827: #define gen_nb_xmlSchemaValPtr 1
34828: static xmlSchemaValPtr gen_xmlSchemaValPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34829: return(NULL);
34830: }
34831: static void des_xmlSchemaValPtr(int no ATTRIBUTE_UNUSED, xmlSchemaValPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34832: }
34833: #endif
34834:
34835:
34836: static int
34837: test_xmlSchemaCompareValues(void) {
34838: int test_ret = 0;
34839:
34840: #if defined(LIBXML_SCHEMAS_ENABLED)
34841: int mem_base;
34842: int ret_val;
34843: xmlSchemaValPtr x; /* a first value */
34844: int n_x;
34845: xmlSchemaValPtr y; /* a second value */
34846: int n_y;
34847:
34848: for (n_x = 0;n_x < gen_nb_xmlSchemaValPtr;n_x++) {
34849: for (n_y = 0;n_y < gen_nb_xmlSchemaValPtr;n_y++) {
34850: mem_base = xmlMemBlocks();
34851: x = gen_xmlSchemaValPtr(n_x, 0);
34852: y = gen_xmlSchemaValPtr(n_y, 1);
34853:
34854: ret_val = xmlSchemaCompareValues(x, y);
34855: desret_int(ret_val);
34856: call_tests++;
34857: des_xmlSchemaValPtr(n_x, x, 0);
34858: des_xmlSchemaValPtr(n_y, y, 1);
34859: xmlResetLastError();
34860: if (mem_base != xmlMemBlocks()) {
34861: printf("Leak of %d blocks found in xmlSchemaCompareValues",
34862: xmlMemBlocks() - mem_base);
34863: test_ret++;
34864: printf(" %d", n_x);
34865: printf(" %d", n_y);
34866: printf("\n");
34867: }
34868: }
34869: }
34870: function_tests++;
34871: #endif
34872:
34873: return(test_ret);
34874: }
34875:
34876:
34877: static int
34878: test_xmlSchemaCompareValuesWhtsp(void) {
34879: int test_ret = 0;
34880:
34881: #if defined(LIBXML_SCHEMAS_ENABLED)
34882: int mem_base;
34883: int ret_val;
34884: xmlSchemaValPtr x; /* a first value */
34885: int n_x;
34886: xmlSchemaWhitespaceValueType xws; /* the whitespace value of x */
34887: int n_xws;
34888: xmlSchemaValPtr y; /* a second value */
34889: int n_y;
34890: xmlSchemaWhitespaceValueType yws; /* the whitespace value of y */
34891: int n_yws;
34892:
34893: for (n_x = 0;n_x < gen_nb_xmlSchemaValPtr;n_x++) {
34894: for (n_xws = 0;n_xws < gen_nb_xmlSchemaWhitespaceValueType;n_xws++) {
34895: for (n_y = 0;n_y < gen_nb_xmlSchemaValPtr;n_y++) {
34896: for (n_yws = 0;n_yws < gen_nb_xmlSchemaWhitespaceValueType;n_yws++) {
34897: mem_base = xmlMemBlocks();
34898: x = gen_xmlSchemaValPtr(n_x, 0);
34899: xws = gen_xmlSchemaWhitespaceValueType(n_xws, 1);
34900: y = gen_xmlSchemaValPtr(n_y, 2);
34901: yws = gen_xmlSchemaWhitespaceValueType(n_yws, 3);
34902:
34903: ret_val = xmlSchemaCompareValuesWhtsp(x, xws, y, yws);
34904: desret_int(ret_val);
34905: call_tests++;
34906: des_xmlSchemaValPtr(n_x, x, 0);
34907: des_xmlSchemaWhitespaceValueType(n_xws, xws, 1);
34908: des_xmlSchemaValPtr(n_y, y, 2);
34909: des_xmlSchemaWhitespaceValueType(n_yws, yws, 3);
34910: xmlResetLastError();
34911: if (mem_base != xmlMemBlocks()) {
34912: printf("Leak of %d blocks found in xmlSchemaCompareValuesWhtsp",
34913: xmlMemBlocks() - mem_base);
34914: test_ret++;
34915: printf(" %d", n_x);
34916: printf(" %d", n_xws);
34917: printf(" %d", n_y);
34918: printf(" %d", n_yws);
34919: printf("\n");
34920: }
34921: }
34922: }
34923: }
34924: }
34925: function_tests++;
34926: #endif
34927:
34928: return(test_ret);
34929: }
34930:
34931:
34932: static int
34933: test_xmlSchemaCopyValue(void) {
34934: int test_ret = 0;
34935:
34936:
34937: /* missing type support */
34938: return(test_ret);
34939: }
34940:
34941:
34942: static int
34943: test_xmlSchemaGetBuiltInListSimpleTypeItemType(void) {
34944: int test_ret = 0;
34945:
34946: #if defined(LIBXML_SCHEMAS_ENABLED)
34947: int mem_base;
34948: xmlSchemaTypePtr ret_val;
34949: xmlSchemaTypePtr type; /* the built-in simple type. */
34950: int n_type;
34951:
34952: for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
34953: mem_base = xmlMemBlocks();
34954: type = gen_xmlSchemaTypePtr(n_type, 0);
34955:
34956: ret_val = xmlSchemaGetBuiltInListSimpleTypeItemType(type);
34957: desret_xmlSchemaTypePtr(ret_val);
34958: call_tests++;
34959: des_xmlSchemaTypePtr(n_type, type, 0);
34960: xmlResetLastError();
34961: if (mem_base != xmlMemBlocks()) {
34962: printf("Leak of %d blocks found in xmlSchemaGetBuiltInListSimpleTypeItemType",
34963: xmlMemBlocks() - mem_base);
34964: test_ret++;
34965: printf(" %d", n_type);
34966: printf("\n");
34967: }
34968: }
34969: function_tests++;
34970: #endif
34971:
34972: return(test_ret);
34973: }
34974:
34975:
34976: static int
34977: test_xmlSchemaGetBuiltInType(void) {
34978: int test_ret = 0;
34979:
34980: #if defined(LIBXML_SCHEMAS_ENABLED)
34981: xmlSchemaTypePtr ret_val;
34982: xmlSchemaValType type; /* the type of the built in type */
34983: int n_type;
34984:
34985: for (n_type = 0;n_type < gen_nb_xmlSchemaValType;n_type++) {
34986: type = gen_xmlSchemaValType(n_type, 0);
34987:
34988: ret_val = xmlSchemaGetBuiltInType(type);
34989: desret_xmlSchemaTypePtr(ret_val);
34990: call_tests++;
34991: des_xmlSchemaValType(n_type, type, 0);
34992: xmlResetLastError();
34993: }
34994: function_tests++;
34995: #endif
34996:
34997: return(test_ret);
34998: }
34999:
35000:
35001: static int
35002: test_xmlSchemaGetCanonValue(void) {
35003: int test_ret = 0;
35004:
35005: #if defined(LIBXML_SCHEMAS_ENABLED)
35006: int mem_base;
35007: int ret_val;
35008: xmlSchemaValPtr val; /* the precomputed value */
35009: int n_val;
35010: xmlChar ** retValue; /* the returned value */
35011: int n_retValue;
35012:
35013: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
35014: for (n_retValue = 0;n_retValue < gen_nb_const_xmlChar_ptr_ptr;n_retValue++) {
35015: mem_base = xmlMemBlocks();
35016: val = gen_xmlSchemaValPtr(n_val, 0);
35017: retValue = gen_const_xmlChar_ptr_ptr(n_retValue, 1);
35018:
35019: ret_val = xmlSchemaGetCanonValue(val, (const xmlChar **)retValue);
35020: desret_int(ret_val);
35021: call_tests++;
35022: des_xmlSchemaValPtr(n_val, val, 0);
35023: des_const_xmlChar_ptr_ptr(n_retValue, (const xmlChar **)retValue, 1);
35024: xmlResetLastError();
35025: if (mem_base != xmlMemBlocks()) {
35026: printf("Leak of %d blocks found in xmlSchemaGetCanonValue",
35027: xmlMemBlocks() - mem_base);
35028: test_ret++;
35029: printf(" %d", n_val);
35030: printf(" %d", n_retValue);
35031: printf("\n");
35032: }
35033: }
35034: }
35035: function_tests++;
35036: #endif
35037:
35038: return(test_ret);
35039: }
35040:
35041:
35042: static int
35043: test_xmlSchemaGetCanonValueWhtsp(void) {
35044: int test_ret = 0;
35045:
35046: #if defined(LIBXML_SCHEMAS_ENABLED)
35047: int mem_base;
35048: int ret_val;
35049: xmlSchemaValPtr val; /* the precomputed value */
35050: int n_val;
35051: xmlChar ** retValue; /* the returned value */
35052: int n_retValue;
35053: xmlSchemaWhitespaceValueType ws; /* the whitespace type of the value */
35054: int n_ws;
35055:
35056: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
35057: for (n_retValue = 0;n_retValue < gen_nb_const_xmlChar_ptr_ptr;n_retValue++) {
35058: for (n_ws = 0;n_ws < gen_nb_xmlSchemaWhitespaceValueType;n_ws++) {
35059: mem_base = xmlMemBlocks();
35060: val = gen_xmlSchemaValPtr(n_val, 0);
35061: retValue = gen_const_xmlChar_ptr_ptr(n_retValue, 1);
35062: ws = gen_xmlSchemaWhitespaceValueType(n_ws, 2);
35063:
35064: ret_val = xmlSchemaGetCanonValueWhtsp(val, (const xmlChar **)retValue, ws);
35065: desret_int(ret_val);
35066: call_tests++;
35067: des_xmlSchemaValPtr(n_val, val, 0);
35068: des_const_xmlChar_ptr_ptr(n_retValue, (const xmlChar **)retValue, 1);
35069: des_xmlSchemaWhitespaceValueType(n_ws, ws, 2);
35070: xmlResetLastError();
35071: if (mem_base != xmlMemBlocks()) {
35072: printf("Leak of %d blocks found in xmlSchemaGetCanonValueWhtsp",
35073: xmlMemBlocks() - mem_base);
35074: test_ret++;
35075: printf(" %d", n_val);
35076: printf(" %d", n_retValue);
35077: printf(" %d", n_ws);
35078: printf("\n");
35079: }
35080: }
35081: }
35082: }
35083: function_tests++;
35084: #endif
35085:
35086: return(test_ret);
35087: }
35088:
35089:
35090: static int
35091: test_xmlSchemaGetFacetValueAsULong(void) {
35092: int test_ret = 0;
35093:
35094: #if defined(LIBXML_SCHEMAS_ENABLED)
35095: int mem_base;
35096: unsigned long ret_val;
35097: xmlSchemaFacetPtr facet; /* an schemas type facet */
35098: int n_facet;
35099:
35100: for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
35101: mem_base = xmlMemBlocks();
35102: facet = gen_xmlSchemaFacetPtr(n_facet, 0);
35103:
35104: ret_val = xmlSchemaGetFacetValueAsULong(facet);
35105: desret_unsigned_long(ret_val);
35106: call_tests++;
35107: des_xmlSchemaFacetPtr(n_facet, facet, 0);
35108: xmlResetLastError();
35109: if (mem_base != xmlMemBlocks()) {
35110: printf("Leak of %d blocks found in xmlSchemaGetFacetValueAsULong",
35111: xmlMemBlocks() - mem_base);
35112: test_ret++;
35113: printf(" %d", n_facet);
35114: printf("\n");
35115: }
35116: }
35117: function_tests++;
35118: #endif
35119:
35120: return(test_ret);
35121: }
35122:
35123:
35124: static int
35125: test_xmlSchemaGetPredefinedType(void) {
35126: int test_ret = 0;
35127:
35128: #if defined(LIBXML_SCHEMAS_ENABLED)
35129: int mem_base;
35130: xmlSchemaTypePtr ret_val;
35131: xmlChar * name; /* the type name */
35132: int n_name;
35133: xmlChar * ns; /* the URI of the namespace usually "http://www.w3.org/2001/XMLSchema" */
35134: int n_ns;
35135:
35136: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
35137: for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) {
35138: mem_base = xmlMemBlocks();
35139: name = gen_const_xmlChar_ptr(n_name, 0);
35140: ns = gen_const_xmlChar_ptr(n_ns, 1);
35141:
35142: ret_val = xmlSchemaGetPredefinedType((const xmlChar *)name, (const xmlChar *)ns);
35143: desret_xmlSchemaTypePtr(ret_val);
35144: call_tests++;
35145: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
35146: des_const_xmlChar_ptr(n_ns, (const xmlChar *)ns, 1);
35147: xmlResetLastError();
35148: if (mem_base != xmlMemBlocks()) {
35149: printf("Leak of %d blocks found in xmlSchemaGetPredefinedType",
35150: xmlMemBlocks() - mem_base);
35151: test_ret++;
35152: printf(" %d", n_name);
35153: printf(" %d", n_ns);
35154: printf("\n");
35155: }
35156: }
35157: }
35158: function_tests++;
35159: #endif
35160:
35161: return(test_ret);
35162: }
35163:
35164:
35165: static int
35166: test_xmlSchemaGetValType(void) {
35167: int test_ret = 0;
35168:
35169: #if defined(LIBXML_SCHEMAS_ENABLED)
35170: int mem_base;
35171: xmlSchemaValType ret_val;
35172: xmlSchemaValPtr val; /* a schemas value */
35173: int n_val;
35174:
35175: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
35176: mem_base = xmlMemBlocks();
35177: val = gen_xmlSchemaValPtr(n_val, 0);
35178:
35179: ret_val = xmlSchemaGetValType(val);
35180: desret_xmlSchemaValType(ret_val);
35181: call_tests++;
35182: des_xmlSchemaValPtr(n_val, val, 0);
35183: xmlResetLastError();
35184: if (mem_base != xmlMemBlocks()) {
35185: printf("Leak of %d blocks found in xmlSchemaGetValType",
35186: xmlMemBlocks() - mem_base);
35187: test_ret++;
35188: printf(" %d", n_val);
35189: printf("\n");
35190: }
35191: }
35192: function_tests++;
35193: #endif
35194:
35195: return(test_ret);
35196: }
35197:
35198:
35199: static int
35200: test_xmlSchemaInitTypes(void) {
35201: int test_ret = 0;
35202:
35203: #if defined(LIBXML_SCHEMAS_ENABLED)
35204:
35205:
35206: xmlSchemaInitTypes();
35207: call_tests++;
35208: xmlResetLastError();
35209: function_tests++;
35210: #endif
35211:
35212: return(test_ret);
35213: }
35214:
35215:
35216: static int
35217: test_xmlSchemaIsBuiltInTypeFacet(void) {
35218: int test_ret = 0;
35219:
35220: #if defined(LIBXML_SCHEMAS_ENABLED)
35221: int mem_base;
35222: int ret_val;
35223: xmlSchemaTypePtr type; /* the built-in type */
35224: int n_type;
35225: int facetType; /* the facet type */
35226: int n_facetType;
35227:
35228: for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
35229: for (n_facetType = 0;n_facetType < gen_nb_int;n_facetType++) {
35230: mem_base = xmlMemBlocks();
35231: type = gen_xmlSchemaTypePtr(n_type, 0);
35232: facetType = gen_int(n_facetType, 1);
35233:
35234: ret_val = xmlSchemaIsBuiltInTypeFacet(type, facetType);
35235: desret_int(ret_val);
35236: call_tests++;
35237: des_xmlSchemaTypePtr(n_type, type, 0);
35238: des_int(n_facetType, facetType, 1);
35239: xmlResetLastError();
35240: if (mem_base != xmlMemBlocks()) {
35241: printf("Leak of %d blocks found in xmlSchemaIsBuiltInTypeFacet",
35242: xmlMemBlocks() - mem_base);
35243: test_ret++;
35244: printf(" %d", n_type);
35245: printf(" %d", n_facetType);
35246: printf("\n");
35247: }
35248: }
35249: }
35250: function_tests++;
35251: #endif
35252:
35253: return(test_ret);
35254: }
35255:
35256:
35257: static int
35258: test_xmlSchemaNewFacet(void) {
35259: int test_ret = 0;
35260:
35261:
35262: /* missing type support */
35263: return(test_ret);
35264: }
35265:
35266:
35267: static int
35268: test_xmlSchemaNewNOTATIONValue(void) {
35269: int test_ret = 0;
35270:
35271:
35272: /* missing type support */
35273: return(test_ret);
35274: }
35275:
35276:
35277: static int
35278: test_xmlSchemaNewQNameValue(void) {
35279: int test_ret = 0;
35280:
35281:
35282: /* missing type support */
35283: return(test_ret);
35284: }
35285:
35286:
35287: static int
35288: test_xmlSchemaNewStringValue(void) {
35289: int test_ret = 0;
35290:
35291:
35292: /* missing type support */
35293: return(test_ret);
35294: }
35295:
35296: #ifdef LIBXML_SCHEMAS_ENABLED
35297:
35298: #define gen_nb_xmlSchemaValPtr_ptr 1
35299: static xmlSchemaValPtr * gen_xmlSchemaValPtr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
35300: return(NULL);
35301: }
35302: static void des_xmlSchemaValPtr_ptr(int no ATTRIBUTE_UNUSED, xmlSchemaValPtr * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
35303: }
35304: #endif
35305:
35306:
35307: static int
35308: test_xmlSchemaValPredefTypeNode(void) {
35309: int test_ret = 0;
35310:
35311: #if defined(LIBXML_SCHEMAS_ENABLED)
35312: int mem_base;
35313: int ret_val;
35314: xmlSchemaTypePtr type; /* the predefined type */
35315: int n_type;
35316: xmlChar * value; /* the value to check */
35317: int n_value;
35318: xmlSchemaValPtr * val; /* the return computed value */
35319: int n_val;
35320: xmlNodePtr node; /* the node containing the value */
35321: int n_node;
35322:
35323: for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
35324: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35325: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr_ptr;n_val++) {
35326: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
35327: mem_base = xmlMemBlocks();
35328: type = gen_xmlSchemaTypePtr(n_type, 0);
35329: value = gen_const_xmlChar_ptr(n_value, 1);
35330: val = gen_xmlSchemaValPtr_ptr(n_val, 2);
35331: node = gen_xmlNodePtr(n_node, 3);
35332:
35333: ret_val = xmlSchemaValPredefTypeNode(type, (const xmlChar *)value, val, node);
35334: desret_int(ret_val);
35335: call_tests++;
35336: des_xmlSchemaTypePtr(n_type, type, 0);
35337: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
35338: des_xmlSchemaValPtr_ptr(n_val, val, 2);
35339: des_xmlNodePtr(n_node, node, 3);
35340: xmlResetLastError();
35341: if (mem_base != xmlMemBlocks()) {
35342: printf("Leak of %d blocks found in xmlSchemaValPredefTypeNode",
35343: xmlMemBlocks() - mem_base);
35344: test_ret++;
35345: printf(" %d", n_type);
35346: printf(" %d", n_value);
35347: printf(" %d", n_val);
35348: printf(" %d", n_node);
35349: printf("\n");
35350: }
35351: }
35352: }
35353: }
35354: }
35355: function_tests++;
35356: #endif
35357:
35358: return(test_ret);
35359: }
35360:
35361:
35362: static int
35363: test_xmlSchemaValPredefTypeNodeNoNorm(void) {
35364: int test_ret = 0;
35365:
35366: #if defined(LIBXML_SCHEMAS_ENABLED)
35367: int mem_base;
35368: int ret_val;
35369: xmlSchemaTypePtr type; /* the predefined type */
35370: int n_type;
35371: xmlChar * value; /* the value to check */
35372: int n_value;
35373: xmlSchemaValPtr * val; /* the return computed value */
35374: int n_val;
35375: xmlNodePtr node; /* the node containing the value */
35376: int n_node;
35377:
35378: for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
35379: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35380: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr_ptr;n_val++) {
35381: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
35382: mem_base = xmlMemBlocks();
35383: type = gen_xmlSchemaTypePtr(n_type, 0);
35384: value = gen_const_xmlChar_ptr(n_value, 1);
35385: val = gen_xmlSchemaValPtr_ptr(n_val, 2);
35386: node = gen_xmlNodePtr(n_node, 3);
35387:
35388: ret_val = xmlSchemaValPredefTypeNodeNoNorm(type, (const xmlChar *)value, val, node);
35389: desret_int(ret_val);
35390: call_tests++;
35391: des_xmlSchemaTypePtr(n_type, type, 0);
35392: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
35393: des_xmlSchemaValPtr_ptr(n_val, val, 2);
35394: des_xmlNodePtr(n_node, node, 3);
35395: xmlResetLastError();
35396: if (mem_base != xmlMemBlocks()) {
35397: printf("Leak of %d blocks found in xmlSchemaValPredefTypeNodeNoNorm",
35398: xmlMemBlocks() - mem_base);
35399: test_ret++;
35400: printf(" %d", n_type);
35401: printf(" %d", n_value);
35402: printf(" %d", n_val);
35403: printf(" %d", n_node);
35404: printf("\n");
35405: }
35406: }
35407: }
35408: }
35409: }
35410: function_tests++;
35411: #endif
35412:
35413: return(test_ret);
35414: }
35415:
35416:
35417: static int
35418: test_xmlSchemaValidateFacet(void) {
35419: int test_ret = 0;
35420:
35421: #if defined(LIBXML_SCHEMAS_ENABLED)
35422: int mem_base;
35423: int ret_val;
35424: xmlSchemaTypePtr base; /* the base type */
35425: int n_base;
35426: xmlSchemaFacetPtr facet; /* the facet to check */
35427: int n_facet;
35428: xmlChar * value; /* the lexical repr of the value to validate */
35429: int n_value;
35430: xmlSchemaValPtr val; /* the precomputed value */
35431: int n_val;
35432:
35433: for (n_base = 0;n_base < gen_nb_xmlSchemaTypePtr;n_base++) {
35434: for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
35435: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35436: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
35437: mem_base = xmlMemBlocks();
35438: base = gen_xmlSchemaTypePtr(n_base, 0);
35439: facet = gen_xmlSchemaFacetPtr(n_facet, 1);
35440: value = gen_const_xmlChar_ptr(n_value, 2);
35441: val = gen_xmlSchemaValPtr(n_val, 3);
35442:
35443: ret_val = xmlSchemaValidateFacet(base, facet, (const xmlChar *)value, val);
35444: desret_int(ret_val);
35445: call_tests++;
35446: des_xmlSchemaTypePtr(n_base, base, 0);
35447: des_xmlSchemaFacetPtr(n_facet, facet, 1);
35448: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2);
35449: des_xmlSchemaValPtr(n_val, val, 3);
35450: xmlResetLastError();
35451: if (mem_base != xmlMemBlocks()) {
35452: printf("Leak of %d blocks found in xmlSchemaValidateFacet",
35453: xmlMemBlocks() - mem_base);
35454: test_ret++;
35455: printf(" %d", n_base);
35456: printf(" %d", n_facet);
35457: printf(" %d", n_value);
35458: printf(" %d", n_val);
35459: printf("\n");
35460: }
35461: }
35462: }
35463: }
35464: }
35465: function_tests++;
35466: #endif
35467:
35468: return(test_ret);
35469: }
35470:
35471:
35472: static int
35473: test_xmlSchemaValidateFacetWhtsp(void) {
35474: int test_ret = 0;
35475:
35476: #if defined(LIBXML_SCHEMAS_ENABLED)
35477: int mem_base;
35478: int ret_val;
35479: xmlSchemaFacetPtr facet; /* the facet to check */
35480: int n_facet;
35481: xmlSchemaWhitespaceValueType fws; /* the whitespace type of the facet's value */
35482: int n_fws;
35483: xmlSchemaValType valType; /* the built-in type of the value */
35484: int n_valType;
35485: xmlChar * value; /* the lexical (or normalized for pattern) repr of the value to validate */
35486: int n_value;
35487: xmlSchemaValPtr val; /* the precomputed value */
35488: int n_val;
35489: xmlSchemaWhitespaceValueType ws; /* the whitespace type of the value */
35490: int n_ws;
35491:
35492: for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
35493: for (n_fws = 0;n_fws < gen_nb_xmlSchemaWhitespaceValueType;n_fws++) {
35494: for (n_valType = 0;n_valType < gen_nb_xmlSchemaValType;n_valType++) {
35495: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35496: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
35497: for (n_ws = 0;n_ws < gen_nb_xmlSchemaWhitespaceValueType;n_ws++) {
35498: mem_base = xmlMemBlocks();
35499: facet = gen_xmlSchemaFacetPtr(n_facet, 0);
35500: fws = gen_xmlSchemaWhitespaceValueType(n_fws, 1);
35501: valType = gen_xmlSchemaValType(n_valType, 2);
35502: value = gen_const_xmlChar_ptr(n_value, 3);
35503: val = gen_xmlSchemaValPtr(n_val, 4);
35504: ws = gen_xmlSchemaWhitespaceValueType(n_ws, 5);
35505:
35506: ret_val = xmlSchemaValidateFacetWhtsp(facet, fws, valType, (const xmlChar *)value, val, ws);
35507: desret_int(ret_val);
35508: call_tests++;
35509: des_xmlSchemaFacetPtr(n_facet, facet, 0);
35510: des_xmlSchemaWhitespaceValueType(n_fws, fws, 1);
35511: des_xmlSchemaValType(n_valType, valType, 2);
35512: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 3);
35513: des_xmlSchemaValPtr(n_val, val, 4);
35514: des_xmlSchemaWhitespaceValueType(n_ws, ws, 5);
35515: xmlResetLastError();
35516: if (mem_base != xmlMemBlocks()) {
35517: printf("Leak of %d blocks found in xmlSchemaValidateFacetWhtsp",
35518: xmlMemBlocks() - mem_base);
35519: test_ret++;
35520: printf(" %d", n_facet);
35521: printf(" %d", n_fws);
35522: printf(" %d", n_valType);
35523: printf(" %d", n_value);
35524: printf(" %d", n_val);
35525: printf(" %d", n_ws);
35526: printf("\n");
35527: }
35528: }
35529: }
35530: }
35531: }
35532: }
35533: }
35534: function_tests++;
35535: #endif
35536:
35537: return(test_ret);
35538: }
35539:
35540:
35541: static int
35542: test_xmlSchemaValidateLengthFacet(void) {
35543: int test_ret = 0;
35544:
35545: #if defined(LIBXML_SCHEMAS_ENABLED)
35546: int mem_base;
35547: int ret_val;
35548: xmlSchemaTypePtr type; /* the built-in type */
35549: int n_type;
35550: xmlSchemaFacetPtr facet; /* the facet to check */
35551: int n_facet;
35552: xmlChar * value; /* the lexical repr. of the value to be validated */
35553: int n_value;
35554: xmlSchemaValPtr val; /* the precomputed value */
35555: int n_val;
35556: unsigned long * length; /* the actual length of the value */
35557: int n_length;
35558:
35559: for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
35560: for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
35561: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35562: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
35563: for (n_length = 0;n_length < gen_nb_unsigned_long_ptr;n_length++) {
35564: mem_base = xmlMemBlocks();
35565: type = gen_xmlSchemaTypePtr(n_type, 0);
35566: facet = gen_xmlSchemaFacetPtr(n_facet, 1);
35567: value = gen_const_xmlChar_ptr(n_value, 2);
35568: val = gen_xmlSchemaValPtr(n_val, 3);
35569: length = gen_unsigned_long_ptr(n_length, 4);
35570:
35571: ret_val = xmlSchemaValidateLengthFacet(type, facet, (const xmlChar *)value, val, length);
35572: desret_int(ret_val);
35573: call_tests++;
35574: des_xmlSchemaTypePtr(n_type, type, 0);
35575: des_xmlSchemaFacetPtr(n_facet, facet, 1);
35576: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2);
35577: des_xmlSchemaValPtr(n_val, val, 3);
35578: des_unsigned_long_ptr(n_length, length, 4);
35579: xmlResetLastError();
35580: if (mem_base != xmlMemBlocks()) {
35581: printf("Leak of %d blocks found in xmlSchemaValidateLengthFacet",
35582: xmlMemBlocks() - mem_base);
35583: test_ret++;
35584: printf(" %d", n_type);
35585: printf(" %d", n_facet);
35586: printf(" %d", n_value);
35587: printf(" %d", n_val);
35588: printf(" %d", n_length);
35589: printf("\n");
35590: }
35591: }
35592: }
35593: }
35594: }
35595: }
35596: function_tests++;
35597: #endif
35598:
35599: return(test_ret);
35600: }
35601:
35602:
35603: static int
35604: test_xmlSchemaValidateLengthFacetWhtsp(void) {
35605: int test_ret = 0;
35606:
35607: #if defined(LIBXML_SCHEMAS_ENABLED)
35608: int mem_base;
35609: int ret_val;
35610: xmlSchemaFacetPtr facet; /* the facet to check */
35611: int n_facet;
35612: xmlSchemaValType valType; /* the built-in type */
35613: int n_valType;
35614: xmlChar * value; /* the lexical repr. of the value to be validated */
35615: int n_value;
35616: xmlSchemaValPtr val; /* the precomputed value */
35617: int n_val;
35618: unsigned long * length; /* the actual length of the value */
35619: int n_length;
35620: xmlSchemaWhitespaceValueType ws; /* the whitespace type of the value */
35621: int n_ws;
35622:
35623: for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
35624: for (n_valType = 0;n_valType < gen_nb_xmlSchemaValType;n_valType++) {
35625: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35626: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
35627: for (n_length = 0;n_length < gen_nb_unsigned_long_ptr;n_length++) {
35628: for (n_ws = 0;n_ws < gen_nb_xmlSchemaWhitespaceValueType;n_ws++) {
35629: mem_base = xmlMemBlocks();
35630: facet = gen_xmlSchemaFacetPtr(n_facet, 0);
35631: valType = gen_xmlSchemaValType(n_valType, 1);
35632: value = gen_const_xmlChar_ptr(n_value, 2);
35633: val = gen_xmlSchemaValPtr(n_val, 3);
35634: length = gen_unsigned_long_ptr(n_length, 4);
35635: ws = gen_xmlSchemaWhitespaceValueType(n_ws, 5);
35636:
35637: ret_val = xmlSchemaValidateLengthFacetWhtsp(facet, valType, (const xmlChar *)value, val, length, ws);
35638: desret_int(ret_val);
35639: call_tests++;
35640: des_xmlSchemaFacetPtr(n_facet, facet, 0);
35641: des_xmlSchemaValType(n_valType, valType, 1);
35642: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2);
35643: des_xmlSchemaValPtr(n_val, val, 3);
35644: des_unsigned_long_ptr(n_length, length, 4);
35645: des_xmlSchemaWhitespaceValueType(n_ws, ws, 5);
35646: xmlResetLastError();
35647: if (mem_base != xmlMemBlocks()) {
35648: printf("Leak of %d blocks found in xmlSchemaValidateLengthFacetWhtsp",
35649: xmlMemBlocks() - mem_base);
35650: test_ret++;
35651: printf(" %d", n_facet);
35652: printf(" %d", n_valType);
35653: printf(" %d", n_value);
35654: printf(" %d", n_val);
35655: printf(" %d", n_length);
35656: printf(" %d", n_ws);
35657: printf("\n");
35658: }
35659: }
35660: }
35661: }
35662: }
35663: }
35664: }
35665: function_tests++;
35666: #endif
35667:
35668: return(test_ret);
35669: }
35670:
35671:
35672: static int
35673: test_xmlSchemaValidateListSimpleTypeFacet(void) {
35674: int test_ret = 0;
35675:
35676: #if defined(LIBXML_SCHEMAS_ENABLED)
35677: int mem_base;
35678: int ret_val;
35679: xmlSchemaFacetPtr facet; /* the facet to check */
35680: int n_facet;
35681: xmlChar * value; /* the lexical repr of the value to validate */
35682: int n_value;
35683: unsigned long actualLen; /* the number of list items */
35684: int n_actualLen;
35685: unsigned long * expectedLen; /* the resulting expected number of list items */
35686: int n_expectedLen;
35687:
35688: for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
35689: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35690: for (n_actualLen = 0;n_actualLen < gen_nb_unsigned_long;n_actualLen++) {
35691: for (n_expectedLen = 0;n_expectedLen < gen_nb_unsigned_long_ptr;n_expectedLen++) {
35692: mem_base = xmlMemBlocks();
35693: facet = gen_xmlSchemaFacetPtr(n_facet, 0);
35694: value = gen_const_xmlChar_ptr(n_value, 1);
35695: actualLen = gen_unsigned_long(n_actualLen, 2);
35696: expectedLen = gen_unsigned_long_ptr(n_expectedLen, 3);
35697:
35698: ret_val = xmlSchemaValidateListSimpleTypeFacet(facet, (const xmlChar *)value, actualLen, expectedLen);
35699: desret_int(ret_val);
35700: call_tests++;
35701: des_xmlSchemaFacetPtr(n_facet, facet, 0);
35702: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
35703: des_unsigned_long(n_actualLen, actualLen, 2);
35704: des_unsigned_long_ptr(n_expectedLen, expectedLen, 3);
35705: xmlResetLastError();
35706: if (mem_base != xmlMemBlocks()) {
35707: printf("Leak of %d blocks found in xmlSchemaValidateListSimpleTypeFacet",
35708: xmlMemBlocks() - mem_base);
35709: test_ret++;
35710: printf(" %d", n_facet);
35711: printf(" %d", n_value);
35712: printf(" %d", n_actualLen);
35713: printf(" %d", n_expectedLen);
35714: printf("\n");
35715: }
35716: }
35717: }
35718: }
35719: }
35720: function_tests++;
35721: #endif
35722:
35723: return(test_ret);
35724: }
35725:
35726:
35727: static int
35728: test_xmlSchemaValidatePredefinedType(void) {
35729: int test_ret = 0;
35730:
35731: #if defined(LIBXML_SCHEMAS_ENABLED)
35732: int mem_base;
35733: int ret_val;
35734: xmlSchemaTypePtr type; /* the predefined type */
35735: int n_type;
35736: xmlChar * value; /* the value to check */
35737: int n_value;
35738: xmlSchemaValPtr * val; /* the return computed value */
35739: int n_val;
35740:
35741: for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
35742: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35743: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr_ptr;n_val++) {
35744: mem_base = xmlMemBlocks();
35745: type = gen_xmlSchemaTypePtr(n_type, 0);
35746: value = gen_const_xmlChar_ptr(n_value, 1);
35747: val = gen_xmlSchemaValPtr_ptr(n_val, 2);
35748:
35749: ret_val = xmlSchemaValidatePredefinedType(type, (const xmlChar *)value, val);
35750: desret_int(ret_val);
35751: call_tests++;
35752: des_xmlSchemaTypePtr(n_type, type, 0);
35753: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
35754: des_xmlSchemaValPtr_ptr(n_val, val, 2);
35755: xmlResetLastError();
35756: if (mem_base != xmlMemBlocks()) {
35757: printf("Leak of %d blocks found in xmlSchemaValidatePredefinedType",
35758: xmlMemBlocks() - mem_base);
35759: test_ret++;
35760: printf(" %d", n_type);
35761: printf(" %d", n_value);
35762: printf(" %d", n_val);
35763: printf("\n");
35764: }
35765: }
35766: }
35767: }
35768: function_tests++;
35769: #endif
35770:
35771: return(test_ret);
35772: }
35773:
35774:
35775: static int
35776: test_xmlSchemaValueAppend(void) {
35777: int test_ret = 0;
35778:
35779: #if defined(LIBXML_SCHEMAS_ENABLED)
35780: int mem_base;
35781: int ret_val;
35782: xmlSchemaValPtr prev; /* the value */
35783: int n_prev;
35784: xmlSchemaValPtr cur; /* the value to be appended */
35785: int n_cur;
35786:
35787: for (n_prev = 0;n_prev < gen_nb_xmlSchemaValPtr;n_prev++) {
35788: for (n_cur = 0;n_cur < gen_nb_xmlSchemaValPtr;n_cur++) {
35789: mem_base = xmlMemBlocks();
35790: prev = gen_xmlSchemaValPtr(n_prev, 0);
35791: cur = gen_xmlSchemaValPtr(n_cur, 1);
35792:
35793: ret_val = xmlSchemaValueAppend(prev, cur);
35794: desret_int(ret_val);
35795: call_tests++;
35796: des_xmlSchemaValPtr(n_prev, prev, 0);
35797: des_xmlSchemaValPtr(n_cur, cur, 1);
35798: xmlResetLastError();
35799: if (mem_base != xmlMemBlocks()) {
35800: printf("Leak of %d blocks found in xmlSchemaValueAppend",
35801: xmlMemBlocks() - mem_base);
35802: test_ret++;
35803: printf(" %d", n_prev);
35804: printf(" %d", n_cur);
35805: printf("\n");
35806: }
35807: }
35808: }
35809: function_tests++;
35810: #endif
35811:
35812: return(test_ret);
35813: }
35814:
35815:
35816: static int
35817: test_xmlSchemaValueGetAsBoolean(void) {
35818: int test_ret = 0;
35819:
35820: #if defined(LIBXML_SCHEMAS_ENABLED)
35821: int mem_base;
35822: int ret_val;
35823: xmlSchemaValPtr val; /* the value */
35824: int n_val;
35825:
35826: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
35827: mem_base = xmlMemBlocks();
35828: val = gen_xmlSchemaValPtr(n_val, 0);
35829:
35830: ret_val = xmlSchemaValueGetAsBoolean(val);
35831: desret_int(ret_val);
35832: call_tests++;
35833: des_xmlSchemaValPtr(n_val, val, 0);
35834: xmlResetLastError();
35835: if (mem_base != xmlMemBlocks()) {
35836: printf("Leak of %d blocks found in xmlSchemaValueGetAsBoolean",
35837: xmlMemBlocks() - mem_base);
35838: test_ret++;
35839: printf(" %d", n_val);
35840: printf("\n");
35841: }
35842: }
35843: function_tests++;
35844: #endif
35845:
35846: return(test_ret);
35847: }
35848:
35849:
35850: static int
35851: test_xmlSchemaValueGetAsString(void) {
35852: int test_ret = 0;
35853:
35854: #if defined(LIBXML_SCHEMAS_ENABLED)
35855: int mem_base;
35856: const xmlChar * ret_val;
35857: xmlSchemaValPtr val; /* the value */
35858: int n_val;
35859:
35860: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
35861: mem_base = xmlMemBlocks();
35862: val = gen_xmlSchemaValPtr(n_val, 0);
35863:
35864: ret_val = xmlSchemaValueGetAsString(val);
35865: desret_const_xmlChar_ptr(ret_val);
35866: call_tests++;
35867: des_xmlSchemaValPtr(n_val, val, 0);
35868: xmlResetLastError();
35869: if (mem_base != xmlMemBlocks()) {
35870: printf("Leak of %d blocks found in xmlSchemaValueGetAsString",
35871: xmlMemBlocks() - mem_base);
35872: test_ret++;
35873: printf(" %d", n_val);
35874: printf("\n");
35875: }
35876: }
35877: function_tests++;
35878: #endif
35879:
35880: return(test_ret);
35881: }
35882:
35883:
35884: static int
35885: test_xmlSchemaValueGetNext(void) {
35886: int test_ret = 0;
35887:
35888:
35889: /* missing type support */
35890: return(test_ret);
35891: }
35892:
35893:
35894: static int
35895: test_xmlSchemaWhiteSpaceReplace(void) {
35896: int test_ret = 0;
35897:
35898: #if defined(LIBXML_SCHEMAS_ENABLED)
35899: int mem_base;
35900: xmlChar * ret_val;
35901: xmlChar * value; /* a value */
35902: int n_value;
35903:
35904: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35905: mem_base = xmlMemBlocks();
35906: value = gen_const_xmlChar_ptr(n_value, 0);
35907:
35908: ret_val = xmlSchemaWhiteSpaceReplace((const xmlChar *)value);
35909: desret_xmlChar_ptr(ret_val);
35910: call_tests++;
35911: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
35912: xmlResetLastError();
35913: if (mem_base != xmlMemBlocks()) {
35914: printf("Leak of %d blocks found in xmlSchemaWhiteSpaceReplace",
35915: xmlMemBlocks() - mem_base);
35916: test_ret++;
35917: printf(" %d", n_value);
35918: printf("\n");
35919: }
35920: }
35921: function_tests++;
35922: #endif
35923:
35924: return(test_ret);
35925: }
35926:
35927: static int
35928: test_xmlschemastypes(void) {
35929: int test_ret = 0;
35930:
35931: if (quiet == 0) printf("Testing xmlschemastypes : 26 of 34 functions ...\n");
35932: test_ret += test_xmlSchemaCheckFacet();
35933: test_ret += test_xmlSchemaCleanupTypes();
35934: test_ret += test_xmlSchemaCollapseString();
35935: test_ret += test_xmlSchemaCompareValues();
35936: test_ret += test_xmlSchemaCompareValuesWhtsp();
35937: test_ret += test_xmlSchemaCopyValue();
35938: test_ret += test_xmlSchemaGetBuiltInListSimpleTypeItemType();
35939: test_ret += test_xmlSchemaGetBuiltInType();
35940: test_ret += test_xmlSchemaGetCanonValue();
35941: test_ret += test_xmlSchemaGetCanonValueWhtsp();
35942: test_ret += test_xmlSchemaGetFacetValueAsULong();
35943: test_ret += test_xmlSchemaGetPredefinedType();
35944: test_ret += test_xmlSchemaGetValType();
35945: test_ret += test_xmlSchemaInitTypes();
35946: test_ret += test_xmlSchemaIsBuiltInTypeFacet();
35947: test_ret += test_xmlSchemaNewFacet();
35948: test_ret += test_xmlSchemaNewNOTATIONValue();
35949: test_ret += test_xmlSchemaNewQNameValue();
35950: test_ret += test_xmlSchemaNewStringValue();
35951: test_ret += test_xmlSchemaValPredefTypeNode();
35952: test_ret += test_xmlSchemaValPredefTypeNodeNoNorm();
35953: test_ret += test_xmlSchemaValidateFacet();
35954: test_ret += test_xmlSchemaValidateFacetWhtsp();
35955: test_ret += test_xmlSchemaValidateLengthFacet();
35956: test_ret += test_xmlSchemaValidateLengthFacetWhtsp();
35957: test_ret += test_xmlSchemaValidateListSimpleTypeFacet();
35958: test_ret += test_xmlSchemaValidatePredefinedType();
35959: test_ret += test_xmlSchemaValueAppend();
35960: test_ret += test_xmlSchemaValueGetAsBoolean();
35961: test_ret += test_xmlSchemaValueGetAsString();
35962: test_ret += test_xmlSchemaValueGetNext();
35963: test_ret += test_xmlSchemaWhiteSpaceReplace();
35964:
35965: if (test_ret != 0)
35966: printf("Module xmlschemastypes: %d errors\n", test_ret);
35967: return(test_ret);
35968: }
35969:
35970: static int
35971: test_xmlCharStrdup(void) {
35972: int test_ret = 0;
35973:
35974: int mem_base;
35975: xmlChar * ret_val;
35976: char * cur; /* the input char * */
35977: int n_cur;
35978:
35979: for (n_cur = 0;n_cur < gen_nb_const_char_ptr;n_cur++) {
35980: mem_base = xmlMemBlocks();
35981: cur = gen_const_char_ptr(n_cur, 0);
35982:
35983: ret_val = xmlCharStrdup((const char *)cur);
35984: desret_xmlChar_ptr(ret_val);
35985: call_tests++;
35986: des_const_char_ptr(n_cur, (const char *)cur, 0);
35987: xmlResetLastError();
35988: if (mem_base != xmlMemBlocks()) {
35989: printf("Leak of %d blocks found in xmlCharStrdup",
35990: xmlMemBlocks() - mem_base);
35991: test_ret++;
35992: printf(" %d", n_cur);
35993: printf("\n");
35994: }
35995: }
35996: function_tests++;
35997:
35998: return(test_ret);
35999: }
36000:
36001:
36002: static int
36003: test_xmlCharStrndup(void) {
36004: int test_ret = 0;
36005:
36006: int mem_base;
36007: xmlChar * ret_val;
36008: char * cur; /* the input char * */
36009: int n_cur;
36010: int len; /* the len of @cur */
36011: int n_len;
36012:
36013: for (n_cur = 0;n_cur < gen_nb_const_char_ptr;n_cur++) {
36014: for (n_len = 0;n_len < gen_nb_int;n_len++) {
36015: mem_base = xmlMemBlocks();
36016: cur = gen_const_char_ptr(n_cur, 0);
36017: len = gen_int(n_len, 1);
36018:
36019: ret_val = xmlCharStrndup((const char *)cur, len);
36020: desret_xmlChar_ptr(ret_val);
36021: call_tests++;
36022: des_const_char_ptr(n_cur, (const char *)cur, 0);
36023: des_int(n_len, len, 1);
36024: xmlResetLastError();
36025: if (mem_base != xmlMemBlocks()) {
36026: printf("Leak of %d blocks found in xmlCharStrndup",
36027: xmlMemBlocks() - mem_base);
36028: test_ret++;
36029: printf(" %d", n_cur);
36030: printf(" %d", n_len);
36031: printf("\n");
36032: }
36033: }
36034: }
36035: function_tests++;
36036:
36037: return(test_ret);
36038: }
36039:
36040:
36041: static int
36042: test_xmlCheckUTF8(void) {
36043: int test_ret = 0;
36044:
36045: int mem_base;
36046: int ret_val;
36047: unsigned char * utf; /* Pointer to putative UTF-8 encoded string. */
36048: int n_utf;
36049:
36050: for (n_utf = 0;n_utf < gen_nb_const_unsigned_char_ptr;n_utf++) {
36051: mem_base = xmlMemBlocks();
36052: utf = gen_const_unsigned_char_ptr(n_utf, 0);
36053:
36054: ret_val = xmlCheckUTF8((const unsigned char *)utf);
36055: desret_int(ret_val);
36056: call_tests++;
36057: des_const_unsigned_char_ptr(n_utf, (const unsigned char *)utf, 0);
36058: xmlResetLastError();
36059: if (mem_base != xmlMemBlocks()) {
36060: printf("Leak of %d blocks found in xmlCheckUTF8",
36061: xmlMemBlocks() - mem_base);
36062: test_ret++;
36063: printf(" %d", n_utf);
36064: printf("\n");
36065: }
36066: }
36067: function_tests++;
36068:
36069: return(test_ret);
36070: }
36071:
36072:
36073: static int
36074: test_xmlGetUTF8Char(void) {
36075: int test_ret = 0;
36076:
36077: int mem_base;
36078: int ret_val;
36079: unsigned char * utf; /* a sequence of UTF-8 encoded bytes */
36080: int n_utf;
36081: 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. */
36082: int n_len;
36083:
36084: for (n_utf = 0;n_utf < gen_nb_const_unsigned_char_ptr;n_utf++) {
36085: for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
36086: mem_base = xmlMemBlocks();
36087: utf = gen_const_unsigned_char_ptr(n_utf, 0);
36088: len = gen_int_ptr(n_len, 1);
36089:
36090: ret_val = xmlGetUTF8Char((const unsigned char *)utf, len);
36091: desret_int(ret_val);
36092: call_tests++;
36093: des_const_unsigned_char_ptr(n_utf, (const unsigned char *)utf, 0);
36094: des_int_ptr(n_len, len, 1);
36095: xmlResetLastError();
36096: if (mem_base != xmlMemBlocks()) {
36097: printf("Leak of %d blocks found in xmlGetUTF8Char",
36098: xmlMemBlocks() - mem_base);
36099: test_ret++;
36100: printf(" %d", n_utf);
36101: printf(" %d", n_len);
36102: printf("\n");
36103: }
36104: }
36105: }
36106: function_tests++;
36107:
36108: return(test_ret);
36109: }
36110:
36111:
36112: static int
36113: test_xmlStrEqual(void) {
36114: int test_ret = 0;
36115:
36116: int mem_base;
36117: int ret_val;
36118: xmlChar * str1; /* the first xmlChar * */
36119: int n_str1;
36120: xmlChar * str2; /* the second xmlChar * */
36121: int n_str2;
36122:
36123: for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
36124: for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
36125: mem_base = xmlMemBlocks();
36126: str1 = gen_const_xmlChar_ptr(n_str1, 0);
36127: str2 = gen_const_xmlChar_ptr(n_str2, 1);
36128:
36129: ret_val = xmlStrEqual((const xmlChar *)str1, (const xmlChar *)str2);
36130: desret_int(ret_val);
36131: call_tests++;
36132: des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0);
36133: des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1);
36134: xmlResetLastError();
36135: if (mem_base != xmlMemBlocks()) {
36136: printf("Leak of %d blocks found in xmlStrEqual",
36137: xmlMemBlocks() - mem_base);
36138: test_ret++;
36139: printf(" %d", n_str1);
36140: printf(" %d", n_str2);
36141: printf("\n");
36142: }
36143: }
36144: }
36145: function_tests++;
36146:
36147: return(test_ret);
36148: }
36149:
36150:
36151: static int
36152: test_xmlStrPrintf(void) {
36153: int test_ret = 0;
36154:
36155:
36156: /* missing type support */
36157: return(test_ret);
36158: }
36159:
36160:
36161: static int
36162: test_xmlStrQEqual(void) {
36163: int test_ret = 0;
36164:
36165: int mem_base;
36166: int ret_val;
36167: xmlChar * pref; /* the prefix of the QName */
36168: int n_pref;
36169: xmlChar * name; /* the localname of the QName */
36170: int n_name;
36171: xmlChar * str; /* the second xmlChar * */
36172: int n_str;
36173:
36174: for (n_pref = 0;n_pref < gen_nb_const_xmlChar_ptr;n_pref++) {
36175: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
36176: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
36177: mem_base = xmlMemBlocks();
36178: pref = gen_const_xmlChar_ptr(n_pref, 0);
36179: name = gen_const_xmlChar_ptr(n_name, 1);
36180: str = gen_const_xmlChar_ptr(n_str, 2);
36181:
36182: ret_val = xmlStrQEqual((const xmlChar *)pref, (const xmlChar *)name, (const xmlChar *)str);
36183: desret_int(ret_val);
36184: call_tests++;
36185: des_const_xmlChar_ptr(n_pref, (const xmlChar *)pref, 0);
36186: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
36187: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 2);
36188: xmlResetLastError();
36189: if (mem_base != xmlMemBlocks()) {
36190: printf("Leak of %d blocks found in xmlStrQEqual",
36191: xmlMemBlocks() - mem_base);
36192: test_ret++;
36193: printf(" %d", n_pref);
36194: printf(" %d", n_name);
36195: printf(" %d", n_str);
36196: printf("\n");
36197: }
36198: }
36199: }
36200: }
36201: function_tests++;
36202:
36203: return(test_ret);
36204: }
36205:
36206:
36207: static int
36208: test_xmlStrVPrintf(void) {
36209: int test_ret = 0;
36210:
36211:
36212: /* missing type support */
36213: return(test_ret);
36214: }
36215:
36216:
36217: static int
36218: test_xmlStrcasecmp(void) {
36219: int test_ret = 0;
36220:
36221: int mem_base;
36222: int ret_val;
36223: xmlChar * str1; /* the first xmlChar * */
36224: int n_str1;
36225: xmlChar * str2; /* the second xmlChar * */
36226: int n_str2;
36227:
36228: for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
36229: for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
36230: mem_base = xmlMemBlocks();
36231: str1 = gen_const_xmlChar_ptr(n_str1, 0);
36232: str2 = gen_const_xmlChar_ptr(n_str2, 1);
36233:
36234: ret_val = xmlStrcasecmp((const xmlChar *)str1, (const xmlChar *)str2);
36235: desret_int(ret_val);
36236: call_tests++;
36237: des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0);
36238: des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1);
36239: xmlResetLastError();
36240: if (mem_base != xmlMemBlocks()) {
36241: printf("Leak of %d blocks found in xmlStrcasecmp",
36242: xmlMemBlocks() - mem_base);
36243: test_ret++;
36244: printf(" %d", n_str1);
36245: printf(" %d", n_str2);
36246: printf("\n");
36247: }
36248: }
36249: }
36250: function_tests++;
36251:
36252: return(test_ret);
36253: }
36254:
36255:
36256: static int
36257: test_xmlStrcasestr(void) {
36258: int test_ret = 0;
36259:
36260: int mem_base;
36261: const xmlChar * ret_val;
36262: xmlChar * str; /* the xmlChar * array (haystack) */
36263: int n_str;
36264: xmlChar * val; /* the xmlChar to search (needle) */
36265: int n_val;
36266:
36267: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
36268: for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) {
36269: mem_base = xmlMemBlocks();
36270: str = gen_const_xmlChar_ptr(n_str, 0);
36271: val = gen_const_xmlChar_ptr(n_val, 1);
36272:
36273: ret_val = xmlStrcasestr((const xmlChar *)str, (const xmlChar *)val);
36274: desret_const_xmlChar_ptr(ret_val);
36275: call_tests++;
36276: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
36277: des_const_xmlChar_ptr(n_val, (const xmlChar *)val, 1);
36278: xmlResetLastError();
36279: if (mem_base != xmlMemBlocks()) {
36280: printf("Leak of %d blocks found in xmlStrcasestr",
36281: xmlMemBlocks() - mem_base);
36282: test_ret++;
36283: printf(" %d", n_str);
36284: printf(" %d", n_val);
36285: printf("\n");
36286: }
36287: }
36288: }
36289: function_tests++;
36290:
36291: return(test_ret);
36292: }
36293:
36294:
36295: static int
36296: test_xmlStrchr(void) {
36297: int test_ret = 0;
36298:
36299: int mem_base;
36300: const xmlChar * ret_val;
36301: xmlChar * str; /* the xmlChar * array */
36302: int n_str;
36303: xmlChar val; /* the xmlChar to search */
36304: int n_val;
36305:
36306: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
36307: for (n_val = 0;n_val < gen_nb_xmlChar;n_val++) {
36308: mem_base = xmlMemBlocks();
36309: str = gen_const_xmlChar_ptr(n_str, 0);
36310: val = gen_xmlChar(n_val, 1);
36311:
36312: ret_val = xmlStrchr((const xmlChar *)str, val);
36313: desret_const_xmlChar_ptr(ret_val);
36314: call_tests++;
36315: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
36316: des_xmlChar(n_val, val, 1);
36317: xmlResetLastError();
36318: if (mem_base != xmlMemBlocks()) {
36319: printf("Leak of %d blocks found in xmlStrchr",
36320: xmlMemBlocks() - mem_base);
36321: test_ret++;
36322: printf(" %d", n_str);
36323: printf(" %d", n_val);
36324: printf("\n");
36325: }
36326: }
36327: }
36328: function_tests++;
36329:
36330: return(test_ret);
36331: }
36332:
36333:
36334: static int
36335: test_xmlStrcmp(void) {
36336: int test_ret = 0;
36337:
36338: int mem_base;
36339: int ret_val;
36340: xmlChar * str1; /* the first xmlChar * */
36341: int n_str1;
36342: xmlChar * str2; /* the second xmlChar * */
36343: int n_str2;
36344:
36345: for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
36346: for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
36347: mem_base = xmlMemBlocks();
36348: str1 = gen_const_xmlChar_ptr(n_str1, 0);
36349: str2 = gen_const_xmlChar_ptr(n_str2, 1);
36350:
36351: ret_val = xmlStrcmp((const xmlChar *)str1, (const xmlChar *)str2);
36352: desret_int(ret_val);
36353: call_tests++;
36354: des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0);
36355: des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1);
36356: xmlResetLastError();
36357: if (mem_base != xmlMemBlocks()) {
36358: printf("Leak of %d blocks found in xmlStrcmp",
36359: xmlMemBlocks() - mem_base);
36360: test_ret++;
36361: printf(" %d", n_str1);
36362: printf(" %d", n_str2);
36363: printf("\n");
36364: }
36365: }
36366: }
36367: function_tests++;
36368:
36369: return(test_ret);
36370: }
36371:
36372:
36373: static int
36374: test_xmlStrdup(void) {
36375: int test_ret = 0;
36376:
36377: int mem_base;
36378: xmlChar * ret_val;
36379: xmlChar * cur; /* the input xmlChar * */
36380: int n_cur;
36381:
36382: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
36383: mem_base = xmlMemBlocks();
36384: cur = gen_const_xmlChar_ptr(n_cur, 0);
36385:
36386: ret_val = xmlStrdup((const xmlChar *)cur);
36387: desret_xmlChar_ptr(ret_val);
36388: call_tests++;
36389: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
36390: xmlResetLastError();
36391: if (mem_base != xmlMemBlocks()) {
36392: printf("Leak of %d blocks found in xmlStrdup",
36393: xmlMemBlocks() - mem_base);
36394: test_ret++;
36395: printf(" %d", n_cur);
36396: printf("\n");
36397: }
36398: }
36399: function_tests++;
36400:
36401: return(test_ret);
36402: }
36403:
36404:
36405: static int
36406: test_xmlStrlen(void) {
36407: int test_ret = 0;
36408:
36409: int mem_base;
36410: int ret_val;
36411: xmlChar * str; /* the xmlChar * array */
36412: int n_str;
36413:
36414: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
36415: mem_base = xmlMemBlocks();
36416: str = gen_const_xmlChar_ptr(n_str, 0);
36417:
36418: ret_val = xmlStrlen((const xmlChar *)str);
36419: desret_int(ret_val);
36420: call_tests++;
36421: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
36422: xmlResetLastError();
36423: if (mem_base != xmlMemBlocks()) {
36424: printf("Leak of %d blocks found in xmlStrlen",
36425: xmlMemBlocks() - mem_base);
36426: test_ret++;
36427: printf(" %d", n_str);
36428: printf("\n");
36429: }
36430: }
36431: function_tests++;
36432:
36433: return(test_ret);
36434: }
36435:
36436:
36437: static int
36438: test_xmlStrncasecmp(void) {
36439: int test_ret = 0;
36440:
36441: int mem_base;
36442: int ret_val;
36443: xmlChar * str1; /* the first xmlChar * */
36444: int n_str1;
36445: xmlChar * str2; /* the second xmlChar * */
36446: int n_str2;
36447: int len; /* the max comparison length */
36448: int n_len;
36449:
36450: for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
36451: for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
36452: for (n_len = 0;n_len < gen_nb_int;n_len++) {
36453: mem_base = xmlMemBlocks();
36454: str1 = gen_const_xmlChar_ptr(n_str1, 0);
36455: str2 = gen_const_xmlChar_ptr(n_str2, 1);
36456: len = gen_int(n_len, 2);
36457:
36458: ret_val = xmlStrncasecmp((const xmlChar *)str1, (const xmlChar *)str2, len);
36459: desret_int(ret_val);
36460: call_tests++;
36461: des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0);
36462: des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1);
36463: des_int(n_len, len, 2);
36464: xmlResetLastError();
36465: if (mem_base != xmlMemBlocks()) {
36466: printf("Leak of %d blocks found in xmlStrncasecmp",
36467: xmlMemBlocks() - mem_base);
36468: test_ret++;
36469: printf(" %d", n_str1);
36470: printf(" %d", n_str2);
36471: printf(" %d", n_len);
36472: printf("\n");
36473: }
36474: }
36475: }
36476: }
36477: function_tests++;
36478:
36479: return(test_ret);
36480: }
36481:
36482:
36483: static int
36484: test_xmlStrncatNew(void) {
36485: int test_ret = 0;
36486:
36487: int mem_base;
36488: xmlChar * ret_val;
36489: xmlChar * str1; /* first xmlChar string */
36490: int n_str1;
36491: xmlChar * str2; /* second xmlChar string */
36492: int n_str2;
36493: int len; /* the len of @str2 or < 0 */
36494: int n_len;
36495:
36496: for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
36497: for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
36498: for (n_len = 0;n_len < gen_nb_int;n_len++) {
36499: mem_base = xmlMemBlocks();
36500: str1 = gen_const_xmlChar_ptr(n_str1, 0);
36501: str2 = gen_const_xmlChar_ptr(n_str2, 1);
36502: len = gen_int(n_len, 2);
36503:
36504: ret_val = xmlStrncatNew((const xmlChar *)str1, (const xmlChar *)str2, len);
36505: desret_xmlChar_ptr(ret_val);
36506: call_tests++;
36507: des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0);
36508: des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1);
36509: des_int(n_len, len, 2);
36510: xmlResetLastError();
36511: if (mem_base != xmlMemBlocks()) {
36512: printf("Leak of %d blocks found in xmlStrncatNew",
36513: xmlMemBlocks() - mem_base);
36514: test_ret++;
36515: printf(" %d", n_str1);
36516: printf(" %d", n_str2);
36517: printf(" %d", n_len);
36518: printf("\n");
36519: }
36520: }
36521: }
36522: }
36523: function_tests++;
36524:
36525: return(test_ret);
36526: }
36527:
36528:
36529: static int
36530: test_xmlStrncmp(void) {
36531: int test_ret = 0;
36532:
36533: int mem_base;
36534: int ret_val;
36535: xmlChar * str1; /* the first xmlChar * */
36536: int n_str1;
36537: xmlChar * str2; /* the second xmlChar * */
36538: int n_str2;
36539: int len; /* the max comparison length */
36540: int n_len;
36541:
36542: for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
36543: for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
36544: for (n_len = 0;n_len < gen_nb_int;n_len++) {
36545: mem_base = xmlMemBlocks();
36546: str1 = gen_const_xmlChar_ptr(n_str1, 0);
36547: str2 = gen_const_xmlChar_ptr(n_str2, 1);
36548: len = gen_int(n_len, 2);
36549:
36550: ret_val = xmlStrncmp((const xmlChar *)str1, (const xmlChar *)str2, len);
36551: desret_int(ret_val);
36552: call_tests++;
36553: des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0);
36554: des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1);
36555: des_int(n_len, len, 2);
36556: xmlResetLastError();
36557: if (mem_base != xmlMemBlocks()) {
36558: printf("Leak of %d blocks found in xmlStrncmp",
36559: xmlMemBlocks() - mem_base);
36560: test_ret++;
36561: printf(" %d", n_str1);
36562: printf(" %d", n_str2);
36563: printf(" %d", n_len);
36564: printf("\n");
36565: }
36566: }
36567: }
36568: }
36569: function_tests++;
36570:
36571: return(test_ret);
36572: }
36573:
36574:
36575: static int
36576: test_xmlStrndup(void) {
36577: int test_ret = 0;
36578:
36579: int mem_base;
36580: xmlChar * ret_val;
36581: xmlChar * cur; /* the input xmlChar * */
36582: int n_cur;
36583: int len; /* the len of @cur */
36584: int n_len;
36585:
36586: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
36587: for (n_len = 0;n_len < gen_nb_int;n_len++) {
36588: mem_base = xmlMemBlocks();
36589: cur = gen_const_xmlChar_ptr(n_cur, 0);
36590: len = gen_int(n_len, 1);
36591:
36592: ret_val = xmlStrndup((const xmlChar *)cur, len);
36593: desret_xmlChar_ptr(ret_val);
36594: call_tests++;
36595: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
36596: des_int(n_len, len, 1);
36597: xmlResetLastError();
36598: if (mem_base != xmlMemBlocks()) {
36599: printf("Leak of %d blocks found in xmlStrndup",
36600: xmlMemBlocks() - mem_base);
36601: test_ret++;
36602: printf(" %d", n_cur);
36603: printf(" %d", n_len);
36604: printf("\n");
36605: }
36606: }
36607: }
36608: function_tests++;
36609:
36610: return(test_ret);
36611: }
36612:
36613:
36614: static int
36615: test_xmlStrstr(void) {
36616: int test_ret = 0;
36617:
36618: int mem_base;
36619: const xmlChar * ret_val;
36620: xmlChar * str; /* the xmlChar * array (haystack) */
36621: int n_str;
36622: xmlChar * val; /* the xmlChar to search (needle) */
36623: int n_val;
36624:
36625: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
36626: for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) {
36627: mem_base = xmlMemBlocks();
36628: str = gen_const_xmlChar_ptr(n_str, 0);
36629: val = gen_const_xmlChar_ptr(n_val, 1);
36630:
36631: ret_val = xmlStrstr((const xmlChar *)str, (const xmlChar *)val);
36632: desret_const_xmlChar_ptr(ret_val);
36633: call_tests++;
36634: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
36635: des_const_xmlChar_ptr(n_val, (const xmlChar *)val, 1);
36636: xmlResetLastError();
36637: if (mem_base != xmlMemBlocks()) {
36638: printf("Leak of %d blocks found in xmlStrstr",
36639: xmlMemBlocks() - mem_base);
36640: test_ret++;
36641: printf(" %d", n_str);
36642: printf(" %d", n_val);
36643: printf("\n");
36644: }
36645: }
36646: }
36647: function_tests++;
36648:
36649: return(test_ret);
36650: }
36651:
36652:
36653: static int
36654: test_xmlStrsub(void) {
36655: int test_ret = 0;
36656:
36657: int mem_base;
36658: xmlChar * ret_val;
36659: xmlChar * str; /* the xmlChar * array (haystack) */
36660: int n_str;
36661: int start; /* the index of the first char (zero based) */
36662: int n_start;
36663: int len; /* the length of the substring */
36664: int n_len;
36665:
36666: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
36667: for (n_start = 0;n_start < gen_nb_int;n_start++) {
36668: for (n_len = 0;n_len < gen_nb_int;n_len++) {
36669: mem_base = xmlMemBlocks();
36670: str = gen_const_xmlChar_ptr(n_str, 0);
36671: start = gen_int(n_start, 1);
36672: len = gen_int(n_len, 2);
36673:
36674: ret_val = xmlStrsub((const xmlChar *)str, start, len);
36675: desret_xmlChar_ptr(ret_val);
36676: call_tests++;
36677: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
36678: des_int(n_start, start, 1);
36679: des_int(n_len, len, 2);
36680: xmlResetLastError();
36681: if (mem_base != xmlMemBlocks()) {
36682: printf("Leak of %d blocks found in xmlStrsub",
36683: xmlMemBlocks() - mem_base);
36684: test_ret++;
36685: printf(" %d", n_str);
36686: printf(" %d", n_start);
36687: printf(" %d", n_len);
36688: printf("\n");
36689: }
36690: }
36691: }
36692: }
36693: function_tests++;
36694:
36695: return(test_ret);
36696: }
36697:
36698:
36699: static int
36700: test_xmlUTF8Charcmp(void) {
36701: int test_ret = 0;
36702:
36703: int mem_base;
36704: int ret_val;
36705: xmlChar * utf1; /* pointer to first UTF8 char */
36706: int n_utf1;
36707: xmlChar * utf2; /* pointer to second UTF8 char */
36708: int n_utf2;
36709:
36710: for (n_utf1 = 0;n_utf1 < gen_nb_const_xmlChar_ptr;n_utf1++) {
36711: for (n_utf2 = 0;n_utf2 < gen_nb_const_xmlChar_ptr;n_utf2++) {
36712: mem_base = xmlMemBlocks();
36713: utf1 = gen_const_xmlChar_ptr(n_utf1, 0);
36714: utf2 = gen_const_xmlChar_ptr(n_utf2, 1);
36715:
36716: ret_val = xmlUTF8Charcmp((const xmlChar *)utf1, (const xmlChar *)utf2);
36717: desret_int(ret_val);
36718: call_tests++;
36719: des_const_xmlChar_ptr(n_utf1, (const xmlChar *)utf1, 0);
36720: des_const_xmlChar_ptr(n_utf2, (const xmlChar *)utf2, 1);
36721: xmlResetLastError();
36722: if (mem_base != xmlMemBlocks()) {
36723: printf("Leak of %d blocks found in xmlUTF8Charcmp",
36724: xmlMemBlocks() - mem_base);
36725: test_ret++;
36726: printf(" %d", n_utf1);
36727: printf(" %d", n_utf2);
36728: printf("\n");
36729: }
36730: }
36731: }
36732: function_tests++;
36733:
36734: return(test_ret);
36735: }
36736:
36737:
36738: static int
36739: test_xmlUTF8Size(void) {
36740: int test_ret = 0;
36741:
36742: int mem_base;
36743: int ret_val;
36744: xmlChar * utf; /* pointer to the UTF8 character */
36745: int n_utf;
36746:
36747: for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
36748: mem_base = xmlMemBlocks();
36749: utf = gen_const_xmlChar_ptr(n_utf, 0);
36750:
36751: ret_val = xmlUTF8Size((const xmlChar *)utf);
36752: desret_int(ret_val);
36753: call_tests++;
36754: des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
36755: xmlResetLastError();
36756: if (mem_base != xmlMemBlocks()) {
36757: printf("Leak of %d blocks found in xmlUTF8Size",
36758: xmlMemBlocks() - mem_base);
36759: test_ret++;
36760: printf(" %d", n_utf);
36761: printf("\n");
36762: }
36763: }
36764: function_tests++;
36765:
36766: return(test_ret);
36767: }
36768:
36769:
36770: static int
36771: test_xmlUTF8Strlen(void) {
36772: int test_ret = 0;
36773:
36774: int mem_base;
36775: int ret_val;
36776: xmlChar * utf; /* a sequence of UTF-8 encoded bytes */
36777: int n_utf;
36778:
36779: for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
36780: mem_base = xmlMemBlocks();
36781: utf = gen_const_xmlChar_ptr(n_utf, 0);
36782:
36783: ret_val = xmlUTF8Strlen((const xmlChar *)utf);
36784: desret_int(ret_val);
36785: call_tests++;
36786: des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
36787: xmlResetLastError();
36788: if (mem_base != xmlMemBlocks()) {
36789: printf("Leak of %d blocks found in xmlUTF8Strlen",
36790: xmlMemBlocks() - mem_base);
36791: test_ret++;
36792: printf(" %d", n_utf);
36793: printf("\n");
36794: }
36795: }
36796: function_tests++;
36797:
36798: return(test_ret);
36799: }
36800:
36801:
36802: static int
36803: test_xmlUTF8Strloc(void) {
36804: int test_ret = 0;
36805:
36806: int mem_base;
36807: int ret_val;
36808: xmlChar * utf; /* the input UTF8 * */
36809: int n_utf;
36810: xmlChar * utfchar; /* the UTF8 character to be found */
36811: int n_utfchar;
36812:
36813: for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
36814: for (n_utfchar = 0;n_utfchar < gen_nb_const_xmlChar_ptr;n_utfchar++) {
36815: mem_base = xmlMemBlocks();
36816: utf = gen_const_xmlChar_ptr(n_utf, 0);
36817: utfchar = gen_const_xmlChar_ptr(n_utfchar, 1);
36818:
36819: ret_val = xmlUTF8Strloc((const xmlChar *)utf, (const xmlChar *)utfchar);
36820: desret_int(ret_val);
36821: call_tests++;
36822: des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
36823: des_const_xmlChar_ptr(n_utfchar, (const xmlChar *)utfchar, 1);
36824: xmlResetLastError();
36825: if (mem_base != xmlMemBlocks()) {
36826: printf("Leak of %d blocks found in xmlUTF8Strloc",
36827: xmlMemBlocks() - mem_base);
36828: test_ret++;
36829: printf(" %d", n_utf);
36830: printf(" %d", n_utfchar);
36831: printf("\n");
36832: }
36833: }
36834: }
36835: function_tests++;
36836:
36837: return(test_ret);
36838: }
36839:
36840:
36841: static int
36842: test_xmlUTF8Strndup(void) {
36843: int test_ret = 0;
36844:
36845: int mem_base;
36846: xmlChar * ret_val;
36847: xmlChar * utf; /* the input UTF8 * */
36848: int n_utf;
36849: int len; /* the len of @utf (in chars) */
36850: int n_len;
36851:
36852: for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
36853: for (n_len = 0;n_len < gen_nb_int;n_len++) {
36854: mem_base = xmlMemBlocks();
36855: utf = gen_const_xmlChar_ptr(n_utf, 0);
36856: len = gen_int(n_len, 1);
36857:
36858: ret_val = xmlUTF8Strndup((const xmlChar *)utf, len);
36859: desret_xmlChar_ptr(ret_val);
36860: call_tests++;
36861: des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
36862: des_int(n_len, len, 1);
36863: xmlResetLastError();
36864: if (mem_base != xmlMemBlocks()) {
36865: printf("Leak of %d blocks found in xmlUTF8Strndup",
36866: xmlMemBlocks() - mem_base);
36867: test_ret++;
36868: printf(" %d", n_utf);
36869: printf(" %d", n_len);
36870: printf("\n");
36871: }
36872: }
36873: }
36874: function_tests++;
36875:
36876: return(test_ret);
36877: }
36878:
36879:
36880: static int
36881: test_xmlUTF8Strpos(void) {
36882: int test_ret = 0;
36883:
36884: int mem_base;
36885: const xmlChar * ret_val;
36886: xmlChar * utf; /* the input UTF8 * */
36887: int n_utf;
36888: int pos; /* the position of the desired UTF8 char (in chars) */
36889: int n_pos;
36890:
36891: for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
36892: for (n_pos = 0;n_pos < gen_nb_int;n_pos++) {
36893: mem_base = xmlMemBlocks();
36894: utf = gen_const_xmlChar_ptr(n_utf, 0);
36895: pos = gen_int(n_pos, 1);
36896:
36897: ret_val = xmlUTF8Strpos((const xmlChar *)utf, pos);
36898: desret_const_xmlChar_ptr(ret_val);
36899: call_tests++;
36900: des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
36901: des_int(n_pos, pos, 1);
36902: xmlResetLastError();
36903: if (mem_base != xmlMemBlocks()) {
36904: printf("Leak of %d blocks found in xmlUTF8Strpos",
36905: xmlMemBlocks() - mem_base);
36906: test_ret++;
36907: printf(" %d", n_utf);
36908: printf(" %d", n_pos);
36909: printf("\n");
36910: }
36911: }
36912: }
36913: function_tests++;
36914:
36915: return(test_ret);
36916: }
36917:
36918:
36919: static int
36920: test_xmlUTF8Strsize(void) {
36921: int test_ret = 0;
36922:
36923: int mem_base;
36924: int ret_val;
36925: xmlChar * utf; /* a sequence of UTF-8 encoded bytes */
36926: int n_utf;
36927: int len; /* the number of characters in the array */
36928: int n_len;
36929:
36930: for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
36931: for (n_len = 0;n_len < gen_nb_int;n_len++) {
36932: mem_base = xmlMemBlocks();
36933: utf = gen_const_xmlChar_ptr(n_utf, 0);
36934: len = gen_int(n_len, 1);
36935:
36936: ret_val = xmlUTF8Strsize((const xmlChar *)utf, len);
36937: desret_int(ret_val);
36938: call_tests++;
36939: des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
36940: des_int(n_len, len, 1);
36941: xmlResetLastError();
36942: if (mem_base != xmlMemBlocks()) {
36943: printf("Leak of %d blocks found in xmlUTF8Strsize",
36944: xmlMemBlocks() - mem_base);
36945: test_ret++;
36946: printf(" %d", n_utf);
36947: printf(" %d", n_len);
36948: printf("\n");
36949: }
36950: }
36951: }
36952: function_tests++;
36953:
36954: return(test_ret);
36955: }
36956:
36957:
36958: static int
36959: test_xmlUTF8Strsub(void) {
36960: int test_ret = 0;
36961:
36962: int mem_base;
36963: xmlChar * ret_val;
36964: xmlChar * utf; /* a sequence of UTF-8 encoded bytes */
36965: int n_utf;
36966: int start; /* relative pos of first char */
36967: int n_start;
36968: int len; /* total number to copy */
36969: int n_len;
36970:
36971: for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
36972: for (n_start = 0;n_start < gen_nb_int;n_start++) {
36973: for (n_len = 0;n_len < gen_nb_int;n_len++) {
36974: mem_base = xmlMemBlocks();
36975: utf = gen_const_xmlChar_ptr(n_utf, 0);
36976: start = gen_int(n_start, 1);
36977: len = gen_int(n_len, 2);
36978:
36979: ret_val = xmlUTF8Strsub((const xmlChar *)utf, start, len);
36980: desret_xmlChar_ptr(ret_val);
36981: call_tests++;
36982: des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
36983: des_int(n_start, start, 1);
36984: des_int(n_len, len, 2);
36985: xmlResetLastError();
36986: if (mem_base != xmlMemBlocks()) {
36987: printf("Leak of %d blocks found in xmlUTF8Strsub",
36988: xmlMemBlocks() - mem_base);
36989: test_ret++;
36990: printf(" %d", n_utf);
36991: printf(" %d", n_start);
36992: printf(" %d", n_len);
36993: printf("\n");
36994: }
36995: }
36996: }
36997: }
36998: function_tests++;
36999:
37000: return(test_ret);
37001: }
37002:
37003: static int
37004: test_xmlstring(void) {
37005: int test_ret = 0;
37006:
37007: if (quiet == 0) printf("Testing xmlstring : 26 of 30 functions ...\n");
37008: test_ret += test_xmlCharStrdup();
37009: test_ret += test_xmlCharStrndup();
37010: test_ret += test_xmlCheckUTF8();
37011: test_ret += test_xmlGetUTF8Char();
37012: test_ret += test_xmlStrEqual();
37013: test_ret += test_xmlStrPrintf();
37014: test_ret += test_xmlStrQEqual();
37015: test_ret += test_xmlStrVPrintf();
37016: test_ret += test_xmlStrcasecmp();
37017: test_ret += test_xmlStrcasestr();
37018: test_ret += test_xmlStrchr();
37019: test_ret += test_xmlStrcmp();
37020: test_ret += test_xmlStrdup();
37021: test_ret += test_xmlStrlen();
37022: test_ret += test_xmlStrncasecmp();
37023: test_ret += test_xmlStrncatNew();
37024: test_ret += test_xmlStrncmp();
37025: test_ret += test_xmlStrndup();
37026: test_ret += test_xmlStrstr();
37027: test_ret += test_xmlStrsub();
37028: test_ret += test_xmlUTF8Charcmp();
37029: test_ret += test_xmlUTF8Size();
37030: test_ret += test_xmlUTF8Strlen();
37031: test_ret += test_xmlUTF8Strloc();
37032: test_ret += test_xmlUTF8Strndup();
37033: test_ret += test_xmlUTF8Strpos();
37034: test_ret += test_xmlUTF8Strsize();
37035: test_ret += test_xmlUTF8Strsub();
37036:
37037: if (test_ret != 0)
37038: printf("Module xmlstring: %d errors\n", test_ret);
37039: return(test_ret);
37040: }
37041:
37042: static int
37043: test_xmlUCSIsAegeanNumbers(void) {
37044: int test_ret = 0;
37045:
37046: #if defined(LIBXML_UNICODE_ENABLED)
37047: int mem_base;
37048: int ret_val;
37049: int code; /* UCS code point */
37050: int n_code;
37051:
37052: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37053: mem_base = xmlMemBlocks();
37054: code = gen_int(n_code, 0);
37055:
37056: ret_val = xmlUCSIsAegeanNumbers(code);
37057: desret_int(ret_val);
37058: call_tests++;
37059: des_int(n_code, code, 0);
37060: xmlResetLastError();
37061: if (mem_base != xmlMemBlocks()) {
37062: printf("Leak of %d blocks found in xmlUCSIsAegeanNumbers",
37063: xmlMemBlocks() - mem_base);
37064: test_ret++;
37065: printf(" %d", n_code);
37066: printf("\n");
37067: }
37068: }
37069: function_tests++;
37070: #endif
37071:
37072: return(test_ret);
37073: }
37074:
37075:
37076: static int
37077: test_xmlUCSIsAlphabeticPresentationForms(void) {
37078: int test_ret = 0;
37079:
37080: #if defined(LIBXML_UNICODE_ENABLED)
37081: int mem_base;
37082: int ret_val;
37083: int code; /* UCS code point */
37084: int n_code;
37085:
37086: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37087: mem_base = xmlMemBlocks();
37088: code = gen_int(n_code, 0);
37089:
37090: ret_val = xmlUCSIsAlphabeticPresentationForms(code);
37091: desret_int(ret_val);
37092: call_tests++;
37093: des_int(n_code, code, 0);
37094: xmlResetLastError();
37095: if (mem_base != xmlMemBlocks()) {
37096: printf("Leak of %d blocks found in xmlUCSIsAlphabeticPresentationForms",
37097: xmlMemBlocks() - mem_base);
37098: test_ret++;
37099: printf(" %d", n_code);
37100: printf("\n");
37101: }
37102: }
37103: function_tests++;
37104: #endif
37105:
37106: return(test_ret);
37107: }
37108:
37109:
37110: static int
37111: test_xmlUCSIsArabic(void) {
37112: int test_ret = 0;
37113:
37114: #if defined(LIBXML_UNICODE_ENABLED)
37115: int mem_base;
37116: int ret_val;
37117: int code; /* UCS code point */
37118: int n_code;
37119:
37120: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37121: mem_base = xmlMemBlocks();
37122: code = gen_int(n_code, 0);
37123:
37124: ret_val = xmlUCSIsArabic(code);
37125: desret_int(ret_val);
37126: call_tests++;
37127: des_int(n_code, code, 0);
37128: xmlResetLastError();
37129: if (mem_base != xmlMemBlocks()) {
37130: printf("Leak of %d blocks found in xmlUCSIsArabic",
37131: xmlMemBlocks() - mem_base);
37132: test_ret++;
37133: printf(" %d", n_code);
37134: printf("\n");
37135: }
37136: }
37137: function_tests++;
37138: #endif
37139:
37140: return(test_ret);
37141: }
37142:
37143:
37144: static int
37145: test_xmlUCSIsArabicPresentationFormsA(void) {
37146: int test_ret = 0;
37147:
37148: #if defined(LIBXML_UNICODE_ENABLED)
37149: int mem_base;
37150: int ret_val;
37151: int code; /* UCS code point */
37152: int n_code;
37153:
37154: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37155: mem_base = xmlMemBlocks();
37156: code = gen_int(n_code, 0);
37157:
37158: ret_val = xmlUCSIsArabicPresentationFormsA(code);
37159: desret_int(ret_val);
37160: call_tests++;
37161: des_int(n_code, code, 0);
37162: xmlResetLastError();
37163: if (mem_base != xmlMemBlocks()) {
37164: printf("Leak of %d blocks found in xmlUCSIsArabicPresentationFormsA",
37165: xmlMemBlocks() - mem_base);
37166: test_ret++;
37167: printf(" %d", n_code);
37168: printf("\n");
37169: }
37170: }
37171: function_tests++;
37172: #endif
37173:
37174: return(test_ret);
37175: }
37176:
37177:
37178: static int
37179: test_xmlUCSIsArabicPresentationFormsB(void) {
37180: int test_ret = 0;
37181:
37182: #if defined(LIBXML_UNICODE_ENABLED)
37183: int mem_base;
37184: int ret_val;
37185: int code; /* UCS code point */
37186: int n_code;
37187:
37188: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37189: mem_base = xmlMemBlocks();
37190: code = gen_int(n_code, 0);
37191:
37192: ret_val = xmlUCSIsArabicPresentationFormsB(code);
37193: desret_int(ret_val);
37194: call_tests++;
37195: des_int(n_code, code, 0);
37196: xmlResetLastError();
37197: if (mem_base != xmlMemBlocks()) {
37198: printf("Leak of %d blocks found in xmlUCSIsArabicPresentationFormsB",
37199: xmlMemBlocks() - mem_base);
37200: test_ret++;
37201: printf(" %d", n_code);
37202: printf("\n");
37203: }
37204: }
37205: function_tests++;
37206: #endif
37207:
37208: return(test_ret);
37209: }
37210:
37211:
37212: static int
37213: test_xmlUCSIsArmenian(void) {
37214: int test_ret = 0;
37215:
37216: #if defined(LIBXML_UNICODE_ENABLED)
37217: int mem_base;
37218: int ret_val;
37219: int code; /* UCS code point */
37220: int n_code;
37221:
37222: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37223: mem_base = xmlMemBlocks();
37224: code = gen_int(n_code, 0);
37225:
37226: ret_val = xmlUCSIsArmenian(code);
37227: desret_int(ret_val);
37228: call_tests++;
37229: des_int(n_code, code, 0);
37230: xmlResetLastError();
37231: if (mem_base != xmlMemBlocks()) {
37232: printf("Leak of %d blocks found in xmlUCSIsArmenian",
37233: xmlMemBlocks() - mem_base);
37234: test_ret++;
37235: printf(" %d", n_code);
37236: printf("\n");
37237: }
37238: }
37239: function_tests++;
37240: #endif
37241:
37242: return(test_ret);
37243: }
37244:
37245:
37246: static int
37247: test_xmlUCSIsArrows(void) {
37248: int test_ret = 0;
37249:
37250: #if defined(LIBXML_UNICODE_ENABLED)
37251: int mem_base;
37252: int ret_val;
37253: int code; /* UCS code point */
37254: int n_code;
37255:
37256: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37257: mem_base = xmlMemBlocks();
37258: code = gen_int(n_code, 0);
37259:
37260: ret_val = xmlUCSIsArrows(code);
37261: desret_int(ret_val);
37262: call_tests++;
37263: des_int(n_code, code, 0);
37264: xmlResetLastError();
37265: if (mem_base != xmlMemBlocks()) {
37266: printf("Leak of %d blocks found in xmlUCSIsArrows",
37267: xmlMemBlocks() - mem_base);
37268: test_ret++;
37269: printf(" %d", n_code);
37270: printf("\n");
37271: }
37272: }
37273: function_tests++;
37274: #endif
37275:
37276: return(test_ret);
37277: }
37278:
37279:
37280: static int
37281: test_xmlUCSIsBasicLatin(void) {
37282: int test_ret = 0;
37283:
37284: #if defined(LIBXML_UNICODE_ENABLED)
37285: int mem_base;
37286: int ret_val;
37287: int code; /* UCS code point */
37288: int n_code;
37289:
37290: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37291: mem_base = xmlMemBlocks();
37292: code = gen_int(n_code, 0);
37293:
37294: ret_val = xmlUCSIsBasicLatin(code);
37295: desret_int(ret_val);
37296: call_tests++;
37297: des_int(n_code, code, 0);
37298: xmlResetLastError();
37299: if (mem_base != xmlMemBlocks()) {
37300: printf("Leak of %d blocks found in xmlUCSIsBasicLatin",
37301: xmlMemBlocks() - mem_base);
37302: test_ret++;
37303: printf(" %d", n_code);
37304: printf("\n");
37305: }
37306: }
37307: function_tests++;
37308: #endif
37309:
37310: return(test_ret);
37311: }
37312:
37313:
37314: static int
37315: test_xmlUCSIsBengali(void) {
37316: int test_ret = 0;
37317:
37318: #if defined(LIBXML_UNICODE_ENABLED)
37319: int mem_base;
37320: int ret_val;
37321: int code; /* UCS code point */
37322: int n_code;
37323:
37324: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37325: mem_base = xmlMemBlocks();
37326: code = gen_int(n_code, 0);
37327:
37328: ret_val = xmlUCSIsBengali(code);
37329: desret_int(ret_val);
37330: call_tests++;
37331: des_int(n_code, code, 0);
37332: xmlResetLastError();
37333: if (mem_base != xmlMemBlocks()) {
37334: printf("Leak of %d blocks found in xmlUCSIsBengali",
37335: xmlMemBlocks() - mem_base);
37336: test_ret++;
37337: printf(" %d", n_code);
37338: printf("\n");
37339: }
37340: }
37341: function_tests++;
37342: #endif
37343:
37344: return(test_ret);
37345: }
37346:
37347:
37348: static int
37349: test_xmlUCSIsBlock(void) {
37350: int test_ret = 0;
37351:
37352: #if defined(LIBXML_UNICODE_ENABLED)
37353: int mem_base;
37354: int ret_val;
37355: int code; /* UCS code point */
37356: int n_code;
37357: char * block; /* UCS block name */
37358: int n_block;
37359:
37360: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37361: for (n_block = 0;n_block < gen_nb_const_char_ptr;n_block++) {
37362: mem_base = xmlMemBlocks();
37363: code = gen_int(n_code, 0);
37364: block = gen_const_char_ptr(n_block, 1);
37365:
37366: ret_val = xmlUCSIsBlock(code, (const char *)block);
37367: desret_int(ret_val);
37368: call_tests++;
37369: des_int(n_code, code, 0);
37370: des_const_char_ptr(n_block, (const char *)block, 1);
37371: xmlResetLastError();
37372: if (mem_base != xmlMemBlocks()) {
37373: printf("Leak of %d blocks found in xmlUCSIsBlock",
37374: xmlMemBlocks() - mem_base);
37375: test_ret++;
37376: printf(" %d", n_code);
37377: printf(" %d", n_block);
37378: printf("\n");
37379: }
37380: }
37381: }
37382: function_tests++;
37383: #endif
37384:
37385: return(test_ret);
37386: }
37387:
37388:
37389: static int
37390: test_xmlUCSIsBlockElements(void) {
37391: int test_ret = 0;
37392:
37393: #if defined(LIBXML_UNICODE_ENABLED)
37394: int mem_base;
37395: int ret_val;
37396: int code; /* UCS code point */
37397: int n_code;
37398:
37399: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37400: mem_base = xmlMemBlocks();
37401: code = gen_int(n_code, 0);
37402:
37403: ret_val = xmlUCSIsBlockElements(code);
37404: desret_int(ret_val);
37405: call_tests++;
37406: des_int(n_code, code, 0);
37407: xmlResetLastError();
37408: if (mem_base != xmlMemBlocks()) {
37409: printf("Leak of %d blocks found in xmlUCSIsBlockElements",
37410: xmlMemBlocks() - mem_base);
37411: test_ret++;
37412: printf(" %d", n_code);
37413: printf("\n");
37414: }
37415: }
37416: function_tests++;
37417: #endif
37418:
37419: return(test_ret);
37420: }
37421:
37422:
37423: static int
37424: test_xmlUCSIsBopomofo(void) {
37425: int test_ret = 0;
37426:
37427: #if defined(LIBXML_UNICODE_ENABLED)
37428: int mem_base;
37429: int ret_val;
37430: int code; /* UCS code point */
37431: int n_code;
37432:
37433: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37434: mem_base = xmlMemBlocks();
37435: code = gen_int(n_code, 0);
37436:
37437: ret_val = xmlUCSIsBopomofo(code);
37438: desret_int(ret_val);
37439: call_tests++;
37440: des_int(n_code, code, 0);
37441: xmlResetLastError();
37442: if (mem_base != xmlMemBlocks()) {
37443: printf("Leak of %d blocks found in xmlUCSIsBopomofo",
37444: xmlMemBlocks() - mem_base);
37445: test_ret++;
37446: printf(" %d", n_code);
37447: printf("\n");
37448: }
37449: }
37450: function_tests++;
37451: #endif
37452:
37453: return(test_ret);
37454: }
37455:
37456:
37457: static int
37458: test_xmlUCSIsBopomofoExtended(void) {
37459: int test_ret = 0;
37460:
37461: #if defined(LIBXML_UNICODE_ENABLED)
37462: int mem_base;
37463: int ret_val;
37464: int code; /* UCS code point */
37465: int n_code;
37466:
37467: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37468: mem_base = xmlMemBlocks();
37469: code = gen_int(n_code, 0);
37470:
37471: ret_val = xmlUCSIsBopomofoExtended(code);
37472: desret_int(ret_val);
37473: call_tests++;
37474: des_int(n_code, code, 0);
37475: xmlResetLastError();
37476: if (mem_base != xmlMemBlocks()) {
37477: printf("Leak of %d blocks found in xmlUCSIsBopomofoExtended",
37478: xmlMemBlocks() - mem_base);
37479: test_ret++;
37480: printf(" %d", n_code);
37481: printf("\n");
37482: }
37483: }
37484: function_tests++;
37485: #endif
37486:
37487: return(test_ret);
37488: }
37489:
37490:
37491: static int
37492: test_xmlUCSIsBoxDrawing(void) {
37493: int test_ret = 0;
37494:
37495: #if defined(LIBXML_UNICODE_ENABLED)
37496: int mem_base;
37497: int ret_val;
37498: int code; /* UCS code point */
37499: int n_code;
37500:
37501: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37502: mem_base = xmlMemBlocks();
37503: code = gen_int(n_code, 0);
37504:
37505: ret_val = xmlUCSIsBoxDrawing(code);
37506: desret_int(ret_val);
37507: call_tests++;
37508: des_int(n_code, code, 0);
37509: xmlResetLastError();
37510: if (mem_base != xmlMemBlocks()) {
37511: printf("Leak of %d blocks found in xmlUCSIsBoxDrawing",
37512: xmlMemBlocks() - mem_base);
37513: test_ret++;
37514: printf(" %d", n_code);
37515: printf("\n");
37516: }
37517: }
37518: function_tests++;
37519: #endif
37520:
37521: return(test_ret);
37522: }
37523:
37524:
37525: static int
37526: test_xmlUCSIsBraillePatterns(void) {
37527: int test_ret = 0;
37528:
37529: #if defined(LIBXML_UNICODE_ENABLED)
37530: int mem_base;
37531: int ret_val;
37532: int code; /* UCS code point */
37533: int n_code;
37534:
37535: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37536: mem_base = xmlMemBlocks();
37537: code = gen_int(n_code, 0);
37538:
37539: ret_val = xmlUCSIsBraillePatterns(code);
37540: desret_int(ret_val);
37541: call_tests++;
37542: des_int(n_code, code, 0);
37543: xmlResetLastError();
37544: if (mem_base != xmlMemBlocks()) {
37545: printf("Leak of %d blocks found in xmlUCSIsBraillePatterns",
37546: xmlMemBlocks() - mem_base);
37547: test_ret++;
37548: printf(" %d", n_code);
37549: printf("\n");
37550: }
37551: }
37552: function_tests++;
37553: #endif
37554:
37555: return(test_ret);
37556: }
37557:
37558:
37559: static int
37560: test_xmlUCSIsBuhid(void) {
37561: int test_ret = 0;
37562:
37563: #if defined(LIBXML_UNICODE_ENABLED)
37564: int mem_base;
37565: int ret_val;
37566: int code; /* UCS code point */
37567: int n_code;
37568:
37569: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37570: mem_base = xmlMemBlocks();
37571: code = gen_int(n_code, 0);
37572:
37573: ret_val = xmlUCSIsBuhid(code);
37574: desret_int(ret_val);
37575: call_tests++;
37576: des_int(n_code, code, 0);
37577: xmlResetLastError();
37578: if (mem_base != xmlMemBlocks()) {
37579: printf("Leak of %d blocks found in xmlUCSIsBuhid",
37580: xmlMemBlocks() - mem_base);
37581: test_ret++;
37582: printf(" %d", n_code);
37583: printf("\n");
37584: }
37585: }
37586: function_tests++;
37587: #endif
37588:
37589: return(test_ret);
37590: }
37591:
37592:
37593: static int
37594: test_xmlUCSIsByzantineMusicalSymbols(void) {
37595: int test_ret = 0;
37596:
37597: #if defined(LIBXML_UNICODE_ENABLED)
37598: int mem_base;
37599: int ret_val;
37600: int code; /* UCS code point */
37601: int n_code;
37602:
37603: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37604: mem_base = xmlMemBlocks();
37605: code = gen_int(n_code, 0);
37606:
37607: ret_val = xmlUCSIsByzantineMusicalSymbols(code);
37608: desret_int(ret_val);
37609: call_tests++;
37610: des_int(n_code, code, 0);
37611: xmlResetLastError();
37612: if (mem_base != xmlMemBlocks()) {
37613: printf("Leak of %d blocks found in xmlUCSIsByzantineMusicalSymbols",
37614: xmlMemBlocks() - mem_base);
37615: test_ret++;
37616: printf(" %d", n_code);
37617: printf("\n");
37618: }
37619: }
37620: function_tests++;
37621: #endif
37622:
37623: return(test_ret);
37624: }
37625:
37626:
37627: static int
37628: test_xmlUCSIsCJKCompatibility(void) {
37629: int test_ret = 0;
37630:
37631: #if defined(LIBXML_UNICODE_ENABLED)
37632: int mem_base;
37633: int ret_val;
37634: int code; /* UCS code point */
37635: int n_code;
37636:
37637: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37638: mem_base = xmlMemBlocks();
37639: code = gen_int(n_code, 0);
37640:
37641: ret_val = xmlUCSIsCJKCompatibility(code);
37642: desret_int(ret_val);
37643: call_tests++;
37644: des_int(n_code, code, 0);
37645: xmlResetLastError();
37646: if (mem_base != xmlMemBlocks()) {
37647: printf("Leak of %d blocks found in xmlUCSIsCJKCompatibility",
37648: xmlMemBlocks() - mem_base);
37649: test_ret++;
37650: printf(" %d", n_code);
37651: printf("\n");
37652: }
37653: }
37654: function_tests++;
37655: #endif
37656:
37657: return(test_ret);
37658: }
37659:
37660:
37661: static int
37662: test_xmlUCSIsCJKCompatibilityForms(void) {
37663: int test_ret = 0;
37664:
37665: #if defined(LIBXML_UNICODE_ENABLED)
37666: int mem_base;
37667: int ret_val;
37668: int code; /* UCS code point */
37669: int n_code;
37670:
37671: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37672: mem_base = xmlMemBlocks();
37673: code = gen_int(n_code, 0);
37674:
37675: ret_val = xmlUCSIsCJKCompatibilityForms(code);
37676: desret_int(ret_val);
37677: call_tests++;
37678: des_int(n_code, code, 0);
37679: xmlResetLastError();
37680: if (mem_base != xmlMemBlocks()) {
37681: printf("Leak of %d blocks found in xmlUCSIsCJKCompatibilityForms",
37682: xmlMemBlocks() - mem_base);
37683: test_ret++;
37684: printf(" %d", n_code);
37685: printf("\n");
37686: }
37687: }
37688: function_tests++;
37689: #endif
37690:
37691: return(test_ret);
37692: }
37693:
37694:
37695: static int
37696: test_xmlUCSIsCJKCompatibilityIdeographs(void) {
37697: int test_ret = 0;
37698:
37699: #if defined(LIBXML_UNICODE_ENABLED)
37700: int mem_base;
37701: int ret_val;
37702: int code; /* UCS code point */
37703: int n_code;
37704:
37705: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37706: mem_base = xmlMemBlocks();
37707: code = gen_int(n_code, 0);
37708:
37709: ret_val = xmlUCSIsCJKCompatibilityIdeographs(code);
37710: desret_int(ret_val);
37711: call_tests++;
37712: des_int(n_code, code, 0);
37713: xmlResetLastError();
37714: if (mem_base != xmlMemBlocks()) {
37715: printf("Leak of %d blocks found in xmlUCSIsCJKCompatibilityIdeographs",
37716: xmlMemBlocks() - mem_base);
37717: test_ret++;
37718: printf(" %d", n_code);
37719: printf("\n");
37720: }
37721: }
37722: function_tests++;
37723: #endif
37724:
37725: return(test_ret);
37726: }
37727:
37728:
37729: static int
37730: test_xmlUCSIsCJKCompatibilityIdeographsSupplement(void) {
37731: int test_ret = 0;
37732:
37733: #if defined(LIBXML_UNICODE_ENABLED)
37734: int mem_base;
37735: int ret_val;
37736: int code; /* UCS code point */
37737: int n_code;
37738:
37739: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37740: mem_base = xmlMemBlocks();
37741: code = gen_int(n_code, 0);
37742:
37743: ret_val = xmlUCSIsCJKCompatibilityIdeographsSupplement(code);
37744: desret_int(ret_val);
37745: call_tests++;
37746: des_int(n_code, code, 0);
37747: xmlResetLastError();
37748: if (mem_base != xmlMemBlocks()) {
37749: printf("Leak of %d blocks found in xmlUCSIsCJKCompatibilityIdeographsSupplement",
37750: xmlMemBlocks() - mem_base);
37751: test_ret++;
37752: printf(" %d", n_code);
37753: printf("\n");
37754: }
37755: }
37756: function_tests++;
37757: #endif
37758:
37759: return(test_ret);
37760: }
37761:
37762:
37763: static int
37764: test_xmlUCSIsCJKRadicalsSupplement(void) {
37765: int test_ret = 0;
37766:
37767: #if defined(LIBXML_UNICODE_ENABLED)
37768: int mem_base;
37769: int ret_val;
37770: int code; /* UCS code point */
37771: int n_code;
37772:
37773: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37774: mem_base = xmlMemBlocks();
37775: code = gen_int(n_code, 0);
37776:
37777: ret_val = xmlUCSIsCJKRadicalsSupplement(code);
37778: desret_int(ret_val);
37779: call_tests++;
37780: des_int(n_code, code, 0);
37781: xmlResetLastError();
37782: if (mem_base != xmlMemBlocks()) {
37783: printf("Leak of %d blocks found in xmlUCSIsCJKRadicalsSupplement",
37784: xmlMemBlocks() - mem_base);
37785: test_ret++;
37786: printf(" %d", n_code);
37787: printf("\n");
37788: }
37789: }
37790: function_tests++;
37791: #endif
37792:
37793: return(test_ret);
37794: }
37795:
37796:
37797: static int
37798: test_xmlUCSIsCJKSymbolsandPunctuation(void) {
37799: int test_ret = 0;
37800:
37801: #if defined(LIBXML_UNICODE_ENABLED)
37802: int mem_base;
37803: int ret_val;
37804: int code; /* UCS code point */
37805: int n_code;
37806:
37807: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37808: mem_base = xmlMemBlocks();
37809: code = gen_int(n_code, 0);
37810:
37811: ret_val = xmlUCSIsCJKSymbolsandPunctuation(code);
37812: desret_int(ret_val);
37813: call_tests++;
37814: des_int(n_code, code, 0);
37815: xmlResetLastError();
37816: if (mem_base != xmlMemBlocks()) {
37817: printf("Leak of %d blocks found in xmlUCSIsCJKSymbolsandPunctuation",
37818: xmlMemBlocks() - mem_base);
37819: test_ret++;
37820: printf(" %d", n_code);
37821: printf("\n");
37822: }
37823: }
37824: function_tests++;
37825: #endif
37826:
37827: return(test_ret);
37828: }
37829:
37830:
37831: static int
37832: test_xmlUCSIsCJKUnifiedIdeographs(void) {
37833: int test_ret = 0;
37834:
37835: #if defined(LIBXML_UNICODE_ENABLED)
37836: int mem_base;
37837: int ret_val;
37838: int code; /* UCS code point */
37839: int n_code;
37840:
37841: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37842: mem_base = xmlMemBlocks();
37843: code = gen_int(n_code, 0);
37844:
37845: ret_val = xmlUCSIsCJKUnifiedIdeographs(code);
37846: desret_int(ret_val);
37847: call_tests++;
37848: des_int(n_code, code, 0);
37849: xmlResetLastError();
37850: if (mem_base != xmlMemBlocks()) {
37851: printf("Leak of %d blocks found in xmlUCSIsCJKUnifiedIdeographs",
37852: xmlMemBlocks() - mem_base);
37853: test_ret++;
37854: printf(" %d", n_code);
37855: printf("\n");
37856: }
37857: }
37858: function_tests++;
37859: #endif
37860:
37861: return(test_ret);
37862: }
37863:
37864:
37865: static int
37866: test_xmlUCSIsCJKUnifiedIdeographsExtensionA(void) {
37867: int test_ret = 0;
37868:
37869: #if defined(LIBXML_UNICODE_ENABLED)
37870: int mem_base;
37871: int ret_val;
37872: int code; /* UCS code point */
37873: int n_code;
37874:
37875: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37876: mem_base = xmlMemBlocks();
37877: code = gen_int(n_code, 0);
37878:
37879: ret_val = xmlUCSIsCJKUnifiedIdeographsExtensionA(code);
37880: desret_int(ret_val);
37881: call_tests++;
37882: des_int(n_code, code, 0);
37883: xmlResetLastError();
37884: if (mem_base != xmlMemBlocks()) {
37885: printf("Leak of %d blocks found in xmlUCSIsCJKUnifiedIdeographsExtensionA",
37886: xmlMemBlocks() - mem_base);
37887: test_ret++;
37888: printf(" %d", n_code);
37889: printf("\n");
37890: }
37891: }
37892: function_tests++;
37893: #endif
37894:
37895: return(test_ret);
37896: }
37897:
37898:
37899: static int
37900: test_xmlUCSIsCJKUnifiedIdeographsExtensionB(void) {
37901: int test_ret = 0;
37902:
37903: #if defined(LIBXML_UNICODE_ENABLED)
37904: int mem_base;
37905: int ret_val;
37906: int code; /* UCS code point */
37907: int n_code;
37908:
37909: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37910: mem_base = xmlMemBlocks();
37911: code = gen_int(n_code, 0);
37912:
37913: ret_val = xmlUCSIsCJKUnifiedIdeographsExtensionB(code);
37914: desret_int(ret_val);
37915: call_tests++;
37916: des_int(n_code, code, 0);
37917: xmlResetLastError();
37918: if (mem_base != xmlMemBlocks()) {
37919: printf("Leak of %d blocks found in xmlUCSIsCJKUnifiedIdeographsExtensionB",
37920: xmlMemBlocks() - mem_base);
37921: test_ret++;
37922: printf(" %d", n_code);
37923: printf("\n");
37924: }
37925: }
37926: function_tests++;
37927: #endif
37928:
37929: return(test_ret);
37930: }
37931:
37932:
37933: static int
37934: test_xmlUCSIsCat(void) {
37935: int test_ret = 0;
37936:
37937: #if defined(LIBXML_UNICODE_ENABLED)
37938: int mem_base;
37939: int ret_val;
37940: int code; /* UCS code point */
37941: int n_code;
37942: char * cat; /* UCS Category name */
37943: int n_cat;
37944:
37945: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37946: for (n_cat = 0;n_cat < gen_nb_const_char_ptr;n_cat++) {
37947: mem_base = xmlMemBlocks();
37948: code = gen_int(n_code, 0);
37949: cat = gen_const_char_ptr(n_cat, 1);
37950:
37951: ret_val = xmlUCSIsCat(code, (const char *)cat);
37952: desret_int(ret_val);
37953: call_tests++;
37954: des_int(n_code, code, 0);
37955: des_const_char_ptr(n_cat, (const char *)cat, 1);
37956: xmlResetLastError();
37957: if (mem_base != xmlMemBlocks()) {
37958: printf("Leak of %d blocks found in xmlUCSIsCat",
37959: xmlMemBlocks() - mem_base);
37960: test_ret++;
37961: printf(" %d", n_code);
37962: printf(" %d", n_cat);
37963: printf("\n");
37964: }
37965: }
37966: }
37967: function_tests++;
37968: #endif
37969:
37970: return(test_ret);
37971: }
37972:
37973:
37974: static int
37975: test_xmlUCSIsCatC(void) {
37976: int test_ret = 0;
37977:
37978: #if defined(LIBXML_UNICODE_ENABLED)
37979: int mem_base;
37980: int ret_val;
37981: int code; /* UCS code point */
37982: int n_code;
37983:
37984: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37985: mem_base = xmlMemBlocks();
37986: code = gen_int(n_code, 0);
37987:
37988: ret_val = xmlUCSIsCatC(code);
37989: desret_int(ret_val);
37990: call_tests++;
37991: des_int(n_code, code, 0);
37992: xmlResetLastError();
37993: if (mem_base != xmlMemBlocks()) {
37994: printf("Leak of %d blocks found in xmlUCSIsCatC",
37995: xmlMemBlocks() - mem_base);
37996: test_ret++;
37997: printf(" %d", n_code);
37998: printf("\n");
37999: }
38000: }
38001: function_tests++;
38002: #endif
38003:
38004: return(test_ret);
38005: }
38006:
38007:
38008: static int
38009: test_xmlUCSIsCatCc(void) {
38010: int test_ret = 0;
38011:
38012: #if defined(LIBXML_UNICODE_ENABLED)
38013: int mem_base;
38014: int ret_val;
38015: int code; /* UCS code point */
38016: int n_code;
38017:
38018: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38019: mem_base = xmlMemBlocks();
38020: code = gen_int(n_code, 0);
38021:
38022: ret_val = xmlUCSIsCatCc(code);
38023: desret_int(ret_val);
38024: call_tests++;
38025: des_int(n_code, code, 0);
38026: xmlResetLastError();
38027: if (mem_base != xmlMemBlocks()) {
38028: printf("Leak of %d blocks found in xmlUCSIsCatCc",
38029: xmlMemBlocks() - mem_base);
38030: test_ret++;
38031: printf(" %d", n_code);
38032: printf("\n");
38033: }
38034: }
38035: function_tests++;
38036: #endif
38037:
38038: return(test_ret);
38039: }
38040:
38041:
38042: static int
38043: test_xmlUCSIsCatCf(void) {
38044: int test_ret = 0;
38045:
38046: #if defined(LIBXML_UNICODE_ENABLED)
38047: int mem_base;
38048: int ret_val;
38049: int code; /* UCS code point */
38050: int n_code;
38051:
38052: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38053: mem_base = xmlMemBlocks();
38054: code = gen_int(n_code, 0);
38055:
38056: ret_val = xmlUCSIsCatCf(code);
38057: desret_int(ret_val);
38058: call_tests++;
38059: des_int(n_code, code, 0);
38060: xmlResetLastError();
38061: if (mem_base != xmlMemBlocks()) {
38062: printf("Leak of %d blocks found in xmlUCSIsCatCf",
38063: xmlMemBlocks() - mem_base);
38064: test_ret++;
38065: printf(" %d", n_code);
38066: printf("\n");
38067: }
38068: }
38069: function_tests++;
38070: #endif
38071:
38072: return(test_ret);
38073: }
38074:
38075:
38076: static int
38077: test_xmlUCSIsCatCo(void) {
38078: int test_ret = 0;
38079:
38080: #if defined(LIBXML_UNICODE_ENABLED)
38081: int mem_base;
38082: int ret_val;
38083: int code; /* UCS code point */
38084: int n_code;
38085:
38086: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38087: mem_base = xmlMemBlocks();
38088: code = gen_int(n_code, 0);
38089:
38090: ret_val = xmlUCSIsCatCo(code);
38091: desret_int(ret_val);
38092: call_tests++;
38093: des_int(n_code, code, 0);
38094: xmlResetLastError();
38095: if (mem_base != xmlMemBlocks()) {
38096: printf("Leak of %d blocks found in xmlUCSIsCatCo",
38097: xmlMemBlocks() - mem_base);
38098: test_ret++;
38099: printf(" %d", n_code);
38100: printf("\n");
38101: }
38102: }
38103: function_tests++;
38104: #endif
38105:
38106: return(test_ret);
38107: }
38108:
38109:
38110: static int
38111: test_xmlUCSIsCatCs(void) {
38112: int test_ret = 0;
38113:
38114: #if defined(LIBXML_UNICODE_ENABLED)
38115: int mem_base;
38116: int ret_val;
38117: int code; /* UCS code point */
38118: int n_code;
38119:
38120: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38121: mem_base = xmlMemBlocks();
38122: code = gen_int(n_code, 0);
38123:
38124: ret_val = xmlUCSIsCatCs(code);
38125: desret_int(ret_val);
38126: call_tests++;
38127: des_int(n_code, code, 0);
38128: xmlResetLastError();
38129: if (mem_base != xmlMemBlocks()) {
38130: printf("Leak of %d blocks found in xmlUCSIsCatCs",
38131: xmlMemBlocks() - mem_base);
38132: test_ret++;
38133: printf(" %d", n_code);
38134: printf("\n");
38135: }
38136: }
38137: function_tests++;
38138: #endif
38139:
38140: return(test_ret);
38141: }
38142:
38143:
38144: static int
38145: test_xmlUCSIsCatL(void) {
38146: int test_ret = 0;
38147:
38148: #if defined(LIBXML_UNICODE_ENABLED)
38149: int mem_base;
38150: int ret_val;
38151: int code; /* UCS code point */
38152: int n_code;
38153:
38154: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38155: mem_base = xmlMemBlocks();
38156: code = gen_int(n_code, 0);
38157:
38158: ret_val = xmlUCSIsCatL(code);
38159: desret_int(ret_val);
38160: call_tests++;
38161: des_int(n_code, code, 0);
38162: xmlResetLastError();
38163: if (mem_base != xmlMemBlocks()) {
38164: printf("Leak of %d blocks found in xmlUCSIsCatL",
38165: xmlMemBlocks() - mem_base);
38166: test_ret++;
38167: printf(" %d", n_code);
38168: printf("\n");
38169: }
38170: }
38171: function_tests++;
38172: #endif
38173:
38174: return(test_ret);
38175: }
38176:
38177:
38178: static int
38179: test_xmlUCSIsCatLl(void) {
38180: int test_ret = 0;
38181:
38182: #if defined(LIBXML_UNICODE_ENABLED)
38183: int mem_base;
38184: int ret_val;
38185: int code; /* UCS code point */
38186: int n_code;
38187:
38188: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38189: mem_base = xmlMemBlocks();
38190: code = gen_int(n_code, 0);
38191:
38192: ret_val = xmlUCSIsCatLl(code);
38193: desret_int(ret_val);
38194: call_tests++;
38195: des_int(n_code, code, 0);
38196: xmlResetLastError();
38197: if (mem_base != xmlMemBlocks()) {
38198: printf("Leak of %d blocks found in xmlUCSIsCatLl",
38199: xmlMemBlocks() - mem_base);
38200: test_ret++;
38201: printf(" %d", n_code);
38202: printf("\n");
38203: }
38204: }
38205: function_tests++;
38206: #endif
38207:
38208: return(test_ret);
38209: }
38210:
38211:
38212: static int
38213: test_xmlUCSIsCatLm(void) {
38214: int test_ret = 0;
38215:
38216: #if defined(LIBXML_UNICODE_ENABLED)
38217: int mem_base;
38218: int ret_val;
38219: int code; /* UCS code point */
38220: int n_code;
38221:
38222: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38223: mem_base = xmlMemBlocks();
38224: code = gen_int(n_code, 0);
38225:
38226: ret_val = xmlUCSIsCatLm(code);
38227: desret_int(ret_val);
38228: call_tests++;
38229: des_int(n_code, code, 0);
38230: xmlResetLastError();
38231: if (mem_base != xmlMemBlocks()) {
38232: printf("Leak of %d blocks found in xmlUCSIsCatLm",
38233: xmlMemBlocks() - mem_base);
38234: test_ret++;
38235: printf(" %d", n_code);
38236: printf("\n");
38237: }
38238: }
38239: function_tests++;
38240: #endif
38241:
38242: return(test_ret);
38243: }
38244:
38245:
38246: static int
38247: test_xmlUCSIsCatLo(void) {
38248: int test_ret = 0;
38249:
38250: #if defined(LIBXML_UNICODE_ENABLED)
38251: int mem_base;
38252: int ret_val;
38253: int code; /* UCS code point */
38254: int n_code;
38255:
38256: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38257: mem_base = xmlMemBlocks();
38258: code = gen_int(n_code, 0);
38259:
38260: ret_val = xmlUCSIsCatLo(code);
38261: desret_int(ret_val);
38262: call_tests++;
38263: des_int(n_code, code, 0);
38264: xmlResetLastError();
38265: if (mem_base != xmlMemBlocks()) {
38266: printf("Leak of %d blocks found in xmlUCSIsCatLo",
38267: xmlMemBlocks() - mem_base);
38268: test_ret++;
38269: printf(" %d", n_code);
38270: printf("\n");
38271: }
38272: }
38273: function_tests++;
38274: #endif
38275:
38276: return(test_ret);
38277: }
38278:
38279:
38280: static int
38281: test_xmlUCSIsCatLt(void) {
38282: int test_ret = 0;
38283:
38284: #if defined(LIBXML_UNICODE_ENABLED)
38285: int mem_base;
38286: int ret_val;
38287: int code; /* UCS code point */
38288: int n_code;
38289:
38290: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38291: mem_base = xmlMemBlocks();
38292: code = gen_int(n_code, 0);
38293:
38294: ret_val = xmlUCSIsCatLt(code);
38295: desret_int(ret_val);
38296: call_tests++;
38297: des_int(n_code, code, 0);
38298: xmlResetLastError();
38299: if (mem_base != xmlMemBlocks()) {
38300: printf("Leak of %d blocks found in xmlUCSIsCatLt",
38301: xmlMemBlocks() - mem_base);
38302: test_ret++;
38303: printf(" %d", n_code);
38304: printf("\n");
38305: }
38306: }
38307: function_tests++;
38308: #endif
38309:
38310: return(test_ret);
38311: }
38312:
38313:
38314: static int
38315: test_xmlUCSIsCatLu(void) {
38316: int test_ret = 0;
38317:
38318: #if defined(LIBXML_UNICODE_ENABLED)
38319: int mem_base;
38320: int ret_val;
38321: int code; /* UCS code point */
38322: int n_code;
38323:
38324: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38325: mem_base = xmlMemBlocks();
38326: code = gen_int(n_code, 0);
38327:
38328: ret_val = xmlUCSIsCatLu(code);
38329: desret_int(ret_val);
38330: call_tests++;
38331: des_int(n_code, code, 0);
38332: xmlResetLastError();
38333: if (mem_base != xmlMemBlocks()) {
38334: printf("Leak of %d blocks found in xmlUCSIsCatLu",
38335: xmlMemBlocks() - mem_base);
38336: test_ret++;
38337: printf(" %d", n_code);
38338: printf("\n");
38339: }
38340: }
38341: function_tests++;
38342: #endif
38343:
38344: return(test_ret);
38345: }
38346:
38347:
38348: static int
38349: test_xmlUCSIsCatM(void) {
38350: int test_ret = 0;
38351:
38352: #if defined(LIBXML_UNICODE_ENABLED)
38353: int mem_base;
38354: int ret_val;
38355: int code; /* UCS code point */
38356: int n_code;
38357:
38358: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38359: mem_base = xmlMemBlocks();
38360: code = gen_int(n_code, 0);
38361:
38362: ret_val = xmlUCSIsCatM(code);
38363: desret_int(ret_val);
38364: call_tests++;
38365: des_int(n_code, code, 0);
38366: xmlResetLastError();
38367: if (mem_base != xmlMemBlocks()) {
38368: printf("Leak of %d blocks found in xmlUCSIsCatM",
38369: xmlMemBlocks() - mem_base);
38370: test_ret++;
38371: printf(" %d", n_code);
38372: printf("\n");
38373: }
38374: }
38375: function_tests++;
38376: #endif
38377:
38378: return(test_ret);
38379: }
38380:
38381:
38382: static int
38383: test_xmlUCSIsCatMc(void) {
38384: int test_ret = 0;
38385:
38386: #if defined(LIBXML_UNICODE_ENABLED)
38387: int mem_base;
38388: int ret_val;
38389: int code; /* UCS code point */
38390: int n_code;
38391:
38392: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38393: mem_base = xmlMemBlocks();
38394: code = gen_int(n_code, 0);
38395:
38396: ret_val = xmlUCSIsCatMc(code);
38397: desret_int(ret_val);
38398: call_tests++;
38399: des_int(n_code, code, 0);
38400: xmlResetLastError();
38401: if (mem_base != xmlMemBlocks()) {
38402: printf("Leak of %d blocks found in xmlUCSIsCatMc",
38403: xmlMemBlocks() - mem_base);
38404: test_ret++;
38405: printf(" %d", n_code);
38406: printf("\n");
38407: }
38408: }
38409: function_tests++;
38410: #endif
38411:
38412: return(test_ret);
38413: }
38414:
38415:
38416: static int
38417: test_xmlUCSIsCatMe(void) {
38418: int test_ret = 0;
38419:
38420: #if defined(LIBXML_UNICODE_ENABLED)
38421: int mem_base;
38422: int ret_val;
38423: int code; /* UCS code point */
38424: int n_code;
38425:
38426: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38427: mem_base = xmlMemBlocks();
38428: code = gen_int(n_code, 0);
38429:
38430: ret_val = xmlUCSIsCatMe(code);
38431: desret_int(ret_val);
38432: call_tests++;
38433: des_int(n_code, code, 0);
38434: xmlResetLastError();
38435: if (mem_base != xmlMemBlocks()) {
38436: printf("Leak of %d blocks found in xmlUCSIsCatMe",
38437: xmlMemBlocks() - mem_base);
38438: test_ret++;
38439: printf(" %d", n_code);
38440: printf("\n");
38441: }
38442: }
38443: function_tests++;
38444: #endif
38445:
38446: return(test_ret);
38447: }
38448:
38449:
38450: static int
38451: test_xmlUCSIsCatMn(void) {
38452: int test_ret = 0;
38453:
38454: #if defined(LIBXML_UNICODE_ENABLED)
38455: int mem_base;
38456: int ret_val;
38457: int code; /* UCS code point */
38458: int n_code;
38459:
38460: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38461: mem_base = xmlMemBlocks();
38462: code = gen_int(n_code, 0);
38463:
38464: ret_val = xmlUCSIsCatMn(code);
38465: desret_int(ret_val);
38466: call_tests++;
38467: des_int(n_code, code, 0);
38468: xmlResetLastError();
38469: if (mem_base != xmlMemBlocks()) {
38470: printf("Leak of %d blocks found in xmlUCSIsCatMn",
38471: xmlMemBlocks() - mem_base);
38472: test_ret++;
38473: printf(" %d", n_code);
38474: printf("\n");
38475: }
38476: }
38477: function_tests++;
38478: #endif
38479:
38480: return(test_ret);
38481: }
38482:
38483:
38484: static int
38485: test_xmlUCSIsCatN(void) {
38486: int test_ret = 0;
38487:
38488: #if defined(LIBXML_UNICODE_ENABLED)
38489: int mem_base;
38490: int ret_val;
38491: int code; /* UCS code point */
38492: int n_code;
38493:
38494: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38495: mem_base = xmlMemBlocks();
38496: code = gen_int(n_code, 0);
38497:
38498: ret_val = xmlUCSIsCatN(code);
38499: desret_int(ret_val);
38500: call_tests++;
38501: des_int(n_code, code, 0);
38502: xmlResetLastError();
38503: if (mem_base != xmlMemBlocks()) {
38504: printf("Leak of %d blocks found in xmlUCSIsCatN",
38505: xmlMemBlocks() - mem_base);
38506: test_ret++;
38507: printf(" %d", n_code);
38508: printf("\n");
38509: }
38510: }
38511: function_tests++;
38512: #endif
38513:
38514: return(test_ret);
38515: }
38516:
38517:
38518: static int
38519: test_xmlUCSIsCatNd(void) {
38520: int test_ret = 0;
38521:
38522: #if defined(LIBXML_UNICODE_ENABLED)
38523: int mem_base;
38524: int ret_val;
38525: int code; /* UCS code point */
38526: int n_code;
38527:
38528: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38529: mem_base = xmlMemBlocks();
38530: code = gen_int(n_code, 0);
38531:
38532: ret_val = xmlUCSIsCatNd(code);
38533: desret_int(ret_val);
38534: call_tests++;
38535: des_int(n_code, code, 0);
38536: xmlResetLastError();
38537: if (mem_base != xmlMemBlocks()) {
38538: printf("Leak of %d blocks found in xmlUCSIsCatNd",
38539: xmlMemBlocks() - mem_base);
38540: test_ret++;
38541: printf(" %d", n_code);
38542: printf("\n");
38543: }
38544: }
38545: function_tests++;
38546: #endif
38547:
38548: return(test_ret);
38549: }
38550:
38551:
38552: static int
38553: test_xmlUCSIsCatNl(void) {
38554: int test_ret = 0;
38555:
38556: #if defined(LIBXML_UNICODE_ENABLED)
38557: int mem_base;
38558: int ret_val;
38559: int code; /* UCS code point */
38560: int n_code;
38561:
38562: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38563: mem_base = xmlMemBlocks();
38564: code = gen_int(n_code, 0);
38565:
38566: ret_val = xmlUCSIsCatNl(code);
38567: desret_int(ret_val);
38568: call_tests++;
38569: des_int(n_code, code, 0);
38570: xmlResetLastError();
38571: if (mem_base != xmlMemBlocks()) {
38572: printf("Leak of %d blocks found in xmlUCSIsCatNl",
38573: xmlMemBlocks() - mem_base);
38574: test_ret++;
38575: printf(" %d", n_code);
38576: printf("\n");
38577: }
38578: }
38579: function_tests++;
38580: #endif
38581:
38582: return(test_ret);
38583: }
38584:
38585:
38586: static int
38587: test_xmlUCSIsCatNo(void) {
38588: int test_ret = 0;
38589:
38590: #if defined(LIBXML_UNICODE_ENABLED)
38591: int mem_base;
38592: int ret_val;
38593: int code; /* UCS code point */
38594: int n_code;
38595:
38596: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38597: mem_base = xmlMemBlocks();
38598: code = gen_int(n_code, 0);
38599:
38600: ret_val = xmlUCSIsCatNo(code);
38601: desret_int(ret_val);
38602: call_tests++;
38603: des_int(n_code, code, 0);
38604: xmlResetLastError();
38605: if (mem_base != xmlMemBlocks()) {
38606: printf("Leak of %d blocks found in xmlUCSIsCatNo",
38607: xmlMemBlocks() - mem_base);
38608: test_ret++;
38609: printf(" %d", n_code);
38610: printf("\n");
38611: }
38612: }
38613: function_tests++;
38614: #endif
38615:
38616: return(test_ret);
38617: }
38618:
38619:
38620: static int
38621: test_xmlUCSIsCatP(void) {
38622: int test_ret = 0;
38623:
38624: #if defined(LIBXML_UNICODE_ENABLED)
38625: int mem_base;
38626: int ret_val;
38627: int code; /* UCS code point */
38628: int n_code;
38629:
38630: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38631: mem_base = xmlMemBlocks();
38632: code = gen_int(n_code, 0);
38633:
38634: ret_val = xmlUCSIsCatP(code);
38635: desret_int(ret_val);
38636: call_tests++;
38637: des_int(n_code, code, 0);
38638: xmlResetLastError();
38639: if (mem_base != xmlMemBlocks()) {
38640: printf("Leak of %d blocks found in xmlUCSIsCatP",
38641: xmlMemBlocks() - mem_base);
38642: test_ret++;
38643: printf(" %d", n_code);
38644: printf("\n");
38645: }
38646: }
38647: function_tests++;
38648: #endif
38649:
38650: return(test_ret);
38651: }
38652:
38653:
38654: static int
38655: test_xmlUCSIsCatPc(void) {
38656: int test_ret = 0;
38657:
38658: #if defined(LIBXML_UNICODE_ENABLED)
38659: int mem_base;
38660: int ret_val;
38661: int code; /* UCS code point */
38662: int n_code;
38663:
38664: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38665: mem_base = xmlMemBlocks();
38666: code = gen_int(n_code, 0);
38667:
38668: ret_val = xmlUCSIsCatPc(code);
38669: desret_int(ret_val);
38670: call_tests++;
38671: des_int(n_code, code, 0);
38672: xmlResetLastError();
38673: if (mem_base != xmlMemBlocks()) {
38674: printf("Leak of %d blocks found in xmlUCSIsCatPc",
38675: xmlMemBlocks() - mem_base);
38676: test_ret++;
38677: printf(" %d", n_code);
38678: printf("\n");
38679: }
38680: }
38681: function_tests++;
38682: #endif
38683:
38684: return(test_ret);
38685: }
38686:
38687:
38688: static int
38689: test_xmlUCSIsCatPd(void) {
38690: int test_ret = 0;
38691:
38692: #if defined(LIBXML_UNICODE_ENABLED)
38693: int mem_base;
38694: int ret_val;
38695: int code; /* UCS code point */
38696: int n_code;
38697:
38698: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38699: mem_base = xmlMemBlocks();
38700: code = gen_int(n_code, 0);
38701:
38702: ret_val = xmlUCSIsCatPd(code);
38703: desret_int(ret_val);
38704: call_tests++;
38705: des_int(n_code, code, 0);
38706: xmlResetLastError();
38707: if (mem_base != xmlMemBlocks()) {
38708: printf("Leak of %d blocks found in xmlUCSIsCatPd",
38709: xmlMemBlocks() - mem_base);
38710: test_ret++;
38711: printf(" %d", n_code);
38712: printf("\n");
38713: }
38714: }
38715: function_tests++;
38716: #endif
38717:
38718: return(test_ret);
38719: }
38720:
38721:
38722: static int
38723: test_xmlUCSIsCatPe(void) {
38724: int test_ret = 0;
38725:
38726: #if defined(LIBXML_UNICODE_ENABLED)
38727: int mem_base;
38728: int ret_val;
38729: int code; /* UCS code point */
38730: int n_code;
38731:
38732: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38733: mem_base = xmlMemBlocks();
38734: code = gen_int(n_code, 0);
38735:
38736: ret_val = xmlUCSIsCatPe(code);
38737: desret_int(ret_val);
38738: call_tests++;
38739: des_int(n_code, code, 0);
38740: xmlResetLastError();
38741: if (mem_base != xmlMemBlocks()) {
38742: printf("Leak of %d blocks found in xmlUCSIsCatPe",
38743: xmlMemBlocks() - mem_base);
38744: test_ret++;
38745: printf(" %d", n_code);
38746: printf("\n");
38747: }
38748: }
38749: function_tests++;
38750: #endif
38751:
38752: return(test_ret);
38753: }
38754:
38755:
38756: static int
38757: test_xmlUCSIsCatPf(void) {
38758: int test_ret = 0;
38759:
38760: #if defined(LIBXML_UNICODE_ENABLED)
38761: int mem_base;
38762: int ret_val;
38763: int code; /* UCS code point */
38764: int n_code;
38765:
38766: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38767: mem_base = xmlMemBlocks();
38768: code = gen_int(n_code, 0);
38769:
38770: ret_val = xmlUCSIsCatPf(code);
38771: desret_int(ret_val);
38772: call_tests++;
38773: des_int(n_code, code, 0);
38774: xmlResetLastError();
38775: if (mem_base != xmlMemBlocks()) {
38776: printf("Leak of %d blocks found in xmlUCSIsCatPf",
38777: xmlMemBlocks() - mem_base);
38778: test_ret++;
38779: printf(" %d", n_code);
38780: printf("\n");
38781: }
38782: }
38783: function_tests++;
38784: #endif
38785:
38786: return(test_ret);
38787: }
38788:
38789:
38790: static int
38791: test_xmlUCSIsCatPi(void) {
38792: int test_ret = 0;
38793:
38794: #if defined(LIBXML_UNICODE_ENABLED)
38795: int mem_base;
38796: int ret_val;
38797: int code; /* UCS code point */
38798: int n_code;
38799:
38800: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38801: mem_base = xmlMemBlocks();
38802: code = gen_int(n_code, 0);
38803:
38804: ret_val = xmlUCSIsCatPi(code);
38805: desret_int(ret_val);
38806: call_tests++;
38807: des_int(n_code, code, 0);
38808: xmlResetLastError();
38809: if (mem_base != xmlMemBlocks()) {
38810: printf("Leak of %d blocks found in xmlUCSIsCatPi",
38811: xmlMemBlocks() - mem_base);
38812: test_ret++;
38813: printf(" %d", n_code);
38814: printf("\n");
38815: }
38816: }
38817: function_tests++;
38818: #endif
38819:
38820: return(test_ret);
38821: }
38822:
38823:
38824: static int
38825: test_xmlUCSIsCatPo(void) {
38826: int test_ret = 0;
38827:
38828: #if defined(LIBXML_UNICODE_ENABLED)
38829: int mem_base;
38830: int ret_val;
38831: int code; /* UCS code point */
38832: int n_code;
38833:
38834: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38835: mem_base = xmlMemBlocks();
38836: code = gen_int(n_code, 0);
38837:
38838: ret_val = xmlUCSIsCatPo(code);
38839: desret_int(ret_val);
38840: call_tests++;
38841: des_int(n_code, code, 0);
38842: xmlResetLastError();
38843: if (mem_base != xmlMemBlocks()) {
38844: printf("Leak of %d blocks found in xmlUCSIsCatPo",
38845: xmlMemBlocks() - mem_base);
38846: test_ret++;
38847: printf(" %d", n_code);
38848: printf("\n");
38849: }
38850: }
38851: function_tests++;
38852: #endif
38853:
38854: return(test_ret);
38855: }
38856:
38857:
38858: static int
38859: test_xmlUCSIsCatPs(void) {
38860: int test_ret = 0;
38861:
38862: #if defined(LIBXML_UNICODE_ENABLED)
38863: int mem_base;
38864: int ret_val;
38865: int code; /* UCS code point */
38866: int n_code;
38867:
38868: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38869: mem_base = xmlMemBlocks();
38870: code = gen_int(n_code, 0);
38871:
38872: ret_val = xmlUCSIsCatPs(code);
38873: desret_int(ret_val);
38874: call_tests++;
38875: des_int(n_code, code, 0);
38876: xmlResetLastError();
38877: if (mem_base != xmlMemBlocks()) {
38878: printf("Leak of %d blocks found in xmlUCSIsCatPs",
38879: xmlMemBlocks() - mem_base);
38880: test_ret++;
38881: printf(" %d", n_code);
38882: printf("\n");
38883: }
38884: }
38885: function_tests++;
38886: #endif
38887:
38888: return(test_ret);
38889: }
38890:
38891:
38892: static int
38893: test_xmlUCSIsCatS(void) {
38894: int test_ret = 0;
38895:
38896: #if defined(LIBXML_UNICODE_ENABLED)
38897: int mem_base;
38898: int ret_val;
38899: int code; /* UCS code point */
38900: int n_code;
38901:
38902: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38903: mem_base = xmlMemBlocks();
38904: code = gen_int(n_code, 0);
38905:
38906: ret_val = xmlUCSIsCatS(code);
38907: desret_int(ret_val);
38908: call_tests++;
38909: des_int(n_code, code, 0);
38910: xmlResetLastError();
38911: if (mem_base != xmlMemBlocks()) {
38912: printf("Leak of %d blocks found in xmlUCSIsCatS",
38913: xmlMemBlocks() - mem_base);
38914: test_ret++;
38915: printf(" %d", n_code);
38916: printf("\n");
38917: }
38918: }
38919: function_tests++;
38920: #endif
38921:
38922: return(test_ret);
38923: }
38924:
38925:
38926: static int
38927: test_xmlUCSIsCatSc(void) {
38928: int test_ret = 0;
38929:
38930: #if defined(LIBXML_UNICODE_ENABLED)
38931: int mem_base;
38932: int ret_val;
38933: int code; /* UCS code point */
38934: int n_code;
38935:
38936: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38937: mem_base = xmlMemBlocks();
38938: code = gen_int(n_code, 0);
38939:
38940: ret_val = xmlUCSIsCatSc(code);
38941: desret_int(ret_val);
38942: call_tests++;
38943: des_int(n_code, code, 0);
38944: xmlResetLastError();
38945: if (mem_base != xmlMemBlocks()) {
38946: printf("Leak of %d blocks found in xmlUCSIsCatSc",
38947: xmlMemBlocks() - mem_base);
38948: test_ret++;
38949: printf(" %d", n_code);
38950: printf("\n");
38951: }
38952: }
38953: function_tests++;
38954: #endif
38955:
38956: return(test_ret);
38957: }
38958:
38959:
38960: static int
38961: test_xmlUCSIsCatSk(void) {
38962: int test_ret = 0;
38963:
38964: #if defined(LIBXML_UNICODE_ENABLED)
38965: int mem_base;
38966: int ret_val;
38967: int code; /* UCS code point */
38968: int n_code;
38969:
38970: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38971: mem_base = xmlMemBlocks();
38972: code = gen_int(n_code, 0);
38973:
38974: ret_val = xmlUCSIsCatSk(code);
38975: desret_int(ret_val);
38976: call_tests++;
38977: des_int(n_code, code, 0);
38978: xmlResetLastError();
38979: if (mem_base != xmlMemBlocks()) {
38980: printf("Leak of %d blocks found in xmlUCSIsCatSk",
38981: xmlMemBlocks() - mem_base);
38982: test_ret++;
38983: printf(" %d", n_code);
38984: printf("\n");
38985: }
38986: }
38987: function_tests++;
38988: #endif
38989:
38990: return(test_ret);
38991: }
38992:
38993:
38994: static int
38995: test_xmlUCSIsCatSm(void) {
38996: int test_ret = 0;
38997:
38998: #if defined(LIBXML_UNICODE_ENABLED)
38999: int mem_base;
39000: int ret_val;
39001: int code; /* UCS code point */
39002: int n_code;
39003:
39004: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39005: mem_base = xmlMemBlocks();
39006: code = gen_int(n_code, 0);
39007:
39008: ret_val = xmlUCSIsCatSm(code);
39009: desret_int(ret_val);
39010: call_tests++;
39011: des_int(n_code, code, 0);
39012: xmlResetLastError();
39013: if (mem_base != xmlMemBlocks()) {
39014: printf("Leak of %d blocks found in xmlUCSIsCatSm",
39015: xmlMemBlocks() - mem_base);
39016: test_ret++;
39017: printf(" %d", n_code);
39018: printf("\n");
39019: }
39020: }
39021: function_tests++;
39022: #endif
39023:
39024: return(test_ret);
39025: }
39026:
39027:
39028: static int
39029: test_xmlUCSIsCatSo(void) {
39030: int test_ret = 0;
39031:
39032: #if defined(LIBXML_UNICODE_ENABLED)
39033: int mem_base;
39034: int ret_val;
39035: int code; /* UCS code point */
39036: int n_code;
39037:
39038: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39039: mem_base = xmlMemBlocks();
39040: code = gen_int(n_code, 0);
39041:
39042: ret_val = xmlUCSIsCatSo(code);
39043: desret_int(ret_val);
39044: call_tests++;
39045: des_int(n_code, code, 0);
39046: xmlResetLastError();
39047: if (mem_base != xmlMemBlocks()) {
39048: printf("Leak of %d blocks found in xmlUCSIsCatSo",
39049: xmlMemBlocks() - mem_base);
39050: test_ret++;
39051: printf(" %d", n_code);
39052: printf("\n");
39053: }
39054: }
39055: function_tests++;
39056: #endif
39057:
39058: return(test_ret);
39059: }
39060:
39061:
39062: static int
39063: test_xmlUCSIsCatZ(void) {
39064: int test_ret = 0;
39065:
39066: #if defined(LIBXML_UNICODE_ENABLED)
39067: int mem_base;
39068: int ret_val;
39069: int code; /* UCS code point */
39070: int n_code;
39071:
39072: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39073: mem_base = xmlMemBlocks();
39074: code = gen_int(n_code, 0);
39075:
39076: ret_val = xmlUCSIsCatZ(code);
39077: desret_int(ret_val);
39078: call_tests++;
39079: des_int(n_code, code, 0);
39080: xmlResetLastError();
39081: if (mem_base != xmlMemBlocks()) {
39082: printf("Leak of %d blocks found in xmlUCSIsCatZ",
39083: xmlMemBlocks() - mem_base);
39084: test_ret++;
39085: printf(" %d", n_code);
39086: printf("\n");
39087: }
39088: }
39089: function_tests++;
39090: #endif
39091:
39092: return(test_ret);
39093: }
39094:
39095:
39096: static int
39097: test_xmlUCSIsCatZl(void) {
39098: int test_ret = 0;
39099:
39100: #if defined(LIBXML_UNICODE_ENABLED)
39101: int mem_base;
39102: int ret_val;
39103: int code; /* UCS code point */
39104: int n_code;
39105:
39106: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39107: mem_base = xmlMemBlocks();
39108: code = gen_int(n_code, 0);
39109:
39110: ret_val = xmlUCSIsCatZl(code);
39111: desret_int(ret_val);
39112: call_tests++;
39113: des_int(n_code, code, 0);
39114: xmlResetLastError();
39115: if (mem_base != xmlMemBlocks()) {
39116: printf("Leak of %d blocks found in xmlUCSIsCatZl",
39117: xmlMemBlocks() - mem_base);
39118: test_ret++;
39119: printf(" %d", n_code);
39120: printf("\n");
39121: }
39122: }
39123: function_tests++;
39124: #endif
39125:
39126: return(test_ret);
39127: }
39128:
39129:
39130: static int
39131: test_xmlUCSIsCatZp(void) {
39132: int test_ret = 0;
39133:
39134: #if defined(LIBXML_UNICODE_ENABLED)
39135: int mem_base;
39136: int ret_val;
39137: int code; /* UCS code point */
39138: int n_code;
39139:
39140: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39141: mem_base = xmlMemBlocks();
39142: code = gen_int(n_code, 0);
39143:
39144: ret_val = xmlUCSIsCatZp(code);
39145: desret_int(ret_val);
39146: call_tests++;
39147: des_int(n_code, code, 0);
39148: xmlResetLastError();
39149: if (mem_base != xmlMemBlocks()) {
39150: printf("Leak of %d blocks found in xmlUCSIsCatZp",
39151: xmlMemBlocks() - mem_base);
39152: test_ret++;
39153: printf(" %d", n_code);
39154: printf("\n");
39155: }
39156: }
39157: function_tests++;
39158: #endif
39159:
39160: return(test_ret);
39161: }
39162:
39163:
39164: static int
39165: test_xmlUCSIsCatZs(void) {
39166: int test_ret = 0;
39167:
39168: #if defined(LIBXML_UNICODE_ENABLED)
39169: int mem_base;
39170: int ret_val;
39171: int code; /* UCS code point */
39172: int n_code;
39173:
39174: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39175: mem_base = xmlMemBlocks();
39176: code = gen_int(n_code, 0);
39177:
39178: ret_val = xmlUCSIsCatZs(code);
39179: desret_int(ret_val);
39180: call_tests++;
39181: des_int(n_code, code, 0);
39182: xmlResetLastError();
39183: if (mem_base != xmlMemBlocks()) {
39184: printf("Leak of %d blocks found in xmlUCSIsCatZs",
39185: xmlMemBlocks() - mem_base);
39186: test_ret++;
39187: printf(" %d", n_code);
39188: printf("\n");
39189: }
39190: }
39191: function_tests++;
39192: #endif
39193:
39194: return(test_ret);
39195: }
39196:
39197:
39198: static int
39199: test_xmlUCSIsCherokee(void) {
39200: int test_ret = 0;
39201:
39202: #if defined(LIBXML_UNICODE_ENABLED)
39203: int mem_base;
39204: int ret_val;
39205: int code; /* UCS code point */
39206: int n_code;
39207:
39208: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39209: mem_base = xmlMemBlocks();
39210: code = gen_int(n_code, 0);
39211:
39212: ret_val = xmlUCSIsCherokee(code);
39213: desret_int(ret_val);
39214: call_tests++;
39215: des_int(n_code, code, 0);
39216: xmlResetLastError();
39217: if (mem_base != xmlMemBlocks()) {
39218: printf("Leak of %d blocks found in xmlUCSIsCherokee",
39219: xmlMemBlocks() - mem_base);
39220: test_ret++;
39221: printf(" %d", n_code);
39222: printf("\n");
39223: }
39224: }
39225: function_tests++;
39226: #endif
39227:
39228: return(test_ret);
39229: }
39230:
39231:
39232: static int
39233: test_xmlUCSIsCombiningDiacriticalMarks(void) {
39234: int test_ret = 0;
39235:
39236: #if defined(LIBXML_UNICODE_ENABLED)
39237: int mem_base;
39238: int ret_val;
39239: int code; /* UCS code point */
39240: int n_code;
39241:
39242: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39243: mem_base = xmlMemBlocks();
39244: code = gen_int(n_code, 0);
39245:
39246: ret_val = xmlUCSIsCombiningDiacriticalMarks(code);
39247: desret_int(ret_val);
39248: call_tests++;
39249: des_int(n_code, code, 0);
39250: xmlResetLastError();
39251: if (mem_base != xmlMemBlocks()) {
39252: printf("Leak of %d blocks found in xmlUCSIsCombiningDiacriticalMarks",
39253: xmlMemBlocks() - mem_base);
39254: test_ret++;
39255: printf(" %d", n_code);
39256: printf("\n");
39257: }
39258: }
39259: function_tests++;
39260: #endif
39261:
39262: return(test_ret);
39263: }
39264:
39265:
39266: static int
39267: test_xmlUCSIsCombiningDiacriticalMarksforSymbols(void) {
39268: int test_ret = 0;
39269:
39270: #if defined(LIBXML_UNICODE_ENABLED)
39271: int mem_base;
39272: int ret_val;
39273: int code; /* UCS code point */
39274: int n_code;
39275:
39276: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39277: mem_base = xmlMemBlocks();
39278: code = gen_int(n_code, 0);
39279:
39280: ret_val = xmlUCSIsCombiningDiacriticalMarksforSymbols(code);
39281: desret_int(ret_val);
39282: call_tests++;
39283: des_int(n_code, code, 0);
39284: xmlResetLastError();
39285: if (mem_base != xmlMemBlocks()) {
39286: printf("Leak of %d blocks found in xmlUCSIsCombiningDiacriticalMarksforSymbols",
39287: xmlMemBlocks() - mem_base);
39288: test_ret++;
39289: printf(" %d", n_code);
39290: printf("\n");
39291: }
39292: }
39293: function_tests++;
39294: #endif
39295:
39296: return(test_ret);
39297: }
39298:
39299:
39300: static int
39301: test_xmlUCSIsCombiningHalfMarks(void) {
39302: int test_ret = 0;
39303:
39304: #if defined(LIBXML_UNICODE_ENABLED)
39305: int mem_base;
39306: int ret_val;
39307: int code; /* UCS code point */
39308: int n_code;
39309:
39310: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39311: mem_base = xmlMemBlocks();
39312: code = gen_int(n_code, 0);
39313:
39314: ret_val = xmlUCSIsCombiningHalfMarks(code);
39315: desret_int(ret_val);
39316: call_tests++;
39317: des_int(n_code, code, 0);
39318: xmlResetLastError();
39319: if (mem_base != xmlMemBlocks()) {
39320: printf("Leak of %d blocks found in xmlUCSIsCombiningHalfMarks",
39321: xmlMemBlocks() - mem_base);
39322: test_ret++;
39323: printf(" %d", n_code);
39324: printf("\n");
39325: }
39326: }
39327: function_tests++;
39328: #endif
39329:
39330: return(test_ret);
39331: }
39332:
39333:
39334: static int
39335: test_xmlUCSIsCombiningMarksforSymbols(void) {
39336: int test_ret = 0;
39337:
39338: #if defined(LIBXML_UNICODE_ENABLED)
39339: int mem_base;
39340: int ret_val;
39341: int code; /* UCS code point */
39342: int n_code;
39343:
39344: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39345: mem_base = xmlMemBlocks();
39346: code = gen_int(n_code, 0);
39347:
39348: ret_val = xmlUCSIsCombiningMarksforSymbols(code);
39349: desret_int(ret_val);
39350: call_tests++;
39351: des_int(n_code, code, 0);
39352: xmlResetLastError();
39353: if (mem_base != xmlMemBlocks()) {
39354: printf("Leak of %d blocks found in xmlUCSIsCombiningMarksforSymbols",
39355: xmlMemBlocks() - mem_base);
39356: test_ret++;
39357: printf(" %d", n_code);
39358: printf("\n");
39359: }
39360: }
39361: function_tests++;
39362: #endif
39363:
39364: return(test_ret);
39365: }
39366:
39367:
39368: static int
39369: test_xmlUCSIsControlPictures(void) {
39370: int test_ret = 0;
39371:
39372: #if defined(LIBXML_UNICODE_ENABLED)
39373: int mem_base;
39374: int ret_val;
39375: int code; /* UCS code point */
39376: int n_code;
39377:
39378: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39379: mem_base = xmlMemBlocks();
39380: code = gen_int(n_code, 0);
39381:
39382: ret_val = xmlUCSIsControlPictures(code);
39383: desret_int(ret_val);
39384: call_tests++;
39385: des_int(n_code, code, 0);
39386: xmlResetLastError();
39387: if (mem_base != xmlMemBlocks()) {
39388: printf("Leak of %d blocks found in xmlUCSIsControlPictures",
39389: xmlMemBlocks() - mem_base);
39390: test_ret++;
39391: printf(" %d", n_code);
39392: printf("\n");
39393: }
39394: }
39395: function_tests++;
39396: #endif
39397:
39398: return(test_ret);
39399: }
39400:
39401:
39402: static int
39403: test_xmlUCSIsCurrencySymbols(void) {
39404: int test_ret = 0;
39405:
39406: #if defined(LIBXML_UNICODE_ENABLED)
39407: int mem_base;
39408: int ret_val;
39409: int code; /* UCS code point */
39410: int n_code;
39411:
39412: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39413: mem_base = xmlMemBlocks();
39414: code = gen_int(n_code, 0);
39415:
39416: ret_val = xmlUCSIsCurrencySymbols(code);
39417: desret_int(ret_val);
39418: call_tests++;
39419: des_int(n_code, code, 0);
39420: xmlResetLastError();
39421: if (mem_base != xmlMemBlocks()) {
39422: printf("Leak of %d blocks found in xmlUCSIsCurrencySymbols",
39423: xmlMemBlocks() - mem_base);
39424: test_ret++;
39425: printf(" %d", n_code);
39426: printf("\n");
39427: }
39428: }
39429: function_tests++;
39430: #endif
39431:
39432: return(test_ret);
39433: }
39434:
39435:
39436: static int
39437: test_xmlUCSIsCypriotSyllabary(void) {
39438: int test_ret = 0;
39439:
39440: #if defined(LIBXML_UNICODE_ENABLED)
39441: int mem_base;
39442: int ret_val;
39443: int code; /* UCS code point */
39444: int n_code;
39445:
39446: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39447: mem_base = xmlMemBlocks();
39448: code = gen_int(n_code, 0);
39449:
39450: ret_val = xmlUCSIsCypriotSyllabary(code);
39451: desret_int(ret_val);
39452: call_tests++;
39453: des_int(n_code, code, 0);
39454: xmlResetLastError();
39455: if (mem_base != xmlMemBlocks()) {
39456: printf("Leak of %d blocks found in xmlUCSIsCypriotSyllabary",
39457: xmlMemBlocks() - mem_base);
39458: test_ret++;
39459: printf(" %d", n_code);
39460: printf("\n");
39461: }
39462: }
39463: function_tests++;
39464: #endif
39465:
39466: return(test_ret);
39467: }
39468:
39469:
39470: static int
39471: test_xmlUCSIsCyrillic(void) {
39472: int test_ret = 0;
39473:
39474: #if defined(LIBXML_UNICODE_ENABLED)
39475: int mem_base;
39476: int ret_val;
39477: int code; /* UCS code point */
39478: int n_code;
39479:
39480: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39481: mem_base = xmlMemBlocks();
39482: code = gen_int(n_code, 0);
39483:
39484: ret_val = xmlUCSIsCyrillic(code);
39485: desret_int(ret_val);
39486: call_tests++;
39487: des_int(n_code, code, 0);
39488: xmlResetLastError();
39489: if (mem_base != xmlMemBlocks()) {
39490: printf("Leak of %d blocks found in xmlUCSIsCyrillic",
39491: xmlMemBlocks() - mem_base);
39492: test_ret++;
39493: printf(" %d", n_code);
39494: printf("\n");
39495: }
39496: }
39497: function_tests++;
39498: #endif
39499:
39500: return(test_ret);
39501: }
39502:
39503:
39504: static int
39505: test_xmlUCSIsCyrillicSupplement(void) {
39506: int test_ret = 0;
39507:
39508: #if defined(LIBXML_UNICODE_ENABLED)
39509: int mem_base;
39510: int ret_val;
39511: int code; /* UCS code point */
39512: int n_code;
39513:
39514: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39515: mem_base = xmlMemBlocks();
39516: code = gen_int(n_code, 0);
39517:
39518: ret_val = xmlUCSIsCyrillicSupplement(code);
39519: desret_int(ret_val);
39520: call_tests++;
39521: des_int(n_code, code, 0);
39522: xmlResetLastError();
39523: if (mem_base != xmlMemBlocks()) {
39524: printf("Leak of %d blocks found in xmlUCSIsCyrillicSupplement",
39525: xmlMemBlocks() - mem_base);
39526: test_ret++;
39527: printf(" %d", n_code);
39528: printf("\n");
39529: }
39530: }
39531: function_tests++;
39532: #endif
39533:
39534: return(test_ret);
39535: }
39536:
39537:
39538: static int
39539: test_xmlUCSIsDeseret(void) {
39540: int test_ret = 0;
39541:
39542: #if defined(LIBXML_UNICODE_ENABLED)
39543: int mem_base;
39544: int ret_val;
39545: int code; /* UCS code point */
39546: int n_code;
39547:
39548: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39549: mem_base = xmlMemBlocks();
39550: code = gen_int(n_code, 0);
39551:
39552: ret_val = xmlUCSIsDeseret(code);
39553: desret_int(ret_val);
39554: call_tests++;
39555: des_int(n_code, code, 0);
39556: xmlResetLastError();
39557: if (mem_base != xmlMemBlocks()) {
39558: printf("Leak of %d blocks found in xmlUCSIsDeseret",
39559: xmlMemBlocks() - mem_base);
39560: test_ret++;
39561: printf(" %d", n_code);
39562: printf("\n");
39563: }
39564: }
39565: function_tests++;
39566: #endif
39567:
39568: return(test_ret);
39569: }
39570:
39571:
39572: static int
39573: test_xmlUCSIsDevanagari(void) {
39574: int test_ret = 0;
39575:
39576: #if defined(LIBXML_UNICODE_ENABLED)
39577: int mem_base;
39578: int ret_val;
39579: int code; /* UCS code point */
39580: int n_code;
39581:
39582: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39583: mem_base = xmlMemBlocks();
39584: code = gen_int(n_code, 0);
39585:
39586: ret_val = xmlUCSIsDevanagari(code);
39587: desret_int(ret_val);
39588: call_tests++;
39589: des_int(n_code, code, 0);
39590: xmlResetLastError();
39591: if (mem_base != xmlMemBlocks()) {
39592: printf("Leak of %d blocks found in xmlUCSIsDevanagari",
39593: xmlMemBlocks() - mem_base);
39594: test_ret++;
39595: printf(" %d", n_code);
39596: printf("\n");
39597: }
39598: }
39599: function_tests++;
39600: #endif
39601:
39602: return(test_ret);
39603: }
39604:
39605:
39606: static int
39607: test_xmlUCSIsDingbats(void) {
39608: int test_ret = 0;
39609:
39610: #if defined(LIBXML_UNICODE_ENABLED)
39611: int mem_base;
39612: int ret_val;
39613: int code; /* UCS code point */
39614: int n_code;
39615:
39616: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39617: mem_base = xmlMemBlocks();
39618: code = gen_int(n_code, 0);
39619:
39620: ret_val = xmlUCSIsDingbats(code);
39621: desret_int(ret_val);
39622: call_tests++;
39623: des_int(n_code, code, 0);
39624: xmlResetLastError();
39625: if (mem_base != xmlMemBlocks()) {
39626: printf("Leak of %d blocks found in xmlUCSIsDingbats",
39627: xmlMemBlocks() - mem_base);
39628: test_ret++;
39629: printf(" %d", n_code);
39630: printf("\n");
39631: }
39632: }
39633: function_tests++;
39634: #endif
39635:
39636: return(test_ret);
39637: }
39638:
39639:
39640: static int
39641: test_xmlUCSIsEnclosedAlphanumerics(void) {
39642: int test_ret = 0;
39643:
39644: #if defined(LIBXML_UNICODE_ENABLED)
39645: int mem_base;
39646: int ret_val;
39647: int code; /* UCS code point */
39648: int n_code;
39649:
39650: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39651: mem_base = xmlMemBlocks();
39652: code = gen_int(n_code, 0);
39653:
39654: ret_val = xmlUCSIsEnclosedAlphanumerics(code);
39655: desret_int(ret_val);
39656: call_tests++;
39657: des_int(n_code, code, 0);
39658: xmlResetLastError();
39659: if (mem_base != xmlMemBlocks()) {
39660: printf("Leak of %d blocks found in xmlUCSIsEnclosedAlphanumerics",
39661: xmlMemBlocks() - mem_base);
39662: test_ret++;
39663: printf(" %d", n_code);
39664: printf("\n");
39665: }
39666: }
39667: function_tests++;
39668: #endif
39669:
39670: return(test_ret);
39671: }
39672:
39673:
39674: static int
39675: test_xmlUCSIsEnclosedCJKLettersandMonths(void) {
39676: int test_ret = 0;
39677:
39678: #if defined(LIBXML_UNICODE_ENABLED)
39679: int mem_base;
39680: int ret_val;
39681: int code; /* UCS code point */
39682: int n_code;
39683:
39684: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39685: mem_base = xmlMemBlocks();
39686: code = gen_int(n_code, 0);
39687:
39688: ret_val = xmlUCSIsEnclosedCJKLettersandMonths(code);
39689: desret_int(ret_val);
39690: call_tests++;
39691: des_int(n_code, code, 0);
39692: xmlResetLastError();
39693: if (mem_base != xmlMemBlocks()) {
39694: printf("Leak of %d blocks found in xmlUCSIsEnclosedCJKLettersandMonths",
39695: xmlMemBlocks() - mem_base);
39696: test_ret++;
39697: printf(" %d", n_code);
39698: printf("\n");
39699: }
39700: }
39701: function_tests++;
39702: #endif
39703:
39704: return(test_ret);
39705: }
39706:
39707:
39708: static int
39709: test_xmlUCSIsEthiopic(void) {
39710: int test_ret = 0;
39711:
39712: #if defined(LIBXML_UNICODE_ENABLED)
39713: int mem_base;
39714: int ret_val;
39715: int code; /* UCS code point */
39716: int n_code;
39717:
39718: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39719: mem_base = xmlMemBlocks();
39720: code = gen_int(n_code, 0);
39721:
39722: ret_val = xmlUCSIsEthiopic(code);
39723: desret_int(ret_val);
39724: call_tests++;
39725: des_int(n_code, code, 0);
39726: xmlResetLastError();
39727: if (mem_base != xmlMemBlocks()) {
39728: printf("Leak of %d blocks found in xmlUCSIsEthiopic",
39729: xmlMemBlocks() - mem_base);
39730: test_ret++;
39731: printf(" %d", n_code);
39732: printf("\n");
39733: }
39734: }
39735: function_tests++;
39736: #endif
39737:
39738: return(test_ret);
39739: }
39740:
39741:
39742: static int
39743: test_xmlUCSIsGeneralPunctuation(void) {
39744: int test_ret = 0;
39745:
39746: #if defined(LIBXML_UNICODE_ENABLED)
39747: int mem_base;
39748: int ret_val;
39749: int code; /* UCS code point */
39750: int n_code;
39751:
39752: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39753: mem_base = xmlMemBlocks();
39754: code = gen_int(n_code, 0);
39755:
39756: ret_val = xmlUCSIsGeneralPunctuation(code);
39757: desret_int(ret_val);
39758: call_tests++;
39759: des_int(n_code, code, 0);
39760: xmlResetLastError();
39761: if (mem_base != xmlMemBlocks()) {
39762: printf("Leak of %d blocks found in xmlUCSIsGeneralPunctuation",
39763: xmlMemBlocks() - mem_base);
39764: test_ret++;
39765: printf(" %d", n_code);
39766: printf("\n");
39767: }
39768: }
39769: function_tests++;
39770: #endif
39771:
39772: return(test_ret);
39773: }
39774:
39775:
39776: static int
39777: test_xmlUCSIsGeometricShapes(void) {
39778: int test_ret = 0;
39779:
39780: #if defined(LIBXML_UNICODE_ENABLED)
39781: int mem_base;
39782: int ret_val;
39783: int code; /* UCS code point */
39784: int n_code;
39785:
39786: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39787: mem_base = xmlMemBlocks();
39788: code = gen_int(n_code, 0);
39789:
39790: ret_val = xmlUCSIsGeometricShapes(code);
39791: desret_int(ret_val);
39792: call_tests++;
39793: des_int(n_code, code, 0);
39794: xmlResetLastError();
39795: if (mem_base != xmlMemBlocks()) {
39796: printf("Leak of %d blocks found in xmlUCSIsGeometricShapes",
39797: xmlMemBlocks() - mem_base);
39798: test_ret++;
39799: printf(" %d", n_code);
39800: printf("\n");
39801: }
39802: }
39803: function_tests++;
39804: #endif
39805:
39806: return(test_ret);
39807: }
39808:
39809:
39810: static int
39811: test_xmlUCSIsGeorgian(void) {
39812: int test_ret = 0;
39813:
39814: #if defined(LIBXML_UNICODE_ENABLED)
39815: int mem_base;
39816: int ret_val;
39817: int code; /* UCS code point */
39818: int n_code;
39819:
39820: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39821: mem_base = xmlMemBlocks();
39822: code = gen_int(n_code, 0);
39823:
39824: ret_val = xmlUCSIsGeorgian(code);
39825: desret_int(ret_val);
39826: call_tests++;
39827: des_int(n_code, code, 0);
39828: xmlResetLastError();
39829: if (mem_base != xmlMemBlocks()) {
39830: printf("Leak of %d blocks found in xmlUCSIsGeorgian",
39831: xmlMemBlocks() - mem_base);
39832: test_ret++;
39833: printf(" %d", n_code);
39834: printf("\n");
39835: }
39836: }
39837: function_tests++;
39838: #endif
39839:
39840: return(test_ret);
39841: }
39842:
39843:
39844: static int
39845: test_xmlUCSIsGothic(void) {
39846: int test_ret = 0;
39847:
39848: #if defined(LIBXML_UNICODE_ENABLED)
39849: int mem_base;
39850: int ret_val;
39851: int code; /* UCS code point */
39852: int n_code;
39853:
39854: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39855: mem_base = xmlMemBlocks();
39856: code = gen_int(n_code, 0);
39857:
39858: ret_val = xmlUCSIsGothic(code);
39859: desret_int(ret_val);
39860: call_tests++;
39861: des_int(n_code, code, 0);
39862: xmlResetLastError();
39863: if (mem_base != xmlMemBlocks()) {
39864: printf("Leak of %d blocks found in xmlUCSIsGothic",
39865: xmlMemBlocks() - mem_base);
39866: test_ret++;
39867: printf(" %d", n_code);
39868: printf("\n");
39869: }
39870: }
39871: function_tests++;
39872: #endif
39873:
39874: return(test_ret);
39875: }
39876:
39877:
39878: static int
39879: test_xmlUCSIsGreek(void) {
39880: int test_ret = 0;
39881:
39882: #if defined(LIBXML_UNICODE_ENABLED)
39883: int mem_base;
39884: int ret_val;
39885: int code; /* UCS code point */
39886: int n_code;
39887:
39888: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39889: mem_base = xmlMemBlocks();
39890: code = gen_int(n_code, 0);
39891:
39892: ret_val = xmlUCSIsGreek(code);
39893: desret_int(ret_val);
39894: call_tests++;
39895: des_int(n_code, code, 0);
39896: xmlResetLastError();
39897: if (mem_base != xmlMemBlocks()) {
39898: printf("Leak of %d blocks found in xmlUCSIsGreek",
39899: xmlMemBlocks() - mem_base);
39900: test_ret++;
39901: printf(" %d", n_code);
39902: printf("\n");
39903: }
39904: }
39905: function_tests++;
39906: #endif
39907:
39908: return(test_ret);
39909: }
39910:
39911:
39912: static int
39913: test_xmlUCSIsGreekExtended(void) {
39914: int test_ret = 0;
39915:
39916: #if defined(LIBXML_UNICODE_ENABLED)
39917: int mem_base;
39918: int ret_val;
39919: int code; /* UCS code point */
39920: int n_code;
39921:
39922: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39923: mem_base = xmlMemBlocks();
39924: code = gen_int(n_code, 0);
39925:
39926: ret_val = xmlUCSIsGreekExtended(code);
39927: desret_int(ret_val);
39928: call_tests++;
39929: des_int(n_code, code, 0);
39930: xmlResetLastError();
39931: if (mem_base != xmlMemBlocks()) {
39932: printf("Leak of %d blocks found in xmlUCSIsGreekExtended",
39933: xmlMemBlocks() - mem_base);
39934: test_ret++;
39935: printf(" %d", n_code);
39936: printf("\n");
39937: }
39938: }
39939: function_tests++;
39940: #endif
39941:
39942: return(test_ret);
39943: }
39944:
39945:
39946: static int
39947: test_xmlUCSIsGreekandCoptic(void) {
39948: int test_ret = 0;
39949:
39950: #if defined(LIBXML_UNICODE_ENABLED)
39951: int mem_base;
39952: int ret_val;
39953: int code; /* UCS code point */
39954: int n_code;
39955:
39956: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39957: mem_base = xmlMemBlocks();
39958: code = gen_int(n_code, 0);
39959:
39960: ret_val = xmlUCSIsGreekandCoptic(code);
39961: desret_int(ret_val);
39962: call_tests++;
39963: des_int(n_code, code, 0);
39964: xmlResetLastError();
39965: if (mem_base != xmlMemBlocks()) {
39966: printf("Leak of %d blocks found in xmlUCSIsGreekandCoptic",
39967: xmlMemBlocks() - mem_base);
39968: test_ret++;
39969: printf(" %d", n_code);
39970: printf("\n");
39971: }
39972: }
39973: function_tests++;
39974: #endif
39975:
39976: return(test_ret);
39977: }
39978:
39979:
39980: static int
39981: test_xmlUCSIsGujarati(void) {
39982: int test_ret = 0;
39983:
39984: #if defined(LIBXML_UNICODE_ENABLED)
39985: int mem_base;
39986: int ret_val;
39987: int code; /* UCS code point */
39988: int n_code;
39989:
39990: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39991: mem_base = xmlMemBlocks();
39992: code = gen_int(n_code, 0);
39993:
39994: ret_val = xmlUCSIsGujarati(code);
39995: desret_int(ret_val);
39996: call_tests++;
39997: des_int(n_code, code, 0);
39998: xmlResetLastError();
39999: if (mem_base != xmlMemBlocks()) {
40000: printf("Leak of %d blocks found in xmlUCSIsGujarati",
40001: xmlMemBlocks() - mem_base);
40002: test_ret++;
40003: printf(" %d", n_code);
40004: printf("\n");
40005: }
40006: }
40007: function_tests++;
40008: #endif
40009:
40010: return(test_ret);
40011: }
40012:
40013:
40014: static int
40015: test_xmlUCSIsGurmukhi(void) {
40016: int test_ret = 0;
40017:
40018: #if defined(LIBXML_UNICODE_ENABLED)
40019: int mem_base;
40020: int ret_val;
40021: int code; /* UCS code point */
40022: int n_code;
40023:
40024: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40025: mem_base = xmlMemBlocks();
40026: code = gen_int(n_code, 0);
40027:
40028: ret_val = xmlUCSIsGurmukhi(code);
40029: desret_int(ret_val);
40030: call_tests++;
40031: des_int(n_code, code, 0);
40032: xmlResetLastError();
40033: if (mem_base != xmlMemBlocks()) {
40034: printf("Leak of %d blocks found in xmlUCSIsGurmukhi",
40035: xmlMemBlocks() - mem_base);
40036: test_ret++;
40037: printf(" %d", n_code);
40038: printf("\n");
40039: }
40040: }
40041: function_tests++;
40042: #endif
40043:
40044: return(test_ret);
40045: }
40046:
40047:
40048: static int
40049: test_xmlUCSIsHalfwidthandFullwidthForms(void) {
40050: int test_ret = 0;
40051:
40052: #if defined(LIBXML_UNICODE_ENABLED)
40053: int mem_base;
40054: int ret_val;
40055: int code; /* UCS code point */
40056: int n_code;
40057:
40058: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40059: mem_base = xmlMemBlocks();
40060: code = gen_int(n_code, 0);
40061:
40062: ret_val = xmlUCSIsHalfwidthandFullwidthForms(code);
40063: desret_int(ret_val);
40064: call_tests++;
40065: des_int(n_code, code, 0);
40066: xmlResetLastError();
40067: if (mem_base != xmlMemBlocks()) {
40068: printf("Leak of %d blocks found in xmlUCSIsHalfwidthandFullwidthForms",
40069: xmlMemBlocks() - mem_base);
40070: test_ret++;
40071: printf(" %d", n_code);
40072: printf("\n");
40073: }
40074: }
40075: function_tests++;
40076: #endif
40077:
40078: return(test_ret);
40079: }
40080:
40081:
40082: static int
40083: test_xmlUCSIsHangulCompatibilityJamo(void) {
40084: int test_ret = 0;
40085:
40086: #if defined(LIBXML_UNICODE_ENABLED)
40087: int mem_base;
40088: int ret_val;
40089: int code; /* UCS code point */
40090: int n_code;
40091:
40092: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40093: mem_base = xmlMemBlocks();
40094: code = gen_int(n_code, 0);
40095:
40096: ret_val = xmlUCSIsHangulCompatibilityJamo(code);
40097: desret_int(ret_val);
40098: call_tests++;
40099: des_int(n_code, code, 0);
40100: xmlResetLastError();
40101: if (mem_base != xmlMemBlocks()) {
40102: printf("Leak of %d blocks found in xmlUCSIsHangulCompatibilityJamo",
40103: xmlMemBlocks() - mem_base);
40104: test_ret++;
40105: printf(" %d", n_code);
40106: printf("\n");
40107: }
40108: }
40109: function_tests++;
40110: #endif
40111:
40112: return(test_ret);
40113: }
40114:
40115:
40116: static int
40117: test_xmlUCSIsHangulJamo(void) {
40118: int test_ret = 0;
40119:
40120: #if defined(LIBXML_UNICODE_ENABLED)
40121: int mem_base;
40122: int ret_val;
40123: int code; /* UCS code point */
40124: int n_code;
40125:
40126: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40127: mem_base = xmlMemBlocks();
40128: code = gen_int(n_code, 0);
40129:
40130: ret_val = xmlUCSIsHangulJamo(code);
40131: desret_int(ret_val);
40132: call_tests++;
40133: des_int(n_code, code, 0);
40134: xmlResetLastError();
40135: if (mem_base != xmlMemBlocks()) {
40136: printf("Leak of %d blocks found in xmlUCSIsHangulJamo",
40137: xmlMemBlocks() - mem_base);
40138: test_ret++;
40139: printf(" %d", n_code);
40140: printf("\n");
40141: }
40142: }
40143: function_tests++;
40144: #endif
40145:
40146: return(test_ret);
40147: }
40148:
40149:
40150: static int
40151: test_xmlUCSIsHangulSyllables(void) {
40152: int test_ret = 0;
40153:
40154: #if defined(LIBXML_UNICODE_ENABLED)
40155: int mem_base;
40156: int ret_val;
40157: int code; /* UCS code point */
40158: int n_code;
40159:
40160: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40161: mem_base = xmlMemBlocks();
40162: code = gen_int(n_code, 0);
40163:
40164: ret_val = xmlUCSIsHangulSyllables(code);
40165: desret_int(ret_val);
40166: call_tests++;
40167: des_int(n_code, code, 0);
40168: xmlResetLastError();
40169: if (mem_base != xmlMemBlocks()) {
40170: printf("Leak of %d blocks found in xmlUCSIsHangulSyllables",
40171: xmlMemBlocks() - mem_base);
40172: test_ret++;
40173: printf(" %d", n_code);
40174: printf("\n");
40175: }
40176: }
40177: function_tests++;
40178: #endif
40179:
40180: return(test_ret);
40181: }
40182:
40183:
40184: static int
40185: test_xmlUCSIsHanunoo(void) {
40186: int test_ret = 0;
40187:
40188: #if defined(LIBXML_UNICODE_ENABLED)
40189: int mem_base;
40190: int ret_val;
40191: int code; /* UCS code point */
40192: int n_code;
40193:
40194: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40195: mem_base = xmlMemBlocks();
40196: code = gen_int(n_code, 0);
40197:
40198: ret_val = xmlUCSIsHanunoo(code);
40199: desret_int(ret_val);
40200: call_tests++;
40201: des_int(n_code, code, 0);
40202: xmlResetLastError();
40203: if (mem_base != xmlMemBlocks()) {
40204: printf("Leak of %d blocks found in xmlUCSIsHanunoo",
40205: xmlMemBlocks() - mem_base);
40206: test_ret++;
40207: printf(" %d", n_code);
40208: printf("\n");
40209: }
40210: }
40211: function_tests++;
40212: #endif
40213:
40214: return(test_ret);
40215: }
40216:
40217:
40218: static int
40219: test_xmlUCSIsHebrew(void) {
40220: int test_ret = 0;
40221:
40222: #if defined(LIBXML_UNICODE_ENABLED)
40223: int mem_base;
40224: int ret_val;
40225: int code; /* UCS code point */
40226: int n_code;
40227:
40228: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40229: mem_base = xmlMemBlocks();
40230: code = gen_int(n_code, 0);
40231:
40232: ret_val = xmlUCSIsHebrew(code);
40233: desret_int(ret_val);
40234: call_tests++;
40235: des_int(n_code, code, 0);
40236: xmlResetLastError();
40237: if (mem_base != xmlMemBlocks()) {
40238: printf("Leak of %d blocks found in xmlUCSIsHebrew",
40239: xmlMemBlocks() - mem_base);
40240: test_ret++;
40241: printf(" %d", n_code);
40242: printf("\n");
40243: }
40244: }
40245: function_tests++;
40246: #endif
40247:
40248: return(test_ret);
40249: }
40250:
40251:
40252: static int
40253: test_xmlUCSIsHighPrivateUseSurrogates(void) {
40254: int test_ret = 0;
40255:
40256: #if defined(LIBXML_UNICODE_ENABLED)
40257: int mem_base;
40258: int ret_val;
40259: int code; /* UCS code point */
40260: int n_code;
40261:
40262: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40263: mem_base = xmlMemBlocks();
40264: code = gen_int(n_code, 0);
40265:
40266: ret_val = xmlUCSIsHighPrivateUseSurrogates(code);
40267: desret_int(ret_val);
40268: call_tests++;
40269: des_int(n_code, code, 0);
40270: xmlResetLastError();
40271: if (mem_base != xmlMemBlocks()) {
40272: printf("Leak of %d blocks found in xmlUCSIsHighPrivateUseSurrogates",
40273: xmlMemBlocks() - mem_base);
40274: test_ret++;
40275: printf(" %d", n_code);
40276: printf("\n");
40277: }
40278: }
40279: function_tests++;
40280: #endif
40281:
40282: return(test_ret);
40283: }
40284:
40285:
40286: static int
40287: test_xmlUCSIsHighSurrogates(void) {
40288: int test_ret = 0;
40289:
40290: #if defined(LIBXML_UNICODE_ENABLED)
40291: int mem_base;
40292: int ret_val;
40293: int code; /* UCS code point */
40294: int n_code;
40295:
40296: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40297: mem_base = xmlMemBlocks();
40298: code = gen_int(n_code, 0);
40299:
40300: ret_val = xmlUCSIsHighSurrogates(code);
40301: desret_int(ret_val);
40302: call_tests++;
40303: des_int(n_code, code, 0);
40304: xmlResetLastError();
40305: if (mem_base != xmlMemBlocks()) {
40306: printf("Leak of %d blocks found in xmlUCSIsHighSurrogates",
40307: xmlMemBlocks() - mem_base);
40308: test_ret++;
40309: printf(" %d", n_code);
40310: printf("\n");
40311: }
40312: }
40313: function_tests++;
40314: #endif
40315:
40316: return(test_ret);
40317: }
40318:
40319:
40320: static int
40321: test_xmlUCSIsHiragana(void) {
40322: int test_ret = 0;
40323:
40324: #if defined(LIBXML_UNICODE_ENABLED)
40325: int mem_base;
40326: int ret_val;
40327: int code; /* UCS code point */
40328: int n_code;
40329:
40330: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40331: mem_base = xmlMemBlocks();
40332: code = gen_int(n_code, 0);
40333:
40334: ret_val = xmlUCSIsHiragana(code);
40335: desret_int(ret_val);
40336: call_tests++;
40337: des_int(n_code, code, 0);
40338: xmlResetLastError();
40339: if (mem_base != xmlMemBlocks()) {
40340: printf("Leak of %d blocks found in xmlUCSIsHiragana",
40341: xmlMemBlocks() - mem_base);
40342: test_ret++;
40343: printf(" %d", n_code);
40344: printf("\n");
40345: }
40346: }
40347: function_tests++;
40348: #endif
40349:
40350: return(test_ret);
40351: }
40352:
40353:
40354: static int
40355: test_xmlUCSIsIPAExtensions(void) {
40356: int test_ret = 0;
40357:
40358: #if defined(LIBXML_UNICODE_ENABLED)
40359: int mem_base;
40360: int ret_val;
40361: int code; /* UCS code point */
40362: int n_code;
40363:
40364: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40365: mem_base = xmlMemBlocks();
40366: code = gen_int(n_code, 0);
40367:
40368: ret_val = xmlUCSIsIPAExtensions(code);
40369: desret_int(ret_val);
40370: call_tests++;
40371: des_int(n_code, code, 0);
40372: xmlResetLastError();
40373: if (mem_base != xmlMemBlocks()) {
40374: printf("Leak of %d blocks found in xmlUCSIsIPAExtensions",
40375: xmlMemBlocks() - mem_base);
40376: test_ret++;
40377: printf(" %d", n_code);
40378: printf("\n");
40379: }
40380: }
40381: function_tests++;
40382: #endif
40383:
40384: return(test_ret);
40385: }
40386:
40387:
40388: static int
40389: test_xmlUCSIsIdeographicDescriptionCharacters(void) {
40390: int test_ret = 0;
40391:
40392: #if defined(LIBXML_UNICODE_ENABLED)
40393: int mem_base;
40394: int ret_val;
40395: int code; /* UCS code point */
40396: int n_code;
40397:
40398: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40399: mem_base = xmlMemBlocks();
40400: code = gen_int(n_code, 0);
40401:
40402: ret_val = xmlUCSIsIdeographicDescriptionCharacters(code);
40403: desret_int(ret_val);
40404: call_tests++;
40405: des_int(n_code, code, 0);
40406: xmlResetLastError();
40407: if (mem_base != xmlMemBlocks()) {
40408: printf("Leak of %d blocks found in xmlUCSIsIdeographicDescriptionCharacters",
40409: xmlMemBlocks() - mem_base);
40410: test_ret++;
40411: printf(" %d", n_code);
40412: printf("\n");
40413: }
40414: }
40415: function_tests++;
40416: #endif
40417:
40418: return(test_ret);
40419: }
40420:
40421:
40422: static int
40423: test_xmlUCSIsKanbun(void) {
40424: int test_ret = 0;
40425:
40426: #if defined(LIBXML_UNICODE_ENABLED)
40427: int mem_base;
40428: int ret_val;
40429: int code; /* UCS code point */
40430: int n_code;
40431:
40432: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40433: mem_base = xmlMemBlocks();
40434: code = gen_int(n_code, 0);
40435:
40436: ret_val = xmlUCSIsKanbun(code);
40437: desret_int(ret_val);
40438: call_tests++;
40439: des_int(n_code, code, 0);
40440: xmlResetLastError();
40441: if (mem_base != xmlMemBlocks()) {
40442: printf("Leak of %d blocks found in xmlUCSIsKanbun",
40443: xmlMemBlocks() - mem_base);
40444: test_ret++;
40445: printf(" %d", n_code);
40446: printf("\n");
40447: }
40448: }
40449: function_tests++;
40450: #endif
40451:
40452: return(test_ret);
40453: }
40454:
40455:
40456: static int
40457: test_xmlUCSIsKangxiRadicals(void) {
40458: int test_ret = 0;
40459:
40460: #if defined(LIBXML_UNICODE_ENABLED)
40461: int mem_base;
40462: int ret_val;
40463: int code; /* UCS code point */
40464: int n_code;
40465:
40466: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40467: mem_base = xmlMemBlocks();
40468: code = gen_int(n_code, 0);
40469:
40470: ret_val = xmlUCSIsKangxiRadicals(code);
40471: desret_int(ret_val);
40472: call_tests++;
40473: des_int(n_code, code, 0);
40474: xmlResetLastError();
40475: if (mem_base != xmlMemBlocks()) {
40476: printf("Leak of %d blocks found in xmlUCSIsKangxiRadicals",
40477: xmlMemBlocks() - mem_base);
40478: test_ret++;
40479: printf(" %d", n_code);
40480: printf("\n");
40481: }
40482: }
40483: function_tests++;
40484: #endif
40485:
40486: return(test_ret);
40487: }
40488:
40489:
40490: static int
40491: test_xmlUCSIsKannada(void) {
40492: int test_ret = 0;
40493:
40494: #if defined(LIBXML_UNICODE_ENABLED)
40495: int mem_base;
40496: int ret_val;
40497: int code; /* UCS code point */
40498: int n_code;
40499:
40500: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40501: mem_base = xmlMemBlocks();
40502: code = gen_int(n_code, 0);
40503:
40504: ret_val = xmlUCSIsKannada(code);
40505: desret_int(ret_val);
40506: call_tests++;
40507: des_int(n_code, code, 0);
40508: xmlResetLastError();
40509: if (mem_base != xmlMemBlocks()) {
40510: printf("Leak of %d blocks found in xmlUCSIsKannada",
40511: xmlMemBlocks() - mem_base);
40512: test_ret++;
40513: printf(" %d", n_code);
40514: printf("\n");
40515: }
40516: }
40517: function_tests++;
40518: #endif
40519:
40520: return(test_ret);
40521: }
40522:
40523:
40524: static int
40525: test_xmlUCSIsKatakana(void) {
40526: int test_ret = 0;
40527:
40528: #if defined(LIBXML_UNICODE_ENABLED)
40529: int mem_base;
40530: int ret_val;
40531: int code; /* UCS code point */
40532: int n_code;
40533:
40534: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40535: mem_base = xmlMemBlocks();
40536: code = gen_int(n_code, 0);
40537:
40538: ret_val = xmlUCSIsKatakana(code);
40539: desret_int(ret_val);
40540: call_tests++;
40541: des_int(n_code, code, 0);
40542: xmlResetLastError();
40543: if (mem_base != xmlMemBlocks()) {
40544: printf("Leak of %d blocks found in xmlUCSIsKatakana",
40545: xmlMemBlocks() - mem_base);
40546: test_ret++;
40547: printf(" %d", n_code);
40548: printf("\n");
40549: }
40550: }
40551: function_tests++;
40552: #endif
40553:
40554: return(test_ret);
40555: }
40556:
40557:
40558: static int
40559: test_xmlUCSIsKatakanaPhoneticExtensions(void) {
40560: int test_ret = 0;
40561:
40562: #if defined(LIBXML_UNICODE_ENABLED)
40563: int mem_base;
40564: int ret_val;
40565: int code; /* UCS code point */
40566: int n_code;
40567:
40568: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40569: mem_base = xmlMemBlocks();
40570: code = gen_int(n_code, 0);
40571:
40572: ret_val = xmlUCSIsKatakanaPhoneticExtensions(code);
40573: desret_int(ret_val);
40574: call_tests++;
40575: des_int(n_code, code, 0);
40576: xmlResetLastError();
40577: if (mem_base != xmlMemBlocks()) {
40578: printf("Leak of %d blocks found in xmlUCSIsKatakanaPhoneticExtensions",
40579: xmlMemBlocks() - mem_base);
40580: test_ret++;
40581: printf(" %d", n_code);
40582: printf("\n");
40583: }
40584: }
40585: function_tests++;
40586: #endif
40587:
40588: return(test_ret);
40589: }
40590:
40591:
40592: static int
40593: test_xmlUCSIsKhmer(void) {
40594: int test_ret = 0;
40595:
40596: #if defined(LIBXML_UNICODE_ENABLED)
40597: int mem_base;
40598: int ret_val;
40599: int code; /* UCS code point */
40600: int n_code;
40601:
40602: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40603: mem_base = xmlMemBlocks();
40604: code = gen_int(n_code, 0);
40605:
40606: ret_val = xmlUCSIsKhmer(code);
40607: desret_int(ret_val);
40608: call_tests++;
40609: des_int(n_code, code, 0);
40610: xmlResetLastError();
40611: if (mem_base != xmlMemBlocks()) {
40612: printf("Leak of %d blocks found in xmlUCSIsKhmer",
40613: xmlMemBlocks() - mem_base);
40614: test_ret++;
40615: printf(" %d", n_code);
40616: printf("\n");
40617: }
40618: }
40619: function_tests++;
40620: #endif
40621:
40622: return(test_ret);
40623: }
40624:
40625:
40626: static int
40627: test_xmlUCSIsKhmerSymbols(void) {
40628: int test_ret = 0;
40629:
40630: #if defined(LIBXML_UNICODE_ENABLED)
40631: int mem_base;
40632: int ret_val;
40633: int code; /* UCS code point */
40634: int n_code;
40635:
40636: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40637: mem_base = xmlMemBlocks();
40638: code = gen_int(n_code, 0);
40639:
40640: ret_val = xmlUCSIsKhmerSymbols(code);
40641: desret_int(ret_val);
40642: call_tests++;
40643: des_int(n_code, code, 0);
40644: xmlResetLastError();
40645: if (mem_base != xmlMemBlocks()) {
40646: printf("Leak of %d blocks found in xmlUCSIsKhmerSymbols",
40647: xmlMemBlocks() - mem_base);
40648: test_ret++;
40649: printf(" %d", n_code);
40650: printf("\n");
40651: }
40652: }
40653: function_tests++;
40654: #endif
40655:
40656: return(test_ret);
40657: }
40658:
40659:
40660: static int
40661: test_xmlUCSIsLao(void) {
40662: int test_ret = 0;
40663:
40664: #if defined(LIBXML_UNICODE_ENABLED)
40665: int mem_base;
40666: int ret_val;
40667: int code; /* UCS code point */
40668: int n_code;
40669:
40670: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40671: mem_base = xmlMemBlocks();
40672: code = gen_int(n_code, 0);
40673:
40674: ret_val = xmlUCSIsLao(code);
40675: desret_int(ret_val);
40676: call_tests++;
40677: des_int(n_code, code, 0);
40678: xmlResetLastError();
40679: if (mem_base != xmlMemBlocks()) {
40680: printf("Leak of %d blocks found in xmlUCSIsLao",
40681: xmlMemBlocks() - mem_base);
40682: test_ret++;
40683: printf(" %d", n_code);
40684: printf("\n");
40685: }
40686: }
40687: function_tests++;
40688: #endif
40689:
40690: return(test_ret);
40691: }
40692:
40693:
40694: static int
40695: test_xmlUCSIsLatin1Supplement(void) {
40696: int test_ret = 0;
40697:
40698: #if defined(LIBXML_UNICODE_ENABLED)
40699: int mem_base;
40700: int ret_val;
40701: int code; /* UCS code point */
40702: int n_code;
40703:
40704: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40705: mem_base = xmlMemBlocks();
40706: code = gen_int(n_code, 0);
40707:
40708: ret_val = xmlUCSIsLatin1Supplement(code);
40709: desret_int(ret_val);
40710: call_tests++;
40711: des_int(n_code, code, 0);
40712: xmlResetLastError();
40713: if (mem_base != xmlMemBlocks()) {
40714: printf("Leak of %d blocks found in xmlUCSIsLatin1Supplement",
40715: xmlMemBlocks() - mem_base);
40716: test_ret++;
40717: printf(" %d", n_code);
40718: printf("\n");
40719: }
40720: }
40721: function_tests++;
40722: #endif
40723:
40724: return(test_ret);
40725: }
40726:
40727:
40728: static int
40729: test_xmlUCSIsLatinExtendedA(void) {
40730: int test_ret = 0;
40731:
40732: #if defined(LIBXML_UNICODE_ENABLED)
40733: int mem_base;
40734: int ret_val;
40735: int code; /* UCS code point */
40736: int n_code;
40737:
40738: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40739: mem_base = xmlMemBlocks();
40740: code = gen_int(n_code, 0);
40741:
40742: ret_val = xmlUCSIsLatinExtendedA(code);
40743: desret_int(ret_val);
40744: call_tests++;
40745: des_int(n_code, code, 0);
40746: xmlResetLastError();
40747: if (mem_base != xmlMemBlocks()) {
40748: printf("Leak of %d blocks found in xmlUCSIsLatinExtendedA",
40749: xmlMemBlocks() - mem_base);
40750: test_ret++;
40751: printf(" %d", n_code);
40752: printf("\n");
40753: }
40754: }
40755: function_tests++;
40756: #endif
40757:
40758: return(test_ret);
40759: }
40760:
40761:
40762: static int
40763: test_xmlUCSIsLatinExtendedAdditional(void) {
40764: int test_ret = 0;
40765:
40766: #if defined(LIBXML_UNICODE_ENABLED)
40767: int mem_base;
40768: int ret_val;
40769: int code; /* UCS code point */
40770: int n_code;
40771:
40772: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40773: mem_base = xmlMemBlocks();
40774: code = gen_int(n_code, 0);
40775:
40776: ret_val = xmlUCSIsLatinExtendedAdditional(code);
40777: desret_int(ret_val);
40778: call_tests++;
40779: des_int(n_code, code, 0);
40780: xmlResetLastError();
40781: if (mem_base != xmlMemBlocks()) {
40782: printf("Leak of %d blocks found in xmlUCSIsLatinExtendedAdditional",
40783: xmlMemBlocks() - mem_base);
40784: test_ret++;
40785: printf(" %d", n_code);
40786: printf("\n");
40787: }
40788: }
40789: function_tests++;
40790: #endif
40791:
40792: return(test_ret);
40793: }
40794:
40795:
40796: static int
40797: test_xmlUCSIsLatinExtendedB(void) {
40798: int test_ret = 0;
40799:
40800: #if defined(LIBXML_UNICODE_ENABLED)
40801: int mem_base;
40802: int ret_val;
40803: int code; /* UCS code point */
40804: int n_code;
40805:
40806: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40807: mem_base = xmlMemBlocks();
40808: code = gen_int(n_code, 0);
40809:
40810: ret_val = xmlUCSIsLatinExtendedB(code);
40811: desret_int(ret_val);
40812: call_tests++;
40813: des_int(n_code, code, 0);
40814: xmlResetLastError();
40815: if (mem_base != xmlMemBlocks()) {
40816: printf("Leak of %d blocks found in xmlUCSIsLatinExtendedB",
40817: xmlMemBlocks() - mem_base);
40818: test_ret++;
40819: printf(" %d", n_code);
40820: printf("\n");
40821: }
40822: }
40823: function_tests++;
40824: #endif
40825:
40826: return(test_ret);
40827: }
40828:
40829:
40830: static int
40831: test_xmlUCSIsLetterlikeSymbols(void) {
40832: int test_ret = 0;
40833:
40834: #if defined(LIBXML_UNICODE_ENABLED)
40835: int mem_base;
40836: int ret_val;
40837: int code; /* UCS code point */
40838: int n_code;
40839:
40840: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40841: mem_base = xmlMemBlocks();
40842: code = gen_int(n_code, 0);
40843:
40844: ret_val = xmlUCSIsLetterlikeSymbols(code);
40845: desret_int(ret_val);
40846: call_tests++;
40847: des_int(n_code, code, 0);
40848: xmlResetLastError();
40849: if (mem_base != xmlMemBlocks()) {
40850: printf("Leak of %d blocks found in xmlUCSIsLetterlikeSymbols",
40851: xmlMemBlocks() - mem_base);
40852: test_ret++;
40853: printf(" %d", n_code);
40854: printf("\n");
40855: }
40856: }
40857: function_tests++;
40858: #endif
40859:
40860: return(test_ret);
40861: }
40862:
40863:
40864: static int
40865: test_xmlUCSIsLimbu(void) {
40866: int test_ret = 0;
40867:
40868: #if defined(LIBXML_UNICODE_ENABLED)
40869: int mem_base;
40870: int ret_val;
40871: int code; /* UCS code point */
40872: int n_code;
40873:
40874: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40875: mem_base = xmlMemBlocks();
40876: code = gen_int(n_code, 0);
40877:
40878: ret_val = xmlUCSIsLimbu(code);
40879: desret_int(ret_val);
40880: call_tests++;
40881: des_int(n_code, code, 0);
40882: xmlResetLastError();
40883: if (mem_base != xmlMemBlocks()) {
40884: printf("Leak of %d blocks found in xmlUCSIsLimbu",
40885: xmlMemBlocks() - mem_base);
40886: test_ret++;
40887: printf(" %d", n_code);
40888: printf("\n");
40889: }
40890: }
40891: function_tests++;
40892: #endif
40893:
40894: return(test_ret);
40895: }
40896:
40897:
40898: static int
40899: test_xmlUCSIsLinearBIdeograms(void) {
40900: int test_ret = 0;
40901:
40902: #if defined(LIBXML_UNICODE_ENABLED)
40903: int mem_base;
40904: int ret_val;
40905: int code; /* UCS code point */
40906: int n_code;
40907:
40908: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40909: mem_base = xmlMemBlocks();
40910: code = gen_int(n_code, 0);
40911:
40912: ret_val = xmlUCSIsLinearBIdeograms(code);
40913: desret_int(ret_val);
40914: call_tests++;
40915: des_int(n_code, code, 0);
40916: xmlResetLastError();
40917: if (mem_base != xmlMemBlocks()) {
40918: printf("Leak of %d blocks found in xmlUCSIsLinearBIdeograms",
40919: xmlMemBlocks() - mem_base);
40920: test_ret++;
40921: printf(" %d", n_code);
40922: printf("\n");
40923: }
40924: }
40925: function_tests++;
40926: #endif
40927:
40928: return(test_ret);
40929: }
40930:
40931:
40932: static int
40933: test_xmlUCSIsLinearBSyllabary(void) {
40934: int test_ret = 0;
40935:
40936: #if defined(LIBXML_UNICODE_ENABLED)
40937: int mem_base;
40938: int ret_val;
40939: int code; /* UCS code point */
40940: int n_code;
40941:
40942: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40943: mem_base = xmlMemBlocks();
40944: code = gen_int(n_code, 0);
40945:
40946: ret_val = xmlUCSIsLinearBSyllabary(code);
40947: desret_int(ret_val);
40948: call_tests++;
40949: des_int(n_code, code, 0);
40950: xmlResetLastError();
40951: if (mem_base != xmlMemBlocks()) {
40952: printf("Leak of %d blocks found in xmlUCSIsLinearBSyllabary",
40953: xmlMemBlocks() - mem_base);
40954: test_ret++;
40955: printf(" %d", n_code);
40956: printf("\n");
40957: }
40958: }
40959: function_tests++;
40960: #endif
40961:
40962: return(test_ret);
40963: }
40964:
40965:
40966: static int
40967: test_xmlUCSIsLowSurrogates(void) {
40968: int test_ret = 0;
40969:
40970: #if defined(LIBXML_UNICODE_ENABLED)
40971: int mem_base;
40972: int ret_val;
40973: int code; /* UCS code point */
40974: int n_code;
40975:
40976: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40977: mem_base = xmlMemBlocks();
40978: code = gen_int(n_code, 0);
40979:
40980: ret_val = xmlUCSIsLowSurrogates(code);
40981: desret_int(ret_val);
40982: call_tests++;
40983: des_int(n_code, code, 0);
40984: xmlResetLastError();
40985: if (mem_base != xmlMemBlocks()) {
40986: printf("Leak of %d blocks found in xmlUCSIsLowSurrogates",
40987: xmlMemBlocks() - mem_base);
40988: test_ret++;
40989: printf(" %d", n_code);
40990: printf("\n");
40991: }
40992: }
40993: function_tests++;
40994: #endif
40995:
40996: return(test_ret);
40997: }
40998:
40999:
41000: static int
41001: test_xmlUCSIsMalayalam(void) {
41002: int test_ret = 0;
41003:
41004: #if defined(LIBXML_UNICODE_ENABLED)
41005: int mem_base;
41006: int ret_val;
41007: int code; /* UCS code point */
41008: int n_code;
41009:
41010: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41011: mem_base = xmlMemBlocks();
41012: code = gen_int(n_code, 0);
41013:
41014: ret_val = xmlUCSIsMalayalam(code);
41015: desret_int(ret_val);
41016: call_tests++;
41017: des_int(n_code, code, 0);
41018: xmlResetLastError();
41019: if (mem_base != xmlMemBlocks()) {
41020: printf("Leak of %d blocks found in xmlUCSIsMalayalam",
41021: xmlMemBlocks() - mem_base);
41022: test_ret++;
41023: printf(" %d", n_code);
41024: printf("\n");
41025: }
41026: }
41027: function_tests++;
41028: #endif
41029:
41030: return(test_ret);
41031: }
41032:
41033:
41034: static int
41035: test_xmlUCSIsMathematicalAlphanumericSymbols(void) {
41036: int test_ret = 0;
41037:
41038: #if defined(LIBXML_UNICODE_ENABLED)
41039: int mem_base;
41040: int ret_val;
41041: int code; /* UCS code point */
41042: int n_code;
41043:
41044: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41045: mem_base = xmlMemBlocks();
41046: code = gen_int(n_code, 0);
41047:
41048: ret_val = xmlUCSIsMathematicalAlphanumericSymbols(code);
41049: desret_int(ret_val);
41050: call_tests++;
41051: des_int(n_code, code, 0);
41052: xmlResetLastError();
41053: if (mem_base != xmlMemBlocks()) {
41054: printf("Leak of %d blocks found in xmlUCSIsMathematicalAlphanumericSymbols",
41055: xmlMemBlocks() - mem_base);
41056: test_ret++;
41057: printf(" %d", n_code);
41058: printf("\n");
41059: }
41060: }
41061: function_tests++;
41062: #endif
41063:
41064: return(test_ret);
41065: }
41066:
41067:
41068: static int
41069: test_xmlUCSIsMathematicalOperators(void) {
41070: int test_ret = 0;
41071:
41072: #if defined(LIBXML_UNICODE_ENABLED)
41073: int mem_base;
41074: int ret_val;
41075: int code; /* UCS code point */
41076: int n_code;
41077:
41078: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41079: mem_base = xmlMemBlocks();
41080: code = gen_int(n_code, 0);
41081:
41082: ret_val = xmlUCSIsMathematicalOperators(code);
41083: desret_int(ret_val);
41084: call_tests++;
41085: des_int(n_code, code, 0);
41086: xmlResetLastError();
41087: if (mem_base != xmlMemBlocks()) {
41088: printf("Leak of %d blocks found in xmlUCSIsMathematicalOperators",
41089: xmlMemBlocks() - mem_base);
41090: test_ret++;
41091: printf(" %d", n_code);
41092: printf("\n");
41093: }
41094: }
41095: function_tests++;
41096: #endif
41097:
41098: return(test_ret);
41099: }
41100:
41101:
41102: static int
41103: test_xmlUCSIsMiscellaneousMathematicalSymbolsA(void) {
41104: int test_ret = 0;
41105:
41106: #if defined(LIBXML_UNICODE_ENABLED)
41107: int mem_base;
41108: int ret_val;
41109: int code; /* UCS code point */
41110: int n_code;
41111:
41112: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41113: mem_base = xmlMemBlocks();
41114: code = gen_int(n_code, 0);
41115:
41116: ret_val = xmlUCSIsMiscellaneousMathematicalSymbolsA(code);
41117: desret_int(ret_val);
41118: call_tests++;
41119: des_int(n_code, code, 0);
41120: xmlResetLastError();
41121: if (mem_base != xmlMemBlocks()) {
41122: printf("Leak of %d blocks found in xmlUCSIsMiscellaneousMathematicalSymbolsA",
41123: xmlMemBlocks() - mem_base);
41124: test_ret++;
41125: printf(" %d", n_code);
41126: printf("\n");
41127: }
41128: }
41129: function_tests++;
41130: #endif
41131:
41132: return(test_ret);
41133: }
41134:
41135:
41136: static int
41137: test_xmlUCSIsMiscellaneousMathematicalSymbolsB(void) {
41138: int test_ret = 0;
41139:
41140: #if defined(LIBXML_UNICODE_ENABLED)
41141: int mem_base;
41142: int ret_val;
41143: int code; /* UCS code point */
41144: int n_code;
41145:
41146: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41147: mem_base = xmlMemBlocks();
41148: code = gen_int(n_code, 0);
41149:
41150: ret_val = xmlUCSIsMiscellaneousMathematicalSymbolsB(code);
41151: desret_int(ret_val);
41152: call_tests++;
41153: des_int(n_code, code, 0);
41154: xmlResetLastError();
41155: if (mem_base != xmlMemBlocks()) {
41156: printf("Leak of %d blocks found in xmlUCSIsMiscellaneousMathematicalSymbolsB",
41157: xmlMemBlocks() - mem_base);
41158: test_ret++;
41159: printf(" %d", n_code);
41160: printf("\n");
41161: }
41162: }
41163: function_tests++;
41164: #endif
41165:
41166: return(test_ret);
41167: }
41168:
41169:
41170: static int
41171: test_xmlUCSIsMiscellaneousSymbols(void) {
41172: int test_ret = 0;
41173:
41174: #if defined(LIBXML_UNICODE_ENABLED)
41175: int mem_base;
41176: int ret_val;
41177: int code; /* UCS code point */
41178: int n_code;
41179:
41180: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41181: mem_base = xmlMemBlocks();
41182: code = gen_int(n_code, 0);
41183:
41184: ret_val = xmlUCSIsMiscellaneousSymbols(code);
41185: desret_int(ret_val);
41186: call_tests++;
41187: des_int(n_code, code, 0);
41188: xmlResetLastError();
41189: if (mem_base != xmlMemBlocks()) {
41190: printf("Leak of %d blocks found in xmlUCSIsMiscellaneousSymbols",
41191: xmlMemBlocks() - mem_base);
41192: test_ret++;
41193: printf(" %d", n_code);
41194: printf("\n");
41195: }
41196: }
41197: function_tests++;
41198: #endif
41199:
41200: return(test_ret);
41201: }
41202:
41203:
41204: static int
41205: test_xmlUCSIsMiscellaneousSymbolsandArrows(void) {
41206: int test_ret = 0;
41207:
41208: #if defined(LIBXML_UNICODE_ENABLED)
41209: int mem_base;
41210: int ret_val;
41211: int code; /* UCS code point */
41212: int n_code;
41213:
41214: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41215: mem_base = xmlMemBlocks();
41216: code = gen_int(n_code, 0);
41217:
41218: ret_val = xmlUCSIsMiscellaneousSymbolsandArrows(code);
41219: desret_int(ret_val);
41220: call_tests++;
41221: des_int(n_code, code, 0);
41222: xmlResetLastError();
41223: if (mem_base != xmlMemBlocks()) {
41224: printf("Leak of %d blocks found in xmlUCSIsMiscellaneousSymbolsandArrows",
41225: xmlMemBlocks() - mem_base);
41226: test_ret++;
41227: printf(" %d", n_code);
41228: printf("\n");
41229: }
41230: }
41231: function_tests++;
41232: #endif
41233:
41234: return(test_ret);
41235: }
41236:
41237:
41238: static int
41239: test_xmlUCSIsMiscellaneousTechnical(void) {
41240: int test_ret = 0;
41241:
41242: #if defined(LIBXML_UNICODE_ENABLED)
41243: int mem_base;
41244: int ret_val;
41245: int code; /* UCS code point */
41246: int n_code;
41247:
41248: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41249: mem_base = xmlMemBlocks();
41250: code = gen_int(n_code, 0);
41251:
41252: ret_val = xmlUCSIsMiscellaneousTechnical(code);
41253: desret_int(ret_val);
41254: call_tests++;
41255: des_int(n_code, code, 0);
41256: xmlResetLastError();
41257: if (mem_base != xmlMemBlocks()) {
41258: printf("Leak of %d blocks found in xmlUCSIsMiscellaneousTechnical",
41259: xmlMemBlocks() - mem_base);
41260: test_ret++;
41261: printf(" %d", n_code);
41262: printf("\n");
41263: }
41264: }
41265: function_tests++;
41266: #endif
41267:
41268: return(test_ret);
41269: }
41270:
41271:
41272: static int
41273: test_xmlUCSIsMongolian(void) {
41274: int test_ret = 0;
41275:
41276: #if defined(LIBXML_UNICODE_ENABLED)
41277: int mem_base;
41278: int ret_val;
41279: int code; /* UCS code point */
41280: int n_code;
41281:
41282: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41283: mem_base = xmlMemBlocks();
41284: code = gen_int(n_code, 0);
41285:
41286: ret_val = xmlUCSIsMongolian(code);
41287: desret_int(ret_val);
41288: call_tests++;
41289: des_int(n_code, code, 0);
41290: xmlResetLastError();
41291: if (mem_base != xmlMemBlocks()) {
41292: printf("Leak of %d blocks found in xmlUCSIsMongolian",
41293: xmlMemBlocks() - mem_base);
41294: test_ret++;
41295: printf(" %d", n_code);
41296: printf("\n");
41297: }
41298: }
41299: function_tests++;
41300: #endif
41301:
41302: return(test_ret);
41303: }
41304:
41305:
41306: static int
41307: test_xmlUCSIsMusicalSymbols(void) {
41308: int test_ret = 0;
41309:
41310: #if defined(LIBXML_UNICODE_ENABLED)
41311: int mem_base;
41312: int ret_val;
41313: int code; /* UCS code point */
41314: int n_code;
41315:
41316: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41317: mem_base = xmlMemBlocks();
41318: code = gen_int(n_code, 0);
41319:
41320: ret_val = xmlUCSIsMusicalSymbols(code);
41321: desret_int(ret_val);
41322: call_tests++;
41323: des_int(n_code, code, 0);
41324: xmlResetLastError();
41325: if (mem_base != xmlMemBlocks()) {
41326: printf("Leak of %d blocks found in xmlUCSIsMusicalSymbols",
41327: xmlMemBlocks() - mem_base);
41328: test_ret++;
41329: printf(" %d", n_code);
41330: printf("\n");
41331: }
41332: }
41333: function_tests++;
41334: #endif
41335:
41336: return(test_ret);
41337: }
41338:
41339:
41340: static int
41341: test_xmlUCSIsMyanmar(void) {
41342: int test_ret = 0;
41343:
41344: #if defined(LIBXML_UNICODE_ENABLED)
41345: int mem_base;
41346: int ret_val;
41347: int code; /* UCS code point */
41348: int n_code;
41349:
41350: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41351: mem_base = xmlMemBlocks();
41352: code = gen_int(n_code, 0);
41353:
41354: ret_val = xmlUCSIsMyanmar(code);
41355: desret_int(ret_val);
41356: call_tests++;
41357: des_int(n_code, code, 0);
41358: xmlResetLastError();
41359: if (mem_base != xmlMemBlocks()) {
41360: printf("Leak of %d blocks found in xmlUCSIsMyanmar",
41361: xmlMemBlocks() - mem_base);
41362: test_ret++;
41363: printf(" %d", n_code);
41364: printf("\n");
41365: }
41366: }
41367: function_tests++;
41368: #endif
41369:
41370: return(test_ret);
41371: }
41372:
41373:
41374: static int
41375: test_xmlUCSIsNumberForms(void) {
41376: int test_ret = 0;
41377:
41378: #if defined(LIBXML_UNICODE_ENABLED)
41379: int mem_base;
41380: int ret_val;
41381: int code; /* UCS code point */
41382: int n_code;
41383:
41384: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41385: mem_base = xmlMemBlocks();
41386: code = gen_int(n_code, 0);
41387:
41388: ret_val = xmlUCSIsNumberForms(code);
41389: desret_int(ret_val);
41390: call_tests++;
41391: des_int(n_code, code, 0);
41392: xmlResetLastError();
41393: if (mem_base != xmlMemBlocks()) {
41394: printf("Leak of %d blocks found in xmlUCSIsNumberForms",
41395: xmlMemBlocks() - mem_base);
41396: test_ret++;
41397: printf(" %d", n_code);
41398: printf("\n");
41399: }
41400: }
41401: function_tests++;
41402: #endif
41403:
41404: return(test_ret);
41405: }
41406:
41407:
41408: static int
41409: test_xmlUCSIsOgham(void) {
41410: int test_ret = 0;
41411:
41412: #if defined(LIBXML_UNICODE_ENABLED)
41413: int mem_base;
41414: int ret_val;
41415: int code; /* UCS code point */
41416: int n_code;
41417:
41418: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41419: mem_base = xmlMemBlocks();
41420: code = gen_int(n_code, 0);
41421:
41422: ret_val = xmlUCSIsOgham(code);
41423: desret_int(ret_val);
41424: call_tests++;
41425: des_int(n_code, code, 0);
41426: xmlResetLastError();
41427: if (mem_base != xmlMemBlocks()) {
41428: printf("Leak of %d blocks found in xmlUCSIsOgham",
41429: xmlMemBlocks() - mem_base);
41430: test_ret++;
41431: printf(" %d", n_code);
41432: printf("\n");
41433: }
41434: }
41435: function_tests++;
41436: #endif
41437:
41438: return(test_ret);
41439: }
41440:
41441:
41442: static int
41443: test_xmlUCSIsOldItalic(void) {
41444: int test_ret = 0;
41445:
41446: #if defined(LIBXML_UNICODE_ENABLED)
41447: int mem_base;
41448: int ret_val;
41449: int code; /* UCS code point */
41450: int n_code;
41451:
41452: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41453: mem_base = xmlMemBlocks();
41454: code = gen_int(n_code, 0);
41455:
41456: ret_val = xmlUCSIsOldItalic(code);
41457: desret_int(ret_val);
41458: call_tests++;
41459: des_int(n_code, code, 0);
41460: xmlResetLastError();
41461: if (mem_base != xmlMemBlocks()) {
41462: printf("Leak of %d blocks found in xmlUCSIsOldItalic",
41463: xmlMemBlocks() - mem_base);
41464: test_ret++;
41465: printf(" %d", n_code);
41466: printf("\n");
41467: }
41468: }
41469: function_tests++;
41470: #endif
41471:
41472: return(test_ret);
41473: }
41474:
41475:
41476: static int
41477: test_xmlUCSIsOpticalCharacterRecognition(void) {
41478: int test_ret = 0;
41479:
41480: #if defined(LIBXML_UNICODE_ENABLED)
41481: int mem_base;
41482: int ret_val;
41483: int code; /* UCS code point */
41484: int n_code;
41485:
41486: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41487: mem_base = xmlMemBlocks();
41488: code = gen_int(n_code, 0);
41489:
41490: ret_val = xmlUCSIsOpticalCharacterRecognition(code);
41491: desret_int(ret_val);
41492: call_tests++;
41493: des_int(n_code, code, 0);
41494: xmlResetLastError();
41495: if (mem_base != xmlMemBlocks()) {
41496: printf("Leak of %d blocks found in xmlUCSIsOpticalCharacterRecognition",
41497: xmlMemBlocks() - mem_base);
41498: test_ret++;
41499: printf(" %d", n_code);
41500: printf("\n");
41501: }
41502: }
41503: function_tests++;
41504: #endif
41505:
41506: return(test_ret);
41507: }
41508:
41509:
41510: static int
41511: test_xmlUCSIsOriya(void) {
41512: int test_ret = 0;
41513:
41514: #if defined(LIBXML_UNICODE_ENABLED)
41515: int mem_base;
41516: int ret_val;
41517: int code; /* UCS code point */
41518: int n_code;
41519:
41520: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41521: mem_base = xmlMemBlocks();
41522: code = gen_int(n_code, 0);
41523:
41524: ret_val = xmlUCSIsOriya(code);
41525: desret_int(ret_val);
41526: call_tests++;
41527: des_int(n_code, code, 0);
41528: xmlResetLastError();
41529: if (mem_base != xmlMemBlocks()) {
41530: printf("Leak of %d blocks found in xmlUCSIsOriya",
41531: xmlMemBlocks() - mem_base);
41532: test_ret++;
41533: printf(" %d", n_code);
41534: printf("\n");
41535: }
41536: }
41537: function_tests++;
41538: #endif
41539:
41540: return(test_ret);
41541: }
41542:
41543:
41544: static int
41545: test_xmlUCSIsOsmanya(void) {
41546: int test_ret = 0;
41547:
41548: #if defined(LIBXML_UNICODE_ENABLED)
41549: int mem_base;
41550: int ret_val;
41551: int code; /* UCS code point */
41552: int n_code;
41553:
41554: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41555: mem_base = xmlMemBlocks();
41556: code = gen_int(n_code, 0);
41557:
41558: ret_val = xmlUCSIsOsmanya(code);
41559: desret_int(ret_val);
41560: call_tests++;
41561: des_int(n_code, code, 0);
41562: xmlResetLastError();
41563: if (mem_base != xmlMemBlocks()) {
41564: printf("Leak of %d blocks found in xmlUCSIsOsmanya",
41565: xmlMemBlocks() - mem_base);
41566: test_ret++;
41567: printf(" %d", n_code);
41568: printf("\n");
41569: }
41570: }
41571: function_tests++;
41572: #endif
41573:
41574: return(test_ret);
41575: }
41576:
41577:
41578: static int
41579: test_xmlUCSIsPhoneticExtensions(void) {
41580: int test_ret = 0;
41581:
41582: #if defined(LIBXML_UNICODE_ENABLED)
41583: int mem_base;
41584: int ret_val;
41585: int code; /* UCS code point */
41586: int n_code;
41587:
41588: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41589: mem_base = xmlMemBlocks();
41590: code = gen_int(n_code, 0);
41591:
41592: ret_val = xmlUCSIsPhoneticExtensions(code);
41593: desret_int(ret_val);
41594: call_tests++;
41595: des_int(n_code, code, 0);
41596: xmlResetLastError();
41597: if (mem_base != xmlMemBlocks()) {
41598: printf("Leak of %d blocks found in xmlUCSIsPhoneticExtensions",
41599: xmlMemBlocks() - mem_base);
41600: test_ret++;
41601: printf(" %d", n_code);
41602: printf("\n");
41603: }
41604: }
41605: function_tests++;
41606: #endif
41607:
41608: return(test_ret);
41609: }
41610:
41611:
41612: static int
41613: test_xmlUCSIsPrivateUse(void) {
41614: int test_ret = 0;
41615:
41616: #if defined(LIBXML_UNICODE_ENABLED)
41617: int mem_base;
41618: int ret_val;
41619: int code; /* UCS code point */
41620: int n_code;
41621:
41622: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41623: mem_base = xmlMemBlocks();
41624: code = gen_int(n_code, 0);
41625:
41626: ret_val = xmlUCSIsPrivateUse(code);
41627: desret_int(ret_val);
41628: call_tests++;
41629: des_int(n_code, code, 0);
41630: xmlResetLastError();
41631: if (mem_base != xmlMemBlocks()) {
41632: printf("Leak of %d blocks found in xmlUCSIsPrivateUse",
41633: xmlMemBlocks() - mem_base);
41634: test_ret++;
41635: printf(" %d", n_code);
41636: printf("\n");
41637: }
41638: }
41639: function_tests++;
41640: #endif
41641:
41642: return(test_ret);
41643: }
41644:
41645:
41646: static int
41647: test_xmlUCSIsPrivateUseArea(void) {
41648: int test_ret = 0;
41649:
41650: #if defined(LIBXML_UNICODE_ENABLED)
41651: int mem_base;
41652: int ret_val;
41653: int code; /* UCS code point */
41654: int n_code;
41655:
41656: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41657: mem_base = xmlMemBlocks();
41658: code = gen_int(n_code, 0);
41659:
41660: ret_val = xmlUCSIsPrivateUseArea(code);
41661: desret_int(ret_val);
41662: call_tests++;
41663: des_int(n_code, code, 0);
41664: xmlResetLastError();
41665: if (mem_base != xmlMemBlocks()) {
41666: printf("Leak of %d blocks found in xmlUCSIsPrivateUseArea",
41667: xmlMemBlocks() - mem_base);
41668: test_ret++;
41669: printf(" %d", n_code);
41670: printf("\n");
41671: }
41672: }
41673: function_tests++;
41674: #endif
41675:
41676: return(test_ret);
41677: }
41678:
41679:
41680: static int
41681: test_xmlUCSIsRunic(void) {
41682: int test_ret = 0;
41683:
41684: #if defined(LIBXML_UNICODE_ENABLED)
41685: int mem_base;
41686: int ret_val;
41687: int code; /* UCS code point */
41688: int n_code;
41689:
41690: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41691: mem_base = xmlMemBlocks();
41692: code = gen_int(n_code, 0);
41693:
41694: ret_val = xmlUCSIsRunic(code);
41695: desret_int(ret_val);
41696: call_tests++;
41697: des_int(n_code, code, 0);
41698: xmlResetLastError();
41699: if (mem_base != xmlMemBlocks()) {
41700: printf("Leak of %d blocks found in xmlUCSIsRunic",
41701: xmlMemBlocks() - mem_base);
41702: test_ret++;
41703: printf(" %d", n_code);
41704: printf("\n");
41705: }
41706: }
41707: function_tests++;
41708: #endif
41709:
41710: return(test_ret);
41711: }
41712:
41713:
41714: static int
41715: test_xmlUCSIsShavian(void) {
41716: int test_ret = 0;
41717:
41718: #if defined(LIBXML_UNICODE_ENABLED)
41719: int mem_base;
41720: int ret_val;
41721: int code; /* UCS code point */
41722: int n_code;
41723:
41724: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41725: mem_base = xmlMemBlocks();
41726: code = gen_int(n_code, 0);
41727:
41728: ret_val = xmlUCSIsShavian(code);
41729: desret_int(ret_val);
41730: call_tests++;
41731: des_int(n_code, code, 0);
41732: xmlResetLastError();
41733: if (mem_base != xmlMemBlocks()) {
41734: printf("Leak of %d blocks found in xmlUCSIsShavian",
41735: xmlMemBlocks() - mem_base);
41736: test_ret++;
41737: printf(" %d", n_code);
41738: printf("\n");
41739: }
41740: }
41741: function_tests++;
41742: #endif
41743:
41744: return(test_ret);
41745: }
41746:
41747:
41748: static int
41749: test_xmlUCSIsSinhala(void) {
41750: int test_ret = 0;
41751:
41752: #if defined(LIBXML_UNICODE_ENABLED)
41753: int mem_base;
41754: int ret_val;
41755: int code; /* UCS code point */
41756: int n_code;
41757:
41758: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41759: mem_base = xmlMemBlocks();
41760: code = gen_int(n_code, 0);
41761:
41762: ret_val = xmlUCSIsSinhala(code);
41763: desret_int(ret_val);
41764: call_tests++;
41765: des_int(n_code, code, 0);
41766: xmlResetLastError();
41767: if (mem_base != xmlMemBlocks()) {
41768: printf("Leak of %d blocks found in xmlUCSIsSinhala",
41769: xmlMemBlocks() - mem_base);
41770: test_ret++;
41771: printf(" %d", n_code);
41772: printf("\n");
41773: }
41774: }
41775: function_tests++;
41776: #endif
41777:
41778: return(test_ret);
41779: }
41780:
41781:
41782: static int
41783: test_xmlUCSIsSmallFormVariants(void) {
41784: int test_ret = 0;
41785:
41786: #if defined(LIBXML_UNICODE_ENABLED)
41787: int mem_base;
41788: int ret_val;
41789: int code; /* UCS code point */
41790: int n_code;
41791:
41792: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41793: mem_base = xmlMemBlocks();
41794: code = gen_int(n_code, 0);
41795:
41796: ret_val = xmlUCSIsSmallFormVariants(code);
41797: desret_int(ret_val);
41798: call_tests++;
41799: des_int(n_code, code, 0);
41800: xmlResetLastError();
41801: if (mem_base != xmlMemBlocks()) {
41802: printf("Leak of %d blocks found in xmlUCSIsSmallFormVariants",
41803: xmlMemBlocks() - mem_base);
41804: test_ret++;
41805: printf(" %d", n_code);
41806: printf("\n");
41807: }
41808: }
41809: function_tests++;
41810: #endif
41811:
41812: return(test_ret);
41813: }
41814:
41815:
41816: static int
41817: test_xmlUCSIsSpacingModifierLetters(void) {
41818: int test_ret = 0;
41819:
41820: #if defined(LIBXML_UNICODE_ENABLED)
41821: int mem_base;
41822: int ret_val;
41823: int code; /* UCS code point */
41824: int n_code;
41825:
41826: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41827: mem_base = xmlMemBlocks();
41828: code = gen_int(n_code, 0);
41829:
41830: ret_val = xmlUCSIsSpacingModifierLetters(code);
41831: desret_int(ret_val);
41832: call_tests++;
41833: des_int(n_code, code, 0);
41834: xmlResetLastError();
41835: if (mem_base != xmlMemBlocks()) {
41836: printf("Leak of %d blocks found in xmlUCSIsSpacingModifierLetters",
41837: xmlMemBlocks() - mem_base);
41838: test_ret++;
41839: printf(" %d", n_code);
41840: printf("\n");
41841: }
41842: }
41843: function_tests++;
41844: #endif
41845:
41846: return(test_ret);
41847: }
41848:
41849:
41850: static int
41851: test_xmlUCSIsSpecials(void) {
41852: int test_ret = 0;
41853:
41854: #if defined(LIBXML_UNICODE_ENABLED)
41855: int mem_base;
41856: int ret_val;
41857: int code; /* UCS code point */
41858: int n_code;
41859:
41860: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41861: mem_base = xmlMemBlocks();
41862: code = gen_int(n_code, 0);
41863:
41864: ret_val = xmlUCSIsSpecials(code);
41865: desret_int(ret_val);
41866: call_tests++;
41867: des_int(n_code, code, 0);
41868: xmlResetLastError();
41869: if (mem_base != xmlMemBlocks()) {
41870: printf("Leak of %d blocks found in xmlUCSIsSpecials",
41871: xmlMemBlocks() - mem_base);
41872: test_ret++;
41873: printf(" %d", n_code);
41874: printf("\n");
41875: }
41876: }
41877: function_tests++;
41878: #endif
41879:
41880: return(test_ret);
41881: }
41882:
41883:
41884: static int
41885: test_xmlUCSIsSuperscriptsandSubscripts(void) {
41886: int test_ret = 0;
41887:
41888: #if defined(LIBXML_UNICODE_ENABLED)
41889: int mem_base;
41890: int ret_val;
41891: int code; /* UCS code point */
41892: int n_code;
41893:
41894: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41895: mem_base = xmlMemBlocks();
41896: code = gen_int(n_code, 0);
41897:
41898: ret_val = xmlUCSIsSuperscriptsandSubscripts(code);
41899: desret_int(ret_val);
41900: call_tests++;
41901: des_int(n_code, code, 0);
41902: xmlResetLastError();
41903: if (mem_base != xmlMemBlocks()) {
41904: printf("Leak of %d blocks found in xmlUCSIsSuperscriptsandSubscripts",
41905: xmlMemBlocks() - mem_base);
41906: test_ret++;
41907: printf(" %d", n_code);
41908: printf("\n");
41909: }
41910: }
41911: function_tests++;
41912: #endif
41913:
41914: return(test_ret);
41915: }
41916:
41917:
41918: static int
41919: test_xmlUCSIsSupplementalArrowsA(void) {
41920: int test_ret = 0;
41921:
41922: #if defined(LIBXML_UNICODE_ENABLED)
41923: int mem_base;
41924: int ret_val;
41925: int code; /* UCS code point */
41926: int n_code;
41927:
41928: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41929: mem_base = xmlMemBlocks();
41930: code = gen_int(n_code, 0);
41931:
41932: ret_val = xmlUCSIsSupplementalArrowsA(code);
41933: desret_int(ret_val);
41934: call_tests++;
41935: des_int(n_code, code, 0);
41936: xmlResetLastError();
41937: if (mem_base != xmlMemBlocks()) {
41938: printf("Leak of %d blocks found in xmlUCSIsSupplementalArrowsA",
41939: xmlMemBlocks() - mem_base);
41940: test_ret++;
41941: printf(" %d", n_code);
41942: printf("\n");
41943: }
41944: }
41945: function_tests++;
41946: #endif
41947:
41948: return(test_ret);
41949: }
41950:
41951:
41952: static int
41953: test_xmlUCSIsSupplementalArrowsB(void) {
41954: int test_ret = 0;
41955:
41956: #if defined(LIBXML_UNICODE_ENABLED)
41957: int mem_base;
41958: int ret_val;
41959: int code; /* UCS code point */
41960: int n_code;
41961:
41962: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41963: mem_base = xmlMemBlocks();
41964: code = gen_int(n_code, 0);
41965:
41966: ret_val = xmlUCSIsSupplementalArrowsB(code);
41967: desret_int(ret_val);
41968: call_tests++;
41969: des_int(n_code, code, 0);
41970: xmlResetLastError();
41971: if (mem_base != xmlMemBlocks()) {
41972: printf("Leak of %d blocks found in xmlUCSIsSupplementalArrowsB",
41973: xmlMemBlocks() - mem_base);
41974: test_ret++;
41975: printf(" %d", n_code);
41976: printf("\n");
41977: }
41978: }
41979: function_tests++;
41980: #endif
41981:
41982: return(test_ret);
41983: }
41984:
41985:
41986: static int
41987: test_xmlUCSIsSupplementalMathematicalOperators(void) {
41988: int test_ret = 0;
41989:
41990: #if defined(LIBXML_UNICODE_ENABLED)
41991: int mem_base;
41992: int ret_val;
41993: int code; /* UCS code point */
41994: int n_code;
41995:
41996: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41997: mem_base = xmlMemBlocks();
41998: code = gen_int(n_code, 0);
41999:
42000: ret_val = xmlUCSIsSupplementalMathematicalOperators(code);
42001: desret_int(ret_val);
42002: call_tests++;
42003: des_int(n_code, code, 0);
42004: xmlResetLastError();
42005: if (mem_base != xmlMemBlocks()) {
42006: printf("Leak of %d blocks found in xmlUCSIsSupplementalMathematicalOperators",
42007: xmlMemBlocks() - mem_base);
42008: test_ret++;
42009: printf(" %d", n_code);
42010: printf("\n");
42011: }
42012: }
42013: function_tests++;
42014: #endif
42015:
42016: return(test_ret);
42017: }
42018:
42019:
42020: static int
42021: test_xmlUCSIsSupplementaryPrivateUseAreaA(void) {
42022: int test_ret = 0;
42023:
42024: #if defined(LIBXML_UNICODE_ENABLED)
42025: int mem_base;
42026: int ret_val;
42027: int code; /* UCS code point */
42028: int n_code;
42029:
42030: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42031: mem_base = xmlMemBlocks();
42032: code = gen_int(n_code, 0);
42033:
42034: ret_val = xmlUCSIsSupplementaryPrivateUseAreaA(code);
42035: desret_int(ret_val);
42036: call_tests++;
42037: des_int(n_code, code, 0);
42038: xmlResetLastError();
42039: if (mem_base != xmlMemBlocks()) {
42040: printf("Leak of %d blocks found in xmlUCSIsSupplementaryPrivateUseAreaA",
42041: xmlMemBlocks() - mem_base);
42042: test_ret++;
42043: printf(" %d", n_code);
42044: printf("\n");
42045: }
42046: }
42047: function_tests++;
42048: #endif
42049:
42050: return(test_ret);
42051: }
42052:
42053:
42054: static int
42055: test_xmlUCSIsSupplementaryPrivateUseAreaB(void) {
42056: int test_ret = 0;
42057:
42058: #if defined(LIBXML_UNICODE_ENABLED)
42059: int mem_base;
42060: int ret_val;
42061: int code; /* UCS code point */
42062: int n_code;
42063:
42064: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42065: mem_base = xmlMemBlocks();
42066: code = gen_int(n_code, 0);
42067:
42068: ret_val = xmlUCSIsSupplementaryPrivateUseAreaB(code);
42069: desret_int(ret_val);
42070: call_tests++;
42071: des_int(n_code, code, 0);
42072: xmlResetLastError();
42073: if (mem_base != xmlMemBlocks()) {
42074: printf("Leak of %d blocks found in xmlUCSIsSupplementaryPrivateUseAreaB",
42075: xmlMemBlocks() - mem_base);
42076: test_ret++;
42077: printf(" %d", n_code);
42078: printf("\n");
42079: }
42080: }
42081: function_tests++;
42082: #endif
42083:
42084: return(test_ret);
42085: }
42086:
42087:
42088: static int
42089: test_xmlUCSIsSyriac(void) {
42090: int test_ret = 0;
42091:
42092: #if defined(LIBXML_UNICODE_ENABLED)
42093: int mem_base;
42094: int ret_val;
42095: int code; /* UCS code point */
42096: int n_code;
42097:
42098: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42099: mem_base = xmlMemBlocks();
42100: code = gen_int(n_code, 0);
42101:
42102: ret_val = xmlUCSIsSyriac(code);
42103: desret_int(ret_val);
42104: call_tests++;
42105: des_int(n_code, code, 0);
42106: xmlResetLastError();
42107: if (mem_base != xmlMemBlocks()) {
42108: printf("Leak of %d blocks found in xmlUCSIsSyriac",
42109: xmlMemBlocks() - mem_base);
42110: test_ret++;
42111: printf(" %d", n_code);
42112: printf("\n");
42113: }
42114: }
42115: function_tests++;
42116: #endif
42117:
42118: return(test_ret);
42119: }
42120:
42121:
42122: static int
42123: test_xmlUCSIsTagalog(void) {
42124: int test_ret = 0;
42125:
42126: #if defined(LIBXML_UNICODE_ENABLED)
42127: int mem_base;
42128: int ret_val;
42129: int code; /* UCS code point */
42130: int n_code;
42131:
42132: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42133: mem_base = xmlMemBlocks();
42134: code = gen_int(n_code, 0);
42135:
42136: ret_val = xmlUCSIsTagalog(code);
42137: desret_int(ret_val);
42138: call_tests++;
42139: des_int(n_code, code, 0);
42140: xmlResetLastError();
42141: if (mem_base != xmlMemBlocks()) {
42142: printf("Leak of %d blocks found in xmlUCSIsTagalog",
42143: xmlMemBlocks() - mem_base);
42144: test_ret++;
42145: printf(" %d", n_code);
42146: printf("\n");
42147: }
42148: }
42149: function_tests++;
42150: #endif
42151:
42152: return(test_ret);
42153: }
42154:
42155:
42156: static int
42157: test_xmlUCSIsTagbanwa(void) {
42158: int test_ret = 0;
42159:
42160: #if defined(LIBXML_UNICODE_ENABLED)
42161: int mem_base;
42162: int ret_val;
42163: int code; /* UCS code point */
42164: int n_code;
42165:
42166: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42167: mem_base = xmlMemBlocks();
42168: code = gen_int(n_code, 0);
42169:
42170: ret_val = xmlUCSIsTagbanwa(code);
42171: desret_int(ret_val);
42172: call_tests++;
42173: des_int(n_code, code, 0);
42174: xmlResetLastError();
42175: if (mem_base != xmlMemBlocks()) {
42176: printf("Leak of %d blocks found in xmlUCSIsTagbanwa",
42177: xmlMemBlocks() - mem_base);
42178: test_ret++;
42179: printf(" %d", n_code);
42180: printf("\n");
42181: }
42182: }
42183: function_tests++;
42184: #endif
42185:
42186: return(test_ret);
42187: }
42188:
42189:
42190: static int
42191: test_xmlUCSIsTags(void) {
42192: int test_ret = 0;
42193:
42194: #if defined(LIBXML_UNICODE_ENABLED)
42195: int mem_base;
42196: int ret_val;
42197: int code; /* UCS code point */
42198: int n_code;
42199:
42200: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42201: mem_base = xmlMemBlocks();
42202: code = gen_int(n_code, 0);
42203:
42204: ret_val = xmlUCSIsTags(code);
42205: desret_int(ret_val);
42206: call_tests++;
42207: des_int(n_code, code, 0);
42208: xmlResetLastError();
42209: if (mem_base != xmlMemBlocks()) {
42210: printf("Leak of %d blocks found in xmlUCSIsTags",
42211: xmlMemBlocks() - mem_base);
42212: test_ret++;
42213: printf(" %d", n_code);
42214: printf("\n");
42215: }
42216: }
42217: function_tests++;
42218: #endif
42219:
42220: return(test_ret);
42221: }
42222:
42223:
42224: static int
42225: test_xmlUCSIsTaiLe(void) {
42226: int test_ret = 0;
42227:
42228: #if defined(LIBXML_UNICODE_ENABLED)
42229: int mem_base;
42230: int ret_val;
42231: int code; /* UCS code point */
42232: int n_code;
42233:
42234: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42235: mem_base = xmlMemBlocks();
42236: code = gen_int(n_code, 0);
42237:
42238: ret_val = xmlUCSIsTaiLe(code);
42239: desret_int(ret_val);
42240: call_tests++;
42241: des_int(n_code, code, 0);
42242: xmlResetLastError();
42243: if (mem_base != xmlMemBlocks()) {
42244: printf("Leak of %d blocks found in xmlUCSIsTaiLe",
42245: xmlMemBlocks() - mem_base);
42246: test_ret++;
42247: printf(" %d", n_code);
42248: printf("\n");
42249: }
42250: }
42251: function_tests++;
42252: #endif
42253:
42254: return(test_ret);
42255: }
42256:
42257:
42258: static int
42259: test_xmlUCSIsTaiXuanJingSymbols(void) {
42260: int test_ret = 0;
42261:
42262: #if defined(LIBXML_UNICODE_ENABLED)
42263: int mem_base;
42264: int ret_val;
42265: int code; /* UCS code point */
42266: int n_code;
42267:
42268: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42269: mem_base = xmlMemBlocks();
42270: code = gen_int(n_code, 0);
42271:
42272: ret_val = xmlUCSIsTaiXuanJingSymbols(code);
42273: desret_int(ret_val);
42274: call_tests++;
42275: des_int(n_code, code, 0);
42276: xmlResetLastError();
42277: if (mem_base != xmlMemBlocks()) {
42278: printf("Leak of %d blocks found in xmlUCSIsTaiXuanJingSymbols",
42279: xmlMemBlocks() - mem_base);
42280: test_ret++;
42281: printf(" %d", n_code);
42282: printf("\n");
42283: }
42284: }
42285: function_tests++;
42286: #endif
42287:
42288: return(test_ret);
42289: }
42290:
42291:
42292: static int
42293: test_xmlUCSIsTamil(void) {
42294: int test_ret = 0;
42295:
42296: #if defined(LIBXML_UNICODE_ENABLED)
42297: int mem_base;
42298: int ret_val;
42299: int code; /* UCS code point */
42300: int n_code;
42301:
42302: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42303: mem_base = xmlMemBlocks();
42304: code = gen_int(n_code, 0);
42305:
42306: ret_val = xmlUCSIsTamil(code);
42307: desret_int(ret_val);
42308: call_tests++;
42309: des_int(n_code, code, 0);
42310: xmlResetLastError();
42311: if (mem_base != xmlMemBlocks()) {
42312: printf("Leak of %d blocks found in xmlUCSIsTamil",
42313: xmlMemBlocks() - mem_base);
42314: test_ret++;
42315: printf(" %d", n_code);
42316: printf("\n");
42317: }
42318: }
42319: function_tests++;
42320: #endif
42321:
42322: return(test_ret);
42323: }
42324:
42325:
42326: static int
42327: test_xmlUCSIsTelugu(void) {
42328: int test_ret = 0;
42329:
42330: #if defined(LIBXML_UNICODE_ENABLED)
42331: int mem_base;
42332: int ret_val;
42333: int code; /* UCS code point */
42334: int n_code;
42335:
42336: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42337: mem_base = xmlMemBlocks();
42338: code = gen_int(n_code, 0);
42339:
42340: ret_val = xmlUCSIsTelugu(code);
42341: desret_int(ret_val);
42342: call_tests++;
42343: des_int(n_code, code, 0);
42344: xmlResetLastError();
42345: if (mem_base != xmlMemBlocks()) {
42346: printf("Leak of %d blocks found in xmlUCSIsTelugu",
42347: xmlMemBlocks() - mem_base);
42348: test_ret++;
42349: printf(" %d", n_code);
42350: printf("\n");
42351: }
42352: }
42353: function_tests++;
42354: #endif
42355:
42356: return(test_ret);
42357: }
42358:
42359:
42360: static int
42361: test_xmlUCSIsThaana(void) {
42362: int test_ret = 0;
42363:
42364: #if defined(LIBXML_UNICODE_ENABLED)
42365: int mem_base;
42366: int ret_val;
42367: int code; /* UCS code point */
42368: int n_code;
42369:
42370: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42371: mem_base = xmlMemBlocks();
42372: code = gen_int(n_code, 0);
42373:
42374: ret_val = xmlUCSIsThaana(code);
42375: desret_int(ret_val);
42376: call_tests++;
42377: des_int(n_code, code, 0);
42378: xmlResetLastError();
42379: if (mem_base != xmlMemBlocks()) {
42380: printf("Leak of %d blocks found in xmlUCSIsThaana",
42381: xmlMemBlocks() - mem_base);
42382: test_ret++;
42383: printf(" %d", n_code);
42384: printf("\n");
42385: }
42386: }
42387: function_tests++;
42388: #endif
42389:
42390: return(test_ret);
42391: }
42392:
42393:
42394: static int
42395: test_xmlUCSIsThai(void) {
42396: int test_ret = 0;
42397:
42398: #if defined(LIBXML_UNICODE_ENABLED)
42399: int mem_base;
42400: int ret_val;
42401: int code; /* UCS code point */
42402: int n_code;
42403:
42404: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42405: mem_base = xmlMemBlocks();
42406: code = gen_int(n_code, 0);
42407:
42408: ret_val = xmlUCSIsThai(code);
42409: desret_int(ret_val);
42410: call_tests++;
42411: des_int(n_code, code, 0);
42412: xmlResetLastError();
42413: if (mem_base != xmlMemBlocks()) {
42414: printf("Leak of %d blocks found in xmlUCSIsThai",
42415: xmlMemBlocks() - mem_base);
42416: test_ret++;
42417: printf(" %d", n_code);
42418: printf("\n");
42419: }
42420: }
42421: function_tests++;
42422: #endif
42423:
42424: return(test_ret);
42425: }
42426:
42427:
42428: static int
42429: test_xmlUCSIsTibetan(void) {
42430: int test_ret = 0;
42431:
42432: #if defined(LIBXML_UNICODE_ENABLED)
42433: int mem_base;
42434: int ret_val;
42435: int code; /* UCS code point */
42436: int n_code;
42437:
42438: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42439: mem_base = xmlMemBlocks();
42440: code = gen_int(n_code, 0);
42441:
42442: ret_val = xmlUCSIsTibetan(code);
42443: desret_int(ret_val);
42444: call_tests++;
42445: des_int(n_code, code, 0);
42446: xmlResetLastError();
42447: if (mem_base != xmlMemBlocks()) {
42448: printf("Leak of %d blocks found in xmlUCSIsTibetan",
42449: xmlMemBlocks() - mem_base);
42450: test_ret++;
42451: printf(" %d", n_code);
42452: printf("\n");
42453: }
42454: }
42455: function_tests++;
42456: #endif
42457:
42458: return(test_ret);
42459: }
42460:
42461:
42462: static int
42463: test_xmlUCSIsUgaritic(void) {
42464: int test_ret = 0;
42465:
42466: #if defined(LIBXML_UNICODE_ENABLED)
42467: int mem_base;
42468: int ret_val;
42469: int code; /* UCS code point */
42470: int n_code;
42471:
42472: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42473: mem_base = xmlMemBlocks();
42474: code = gen_int(n_code, 0);
42475:
42476: ret_val = xmlUCSIsUgaritic(code);
42477: desret_int(ret_val);
42478: call_tests++;
42479: des_int(n_code, code, 0);
42480: xmlResetLastError();
42481: if (mem_base != xmlMemBlocks()) {
42482: printf("Leak of %d blocks found in xmlUCSIsUgaritic",
42483: xmlMemBlocks() - mem_base);
42484: test_ret++;
42485: printf(" %d", n_code);
42486: printf("\n");
42487: }
42488: }
42489: function_tests++;
42490: #endif
42491:
42492: return(test_ret);
42493: }
42494:
42495:
42496: static int
42497: test_xmlUCSIsUnifiedCanadianAboriginalSyllabics(void) {
42498: int test_ret = 0;
42499:
42500: #if defined(LIBXML_UNICODE_ENABLED)
42501: int mem_base;
42502: int ret_val;
42503: int code; /* UCS code point */
42504: int n_code;
42505:
42506: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42507: mem_base = xmlMemBlocks();
42508: code = gen_int(n_code, 0);
42509:
42510: ret_val = xmlUCSIsUnifiedCanadianAboriginalSyllabics(code);
42511: desret_int(ret_val);
42512: call_tests++;
42513: des_int(n_code, code, 0);
42514: xmlResetLastError();
42515: if (mem_base != xmlMemBlocks()) {
42516: printf("Leak of %d blocks found in xmlUCSIsUnifiedCanadianAboriginalSyllabics",
42517: xmlMemBlocks() - mem_base);
42518: test_ret++;
42519: printf(" %d", n_code);
42520: printf("\n");
42521: }
42522: }
42523: function_tests++;
42524: #endif
42525:
42526: return(test_ret);
42527: }
42528:
42529:
42530: static int
42531: test_xmlUCSIsVariationSelectors(void) {
42532: int test_ret = 0;
42533:
42534: #if defined(LIBXML_UNICODE_ENABLED)
42535: int mem_base;
42536: int ret_val;
42537: int code; /* UCS code point */
42538: int n_code;
42539:
42540: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42541: mem_base = xmlMemBlocks();
42542: code = gen_int(n_code, 0);
42543:
42544: ret_val = xmlUCSIsVariationSelectors(code);
42545: desret_int(ret_val);
42546: call_tests++;
42547: des_int(n_code, code, 0);
42548: xmlResetLastError();
42549: if (mem_base != xmlMemBlocks()) {
42550: printf("Leak of %d blocks found in xmlUCSIsVariationSelectors",
42551: xmlMemBlocks() - mem_base);
42552: test_ret++;
42553: printf(" %d", n_code);
42554: printf("\n");
42555: }
42556: }
42557: function_tests++;
42558: #endif
42559:
42560: return(test_ret);
42561: }
42562:
42563:
42564: static int
42565: test_xmlUCSIsVariationSelectorsSupplement(void) {
42566: int test_ret = 0;
42567:
42568: #if defined(LIBXML_UNICODE_ENABLED)
42569: int mem_base;
42570: int ret_val;
42571: int code; /* UCS code point */
42572: int n_code;
42573:
42574: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42575: mem_base = xmlMemBlocks();
42576: code = gen_int(n_code, 0);
42577:
42578: ret_val = xmlUCSIsVariationSelectorsSupplement(code);
42579: desret_int(ret_val);
42580: call_tests++;
42581: des_int(n_code, code, 0);
42582: xmlResetLastError();
42583: if (mem_base != xmlMemBlocks()) {
42584: printf("Leak of %d blocks found in xmlUCSIsVariationSelectorsSupplement",
42585: xmlMemBlocks() - mem_base);
42586: test_ret++;
42587: printf(" %d", n_code);
42588: printf("\n");
42589: }
42590: }
42591: function_tests++;
42592: #endif
42593:
42594: return(test_ret);
42595: }
42596:
42597:
42598: static int
42599: test_xmlUCSIsYiRadicals(void) {
42600: int test_ret = 0;
42601:
42602: #if defined(LIBXML_UNICODE_ENABLED)
42603: int mem_base;
42604: int ret_val;
42605: int code; /* UCS code point */
42606: int n_code;
42607:
42608: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42609: mem_base = xmlMemBlocks();
42610: code = gen_int(n_code, 0);
42611:
42612: ret_val = xmlUCSIsYiRadicals(code);
42613: desret_int(ret_val);
42614: call_tests++;
42615: des_int(n_code, code, 0);
42616: xmlResetLastError();
42617: if (mem_base != xmlMemBlocks()) {
42618: printf("Leak of %d blocks found in xmlUCSIsYiRadicals",
42619: xmlMemBlocks() - mem_base);
42620: test_ret++;
42621: printf(" %d", n_code);
42622: printf("\n");
42623: }
42624: }
42625: function_tests++;
42626: #endif
42627:
42628: return(test_ret);
42629: }
42630:
42631:
42632: static int
42633: test_xmlUCSIsYiSyllables(void) {
42634: int test_ret = 0;
42635:
42636: #if defined(LIBXML_UNICODE_ENABLED)
42637: int mem_base;
42638: int ret_val;
42639: int code; /* UCS code point */
42640: int n_code;
42641:
42642: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42643: mem_base = xmlMemBlocks();
42644: code = gen_int(n_code, 0);
42645:
42646: ret_val = xmlUCSIsYiSyllables(code);
42647: desret_int(ret_val);
42648: call_tests++;
42649: des_int(n_code, code, 0);
42650: xmlResetLastError();
42651: if (mem_base != xmlMemBlocks()) {
42652: printf("Leak of %d blocks found in xmlUCSIsYiSyllables",
42653: xmlMemBlocks() - mem_base);
42654: test_ret++;
42655: printf(" %d", n_code);
42656: printf("\n");
42657: }
42658: }
42659: function_tests++;
42660: #endif
42661:
42662: return(test_ret);
42663: }
42664:
42665:
42666: static int
42667: test_xmlUCSIsYijingHexagramSymbols(void) {
42668: int test_ret = 0;
42669:
42670: #if defined(LIBXML_UNICODE_ENABLED)
42671: int mem_base;
42672: int ret_val;
42673: int code; /* UCS code point */
42674: int n_code;
42675:
42676: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42677: mem_base = xmlMemBlocks();
42678: code = gen_int(n_code, 0);
42679:
42680: ret_val = xmlUCSIsYijingHexagramSymbols(code);
42681: desret_int(ret_val);
42682: call_tests++;
42683: des_int(n_code, code, 0);
42684: xmlResetLastError();
42685: if (mem_base != xmlMemBlocks()) {
42686: printf("Leak of %d blocks found in xmlUCSIsYijingHexagramSymbols",
42687: xmlMemBlocks() - mem_base);
42688: test_ret++;
42689: printf(" %d", n_code);
42690: printf("\n");
42691: }
42692: }
42693: function_tests++;
42694: #endif
42695:
42696: return(test_ret);
42697: }
42698:
42699: static int
42700: test_xmlunicode(void) {
42701: int test_ret = 0;
42702:
42703: if (quiet == 0) printf("Testing xmlunicode : 166 of 166 functions ...\n");
42704: test_ret += test_xmlUCSIsAegeanNumbers();
42705: test_ret += test_xmlUCSIsAlphabeticPresentationForms();
42706: test_ret += test_xmlUCSIsArabic();
42707: test_ret += test_xmlUCSIsArabicPresentationFormsA();
42708: test_ret += test_xmlUCSIsArabicPresentationFormsB();
42709: test_ret += test_xmlUCSIsArmenian();
42710: test_ret += test_xmlUCSIsArrows();
42711: test_ret += test_xmlUCSIsBasicLatin();
42712: test_ret += test_xmlUCSIsBengali();
42713: test_ret += test_xmlUCSIsBlock();
42714: test_ret += test_xmlUCSIsBlockElements();
42715: test_ret += test_xmlUCSIsBopomofo();
42716: test_ret += test_xmlUCSIsBopomofoExtended();
42717: test_ret += test_xmlUCSIsBoxDrawing();
42718: test_ret += test_xmlUCSIsBraillePatterns();
42719: test_ret += test_xmlUCSIsBuhid();
42720: test_ret += test_xmlUCSIsByzantineMusicalSymbols();
42721: test_ret += test_xmlUCSIsCJKCompatibility();
42722: test_ret += test_xmlUCSIsCJKCompatibilityForms();
42723: test_ret += test_xmlUCSIsCJKCompatibilityIdeographs();
42724: test_ret += test_xmlUCSIsCJKCompatibilityIdeographsSupplement();
42725: test_ret += test_xmlUCSIsCJKRadicalsSupplement();
42726: test_ret += test_xmlUCSIsCJKSymbolsandPunctuation();
42727: test_ret += test_xmlUCSIsCJKUnifiedIdeographs();
42728: test_ret += test_xmlUCSIsCJKUnifiedIdeographsExtensionA();
42729: test_ret += test_xmlUCSIsCJKUnifiedIdeographsExtensionB();
42730: test_ret += test_xmlUCSIsCat();
42731: test_ret += test_xmlUCSIsCatC();
42732: test_ret += test_xmlUCSIsCatCc();
42733: test_ret += test_xmlUCSIsCatCf();
42734: test_ret += test_xmlUCSIsCatCo();
42735: test_ret += test_xmlUCSIsCatCs();
42736: test_ret += test_xmlUCSIsCatL();
42737: test_ret += test_xmlUCSIsCatLl();
42738: test_ret += test_xmlUCSIsCatLm();
42739: test_ret += test_xmlUCSIsCatLo();
42740: test_ret += test_xmlUCSIsCatLt();
42741: test_ret += test_xmlUCSIsCatLu();
42742: test_ret += test_xmlUCSIsCatM();
42743: test_ret += test_xmlUCSIsCatMc();
42744: test_ret += test_xmlUCSIsCatMe();
42745: test_ret += test_xmlUCSIsCatMn();
42746: test_ret += test_xmlUCSIsCatN();
42747: test_ret += test_xmlUCSIsCatNd();
42748: test_ret += test_xmlUCSIsCatNl();
42749: test_ret += test_xmlUCSIsCatNo();
42750: test_ret += test_xmlUCSIsCatP();
42751: test_ret += test_xmlUCSIsCatPc();
42752: test_ret += test_xmlUCSIsCatPd();
42753: test_ret += test_xmlUCSIsCatPe();
42754: test_ret += test_xmlUCSIsCatPf();
42755: test_ret += test_xmlUCSIsCatPi();
42756: test_ret += test_xmlUCSIsCatPo();
42757: test_ret += test_xmlUCSIsCatPs();
42758: test_ret += test_xmlUCSIsCatS();
42759: test_ret += test_xmlUCSIsCatSc();
42760: test_ret += test_xmlUCSIsCatSk();
42761: test_ret += test_xmlUCSIsCatSm();
42762: test_ret += test_xmlUCSIsCatSo();
42763: test_ret += test_xmlUCSIsCatZ();
42764: test_ret += test_xmlUCSIsCatZl();
42765: test_ret += test_xmlUCSIsCatZp();
42766: test_ret += test_xmlUCSIsCatZs();
42767: test_ret += test_xmlUCSIsCherokee();
42768: test_ret += test_xmlUCSIsCombiningDiacriticalMarks();
42769: test_ret += test_xmlUCSIsCombiningDiacriticalMarksforSymbols();
42770: test_ret += test_xmlUCSIsCombiningHalfMarks();
42771: test_ret += test_xmlUCSIsCombiningMarksforSymbols();
42772: test_ret += test_xmlUCSIsControlPictures();
42773: test_ret += test_xmlUCSIsCurrencySymbols();
42774: test_ret += test_xmlUCSIsCypriotSyllabary();
42775: test_ret += test_xmlUCSIsCyrillic();
42776: test_ret += test_xmlUCSIsCyrillicSupplement();
42777: test_ret += test_xmlUCSIsDeseret();
42778: test_ret += test_xmlUCSIsDevanagari();
42779: test_ret += test_xmlUCSIsDingbats();
42780: test_ret += test_xmlUCSIsEnclosedAlphanumerics();
42781: test_ret += test_xmlUCSIsEnclosedCJKLettersandMonths();
42782: test_ret += test_xmlUCSIsEthiopic();
42783: test_ret += test_xmlUCSIsGeneralPunctuation();
42784: test_ret += test_xmlUCSIsGeometricShapes();
42785: test_ret += test_xmlUCSIsGeorgian();
42786: test_ret += test_xmlUCSIsGothic();
42787: test_ret += test_xmlUCSIsGreek();
42788: test_ret += test_xmlUCSIsGreekExtended();
42789: test_ret += test_xmlUCSIsGreekandCoptic();
42790: test_ret += test_xmlUCSIsGujarati();
42791: test_ret += test_xmlUCSIsGurmukhi();
42792: test_ret += test_xmlUCSIsHalfwidthandFullwidthForms();
42793: test_ret += test_xmlUCSIsHangulCompatibilityJamo();
42794: test_ret += test_xmlUCSIsHangulJamo();
42795: test_ret += test_xmlUCSIsHangulSyllables();
42796: test_ret += test_xmlUCSIsHanunoo();
42797: test_ret += test_xmlUCSIsHebrew();
42798: test_ret += test_xmlUCSIsHighPrivateUseSurrogates();
42799: test_ret += test_xmlUCSIsHighSurrogates();
42800: test_ret += test_xmlUCSIsHiragana();
42801: test_ret += test_xmlUCSIsIPAExtensions();
42802: test_ret += test_xmlUCSIsIdeographicDescriptionCharacters();
42803: test_ret += test_xmlUCSIsKanbun();
42804: test_ret += test_xmlUCSIsKangxiRadicals();
42805: test_ret += test_xmlUCSIsKannada();
42806: test_ret += test_xmlUCSIsKatakana();
42807: test_ret += test_xmlUCSIsKatakanaPhoneticExtensions();
42808: test_ret += test_xmlUCSIsKhmer();
42809: test_ret += test_xmlUCSIsKhmerSymbols();
42810: test_ret += test_xmlUCSIsLao();
42811: test_ret += test_xmlUCSIsLatin1Supplement();
42812: test_ret += test_xmlUCSIsLatinExtendedA();
42813: test_ret += test_xmlUCSIsLatinExtendedAdditional();
42814: test_ret += test_xmlUCSIsLatinExtendedB();
42815: test_ret += test_xmlUCSIsLetterlikeSymbols();
42816: test_ret += test_xmlUCSIsLimbu();
42817: test_ret += test_xmlUCSIsLinearBIdeograms();
42818: test_ret += test_xmlUCSIsLinearBSyllabary();
42819: test_ret += test_xmlUCSIsLowSurrogates();
42820: test_ret += test_xmlUCSIsMalayalam();
42821: test_ret += test_xmlUCSIsMathematicalAlphanumericSymbols();
42822: test_ret += test_xmlUCSIsMathematicalOperators();
42823: test_ret += test_xmlUCSIsMiscellaneousMathematicalSymbolsA();
42824: test_ret += test_xmlUCSIsMiscellaneousMathematicalSymbolsB();
42825: test_ret += test_xmlUCSIsMiscellaneousSymbols();
42826: test_ret += test_xmlUCSIsMiscellaneousSymbolsandArrows();
42827: test_ret += test_xmlUCSIsMiscellaneousTechnical();
42828: test_ret += test_xmlUCSIsMongolian();
42829: test_ret += test_xmlUCSIsMusicalSymbols();
42830: test_ret += test_xmlUCSIsMyanmar();
42831: test_ret += test_xmlUCSIsNumberForms();
42832: test_ret += test_xmlUCSIsOgham();
42833: test_ret += test_xmlUCSIsOldItalic();
42834: test_ret += test_xmlUCSIsOpticalCharacterRecognition();
42835: test_ret += test_xmlUCSIsOriya();
42836: test_ret += test_xmlUCSIsOsmanya();
42837: test_ret += test_xmlUCSIsPhoneticExtensions();
42838: test_ret += test_xmlUCSIsPrivateUse();
42839: test_ret += test_xmlUCSIsPrivateUseArea();
42840: test_ret += test_xmlUCSIsRunic();
42841: test_ret += test_xmlUCSIsShavian();
42842: test_ret += test_xmlUCSIsSinhala();
42843: test_ret += test_xmlUCSIsSmallFormVariants();
42844: test_ret += test_xmlUCSIsSpacingModifierLetters();
42845: test_ret += test_xmlUCSIsSpecials();
42846: test_ret += test_xmlUCSIsSuperscriptsandSubscripts();
42847: test_ret += test_xmlUCSIsSupplementalArrowsA();
42848: test_ret += test_xmlUCSIsSupplementalArrowsB();
42849: test_ret += test_xmlUCSIsSupplementalMathematicalOperators();
42850: test_ret += test_xmlUCSIsSupplementaryPrivateUseAreaA();
42851: test_ret += test_xmlUCSIsSupplementaryPrivateUseAreaB();
42852: test_ret += test_xmlUCSIsSyriac();
42853: test_ret += test_xmlUCSIsTagalog();
42854: test_ret += test_xmlUCSIsTagbanwa();
42855: test_ret += test_xmlUCSIsTags();
42856: test_ret += test_xmlUCSIsTaiLe();
42857: test_ret += test_xmlUCSIsTaiXuanJingSymbols();
42858: test_ret += test_xmlUCSIsTamil();
42859: test_ret += test_xmlUCSIsTelugu();
42860: test_ret += test_xmlUCSIsThaana();
42861: test_ret += test_xmlUCSIsThai();
42862: test_ret += test_xmlUCSIsTibetan();
42863: test_ret += test_xmlUCSIsUgaritic();
42864: test_ret += test_xmlUCSIsUnifiedCanadianAboriginalSyllabics();
42865: test_ret += test_xmlUCSIsVariationSelectors();
42866: test_ret += test_xmlUCSIsVariationSelectorsSupplement();
42867: test_ret += test_xmlUCSIsYiRadicals();
42868: test_ret += test_xmlUCSIsYiSyllables();
42869: test_ret += test_xmlUCSIsYijingHexagramSymbols();
42870:
42871: if (test_ret != 0)
42872: printf("Module xmlunicode: %d errors\n", test_ret);
42873: return(test_ret);
42874: }
42875:
42876: static int
42877: test_xmlNewTextWriter(void) {
42878: int test_ret = 0;
42879:
42880: #if defined(LIBXML_WRITER_ENABLED)
42881: int mem_base;
42882: xmlTextWriterPtr ret_val;
42883: xmlOutputBufferPtr out; /* an xmlOutputBufferPtr */
42884: int n_out;
42885:
42886: for (n_out = 0;n_out < gen_nb_xmlOutputBufferPtr;n_out++) {
42887: mem_base = xmlMemBlocks();
42888: out = gen_xmlOutputBufferPtr(n_out, 0);
42889:
42890: ret_val = xmlNewTextWriter(out);
42891: if (ret_val != NULL) out = NULL;
42892: desret_xmlTextWriterPtr(ret_val);
42893: call_tests++;
42894: des_xmlOutputBufferPtr(n_out, out, 0);
42895: xmlResetLastError();
42896: if (mem_base != xmlMemBlocks()) {
42897: printf("Leak of %d blocks found in xmlNewTextWriter",
42898: xmlMemBlocks() - mem_base);
42899: test_ret++;
42900: printf(" %d", n_out);
42901: printf("\n");
42902: }
42903: }
42904: function_tests++;
42905: #endif
42906:
42907: return(test_ret);
42908: }
42909:
42910:
42911: static int
42912: test_xmlNewTextWriterFilename(void) {
42913: int test_ret = 0;
42914:
42915: #if defined(LIBXML_WRITER_ENABLED)
42916: int mem_base;
42917: xmlTextWriterPtr ret_val;
42918: const char * uri; /* the URI of the resource for the output */
42919: int n_uri;
42920: int compression; /* compress the output? */
42921: int n_compression;
42922:
42923: for (n_uri = 0;n_uri < gen_nb_fileoutput;n_uri++) {
42924: for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
42925: mem_base = xmlMemBlocks();
42926: uri = gen_fileoutput(n_uri, 0);
42927: compression = gen_int(n_compression, 1);
42928:
42929: ret_val = xmlNewTextWriterFilename(uri, compression);
42930: desret_xmlTextWriterPtr(ret_val);
42931: call_tests++;
42932: des_fileoutput(n_uri, uri, 0);
42933: des_int(n_compression, compression, 1);
42934: xmlResetLastError();
42935: if (mem_base != xmlMemBlocks()) {
42936: printf("Leak of %d blocks found in xmlNewTextWriterFilename",
42937: xmlMemBlocks() - mem_base);
42938: test_ret++;
42939: printf(" %d", n_uri);
42940: printf(" %d", n_compression);
42941: printf("\n");
42942: }
42943: }
42944: }
42945: function_tests++;
42946: #endif
42947:
42948: return(test_ret);
42949: }
42950:
42951:
42952: static int
42953: test_xmlNewTextWriterMemory(void) {
42954: int test_ret = 0;
42955:
42956: #if defined(LIBXML_WRITER_ENABLED)
42957: int mem_base;
42958: xmlTextWriterPtr ret_val;
42959: xmlBufferPtr buf; /* xmlBufferPtr */
42960: int n_buf;
42961: int compression; /* compress the output? */
42962: int n_compression;
42963:
42964: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
42965: for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
42966: mem_base = xmlMemBlocks();
42967: buf = gen_xmlBufferPtr(n_buf, 0);
42968: compression = gen_int(n_compression, 1);
42969:
42970: ret_val = xmlNewTextWriterMemory(buf, compression);
42971: desret_xmlTextWriterPtr(ret_val);
42972: call_tests++;
42973: des_xmlBufferPtr(n_buf, buf, 0);
42974: des_int(n_compression, compression, 1);
42975: xmlResetLastError();
42976: if (mem_base != xmlMemBlocks()) {
42977: printf("Leak of %d blocks found in xmlNewTextWriterMemory",
42978: xmlMemBlocks() - mem_base);
42979: test_ret++;
42980: printf(" %d", n_buf);
42981: printf(" %d", n_compression);
42982: printf("\n");
42983: }
42984: }
42985: }
42986: function_tests++;
42987: #endif
42988:
42989: return(test_ret);
42990: }
42991:
42992:
42993: static int
42994: test_xmlNewTextWriterPushParser(void) {
42995: int test_ret = 0;
42996:
42997: #if defined(LIBXML_WRITER_ENABLED)
42998: int mem_base;
42999: xmlTextWriterPtr ret_val;
43000: xmlParserCtxtPtr ctxt; /* xmlParserCtxtPtr to hold the new XML document tree */
43001: int n_ctxt;
43002: int compression; /* compress the output? */
43003: int n_compression;
43004:
43005: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
43006: for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
43007: mem_base = xmlMemBlocks();
43008: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
43009: compression = gen_int(n_compression, 1);
43010:
43011: ret_val = xmlNewTextWriterPushParser(ctxt, compression);
43012: if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;} if (ret_val != NULL) ctxt = NULL;
43013: desret_xmlTextWriterPtr(ret_val);
43014: call_tests++;
43015: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
43016: des_int(n_compression, compression, 1);
43017: xmlResetLastError();
43018: if (mem_base != xmlMemBlocks()) {
43019: printf("Leak of %d blocks found in xmlNewTextWriterPushParser",
43020: xmlMemBlocks() - mem_base);
43021: test_ret++;
43022: printf(" %d", n_ctxt);
43023: printf(" %d", n_compression);
43024: printf("\n");
43025: }
43026: }
43027: }
43028: function_tests++;
43029: #endif
43030:
43031: return(test_ret);
43032: }
43033:
43034:
43035: static int
43036: test_xmlNewTextWriterTree(void) {
43037: int test_ret = 0;
43038:
43039: #if defined(LIBXML_WRITER_ENABLED)
43040: int mem_base;
43041: xmlTextWriterPtr ret_val;
43042: xmlDocPtr doc; /* xmlDocPtr */
43043: int n_doc;
43044: xmlNodePtr node; /* xmlNodePtr or NULL for doc->children */
43045: int n_node;
43046: int compression; /* compress the output? */
43047: int n_compression;
43048:
43049: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
43050: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
43051: for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
43052: mem_base = xmlMemBlocks();
43053: doc = gen_xmlDocPtr(n_doc, 0);
43054: node = gen_xmlNodePtr(n_node, 1);
43055: compression = gen_int(n_compression, 2);
43056:
43057: ret_val = xmlNewTextWriterTree(doc, node, compression);
43058: desret_xmlTextWriterPtr(ret_val);
43059: call_tests++;
43060: des_xmlDocPtr(n_doc, doc, 0);
43061: des_xmlNodePtr(n_node, node, 1);
43062: des_int(n_compression, compression, 2);
43063: xmlResetLastError();
43064: if (mem_base != xmlMemBlocks()) {
43065: printf("Leak of %d blocks found in xmlNewTextWriterTree",
43066: xmlMemBlocks() - mem_base);
43067: test_ret++;
43068: printf(" %d", n_doc);
43069: printf(" %d", n_node);
43070: printf(" %d", n_compression);
43071: printf("\n");
43072: }
43073: }
43074: }
43075: }
43076: function_tests++;
43077: #endif
43078:
43079: return(test_ret);
43080: }
43081:
43082:
43083: static int
43084: test_xmlTextWriterEndAttribute(void) {
43085: int test_ret = 0;
43086:
43087: #if defined(LIBXML_WRITER_ENABLED)
43088: int mem_base;
43089: int ret_val;
43090: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43091: int n_writer;
43092:
43093: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43094: mem_base = xmlMemBlocks();
43095: writer = gen_xmlTextWriterPtr(n_writer, 0);
43096:
43097: ret_val = xmlTextWriterEndAttribute(writer);
43098: desret_int(ret_val);
43099: call_tests++;
43100: des_xmlTextWriterPtr(n_writer, writer, 0);
43101: xmlResetLastError();
43102: if (mem_base != xmlMemBlocks()) {
43103: printf("Leak of %d blocks found in xmlTextWriterEndAttribute",
43104: xmlMemBlocks() - mem_base);
43105: test_ret++;
43106: printf(" %d", n_writer);
43107: printf("\n");
43108: }
43109: }
43110: function_tests++;
43111: #endif
43112:
43113: return(test_ret);
43114: }
43115:
43116:
43117: static int
43118: test_xmlTextWriterEndCDATA(void) {
43119: int test_ret = 0;
43120:
43121: #if defined(LIBXML_WRITER_ENABLED)
43122: int mem_base;
43123: int ret_val;
43124: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43125: int n_writer;
43126:
43127: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43128: mem_base = xmlMemBlocks();
43129: writer = gen_xmlTextWriterPtr(n_writer, 0);
43130:
43131: ret_val = xmlTextWriterEndCDATA(writer);
43132: desret_int(ret_val);
43133: call_tests++;
43134: des_xmlTextWriterPtr(n_writer, writer, 0);
43135: xmlResetLastError();
43136: if (mem_base != xmlMemBlocks()) {
43137: printf("Leak of %d blocks found in xmlTextWriterEndCDATA",
43138: xmlMemBlocks() - mem_base);
43139: test_ret++;
43140: printf(" %d", n_writer);
43141: printf("\n");
43142: }
43143: }
43144: function_tests++;
43145: #endif
43146:
43147: return(test_ret);
43148: }
43149:
43150:
43151: static int
43152: test_xmlTextWriterEndComment(void) {
43153: int test_ret = 0;
43154:
43155: #if defined(LIBXML_WRITER_ENABLED)
43156: int mem_base;
43157: int ret_val;
43158: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43159: int n_writer;
43160:
43161: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43162: mem_base = xmlMemBlocks();
43163: writer = gen_xmlTextWriterPtr(n_writer, 0);
43164:
43165: ret_val = xmlTextWriterEndComment(writer);
43166: desret_int(ret_val);
43167: call_tests++;
43168: des_xmlTextWriterPtr(n_writer, writer, 0);
43169: xmlResetLastError();
43170: if (mem_base != xmlMemBlocks()) {
43171: printf("Leak of %d blocks found in xmlTextWriterEndComment",
43172: xmlMemBlocks() - mem_base);
43173: test_ret++;
43174: printf(" %d", n_writer);
43175: printf("\n");
43176: }
43177: }
43178: function_tests++;
43179: #endif
43180:
43181: return(test_ret);
43182: }
43183:
43184:
43185: static int
43186: test_xmlTextWriterEndDTD(void) {
43187: int test_ret = 0;
43188:
43189: #if defined(LIBXML_WRITER_ENABLED)
43190: int mem_base;
43191: int ret_val;
43192: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43193: int n_writer;
43194:
43195: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43196: mem_base = xmlMemBlocks();
43197: writer = gen_xmlTextWriterPtr(n_writer, 0);
43198:
43199: ret_val = xmlTextWriterEndDTD(writer);
43200: desret_int(ret_val);
43201: call_tests++;
43202: des_xmlTextWriterPtr(n_writer, writer, 0);
43203: xmlResetLastError();
43204: if (mem_base != xmlMemBlocks()) {
43205: printf("Leak of %d blocks found in xmlTextWriterEndDTD",
43206: xmlMemBlocks() - mem_base);
43207: test_ret++;
43208: printf(" %d", n_writer);
43209: printf("\n");
43210: }
43211: }
43212: function_tests++;
43213: #endif
43214:
43215: return(test_ret);
43216: }
43217:
43218:
43219: static int
43220: test_xmlTextWriterEndDTDAttlist(void) {
43221: int test_ret = 0;
43222:
43223: #if defined(LIBXML_WRITER_ENABLED)
43224: int mem_base;
43225: int ret_val;
43226: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43227: int n_writer;
43228:
43229: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43230: mem_base = xmlMemBlocks();
43231: writer = gen_xmlTextWriterPtr(n_writer, 0);
43232:
43233: ret_val = xmlTextWriterEndDTDAttlist(writer);
43234: desret_int(ret_val);
43235: call_tests++;
43236: des_xmlTextWriterPtr(n_writer, writer, 0);
43237: xmlResetLastError();
43238: if (mem_base != xmlMemBlocks()) {
43239: printf("Leak of %d blocks found in xmlTextWriterEndDTDAttlist",
43240: xmlMemBlocks() - mem_base);
43241: test_ret++;
43242: printf(" %d", n_writer);
43243: printf("\n");
43244: }
43245: }
43246: function_tests++;
43247: #endif
43248:
43249: return(test_ret);
43250: }
43251:
43252:
43253: static int
43254: test_xmlTextWriterEndDTDElement(void) {
43255: int test_ret = 0;
43256:
43257: #if defined(LIBXML_WRITER_ENABLED)
43258: int mem_base;
43259: int ret_val;
43260: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43261: int n_writer;
43262:
43263: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43264: mem_base = xmlMemBlocks();
43265: writer = gen_xmlTextWriterPtr(n_writer, 0);
43266:
43267: ret_val = xmlTextWriterEndDTDElement(writer);
43268: desret_int(ret_val);
43269: call_tests++;
43270: des_xmlTextWriterPtr(n_writer, writer, 0);
43271: xmlResetLastError();
43272: if (mem_base != xmlMemBlocks()) {
43273: printf("Leak of %d blocks found in xmlTextWriterEndDTDElement",
43274: xmlMemBlocks() - mem_base);
43275: test_ret++;
43276: printf(" %d", n_writer);
43277: printf("\n");
43278: }
43279: }
43280: function_tests++;
43281: #endif
43282:
43283: return(test_ret);
43284: }
43285:
43286:
43287: static int
43288: test_xmlTextWriterEndDTDEntity(void) {
43289: int test_ret = 0;
43290:
43291: #if defined(LIBXML_WRITER_ENABLED)
43292: int mem_base;
43293: int ret_val;
43294: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43295: int n_writer;
43296:
43297: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43298: mem_base = xmlMemBlocks();
43299: writer = gen_xmlTextWriterPtr(n_writer, 0);
43300:
43301: ret_val = xmlTextWriterEndDTDEntity(writer);
43302: desret_int(ret_val);
43303: call_tests++;
43304: des_xmlTextWriterPtr(n_writer, writer, 0);
43305: xmlResetLastError();
43306: if (mem_base != xmlMemBlocks()) {
43307: printf("Leak of %d blocks found in xmlTextWriterEndDTDEntity",
43308: xmlMemBlocks() - mem_base);
43309: test_ret++;
43310: printf(" %d", n_writer);
43311: printf("\n");
43312: }
43313: }
43314: function_tests++;
43315: #endif
43316:
43317: return(test_ret);
43318: }
43319:
43320:
43321: static int
43322: test_xmlTextWriterEndDocument(void) {
43323: int test_ret = 0;
43324:
43325: #if defined(LIBXML_WRITER_ENABLED)
43326: int mem_base;
43327: int ret_val;
43328: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43329: int n_writer;
43330:
43331: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43332: mem_base = xmlMemBlocks();
43333: writer = gen_xmlTextWriterPtr(n_writer, 0);
43334:
43335: ret_val = xmlTextWriterEndDocument(writer);
43336: desret_int(ret_val);
43337: call_tests++;
43338: des_xmlTextWriterPtr(n_writer, writer, 0);
43339: xmlResetLastError();
43340: if (mem_base != xmlMemBlocks()) {
43341: printf("Leak of %d blocks found in xmlTextWriterEndDocument",
43342: xmlMemBlocks() - mem_base);
43343: test_ret++;
43344: printf(" %d", n_writer);
43345: printf("\n");
43346: }
43347: }
43348: function_tests++;
43349: #endif
43350:
43351: return(test_ret);
43352: }
43353:
43354:
43355: static int
43356: test_xmlTextWriterEndElement(void) {
43357: int test_ret = 0;
43358:
43359: #if defined(LIBXML_WRITER_ENABLED)
43360: int mem_base;
43361: int ret_val;
43362: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43363: int n_writer;
43364:
43365: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43366: mem_base = xmlMemBlocks();
43367: writer = gen_xmlTextWriterPtr(n_writer, 0);
43368:
43369: ret_val = xmlTextWriterEndElement(writer);
43370: desret_int(ret_val);
43371: call_tests++;
43372: des_xmlTextWriterPtr(n_writer, writer, 0);
43373: xmlResetLastError();
43374: if (mem_base != xmlMemBlocks()) {
43375: printf("Leak of %d blocks found in xmlTextWriterEndElement",
43376: xmlMemBlocks() - mem_base);
43377: test_ret++;
43378: printf(" %d", n_writer);
43379: printf("\n");
43380: }
43381: }
43382: function_tests++;
43383: #endif
43384:
43385: return(test_ret);
43386: }
43387:
43388:
43389: static int
43390: test_xmlTextWriterEndPI(void) {
43391: int test_ret = 0;
43392:
43393: #if defined(LIBXML_WRITER_ENABLED)
43394: int mem_base;
43395: int ret_val;
43396: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43397: int n_writer;
43398:
43399: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43400: mem_base = xmlMemBlocks();
43401: writer = gen_xmlTextWriterPtr(n_writer, 0);
43402:
43403: ret_val = xmlTextWriterEndPI(writer);
43404: desret_int(ret_val);
43405: call_tests++;
43406: des_xmlTextWriterPtr(n_writer, writer, 0);
43407: xmlResetLastError();
43408: if (mem_base != xmlMemBlocks()) {
43409: printf("Leak of %d blocks found in xmlTextWriterEndPI",
43410: xmlMemBlocks() - mem_base);
43411: test_ret++;
43412: printf(" %d", n_writer);
43413: printf("\n");
43414: }
43415: }
43416: function_tests++;
43417: #endif
43418:
43419: return(test_ret);
43420: }
43421:
43422:
43423: static int
43424: test_xmlTextWriterFlush(void) {
43425: int test_ret = 0;
43426:
43427: #if defined(LIBXML_WRITER_ENABLED)
43428: int mem_base;
43429: int ret_val;
43430: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43431: int n_writer;
43432:
43433: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43434: mem_base = xmlMemBlocks();
43435: writer = gen_xmlTextWriterPtr(n_writer, 0);
43436:
43437: ret_val = xmlTextWriterFlush(writer);
43438: desret_int(ret_val);
43439: call_tests++;
43440: des_xmlTextWriterPtr(n_writer, writer, 0);
43441: xmlResetLastError();
43442: if (mem_base != xmlMemBlocks()) {
43443: printf("Leak of %d blocks found in xmlTextWriterFlush",
43444: xmlMemBlocks() - mem_base);
43445: test_ret++;
43446: printf(" %d", n_writer);
43447: printf("\n");
43448: }
43449: }
43450: function_tests++;
43451: #endif
43452:
43453: return(test_ret);
43454: }
43455:
43456:
43457: static int
43458: test_xmlTextWriterFullEndElement(void) {
43459: int test_ret = 0;
43460:
43461: #if defined(LIBXML_WRITER_ENABLED)
43462: int mem_base;
43463: int ret_val;
43464: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43465: int n_writer;
43466:
43467: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43468: mem_base = xmlMemBlocks();
43469: writer = gen_xmlTextWriterPtr(n_writer, 0);
43470:
43471: ret_val = xmlTextWriterFullEndElement(writer);
43472: desret_int(ret_val);
43473: call_tests++;
43474: des_xmlTextWriterPtr(n_writer, writer, 0);
43475: xmlResetLastError();
43476: if (mem_base != xmlMemBlocks()) {
43477: printf("Leak of %d blocks found in xmlTextWriterFullEndElement",
43478: xmlMemBlocks() - mem_base);
43479: test_ret++;
43480: printf(" %d", n_writer);
43481: printf("\n");
43482: }
43483: }
43484: function_tests++;
43485: #endif
43486:
43487: return(test_ret);
43488: }
43489:
43490:
43491: static int
43492: test_xmlTextWriterSetIndent(void) {
43493: int test_ret = 0;
43494:
43495: #if defined(LIBXML_WRITER_ENABLED)
43496: int mem_base;
43497: int ret_val;
43498: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43499: int n_writer;
43500: int indent; /* do indentation? */
43501: int n_indent;
43502:
43503: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43504: for (n_indent = 0;n_indent < gen_nb_int;n_indent++) {
43505: mem_base = xmlMemBlocks();
43506: writer = gen_xmlTextWriterPtr(n_writer, 0);
43507: indent = gen_int(n_indent, 1);
43508:
43509: ret_val = xmlTextWriterSetIndent(writer, indent);
43510: desret_int(ret_val);
43511: call_tests++;
43512: des_xmlTextWriterPtr(n_writer, writer, 0);
43513: des_int(n_indent, indent, 1);
43514: xmlResetLastError();
43515: if (mem_base != xmlMemBlocks()) {
43516: printf("Leak of %d blocks found in xmlTextWriterSetIndent",
43517: xmlMemBlocks() - mem_base);
43518: test_ret++;
43519: printf(" %d", n_writer);
43520: printf(" %d", n_indent);
43521: printf("\n");
43522: }
43523: }
43524: }
43525: function_tests++;
43526: #endif
43527:
43528: return(test_ret);
43529: }
43530:
43531:
43532: static int
43533: test_xmlTextWriterSetIndentString(void) {
43534: int test_ret = 0;
43535:
43536: #if defined(LIBXML_WRITER_ENABLED)
43537: int mem_base;
43538: int ret_val;
43539: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43540: int n_writer;
43541: xmlChar * str; /* the xmlChar string */
43542: int n_str;
43543:
43544: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43545: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
43546: mem_base = xmlMemBlocks();
43547: writer = gen_xmlTextWriterPtr(n_writer, 0);
43548: str = gen_const_xmlChar_ptr(n_str, 1);
43549:
43550: ret_val = xmlTextWriterSetIndentString(writer, (const xmlChar *)str);
43551: desret_int(ret_val);
43552: call_tests++;
43553: des_xmlTextWriterPtr(n_writer, writer, 0);
43554: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
43555: xmlResetLastError();
43556: if (mem_base != xmlMemBlocks()) {
43557: printf("Leak of %d blocks found in xmlTextWriterSetIndentString",
43558: xmlMemBlocks() - mem_base);
43559: test_ret++;
43560: printf(" %d", n_writer);
43561: printf(" %d", n_str);
43562: printf("\n");
43563: }
43564: }
43565: }
43566: function_tests++;
43567: #endif
43568:
43569: return(test_ret);
43570: }
43571:
43572:
43573: static int
43574: test_xmlTextWriterStartAttribute(void) {
43575: int test_ret = 0;
43576:
43577: #if defined(LIBXML_WRITER_ENABLED)
43578: int mem_base;
43579: int ret_val;
43580: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43581: int n_writer;
43582: xmlChar * name; /* element name */
43583: int n_name;
43584:
43585: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43586: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
43587: mem_base = xmlMemBlocks();
43588: writer = gen_xmlTextWriterPtr(n_writer, 0);
43589: name = gen_const_xmlChar_ptr(n_name, 1);
43590:
43591: ret_val = xmlTextWriterStartAttribute(writer, (const xmlChar *)name);
43592: desret_int(ret_val);
43593: call_tests++;
43594: des_xmlTextWriterPtr(n_writer, writer, 0);
43595: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
43596: xmlResetLastError();
43597: if (mem_base != xmlMemBlocks()) {
43598: printf("Leak of %d blocks found in xmlTextWriterStartAttribute",
43599: xmlMemBlocks() - mem_base);
43600: test_ret++;
43601: printf(" %d", n_writer);
43602: printf(" %d", n_name);
43603: printf("\n");
43604: }
43605: }
43606: }
43607: function_tests++;
43608: #endif
43609:
43610: return(test_ret);
43611: }
43612:
43613:
43614: static int
43615: test_xmlTextWriterStartAttributeNS(void) {
43616: int test_ret = 0;
43617:
43618: #if defined(LIBXML_WRITER_ENABLED)
43619: int mem_base;
43620: int ret_val;
43621: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43622: int n_writer;
43623: xmlChar * prefix; /* namespace prefix or NULL */
43624: int n_prefix;
43625: xmlChar * name; /* element local name */
43626: int n_name;
43627: xmlChar * namespaceURI; /* namespace URI or NULL */
43628: int n_namespaceURI;
43629:
43630: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43631: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
43632: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
43633: for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
43634: mem_base = xmlMemBlocks();
43635: writer = gen_xmlTextWriterPtr(n_writer, 0);
43636: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
43637: name = gen_const_xmlChar_ptr(n_name, 2);
43638: namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 3);
43639:
43640: ret_val = xmlTextWriterStartAttributeNS(writer, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)namespaceURI);
43641: desret_int(ret_val);
43642: call_tests++;
43643: des_xmlTextWriterPtr(n_writer, writer, 0);
43644: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
43645: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
43646: des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 3);
43647: xmlResetLastError();
43648: if (mem_base != xmlMemBlocks()) {
43649: printf("Leak of %d blocks found in xmlTextWriterStartAttributeNS",
43650: xmlMemBlocks() - mem_base);
43651: test_ret++;
43652: printf(" %d", n_writer);
43653: printf(" %d", n_prefix);
43654: printf(" %d", n_name);
43655: printf(" %d", n_namespaceURI);
43656: printf("\n");
43657: }
43658: }
43659: }
43660: }
43661: }
43662: function_tests++;
43663: #endif
43664:
43665: return(test_ret);
43666: }
43667:
43668:
43669: static int
43670: test_xmlTextWriterStartCDATA(void) {
43671: int test_ret = 0;
43672:
43673: #if defined(LIBXML_WRITER_ENABLED)
43674: int mem_base;
43675: int ret_val;
43676: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43677: int n_writer;
43678:
43679: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43680: mem_base = xmlMemBlocks();
43681: writer = gen_xmlTextWriterPtr(n_writer, 0);
43682:
43683: ret_val = xmlTextWriterStartCDATA(writer);
43684: desret_int(ret_val);
43685: call_tests++;
43686: des_xmlTextWriterPtr(n_writer, writer, 0);
43687: xmlResetLastError();
43688: if (mem_base != xmlMemBlocks()) {
43689: printf("Leak of %d blocks found in xmlTextWriterStartCDATA",
43690: xmlMemBlocks() - mem_base);
43691: test_ret++;
43692: printf(" %d", n_writer);
43693: printf("\n");
43694: }
43695: }
43696: function_tests++;
43697: #endif
43698:
43699: return(test_ret);
43700: }
43701:
43702:
43703: static int
43704: test_xmlTextWriterStartComment(void) {
43705: int test_ret = 0;
43706:
43707: #if defined(LIBXML_WRITER_ENABLED)
43708: int mem_base;
43709: int ret_val;
43710: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43711: int n_writer;
43712:
43713: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43714: mem_base = xmlMemBlocks();
43715: writer = gen_xmlTextWriterPtr(n_writer, 0);
43716:
43717: ret_val = xmlTextWriterStartComment(writer);
43718: desret_int(ret_val);
43719: call_tests++;
43720: des_xmlTextWriterPtr(n_writer, writer, 0);
43721: xmlResetLastError();
43722: if (mem_base != xmlMemBlocks()) {
43723: printf("Leak of %d blocks found in xmlTextWriterStartComment",
43724: xmlMemBlocks() - mem_base);
43725: test_ret++;
43726: printf(" %d", n_writer);
43727: printf("\n");
43728: }
43729: }
43730: function_tests++;
43731: #endif
43732:
43733: return(test_ret);
43734: }
43735:
43736:
43737: static int
43738: test_xmlTextWriterStartDTD(void) {
43739: int test_ret = 0;
43740:
43741: #if defined(LIBXML_WRITER_ENABLED)
43742: int mem_base;
43743: int ret_val;
43744: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43745: int n_writer;
43746: xmlChar * name; /* the name of the DTD */
43747: int n_name;
43748: xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
43749: int n_pubid;
43750: xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
43751: int n_sysid;
43752:
43753: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43754: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
43755: for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
43756: for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
43757: mem_base = xmlMemBlocks();
43758: writer = gen_xmlTextWriterPtr(n_writer, 0);
43759: name = gen_const_xmlChar_ptr(n_name, 1);
43760: pubid = gen_const_xmlChar_ptr(n_pubid, 2);
43761: sysid = gen_const_xmlChar_ptr(n_sysid, 3);
43762:
43763: ret_val = xmlTextWriterStartDTD(writer, (const xmlChar *)name, (const xmlChar *)pubid, (const xmlChar *)sysid);
43764: desret_int(ret_val);
43765: call_tests++;
43766: des_xmlTextWriterPtr(n_writer, writer, 0);
43767: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
43768: des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 2);
43769: des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 3);
43770: xmlResetLastError();
43771: if (mem_base != xmlMemBlocks()) {
43772: printf("Leak of %d blocks found in xmlTextWriterStartDTD",
43773: xmlMemBlocks() - mem_base);
43774: test_ret++;
43775: printf(" %d", n_writer);
43776: printf(" %d", n_name);
43777: printf(" %d", n_pubid);
43778: printf(" %d", n_sysid);
43779: printf("\n");
43780: }
43781: }
43782: }
43783: }
43784: }
43785: function_tests++;
43786: #endif
43787:
43788: return(test_ret);
43789: }
43790:
43791:
43792: static int
43793: test_xmlTextWriterStartDTDAttlist(void) {
43794: int test_ret = 0;
43795:
43796: #if defined(LIBXML_WRITER_ENABLED)
43797: int mem_base;
43798: int ret_val;
43799: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43800: int n_writer;
43801: xmlChar * name; /* the name of the DTD ATTLIST */
43802: int n_name;
43803:
43804: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43805: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
43806: mem_base = xmlMemBlocks();
43807: writer = gen_xmlTextWriterPtr(n_writer, 0);
43808: name = gen_const_xmlChar_ptr(n_name, 1);
43809:
43810: ret_val = xmlTextWriterStartDTDAttlist(writer, (const xmlChar *)name);
43811: desret_int(ret_val);
43812: call_tests++;
43813: des_xmlTextWriterPtr(n_writer, writer, 0);
43814: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
43815: xmlResetLastError();
43816: if (mem_base != xmlMemBlocks()) {
43817: printf("Leak of %d blocks found in xmlTextWriterStartDTDAttlist",
43818: xmlMemBlocks() - mem_base);
43819: test_ret++;
43820: printf(" %d", n_writer);
43821: printf(" %d", n_name);
43822: printf("\n");
43823: }
43824: }
43825: }
43826: function_tests++;
43827: #endif
43828:
43829: return(test_ret);
43830: }
43831:
43832:
43833: static int
43834: test_xmlTextWriterStartDTDElement(void) {
43835: int test_ret = 0;
43836:
43837: #if defined(LIBXML_WRITER_ENABLED)
43838: int mem_base;
43839: int ret_val;
43840: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43841: int n_writer;
43842: xmlChar * name; /* the name of the DTD element */
43843: int n_name;
43844:
43845: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43846: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
43847: mem_base = xmlMemBlocks();
43848: writer = gen_xmlTextWriterPtr(n_writer, 0);
43849: name = gen_const_xmlChar_ptr(n_name, 1);
43850:
43851: ret_val = xmlTextWriterStartDTDElement(writer, (const xmlChar *)name);
43852: desret_int(ret_val);
43853: call_tests++;
43854: des_xmlTextWriterPtr(n_writer, writer, 0);
43855: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
43856: xmlResetLastError();
43857: if (mem_base != xmlMemBlocks()) {
43858: printf("Leak of %d blocks found in xmlTextWriterStartDTDElement",
43859: xmlMemBlocks() - mem_base);
43860: test_ret++;
43861: printf(" %d", n_writer);
43862: printf(" %d", n_name);
43863: printf("\n");
43864: }
43865: }
43866: }
43867: function_tests++;
43868: #endif
43869:
43870: return(test_ret);
43871: }
43872:
43873:
43874: static int
43875: test_xmlTextWriterStartDTDEntity(void) {
43876: int test_ret = 0;
43877:
43878: #if defined(LIBXML_WRITER_ENABLED)
43879: int mem_base;
43880: int ret_val;
43881: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43882: int n_writer;
43883: int pe; /* TRUE if this is a parameter entity, FALSE if not */
43884: int n_pe;
43885: xmlChar * name; /* the name of the DTD ATTLIST */
43886: int n_name;
43887:
43888: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43889: for (n_pe = 0;n_pe < gen_nb_int;n_pe++) {
43890: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
43891: mem_base = xmlMemBlocks();
43892: writer = gen_xmlTextWriterPtr(n_writer, 0);
43893: pe = gen_int(n_pe, 1);
43894: name = gen_const_xmlChar_ptr(n_name, 2);
43895:
43896: ret_val = xmlTextWriterStartDTDEntity(writer, pe, (const xmlChar *)name);
43897: desret_int(ret_val);
43898: call_tests++;
43899: des_xmlTextWriterPtr(n_writer, writer, 0);
43900: des_int(n_pe, pe, 1);
43901: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
43902: xmlResetLastError();
43903: if (mem_base != xmlMemBlocks()) {
43904: printf("Leak of %d blocks found in xmlTextWriterStartDTDEntity",
43905: xmlMemBlocks() - mem_base);
43906: test_ret++;
43907: printf(" %d", n_writer);
43908: printf(" %d", n_pe);
43909: printf(" %d", n_name);
43910: printf("\n");
43911: }
43912: }
43913: }
43914: }
43915: function_tests++;
43916: #endif
43917:
43918: return(test_ret);
43919: }
43920:
43921:
43922: static int
43923: test_xmlTextWriterStartDocument(void) {
43924: int test_ret = 0;
43925:
43926: #if defined(LIBXML_WRITER_ENABLED)
43927: int mem_base;
43928: int ret_val;
43929: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43930: int n_writer;
43931: char * version; /* the xml version ("1.0") or NULL for default ("1.0") */
43932: int n_version;
43933: char * encoding; /* the encoding or NULL for default */
43934: int n_encoding;
43935: char * standalone; /* "yes" or "no" or NULL for default */
43936: int n_standalone;
43937:
43938: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43939: for (n_version = 0;n_version < gen_nb_const_char_ptr;n_version++) {
43940: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
43941: for (n_standalone = 0;n_standalone < gen_nb_const_char_ptr;n_standalone++) {
43942: mem_base = xmlMemBlocks();
43943: writer = gen_xmlTextWriterPtr(n_writer, 0);
43944: version = gen_const_char_ptr(n_version, 1);
43945: encoding = gen_const_char_ptr(n_encoding, 2);
43946: standalone = gen_const_char_ptr(n_standalone, 3);
43947:
43948: ret_val = xmlTextWriterStartDocument(writer, (const char *)version, (const char *)encoding, (const char *)standalone);
43949: desret_int(ret_val);
43950: call_tests++;
43951: des_xmlTextWriterPtr(n_writer, writer, 0);
43952: des_const_char_ptr(n_version, (const char *)version, 1);
43953: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
43954: des_const_char_ptr(n_standalone, (const char *)standalone, 3);
43955: xmlResetLastError();
43956: if (mem_base != xmlMemBlocks()) {
43957: printf("Leak of %d blocks found in xmlTextWriterStartDocument",
43958: xmlMemBlocks() - mem_base);
43959: test_ret++;
43960: printf(" %d", n_writer);
43961: printf(" %d", n_version);
43962: printf(" %d", n_encoding);
43963: printf(" %d", n_standalone);
43964: printf("\n");
43965: }
43966: }
43967: }
43968: }
43969: }
43970: function_tests++;
43971: #endif
43972:
43973: return(test_ret);
43974: }
43975:
43976:
43977: static int
43978: test_xmlTextWriterStartElement(void) {
43979: int test_ret = 0;
43980:
43981: #if defined(LIBXML_WRITER_ENABLED)
43982: int mem_base;
43983: int ret_val;
43984: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43985: int n_writer;
43986: xmlChar * name; /* element name */
43987: int n_name;
43988:
43989: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43990: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
43991: mem_base = xmlMemBlocks();
43992: writer = gen_xmlTextWriterPtr(n_writer, 0);
43993: name = gen_const_xmlChar_ptr(n_name, 1);
43994:
43995: ret_val = xmlTextWriterStartElement(writer, (const xmlChar *)name);
43996: desret_int(ret_val);
43997: call_tests++;
43998: des_xmlTextWriterPtr(n_writer, writer, 0);
43999: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
44000: xmlResetLastError();
44001: if (mem_base != xmlMemBlocks()) {
44002: printf("Leak of %d blocks found in xmlTextWriterStartElement",
44003: xmlMemBlocks() - mem_base);
44004: test_ret++;
44005: printf(" %d", n_writer);
44006: printf(" %d", n_name);
44007: printf("\n");
44008: }
44009: }
44010: }
44011: function_tests++;
44012: #endif
44013:
44014: return(test_ret);
44015: }
44016:
44017:
44018: static int
44019: test_xmlTextWriterStartElementNS(void) {
44020: int test_ret = 0;
44021:
44022: #if defined(LIBXML_WRITER_ENABLED)
44023: int mem_base;
44024: int ret_val;
44025: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44026: int n_writer;
44027: xmlChar * prefix; /* namespace prefix or NULL */
44028: int n_prefix;
44029: xmlChar * name; /* element local name */
44030: int n_name;
44031: xmlChar * namespaceURI; /* namespace URI or NULL */
44032: int n_namespaceURI;
44033:
44034: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44035: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
44036: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44037: for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
44038: mem_base = xmlMemBlocks();
44039: writer = gen_xmlTextWriterPtr(n_writer, 0);
44040: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
44041: name = gen_const_xmlChar_ptr(n_name, 2);
44042: namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 3);
44043:
44044: ret_val = xmlTextWriterStartElementNS(writer, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)namespaceURI);
44045: desret_int(ret_val);
44046: call_tests++;
44047: des_xmlTextWriterPtr(n_writer, writer, 0);
44048: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
44049: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
44050: des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 3);
44051: xmlResetLastError();
44052: if (mem_base != xmlMemBlocks()) {
44053: printf("Leak of %d blocks found in xmlTextWriterStartElementNS",
44054: xmlMemBlocks() - mem_base);
44055: test_ret++;
44056: printf(" %d", n_writer);
44057: printf(" %d", n_prefix);
44058: printf(" %d", n_name);
44059: printf(" %d", n_namespaceURI);
44060: printf("\n");
44061: }
44062: }
44063: }
44064: }
44065: }
44066: function_tests++;
44067: #endif
44068:
44069: return(test_ret);
44070: }
44071:
44072:
44073: static int
44074: test_xmlTextWriterStartPI(void) {
44075: int test_ret = 0;
44076:
44077: #if defined(LIBXML_WRITER_ENABLED)
44078: int mem_base;
44079: int ret_val;
44080: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44081: int n_writer;
44082: xmlChar * target; /* PI target */
44083: int n_target;
44084:
44085: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44086: for (n_target = 0;n_target < gen_nb_const_xmlChar_ptr;n_target++) {
44087: mem_base = xmlMemBlocks();
44088: writer = gen_xmlTextWriterPtr(n_writer, 0);
44089: target = gen_const_xmlChar_ptr(n_target, 1);
44090:
44091: ret_val = xmlTextWriterStartPI(writer, (const xmlChar *)target);
44092: desret_int(ret_val);
44093: call_tests++;
44094: des_xmlTextWriterPtr(n_writer, writer, 0);
44095: des_const_xmlChar_ptr(n_target, (const xmlChar *)target, 1);
44096: xmlResetLastError();
44097: if (mem_base != xmlMemBlocks()) {
44098: printf("Leak of %d blocks found in xmlTextWriterStartPI",
44099: xmlMemBlocks() - mem_base);
44100: test_ret++;
44101: printf(" %d", n_writer);
44102: printf(" %d", n_target);
44103: printf("\n");
44104: }
44105: }
44106: }
44107: function_tests++;
44108: #endif
44109:
44110: return(test_ret);
44111: }
44112:
44113:
44114: static int
44115: test_xmlTextWriterWriteAttribute(void) {
44116: int test_ret = 0;
44117:
44118: #if defined(LIBXML_WRITER_ENABLED)
44119: int mem_base;
44120: int ret_val;
44121: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44122: int n_writer;
44123: xmlChar * name; /* attribute name */
44124: int n_name;
44125: xmlChar * content; /* attribute content */
44126: int n_content;
44127:
44128: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44129: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44130: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44131: mem_base = xmlMemBlocks();
44132: writer = gen_xmlTextWriterPtr(n_writer, 0);
44133: name = gen_const_xmlChar_ptr(n_name, 1);
44134: content = gen_const_xmlChar_ptr(n_content, 2);
44135:
44136: ret_val = xmlTextWriterWriteAttribute(writer, (const xmlChar *)name, (const xmlChar *)content);
44137: desret_int(ret_val);
44138: call_tests++;
44139: des_xmlTextWriterPtr(n_writer, writer, 0);
44140: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
44141: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2);
44142: xmlResetLastError();
44143: if (mem_base != xmlMemBlocks()) {
44144: printf("Leak of %d blocks found in xmlTextWriterWriteAttribute",
44145: xmlMemBlocks() - mem_base);
44146: test_ret++;
44147: printf(" %d", n_writer);
44148: printf(" %d", n_name);
44149: printf(" %d", n_content);
44150: printf("\n");
44151: }
44152: }
44153: }
44154: }
44155: function_tests++;
44156: #endif
44157:
44158: return(test_ret);
44159: }
44160:
44161:
44162: static int
44163: test_xmlTextWriterWriteAttributeNS(void) {
44164: int test_ret = 0;
44165:
44166: #if defined(LIBXML_WRITER_ENABLED)
44167: int mem_base;
44168: int ret_val;
44169: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44170: int n_writer;
44171: xmlChar * prefix; /* namespace prefix */
44172: int n_prefix;
44173: xmlChar * name; /* attribute local name */
44174: int n_name;
44175: xmlChar * namespaceURI; /* namespace URI */
44176: int n_namespaceURI;
44177: xmlChar * content; /* attribute content */
44178: int n_content;
44179:
44180: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44181: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
44182: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44183: for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
44184: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44185: mem_base = xmlMemBlocks();
44186: writer = gen_xmlTextWriterPtr(n_writer, 0);
44187: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
44188: name = gen_const_xmlChar_ptr(n_name, 2);
44189: namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 3);
44190: content = gen_const_xmlChar_ptr(n_content, 4);
44191:
44192: ret_val = xmlTextWriterWriteAttributeNS(writer, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)namespaceURI, (const xmlChar *)content);
44193: desret_int(ret_val);
44194: call_tests++;
44195: des_xmlTextWriterPtr(n_writer, writer, 0);
44196: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
44197: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
44198: des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 3);
44199: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 4);
44200: xmlResetLastError();
44201: if (mem_base != xmlMemBlocks()) {
44202: printf("Leak of %d blocks found in xmlTextWriterWriteAttributeNS",
44203: xmlMemBlocks() - mem_base);
44204: test_ret++;
44205: printf(" %d", n_writer);
44206: printf(" %d", n_prefix);
44207: printf(" %d", n_name);
44208: printf(" %d", n_namespaceURI);
44209: printf(" %d", n_content);
44210: printf("\n");
44211: }
44212: }
44213: }
44214: }
44215: }
44216: }
44217: function_tests++;
44218: #endif
44219:
44220: return(test_ret);
44221: }
44222:
44223:
44224: static int
44225: test_xmlTextWriterWriteBase64(void) {
44226: int test_ret = 0;
44227:
44228: #if defined(LIBXML_WRITER_ENABLED)
44229: int mem_base;
44230: int ret_val;
44231: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44232: int n_writer;
44233: char * data; /* binary data */
44234: int n_data;
44235: int start; /* the position within the data of the first byte to encode */
44236: int n_start;
44237: int len; /* the number of bytes to encode */
44238: int n_len;
44239:
44240: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44241: for (n_data = 0;n_data < gen_nb_const_char_ptr;n_data++) {
44242: for (n_start = 0;n_start < gen_nb_int;n_start++) {
44243: for (n_len = 0;n_len < gen_nb_int;n_len++) {
44244: mem_base = xmlMemBlocks();
44245: writer = gen_xmlTextWriterPtr(n_writer, 0);
44246: data = gen_const_char_ptr(n_data, 1);
44247: start = gen_int(n_start, 2);
44248: len = gen_int(n_len, 3);
44249:
44250: ret_val = xmlTextWriterWriteBase64(writer, (const char *)data, start, len);
44251: desret_int(ret_val);
44252: call_tests++;
44253: des_xmlTextWriterPtr(n_writer, writer, 0);
44254: des_const_char_ptr(n_data, (const char *)data, 1);
44255: des_int(n_start, start, 2);
44256: des_int(n_len, len, 3);
44257: xmlResetLastError();
44258: if (mem_base != xmlMemBlocks()) {
44259: printf("Leak of %d blocks found in xmlTextWriterWriteBase64",
44260: xmlMemBlocks() - mem_base);
44261: test_ret++;
44262: printf(" %d", n_writer);
44263: printf(" %d", n_data);
44264: printf(" %d", n_start);
44265: printf(" %d", n_len);
44266: printf("\n");
44267: }
44268: }
44269: }
44270: }
44271: }
44272: function_tests++;
44273: #endif
44274:
44275: return(test_ret);
44276: }
44277:
44278:
44279: static int
44280: test_xmlTextWriterWriteBinHex(void) {
44281: int test_ret = 0;
44282:
44283: #if defined(LIBXML_WRITER_ENABLED)
44284: int mem_base;
44285: int ret_val;
44286: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44287: int n_writer;
44288: char * data; /* binary data */
44289: int n_data;
44290: int start; /* the position within the data of the first byte to encode */
44291: int n_start;
44292: int len; /* the number of bytes to encode */
44293: int n_len;
44294:
44295: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44296: for (n_data = 0;n_data < gen_nb_const_char_ptr;n_data++) {
44297: for (n_start = 0;n_start < gen_nb_int;n_start++) {
44298: for (n_len = 0;n_len < gen_nb_int;n_len++) {
44299: mem_base = xmlMemBlocks();
44300: writer = gen_xmlTextWriterPtr(n_writer, 0);
44301: data = gen_const_char_ptr(n_data, 1);
44302: start = gen_int(n_start, 2);
44303: len = gen_int(n_len, 3);
44304:
44305: ret_val = xmlTextWriterWriteBinHex(writer, (const char *)data, start, len);
44306: desret_int(ret_val);
44307: call_tests++;
44308: des_xmlTextWriterPtr(n_writer, writer, 0);
44309: des_const_char_ptr(n_data, (const char *)data, 1);
44310: des_int(n_start, start, 2);
44311: des_int(n_len, len, 3);
44312: xmlResetLastError();
44313: if (mem_base != xmlMemBlocks()) {
44314: printf("Leak of %d blocks found in xmlTextWriterWriteBinHex",
44315: xmlMemBlocks() - mem_base);
44316: test_ret++;
44317: printf(" %d", n_writer);
44318: printf(" %d", n_data);
44319: printf(" %d", n_start);
44320: printf(" %d", n_len);
44321: printf("\n");
44322: }
44323: }
44324: }
44325: }
44326: }
44327: function_tests++;
44328: #endif
44329:
44330: return(test_ret);
44331: }
44332:
44333:
44334: static int
44335: test_xmlTextWriterWriteCDATA(void) {
44336: int test_ret = 0;
44337:
44338: #if defined(LIBXML_WRITER_ENABLED)
44339: int mem_base;
44340: int ret_val;
44341: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44342: int n_writer;
44343: xmlChar * content; /* CDATA content */
44344: int n_content;
44345:
44346: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44347: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44348: mem_base = xmlMemBlocks();
44349: writer = gen_xmlTextWriterPtr(n_writer, 0);
44350: content = gen_const_xmlChar_ptr(n_content, 1);
44351:
44352: ret_val = xmlTextWriterWriteCDATA(writer, (const xmlChar *)content);
44353: desret_int(ret_val);
44354: call_tests++;
44355: des_xmlTextWriterPtr(n_writer, writer, 0);
44356: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
44357: xmlResetLastError();
44358: if (mem_base != xmlMemBlocks()) {
44359: printf("Leak of %d blocks found in xmlTextWriterWriteCDATA",
44360: xmlMemBlocks() - mem_base);
44361: test_ret++;
44362: printf(" %d", n_writer);
44363: printf(" %d", n_content);
44364: printf("\n");
44365: }
44366: }
44367: }
44368: function_tests++;
44369: #endif
44370:
44371: return(test_ret);
44372: }
44373:
44374:
44375: static int
44376: test_xmlTextWriterWriteComment(void) {
44377: int test_ret = 0;
44378:
44379: #if defined(LIBXML_WRITER_ENABLED)
44380: int mem_base;
44381: int ret_val;
44382: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44383: int n_writer;
44384: xmlChar * content; /* comment string */
44385: int n_content;
44386:
44387: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44388: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44389: mem_base = xmlMemBlocks();
44390: writer = gen_xmlTextWriterPtr(n_writer, 0);
44391: content = gen_const_xmlChar_ptr(n_content, 1);
44392:
44393: ret_val = xmlTextWriterWriteComment(writer, (const xmlChar *)content);
44394: desret_int(ret_val);
44395: call_tests++;
44396: des_xmlTextWriterPtr(n_writer, writer, 0);
44397: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
44398: xmlResetLastError();
44399: if (mem_base != xmlMemBlocks()) {
44400: printf("Leak of %d blocks found in xmlTextWriterWriteComment",
44401: xmlMemBlocks() - mem_base);
44402: test_ret++;
44403: printf(" %d", n_writer);
44404: printf(" %d", n_content);
44405: printf("\n");
44406: }
44407: }
44408: }
44409: function_tests++;
44410: #endif
44411:
44412: return(test_ret);
44413: }
44414:
44415:
44416: static int
44417: test_xmlTextWriterWriteDTD(void) {
44418: int test_ret = 0;
44419:
44420: #if defined(LIBXML_WRITER_ENABLED)
44421: int mem_base;
44422: int ret_val;
44423: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44424: int n_writer;
44425: xmlChar * name; /* the name of the DTD */
44426: int n_name;
44427: xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
44428: int n_pubid;
44429: xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
44430: int n_sysid;
44431: xmlChar * subset; /* string content of the DTD */
44432: int n_subset;
44433:
44434: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44435: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44436: for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
44437: for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
44438: for (n_subset = 0;n_subset < gen_nb_const_xmlChar_ptr;n_subset++) {
44439: mem_base = xmlMemBlocks();
44440: writer = gen_xmlTextWriterPtr(n_writer, 0);
44441: name = gen_const_xmlChar_ptr(n_name, 1);
44442: pubid = gen_const_xmlChar_ptr(n_pubid, 2);
44443: sysid = gen_const_xmlChar_ptr(n_sysid, 3);
44444: subset = gen_const_xmlChar_ptr(n_subset, 4);
44445:
44446: ret_val = xmlTextWriterWriteDTD(writer, (const xmlChar *)name, (const xmlChar *)pubid, (const xmlChar *)sysid, (const xmlChar *)subset);
44447: desret_int(ret_val);
44448: call_tests++;
44449: des_xmlTextWriterPtr(n_writer, writer, 0);
44450: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
44451: des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 2);
44452: des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 3);
44453: des_const_xmlChar_ptr(n_subset, (const xmlChar *)subset, 4);
44454: xmlResetLastError();
44455: if (mem_base != xmlMemBlocks()) {
44456: printf("Leak of %d blocks found in xmlTextWriterWriteDTD",
44457: xmlMemBlocks() - mem_base);
44458: test_ret++;
44459: printf(" %d", n_writer);
44460: printf(" %d", n_name);
44461: printf(" %d", n_pubid);
44462: printf(" %d", n_sysid);
44463: printf(" %d", n_subset);
44464: printf("\n");
44465: }
44466: }
44467: }
44468: }
44469: }
44470: }
44471: function_tests++;
44472: #endif
44473:
44474: return(test_ret);
44475: }
44476:
44477:
44478: static int
44479: test_xmlTextWriterWriteDTDAttlist(void) {
44480: int test_ret = 0;
44481:
44482: #if defined(LIBXML_WRITER_ENABLED)
44483: int mem_base;
44484: int ret_val;
44485: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44486: int n_writer;
44487: xmlChar * name; /* the name of the DTD ATTLIST */
44488: int n_name;
44489: xmlChar * content; /* content of the ATTLIST */
44490: int n_content;
44491:
44492: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44493: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
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: name = gen_const_xmlChar_ptr(n_name, 1);
44498: content = gen_const_xmlChar_ptr(n_content, 2);
44499:
44500: ret_val = xmlTextWriterWriteDTDAttlist(writer, (const xmlChar *)name, (const xmlChar *)content);
44501: desret_int(ret_val);
44502: call_tests++;
44503: des_xmlTextWriterPtr(n_writer, writer, 0);
44504: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
44505: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2);
44506: xmlResetLastError();
44507: if (mem_base != xmlMemBlocks()) {
44508: printf("Leak of %d blocks found in xmlTextWriterWriteDTDAttlist",
44509: xmlMemBlocks() - mem_base);
44510: test_ret++;
44511: printf(" %d", n_writer);
44512: printf(" %d", n_name);
44513: printf(" %d", n_content);
44514: printf("\n");
44515: }
44516: }
44517: }
44518: }
44519: function_tests++;
44520: #endif
44521:
44522: return(test_ret);
44523: }
44524:
44525:
44526: static int
44527: test_xmlTextWriterWriteDTDElement(void) {
44528: int test_ret = 0;
44529:
44530: #if defined(LIBXML_WRITER_ENABLED)
44531: int mem_base;
44532: int ret_val;
44533: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44534: int n_writer;
44535: xmlChar * name; /* the name of the DTD element */
44536: int n_name;
44537: xmlChar * content; /* content of the element */
44538: int n_content;
44539:
44540: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44541: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44542: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44543: mem_base = xmlMemBlocks();
44544: writer = gen_xmlTextWriterPtr(n_writer, 0);
44545: name = gen_const_xmlChar_ptr(n_name, 1);
44546: content = gen_const_xmlChar_ptr(n_content, 2);
44547:
44548: ret_val = xmlTextWriterWriteDTDElement(writer, (const xmlChar *)name, (const xmlChar *)content);
44549: desret_int(ret_val);
44550: call_tests++;
44551: des_xmlTextWriterPtr(n_writer, writer, 0);
44552: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
44553: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2);
44554: xmlResetLastError();
44555: if (mem_base != xmlMemBlocks()) {
44556: printf("Leak of %d blocks found in xmlTextWriterWriteDTDElement",
44557: xmlMemBlocks() - mem_base);
44558: test_ret++;
44559: printf(" %d", n_writer);
44560: printf(" %d", n_name);
44561: printf(" %d", n_content);
44562: printf("\n");
44563: }
44564: }
44565: }
44566: }
44567: function_tests++;
44568: #endif
44569:
44570: return(test_ret);
44571: }
44572:
44573:
44574: static int
44575: test_xmlTextWriterWriteDTDEntity(void) {
44576: int test_ret = 0;
44577:
44578: #if defined(LIBXML_WRITER_ENABLED)
44579: int mem_base;
44580: int ret_val;
44581: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44582: int n_writer;
44583: int pe; /* TRUE if this is a parameter entity, FALSE if not */
44584: int n_pe;
44585: xmlChar * name; /* the name of the DTD entity */
44586: int n_name;
44587: xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
44588: int n_pubid;
44589: xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
44590: int n_sysid;
44591: xmlChar * ndataid; /* the xml notation name. */
44592: int n_ndataid;
44593: xmlChar * content; /* content of the entity */
44594: int n_content;
44595:
44596: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44597: for (n_pe = 0;n_pe < gen_nb_int;n_pe++) {
44598: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44599: for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
44600: for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
44601: for (n_ndataid = 0;n_ndataid < gen_nb_const_xmlChar_ptr;n_ndataid++) {
44602: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44603: mem_base = xmlMemBlocks();
44604: writer = gen_xmlTextWriterPtr(n_writer, 0);
44605: pe = gen_int(n_pe, 1);
44606: name = gen_const_xmlChar_ptr(n_name, 2);
44607: pubid = gen_const_xmlChar_ptr(n_pubid, 3);
44608: sysid = gen_const_xmlChar_ptr(n_sysid, 4);
44609: ndataid = gen_const_xmlChar_ptr(n_ndataid, 5);
44610: content = gen_const_xmlChar_ptr(n_content, 6);
44611:
44612: ret_val = xmlTextWriterWriteDTDEntity(writer, pe, (const xmlChar *)name, (const xmlChar *)pubid, (const xmlChar *)sysid, (const xmlChar *)ndataid, (const xmlChar *)content);
44613: desret_int(ret_val);
44614: call_tests++;
44615: des_xmlTextWriterPtr(n_writer, writer, 0);
44616: des_int(n_pe, pe, 1);
44617: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
44618: des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 3);
44619: des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 4);
44620: des_const_xmlChar_ptr(n_ndataid, (const xmlChar *)ndataid, 5);
44621: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 6);
44622: xmlResetLastError();
44623: if (mem_base != xmlMemBlocks()) {
44624: printf("Leak of %d blocks found in xmlTextWriterWriteDTDEntity",
44625: xmlMemBlocks() - mem_base);
44626: test_ret++;
44627: printf(" %d", n_writer);
44628: printf(" %d", n_pe);
44629: printf(" %d", n_name);
44630: printf(" %d", n_pubid);
44631: printf(" %d", n_sysid);
44632: printf(" %d", n_ndataid);
44633: printf(" %d", n_content);
44634: printf("\n");
44635: }
44636: }
44637: }
44638: }
44639: }
44640: }
44641: }
44642: }
44643: function_tests++;
44644: #endif
44645:
44646: return(test_ret);
44647: }
44648:
44649:
44650: static int
44651: test_xmlTextWriterWriteDTDExternalEntity(void) {
44652: int test_ret = 0;
44653:
44654: #if defined(LIBXML_WRITER_ENABLED)
44655: int mem_base;
44656: int ret_val;
44657: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44658: int n_writer;
44659: int pe; /* TRUE if this is a parameter entity, FALSE if not */
44660: int n_pe;
44661: xmlChar * name; /* the name of the DTD entity */
44662: int n_name;
44663: xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
44664: int n_pubid;
44665: xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
44666: int n_sysid;
44667: xmlChar * ndataid; /* the xml notation name. */
44668: int n_ndataid;
44669:
44670: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44671: for (n_pe = 0;n_pe < gen_nb_int;n_pe++) {
44672: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44673: for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
44674: for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
44675: for (n_ndataid = 0;n_ndataid < gen_nb_const_xmlChar_ptr;n_ndataid++) {
44676: mem_base = xmlMemBlocks();
44677: writer = gen_xmlTextWriterPtr(n_writer, 0);
44678: pe = gen_int(n_pe, 1);
44679: name = gen_const_xmlChar_ptr(n_name, 2);
44680: pubid = gen_const_xmlChar_ptr(n_pubid, 3);
44681: sysid = gen_const_xmlChar_ptr(n_sysid, 4);
44682: ndataid = gen_const_xmlChar_ptr(n_ndataid, 5);
44683:
44684: ret_val = xmlTextWriterWriteDTDExternalEntity(writer, pe, (const xmlChar *)name, (const xmlChar *)pubid, (const xmlChar *)sysid, (const xmlChar *)ndataid);
44685: desret_int(ret_val);
44686: call_tests++;
44687: des_xmlTextWriterPtr(n_writer, writer, 0);
44688: des_int(n_pe, pe, 1);
44689: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
44690: des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 3);
44691: des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 4);
44692: des_const_xmlChar_ptr(n_ndataid, (const xmlChar *)ndataid, 5);
44693: xmlResetLastError();
44694: if (mem_base != xmlMemBlocks()) {
44695: printf("Leak of %d blocks found in xmlTextWriterWriteDTDExternalEntity",
44696: xmlMemBlocks() - mem_base);
44697: test_ret++;
44698: printf(" %d", n_writer);
44699: printf(" %d", n_pe);
44700: printf(" %d", n_name);
44701: printf(" %d", n_pubid);
44702: printf(" %d", n_sysid);
44703: printf(" %d", n_ndataid);
44704: printf("\n");
44705: }
44706: }
44707: }
44708: }
44709: }
44710: }
44711: }
44712: function_tests++;
44713: #endif
44714:
44715: return(test_ret);
44716: }
44717:
44718:
44719: static int
44720: test_xmlTextWriterWriteDTDExternalEntityContents(void) {
44721: int test_ret = 0;
44722:
44723: #if defined(LIBXML_WRITER_ENABLED)
44724: int mem_base;
44725: int ret_val;
44726: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44727: int n_writer;
44728: xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
44729: int n_pubid;
44730: xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
44731: int n_sysid;
44732: xmlChar * ndataid; /* the xml notation name. */
44733: int n_ndataid;
44734:
44735: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44736: for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
44737: for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
44738: for (n_ndataid = 0;n_ndataid < gen_nb_const_xmlChar_ptr;n_ndataid++) {
44739: mem_base = xmlMemBlocks();
44740: writer = gen_xmlTextWriterPtr(n_writer, 0);
44741: pubid = gen_const_xmlChar_ptr(n_pubid, 1);
44742: sysid = gen_const_xmlChar_ptr(n_sysid, 2);
44743: ndataid = gen_const_xmlChar_ptr(n_ndataid, 3);
44744:
44745: ret_val = xmlTextWriterWriteDTDExternalEntityContents(writer, (const xmlChar *)pubid, (const xmlChar *)sysid, (const xmlChar *)ndataid);
44746: desret_int(ret_val);
44747: call_tests++;
44748: des_xmlTextWriterPtr(n_writer, writer, 0);
44749: des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 1);
44750: des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 2);
44751: des_const_xmlChar_ptr(n_ndataid, (const xmlChar *)ndataid, 3);
44752: xmlResetLastError();
44753: if (mem_base != xmlMemBlocks()) {
44754: printf("Leak of %d blocks found in xmlTextWriterWriteDTDExternalEntityContents",
44755: xmlMemBlocks() - mem_base);
44756: test_ret++;
44757: printf(" %d", n_writer);
44758: printf(" %d", n_pubid);
44759: printf(" %d", n_sysid);
44760: printf(" %d", n_ndataid);
44761: printf("\n");
44762: }
44763: }
44764: }
44765: }
44766: }
44767: function_tests++;
44768: #endif
44769:
44770: return(test_ret);
44771: }
44772:
44773:
44774: static int
44775: test_xmlTextWriterWriteDTDInternalEntity(void) {
44776: int test_ret = 0;
44777:
44778: #if defined(LIBXML_WRITER_ENABLED)
44779: int mem_base;
44780: int ret_val;
44781: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44782: int n_writer;
44783: int pe; /* TRUE if this is a parameter entity, FALSE if not */
44784: int n_pe;
44785: xmlChar * name; /* the name of the DTD entity */
44786: int n_name;
44787: xmlChar * content; /* content of the entity */
44788: int n_content;
44789:
44790: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44791: for (n_pe = 0;n_pe < gen_nb_int;n_pe++) {
44792: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44793: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44794: mem_base = xmlMemBlocks();
44795: writer = gen_xmlTextWriterPtr(n_writer, 0);
44796: pe = gen_int(n_pe, 1);
44797: name = gen_const_xmlChar_ptr(n_name, 2);
44798: content = gen_const_xmlChar_ptr(n_content, 3);
44799:
44800: ret_val = xmlTextWriterWriteDTDInternalEntity(writer, pe, (const xmlChar *)name, (const xmlChar *)content);
44801: desret_int(ret_val);
44802: call_tests++;
44803: des_xmlTextWriterPtr(n_writer, writer, 0);
44804: des_int(n_pe, pe, 1);
44805: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
44806: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3);
44807: xmlResetLastError();
44808: if (mem_base != xmlMemBlocks()) {
44809: printf("Leak of %d blocks found in xmlTextWriterWriteDTDInternalEntity",
44810: xmlMemBlocks() - mem_base);
44811: test_ret++;
44812: printf(" %d", n_writer);
44813: printf(" %d", n_pe);
44814: printf(" %d", n_name);
44815: printf(" %d", n_content);
44816: printf("\n");
44817: }
44818: }
44819: }
44820: }
44821: }
44822: function_tests++;
44823: #endif
44824:
44825: return(test_ret);
44826: }
44827:
44828:
44829: static int
44830: test_xmlTextWriterWriteDTDNotation(void) {
44831: int test_ret = 0;
44832:
44833: #if defined(LIBXML_WRITER_ENABLED)
44834: int mem_base;
44835: int ret_val;
44836: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44837: int n_writer;
44838: xmlChar * name; /* the name of the xml notation */
44839: int n_name;
44840: xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
44841: int n_pubid;
44842: xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
44843: int n_sysid;
44844:
44845: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44846: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44847: for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
44848: for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
44849: mem_base = xmlMemBlocks();
44850: writer = gen_xmlTextWriterPtr(n_writer, 0);
44851: name = gen_const_xmlChar_ptr(n_name, 1);
44852: pubid = gen_const_xmlChar_ptr(n_pubid, 2);
44853: sysid = gen_const_xmlChar_ptr(n_sysid, 3);
44854:
44855: ret_val = xmlTextWriterWriteDTDNotation(writer, (const xmlChar *)name, (const xmlChar *)pubid, (const xmlChar *)sysid);
44856: desret_int(ret_val);
44857: call_tests++;
44858: des_xmlTextWriterPtr(n_writer, writer, 0);
44859: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
44860: des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 2);
44861: des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 3);
44862: xmlResetLastError();
44863: if (mem_base != xmlMemBlocks()) {
44864: printf("Leak of %d blocks found in xmlTextWriterWriteDTDNotation",
44865: xmlMemBlocks() - mem_base);
44866: test_ret++;
44867: printf(" %d", n_writer);
44868: printf(" %d", n_name);
44869: printf(" %d", n_pubid);
44870: printf(" %d", n_sysid);
44871: printf("\n");
44872: }
44873: }
44874: }
44875: }
44876: }
44877: function_tests++;
44878: #endif
44879:
44880: return(test_ret);
44881: }
44882:
44883:
44884: static int
44885: test_xmlTextWriterWriteElement(void) {
44886: int test_ret = 0;
44887:
44888: #if defined(LIBXML_WRITER_ENABLED)
44889: int mem_base;
44890: int ret_val;
44891: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44892: int n_writer;
44893: xmlChar * name; /* element name */
44894: int n_name;
44895: xmlChar * content; /* element content */
44896: int n_content;
44897:
44898: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44899: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44900: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44901: mem_base = xmlMemBlocks();
44902: writer = gen_xmlTextWriterPtr(n_writer, 0);
44903: name = gen_const_xmlChar_ptr(n_name, 1);
44904: content = gen_const_xmlChar_ptr(n_content, 2);
44905:
44906: ret_val = xmlTextWriterWriteElement(writer, (const xmlChar *)name, (const xmlChar *)content);
44907: desret_int(ret_val);
44908: call_tests++;
44909: des_xmlTextWriterPtr(n_writer, writer, 0);
44910: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
44911: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2);
44912: xmlResetLastError();
44913: if (mem_base != xmlMemBlocks()) {
44914: printf("Leak of %d blocks found in xmlTextWriterWriteElement",
44915: xmlMemBlocks() - mem_base);
44916: test_ret++;
44917: printf(" %d", n_writer);
44918: printf(" %d", n_name);
44919: printf(" %d", n_content);
44920: printf("\n");
44921: }
44922: }
44923: }
44924: }
44925: function_tests++;
44926: #endif
44927:
44928: return(test_ret);
44929: }
44930:
44931:
44932: static int
44933: test_xmlTextWriterWriteElementNS(void) {
44934: int test_ret = 0;
44935:
44936: #if defined(LIBXML_WRITER_ENABLED)
44937: int mem_base;
44938: int ret_val;
44939: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44940: int n_writer;
44941: xmlChar * prefix; /* namespace prefix */
44942: int n_prefix;
44943: xmlChar * name; /* element local name */
44944: int n_name;
44945: xmlChar * namespaceURI; /* namespace URI */
44946: int n_namespaceURI;
44947: xmlChar * content; /* element content */
44948: int n_content;
44949:
44950: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44951: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
44952: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44953: for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
44954: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44955: mem_base = xmlMemBlocks();
44956: writer = gen_xmlTextWriterPtr(n_writer, 0);
44957: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
44958: name = gen_const_xmlChar_ptr(n_name, 2);
44959: namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 3);
44960: content = gen_const_xmlChar_ptr(n_content, 4);
44961:
44962: ret_val = xmlTextWriterWriteElementNS(writer, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)namespaceURI, (const xmlChar *)content);
44963: desret_int(ret_val);
44964: call_tests++;
44965: des_xmlTextWriterPtr(n_writer, writer, 0);
44966: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
44967: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
44968: des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 3);
44969: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 4);
44970: xmlResetLastError();
44971: if (mem_base != xmlMemBlocks()) {
44972: printf("Leak of %d blocks found in xmlTextWriterWriteElementNS",
44973: xmlMemBlocks() - mem_base);
44974: test_ret++;
44975: printf(" %d", n_writer);
44976: printf(" %d", n_prefix);
44977: printf(" %d", n_name);
44978: printf(" %d", n_namespaceURI);
44979: printf(" %d", n_content);
44980: printf("\n");
44981: }
44982: }
44983: }
44984: }
44985: }
44986: }
44987: function_tests++;
44988: #endif
44989:
44990: return(test_ret);
44991: }
44992:
44993:
44994: static int
44995: test_xmlTextWriterWriteFormatAttribute(void) {
44996: int test_ret = 0;
44997:
44998:
44999: /* missing type support */
45000: return(test_ret);
45001: }
45002:
45003:
45004: static int
45005: test_xmlTextWriterWriteFormatAttributeNS(void) {
45006: int test_ret = 0;
45007:
45008:
45009: /* missing type support */
45010: return(test_ret);
45011: }
45012:
45013:
45014: static int
45015: test_xmlTextWriterWriteFormatCDATA(void) {
45016: int test_ret = 0;
45017:
45018:
45019: /* missing type support */
45020: return(test_ret);
45021: }
45022:
45023:
45024: static int
45025: test_xmlTextWriterWriteFormatComment(void) {
45026: int test_ret = 0;
45027:
45028:
45029: /* missing type support */
45030: return(test_ret);
45031: }
45032:
45033:
45034: static int
45035: test_xmlTextWriterWriteFormatDTD(void) {
45036: int test_ret = 0;
45037:
45038:
45039: /* missing type support */
45040: return(test_ret);
45041: }
45042:
45043:
45044: static int
45045: test_xmlTextWriterWriteFormatDTDAttlist(void) {
45046: int test_ret = 0;
45047:
45048:
45049: /* missing type support */
45050: return(test_ret);
45051: }
45052:
45053:
45054: static int
45055: test_xmlTextWriterWriteFormatDTDElement(void) {
45056: int test_ret = 0;
45057:
45058:
45059: /* missing type support */
45060: return(test_ret);
45061: }
45062:
45063:
45064: static int
45065: test_xmlTextWriterWriteFormatDTDInternalEntity(void) {
45066: int test_ret = 0;
45067:
45068:
45069: /* missing type support */
45070: return(test_ret);
45071: }
45072:
45073:
45074: static int
45075: test_xmlTextWriterWriteFormatElement(void) {
45076: int test_ret = 0;
45077:
45078:
45079: /* missing type support */
45080: return(test_ret);
45081: }
45082:
45083:
45084: static int
45085: test_xmlTextWriterWriteFormatElementNS(void) {
45086: int test_ret = 0;
45087:
45088:
45089: /* missing type support */
45090: return(test_ret);
45091: }
45092:
45093:
45094: static int
45095: test_xmlTextWriterWriteFormatPI(void) {
45096: int test_ret = 0;
45097:
45098:
45099: /* missing type support */
45100: return(test_ret);
45101: }
45102:
45103:
45104: static int
45105: test_xmlTextWriterWriteFormatRaw(void) {
45106: int test_ret = 0;
45107:
45108:
45109: /* missing type support */
45110: return(test_ret);
45111: }
45112:
45113:
45114: static int
45115: test_xmlTextWriterWriteFormatString(void) {
45116: int test_ret = 0;
45117:
45118:
45119: /* missing type support */
45120: return(test_ret);
45121: }
45122:
45123:
45124: static int
45125: test_xmlTextWriterWritePI(void) {
45126: int test_ret = 0;
45127:
45128: #if defined(LIBXML_WRITER_ENABLED)
45129: int mem_base;
45130: int ret_val;
45131: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
45132: int n_writer;
45133: xmlChar * target; /* PI target */
45134: int n_target;
45135: xmlChar * content; /* PI content */
45136: int n_content;
45137:
45138: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
45139: for (n_target = 0;n_target < gen_nb_const_xmlChar_ptr;n_target++) {
45140: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
45141: mem_base = xmlMemBlocks();
45142: writer = gen_xmlTextWriterPtr(n_writer, 0);
45143: target = gen_const_xmlChar_ptr(n_target, 1);
45144: content = gen_const_xmlChar_ptr(n_content, 2);
45145:
45146: ret_val = xmlTextWriterWritePI(writer, (const xmlChar *)target, (const xmlChar *)content);
45147: desret_int(ret_val);
45148: call_tests++;
45149: des_xmlTextWriterPtr(n_writer, writer, 0);
45150: des_const_xmlChar_ptr(n_target, (const xmlChar *)target, 1);
45151: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2);
45152: xmlResetLastError();
45153: if (mem_base != xmlMemBlocks()) {
45154: printf("Leak of %d blocks found in xmlTextWriterWritePI",
45155: xmlMemBlocks() - mem_base);
45156: test_ret++;
45157: printf(" %d", n_writer);
45158: printf(" %d", n_target);
45159: printf(" %d", n_content);
45160: printf("\n");
45161: }
45162: }
45163: }
45164: }
45165: function_tests++;
45166: #endif
45167:
45168: return(test_ret);
45169: }
45170:
45171:
45172: static int
45173: test_xmlTextWriterWriteRaw(void) {
45174: int test_ret = 0;
45175:
45176: #if defined(LIBXML_WRITER_ENABLED)
45177: int mem_base;
45178: int ret_val;
45179: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
45180: int n_writer;
45181: xmlChar * content; /* text string */
45182: int n_content;
45183:
45184: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
45185: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
45186: mem_base = xmlMemBlocks();
45187: writer = gen_xmlTextWriterPtr(n_writer, 0);
45188: content = gen_const_xmlChar_ptr(n_content, 1);
45189:
45190: ret_val = xmlTextWriterWriteRaw(writer, (const xmlChar *)content);
45191: desret_int(ret_val);
45192: call_tests++;
45193: des_xmlTextWriterPtr(n_writer, writer, 0);
45194: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
45195: xmlResetLastError();
45196: if (mem_base != xmlMemBlocks()) {
45197: printf("Leak of %d blocks found in xmlTextWriterWriteRaw",
45198: xmlMemBlocks() - mem_base);
45199: test_ret++;
45200: printf(" %d", n_writer);
45201: printf(" %d", n_content);
45202: printf("\n");
45203: }
45204: }
45205: }
45206: function_tests++;
45207: #endif
45208:
45209: return(test_ret);
45210: }
45211:
45212:
45213: static int
45214: test_xmlTextWriterWriteRawLen(void) {
45215: int test_ret = 0;
45216:
45217: #if defined(LIBXML_WRITER_ENABLED)
45218: int mem_base;
45219: int ret_val;
45220: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
45221: int n_writer;
45222: xmlChar * content; /* text string */
45223: int n_content;
45224: int len; /* length of the text string */
45225: int n_len;
45226:
45227: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
45228: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
45229: for (n_len = 0;n_len < gen_nb_int;n_len++) {
45230: mem_base = xmlMemBlocks();
45231: writer = gen_xmlTextWriterPtr(n_writer, 0);
45232: content = gen_const_xmlChar_ptr(n_content, 1);
45233: len = gen_int(n_len, 2);
45234:
45235: ret_val = xmlTextWriterWriteRawLen(writer, (const xmlChar *)content, len);
45236: desret_int(ret_val);
45237: call_tests++;
45238: des_xmlTextWriterPtr(n_writer, writer, 0);
45239: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
45240: des_int(n_len, len, 2);
45241: xmlResetLastError();
45242: if (mem_base != xmlMemBlocks()) {
45243: printf("Leak of %d blocks found in xmlTextWriterWriteRawLen",
45244: xmlMemBlocks() - mem_base);
45245: test_ret++;
45246: printf(" %d", n_writer);
45247: printf(" %d", n_content);
45248: printf(" %d", n_len);
45249: printf("\n");
45250: }
45251: }
45252: }
45253: }
45254: function_tests++;
45255: #endif
45256:
45257: return(test_ret);
45258: }
45259:
45260:
45261: static int
45262: test_xmlTextWriterWriteString(void) {
45263: int test_ret = 0;
45264:
45265: #if defined(LIBXML_WRITER_ENABLED)
45266: int mem_base;
45267: int ret_val;
45268: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
45269: int n_writer;
45270: xmlChar * content; /* text string */
45271: int n_content;
45272:
45273: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
45274: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
45275: mem_base = xmlMemBlocks();
45276: writer = gen_xmlTextWriterPtr(n_writer, 0);
45277: content = gen_const_xmlChar_ptr(n_content, 1);
45278:
45279: ret_val = xmlTextWriterWriteString(writer, (const xmlChar *)content);
45280: desret_int(ret_val);
45281: call_tests++;
45282: des_xmlTextWriterPtr(n_writer, writer, 0);
45283: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
45284: xmlResetLastError();
45285: if (mem_base != xmlMemBlocks()) {
45286: printf("Leak of %d blocks found in xmlTextWriterWriteString",
45287: xmlMemBlocks() - mem_base);
45288: test_ret++;
45289: printf(" %d", n_writer);
45290: printf(" %d", n_content);
45291: printf("\n");
45292: }
45293: }
45294: }
45295: function_tests++;
45296: #endif
45297:
45298: return(test_ret);
45299: }
45300:
45301:
45302: static int
45303: test_xmlTextWriterWriteVFormatAttribute(void) {
45304: int test_ret = 0;
45305:
45306:
45307: /* missing type support */
45308: return(test_ret);
45309: }
45310:
45311:
45312: static int
45313: test_xmlTextWriterWriteVFormatAttributeNS(void) {
45314: int test_ret = 0;
45315:
45316:
45317: /* missing type support */
45318: return(test_ret);
45319: }
45320:
45321:
45322: static int
45323: test_xmlTextWriterWriteVFormatCDATA(void) {
45324: int test_ret = 0;
45325:
45326:
45327: /* missing type support */
45328: return(test_ret);
45329: }
45330:
45331:
45332: static int
45333: test_xmlTextWriterWriteVFormatComment(void) {
45334: int test_ret = 0;
45335:
45336:
45337: /* missing type support */
45338: return(test_ret);
45339: }
45340:
45341:
45342: static int
45343: test_xmlTextWriterWriteVFormatDTD(void) {
45344: int test_ret = 0;
45345:
45346:
45347: /* missing type support */
45348: return(test_ret);
45349: }
45350:
45351:
45352: static int
45353: test_xmlTextWriterWriteVFormatDTDAttlist(void) {
45354: int test_ret = 0;
45355:
45356:
45357: /* missing type support */
45358: return(test_ret);
45359: }
45360:
45361:
45362: static int
45363: test_xmlTextWriterWriteVFormatDTDElement(void) {
45364: int test_ret = 0;
45365:
45366:
45367: /* missing type support */
45368: return(test_ret);
45369: }
45370:
45371:
45372: static int
45373: test_xmlTextWriterWriteVFormatDTDInternalEntity(void) {
45374: int test_ret = 0;
45375:
45376:
45377: /* missing type support */
45378: return(test_ret);
45379: }
45380:
45381:
45382: static int
45383: test_xmlTextWriterWriteVFormatElement(void) {
45384: int test_ret = 0;
45385:
45386:
45387: /* missing type support */
45388: return(test_ret);
45389: }
45390:
45391:
45392: static int
45393: test_xmlTextWriterWriteVFormatElementNS(void) {
45394: int test_ret = 0;
45395:
45396:
45397: /* missing type support */
45398: return(test_ret);
45399: }
45400:
45401:
45402: static int
45403: test_xmlTextWriterWriteVFormatPI(void) {
45404: int test_ret = 0;
45405:
45406:
45407: /* missing type support */
45408: return(test_ret);
45409: }
45410:
45411:
45412: static int
45413: test_xmlTextWriterWriteVFormatRaw(void) {
45414: int test_ret = 0;
45415:
45416:
45417: /* missing type support */
45418: return(test_ret);
45419: }
45420:
45421:
45422: static int
45423: test_xmlTextWriterWriteVFormatString(void) {
45424: int test_ret = 0;
45425:
45426:
45427: /* missing type support */
45428: return(test_ret);
45429: }
45430:
45431: static int
45432: test_xmlwriter(void) {
45433: int test_ret = 0;
45434:
45435: if (quiet == 0) printf("Testing xmlwriter : 51 of 79 functions ...\n");
45436: test_ret += test_xmlNewTextWriter();
45437: test_ret += test_xmlNewTextWriterFilename();
45438: test_ret += test_xmlNewTextWriterMemory();
45439: test_ret += test_xmlNewTextWriterPushParser();
45440: test_ret += test_xmlNewTextWriterTree();
45441: test_ret += test_xmlTextWriterEndAttribute();
45442: test_ret += test_xmlTextWriterEndCDATA();
45443: test_ret += test_xmlTextWriterEndComment();
45444: test_ret += test_xmlTextWriterEndDTD();
45445: test_ret += test_xmlTextWriterEndDTDAttlist();
45446: test_ret += test_xmlTextWriterEndDTDElement();
45447: test_ret += test_xmlTextWriterEndDTDEntity();
45448: test_ret += test_xmlTextWriterEndDocument();
45449: test_ret += test_xmlTextWriterEndElement();
45450: test_ret += test_xmlTextWriterEndPI();
45451: test_ret += test_xmlTextWriterFlush();
45452: test_ret += test_xmlTextWriterFullEndElement();
45453: test_ret += test_xmlTextWriterSetIndent();
45454: test_ret += test_xmlTextWriterSetIndentString();
45455: test_ret += test_xmlTextWriterStartAttribute();
45456: test_ret += test_xmlTextWriterStartAttributeNS();
45457: test_ret += test_xmlTextWriterStartCDATA();
45458: test_ret += test_xmlTextWriterStartComment();
45459: test_ret += test_xmlTextWriterStartDTD();
45460: test_ret += test_xmlTextWriterStartDTDAttlist();
45461: test_ret += test_xmlTextWriterStartDTDElement();
45462: test_ret += test_xmlTextWriterStartDTDEntity();
45463: test_ret += test_xmlTextWriterStartDocument();
45464: test_ret += test_xmlTextWriterStartElement();
45465: test_ret += test_xmlTextWriterStartElementNS();
45466: test_ret += test_xmlTextWriterStartPI();
45467: test_ret += test_xmlTextWriterWriteAttribute();
45468: test_ret += test_xmlTextWriterWriteAttributeNS();
45469: test_ret += test_xmlTextWriterWriteBase64();
45470: test_ret += test_xmlTextWriterWriteBinHex();
45471: test_ret += test_xmlTextWriterWriteCDATA();
45472: test_ret += test_xmlTextWriterWriteComment();
45473: test_ret += test_xmlTextWriterWriteDTD();
45474: test_ret += test_xmlTextWriterWriteDTDAttlist();
45475: test_ret += test_xmlTextWriterWriteDTDElement();
45476: test_ret += test_xmlTextWriterWriteDTDEntity();
45477: test_ret += test_xmlTextWriterWriteDTDExternalEntity();
45478: test_ret += test_xmlTextWriterWriteDTDExternalEntityContents();
45479: test_ret += test_xmlTextWriterWriteDTDInternalEntity();
45480: test_ret += test_xmlTextWriterWriteDTDNotation();
45481: test_ret += test_xmlTextWriterWriteElement();
45482: test_ret += test_xmlTextWriterWriteElementNS();
45483: test_ret += test_xmlTextWriterWriteFormatAttribute();
45484: test_ret += test_xmlTextWriterWriteFormatAttributeNS();
45485: test_ret += test_xmlTextWriterWriteFormatCDATA();
45486: test_ret += test_xmlTextWriterWriteFormatComment();
45487: test_ret += test_xmlTextWriterWriteFormatDTD();
45488: test_ret += test_xmlTextWriterWriteFormatDTDAttlist();
45489: test_ret += test_xmlTextWriterWriteFormatDTDElement();
45490: test_ret += test_xmlTextWriterWriteFormatDTDInternalEntity();
45491: test_ret += test_xmlTextWriterWriteFormatElement();
45492: test_ret += test_xmlTextWriterWriteFormatElementNS();
45493: test_ret += test_xmlTextWriterWriteFormatPI();
45494: test_ret += test_xmlTextWriterWriteFormatRaw();
45495: test_ret += test_xmlTextWriterWriteFormatString();
45496: test_ret += test_xmlTextWriterWritePI();
45497: test_ret += test_xmlTextWriterWriteRaw();
45498: test_ret += test_xmlTextWriterWriteRawLen();
45499: test_ret += test_xmlTextWriterWriteString();
45500: test_ret += test_xmlTextWriterWriteVFormatAttribute();
45501: test_ret += test_xmlTextWriterWriteVFormatAttributeNS();
45502: test_ret += test_xmlTextWriterWriteVFormatCDATA();
45503: test_ret += test_xmlTextWriterWriteVFormatComment();
45504: test_ret += test_xmlTextWriterWriteVFormatDTD();
45505: test_ret += test_xmlTextWriterWriteVFormatDTDAttlist();
45506: test_ret += test_xmlTextWriterWriteVFormatDTDElement();
45507: test_ret += test_xmlTextWriterWriteVFormatDTDInternalEntity();
45508: test_ret += test_xmlTextWriterWriteVFormatElement();
45509: test_ret += test_xmlTextWriterWriteVFormatElementNS();
45510: test_ret += test_xmlTextWriterWriteVFormatPI();
45511: test_ret += test_xmlTextWriterWriteVFormatRaw();
45512: test_ret += test_xmlTextWriterWriteVFormatString();
45513:
45514: if (test_ret != 0)
45515: printf("Module xmlwriter: %d errors\n", test_ret);
45516: return(test_ret);
45517: }
45518:
45519: static int
45520: test_xmlXPathCastBooleanToNumber(void) {
45521: int test_ret = 0;
45522:
45523: #if defined(LIBXML_XPATH_ENABLED)
45524: int mem_base;
45525: double ret_val;
45526: int val; /* a boolean */
45527: int n_val;
45528:
45529: for (n_val = 0;n_val < gen_nb_int;n_val++) {
45530: mem_base = xmlMemBlocks();
45531: val = gen_int(n_val, 0);
45532:
45533: ret_val = xmlXPathCastBooleanToNumber(val);
45534: desret_double(ret_val);
45535: call_tests++;
45536: des_int(n_val, val, 0);
45537: xmlResetLastError();
45538: if (mem_base != xmlMemBlocks()) {
45539: printf("Leak of %d blocks found in xmlXPathCastBooleanToNumber",
45540: xmlMemBlocks() - mem_base);
45541: test_ret++;
45542: printf(" %d", n_val);
45543: printf("\n");
45544: }
45545: }
45546: function_tests++;
45547: #endif
45548:
45549: return(test_ret);
45550: }
45551:
45552:
45553: static int
45554: test_xmlXPathCastBooleanToString(void) {
45555: int test_ret = 0;
45556:
45557: #if defined(LIBXML_XPATH_ENABLED)
45558: int mem_base;
45559: xmlChar * ret_val;
45560: int val; /* a boolean */
45561: int n_val;
45562:
45563: for (n_val = 0;n_val < gen_nb_int;n_val++) {
45564: mem_base = xmlMemBlocks();
45565: val = gen_int(n_val, 0);
45566:
45567: ret_val = xmlXPathCastBooleanToString(val);
45568: desret_xmlChar_ptr(ret_val);
45569: call_tests++;
45570: des_int(n_val, val, 0);
45571: xmlResetLastError();
45572: if (mem_base != xmlMemBlocks()) {
45573: printf("Leak of %d blocks found in xmlXPathCastBooleanToString",
45574: xmlMemBlocks() - mem_base);
45575: test_ret++;
45576: printf(" %d", n_val);
45577: printf("\n");
45578: }
45579: }
45580: function_tests++;
45581: #endif
45582:
45583: return(test_ret);
45584: }
45585:
45586:
45587: static int
45588: test_xmlXPathCastNodeSetToBoolean(void) {
45589: int test_ret = 0;
45590:
45591: #if defined(LIBXML_XPATH_ENABLED)
45592: int mem_base;
45593: int ret_val;
45594: xmlNodeSetPtr ns; /* a node-set */
45595: int n_ns;
45596:
45597: for (n_ns = 0;n_ns < gen_nb_xmlNodeSetPtr;n_ns++) {
45598: mem_base = xmlMemBlocks();
45599: ns = gen_xmlNodeSetPtr(n_ns, 0);
45600:
45601: ret_val = xmlXPathCastNodeSetToBoolean(ns);
45602: desret_int(ret_val);
45603: call_tests++;
45604: des_xmlNodeSetPtr(n_ns, ns, 0);
45605: xmlResetLastError();
45606: if (mem_base != xmlMemBlocks()) {
45607: printf("Leak of %d blocks found in xmlXPathCastNodeSetToBoolean",
45608: xmlMemBlocks() - mem_base);
45609: test_ret++;
45610: printf(" %d", n_ns);
45611: printf("\n");
45612: }
45613: }
45614: function_tests++;
45615: #endif
45616:
45617: return(test_ret);
45618: }
45619:
45620:
45621: static int
45622: test_xmlXPathCastNodeSetToNumber(void) {
45623: int test_ret = 0;
45624:
45625: #if defined(LIBXML_XPATH_ENABLED)
45626: int mem_base;
45627: double ret_val;
45628: xmlNodeSetPtr ns; /* a node-set */
45629: int n_ns;
45630:
45631: for (n_ns = 0;n_ns < gen_nb_xmlNodeSetPtr;n_ns++) {
45632: mem_base = xmlMemBlocks();
45633: ns = gen_xmlNodeSetPtr(n_ns, 0);
45634:
45635: ret_val = xmlXPathCastNodeSetToNumber(ns);
45636: desret_double(ret_val);
45637: call_tests++;
45638: des_xmlNodeSetPtr(n_ns, ns, 0);
45639: xmlResetLastError();
45640: if (mem_base != xmlMemBlocks()) {
45641: printf("Leak of %d blocks found in xmlXPathCastNodeSetToNumber",
45642: xmlMemBlocks() - mem_base);
45643: test_ret++;
45644: printf(" %d", n_ns);
45645: printf("\n");
45646: }
45647: }
45648: function_tests++;
45649: #endif
45650:
45651: return(test_ret);
45652: }
45653:
45654:
45655: static int
45656: test_xmlXPathCastNodeSetToString(void) {
45657: int test_ret = 0;
45658:
45659: #if defined(LIBXML_XPATH_ENABLED)
45660: int mem_base;
45661: xmlChar * ret_val;
45662: xmlNodeSetPtr ns; /* a node-set */
45663: int n_ns;
45664:
45665: for (n_ns = 0;n_ns < gen_nb_xmlNodeSetPtr;n_ns++) {
45666: mem_base = xmlMemBlocks();
45667: ns = gen_xmlNodeSetPtr(n_ns, 0);
45668:
45669: ret_val = xmlXPathCastNodeSetToString(ns);
45670: desret_xmlChar_ptr(ret_val);
45671: call_tests++;
45672: des_xmlNodeSetPtr(n_ns, ns, 0);
45673: xmlResetLastError();
45674: if (mem_base != xmlMemBlocks()) {
45675: printf("Leak of %d blocks found in xmlXPathCastNodeSetToString",
45676: xmlMemBlocks() - mem_base);
45677: test_ret++;
45678: printf(" %d", n_ns);
45679: printf("\n");
45680: }
45681: }
45682: function_tests++;
45683: #endif
45684:
45685: return(test_ret);
45686: }
45687:
45688:
45689: static int
45690: test_xmlXPathCastNodeToNumber(void) {
45691: int test_ret = 0;
45692:
45693: #if defined(LIBXML_XPATH_ENABLED)
45694: int mem_base;
45695: double ret_val;
45696: xmlNodePtr node; /* a node */
45697: int n_node;
45698:
45699: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
45700: mem_base = xmlMemBlocks();
45701: node = gen_xmlNodePtr(n_node, 0);
45702:
45703: ret_val = xmlXPathCastNodeToNumber(node);
45704: desret_double(ret_val);
45705: call_tests++;
45706: des_xmlNodePtr(n_node, node, 0);
45707: xmlResetLastError();
45708: if (mem_base != xmlMemBlocks()) {
45709: printf("Leak of %d blocks found in xmlXPathCastNodeToNumber",
45710: xmlMemBlocks() - mem_base);
45711: test_ret++;
45712: printf(" %d", n_node);
45713: printf("\n");
45714: }
45715: }
45716: function_tests++;
45717: #endif
45718:
45719: return(test_ret);
45720: }
45721:
45722:
45723: static int
45724: test_xmlXPathCastNodeToString(void) {
45725: int test_ret = 0;
45726:
45727: #if defined(LIBXML_XPATH_ENABLED)
45728: int mem_base;
45729: xmlChar * ret_val;
45730: xmlNodePtr node; /* a node */
45731: int n_node;
45732:
45733: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
45734: mem_base = xmlMemBlocks();
45735: node = gen_xmlNodePtr(n_node, 0);
45736:
45737: ret_val = xmlXPathCastNodeToString(node);
45738: desret_xmlChar_ptr(ret_val);
45739: call_tests++;
45740: des_xmlNodePtr(n_node, node, 0);
45741: xmlResetLastError();
45742: if (mem_base != xmlMemBlocks()) {
45743: printf("Leak of %d blocks found in xmlXPathCastNodeToString",
45744: xmlMemBlocks() - mem_base);
45745: test_ret++;
45746: printf(" %d", n_node);
45747: printf("\n");
45748: }
45749: }
45750: function_tests++;
45751: #endif
45752:
45753: return(test_ret);
45754: }
45755:
45756:
45757: static int
45758: test_xmlXPathCastNumberToBoolean(void) {
45759: int test_ret = 0;
45760:
45761: #if defined(LIBXML_XPATH_ENABLED)
45762: int mem_base;
45763: int ret_val;
45764: double val; /* a number */
45765: int n_val;
45766:
45767: for (n_val = 0;n_val < gen_nb_double;n_val++) {
45768: mem_base = xmlMemBlocks();
45769: val = gen_double(n_val, 0);
45770:
45771: ret_val = xmlXPathCastNumberToBoolean(val);
45772: desret_int(ret_val);
45773: call_tests++;
45774: des_double(n_val, val, 0);
45775: xmlResetLastError();
45776: if (mem_base != xmlMemBlocks()) {
45777: printf("Leak of %d blocks found in xmlXPathCastNumberToBoolean",
45778: xmlMemBlocks() - mem_base);
45779: test_ret++;
45780: printf(" %d", n_val);
45781: printf("\n");
45782: }
45783: }
45784: function_tests++;
45785: #endif
45786:
45787: return(test_ret);
45788: }
45789:
45790:
45791: static int
45792: test_xmlXPathCastNumberToString(void) {
45793: int test_ret = 0;
45794:
45795: #if defined(LIBXML_XPATH_ENABLED)
45796: int mem_base;
45797: xmlChar * ret_val;
45798: double val; /* a number */
45799: int n_val;
45800:
45801: for (n_val = 0;n_val < gen_nb_double;n_val++) {
45802: mem_base = xmlMemBlocks();
45803: val = gen_double(n_val, 0);
45804:
45805: ret_val = xmlXPathCastNumberToString(val);
45806: desret_xmlChar_ptr(ret_val);
45807: call_tests++;
45808: des_double(n_val, val, 0);
45809: xmlResetLastError();
45810: if (mem_base != xmlMemBlocks()) {
45811: printf("Leak of %d blocks found in xmlXPathCastNumberToString",
45812: xmlMemBlocks() - mem_base);
45813: test_ret++;
45814: printf(" %d", n_val);
45815: printf("\n");
45816: }
45817: }
45818: function_tests++;
45819: #endif
45820:
45821: return(test_ret);
45822: }
45823:
45824:
45825: static int
45826: test_xmlXPathCastStringToBoolean(void) {
45827: int test_ret = 0;
45828:
45829: #if defined(LIBXML_XPATH_ENABLED)
45830: int mem_base;
45831: int ret_val;
45832: xmlChar * val; /* a string */
45833: int n_val;
45834:
45835: for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) {
45836: mem_base = xmlMemBlocks();
45837: val = gen_const_xmlChar_ptr(n_val, 0);
45838:
45839: ret_val = xmlXPathCastStringToBoolean((const xmlChar *)val);
45840: desret_int(ret_val);
45841: call_tests++;
45842: des_const_xmlChar_ptr(n_val, (const xmlChar *)val, 0);
45843: xmlResetLastError();
45844: if (mem_base != xmlMemBlocks()) {
45845: printf("Leak of %d blocks found in xmlXPathCastStringToBoolean",
45846: xmlMemBlocks() - mem_base);
45847: test_ret++;
45848: printf(" %d", n_val);
45849: printf("\n");
45850: }
45851: }
45852: function_tests++;
45853: #endif
45854:
45855: return(test_ret);
45856: }
45857:
45858:
45859: static int
45860: test_xmlXPathCastStringToNumber(void) {
45861: int test_ret = 0;
45862:
45863: #if defined(LIBXML_XPATH_ENABLED)
45864: int mem_base;
45865: double ret_val;
45866: xmlChar * val; /* a string */
45867: int n_val;
45868:
45869: for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) {
45870: mem_base = xmlMemBlocks();
45871: val = gen_const_xmlChar_ptr(n_val, 0);
45872:
45873: ret_val = xmlXPathCastStringToNumber((const xmlChar *)val);
45874: desret_double(ret_val);
45875: call_tests++;
45876: des_const_xmlChar_ptr(n_val, (const xmlChar *)val, 0);
45877: xmlResetLastError();
45878: if (mem_base != xmlMemBlocks()) {
45879: printf("Leak of %d blocks found in xmlXPathCastStringToNumber",
45880: xmlMemBlocks() - mem_base);
45881: test_ret++;
45882: printf(" %d", n_val);
45883: printf("\n");
45884: }
45885: }
45886: function_tests++;
45887: #endif
45888:
45889: return(test_ret);
45890: }
45891:
45892:
45893: static int
45894: test_xmlXPathCastToBoolean(void) {
45895: int test_ret = 0;
45896:
45897: #if defined(LIBXML_XPATH_ENABLED)
45898: int mem_base;
45899: int ret_val;
45900: xmlXPathObjectPtr val; /* an XPath object */
45901: int n_val;
45902:
45903: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
45904: mem_base = xmlMemBlocks();
45905: val = gen_xmlXPathObjectPtr(n_val, 0);
45906:
45907: ret_val = xmlXPathCastToBoolean(val);
45908: desret_int(ret_val);
45909: call_tests++;
45910: des_xmlXPathObjectPtr(n_val, val, 0);
45911: xmlResetLastError();
45912: if (mem_base != xmlMemBlocks()) {
45913: printf("Leak of %d blocks found in xmlXPathCastToBoolean",
45914: xmlMemBlocks() - mem_base);
45915: test_ret++;
45916: printf(" %d", n_val);
45917: printf("\n");
45918: }
45919: }
45920: function_tests++;
45921: #endif
45922:
45923: return(test_ret);
45924: }
45925:
45926:
45927: static int
45928: test_xmlXPathCastToNumber(void) {
45929: int test_ret = 0;
45930:
45931: #if defined(LIBXML_XPATH_ENABLED)
45932: int mem_base;
45933: double ret_val;
45934: xmlXPathObjectPtr val; /* an XPath object */
45935: int n_val;
45936:
45937: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
45938: mem_base = xmlMemBlocks();
45939: val = gen_xmlXPathObjectPtr(n_val, 0);
45940:
45941: ret_val = xmlXPathCastToNumber(val);
45942: desret_double(ret_val);
45943: call_tests++;
45944: des_xmlXPathObjectPtr(n_val, val, 0);
45945: xmlResetLastError();
45946: if (mem_base != xmlMemBlocks()) {
45947: printf("Leak of %d blocks found in xmlXPathCastToNumber",
45948: xmlMemBlocks() - mem_base);
45949: test_ret++;
45950: printf(" %d", n_val);
45951: printf("\n");
45952: }
45953: }
45954: function_tests++;
45955: #endif
45956:
45957: return(test_ret);
45958: }
45959:
45960:
45961: static int
45962: test_xmlXPathCastToString(void) {
45963: int test_ret = 0;
45964:
45965: #if defined(LIBXML_XPATH_ENABLED)
45966: int mem_base;
45967: xmlChar * ret_val;
45968: xmlXPathObjectPtr val; /* an XPath object */
45969: int n_val;
45970:
45971: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
45972: mem_base = xmlMemBlocks();
45973: val = gen_xmlXPathObjectPtr(n_val, 0);
45974:
45975: ret_val = xmlXPathCastToString(val);
45976: desret_xmlChar_ptr(ret_val);
45977: call_tests++;
45978: des_xmlXPathObjectPtr(n_val, val, 0);
45979: xmlResetLastError();
45980: if (mem_base != xmlMemBlocks()) {
45981: printf("Leak of %d blocks found in xmlXPathCastToString",
45982: xmlMemBlocks() - mem_base);
45983: test_ret++;
45984: printf(" %d", n_val);
45985: printf("\n");
45986: }
45987: }
45988: function_tests++;
45989: #endif
45990:
45991: return(test_ret);
45992: }
45993:
45994:
45995: static int
45996: test_xmlXPathCmpNodes(void) {
45997: int test_ret = 0;
45998:
45999: #if defined(LIBXML_XPATH_ENABLED)
46000: int mem_base;
46001: int ret_val;
46002: xmlNodePtr node1; /* the first node */
46003: int n_node1;
46004: xmlNodePtr node2; /* the second node */
46005: int n_node2;
46006:
46007: for (n_node1 = 0;n_node1 < gen_nb_xmlNodePtr;n_node1++) {
46008: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
46009: mem_base = xmlMemBlocks();
46010: node1 = gen_xmlNodePtr(n_node1, 0);
46011: node2 = gen_xmlNodePtr(n_node2, 1);
46012:
46013: ret_val = xmlXPathCmpNodes(node1, node2);
46014: desret_int(ret_val);
46015: call_tests++;
46016: des_xmlNodePtr(n_node1, node1, 0);
46017: des_xmlNodePtr(n_node2, node2, 1);
46018: xmlResetLastError();
46019: if (mem_base != xmlMemBlocks()) {
46020: printf("Leak of %d blocks found in xmlXPathCmpNodes",
46021: xmlMemBlocks() - mem_base);
46022: test_ret++;
46023: printf(" %d", n_node1);
46024: printf(" %d", n_node2);
46025: printf("\n");
46026: }
46027: }
46028: }
46029: function_tests++;
46030: #endif
46031:
46032: return(test_ret);
46033: }
46034:
46035:
46036: static int
46037: test_xmlXPathCompile(void) {
46038: int test_ret = 0;
46039:
46040:
46041: /* missing type support */
46042: return(test_ret);
46043: }
46044:
46045: #ifdef LIBXML_XPATH_ENABLED
46046:
46047: #define gen_nb_xmlXPathCompExprPtr 1
46048: static xmlXPathCompExprPtr gen_xmlXPathCompExprPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
46049: return(NULL);
46050: }
46051: static void des_xmlXPathCompExprPtr(int no ATTRIBUTE_UNUSED, xmlXPathCompExprPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
46052: }
46053: #endif
46054:
46055: #ifdef LIBXML_XPATH_ENABLED
46056:
46057: #define gen_nb_xmlXPathContextPtr 1
46058: static xmlXPathContextPtr gen_xmlXPathContextPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
46059: return(NULL);
46060: }
46061: static void des_xmlXPathContextPtr(int no ATTRIBUTE_UNUSED, xmlXPathContextPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
46062: }
46063: #endif
46064:
46065:
46066: static int
46067: test_xmlXPathCompiledEval(void) {
46068: int test_ret = 0;
46069:
46070: #if defined(LIBXML_XPATH_ENABLED)
46071: int mem_base;
46072: xmlXPathObjectPtr ret_val;
46073: xmlXPathCompExprPtr comp; /* the compiled XPath expression */
46074: int n_comp;
46075: xmlXPathContextPtr ctx; /* the XPath context */
46076: int n_ctx;
46077:
46078: for (n_comp = 0;n_comp < gen_nb_xmlXPathCompExprPtr;n_comp++) {
46079: for (n_ctx = 0;n_ctx < gen_nb_xmlXPathContextPtr;n_ctx++) {
46080: mem_base = xmlMemBlocks();
46081: comp = gen_xmlXPathCompExprPtr(n_comp, 0);
46082: ctx = gen_xmlXPathContextPtr(n_ctx, 1);
46083:
46084: ret_val = xmlXPathCompiledEval(comp, ctx);
46085: desret_xmlXPathObjectPtr(ret_val);
46086: call_tests++;
46087: des_xmlXPathCompExprPtr(n_comp, comp, 0);
46088: des_xmlXPathContextPtr(n_ctx, ctx, 1);
46089: xmlResetLastError();
46090: if (mem_base != xmlMemBlocks()) {
46091: printf("Leak of %d blocks found in xmlXPathCompiledEval",
46092: xmlMemBlocks() - mem_base);
46093: test_ret++;
46094: printf(" %d", n_comp);
46095: printf(" %d", n_ctx);
46096: printf("\n");
46097: }
46098: }
46099: }
46100: function_tests++;
46101: #endif
46102:
46103: return(test_ret);
46104: }
46105:
46106:
46107: static int
46108: test_xmlXPathCompiledEvalToBoolean(void) {
46109: int test_ret = 0;
46110:
46111: #if defined(LIBXML_XPATH_ENABLED)
46112: int mem_base;
46113: int ret_val;
46114: xmlXPathCompExprPtr comp; /* the compiled XPath expression */
46115: int n_comp;
46116: xmlXPathContextPtr ctxt; /* the XPath context */
46117: int n_ctxt;
46118:
46119: for (n_comp = 0;n_comp < gen_nb_xmlXPathCompExprPtr;n_comp++) {
46120: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
46121: mem_base = xmlMemBlocks();
46122: comp = gen_xmlXPathCompExprPtr(n_comp, 0);
46123: ctxt = gen_xmlXPathContextPtr(n_ctxt, 1);
46124:
46125: ret_val = xmlXPathCompiledEvalToBoolean(comp, ctxt);
46126: desret_int(ret_val);
46127: call_tests++;
46128: des_xmlXPathCompExprPtr(n_comp, comp, 0);
46129: des_xmlXPathContextPtr(n_ctxt, ctxt, 1);
46130: xmlResetLastError();
46131: if (mem_base != xmlMemBlocks()) {
46132: printf("Leak of %d blocks found in xmlXPathCompiledEvalToBoolean",
46133: xmlMemBlocks() - mem_base);
46134: test_ret++;
46135: printf(" %d", n_comp);
46136: printf(" %d", n_ctxt);
46137: printf("\n");
46138: }
46139: }
46140: }
46141: function_tests++;
46142: #endif
46143:
46144: return(test_ret);
46145: }
46146:
46147:
46148: static int
46149: test_xmlXPathContextSetCache(void) {
46150: int test_ret = 0;
46151:
46152: #if defined(LIBXML_XPATH_ENABLED)
46153: int mem_base;
46154: int ret_val;
46155: xmlXPathContextPtr ctxt; /* the XPath context */
46156: int n_ctxt;
46157: int active; /* enables/disables (creates/frees) the cache */
46158: int n_active;
46159: int value; /* a value with semantics dependant on @options */
46160: int n_value;
46161: int options; /* options (currently only the value 0 is used) */
46162: int n_options;
46163:
46164: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
46165: for (n_active = 0;n_active < gen_nb_int;n_active++) {
46166: for (n_value = 0;n_value < gen_nb_int;n_value++) {
46167: for (n_options = 0;n_options < gen_nb_int;n_options++) {
46168: mem_base = xmlMemBlocks();
46169: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
46170: active = gen_int(n_active, 1);
46171: value = gen_int(n_value, 2);
46172: options = gen_int(n_options, 3);
46173:
46174: ret_val = xmlXPathContextSetCache(ctxt, active, value, options);
46175: desret_int(ret_val);
46176: call_tests++;
46177: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
46178: des_int(n_active, active, 1);
46179: des_int(n_value, value, 2);
46180: des_int(n_options, options, 3);
46181: xmlResetLastError();
46182: if (mem_base != xmlMemBlocks()) {
46183: printf("Leak of %d blocks found in xmlXPathContextSetCache",
46184: xmlMemBlocks() - mem_base);
46185: test_ret++;
46186: printf(" %d", n_ctxt);
46187: printf(" %d", n_active);
46188: printf(" %d", n_value);
46189: printf(" %d", n_options);
46190: printf("\n");
46191: }
46192: }
46193: }
46194: }
46195: }
46196: function_tests++;
46197: #endif
46198:
46199: return(test_ret);
46200: }
46201:
46202:
46203: static int
46204: test_xmlXPathConvertBoolean(void) {
46205: int test_ret = 0;
46206:
46207: #if defined(LIBXML_XPATH_ENABLED)
46208: int mem_base;
46209: xmlXPathObjectPtr ret_val;
46210: xmlXPathObjectPtr val; /* an XPath object */
46211: int n_val;
46212:
46213: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
46214: mem_base = xmlMemBlocks();
46215: val = gen_xmlXPathObjectPtr(n_val, 0);
46216:
46217: ret_val = xmlXPathConvertBoolean(val);
46218: val = NULL;
46219: desret_xmlXPathObjectPtr(ret_val);
46220: call_tests++;
46221: des_xmlXPathObjectPtr(n_val, val, 0);
46222: xmlResetLastError();
46223: if (mem_base != xmlMemBlocks()) {
46224: printf("Leak of %d blocks found in xmlXPathConvertBoolean",
46225: xmlMemBlocks() - mem_base);
46226: test_ret++;
46227: printf(" %d", n_val);
46228: printf("\n");
46229: }
46230: }
46231: function_tests++;
46232: #endif
46233:
46234: return(test_ret);
46235: }
46236:
46237:
46238: static int
46239: test_xmlXPathConvertNumber(void) {
46240: int test_ret = 0;
46241:
46242: #if defined(LIBXML_XPATH_ENABLED)
46243: int mem_base;
46244: xmlXPathObjectPtr ret_val;
46245: xmlXPathObjectPtr val; /* an XPath object */
46246: int n_val;
46247:
46248: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
46249: mem_base = xmlMemBlocks();
46250: val = gen_xmlXPathObjectPtr(n_val, 0);
46251:
46252: ret_val = xmlXPathConvertNumber(val);
46253: val = NULL;
46254: desret_xmlXPathObjectPtr(ret_val);
46255: call_tests++;
46256: des_xmlXPathObjectPtr(n_val, val, 0);
46257: xmlResetLastError();
46258: if (mem_base != xmlMemBlocks()) {
46259: printf("Leak of %d blocks found in xmlXPathConvertNumber",
46260: xmlMemBlocks() - mem_base);
46261: test_ret++;
46262: printf(" %d", n_val);
46263: printf("\n");
46264: }
46265: }
46266: function_tests++;
46267: #endif
46268:
46269: return(test_ret);
46270: }
46271:
46272:
46273: static int
46274: test_xmlXPathConvertString(void) {
46275: int test_ret = 0;
46276:
46277: #if defined(LIBXML_XPATH_ENABLED)
46278: int mem_base;
46279: xmlXPathObjectPtr ret_val;
46280: xmlXPathObjectPtr val; /* an XPath object */
46281: int n_val;
46282:
46283: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
46284: mem_base = xmlMemBlocks();
46285: val = gen_xmlXPathObjectPtr(n_val, 0);
46286:
46287: ret_val = xmlXPathConvertString(val);
46288: val = NULL;
46289: desret_xmlXPathObjectPtr(ret_val);
46290: call_tests++;
46291: des_xmlXPathObjectPtr(n_val, val, 0);
46292: xmlResetLastError();
46293: if (mem_base != xmlMemBlocks()) {
46294: printf("Leak of %d blocks found in xmlXPathConvertString",
46295: xmlMemBlocks() - mem_base);
46296: test_ret++;
46297: printf(" %d", n_val);
46298: printf("\n");
46299: }
46300: }
46301: function_tests++;
46302: #endif
46303:
46304: return(test_ret);
46305: }
46306:
46307:
46308: static int
46309: test_xmlXPathCtxtCompile(void) {
46310: int test_ret = 0;
46311:
46312:
46313: /* missing type support */
46314: return(test_ret);
46315: }
46316:
46317:
46318: static int
46319: test_xmlXPathEval(void) {
46320: int test_ret = 0;
46321:
46322: #if defined(LIBXML_XPATH_ENABLED)
46323: int mem_base;
46324: xmlXPathObjectPtr ret_val;
46325: xmlChar * str; /* the XPath expression */
46326: int n_str;
46327: xmlXPathContextPtr ctx; /* the XPath context */
46328: int n_ctx;
46329:
46330: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
46331: for (n_ctx = 0;n_ctx < gen_nb_xmlXPathContextPtr;n_ctx++) {
46332: mem_base = xmlMemBlocks();
46333: str = gen_const_xmlChar_ptr(n_str, 0);
46334: ctx = gen_xmlXPathContextPtr(n_ctx, 1);
46335:
46336: ret_val = xmlXPathEval((const xmlChar *)str, ctx);
46337: desret_xmlXPathObjectPtr(ret_val);
46338: call_tests++;
46339: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
46340: des_xmlXPathContextPtr(n_ctx, ctx, 1);
46341: xmlResetLastError();
46342: if (mem_base != xmlMemBlocks()) {
46343: printf("Leak of %d blocks found in xmlXPathEval",
46344: xmlMemBlocks() - mem_base);
46345: test_ret++;
46346: printf(" %d", n_str);
46347: printf(" %d", n_ctx);
46348: printf("\n");
46349: }
46350: }
46351: }
46352: function_tests++;
46353: #endif
46354:
46355: return(test_ret);
46356: }
46357:
46358:
46359: static int
46360: test_xmlXPathEvalExpression(void) {
46361: int test_ret = 0;
46362:
46363: #if defined(LIBXML_XPATH_ENABLED)
46364: int mem_base;
46365: xmlXPathObjectPtr ret_val;
46366: xmlChar * str; /* the XPath expression */
46367: int n_str;
46368: xmlXPathContextPtr ctxt; /* the XPath context */
46369: int n_ctxt;
46370:
46371: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
46372: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
46373: mem_base = xmlMemBlocks();
46374: str = gen_const_xmlChar_ptr(n_str, 0);
46375: ctxt = gen_xmlXPathContextPtr(n_ctxt, 1);
46376:
46377: ret_val = xmlXPathEvalExpression((const xmlChar *)str, ctxt);
46378: desret_xmlXPathObjectPtr(ret_val);
46379: call_tests++;
46380: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
46381: des_xmlXPathContextPtr(n_ctxt, ctxt, 1);
46382: xmlResetLastError();
46383: if (mem_base != xmlMemBlocks()) {
46384: printf("Leak of %d blocks found in xmlXPathEvalExpression",
46385: xmlMemBlocks() - mem_base);
46386: test_ret++;
46387: printf(" %d", n_str);
46388: printf(" %d", n_ctxt);
46389: printf("\n");
46390: }
46391: }
46392: }
46393: function_tests++;
46394: #endif
46395:
46396: return(test_ret);
46397: }
46398:
46399:
46400: static int
46401: test_xmlXPathEvalPredicate(void) {
46402: int test_ret = 0;
46403:
46404: #if defined(LIBXML_XPATH_ENABLED)
46405: int mem_base;
46406: int ret_val;
46407: xmlXPathContextPtr ctxt; /* the XPath context */
46408: int n_ctxt;
46409: xmlXPathObjectPtr res; /* the Predicate Expression evaluation result */
46410: int n_res;
46411:
46412: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
46413: for (n_res = 0;n_res < gen_nb_xmlXPathObjectPtr;n_res++) {
46414: mem_base = xmlMemBlocks();
46415: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
46416: res = gen_xmlXPathObjectPtr(n_res, 1);
46417:
46418: ret_val = xmlXPathEvalPredicate(ctxt, res);
46419: desret_int(ret_val);
46420: call_tests++;
46421: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
46422: des_xmlXPathObjectPtr(n_res, res, 1);
46423: xmlResetLastError();
46424: if (mem_base != xmlMemBlocks()) {
46425: printf("Leak of %d blocks found in xmlXPathEvalPredicate",
46426: xmlMemBlocks() - mem_base);
46427: test_ret++;
46428: printf(" %d", n_ctxt);
46429: printf(" %d", n_res);
46430: printf("\n");
46431: }
46432: }
46433: }
46434: function_tests++;
46435: #endif
46436:
46437: return(test_ret);
46438: }
46439:
46440:
46441: static int
46442: test_xmlXPathInit(void) {
46443: int test_ret = 0;
46444:
46445: #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
46446: int mem_base;
46447:
46448: mem_base = xmlMemBlocks();
46449:
46450: xmlXPathInit();
46451: call_tests++;
46452: xmlResetLastError();
46453: if (mem_base != xmlMemBlocks()) {
46454: printf("Leak of %d blocks found in xmlXPathInit",
46455: xmlMemBlocks() - mem_base);
46456: test_ret++;
46457: printf("\n");
46458: }
46459: function_tests++;
46460: #endif
46461:
46462: return(test_ret);
46463: }
46464:
46465:
46466: static int
46467: test_xmlXPathIsInf(void) {
46468: int test_ret = 0;
46469:
46470: #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
46471: int mem_base;
46472: int ret_val;
46473: double val; /* a double value */
46474: int n_val;
46475:
46476: for (n_val = 0;n_val < gen_nb_double;n_val++) {
46477: mem_base = xmlMemBlocks();
46478: val = gen_double(n_val, 0);
46479:
46480: ret_val = xmlXPathIsInf(val);
46481: desret_int(ret_val);
46482: call_tests++;
46483: des_double(n_val, val, 0);
46484: xmlResetLastError();
46485: if (mem_base != xmlMemBlocks()) {
46486: printf("Leak of %d blocks found in xmlXPathIsInf",
46487: xmlMemBlocks() - mem_base);
46488: test_ret++;
46489: printf(" %d", n_val);
46490: printf("\n");
46491: }
46492: }
46493: function_tests++;
46494: #endif
46495:
46496: return(test_ret);
46497: }
46498:
46499:
46500: static int
46501: test_xmlXPathIsNaN(void) {
46502: int test_ret = 0;
46503:
46504: #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
46505: int mem_base;
46506: int ret_val;
46507: double val; /* a double value */
46508: int n_val;
46509:
46510: for (n_val = 0;n_val < gen_nb_double;n_val++) {
46511: mem_base = xmlMemBlocks();
46512: val = gen_double(n_val, 0);
46513:
46514: ret_val = xmlXPathIsNaN(val);
46515: desret_int(ret_val);
46516: call_tests++;
46517: des_double(n_val, val, 0);
46518: xmlResetLastError();
46519: if (mem_base != xmlMemBlocks()) {
46520: printf("Leak of %d blocks found in xmlXPathIsNaN",
46521: xmlMemBlocks() - mem_base);
46522: test_ret++;
46523: printf(" %d", n_val);
46524: printf("\n");
46525: }
46526: }
46527: function_tests++;
46528: #endif
46529:
46530: return(test_ret);
46531: }
46532:
46533:
46534: static int
46535: test_xmlXPathNewContext(void) {
46536: int test_ret = 0;
46537:
46538:
46539: /* missing type support */
46540: return(test_ret);
46541: }
46542:
46543:
46544: static int
46545: test_xmlXPathNodeSetCreate(void) {
46546: int test_ret = 0;
46547:
46548: #if defined(LIBXML_XPATH_ENABLED)
46549: int mem_base;
46550: xmlNodeSetPtr ret_val;
46551: xmlNodePtr val; /* an initial xmlNodePtr, or NULL */
46552: int n_val;
46553:
46554: for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
46555: mem_base = xmlMemBlocks();
46556: val = gen_xmlNodePtr(n_val, 0);
46557:
46558: ret_val = xmlXPathNodeSetCreate(val);
46559: desret_xmlNodeSetPtr(ret_val);
46560: call_tests++;
46561: des_xmlNodePtr(n_val, val, 0);
46562: xmlResetLastError();
46563: if (mem_base != xmlMemBlocks()) {
46564: printf("Leak of %d blocks found in xmlXPathNodeSetCreate",
46565: xmlMemBlocks() - mem_base);
46566: test_ret++;
46567: printf(" %d", n_val);
46568: printf("\n");
46569: }
46570: }
46571: function_tests++;
46572: #endif
46573:
46574: return(test_ret);
46575: }
46576:
46577:
46578: static int
46579: test_xmlXPathObjectCopy(void) {
46580: int test_ret = 0;
46581:
46582: #if defined(LIBXML_XPATH_ENABLED)
46583: int mem_base;
46584: xmlXPathObjectPtr ret_val;
46585: xmlXPathObjectPtr val; /* the original object */
46586: int n_val;
46587:
46588: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
46589: mem_base = xmlMemBlocks();
46590: val = gen_xmlXPathObjectPtr(n_val, 0);
46591:
46592: ret_val = xmlXPathObjectCopy(val);
46593: desret_xmlXPathObjectPtr(ret_val);
46594: call_tests++;
46595: des_xmlXPathObjectPtr(n_val, val, 0);
46596: xmlResetLastError();
46597: if (mem_base != xmlMemBlocks()) {
46598: printf("Leak of %d blocks found in xmlXPathObjectCopy",
46599: xmlMemBlocks() - mem_base);
46600: test_ret++;
46601: printf(" %d", n_val);
46602: printf("\n");
46603: }
46604: }
46605: function_tests++;
46606: #endif
46607:
46608: return(test_ret);
46609: }
46610:
46611:
46612: static int
46613: test_xmlXPathOrderDocElems(void) {
46614: int test_ret = 0;
46615:
46616: #if defined(LIBXML_XPATH_ENABLED)
46617: int mem_base;
46618: long ret_val;
46619: xmlDocPtr doc; /* an input document */
46620: int n_doc;
46621:
46622: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
46623: mem_base = xmlMemBlocks();
46624: doc = gen_xmlDocPtr(n_doc, 0);
46625:
46626: ret_val = xmlXPathOrderDocElems(doc);
46627: desret_long(ret_val);
46628: call_tests++;
46629: des_xmlDocPtr(n_doc, doc, 0);
46630: xmlResetLastError();
46631: if (mem_base != xmlMemBlocks()) {
46632: printf("Leak of %d blocks found in xmlXPathOrderDocElems",
46633: xmlMemBlocks() - mem_base);
46634: test_ret++;
46635: printf(" %d", n_doc);
46636: printf("\n");
46637: }
46638: }
46639: function_tests++;
46640: #endif
46641:
46642: return(test_ret);
46643: }
46644:
46645: static int
46646: test_xpath(void) {
46647: int test_ret = 0;
46648:
46649: if (quiet == 0) printf("Testing xpath : 30 of 38 functions ...\n");
46650: test_ret += test_xmlXPathCastBooleanToNumber();
46651: test_ret += test_xmlXPathCastBooleanToString();
46652: test_ret += test_xmlXPathCastNodeSetToBoolean();
46653: test_ret += test_xmlXPathCastNodeSetToNumber();
46654: test_ret += test_xmlXPathCastNodeSetToString();
46655: test_ret += test_xmlXPathCastNodeToNumber();
46656: test_ret += test_xmlXPathCastNodeToString();
46657: test_ret += test_xmlXPathCastNumberToBoolean();
46658: test_ret += test_xmlXPathCastNumberToString();
46659: test_ret += test_xmlXPathCastStringToBoolean();
46660: test_ret += test_xmlXPathCastStringToNumber();
46661: test_ret += test_xmlXPathCastToBoolean();
46662: test_ret += test_xmlXPathCastToNumber();
46663: test_ret += test_xmlXPathCastToString();
46664: test_ret += test_xmlXPathCmpNodes();
46665: test_ret += test_xmlXPathCompile();
46666: test_ret += test_xmlXPathCompiledEval();
46667: test_ret += test_xmlXPathCompiledEvalToBoolean();
46668: test_ret += test_xmlXPathContextSetCache();
46669: test_ret += test_xmlXPathConvertBoolean();
46670: test_ret += test_xmlXPathConvertNumber();
46671: test_ret += test_xmlXPathConvertString();
46672: test_ret += test_xmlXPathCtxtCompile();
46673: test_ret += test_xmlXPathEval();
46674: test_ret += test_xmlXPathEvalExpression();
46675: test_ret += test_xmlXPathEvalPredicate();
46676: test_ret += test_xmlXPathInit();
46677: test_ret += test_xmlXPathIsInf();
46678: test_ret += test_xmlXPathIsNaN();
46679: test_ret += test_xmlXPathNewContext();
46680: test_ret += test_xmlXPathNodeSetCreate();
46681: test_ret += test_xmlXPathObjectCopy();
46682: test_ret += test_xmlXPathOrderDocElems();
46683:
46684: if (test_ret != 0)
46685: printf("Module xpath: %d errors\n", test_ret);
46686: return(test_ret);
46687: }
46688: #ifdef LIBXML_XPATH_ENABLED
46689:
46690: #define gen_nb_xmlXPathParserContextPtr 1
46691: static xmlXPathParserContextPtr gen_xmlXPathParserContextPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
46692: return(NULL);
46693: }
46694: static void des_xmlXPathParserContextPtr(int no ATTRIBUTE_UNUSED, xmlXPathParserContextPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
46695: }
46696: #endif
46697:
46698:
46699: static int
46700: test_valuePop(void) {
46701: int test_ret = 0;
46702:
46703: #if defined(LIBXML_XPATH_ENABLED)
46704: int mem_base;
46705: xmlXPathObjectPtr ret_val;
46706: xmlXPathParserContextPtr ctxt; /* an XPath evaluation context */
46707: int n_ctxt;
46708:
46709: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
46710: mem_base = xmlMemBlocks();
46711: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
46712:
46713: ret_val = valuePop(ctxt);
46714: desret_xmlXPathObjectPtr(ret_val);
46715: call_tests++;
46716: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
46717: xmlResetLastError();
46718: if (mem_base != xmlMemBlocks()) {
46719: printf("Leak of %d blocks found in valuePop",
46720: xmlMemBlocks() - mem_base);
46721: test_ret++;
46722: printf(" %d", n_ctxt);
46723: printf("\n");
46724: }
46725: }
46726: function_tests++;
46727: #endif
46728:
46729: return(test_ret);
46730: }
46731:
46732:
46733: static int
46734: test_valuePush(void) {
46735: int test_ret = 0;
46736:
46737: #if defined(LIBXML_XPATH_ENABLED)
46738: int mem_base;
46739: int ret_val;
46740: xmlXPathParserContextPtr ctxt; /* an XPath evaluation context */
46741: int n_ctxt;
46742: xmlXPathObjectPtr value; /* the XPath object */
46743: int n_value;
46744:
46745: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
46746: for (n_value = 0;n_value < gen_nb_xmlXPathObjectPtr;n_value++) {
46747: mem_base = xmlMemBlocks();
46748: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
46749: value = gen_xmlXPathObjectPtr(n_value, 1);
46750:
46751: ret_val = valuePush(ctxt, value);
46752: desret_int(ret_val);
46753: call_tests++;
46754: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
46755: des_xmlXPathObjectPtr(n_value, value, 1);
46756: xmlResetLastError();
46757: if (mem_base != xmlMemBlocks()) {
46758: printf("Leak of %d blocks found in valuePush",
46759: xmlMemBlocks() - mem_base);
46760: test_ret++;
46761: printf(" %d", n_ctxt);
46762: printf(" %d", n_value);
46763: printf("\n");
46764: }
46765: }
46766: }
46767: function_tests++;
46768: #endif
46769:
46770: return(test_ret);
46771: }
46772:
46773:
46774: static int
46775: test_xmlXPathAddValues(void) {
46776: int test_ret = 0;
46777:
46778: #if defined(LIBXML_XPATH_ENABLED)
46779: int mem_base;
46780: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
46781: int n_ctxt;
46782:
46783: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
46784: mem_base = xmlMemBlocks();
46785: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
46786:
46787: xmlXPathAddValues(ctxt);
46788: call_tests++;
46789: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
46790: xmlResetLastError();
46791: if (mem_base != xmlMemBlocks()) {
46792: printf("Leak of %d blocks found in xmlXPathAddValues",
46793: xmlMemBlocks() - mem_base);
46794: test_ret++;
46795: printf(" %d", n_ctxt);
46796: printf("\n");
46797: }
46798: }
46799: function_tests++;
46800: #endif
46801:
46802: return(test_ret);
46803: }
46804:
46805:
46806: static int
46807: test_xmlXPathBooleanFunction(void) {
46808: int test_ret = 0;
46809:
46810: #if defined(LIBXML_XPATH_ENABLED)
46811: int mem_base;
46812: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
46813: int n_ctxt;
46814: int nargs; /* the number of arguments */
46815: int n_nargs;
46816:
46817: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
46818: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
46819: mem_base = xmlMemBlocks();
46820: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
46821: nargs = gen_int(n_nargs, 1);
46822:
46823: xmlXPathBooleanFunction(ctxt, nargs);
46824: call_tests++;
46825: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
46826: des_int(n_nargs, nargs, 1);
46827: xmlResetLastError();
46828: if (mem_base != xmlMemBlocks()) {
46829: printf("Leak of %d blocks found in xmlXPathBooleanFunction",
46830: xmlMemBlocks() - mem_base);
46831: test_ret++;
46832: printf(" %d", n_ctxt);
46833: printf(" %d", n_nargs);
46834: printf("\n");
46835: }
46836: }
46837: }
46838: function_tests++;
46839: #endif
46840:
46841: return(test_ret);
46842: }
46843:
46844:
46845: static int
46846: test_xmlXPathCeilingFunction(void) {
46847: int test_ret = 0;
46848:
46849: #if defined(LIBXML_XPATH_ENABLED)
46850: int mem_base;
46851: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
46852: int n_ctxt;
46853: int nargs; /* the number of arguments */
46854: int n_nargs;
46855:
46856: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
46857: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
46858: mem_base = xmlMemBlocks();
46859: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
46860: nargs = gen_int(n_nargs, 1);
46861:
46862: xmlXPathCeilingFunction(ctxt, nargs);
46863: call_tests++;
46864: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
46865: des_int(n_nargs, nargs, 1);
46866: xmlResetLastError();
46867: if (mem_base != xmlMemBlocks()) {
46868: printf("Leak of %d blocks found in xmlXPathCeilingFunction",
46869: xmlMemBlocks() - mem_base);
46870: test_ret++;
46871: printf(" %d", n_ctxt);
46872: printf(" %d", n_nargs);
46873: printf("\n");
46874: }
46875: }
46876: }
46877: function_tests++;
46878: #endif
46879:
46880: return(test_ret);
46881: }
46882:
46883:
46884: static int
46885: test_xmlXPathCompareValues(void) {
46886: int test_ret = 0;
46887:
46888: #if defined(LIBXML_XPATH_ENABLED)
46889: int mem_base;
46890: int ret_val;
46891: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
46892: int n_ctxt;
46893: int inf; /* less than (1) or greater than (0) */
46894: int n_inf;
46895: int strict; /* is the comparison strict */
46896: int n_strict;
46897:
46898: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
46899: for (n_inf = 0;n_inf < gen_nb_int;n_inf++) {
46900: for (n_strict = 0;n_strict < gen_nb_int;n_strict++) {
46901: mem_base = xmlMemBlocks();
46902: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
46903: inf = gen_int(n_inf, 1);
46904: strict = gen_int(n_strict, 2);
46905:
46906: ret_val = xmlXPathCompareValues(ctxt, inf, strict);
46907: desret_int(ret_val);
46908: call_tests++;
46909: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
46910: des_int(n_inf, inf, 1);
46911: des_int(n_strict, strict, 2);
46912: xmlResetLastError();
46913: if (mem_base != xmlMemBlocks()) {
46914: printf("Leak of %d blocks found in xmlXPathCompareValues",
46915: xmlMemBlocks() - mem_base);
46916: test_ret++;
46917: printf(" %d", n_ctxt);
46918: printf(" %d", n_inf);
46919: printf(" %d", n_strict);
46920: printf("\n");
46921: }
46922: }
46923: }
46924: }
46925: function_tests++;
46926: #endif
46927:
46928: return(test_ret);
46929: }
46930:
46931:
46932: static int
46933: test_xmlXPathConcatFunction(void) {
46934: int test_ret = 0;
46935:
46936: #if defined(LIBXML_XPATH_ENABLED)
46937: int mem_base;
46938: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
46939: int n_ctxt;
46940: int nargs; /* the number of arguments */
46941: int n_nargs;
46942:
46943: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
46944: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
46945: mem_base = xmlMemBlocks();
46946: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
46947: nargs = gen_int(n_nargs, 1);
46948:
46949: xmlXPathConcatFunction(ctxt, nargs);
46950: call_tests++;
46951: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
46952: des_int(n_nargs, nargs, 1);
46953: xmlResetLastError();
46954: if (mem_base != xmlMemBlocks()) {
46955: printf("Leak of %d blocks found in xmlXPathConcatFunction",
46956: xmlMemBlocks() - mem_base);
46957: test_ret++;
46958: printf(" %d", n_ctxt);
46959: printf(" %d", n_nargs);
46960: printf("\n");
46961: }
46962: }
46963: }
46964: function_tests++;
46965: #endif
46966:
46967: return(test_ret);
46968: }
46969:
46970:
46971: static int
46972: test_xmlXPathContainsFunction(void) {
46973: int test_ret = 0;
46974:
46975: #if defined(LIBXML_XPATH_ENABLED)
46976: int mem_base;
46977: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
46978: int n_ctxt;
46979: int nargs; /* the number of arguments */
46980: int n_nargs;
46981:
46982: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
46983: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
46984: mem_base = xmlMemBlocks();
46985: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
46986: nargs = gen_int(n_nargs, 1);
46987:
46988: xmlXPathContainsFunction(ctxt, nargs);
46989: call_tests++;
46990: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
46991: des_int(n_nargs, nargs, 1);
46992: xmlResetLastError();
46993: if (mem_base != xmlMemBlocks()) {
46994: printf("Leak of %d blocks found in xmlXPathContainsFunction",
46995: xmlMemBlocks() - mem_base);
46996: test_ret++;
46997: printf(" %d", n_ctxt);
46998: printf(" %d", n_nargs);
46999: printf("\n");
47000: }
47001: }
47002: }
47003: function_tests++;
47004: #endif
47005:
47006: return(test_ret);
47007: }
47008:
47009:
47010: static int
47011: test_xmlXPathCountFunction(void) {
47012: int test_ret = 0;
47013:
47014: #if defined(LIBXML_XPATH_ENABLED)
47015: int mem_base;
47016: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47017: int n_ctxt;
47018: int nargs; /* the number of arguments */
47019: int n_nargs;
47020:
47021: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47022: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
47023: mem_base = xmlMemBlocks();
47024: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47025: nargs = gen_int(n_nargs, 1);
47026:
47027: xmlXPathCountFunction(ctxt, nargs);
47028: call_tests++;
47029: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47030: des_int(n_nargs, nargs, 1);
47031: xmlResetLastError();
47032: if (mem_base != xmlMemBlocks()) {
47033: printf("Leak of %d blocks found in xmlXPathCountFunction",
47034: xmlMemBlocks() - mem_base);
47035: test_ret++;
47036: printf(" %d", n_ctxt);
47037: printf(" %d", n_nargs);
47038: printf("\n");
47039: }
47040: }
47041: }
47042: function_tests++;
47043: #endif
47044:
47045: return(test_ret);
47046: }
47047:
47048:
47049: static int
47050: test_xmlXPathDebugDumpCompExpr(void) {
47051: int test_ret = 0;
47052:
47053: #if defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_DEBUG_ENABLED)
47054: int mem_base;
47055: FILE * output; /* the FILE * for the output */
47056: int n_output;
47057: xmlXPathCompExprPtr comp; /* the precompiled XPath expression */
47058: int n_comp;
47059: int depth; /* the indentation level. */
47060: int n_depth;
47061:
47062: for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
47063: for (n_comp = 0;n_comp < gen_nb_xmlXPathCompExprPtr;n_comp++) {
47064: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
47065: mem_base = xmlMemBlocks();
47066: output = gen_FILE_ptr(n_output, 0);
47067: comp = gen_xmlXPathCompExprPtr(n_comp, 1);
47068: depth = gen_int(n_depth, 2);
47069:
47070: xmlXPathDebugDumpCompExpr(output, comp, depth);
47071: call_tests++;
47072: des_FILE_ptr(n_output, output, 0);
47073: des_xmlXPathCompExprPtr(n_comp, comp, 1);
47074: des_int(n_depth, depth, 2);
47075: xmlResetLastError();
47076: if (mem_base != xmlMemBlocks()) {
47077: printf("Leak of %d blocks found in xmlXPathDebugDumpCompExpr",
47078: xmlMemBlocks() - mem_base);
47079: test_ret++;
47080: printf(" %d", n_output);
47081: printf(" %d", n_comp);
47082: printf(" %d", n_depth);
47083: printf("\n");
47084: }
47085: }
47086: }
47087: }
47088: function_tests++;
47089: #endif
47090:
47091: return(test_ret);
47092: }
47093:
47094:
47095: static int
47096: test_xmlXPathDebugDumpObject(void) {
47097: int test_ret = 0;
47098:
47099: #if defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_DEBUG_ENABLED)
47100: int mem_base;
47101: FILE * output; /* the FILE * to dump the output */
47102: int n_output;
47103: xmlXPathObjectPtr cur; /* the object to inspect */
47104: int n_cur;
47105: int depth; /* indentation level */
47106: int n_depth;
47107:
47108: for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
47109: for (n_cur = 0;n_cur < gen_nb_xmlXPathObjectPtr;n_cur++) {
47110: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
47111: mem_base = xmlMemBlocks();
47112: output = gen_FILE_ptr(n_output, 0);
47113: cur = gen_xmlXPathObjectPtr(n_cur, 1);
47114: depth = gen_int(n_depth, 2);
47115:
47116: xmlXPathDebugDumpObject(output, cur, depth);
47117: call_tests++;
47118: des_FILE_ptr(n_output, output, 0);
47119: des_xmlXPathObjectPtr(n_cur, cur, 1);
47120: des_int(n_depth, depth, 2);
47121: xmlResetLastError();
47122: if (mem_base != xmlMemBlocks()) {
47123: printf("Leak of %d blocks found in xmlXPathDebugDumpObject",
47124: xmlMemBlocks() - mem_base);
47125: test_ret++;
47126: printf(" %d", n_output);
47127: printf(" %d", n_cur);
47128: printf(" %d", n_depth);
47129: printf("\n");
47130: }
47131: }
47132: }
47133: }
47134: function_tests++;
47135: #endif
47136:
47137: return(test_ret);
47138: }
47139:
47140:
47141: static int
47142: test_xmlXPathDifference(void) {
47143: int test_ret = 0;
47144:
47145: #if defined(LIBXML_XPATH_ENABLED)
47146: int mem_base;
47147: xmlNodeSetPtr ret_val;
47148: xmlNodeSetPtr nodes1; /* a node-set */
47149: int n_nodes1;
47150: xmlNodeSetPtr nodes2; /* a node-set */
47151: int n_nodes2;
47152:
47153: for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
47154: for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
47155: mem_base = xmlMemBlocks();
47156: nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
47157: nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
47158:
47159: ret_val = xmlXPathDifference(nodes1, nodes2);
47160: desret_xmlNodeSetPtr(ret_val);
47161: call_tests++;
47162: des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
47163: des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
47164: xmlResetLastError();
47165: if (mem_base != xmlMemBlocks()) {
47166: printf("Leak of %d blocks found in xmlXPathDifference",
47167: xmlMemBlocks() - mem_base);
47168: test_ret++;
47169: printf(" %d", n_nodes1);
47170: printf(" %d", n_nodes2);
47171: printf("\n");
47172: }
47173: }
47174: }
47175: function_tests++;
47176: #endif
47177:
47178: return(test_ret);
47179: }
47180:
47181:
47182: static int
47183: test_xmlXPathDistinct(void) {
47184: int test_ret = 0;
47185:
47186: #if defined(LIBXML_XPATH_ENABLED)
47187: int mem_base;
47188: xmlNodeSetPtr ret_val;
47189: xmlNodeSetPtr nodes; /* a node-set */
47190: int n_nodes;
47191:
47192: for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
47193: mem_base = xmlMemBlocks();
47194: nodes = gen_xmlNodeSetPtr(n_nodes, 0);
47195:
47196: ret_val = xmlXPathDistinct(nodes);
47197: desret_xmlNodeSetPtr(ret_val);
47198: call_tests++;
47199: des_xmlNodeSetPtr(n_nodes, nodes, 0);
47200: xmlResetLastError();
47201: if (mem_base != xmlMemBlocks()) {
47202: printf("Leak of %d blocks found in xmlXPathDistinct",
47203: xmlMemBlocks() - mem_base);
47204: test_ret++;
47205: printf(" %d", n_nodes);
47206: printf("\n");
47207: }
47208: }
47209: function_tests++;
47210: #endif
47211:
47212: return(test_ret);
47213: }
47214:
47215:
47216: static int
47217: test_xmlXPathDistinctSorted(void) {
47218: int test_ret = 0;
47219:
47220: #if defined(LIBXML_XPATH_ENABLED)
47221: int mem_base;
47222: xmlNodeSetPtr ret_val;
47223: xmlNodeSetPtr nodes; /* a node-set, sorted by document order */
47224: int n_nodes;
47225:
47226: for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
47227: mem_base = xmlMemBlocks();
47228: nodes = gen_xmlNodeSetPtr(n_nodes, 0);
47229:
47230: ret_val = xmlXPathDistinctSorted(nodes);
47231: desret_xmlNodeSetPtr(ret_val);
47232: call_tests++;
47233: des_xmlNodeSetPtr(n_nodes, nodes, 0);
47234: xmlResetLastError();
47235: if (mem_base != xmlMemBlocks()) {
47236: printf("Leak of %d blocks found in xmlXPathDistinctSorted",
47237: xmlMemBlocks() - mem_base);
47238: test_ret++;
47239: printf(" %d", n_nodes);
47240: printf("\n");
47241: }
47242: }
47243: function_tests++;
47244: #endif
47245:
47246: return(test_ret);
47247: }
47248:
47249:
47250: static int
47251: test_xmlXPathDivValues(void) {
47252: int test_ret = 0;
47253:
47254: #if defined(LIBXML_XPATH_ENABLED)
47255: int mem_base;
47256: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47257: int n_ctxt;
47258:
47259: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47260: mem_base = xmlMemBlocks();
47261: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47262:
47263: xmlXPathDivValues(ctxt);
47264: call_tests++;
47265: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47266: xmlResetLastError();
47267: if (mem_base != xmlMemBlocks()) {
47268: printf("Leak of %d blocks found in xmlXPathDivValues",
47269: xmlMemBlocks() - mem_base);
47270: test_ret++;
47271: printf(" %d", n_ctxt);
47272: printf("\n");
47273: }
47274: }
47275: function_tests++;
47276: #endif
47277:
47278: return(test_ret);
47279: }
47280:
47281:
47282: static int
47283: test_xmlXPathEqualValues(void) {
47284: int test_ret = 0;
47285:
47286: #if defined(LIBXML_XPATH_ENABLED)
47287: int mem_base;
47288: int ret_val;
47289: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47290: int n_ctxt;
47291:
47292: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47293: mem_base = xmlMemBlocks();
47294: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47295:
47296: ret_val = xmlXPathEqualValues(ctxt);
47297: desret_int(ret_val);
47298: call_tests++;
47299: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47300: xmlResetLastError();
47301: if (mem_base != xmlMemBlocks()) {
47302: printf("Leak of %d blocks found in xmlXPathEqualValues",
47303: xmlMemBlocks() - mem_base);
47304: test_ret++;
47305: printf(" %d", n_ctxt);
47306: printf("\n");
47307: }
47308: }
47309: function_tests++;
47310: #endif
47311:
47312: return(test_ret);
47313: }
47314:
47315:
47316: static int
47317: test_xmlXPathErr(void) {
47318: int test_ret = 0;
47319:
47320: #if defined(LIBXML_XPATH_ENABLED)
47321: int mem_base;
47322: xmlXPathParserContextPtr ctxt; /* a XPath parser context */
47323: int n_ctxt;
47324: int error; /* the error code */
47325: int n_error;
47326:
47327: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47328: for (n_error = 0;n_error < gen_nb_int;n_error++) {
47329: mem_base = xmlMemBlocks();
47330: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47331: error = gen_int(n_error, 1);
47332:
47333: xmlXPathErr(ctxt, error);
47334: call_tests++;
47335: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47336: des_int(n_error, error, 1);
47337: xmlResetLastError();
47338: if (mem_base != xmlMemBlocks()) {
47339: printf("Leak of %d blocks found in xmlXPathErr",
47340: xmlMemBlocks() - mem_base);
47341: test_ret++;
47342: printf(" %d", n_ctxt);
47343: printf(" %d", n_error);
47344: printf("\n");
47345: }
47346: }
47347: }
47348: function_tests++;
47349: #endif
47350:
47351: return(test_ret);
47352: }
47353:
47354:
47355: static int
47356: test_xmlXPathEvalExpr(void) {
47357: int test_ret = 0;
47358:
47359: #if defined(LIBXML_XPATH_ENABLED)
47360: int mem_base;
47361: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47362: int n_ctxt;
47363:
47364: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47365: mem_base = xmlMemBlocks();
47366: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47367:
47368: xmlXPathEvalExpr(ctxt);
47369: call_tests++;
47370: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47371: xmlResetLastError();
47372: if (mem_base != xmlMemBlocks()) {
47373: printf("Leak of %d blocks found in xmlXPathEvalExpr",
47374: xmlMemBlocks() - mem_base);
47375: test_ret++;
47376: printf(" %d", n_ctxt);
47377: printf("\n");
47378: }
47379: }
47380: function_tests++;
47381: #endif
47382:
47383: return(test_ret);
47384: }
47385:
47386:
47387: static int
47388: test_xmlXPathEvaluatePredicateResult(void) {
47389: int test_ret = 0;
47390:
47391: #if defined(LIBXML_XPATH_ENABLED)
47392: int mem_base;
47393: int ret_val;
47394: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47395: int n_ctxt;
47396: xmlXPathObjectPtr res; /* the Predicate Expression evaluation result */
47397: int n_res;
47398:
47399: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47400: for (n_res = 0;n_res < gen_nb_xmlXPathObjectPtr;n_res++) {
47401: mem_base = xmlMemBlocks();
47402: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47403: res = gen_xmlXPathObjectPtr(n_res, 1);
47404:
47405: ret_val = xmlXPathEvaluatePredicateResult(ctxt, res);
47406: desret_int(ret_val);
47407: call_tests++;
47408: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47409: des_xmlXPathObjectPtr(n_res, res, 1);
47410: xmlResetLastError();
47411: if (mem_base != xmlMemBlocks()) {
47412: printf("Leak of %d blocks found in xmlXPathEvaluatePredicateResult",
47413: xmlMemBlocks() - mem_base);
47414: test_ret++;
47415: printf(" %d", n_ctxt);
47416: printf(" %d", n_res);
47417: printf("\n");
47418: }
47419: }
47420: }
47421: function_tests++;
47422: #endif
47423:
47424: return(test_ret);
47425: }
47426:
47427:
47428: static int
47429: test_xmlXPathFalseFunction(void) {
47430: int test_ret = 0;
47431:
47432: #if defined(LIBXML_XPATH_ENABLED)
47433: int mem_base;
47434: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47435: int n_ctxt;
47436: int nargs; /* the number of arguments */
47437: int n_nargs;
47438:
47439: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47440: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
47441: mem_base = xmlMemBlocks();
47442: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47443: nargs = gen_int(n_nargs, 1);
47444:
47445: xmlXPathFalseFunction(ctxt, nargs);
47446: call_tests++;
47447: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47448: des_int(n_nargs, nargs, 1);
47449: xmlResetLastError();
47450: if (mem_base != xmlMemBlocks()) {
47451: printf("Leak of %d blocks found in xmlXPathFalseFunction",
47452: xmlMemBlocks() - mem_base);
47453: test_ret++;
47454: printf(" %d", n_ctxt);
47455: printf(" %d", n_nargs);
47456: printf("\n");
47457: }
47458: }
47459: }
47460: function_tests++;
47461: #endif
47462:
47463: return(test_ret);
47464: }
47465:
47466:
47467: static int
47468: test_xmlXPathFloorFunction(void) {
47469: int test_ret = 0;
47470:
47471: #if defined(LIBXML_XPATH_ENABLED)
47472: int mem_base;
47473: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47474: int n_ctxt;
47475: int nargs; /* the number of arguments */
47476: int n_nargs;
47477:
47478: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47479: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
47480: mem_base = xmlMemBlocks();
47481: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47482: nargs = gen_int(n_nargs, 1);
47483:
47484: xmlXPathFloorFunction(ctxt, nargs);
47485: call_tests++;
47486: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47487: des_int(n_nargs, nargs, 1);
47488: xmlResetLastError();
47489: if (mem_base != xmlMemBlocks()) {
47490: printf("Leak of %d blocks found in xmlXPathFloorFunction",
47491: xmlMemBlocks() - mem_base);
47492: test_ret++;
47493: printf(" %d", n_ctxt);
47494: printf(" %d", n_nargs);
47495: printf("\n");
47496: }
47497: }
47498: }
47499: function_tests++;
47500: #endif
47501:
47502: return(test_ret);
47503: }
47504:
47505:
47506: static int
47507: test_xmlXPathFunctionLookup(void) {
47508: int test_ret = 0;
47509:
47510:
47511: /* missing type support */
47512: return(test_ret);
47513: }
47514:
47515:
47516: static int
47517: test_xmlXPathFunctionLookupNS(void) {
47518: int test_ret = 0;
47519:
47520:
47521: /* missing type support */
47522: return(test_ret);
47523: }
47524:
47525:
47526: static int
47527: test_xmlXPathHasSameNodes(void) {
47528: int test_ret = 0;
47529:
47530: #if defined(LIBXML_XPATH_ENABLED)
47531: int mem_base;
47532: int ret_val;
47533: xmlNodeSetPtr nodes1; /* a node-set */
47534: int n_nodes1;
47535: xmlNodeSetPtr nodes2; /* a node-set */
47536: int n_nodes2;
47537:
47538: for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
47539: for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
47540: mem_base = xmlMemBlocks();
47541: nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
47542: nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
47543:
47544: ret_val = xmlXPathHasSameNodes(nodes1, nodes2);
47545: desret_int(ret_val);
47546: call_tests++;
47547: des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
47548: des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
47549: xmlResetLastError();
47550: if (mem_base != xmlMemBlocks()) {
47551: printf("Leak of %d blocks found in xmlXPathHasSameNodes",
47552: xmlMemBlocks() - mem_base);
47553: test_ret++;
47554: printf(" %d", n_nodes1);
47555: printf(" %d", n_nodes2);
47556: printf("\n");
47557: }
47558: }
47559: }
47560: function_tests++;
47561: #endif
47562:
47563: return(test_ret);
47564: }
47565:
47566:
47567: static int
47568: test_xmlXPathIdFunction(void) {
47569: int test_ret = 0;
47570:
47571: #if defined(LIBXML_XPATH_ENABLED)
47572: int mem_base;
47573: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47574: int n_ctxt;
47575: int nargs; /* the number of arguments */
47576: int n_nargs;
47577:
47578: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47579: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
47580: mem_base = xmlMemBlocks();
47581: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47582: nargs = gen_int(n_nargs, 1);
47583:
47584: xmlXPathIdFunction(ctxt, nargs);
47585: call_tests++;
47586: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47587: des_int(n_nargs, nargs, 1);
47588: xmlResetLastError();
47589: if (mem_base != xmlMemBlocks()) {
47590: printf("Leak of %d blocks found in xmlXPathIdFunction",
47591: xmlMemBlocks() - mem_base);
47592: test_ret++;
47593: printf(" %d", n_ctxt);
47594: printf(" %d", n_nargs);
47595: printf("\n");
47596: }
47597: }
47598: }
47599: function_tests++;
47600: #endif
47601:
47602: return(test_ret);
47603: }
47604:
47605:
47606: static int
47607: test_xmlXPathIntersection(void) {
47608: int test_ret = 0;
47609:
47610: #if defined(LIBXML_XPATH_ENABLED)
47611: int mem_base;
47612: xmlNodeSetPtr ret_val;
47613: xmlNodeSetPtr nodes1; /* a node-set */
47614: int n_nodes1;
47615: xmlNodeSetPtr nodes2; /* a node-set */
47616: int n_nodes2;
47617:
47618: for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
47619: for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
47620: mem_base = xmlMemBlocks();
47621: nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
47622: nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
47623:
47624: ret_val = xmlXPathIntersection(nodes1, nodes2);
47625: desret_xmlNodeSetPtr(ret_val);
47626: call_tests++;
47627: des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
47628: des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
47629: xmlResetLastError();
47630: if (mem_base != xmlMemBlocks()) {
47631: printf("Leak of %d blocks found in xmlXPathIntersection",
47632: xmlMemBlocks() - mem_base);
47633: test_ret++;
47634: printf(" %d", n_nodes1);
47635: printf(" %d", n_nodes2);
47636: printf("\n");
47637: }
47638: }
47639: }
47640: function_tests++;
47641: #endif
47642:
47643: return(test_ret);
47644: }
47645:
47646:
47647: static int
47648: test_xmlXPathIsNodeType(void) {
47649: int test_ret = 0;
47650:
47651: #if defined(LIBXML_XPATH_ENABLED)
47652: int mem_base;
47653: int ret_val;
47654: xmlChar * name; /* a name string */
47655: int n_name;
47656:
47657: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
47658: mem_base = xmlMemBlocks();
47659: name = gen_const_xmlChar_ptr(n_name, 0);
47660:
47661: ret_val = xmlXPathIsNodeType((const xmlChar *)name);
47662: desret_int(ret_val);
47663: call_tests++;
47664: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
47665: xmlResetLastError();
47666: if (mem_base != xmlMemBlocks()) {
47667: printf("Leak of %d blocks found in xmlXPathIsNodeType",
47668: xmlMemBlocks() - mem_base);
47669: test_ret++;
47670: printf(" %d", n_name);
47671: printf("\n");
47672: }
47673: }
47674: function_tests++;
47675: #endif
47676:
47677: return(test_ret);
47678: }
47679:
47680:
47681: static int
47682: test_xmlXPathLangFunction(void) {
47683: int test_ret = 0;
47684:
47685: #if defined(LIBXML_XPATH_ENABLED)
47686: int mem_base;
47687: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47688: int n_ctxt;
47689: int nargs; /* the number of arguments */
47690: int n_nargs;
47691:
47692: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47693: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
47694: mem_base = xmlMemBlocks();
47695: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47696: nargs = gen_int(n_nargs, 1);
47697:
47698: xmlXPathLangFunction(ctxt, nargs);
47699: call_tests++;
47700: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47701: des_int(n_nargs, nargs, 1);
47702: xmlResetLastError();
47703: if (mem_base != xmlMemBlocks()) {
47704: printf("Leak of %d blocks found in xmlXPathLangFunction",
47705: xmlMemBlocks() - mem_base);
47706: test_ret++;
47707: printf(" %d", n_ctxt);
47708: printf(" %d", n_nargs);
47709: printf("\n");
47710: }
47711: }
47712: }
47713: function_tests++;
47714: #endif
47715:
47716: return(test_ret);
47717: }
47718:
47719:
47720: static int
47721: test_xmlXPathLastFunction(void) {
47722: int test_ret = 0;
47723:
47724: #if defined(LIBXML_XPATH_ENABLED)
47725: int mem_base;
47726: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47727: int n_ctxt;
47728: int nargs; /* the number of arguments */
47729: int n_nargs;
47730:
47731: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47732: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
47733: mem_base = xmlMemBlocks();
47734: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47735: nargs = gen_int(n_nargs, 1);
47736:
47737: xmlXPathLastFunction(ctxt, nargs);
47738: call_tests++;
47739: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47740: des_int(n_nargs, nargs, 1);
47741: xmlResetLastError();
47742: if (mem_base != xmlMemBlocks()) {
47743: printf("Leak of %d blocks found in xmlXPathLastFunction",
47744: xmlMemBlocks() - mem_base);
47745: test_ret++;
47746: printf(" %d", n_ctxt);
47747: printf(" %d", n_nargs);
47748: printf("\n");
47749: }
47750: }
47751: }
47752: function_tests++;
47753: #endif
47754:
47755: return(test_ret);
47756: }
47757:
47758:
47759: static int
47760: test_xmlXPathLeading(void) {
47761: int test_ret = 0;
47762:
47763: #if defined(LIBXML_XPATH_ENABLED)
47764: int mem_base;
47765: xmlNodeSetPtr ret_val;
47766: xmlNodeSetPtr nodes1; /* a node-set */
47767: int n_nodes1;
47768: xmlNodeSetPtr nodes2; /* a node-set */
47769: int n_nodes2;
47770:
47771: for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
47772: for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
47773: mem_base = xmlMemBlocks();
47774: nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
47775: nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
47776:
47777: ret_val = xmlXPathLeading(nodes1, nodes2);
47778: desret_xmlNodeSetPtr(ret_val);
47779: call_tests++;
47780: des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
47781: des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
47782: xmlResetLastError();
47783: if (mem_base != xmlMemBlocks()) {
47784: printf("Leak of %d blocks found in xmlXPathLeading",
47785: xmlMemBlocks() - mem_base);
47786: test_ret++;
47787: printf(" %d", n_nodes1);
47788: printf(" %d", n_nodes2);
47789: printf("\n");
47790: }
47791: }
47792: }
47793: function_tests++;
47794: #endif
47795:
47796: return(test_ret);
47797: }
47798:
47799:
47800: static int
47801: test_xmlXPathLeadingSorted(void) {
47802: int test_ret = 0;
47803:
47804: #if defined(LIBXML_XPATH_ENABLED)
47805: int mem_base;
47806: xmlNodeSetPtr ret_val;
47807: xmlNodeSetPtr nodes1; /* a node-set, sorted by document order */
47808: int n_nodes1;
47809: xmlNodeSetPtr nodes2; /* a node-set, sorted by document order */
47810: int n_nodes2;
47811:
47812: for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
47813: for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
47814: mem_base = xmlMemBlocks();
47815: nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
47816: nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
47817:
47818: ret_val = xmlXPathLeadingSorted(nodes1, nodes2);
47819: desret_xmlNodeSetPtr(ret_val);
47820: call_tests++;
47821: des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
47822: des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
47823: xmlResetLastError();
47824: if (mem_base != xmlMemBlocks()) {
47825: printf("Leak of %d blocks found in xmlXPathLeadingSorted",
47826: xmlMemBlocks() - mem_base);
47827: test_ret++;
47828: printf(" %d", n_nodes1);
47829: printf(" %d", n_nodes2);
47830: printf("\n");
47831: }
47832: }
47833: }
47834: function_tests++;
47835: #endif
47836:
47837: return(test_ret);
47838: }
47839:
47840:
47841: static int
47842: test_xmlXPathLocalNameFunction(void) {
47843: int test_ret = 0;
47844:
47845: #if defined(LIBXML_XPATH_ENABLED)
47846: int mem_base;
47847: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47848: int n_ctxt;
47849: int nargs; /* the number of arguments */
47850: int n_nargs;
47851:
47852: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47853: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
47854: mem_base = xmlMemBlocks();
47855: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47856: nargs = gen_int(n_nargs, 1);
47857:
47858: xmlXPathLocalNameFunction(ctxt, nargs);
47859: call_tests++;
47860: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47861: des_int(n_nargs, nargs, 1);
47862: xmlResetLastError();
47863: if (mem_base != xmlMemBlocks()) {
47864: printf("Leak of %d blocks found in xmlXPathLocalNameFunction",
47865: xmlMemBlocks() - mem_base);
47866: test_ret++;
47867: printf(" %d", n_ctxt);
47868: printf(" %d", n_nargs);
47869: printf("\n");
47870: }
47871: }
47872: }
47873: function_tests++;
47874: #endif
47875:
47876: return(test_ret);
47877: }
47878:
47879:
47880: static int
47881: test_xmlXPathModValues(void) {
47882: int test_ret = 0;
47883:
47884: #if defined(LIBXML_XPATH_ENABLED)
47885: int mem_base;
47886: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47887: int n_ctxt;
47888:
47889: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47890: mem_base = xmlMemBlocks();
47891: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47892:
47893: xmlXPathModValues(ctxt);
47894: call_tests++;
47895: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47896: xmlResetLastError();
47897: if (mem_base != xmlMemBlocks()) {
47898: printf("Leak of %d blocks found in xmlXPathModValues",
47899: xmlMemBlocks() - mem_base);
47900: test_ret++;
47901: printf(" %d", n_ctxt);
47902: printf("\n");
47903: }
47904: }
47905: function_tests++;
47906: #endif
47907:
47908: return(test_ret);
47909: }
47910:
47911:
47912: static int
47913: test_xmlXPathMultValues(void) {
47914: int test_ret = 0;
47915:
47916: #if defined(LIBXML_XPATH_ENABLED)
47917: int mem_base;
47918: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47919: int n_ctxt;
47920:
47921: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47922: mem_base = xmlMemBlocks();
47923: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47924:
47925: xmlXPathMultValues(ctxt);
47926: call_tests++;
47927: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47928: xmlResetLastError();
47929: if (mem_base != xmlMemBlocks()) {
47930: printf("Leak of %d blocks found in xmlXPathMultValues",
47931: xmlMemBlocks() - mem_base);
47932: test_ret++;
47933: printf(" %d", n_ctxt);
47934: printf("\n");
47935: }
47936: }
47937: function_tests++;
47938: #endif
47939:
47940: return(test_ret);
47941: }
47942:
47943:
47944: static int
47945: test_xmlXPathNamespaceURIFunction(void) {
47946: int test_ret = 0;
47947:
47948: #if defined(LIBXML_XPATH_ENABLED)
47949: int mem_base;
47950: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47951: int n_ctxt;
47952: int nargs; /* the number of arguments */
47953: int n_nargs;
47954:
47955: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47956: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
47957: mem_base = xmlMemBlocks();
47958: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47959: nargs = gen_int(n_nargs, 1);
47960:
47961: xmlXPathNamespaceURIFunction(ctxt, nargs);
47962: call_tests++;
47963: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47964: des_int(n_nargs, nargs, 1);
47965: xmlResetLastError();
47966: if (mem_base != xmlMemBlocks()) {
47967: printf("Leak of %d blocks found in xmlXPathNamespaceURIFunction",
47968: xmlMemBlocks() - mem_base);
47969: test_ret++;
47970: printf(" %d", n_ctxt);
47971: printf(" %d", n_nargs);
47972: printf("\n");
47973: }
47974: }
47975: }
47976: function_tests++;
47977: #endif
47978:
47979: return(test_ret);
47980: }
47981:
47982:
47983: static int
47984: test_xmlXPathNewBoolean(void) {
47985: int test_ret = 0;
47986:
47987: #if defined(LIBXML_XPATH_ENABLED)
47988: int mem_base;
47989: xmlXPathObjectPtr ret_val;
47990: int val; /* the boolean value */
47991: int n_val;
47992:
47993: for (n_val = 0;n_val < gen_nb_int;n_val++) {
47994: mem_base = xmlMemBlocks();
47995: val = gen_int(n_val, 0);
47996:
47997: ret_val = xmlXPathNewBoolean(val);
47998: desret_xmlXPathObjectPtr(ret_val);
47999: call_tests++;
48000: des_int(n_val, val, 0);
48001: xmlResetLastError();
48002: if (mem_base != xmlMemBlocks()) {
48003: printf("Leak of %d blocks found in xmlXPathNewBoolean",
48004: xmlMemBlocks() - mem_base);
48005: test_ret++;
48006: printf(" %d", n_val);
48007: printf("\n");
48008: }
48009: }
48010: function_tests++;
48011: #endif
48012:
48013: return(test_ret);
48014: }
48015:
48016:
48017: static int
48018: test_xmlXPathNewCString(void) {
48019: int test_ret = 0;
48020:
48021: #if defined(LIBXML_XPATH_ENABLED)
48022: int mem_base;
48023: xmlXPathObjectPtr ret_val;
48024: char * val; /* the char * value */
48025: int n_val;
48026:
48027: for (n_val = 0;n_val < gen_nb_const_char_ptr;n_val++) {
48028: mem_base = xmlMemBlocks();
48029: val = gen_const_char_ptr(n_val, 0);
48030:
48031: ret_val = xmlXPathNewCString((const char *)val);
48032: desret_xmlXPathObjectPtr(ret_val);
48033: call_tests++;
48034: des_const_char_ptr(n_val, (const char *)val, 0);
48035: xmlResetLastError();
48036: if (mem_base != xmlMemBlocks()) {
48037: printf("Leak of %d blocks found in xmlXPathNewCString",
48038: xmlMemBlocks() - mem_base);
48039: test_ret++;
48040: printf(" %d", n_val);
48041: printf("\n");
48042: }
48043: }
48044: function_tests++;
48045: #endif
48046:
48047: return(test_ret);
48048: }
48049:
48050:
48051: static int
48052: test_xmlXPathNewFloat(void) {
48053: int test_ret = 0;
48054:
48055: #if defined(LIBXML_XPATH_ENABLED)
48056: int mem_base;
48057: xmlXPathObjectPtr ret_val;
48058: double val; /* the double value */
48059: int n_val;
48060:
48061: for (n_val = 0;n_val < gen_nb_double;n_val++) {
48062: mem_base = xmlMemBlocks();
48063: val = gen_double(n_val, 0);
48064:
48065: ret_val = xmlXPathNewFloat(val);
48066: desret_xmlXPathObjectPtr(ret_val);
48067: call_tests++;
48068: des_double(n_val, val, 0);
48069: xmlResetLastError();
48070: if (mem_base != xmlMemBlocks()) {
48071: printf("Leak of %d blocks found in xmlXPathNewFloat",
48072: xmlMemBlocks() - mem_base);
48073: test_ret++;
48074: printf(" %d", n_val);
48075: printf("\n");
48076: }
48077: }
48078: function_tests++;
48079: #endif
48080:
48081: return(test_ret);
48082: }
48083:
48084:
48085: static int
48086: test_xmlXPathNewNodeSet(void) {
48087: int test_ret = 0;
48088:
48089: #if defined(LIBXML_XPATH_ENABLED)
48090: int mem_base;
48091: xmlXPathObjectPtr ret_val;
48092: xmlNodePtr val; /* the NodePtr value */
48093: int n_val;
48094:
48095: for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
48096: mem_base = xmlMemBlocks();
48097: val = gen_xmlNodePtr(n_val, 0);
48098:
48099: ret_val = xmlXPathNewNodeSet(val);
48100: desret_xmlXPathObjectPtr(ret_val);
48101: call_tests++;
48102: des_xmlNodePtr(n_val, val, 0);
48103: xmlResetLastError();
48104: if (mem_base != xmlMemBlocks()) {
48105: printf("Leak of %d blocks found in xmlXPathNewNodeSet",
48106: xmlMemBlocks() - mem_base);
48107: test_ret++;
48108: printf(" %d", n_val);
48109: printf("\n");
48110: }
48111: }
48112: function_tests++;
48113: #endif
48114:
48115: return(test_ret);
48116: }
48117:
48118:
48119: static int
48120: test_xmlXPathNewNodeSetList(void) {
48121: int test_ret = 0;
48122:
48123: #if defined(LIBXML_XPATH_ENABLED)
48124: int mem_base;
48125: xmlXPathObjectPtr ret_val;
48126: xmlNodeSetPtr val; /* an existing NodeSet */
48127: int n_val;
48128:
48129: for (n_val = 0;n_val < gen_nb_xmlNodeSetPtr;n_val++) {
48130: mem_base = xmlMemBlocks();
48131: val = gen_xmlNodeSetPtr(n_val, 0);
48132:
48133: ret_val = xmlXPathNewNodeSetList(val);
48134: desret_xmlXPathObjectPtr(ret_val);
48135: call_tests++;
48136: des_xmlNodeSetPtr(n_val, val, 0);
48137: xmlResetLastError();
48138: if (mem_base != xmlMemBlocks()) {
48139: printf("Leak of %d blocks found in xmlXPathNewNodeSetList",
48140: xmlMemBlocks() - mem_base);
48141: test_ret++;
48142: printf(" %d", n_val);
48143: printf("\n");
48144: }
48145: }
48146: function_tests++;
48147: #endif
48148:
48149: return(test_ret);
48150: }
48151:
48152:
48153: static int
48154: test_xmlXPathNewParserContext(void) {
48155: int test_ret = 0;
48156:
48157:
48158: /* missing type support */
48159: return(test_ret);
48160: }
48161:
48162:
48163: static int
48164: test_xmlXPathNewString(void) {
48165: int test_ret = 0;
48166:
48167: #if defined(LIBXML_XPATH_ENABLED)
48168: int mem_base;
48169: xmlXPathObjectPtr ret_val;
48170: xmlChar * val; /* the xmlChar * value */
48171: int n_val;
48172:
48173: for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) {
48174: mem_base = xmlMemBlocks();
48175: val = gen_const_xmlChar_ptr(n_val, 0);
48176:
48177: ret_val = xmlXPathNewString((const xmlChar *)val);
48178: desret_xmlXPathObjectPtr(ret_val);
48179: call_tests++;
48180: des_const_xmlChar_ptr(n_val, (const xmlChar *)val, 0);
48181: xmlResetLastError();
48182: if (mem_base != xmlMemBlocks()) {
48183: printf("Leak of %d blocks found in xmlXPathNewString",
48184: xmlMemBlocks() - mem_base);
48185: test_ret++;
48186: printf(" %d", n_val);
48187: printf("\n");
48188: }
48189: }
48190: function_tests++;
48191: #endif
48192:
48193: return(test_ret);
48194: }
48195:
48196:
48197: static int
48198: test_xmlXPathNextAncestor(void) {
48199: int test_ret = 0;
48200:
48201: #if defined(LIBXML_XPATH_ENABLED)
48202: int mem_base;
48203: xmlNodePtr ret_val;
48204: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48205: int n_ctxt;
48206: xmlNodePtr cur; /* the current node in the traversal */
48207: int n_cur;
48208:
48209: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48210: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48211: mem_base = xmlMemBlocks();
48212: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48213: cur = gen_xmlNodePtr(n_cur, 1);
48214:
48215: ret_val = xmlXPathNextAncestor(ctxt, cur);
48216: desret_xmlNodePtr(ret_val);
48217: call_tests++;
48218: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48219: des_xmlNodePtr(n_cur, cur, 1);
48220: xmlResetLastError();
48221: if (mem_base != xmlMemBlocks()) {
48222: printf("Leak of %d blocks found in xmlXPathNextAncestor",
48223: xmlMemBlocks() - mem_base);
48224: test_ret++;
48225: printf(" %d", n_ctxt);
48226: printf(" %d", n_cur);
48227: printf("\n");
48228: }
48229: }
48230: }
48231: function_tests++;
48232: #endif
48233:
48234: return(test_ret);
48235: }
48236:
48237:
48238: static int
48239: test_xmlXPathNextAncestorOrSelf(void) {
48240: int test_ret = 0;
48241:
48242: #if defined(LIBXML_XPATH_ENABLED)
48243: int mem_base;
48244: xmlNodePtr ret_val;
48245: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48246: int n_ctxt;
48247: xmlNodePtr cur; /* the current node in the traversal */
48248: int n_cur;
48249:
48250: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48251: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48252: mem_base = xmlMemBlocks();
48253: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48254: cur = gen_xmlNodePtr(n_cur, 1);
48255:
48256: ret_val = xmlXPathNextAncestorOrSelf(ctxt, cur);
48257: desret_xmlNodePtr(ret_val);
48258: call_tests++;
48259: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48260: des_xmlNodePtr(n_cur, cur, 1);
48261: xmlResetLastError();
48262: if (mem_base != xmlMemBlocks()) {
48263: printf("Leak of %d blocks found in xmlXPathNextAncestorOrSelf",
48264: xmlMemBlocks() - mem_base);
48265: test_ret++;
48266: printf(" %d", n_ctxt);
48267: printf(" %d", n_cur);
48268: printf("\n");
48269: }
48270: }
48271: }
48272: function_tests++;
48273: #endif
48274:
48275: return(test_ret);
48276: }
48277:
48278:
48279: static int
48280: test_xmlXPathNextAttribute(void) {
48281: int test_ret = 0;
48282:
48283: #if defined(LIBXML_XPATH_ENABLED)
48284: int mem_base;
48285: xmlNodePtr ret_val;
48286: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48287: int n_ctxt;
48288: xmlNodePtr cur; /* the current attribute in the traversal */
48289: int n_cur;
48290:
48291: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48292: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48293: mem_base = xmlMemBlocks();
48294: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48295: cur = gen_xmlNodePtr(n_cur, 1);
48296:
48297: ret_val = xmlXPathNextAttribute(ctxt, cur);
48298: desret_xmlNodePtr(ret_val);
48299: call_tests++;
48300: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48301: des_xmlNodePtr(n_cur, cur, 1);
48302: xmlResetLastError();
48303: if (mem_base != xmlMemBlocks()) {
48304: printf("Leak of %d blocks found in xmlXPathNextAttribute",
48305: xmlMemBlocks() - mem_base);
48306: test_ret++;
48307: printf(" %d", n_ctxt);
48308: printf(" %d", n_cur);
48309: printf("\n");
48310: }
48311: }
48312: }
48313: function_tests++;
48314: #endif
48315:
48316: return(test_ret);
48317: }
48318:
48319:
48320: static int
48321: test_xmlXPathNextChild(void) {
48322: int test_ret = 0;
48323:
48324: #if defined(LIBXML_XPATH_ENABLED)
48325: int mem_base;
48326: xmlNodePtr ret_val;
48327: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48328: int n_ctxt;
48329: xmlNodePtr cur; /* the current node in the traversal */
48330: int n_cur;
48331:
48332: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48333: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48334: mem_base = xmlMemBlocks();
48335: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48336: cur = gen_xmlNodePtr(n_cur, 1);
48337:
48338: ret_val = xmlXPathNextChild(ctxt, cur);
48339: desret_xmlNodePtr(ret_val);
48340: call_tests++;
48341: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48342: des_xmlNodePtr(n_cur, cur, 1);
48343: xmlResetLastError();
48344: if (mem_base != xmlMemBlocks()) {
48345: printf("Leak of %d blocks found in xmlXPathNextChild",
48346: xmlMemBlocks() - mem_base);
48347: test_ret++;
48348: printf(" %d", n_ctxt);
48349: printf(" %d", n_cur);
48350: printf("\n");
48351: }
48352: }
48353: }
48354: function_tests++;
48355: #endif
48356:
48357: return(test_ret);
48358: }
48359:
48360:
48361: static int
48362: test_xmlXPathNextDescendant(void) {
48363: int test_ret = 0;
48364:
48365: #if defined(LIBXML_XPATH_ENABLED)
48366: int mem_base;
48367: xmlNodePtr ret_val;
48368: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48369: int n_ctxt;
48370: xmlNodePtr cur; /* the current node in the traversal */
48371: int n_cur;
48372:
48373: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48374: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48375: mem_base = xmlMemBlocks();
48376: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48377: cur = gen_xmlNodePtr(n_cur, 1);
48378:
48379: ret_val = xmlXPathNextDescendant(ctxt, cur);
48380: desret_xmlNodePtr(ret_val);
48381: call_tests++;
48382: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48383: des_xmlNodePtr(n_cur, cur, 1);
48384: xmlResetLastError();
48385: if (mem_base != xmlMemBlocks()) {
48386: printf("Leak of %d blocks found in xmlXPathNextDescendant",
48387: xmlMemBlocks() - mem_base);
48388: test_ret++;
48389: printf(" %d", n_ctxt);
48390: printf(" %d", n_cur);
48391: printf("\n");
48392: }
48393: }
48394: }
48395: function_tests++;
48396: #endif
48397:
48398: return(test_ret);
48399: }
48400:
48401:
48402: static int
48403: test_xmlXPathNextDescendantOrSelf(void) {
48404: int test_ret = 0;
48405:
48406: #if defined(LIBXML_XPATH_ENABLED)
48407: int mem_base;
48408: xmlNodePtr ret_val;
48409: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48410: int n_ctxt;
48411: xmlNodePtr cur; /* the current node in the traversal */
48412: int n_cur;
48413:
48414: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48415: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48416: mem_base = xmlMemBlocks();
48417: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48418: cur = gen_xmlNodePtr(n_cur, 1);
48419:
48420: ret_val = xmlXPathNextDescendantOrSelf(ctxt, cur);
48421: desret_xmlNodePtr(ret_val);
48422: call_tests++;
48423: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48424: des_xmlNodePtr(n_cur, cur, 1);
48425: xmlResetLastError();
48426: if (mem_base != xmlMemBlocks()) {
48427: printf("Leak of %d blocks found in xmlXPathNextDescendantOrSelf",
48428: xmlMemBlocks() - mem_base);
48429: test_ret++;
48430: printf(" %d", n_ctxt);
48431: printf(" %d", n_cur);
48432: printf("\n");
48433: }
48434: }
48435: }
48436: function_tests++;
48437: #endif
48438:
48439: return(test_ret);
48440: }
48441:
48442:
48443: static int
48444: test_xmlXPathNextFollowing(void) {
48445: int test_ret = 0;
48446:
48447: #if defined(LIBXML_XPATH_ENABLED)
48448: int mem_base;
48449: xmlNodePtr ret_val;
48450: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48451: int n_ctxt;
48452: xmlNodePtr cur; /* the current node in the traversal */
48453: int n_cur;
48454:
48455: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48456: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48457: mem_base = xmlMemBlocks();
48458: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48459: cur = gen_xmlNodePtr(n_cur, 1);
48460:
48461: ret_val = xmlXPathNextFollowing(ctxt, cur);
48462: desret_xmlNodePtr(ret_val);
48463: call_tests++;
48464: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48465: des_xmlNodePtr(n_cur, cur, 1);
48466: xmlResetLastError();
48467: if (mem_base != xmlMemBlocks()) {
48468: printf("Leak of %d blocks found in xmlXPathNextFollowing",
48469: xmlMemBlocks() - mem_base);
48470: test_ret++;
48471: printf(" %d", n_ctxt);
48472: printf(" %d", n_cur);
48473: printf("\n");
48474: }
48475: }
48476: }
48477: function_tests++;
48478: #endif
48479:
48480: return(test_ret);
48481: }
48482:
48483:
48484: static int
48485: test_xmlXPathNextFollowingSibling(void) {
48486: int test_ret = 0;
48487:
48488: #if defined(LIBXML_XPATH_ENABLED)
48489: int mem_base;
48490: xmlNodePtr ret_val;
48491: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48492: int n_ctxt;
48493: xmlNodePtr cur; /* the current node in the traversal */
48494: int n_cur;
48495:
48496: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48497: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48498: mem_base = xmlMemBlocks();
48499: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48500: cur = gen_xmlNodePtr(n_cur, 1);
48501:
48502: ret_val = xmlXPathNextFollowingSibling(ctxt, cur);
48503: desret_xmlNodePtr(ret_val);
48504: call_tests++;
48505: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48506: des_xmlNodePtr(n_cur, cur, 1);
48507: xmlResetLastError();
48508: if (mem_base != xmlMemBlocks()) {
48509: printf("Leak of %d blocks found in xmlXPathNextFollowingSibling",
48510: xmlMemBlocks() - mem_base);
48511: test_ret++;
48512: printf(" %d", n_ctxt);
48513: printf(" %d", n_cur);
48514: printf("\n");
48515: }
48516: }
48517: }
48518: function_tests++;
48519: #endif
48520:
48521: return(test_ret);
48522: }
48523:
48524:
48525: static int
48526: test_xmlXPathNextNamespace(void) {
48527: int test_ret = 0;
48528:
48529: #if defined(LIBXML_XPATH_ENABLED)
48530: int mem_base;
48531: xmlNodePtr ret_val;
48532: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48533: int n_ctxt;
48534: xmlNodePtr cur; /* the current attribute in the traversal */
48535: int n_cur;
48536:
48537: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48538: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48539: mem_base = xmlMemBlocks();
48540: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48541: cur = gen_xmlNodePtr(n_cur, 1);
48542:
48543: ret_val = xmlXPathNextNamespace(ctxt, cur);
48544: desret_xmlNodePtr(ret_val);
48545: call_tests++;
48546: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48547: des_xmlNodePtr(n_cur, cur, 1);
48548: xmlResetLastError();
48549: if (mem_base != xmlMemBlocks()) {
48550: printf("Leak of %d blocks found in xmlXPathNextNamespace",
48551: xmlMemBlocks() - mem_base);
48552: test_ret++;
48553: printf(" %d", n_ctxt);
48554: printf(" %d", n_cur);
48555: printf("\n");
48556: }
48557: }
48558: }
48559: function_tests++;
48560: #endif
48561:
48562: return(test_ret);
48563: }
48564:
48565:
48566: static int
48567: test_xmlXPathNextParent(void) {
48568: int test_ret = 0;
48569:
48570: #if defined(LIBXML_XPATH_ENABLED)
48571: int mem_base;
48572: xmlNodePtr ret_val;
48573: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48574: int n_ctxt;
48575: xmlNodePtr cur; /* the current node in the traversal */
48576: int n_cur;
48577:
48578: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48579: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48580: mem_base = xmlMemBlocks();
48581: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48582: cur = gen_xmlNodePtr(n_cur, 1);
48583:
48584: ret_val = xmlXPathNextParent(ctxt, cur);
48585: desret_xmlNodePtr(ret_val);
48586: call_tests++;
48587: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48588: des_xmlNodePtr(n_cur, cur, 1);
48589: xmlResetLastError();
48590: if (mem_base != xmlMemBlocks()) {
48591: printf("Leak of %d blocks found in xmlXPathNextParent",
48592: xmlMemBlocks() - mem_base);
48593: test_ret++;
48594: printf(" %d", n_ctxt);
48595: printf(" %d", n_cur);
48596: printf("\n");
48597: }
48598: }
48599: }
48600: function_tests++;
48601: #endif
48602:
48603: return(test_ret);
48604: }
48605:
48606:
48607: static int
48608: test_xmlXPathNextPreceding(void) {
48609: int test_ret = 0;
48610:
48611: #if defined(LIBXML_XPATH_ENABLED)
48612: int mem_base;
48613: xmlNodePtr ret_val;
48614: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48615: int n_ctxt;
48616: xmlNodePtr cur; /* the current node in the traversal */
48617: int n_cur;
48618:
48619: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48620: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48621: mem_base = xmlMemBlocks();
48622: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48623: cur = gen_xmlNodePtr(n_cur, 1);
48624:
48625: ret_val = xmlXPathNextPreceding(ctxt, cur);
48626: desret_xmlNodePtr(ret_val);
48627: call_tests++;
48628: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48629: des_xmlNodePtr(n_cur, cur, 1);
48630: xmlResetLastError();
48631: if (mem_base != xmlMemBlocks()) {
48632: printf("Leak of %d blocks found in xmlXPathNextPreceding",
48633: xmlMemBlocks() - mem_base);
48634: test_ret++;
48635: printf(" %d", n_ctxt);
48636: printf(" %d", n_cur);
48637: printf("\n");
48638: }
48639: }
48640: }
48641: function_tests++;
48642: #endif
48643:
48644: return(test_ret);
48645: }
48646:
48647:
48648: static int
48649: test_xmlXPathNextPrecedingSibling(void) {
48650: int test_ret = 0;
48651:
48652: #if defined(LIBXML_XPATH_ENABLED)
48653: int mem_base;
48654: xmlNodePtr ret_val;
48655: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48656: int n_ctxt;
48657: xmlNodePtr cur; /* the current node in the traversal */
48658: int n_cur;
48659:
48660: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48661: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48662: mem_base = xmlMemBlocks();
48663: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48664: cur = gen_xmlNodePtr(n_cur, 1);
48665:
48666: ret_val = xmlXPathNextPrecedingSibling(ctxt, cur);
48667: desret_xmlNodePtr(ret_val);
48668: call_tests++;
48669: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48670: des_xmlNodePtr(n_cur, cur, 1);
48671: xmlResetLastError();
48672: if (mem_base != xmlMemBlocks()) {
48673: printf("Leak of %d blocks found in xmlXPathNextPrecedingSibling",
48674: xmlMemBlocks() - mem_base);
48675: test_ret++;
48676: printf(" %d", n_ctxt);
48677: printf(" %d", n_cur);
48678: printf("\n");
48679: }
48680: }
48681: }
48682: function_tests++;
48683: #endif
48684:
48685: return(test_ret);
48686: }
48687:
48688:
48689: static int
48690: test_xmlXPathNextSelf(void) {
48691: int test_ret = 0;
48692:
48693: #if defined(LIBXML_XPATH_ENABLED)
48694: int mem_base;
48695: xmlNodePtr ret_val;
48696: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48697: int n_ctxt;
48698: xmlNodePtr cur; /* the current node in the traversal */
48699: int n_cur;
48700:
48701: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48702: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48703: mem_base = xmlMemBlocks();
48704: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48705: cur = gen_xmlNodePtr(n_cur, 1);
48706:
48707: ret_val = xmlXPathNextSelf(ctxt, cur);
48708: desret_xmlNodePtr(ret_val);
48709: call_tests++;
48710: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48711: des_xmlNodePtr(n_cur, cur, 1);
48712: xmlResetLastError();
48713: if (mem_base != xmlMemBlocks()) {
48714: printf("Leak of %d blocks found in xmlXPathNextSelf",
48715: xmlMemBlocks() - mem_base);
48716: test_ret++;
48717: printf(" %d", n_ctxt);
48718: printf(" %d", n_cur);
48719: printf("\n");
48720: }
48721: }
48722: }
48723: function_tests++;
48724: #endif
48725:
48726: return(test_ret);
48727: }
48728:
48729:
48730: static int
48731: test_xmlXPathNodeLeading(void) {
48732: int test_ret = 0;
48733:
48734: #if defined(LIBXML_XPATH_ENABLED)
48735: int mem_base;
48736: xmlNodeSetPtr ret_val;
48737: xmlNodeSetPtr nodes; /* a node-set */
48738: int n_nodes;
48739: xmlNodePtr node; /* a node */
48740: int n_node;
48741:
48742: for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
48743: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
48744: mem_base = xmlMemBlocks();
48745: nodes = gen_xmlNodeSetPtr(n_nodes, 0);
48746: node = gen_xmlNodePtr(n_node, 1);
48747:
48748: ret_val = xmlXPathNodeLeading(nodes, node);
48749: desret_xmlNodeSetPtr(ret_val);
48750: call_tests++;
48751: des_xmlNodeSetPtr(n_nodes, nodes, 0);
48752: des_xmlNodePtr(n_node, node, 1);
48753: xmlResetLastError();
48754: if (mem_base != xmlMemBlocks()) {
48755: printf("Leak of %d blocks found in xmlXPathNodeLeading",
48756: xmlMemBlocks() - mem_base);
48757: test_ret++;
48758: printf(" %d", n_nodes);
48759: printf(" %d", n_node);
48760: printf("\n");
48761: }
48762: }
48763: }
48764: function_tests++;
48765: #endif
48766:
48767: return(test_ret);
48768: }
48769:
48770:
48771: static int
48772: test_xmlXPathNodeLeadingSorted(void) {
48773: int test_ret = 0;
48774:
48775: #if defined(LIBXML_XPATH_ENABLED)
48776: int mem_base;
48777: xmlNodeSetPtr ret_val;
48778: xmlNodeSetPtr nodes; /* a node-set, sorted by document order */
48779: int n_nodes;
48780: xmlNodePtr node; /* a node */
48781: int n_node;
48782:
48783: for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
48784: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
48785: mem_base = xmlMemBlocks();
48786: nodes = gen_xmlNodeSetPtr(n_nodes, 0);
48787: node = gen_xmlNodePtr(n_node, 1);
48788:
48789: ret_val = xmlXPathNodeLeadingSorted(nodes, node);
48790: desret_xmlNodeSetPtr(ret_val);
48791: call_tests++;
48792: des_xmlNodeSetPtr(n_nodes, nodes, 0);
48793: des_xmlNodePtr(n_node, node, 1);
48794: xmlResetLastError();
48795: if (mem_base != xmlMemBlocks()) {
48796: printf("Leak of %d blocks found in xmlXPathNodeLeadingSorted",
48797: xmlMemBlocks() - mem_base);
48798: test_ret++;
48799: printf(" %d", n_nodes);
48800: printf(" %d", n_node);
48801: printf("\n");
48802: }
48803: }
48804: }
48805: function_tests++;
48806: #endif
48807:
48808: return(test_ret);
48809: }
48810:
48811:
48812: static int
48813: test_xmlXPathNodeSetAdd(void) {
48814: int test_ret = 0;
48815:
48816: #if defined(LIBXML_XPATH_ENABLED)
48817: int mem_base;
48818: xmlNodeSetPtr cur; /* the initial node set */
48819: int n_cur;
48820: xmlNodePtr val; /* a new xmlNodePtr */
48821: int n_val;
48822:
48823: for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
48824: for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
48825: mem_base = xmlMemBlocks();
48826: cur = gen_xmlNodeSetPtr(n_cur, 0);
48827: val = gen_xmlNodePtr(n_val, 1);
48828:
48829: xmlXPathNodeSetAdd(cur, val);
48830: call_tests++;
48831: des_xmlNodeSetPtr(n_cur, cur, 0);
48832: des_xmlNodePtr(n_val, val, 1);
48833: xmlResetLastError();
48834: if (mem_base != xmlMemBlocks()) {
48835: printf("Leak of %d blocks found in xmlXPathNodeSetAdd",
48836: xmlMemBlocks() - mem_base);
48837: test_ret++;
48838: printf(" %d", n_cur);
48839: printf(" %d", n_val);
48840: printf("\n");
48841: }
48842: }
48843: }
48844: function_tests++;
48845: #endif
48846:
48847: return(test_ret);
48848: }
48849:
48850:
48851: static int
48852: test_xmlXPathNodeSetAddNs(void) {
48853: int test_ret = 0;
48854:
48855: #if defined(LIBXML_XPATH_ENABLED)
48856: int mem_base;
48857: xmlNodeSetPtr cur; /* the initial node set */
48858: int n_cur;
48859: xmlNodePtr node; /* the hosting node */
48860: int n_node;
48861: xmlNsPtr ns; /* a the namespace node */
48862: int n_ns;
48863:
48864: for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
48865: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
48866: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
48867: mem_base = xmlMemBlocks();
48868: cur = gen_xmlNodeSetPtr(n_cur, 0);
48869: node = gen_xmlNodePtr(n_node, 1);
48870: ns = gen_xmlNsPtr(n_ns, 2);
48871:
48872: xmlXPathNodeSetAddNs(cur, node, ns);
48873: call_tests++;
48874: des_xmlNodeSetPtr(n_cur, cur, 0);
48875: des_xmlNodePtr(n_node, node, 1);
48876: des_xmlNsPtr(n_ns, ns, 2);
48877: xmlResetLastError();
48878: if (mem_base != xmlMemBlocks()) {
48879: printf("Leak of %d blocks found in xmlXPathNodeSetAddNs",
48880: xmlMemBlocks() - mem_base);
48881: test_ret++;
48882: printf(" %d", n_cur);
48883: printf(" %d", n_node);
48884: printf(" %d", n_ns);
48885: printf("\n");
48886: }
48887: }
48888: }
48889: }
48890: function_tests++;
48891: #endif
48892:
48893: return(test_ret);
48894: }
48895:
48896:
48897: static int
48898: test_xmlXPathNodeSetAddUnique(void) {
48899: int test_ret = 0;
48900:
48901: #if defined(LIBXML_XPATH_ENABLED)
48902: int mem_base;
48903: xmlNodeSetPtr cur; /* the initial node set */
48904: int n_cur;
48905: xmlNodePtr val; /* a new xmlNodePtr */
48906: int n_val;
48907:
48908: for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
48909: for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
48910: mem_base = xmlMemBlocks();
48911: cur = gen_xmlNodeSetPtr(n_cur, 0);
48912: val = gen_xmlNodePtr(n_val, 1);
48913:
48914: xmlXPathNodeSetAddUnique(cur, val);
48915: call_tests++;
48916: des_xmlNodeSetPtr(n_cur, cur, 0);
48917: des_xmlNodePtr(n_val, val, 1);
48918: xmlResetLastError();
48919: if (mem_base != xmlMemBlocks()) {
48920: printf("Leak of %d blocks found in xmlXPathNodeSetAddUnique",
48921: xmlMemBlocks() - mem_base);
48922: test_ret++;
48923: printf(" %d", n_cur);
48924: printf(" %d", n_val);
48925: printf("\n");
48926: }
48927: }
48928: }
48929: function_tests++;
48930: #endif
48931:
48932: return(test_ret);
48933: }
48934:
48935:
48936: static int
48937: test_xmlXPathNodeSetContains(void) {
48938: int test_ret = 0;
48939:
48940: #if defined(LIBXML_XPATH_ENABLED)
48941: int mem_base;
48942: int ret_val;
48943: xmlNodeSetPtr cur; /* the node-set */
48944: int n_cur;
48945: xmlNodePtr val; /* the node */
48946: int n_val;
48947:
48948: for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
48949: for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
48950: mem_base = xmlMemBlocks();
48951: cur = gen_xmlNodeSetPtr(n_cur, 0);
48952: val = gen_xmlNodePtr(n_val, 1);
48953:
48954: ret_val = xmlXPathNodeSetContains(cur, val);
48955: desret_int(ret_val);
48956: call_tests++;
48957: des_xmlNodeSetPtr(n_cur, cur, 0);
48958: des_xmlNodePtr(n_val, val, 1);
48959: xmlResetLastError();
48960: if (mem_base != xmlMemBlocks()) {
48961: printf("Leak of %d blocks found in xmlXPathNodeSetContains",
48962: xmlMemBlocks() - mem_base);
48963: test_ret++;
48964: printf(" %d", n_cur);
48965: printf(" %d", n_val);
48966: printf("\n");
48967: }
48968: }
48969: }
48970: function_tests++;
48971: #endif
48972:
48973: return(test_ret);
48974: }
48975:
48976:
48977: static int
48978: test_xmlXPathNodeSetDel(void) {
48979: int test_ret = 0;
48980:
48981: #if defined(LIBXML_XPATH_ENABLED)
48982: int mem_base;
48983: xmlNodeSetPtr cur; /* the initial node set */
48984: int n_cur;
48985: xmlNodePtr val; /* an xmlNodePtr */
48986: int n_val;
48987:
48988: for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
48989: for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
48990: mem_base = xmlMemBlocks();
48991: cur = gen_xmlNodeSetPtr(n_cur, 0);
48992: val = gen_xmlNodePtr(n_val, 1);
48993:
48994: xmlXPathNodeSetDel(cur, val);
48995: call_tests++;
48996: des_xmlNodeSetPtr(n_cur, cur, 0);
48997: des_xmlNodePtr(n_val, val, 1);
48998: xmlResetLastError();
48999: if (mem_base != xmlMemBlocks()) {
49000: printf("Leak of %d blocks found in xmlXPathNodeSetDel",
49001: xmlMemBlocks() - mem_base);
49002: test_ret++;
49003: printf(" %d", n_cur);
49004: printf(" %d", n_val);
49005: printf("\n");
49006: }
49007: }
49008: }
49009: function_tests++;
49010: #endif
49011:
49012: return(test_ret);
49013: }
49014:
49015:
49016: static int
49017: test_xmlXPathNodeSetMerge(void) {
49018: int test_ret = 0;
49019:
49020: #if defined(LIBXML_XPATH_ENABLED)
49021: int mem_base;
49022: xmlNodeSetPtr ret_val;
49023: xmlNodeSetPtr val1; /* the first NodeSet or NULL */
49024: int n_val1;
49025: xmlNodeSetPtr val2; /* the second NodeSet */
49026: int n_val2;
49027:
49028: for (n_val1 = 0;n_val1 < gen_nb_xmlNodeSetPtr;n_val1++) {
49029: for (n_val2 = 0;n_val2 < gen_nb_xmlNodeSetPtr;n_val2++) {
49030: mem_base = xmlMemBlocks();
49031: val1 = gen_xmlNodeSetPtr(n_val1, 0);
49032: val2 = gen_xmlNodeSetPtr(n_val2, 1);
49033:
49034: ret_val = xmlXPathNodeSetMerge(val1, val2);
49035: desret_xmlNodeSetPtr(ret_val);
49036: call_tests++;
49037: des_xmlNodeSetPtr(n_val1, val1, 0);
49038: des_xmlNodeSetPtr(n_val2, val2, 1);
49039: xmlResetLastError();
49040: if (mem_base != xmlMemBlocks()) {
49041: printf("Leak of %d blocks found in xmlXPathNodeSetMerge",
49042: xmlMemBlocks() - mem_base);
49043: test_ret++;
49044: printf(" %d", n_val1);
49045: printf(" %d", n_val2);
49046: printf("\n");
49047: }
49048: }
49049: }
49050: function_tests++;
49051: #endif
49052:
49053: return(test_ret);
49054: }
49055:
49056:
49057: static int
49058: test_xmlXPathNodeSetRemove(void) {
49059: int test_ret = 0;
49060:
49061: #if defined(LIBXML_XPATH_ENABLED)
49062: int mem_base;
49063: xmlNodeSetPtr cur; /* the initial node set */
49064: int n_cur;
49065: int val; /* the index to remove */
49066: int n_val;
49067:
49068: for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
49069: for (n_val = 0;n_val < gen_nb_int;n_val++) {
49070: mem_base = xmlMemBlocks();
49071: cur = gen_xmlNodeSetPtr(n_cur, 0);
49072: val = gen_int(n_val, 1);
49073:
49074: xmlXPathNodeSetRemove(cur, val);
49075: call_tests++;
49076: des_xmlNodeSetPtr(n_cur, cur, 0);
49077: des_int(n_val, val, 1);
49078: xmlResetLastError();
49079: if (mem_base != xmlMemBlocks()) {
49080: printf("Leak of %d blocks found in xmlXPathNodeSetRemove",
49081: xmlMemBlocks() - mem_base);
49082: test_ret++;
49083: printf(" %d", n_cur);
49084: printf(" %d", n_val);
49085: printf("\n");
49086: }
49087: }
49088: }
49089: function_tests++;
49090: #endif
49091:
49092: return(test_ret);
49093: }
49094:
49095:
49096: static int
49097: test_xmlXPathNodeSetSort(void) {
49098: int test_ret = 0;
49099:
49100: #if defined(LIBXML_XPATH_ENABLED)
49101: int mem_base;
49102: xmlNodeSetPtr set; /* the node set */
49103: int n_set;
49104:
49105: for (n_set = 0;n_set < gen_nb_xmlNodeSetPtr;n_set++) {
49106: mem_base = xmlMemBlocks();
49107: set = gen_xmlNodeSetPtr(n_set, 0);
49108:
49109: xmlXPathNodeSetSort(set);
49110: call_tests++;
49111: des_xmlNodeSetPtr(n_set, set, 0);
49112: xmlResetLastError();
49113: if (mem_base != xmlMemBlocks()) {
49114: printf("Leak of %d blocks found in xmlXPathNodeSetSort",
49115: xmlMemBlocks() - mem_base);
49116: test_ret++;
49117: printf(" %d", n_set);
49118: printf("\n");
49119: }
49120: }
49121: function_tests++;
49122: #endif
49123:
49124: return(test_ret);
49125: }
49126:
49127:
49128: static int
49129: test_xmlXPathNodeTrailing(void) {
49130: int test_ret = 0;
49131:
49132: #if defined(LIBXML_XPATH_ENABLED)
49133: int mem_base;
49134: xmlNodeSetPtr ret_val;
49135: xmlNodeSetPtr nodes; /* a node-set */
49136: int n_nodes;
49137: xmlNodePtr node; /* a node */
49138: int n_node;
49139:
49140: for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
49141: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
49142: mem_base = xmlMemBlocks();
49143: nodes = gen_xmlNodeSetPtr(n_nodes, 0);
49144: node = gen_xmlNodePtr(n_node, 1);
49145:
49146: ret_val = xmlXPathNodeTrailing(nodes, node);
49147: desret_xmlNodeSetPtr(ret_val);
49148: call_tests++;
49149: des_xmlNodeSetPtr(n_nodes, nodes, 0);
49150: des_xmlNodePtr(n_node, node, 1);
49151: xmlResetLastError();
49152: if (mem_base != xmlMemBlocks()) {
49153: printf("Leak of %d blocks found in xmlXPathNodeTrailing",
49154: xmlMemBlocks() - mem_base);
49155: test_ret++;
49156: printf(" %d", n_nodes);
49157: printf(" %d", n_node);
49158: printf("\n");
49159: }
49160: }
49161: }
49162: function_tests++;
49163: #endif
49164:
49165: return(test_ret);
49166: }
49167:
49168:
49169: static int
49170: test_xmlXPathNodeTrailingSorted(void) {
49171: int test_ret = 0;
49172:
49173: #if defined(LIBXML_XPATH_ENABLED)
49174: int mem_base;
49175: xmlNodeSetPtr ret_val;
49176: xmlNodeSetPtr nodes; /* a node-set, sorted by document order */
49177: int n_nodes;
49178: xmlNodePtr node; /* a node */
49179: int n_node;
49180:
49181: for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
49182: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
49183: mem_base = xmlMemBlocks();
49184: nodes = gen_xmlNodeSetPtr(n_nodes, 0);
49185: node = gen_xmlNodePtr(n_node, 1);
49186:
49187: ret_val = xmlXPathNodeTrailingSorted(nodes, node);
49188: desret_xmlNodeSetPtr(ret_val);
49189: call_tests++;
49190: des_xmlNodeSetPtr(n_nodes, nodes, 0);
49191: des_xmlNodePtr(n_node, node, 1);
49192: xmlResetLastError();
49193: if (mem_base != xmlMemBlocks()) {
49194: printf("Leak of %d blocks found in xmlXPathNodeTrailingSorted",
49195: xmlMemBlocks() - mem_base);
49196: test_ret++;
49197: printf(" %d", n_nodes);
49198: printf(" %d", n_node);
49199: printf("\n");
49200: }
49201: }
49202: }
49203: function_tests++;
49204: #endif
49205:
49206: return(test_ret);
49207: }
49208:
49209:
49210: static int
49211: test_xmlXPathNormalizeFunction(void) {
49212: int test_ret = 0;
49213:
49214: #if defined(LIBXML_XPATH_ENABLED)
49215: int mem_base;
49216: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49217: int n_ctxt;
49218: int nargs; /* the number of arguments */
49219: int n_nargs;
49220:
49221: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49222: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
49223: mem_base = xmlMemBlocks();
49224: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49225: nargs = gen_int(n_nargs, 1);
49226:
49227: xmlXPathNormalizeFunction(ctxt, nargs);
49228: call_tests++;
49229: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49230: des_int(n_nargs, nargs, 1);
49231: xmlResetLastError();
49232: if (mem_base != xmlMemBlocks()) {
49233: printf("Leak of %d blocks found in xmlXPathNormalizeFunction",
49234: xmlMemBlocks() - mem_base);
49235: test_ret++;
49236: printf(" %d", n_ctxt);
49237: printf(" %d", n_nargs);
49238: printf("\n");
49239: }
49240: }
49241: }
49242: function_tests++;
49243: #endif
49244:
49245: return(test_ret);
49246: }
49247:
49248:
49249: static int
49250: test_xmlXPathNotEqualValues(void) {
49251: int test_ret = 0;
49252:
49253: #if defined(LIBXML_XPATH_ENABLED)
49254: int mem_base;
49255: int ret_val;
49256: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49257: int n_ctxt;
49258:
49259: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49260: mem_base = xmlMemBlocks();
49261: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49262:
49263: ret_val = xmlXPathNotEqualValues(ctxt);
49264: desret_int(ret_val);
49265: call_tests++;
49266: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49267: xmlResetLastError();
49268: if (mem_base != xmlMemBlocks()) {
49269: printf("Leak of %d blocks found in xmlXPathNotEqualValues",
49270: xmlMemBlocks() - mem_base);
49271: test_ret++;
49272: printf(" %d", n_ctxt);
49273: printf("\n");
49274: }
49275: }
49276: function_tests++;
49277: #endif
49278:
49279: return(test_ret);
49280: }
49281:
49282:
49283: static int
49284: test_xmlXPathNotFunction(void) {
49285: int test_ret = 0;
49286:
49287: #if defined(LIBXML_XPATH_ENABLED)
49288: int mem_base;
49289: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49290: int n_ctxt;
49291: int nargs; /* the number of arguments */
49292: int n_nargs;
49293:
49294: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49295: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
49296: mem_base = xmlMemBlocks();
49297: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49298: nargs = gen_int(n_nargs, 1);
49299:
49300: xmlXPathNotFunction(ctxt, nargs);
49301: call_tests++;
49302: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49303: des_int(n_nargs, nargs, 1);
49304: xmlResetLastError();
49305: if (mem_base != xmlMemBlocks()) {
49306: printf("Leak of %d blocks found in xmlXPathNotFunction",
49307: xmlMemBlocks() - mem_base);
49308: test_ret++;
49309: printf(" %d", n_ctxt);
49310: printf(" %d", n_nargs);
49311: printf("\n");
49312: }
49313: }
49314: }
49315: function_tests++;
49316: #endif
49317:
49318: return(test_ret);
49319: }
49320:
49321:
49322: static int
49323: test_xmlXPathNsLookup(void) {
49324: int test_ret = 0;
49325:
49326: #if defined(LIBXML_XPATH_ENABLED)
49327: int mem_base;
49328: const xmlChar * ret_val;
49329: xmlXPathContextPtr ctxt; /* the XPath context */
49330: int n_ctxt;
49331: xmlChar * prefix; /* the namespace prefix value */
49332: int n_prefix;
49333:
49334: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
49335: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
49336: mem_base = xmlMemBlocks();
49337: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
49338: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
49339:
49340: ret_val = xmlXPathNsLookup(ctxt, (const xmlChar *)prefix);
49341: desret_const_xmlChar_ptr(ret_val);
49342: call_tests++;
49343: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
49344: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
49345: xmlResetLastError();
49346: if (mem_base != xmlMemBlocks()) {
49347: printf("Leak of %d blocks found in xmlXPathNsLookup",
49348: xmlMemBlocks() - mem_base);
49349: test_ret++;
49350: printf(" %d", n_ctxt);
49351: printf(" %d", n_prefix);
49352: printf("\n");
49353: }
49354: }
49355: }
49356: function_tests++;
49357: #endif
49358:
49359: return(test_ret);
49360: }
49361:
49362:
49363: static int
49364: test_xmlXPathNumberFunction(void) {
49365: int test_ret = 0;
49366:
49367: #if defined(LIBXML_XPATH_ENABLED)
49368: int mem_base;
49369: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49370: int n_ctxt;
49371: int nargs; /* the number of arguments */
49372: int n_nargs;
49373:
49374: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49375: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
49376: mem_base = xmlMemBlocks();
49377: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49378: nargs = gen_int(n_nargs, 1);
49379:
49380: xmlXPathNumberFunction(ctxt, nargs);
49381: call_tests++;
49382: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49383: des_int(n_nargs, nargs, 1);
49384: xmlResetLastError();
49385: if (mem_base != xmlMemBlocks()) {
49386: printf("Leak of %d blocks found in xmlXPathNumberFunction",
49387: xmlMemBlocks() - mem_base);
49388: test_ret++;
49389: printf(" %d", n_ctxt);
49390: printf(" %d", n_nargs);
49391: printf("\n");
49392: }
49393: }
49394: }
49395: function_tests++;
49396: #endif
49397:
49398: return(test_ret);
49399: }
49400:
49401:
49402: static int
49403: test_xmlXPathParseNCName(void) {
49404: int test_ret = 0;
49405:
49406: #if defined(LIBXML_XPATH_ENABLED)
49407: int mem_base;
49408: xmlChar * ret_val;
49409: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49410: int n_ctxt;
49411:
49412: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49413: mem_base = xmlMemBlocks();
49414: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49415:
49416: ret_val = xmlXPathParseNCName(ctxt);
49417: desret_xmlChar_ptr(ret_val);
49418: call_tests++;
49419: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49420: xmlResetLastError();
49421: if (mem_base != xmlMemBlocks()) {
49422: printf("Leak of %d blocks found in xmlXPathParseNCName",
49423: xmlMemBlocks() - mem_base);
49424: test_ret++;
49425: printf(" %d", n_ctxt);
49426: printf("\n");
49427: }
49428: }
49429: function_tests++;
49430: #endif
49431:
49432: return(test_ret);
49433: }
49434:
49435:
49436: static int
49437: test_xmlXPathParseName(void) {
49438: int test_ret = 0;
49439:
49440: #if defined(LIBXML_XPATH_ENABLED)
49441: int mem_base;
49442: xmlChar * ret_val;
49443: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49444: int n_ctxt;
49445:
49446: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49447: mem_base = xmlMemBlocks();
49448: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49449:
49450: ret_val = xmlXPathParseName(ctxt);
49451: desret_xmlChar_ptr(ret_val);
49452: call_tests++;
49453: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49454: xmlResetLastError();
49455: if (mem_base != xmlMemBlocks()) {
49456: printf("Leak of %d blocks found in xmlXPathParseName",
49457: xmlMemBlocks() - mem_base);
49458: test_ret++;
49459: printf(" %d", n_ctxt);
49460: printf("\n");
49461: }
49462: }
49463: function_tests++;
49464: #endif
49465:
49466: return(test_ret);
49467: }
49468:
49469:
49470: static int
49471: test_xmlXPathPopBoolean(void) {
49472: int test_ret = 0;
49473:
49474: #if defined(LIBXML_XPATH_ENABLED)
49475: int mem_base;
49476: int ret_val;
49477: xmlXPathParserContextPtr ctxt; /* an XPath parser context */
49478: int n_ctxt;
49479:
49480: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49481: mem_base = xmlMemBlocks();
49482: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49483:
49484: ret_val = xmlXPathPopBoolean(ctxt);
49485: desret_int(ret_val);
49486: call_tests++;
49487: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49488: xmlResetLastError();
49489: if (mem_base != xmlMemBlocks()) {
49490: printf("Leak of %d blocks found in xmlXPathPopBoolean",
49491: xmlMemBlocks() - mem_base);
49492: test_ret++;
49493: printf(" %d", n_ctxt);
49494: printf("\n");
49495: }
49496: }
49497: function_tests++;
49498: #endif
49499:
49500: return(test_ret);
49501: }
49502:
49503:
49504: static int
49505: test_xmlXPathPopExternal(void) {
49506: int test_ret = 0;
49507:
49508: #if defined(LIBXML_XPATH_ENABLED)
49509: int mem_base;
49510: void * ret_val;
49511: xmlXPathParserContextPtr ctxt; /* an XPath parser context */
49512: int n_ctxt;
49513:
49514: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49515: mem_base = xmlMemBlocks();
49516: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49517:
49518: ret_val = xmlXPathPopExternal(ctxt);
49519: desret_void_ptr(ret_val);
49520: call_tests++;
49521: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49522: xmlResetLastError();
49523: if (mem_base != xmlMemBlocks()) {
49524: printf("Leak of %d blocks found in xmlXPathPopExternal",
49525: xmlMemBlocks() - mem_base);
49526: test_ret++;
49527: printf(" %d", n_ctxt);
49528: printf("\n");
49529: }
49530: }
49531: function_tests++;
49532: #endif
49533:
49534: return(test_ret);
49535: }
49536:
49537:
49538: static int
49539: test_xmlXPathPopNodeSet(void) {
49540: int test_ret = 0;
49541:
49542: #if defined(LIBXML_XPATH_ENABLED)
49543: int mem_base;
49544: xmlNodeSetPtr ret_val;
49545: xmlXPathParserContextPtr ctxt; /* an XPath parser context */
49546: int n_ctxt;
49547:
49548: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49549: mem_base = xmlMemBlocks();
49550: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49551:
49552: ret_val = xmlXPathPopNodeSet(ctxt);
49553: desret_xmlNodeSetPtr(ret_val);
49554: call_tests++;
49555: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49556: xmlResetLastError();
49557: if (mem_base != xmlMemBlocks()) {
49558: printf("Leak of %d blocks found in xmlXPathPopNodeSet",
49559: xmlMemBlocks() - mem_base);
49560: test_ret++;
49561: printf(" %d", n_ctxt);
49562: printf("\n");
49563: }
49564: }
49565: function_tests++;
49566: #endif
49567:
49568: return(test_ret);
49569: }
49570:
49571:
49572: static int
49573: test_xmlXPathPopNumber(void) {
49574: int test_ret = 0;
49575:
49576: #if defined(LIBXML_XPATH_ENABLED)
49577: int mem_base;
49578: double ret_val;
49579: xmlXPathParserContextPtr ctxt; /* an XPath parser context */
49580: int n_ctxt;
49581:
49582: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49583: mem_base = xmlMemBlocks();
49584: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49585:
49586: ret_val = xmlXPathPopNumber(ctxt);
49587: desret_double(ret_val);
49588: call_tests++;
49589: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49590: xmlResetLastError();
49591: if (mem_base != xmlMemBlocks()) {
49592: printf("Leak of %d blocks found in xmlXPathPopNumber",
49593: xmlMemBlocks() - mem_base);
49594: test_ret++;
49595: printf(" %d", n_ctxt);
49596: printf("\n");
49597: }
49598: }
49599: function_tests++;
49600: #endif
49601:
49602: return(test_ret);
49603: }
49604:
49605:
49606: static int
49607: test_xmlXPathPopString(void) {
49608: int test_ret = 0;
49609:
49610: #if defined(LIBXML_XPATH_ENABLED)
49611: int mem_base;
49612: xmlChar * ret_val;
49613: xmlXPathParserContextPtr ctxt; /* an XPath parser context */
49614: int n_ctxt;
49615:
49616: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49617: mem_base = xmlMemBlocks();
49618: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49619:
49620: ret_val = xmlXPathPopString(ctxt);
49621: desret_xmlChar_ptr(ret_val);
49622: call_tests++;
49623: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49624: xmlResetLastError();
49625: if (mem_base != xmlMemBlocks()) {
49626: printf("Leak of %d blocks found in xmlXPathPopString",
49627: xmlMemBlocks() - mem_base);
49628: test_ret++;
49629: printf(" %d", n_ctxt);
49630: printf("\n");
49631: }
49632: }
49633: function_tests++;
49634: #endif
49635:
49636: return(test_ret);
49637: }
49638:
49639:
49640: static int
49641: test_xmlXPathPositionFunction(void) {
49642: int test_ret = 0;
49643:
49644: #if defined(LIBXML_XPATH_ENABLED)
49645: int mem_base;
49646: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49647: int n_ctxt;
49648: int nargs; /* the number of arguments */
49649: int n_nargs;
49650:
49651: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49652: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
49653: mem_base = xmlMemBlocks();
49654: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49655: nargs = gen_int(n_nargs, 1);
49656:
49657: xmlXPathPositionFunction(ctxt, nargs);
49658: call_tests++;
49659: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49660: des_int(n_nargs, nargs, 1);
49661: xmlResetLastError();
49662: if (mem_base != xmlMemBlocks()) {
49663: printf("Leak of %d blocks found in xmlXPathPositionFunction",
49664: xmlMemBlocks() - mem_base);
49665: test_ret++;
49666: printf(" %d", n_ctxt);
49667: printf(" %d", n_nargs);
49668: printf("\n");
49669: }
49670: }
49671: }
49672: function_tests++;
49673: #endif
49674:
49675: return(test_ret);
49676: }
49677:
49678:
49679: static int
49680: test_xmlXPathRegisterAllFunctions(void) {
49681: int test_ret = 0;
49682:
49683: #if defined(LIBXML_XPATH_ENABLED)
49684: int mem_base;
49685: xmlXPathContextPtr ctxt; /* the XPath context */
49686: int n_ctxt;
49687:
49688: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
49689: mem_base = xmlMemBlocks();
49690: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
49691:
49692: xmlXPathRegisterAllFunctions(ctxt);
49693: call_tests++;
49694: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
49695: xmlResetLastError();
49696: if (mem_base != xmlMemBlocks()) {
49697: printf("Leak of %d blocks found in xmlXPathRegisterAllFunctions",
49698: xmlMemBlocks() - mem_base);
49699: test_ret++;
49700: printf(" %d", n_ctxt);
49701: printf("\n");
49702: }
49703: }
49704: function_tests++;
49705: #endif
49706:
49707: return(test_ret);
49708: }
49709:
49710:
49711: static int
49712: test_xmlXPathRegisterFunc(void) {
49713: int test_ret = 0;
49714:
49715:
49716: /* missing type support */
49717: return(test_ret);
49718: }
49719:
49720:
49721: static int
49722: test_xmlXPathRegisterFuncLookup(void) {
49723: int test_ret = 0;
49724:
49725:
49726: /* missing type support */
49727: return(test_ret);
49728: }
49729:
49730:
49731: static int
49732: test_xmlXPathRegisterFuncNS(void) {
49733: int test_ret = 0;
49734:
49735:
49736: /* missing type support */
49737: return(test_ret);
49738: }
49739:
49740:
49741: static int
49742: test_xmlXPathRegisterNs(void) {
49743: int test_ret = 0;
49744:
49745: #if defined(LIBXML_XPATH_ENABLED)
49746: int mem_base;
49747: int ret_val;
49748: xmlXPathContextPtr ctxt; /* the XPath context */
49749: int n_ctxt;
49750: xmlChar * prefix; /* the namespace prefix cannot be NULL or empty string */
49751: int n_prefix;
49752: xmlChar * ns_uri; /* the namespace name */
49753: int n_ns_uri;
49754:
49755: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
49756: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
49757: for (n_ns_uri = 0;n_ns_uri < gen_nb_const_xmlChar_ptr;n_ns_uri++) {
49758: mem_base = xmlMemBlocks();
49759: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
49760: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
49761: ns_uri = gen_const_xmlChar_ptr(n_ns_uri, 2);
49762:
49763: ret_val = xmlXPathRegisterNs(ctxt, (const xmlChar *)prefix, (const xmlChar *)ns_uri);
49764: desret_int(ret_val);
49765: call_tests++;
49766: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
49767: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
49768: des_const_xmlChar_ptr(n_ns_uri, (const xmlChar *)ns_uri, 2);
49769: xmlResetLastError();
49770: if (mem_base != xmlMemBlocks()) {
49771: printf("Leak of %d blocks found in xmlXPathRegisterNs",
49772: xmlMemBlocks() - mem_base);
49773: test_ret++;
49774: printf(" %d", n_ctxt);
49775: printf(" %d", n_prefix);
49776: printf(" %d", n_ns_uri);
49777: printf("\n");
49778: }
49779: }
49780: }
49781: }
49782: function_tests++;
49783: #endif
49784:
49785: return(test_ret);
49786: }
49787:
49788:
49789: static int
49790: test_xmlXPathRegisterVariable(void) {
49791: int test_ret = 0;
49792:
49793: #if defined(LIBXML_XPATH_ENABLED)
49794: int mem_base;
49795: int ret_val;
49796: xmlXPathContextPtr ctxt; /* the XPath context */
49797: int n_ctxt;
49798: xmlChar * name; /* the variable name */
49799: int n_name;
49800: xmlXPathObjectPtr value; /* the variable value or NULL */
49801: int n_value;
49802:
49803: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
49804: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
49805: for (n_value = 0;n_value < gen_nb_xmlXPathObjectPtr;n_value++) {
49806: mem_base = xmlMemBlocks();
49807: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
49808: name = gen_const_xmlChar_ptr(n_name, 1);
49809: value = gen_xmlXPathObjectPtr(n_value, 2);
49810:
49811: ret_val = xmlXPathRegisterVariable(ctxt, (const xmlChar *)name, value);
49812: desret_int(ret_val);
49813: call_tests++;
49814: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
49815: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
49816: des_xmlXPathObjectPtr(n_value, value, 2);
49817: xmlResetLastError();
49818: if (mem_base != xmlMemBlocks()) {
49819: printf("Leak of %d blocks found in xmlXPathRegisterVariable",
49820: xmlMemBlocks() - mem_base);
49821: test_ret++;
49822: printf(" %d", n_ctxt);
49823: printf(" %d", n_name);
49824: printf(" %d", n_value);
49825: printf("\n");
49826: }
49827: }
49828: }
49829: }
49830: function_tests++;
49831: #endif
49832:
49833: return(test_ret);
49834: }
49835:
49836:
49837: static int
49838: test_xmlXPathRegisterVariableLookup(void) {
49839: int test_ret = 0;
49840:
49841:
49842: /* missing type support */
49843: return(test_ret);
49844: }
49845:
49846:
49847: static int
49848: test_xmlXPathRegisterVariableNS(void) {
49849: int test_ret = 0;
49850:
49851: #if defined(LIBXML_XPATH_ENABLED)
49852: int mem_base;
49853: int ret_val;
49854: xmlXPathContextPtr ctxt; /* the XPath context */
49855: int n_ctxt;
49856: xmlChar * name; /* the variable name */
49857: int n_name;
49858: xmlChar * ns_uri; /* the variable namespace URI */
49859: int n_ns_uri;
49860: xmlXPathObjectPtr value; /* the variable value or NULL */
49861: int n_value;
49862:
49863: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
49864: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
49865: for (n_ns_uri = 0;n_ns_uri < gen_nb_const_xmlChar_ptr;n_ns_uri++) {
49866: for (n_value = 0;n_value < gen_nb_xmlXPathObjectPtr;n_value++) {
49867: mem_base = xmlMemBlocks();
49868: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
49869: name = gen_const_xmlChar_ptr(n_name, 1);
49870: ns_uri = gen_const_xmlChar_ptr(n_ns_uri, 2);
49871: value = gen_xmlXPathObjectPtr(n_value, 3);
49872:
49873: ret_val = xmlXPathRegisterVariableNS(ctxt, (const xmlChar *)name, (const xmlChar *)ns_uri, value);
49874: desret_int(ret_val);
49875: call_tests++;
49876: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
49877: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
49878: des_const_xmlChar_ptr(n_ns_uri, (const xmlChar *)ns_uri, 2);
49879: des_xmlXPathObjectPtr(n_value, value, 3);
49880: xmlResetLastError();
49881: if (mem_base != xmlMemBlocks()) {
49882: printf("Leak of %d blocks found in xmlXPathRegisterVariableNS",
49883: xmlMemBlocks() - mem_base);
49884: test_ret++;
49885: printf(" %d", n_ctxt);
49886: printf(" %d", n_name);
49887: printf(" %d", n_ns_uri);
49888: printf(" %d", n_value);
49889: printf("\n");
49890: }
49891: }
49892: }
49893: }
49894: }
49895: function_tests++;
49896: #endif
49897:
49898: return(test_ret);
49899: }
49900:
49901:
49902: static int
49903: test_xmlXPathRegisteredFuncsCleanup(void) {
49904: int test_ret = 0;
49905:
49906: #if defined(LIBXML_XPATH_ENABLED)
49907: int mem_base;
49908: xmlXPathContextPtr ctxt; /* the XPath context */
49909: int n_ctxt;
49910:
49911: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
49912: mem_base = xmlMemBlocks();
49913: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
49914:
49915: xmlXPathRegisteredFuncsCleanup(ctxt);
49916: call_tests++;
49917: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
49918: xmlResetLastError();
49919: if (mem_base != xmlMemBlocks()) {
49920: printf("Leak of %d blocks found in xmlXPathRegisteredFuncsCleanup",
49921: xmlMemBlocks() - mem_base);
49922: test_ret++;
49923: printf(" %d", n_ctxt);
49924: printf("\n");
49925: }
49926: }
49927: function_tests++;
49928: #endif
49929:
49930: return(test_ret);
49931: }
49932:
49933:
49934: static int
49935: test_xmlXPathRegisteredNsCleanup(void) {
49936: int test_ret = 0;
49937:
49938: #if defined(LIBXML_XPATH_ENABLED)
49939: int mem_base;
49940: xmlXPathContextPtr ctxt; /* the XPath context */
49941: int n_ctxt;
49942:
49943: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
49944: mem_base = xmlMemBlocks();
49945: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
49946:
49947: xmlXPathRegisteredNsCleanup(ctxt);
49948: call_tests++;
49949: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
49950: xmlResetLastError();
49951: if (mem_base != xmlMemBlocks()) {
49952: printf("Leak of %d blocks found in xmlXPathRegisteredNsCleanup",
49953: xmlMemBlocks() - mem_base);
49954: test_ret++;
49955: printf(" %d", n_ctxt);
49956: printf("\n");
49957: }
49958: }
49959: function_tests++;
49960: #endif
49961:
49962: return(test_ret);
49963: }
49964:
49965:
49966: static int
49967: test_xmlXPathRegisteredVariablesCleanup(void) {
49968: int test_ret = 0;
49969:
49970: #if defined(LIBXML_XPATH_ENABLED)
49971: int mem_base;
49972: xmlXPathContextPtr ctxt; /* the XPath context */
49973: int n_ctxt;
49974:
49975: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
49976: mem_base = xmlMemBlocks();
49977: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
49978:
49979: xmlXPathRegisteredVariablesCleanup(ctxt);
49980: call_tests++;
49981: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
49982: xmlResetLastError();
49983: if (mem_base != xmlMemBlocks()) {
49984: printf("Leak of %d blocks found in xmlXPathRegisteredVariablesCleanup",
49985: xmlMemBlocks() - mem_base);
49986: test_ret++;
49987: printf(" %d", n_ctxt);
49988: printf("\n");
49989: }
49990: }
49991: function_tests++;
49992: #endif
49993:
49994: return(test_ret);
49995: }
49996:
49997:
49998: static int
49999: test_xmlXPathRoot(void) {
50000: int test_ret = 0;
50001:
50002: #if defined(LIBXML_XPATH_ENABLED)
50003: int mem_base;
50004: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50005: int n_ctxt;
50006:
50007: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50008: mem_base = xmlMemBlocks();
50009: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50010:
50011: xmlXPathRoot(ctxt);
50012: call_tests++;
50013: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50014: xmlResetLastError();
50015: if (mem_base != xmlMemBlocks()) {
50016: printf("Leak of %d blocks found in xmlXPathRoot",
50017: xmlMemBlocks() - mem_base);
50018: test_ret++;
50019: printf(" %d", n_ctxt);
50020: printf("\n");
50021: }
50022: }
50023: function_tests++;
50024: #endif
50025:
50026: return(test_ret);
50027: }
50028:
50029:
50030: static int
50031: test_xmlXPathRoundFunction(void) {
50032: int test_ret = 0;
50033:
50034: #if defined(LIBXML_XPATH_ENABLED)
50035: int mem_base;
50036: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50037: int n_ctxt;
50038: int nargs; /* the number of arguments */
50039: int n_nargs;
50040:
50041: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50042: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50043: mem_base = xmlMemBlocks();
50044: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50045: nargs = gen_int(n_nargs, 1);
50046:
50047: xmlXPathRoundFunction(ctxt, nargs);
50048: call_tests++;
50049: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50050: des_int(n_nargs, nargs, 1);
50051: xmlResetLastError();
50052: if (mem_base != xmlMemBlocks()) {
50053: printf("Leak of %d blocks found in xmlXPathRoundFunction",
50054: xmlMemBlocks() - mem_base);
50055: test_ret++;
50056: printf(" %d", n_ctxt);
50057: printf(" %d", n_nargs);
50058: printf("\n");
50059: }
50060: }
50061: }
50062: function_tests++;
50063: #endif
50064:
50065: return(test_ret);
50066: }
50067:
50068:
50069: static int
50070: test_xmlXPathStartsWithFunction(void) {
50071: int test_ret = 0;
50072:
50073: #if defined(LIBXML_XPATH_ENABLED)
50074: int mem_base;
50075: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50076: int n_ctxt;
50077: int nargs; /* the number of arguments */
50078: int n_nargs;
50079:
50080: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50081: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50082: mem_base = xmlMemBlocks();
50083: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50084: nargs = gen_int(n_nargs, 1);
50085:
50086: xmlXPathStartsWithFunction(ctxt, nargs);
50087: call_tests++;
50088: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50089: des_int(n_nargs, nargs, 1);
50090: xmlResetLastError();
50091: if (mem_base != xmlMemBlocks()) {
50092: printf("Leak of %d blocks found in xmlXPathStartsWithFunction",
50093: xmlMemBlocks() - mem_base);
50094: test_ret++;
50095: printf(" %d", n_ctxt);
50096: printf(" %d", n_nargs);
50097: printf("\n");
50098: }
50099: }
50100: }
50101: function_tests++;
50102: #endif
50103:
50104: return(test_ret);
50105: }
50106:
50107:
50108: static int
50109: test_xmlXPathStringEvalNumber(void) {
50110: int test_ret = 0;
50111:
50112: #if defined(LIBXML_XPATH_ENABLED)
50113: int mem_base;
50114: double ret_val;
50115: xmlChar * str; /* A string to scan */
50116: int n_str;
50117:
50118: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
50119: mem_base = xmlMemBlocks();
50120: str = gen_const_xmlChar_ptr(n_str, 0);
50121:
50122: ret_val = xmlXPathStringEvalNumber((const xmlChar *)str);
50123: desret_double(ret_val);
50124: call_tests++;
50125: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
50126: xmlResetLastError();
50127: if (mem_base != xmlMemBlocks()) {
50128: printf("Leak of %d blocks found in xmlXPathStringEvalNumber",
50129: xmlMemBlocks() - mem_base);
50130: test_ret++;
50131: printf(" %d", n_str);
50132: printf("\n");
50133: }
50134: }
50135: function_tests++;
50136: #endif
50137:
50138: return(test_ret);
50139: }
50140:
50141:
50142: static int
50143: test_xmlXPathStringFunction(void) {
50144: int test_ret = 0;
50145:
50146: #if defined(LIBXML_XPATH_ENABLED)
50147: int mem_base;
50148: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50149: int n_ctxt;
50150: int nargs; /* the number of arguments */
50151: int n_nargs;
50152:
50153: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50154: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50155: mem_base = xmlMemBlocks();
50156: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50157: nargs = gen_int(n_nargs, 1);
50158:
50159: xmlXPathStringFunction(ctxt, nargs);
50160: call_tests++;
50161: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50162: des_int(n_nargs, nargs, 1);
50163: xmlResetLastError();
50164: if (mem_base != xmlMemBlocks()) {
50165: printf("Leak of %d blocks found in xmlXPathStringFunction",
50166: xmlMemBlocks() - mem_base);
50167: test_ret++;
50168: printf(" %d", n_ctxt);
50169: printf(" %d", n_nargs);
50170: printf("\n");
50171: }
50172: }
50173: }
50174: function_tests++;
50175: #endif
50176:
50177: return(test_ret);
50178: }
50179:
50180:
50181: static int
50182: test_xmlXPathStringLengthFunction(void) {
50183: int test_ret = 0;
50184:
50185: #if defined(LIBXML_XPATH_ENABLED)
50186: int mem_base;
50187: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50188: int n_ctxt;
50189: int nargs; /* the number of arguments */
50190: int n_nargs;
50191:
50192: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50193: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50194: mem_base = xmlMemBlocks();
50195: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50196: nargs = gen_int(n_nargs, 1);
50197:
50198: xmlXPathStringLengthFunction(ctxt, nargs);
50199: call_tests++;
50200: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50201: des_int(n_nargs, nargs, 1);
50202: xmlResetLastError();
50203: if (mem_base != xmlMemBlocks()) {
50204: printf("Leak of %d blocks found in xmlXPathStringLengthFunction",
50205: xmlMemBlocks() - mem_base);
50206: test_ret++;
50207: printf(" %d", n_ctxt);
50208: printf(" %d", n_nargs);
50209: printf("\n");
50210: }
50211: }
50212: }
50213: function_tests++;
50214: #endif
50215:
50216: return(test_ret);
50217: }
50218:
50219:
50220: static int
50221: test_xmlXPathSubValues(void) {
50222: int test_ret = 0;
50223:
50224: #if defined(LIBXML_XPATH_ENABLED)
50225: int mem_base;
50226: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50227: int n_ctxt;
50228:
50229: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50230: mem_base = xmlMemBlocks();
50231: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50232:
50233: xmlXPathSubValues(ctxt);
50234: call_tests++;
50235: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50236: xmlResetLastError();
50237: if (mem_base != xmlMemBlocks()) {
50238: printf("Leak of %d blocks found in xmlXPathSubValues",
50239: xmlMemBlocks() - mem_base);
50240: test_ret++;
50241: printf(" %d", n_ctxt);
50242: printf("\n");
50243: }
50244: }
50245: function_tests++;
50246: #endif
50247:
50248: return(test_ret);
50249: }
50250:
50251:
50252: static int
50253: test_xmlXPathSubstringAfterFunction(void) {
50254: int test_ret = 0;
50255:
50256: #if defined(LIBXML_XPATH_ENABLED)
50257: int mem_base;
50258: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50259: int n_ctxt;
50260: int nargs; /* the number of arguments */
50261: int n_nargs;
50262:
50263: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50264: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50265: mem_base = xmlMemBlocks();
50266: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50267: nargs = gen_int(n_nargs, 1);
50268:
50269: xmlXPathSubstringAfterFunction(ctxt, nargs);
50270: call_tests++;
50271: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50272: des_int(n_nargs, nargs, 1);
50273: xmlResetLastError();
50274: if (mem_base != xmlMemBlocks()) {
50275: printf("Leak of %d blocks found in xmlXPathSubstringAfterFunction",
50276: xmlMemBlocks() - mem_base);
50277: test_ret++;
50278: printf(" %d", n_ctxt);
50279: printf(" %d", n_nargs);
50280: printf("\n");
50281: }
50282: }
50283: }
50284: function_tests++;
50285: #endif
50286:
50287: return(test_ret);
50288: }
50289:
50290:
50291: static int
50292: test_xmlXPathSubstringBeforeFunction(void) {
50293: int test_ret = 0;
50294:
50295: #if defined(LIBXML_XPATH_ENABLED)
50296: int mem_base;
50297: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50298: int n_ctxt;
50299: int nargs; /* the number of arguments */
50300: int n_nargs;
50301:
50302: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50303: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50304: mem_base = xmlMemBlocks();
50305: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50306: nargs = gen_int(n_nargs, 1);
50307:
50308: xmlXPathSubstringBeforeFunction(ctxt, nargs);
50309: call_tests++;
50310: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50311: des_int(n_nargs, nargs, 1);
50312: xmlResetLastError();
50313: if (mem_base != xmlMemBlocks()) {
50314: printf("Leak of %d blocks found in xmlXPathSubstringBeforeFunction",
50315: xmlMemBlocks() - mem_base);
50316: test_ret++;
50317: printf(" %d", n_ctxt);
50318: printf(" %d", n_nargs);
50319: printf("\n");
50320: }
50321: }
50322: }
50323: function_tests++;
50324: #endif
50325:
50326: return(test_ret);
50327: }
50328:
50329:
50330: static int
50331: test_xmlXPathSubstringFunction(void) {
50332: int test_ret = 0;
50333:
50334: #if defined(LIBXML_XPATH_ENABLED)
50335: int mem_base;
50336: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50337: int n_ctxt;
50338: int nargs; /* the number of arguments */
50339: int n_nargs;
50340:
50341: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50342: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50343: mem_base = xmlMemBlocks();
50344: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50345: nargs = gen_int(n_nargs, 1);
50346:
50347: xmlXPathSubstringFunction(ctxt, nargs);
50348: call_tests++;
50349: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50350: des_int(n_nargs, nargs, 1);
50351: xmlResetLastError();
50352: if (mem_base != xmlMemBlocks()) {
50353: printf("Leak of %d blocks found in xmlXPathSubstringFunction",
50354: xmlMemBlocks() - mem_base);
50355: test_ret++;
50356: printf(" %d", n_ctxt);
50357: printf(" %d", n_nargs);
50358: printf("\n");
50359: }
50360: }
50361: }
50362: function_tests++;
50363: #endif
50364:
50365: return(test_ret);
50366: }
50367:
50368:
50369: static int
50370: test_xmlXPathSumFunction(void) {
50371: int test_ret = 0;
50372:
50373: #if defined(LIBXML_XPATH_ENABLED)
50374: int mem_base;
50375: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50376: int n_ctxt;
50377: int nargs; /* the number of arguments */
50378: int n_nargs;
50379:
50380: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50381: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50382: mem_base = xmlMemBlocks();
50383: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50384: nargs = gen_int(n_nargs, 1);
50385:
50386: xmlXPathSumFunction(ctxt, nargs);
50387: call_tests++;
50388: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50389: des_int(n_nargs, nargs, 1);
50390: xmlResetLastError();
50391: if (mem_base != xmlMemBlocks()) {
50392: printf("Leak of %d blocks found in xmlXPathSumFunction",
50393: xmlMemBlocks() - mem_base);
50394: test_ret++;
50395: printf(" %d", n_ctxt);
50396: printf(" %d", n_nargs);
50397: printf("\n");
50398: }
50399: }
50400: }
50401: function_tests++;
50402: #endif
50403:
50404: return(test_ret);
50405: }
50406:
50407:
50408: static int
50409: test_xmlXPathTrailing(void) {
50410: int test_ret = 0;
50411:
50412: #if defined(LIBXML_XPATH_ENABLED)
50413: int mem_base;
50414: xmlNodeSetPtr ret_val;
50415: xmlNodeSetPtr nodes1; /* a node-set */
50416: int n_nodes1;
50417: xmlNodeSetPtr nodes2; /* a node-set */
50418: int n_nodes2;
50419:
50420: for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
50421: for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
50422: mem_base = xmlMemBlocks();
50423: nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
50424: nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
50425:
50426: ret_val = xmlXPathTrailing(nodes1, nodes2);
50427: desret_xmlNodeSetPtr(ret_val);
50428: call_tests++;
50429: des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
50430: des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
50431: xmlResetLastError();
50432: if (mem_base != xmlMemBlocks()) {
50433: printf("Leak of %d blocks found in xmlXPathTrailing",
50434: xmlMemBlocks() - mem_base);
50435: test_ret++;
50436: printf(" %d", n_nodes1);
50437: printf(" %d", n_nodes2);
50438: printf("\n");
50439: }
50440: }
50441: }
50442: function_tests++;
50443: #endif
50444:
50445: return(test_ret);
50446: }
50447:
50448:
50449: static int
50450: test_xmlXPathTrailingSorted(void) {
50451: int test_ret = 0;
50452:
50453: #if defined(LIBXML_XPATH_ENABLED)
50454: int mem_base;
50455: xmlNodeSetPtr ret_val;
50456: xmlNodeSetPtr nodes1; /* a node-set, sorted by document order */
50457: int n_nodes1;
50458: xmlNodeSetPtr nodes2; /* a node-set, sorted by document order */
50459: int n_nodes2;
50460:
50461: for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
50462: for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
50463: mem_base = xmlMemBlocks();
50464: nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
50465: nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
50466:
50467: ret_val = xmlXPathTrailingSorted(nodes1, nodes2);
50468: desret_xmlNodeSetPtr(ret_val);
50469: call_tests++;
50470: des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
50471: des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
50472: xmlResetLastError();
50473: if (mem_base != xmlMemBlocks()) {
50474: printf("Leak of %d blocks found in xmlXPathTrailingSorted",
50475: xmlMemBlocks() - mem_base);
50476: test_ret++;
50477: printf(" %d", n_nodes1);
50478: printf(" %d", n_nodes2);
50479: printf("\n");
50480: }
50481: }
50482: }
50483: function_tests++;
50484: #endif
50485:
50486: return(test_ret);
50487: }
50488:
50489:
50490: static int
50491: test_xmlXPathTranslateFunction(void) {
50492: int test_ret = 0;
50493:
50494: #if defined(LIBXML_XPATH_ENABLED)
50495: int mem_base;
50496: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50497: int n_ctxt;
50498: int nargs; /* the number of arguments */
50499: int n_nargs;
50500:
50501: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50502: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50503: mem_base = xmlMemBlocks();
50504: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50505: nargs = gen_int(n_nargs, 1);
50506:
50507: xmlXPathTranslateFunction(ctxt, nargs);
50508: call_tests++;
50509: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50510: des_int(n_nargs, nargs, 1);
50511: xmlResetLastError();
50512: if (mem_base != xmlMemBlocks()) {
50513: printf("Leak of %d blocks found in xmlXPathTranslateFunction",
50514: xmlMemBlocks() - mem_base);
50515: test_ret++;
50516: printf(" %d", n_ctxt);
50517: printf(" %d", n_nargs);
50518: printf("\n");
50519: }
50520: }
50521: }
50522: function_tests++;
50523: #endif
50524:
50525: return(test_ret);
50526: }
50527:
50528:
50529: static int
50530: test_xmlXPathTrueFunction(void) {
50531: int test_ret = 0;
50532:
50533: #if defined(LIBXML_XPATH_ENABLED)
50534: int mem_base;
50535: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50536: int n_ctxt;
50537: int nargs; /* the number of arguments */
50538: int n_nargs;
50539:
50540: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50541: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50542: mem_base = xmlMemBlocks();
50543: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50544: nargs = gen_int(n_nargs, 1);
50545:
50546: xmlXPathTrueFunction(ctxt, nargs);
50547: call_tests++;
50548: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50549: des_int(n_nargs, nargs, 1);
50550: xmlResetLastError();
50551: if (mem_base != xmlMemBlocks()) {
50552: printf("Leak of %d blocks found in xmlXPathTrueFunction",
50553: xmlMemBlocks() - mem_base);
50554: test_ret++;
50555: printf(" %d", n_ctxt);
50556: printf(" %d", n_nargs);
50557: printf("\n");
50558: }
50559: }
50560: }
50561: function_tests++;
50562: #endif
50563:
50564: return(test_ret);
50565: }
50566:
50567:
50568: static int
50569: test_xmlXPathValueFlipSign(void) {
50570: int test_ret = 0;
50571:
50572: #if defined(LIBXML_XPATH_ENABLED)
50573: int mem_base;
50574: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50575: int n_ctxt;
50576:
50577: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50578: mem_base = xmlMemBlocks();
50579: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50580:
50581: xmlXPathValueFlipSign(ctxt);
50582: call_tests++;
50583: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50584: xmlResetLastError();
50585: if (mem_base != xmlMemBlocks()) {
50586: printf("Leak of %d blocks found in xmlXPathValueFlipSign",
50587: xmlMemBlocks() - mem_base);
50588: test_ret++;
50589: printf(" %d", n_ctxt);
50590: printf("\n");
50591: }
50592: }
50593: function_tests++;
50594: #endif
50595:
50596: return(test_ret);
50597: }
50598:
50599:
50600: static int
50601: test_xmlXPathVariableLookup(void) {
50602: int test_ret = 0;
50603:
50604: #if defined(LIBXML_XPATH_ENABLED)
50605: int mem_base;
50606: xmlXPathObjectPtr ret_val;
50607: xmlXPathContextPtr ctxt; /* the XPath context */
50608: int n_ctxt;
50609: xmlChar * name; /* the variable name */
50610: int n_name;
50611:
50612: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
50613: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
50614: mem_base = xmlMemBlocks();
50615: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
50616: name = gen_const_xmlChar_ptr(n_name, 1);
50617:
50618: ret_val = xmlXPathVariableLookup(ctxt, (const xmlChar *)name);
50619: desret_xmlXPathObjectPtr(ret_val);
50620: call_tests++;
50621: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
50622: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
50623: xmlResetLastError();
50624: if (mem_base != xmlMemBlocks()) {
50625: printf("Leak of %d blocks found in xmlXPathVariableLookup",
50626: xmlMemBlocks() - mem_base);
50627: test_ret++;
50628: printf(" %d", n_ctxt);
50629: printf(" %d", n_name);
50630: printf("\n");
50631: }
50632: }
50633: }
50634: function_tests++;
50635: #endif
50636:
50637: return(test_ret);
50638: }
50639:
50640:
50641: static int
50642: test_xmlXPathVariableLookupNS(void) {
50643: int test_ret = 0;
50644:
50645: #if defined(LIBXML_XPATH_ENABLED)
50646: int mem_base;
50647: xmlXPathObjectPtr ret_val;
50648: xmlXPathContextPtr ctxt; /* the XPath context */
50649: int n_ctxt;
50650: xmlChar * name; /* the variable name */
50651: int n_name;
50652: xmlChar * ns_uri; /* the variable namespace URI */
50653: int n_ns_uri;
50654:
50655: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
50656: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
50657: for (n_ns_uri = 0;n_ns_uri < gen_nb_const_xmlChar_ptr;n_ns_uri++) {
50658: mem_base = xmlMemBlocks();
50659: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
50660: name = gen_const_xmlChar_ptr(n_name, 1);
50661: ns_uri = gen_const_xmlChar_ptr(n_ns_uri, 2);
50662:
50663: ret_val = xmlXPathVariableLookupNS(ctxt, (const xmlChar *)name, (const xmlChar *)ns_uri);
50664: desret_xmlXPathObjectPtr(ret_val);
50665: call_tests++;
50666: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
50667: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
50668: des_const_xmlChar_ptr(n_ns_uri, (const xmlChar *)ns_uri, 2);
50669: xmlResetLastError();
50670: if (mem_base != xmlMemBlocks()) {
50671: printf("Leak of %d blocks found in xmlXPathVariableLookupNS",
50672: xmlMemBlocks() - mem_base);
50673: test_ret++;
50674: printf(" %d", n_ctxt);
50675: printf(" %d", n_name);
50676: printf(" %d", n_ns_uri);
50677: printf("\n");
50678: }
50679: }
50680: }
50681: }
50682: function_tests++;
50683: #endif
50684:
50685: return(test_ret);
50686: }
50687:
50688:
50689: static int
50690: test_xmlXPathWrapCString(void) {
50691: int test_ret = 0;
50692:
50693: #if defined(LIBXML_XPATH_ENABLED)
50694: int mem_base;
50695: xmlXPathObjectPtr ret_val;
50696: char * val; /* the char * value */
50697: int n_val;
50698:
50699: for (n_val = 0;n_val < gen_nb_char_ptr;n_val++) {
50700: mem_base = xmlMemBlocks();
50701: val = gen_char_ptr(n_val, 0);
50702:
50703: ret_val = xmlXPathWrapCString(val);
50704: desret_xmlXPathObjectPtr(ret_val);
50705: call_tests++;
50706: des_char_ptr(n_val, val, 0);
50707: xmlResetLastError();
50708: if (mem_base != xmlMemBlocks()) {
50709: printf("Leak of %d blocks found in xmlXPathWrapCString",
50710: xmlMemBlocks() - mem_base);
50711: test_ret++;
50712: printf(" %d", n_val);
50713: printf("\n");
50714: }
50715: }
50716: function_tests++;
50717: #endif
50718:
50719: return(test_ret);
50720: }
50721:
50722:
50723: static int
50724: test_xmlXPathWrapExternal(void) {
50725: int test_ret = 0;
50726:
50727: #if defined(LIBXML_XPATH_ENABLED)
50728: int mem_base;
50729: xmlXPathObjectPtr ret_val;
50730: void * val; /* the user data */
50731: int n_val;
50732:
50733: for (n_val = 0;n_val < gen_nb_void_ptr;n_val++) {
50734: mem_base = xmlMemBlocks();
50735: val = gen_void_ptr(n_val, 0);
50736:
50737: ret_val = xmlXPathWrapExternal(val);
50738: desret_xmlXPathObjectPtr(ret_val);
50739: call_tests++;
50740: des_void_ptr(n_val, val, 0);
50741: xmlResetLastError();
50742: if (mem_base != xmlMemBlocks()) {
50743: printf("Leak of %d blocks found in xmlXPathWrapExternal",
50744: xmlMemBlocks() - mem_base);
50745: test_ret++;
50746: printf(" %d", n_val);
50747: printf("\n");
50748: }
50749: }
50750: function_tests++;
50751: #endif
50752:
50753: return(test_ret);
50754: }
50755:
50756:
50757: static int
50758: test_xmlXPathWrapNodeSet(void) {
50759: int test_ret = 0;
50760:
50761: #if defined(LIBXML_XPATH_ENABLED)
50762: int mem_base;
50763: xmlXPathObjectPtr ret_val;
50764: xmlNodeSetPtr val; /* the NodePtr value */
50765: int n_val;
50766:
50767: for (n_val = 0;n_val < gen_nb_xmlNodeSetPtr;n_val++) {
50768: mem_base = xmlMemBlocks();
50769: val = gen_xmlNodeSetPtr(n_val, 0);
50770:
50771: ret_val = xmlXPathWrapNodeSet(val);
50772: desret_xmlXPathObjectPtr(ret_val);
50773: call_tests++;
50774: des_xmlNodeSetPtr(n_val, val, 0);
50775: xmlResetLastError();
50776: if (mem_base != xmlMemBlocks()) {
50777: printf("Leak of %d blocks found in xmlXPathWrapNodeSet",
50778: xmlMemBlocks() - mem_base);
50779: test_ret++;
50780: printf(" %d", n_val);
50781: printf("\n");
50782: }
50783: }
50784: function_tests++;
50785: #endif
50786:
50787: return(test_ret);
50788: }
50789:
50790:
50791: static int
50792: test_xmlXPatherror(void) {
50793: int test_ret = 0;
50794:
50795: #if defined(LIBXML_XPATH_ENABLED)
50796: int mem_base;
50797: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50798: int n_ctxt;
50799: const char * file; /* the file name */
50800: int n_file;
50801: int line; /* the line number */
50802: int n_line;
50803: int no; /* the error number */
50804: int n_no;
50805:
50806: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50807: for (n_file = 0;n_file < gen_nb_filepath;n_file++) {
50808: for (n_line = 0;n_line < gen_nb_int;n_line++) {
50809: for (n_no = 0;n_no < gen_nb_int;n_no++) {
50810: mem_base = xmlMemBlocks();
50811: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50812: file = gen_filepath(n_file, 1);
50813: line = gen_int(n_line, 2);
50814: no = gen_int(n_no, 3);
50815:
50816: xmlXPatherror(ctxt, file, line, no);
50817: call_tests++;
50818: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50819: des_filepath(n_file, file, 1);
50820: des_int(n_line, line, 2);
50821: des_int(n_no, no, 3);
50822: xmlResetLastError();
50823: if (mem_base != xmlMemBlocks()) {
50824: printf("Leak of %d blocks found in xmlXPatherror",
50825: xmlMemBlocks() - mem_base);
50826: test_ret++;
50827: printf(" %d", n_ctxt);
50828: printf(" %d", n_file);
50829: printf(" %d", n_line);
50830: printf(" %d", n_no);
50831: printf("\n");
50832: }
50833: }
50834: }
50835: }
50836: }
50837: function_tests++;
50838: #endif
50839:
50840: return(test_ret);
50841: }
50842:
50843: static int
50844: test_xpathInternals(void) {
50845: int test_ret = 0;
50846:
50847: if (quiet == 0) printf("Testing xpathInternals : 106 of 117 functions ...\n");
50848: test_ret += test_valuePop();
50849: test_ret += test_valuePush();
50850: test_ret += test_xmlXPathAddValues();
50851: test_ret += test_xmlXPathBooleanFunction();
50852: test_ret += test_xmlXPathCeilingFunction();
50853: test_ret += test_xmlXPathCompareValues();
50854: test_ret += test_xmlXPathConcatFunction();
50855: test_ret += test_xmlXPathContainsFunction();
50856: test_ret += test_xmlXPathCountFunction();
50857: test_ret += test_xmlXPathDebugDumpCompExpr();
50858: test_ret += test_xmlXPathDebugDumpObject();
50859: test_ret += test_xmlXPathDifference();
50860: test_ret += test_xmlXPathDistinct();
50861: test_ret += test_xmlXPathDistinctSorted();
50862: test_ret += test_xmlXPathDivValues();
50863: test_ret += test_xmlXPathEqualValues();
50864: test_ret += test_xmlXPathErr();
50865: test_ret += test_xmlXPathEvalExpr();
50866: test_ret += test_xmlXPathEvaluatePredicateResult();
50867: test_ret += test_xmlXPathFalseFunction();
50868: test_ret += test_xmlXPathFloorFunction();
50869: test_ret += test_xmlXPathFunctionLookup();
50870: test_ret += test_xmlXPathFunctionLookupNS();
50871: test_ret += test_xmlXPathHasSameNodes();
50872: test_ret += test_xmlXPathIdFunction();
50873: test_ret += test_xmlXPathIntersection();
50874: test_ret += test_xmlXPathIsNodeType();
50875: test_ret += test_xmlXPathLangFunction();
50876: test_ret += test_xmlXPathLastFunction();
50877: test_ret += test_xmlXPathLeading();
50878: test_ret += test_xmlXPathLeadingSorted();
50879: test_ret += test_xmlXPathLocalNameFunction();
50880: test_ret += test_xmlXPathModValues();
50881: test_ret += test_xmlXPathMultValues();
50882: test_ret += test_xmlXPathNamespaceURIFunction();
50883: test_ret += test_xmlXPathNewBoolean();
50884: test_ret += test_xmlXPathNewCString();
50885: test_ret += test_xmlXPathNewFloat();
50886: test_ret += test_xmlXPathNewNodeSet();
50887: test_ret += test_xmlXPathNewNodeSetList();
50888: test_ret += test_xmlXPathNewParserContext();
50889: test_ret += test_xmlXPathNewString();
50890: test_ret += test_xmlXPathNextAncestor();
50891: test_ret += test_xmlXPathNextAncestorOrSelf();
50892: test_ret += test_xmlXPathNextAttribute();
50893: test_ret += test_xmlXPathNextChild();
50894: test_ret += test_xmlXPathNextDescendant();
50895: test_ret += test_xmlXPathNextDescendantOrSelf();
50896: test_ret += test_xmlXPathNextFollowing();
50897: test_ret += test_xmlXPathNextFollowingSibling();
50898: test_ret += test_xmlXPathNextNamespace();
50899: test_ret += test_xmlXPathNextParent();
50900: test_ret += test_xmlXPathNextPreceding();
50901: test_ret += test_xmlXPathNextPrecedingSibling();
50902: test_ret += test_xmlXPathNextSelf();
50903: test_ret += test_xmlXPathNodeLeading();
50904: test_ret += test_xmlXPathNodeLeadingSorted();
50905: test_ret += test_xmlXPathNodeSetAdd();
50906: test_ret += test_xmlXPathNodeSetAddNs();
50907: test_ret += test_xmlXPathNodeSetAddUnique();
50908: test_ret += test_xmlXPathNodeSetContains();
50909: test_ret += test_xmlXPathNodeSetDel();
50910: test_ret += test_xmlXPathNodeSetMerge();
50911: test_ret += test_xmlXPathNodeSetRemove();
50912: test_ret += test_xmlXPathNodeSetSort();
50913: test_ret += test_xmlXPathNodeTrailing();
50914: test_ret += test_xmlXPathNodeTrailingSorted();
50915: test_ret += test_xmlXPathNormalizeFunction();
50916: test_ret += test_xmlXPathNotEqualValues();
50917: test_ret += test_xmlXPathNotFunction();
50918: test_ret += test_xmlXPathNsLookup();
50919: test_ret += test_xmlXPathNumberFunction();
50920: test_ret += test_xmlXPathParseNCName();
50921: test_ret += test_xmlXPathParseName();
50922: test_ret += test_xmlXPathPopBoolean();
50923: test_ret += test_xmlXPathPopExternal();
50924: test_ret += test_xmlXPathPopNodeSet();
50925: test_ret += test_xmlXPathPopNumber();
50926: test_ret += test_xmlXPathPopString();
50927: test_ret += test_xmlXPathPositionFunction();
50928: test_ret += test_xmlXPathRegisterAllFunctions();
50929: test_ret += test_xmlXPathRegisterFunc();
50930: test_ret += test_xmlXPathRegisterFuncLookup();
50931: test_ret += test_xmlXPathRegisterFuncNS();
50932: test_ret += test_xmlXPathRegisterNs();
50933: test_ret += test_xmlXPathRegisterVariable();
50934: test_ret += test_xmlXPathRegisterVariableLookup();
50935: test_ret += test_xmlXPathRegisterVariableNS();
50936: test_ret += test_xmlXPathRegisteredFuncsCleanup();
50937: test_ret += test_xmlXPathRegisteredNsCleanup();
50938: test_ret += test_xmlXPathRegisteredVariablesCleanup();
50939: test_ret += test_xmlXPathRoot();
50940: test_ret += test_xmlXPathRoundFunction();
50941: test_ret += test_xmlXPathStartsWithFunction();
50942: test_ret += test_xmlXPathStringEvalNumber();
50943: test_ret += test_xmlXPathStringFunction();
50944: test_ret += test_xmlXPathStringLengthFunction();
50945: test_ret += test_xmlXPathSubValues();
50946: test_ret += test_xmlXPathSubstringAfterFunction();
50947: test_ret += test_xmlXPathSubstringBeforeFunction();
50948: test_ret += test_xmlXPathSubstringFunction();
50949: test_ret += test_xmlXPathSumFunction();
50950: test_ret += test_xmlXPathTrailing();
50951: test_ret += test_xmlXPathTrailingSorted();
50952: test_ret += test_xmlXPathTranslateFunction();
50953: test_ret += test_xmlXPathTrueFunction();
50954: test_ret += test_xmlXPathValueFlipSign();
50955: test_ret += test_xmlXPathVariableLookup();
50956: test_ret += test_xmlXPathVariableLookupNS();
50957: test_ret += test_xmlXPathWrapCString();
50958: test_ret += test_xmlXPathWrapExternal();
50959: test_ret += test_xmlXPathWrapNodeSet();
50960: test_ret += test_xmlXPatherror();
50961:
50962: if (test_ret != 0)
50963: printf("Module xpathInternals: %d errors\n", test_ret);
50964: return(test_ret);
50965: }
50966:
50967: static int
50968: test_xmlXPtrBuildNodeList(void) {
50969: int test_ret = 0;
50970:
50971: #if defined(LIBXML_XPTR_ENABLED)
50972: int mem_base;
50973: xmlNodePtr ret_val;
50974: xmlXPathObjectPtr obj; /* the XPointer result from the evaluation. */
50975: int n_obj;
50976:
50977: for (n_obj = 0;n_obj < gen_nb_xmlXPathObjectPtr;n_obj++) {
50978: mem_base = xmlMemBlocks();
50979: obj = gen_xmlXPathObjectPtr(n_obj, 0);
50980:
50981: ret_val = xmlXPtrBuildNodeList(obj);
50982: desret_xmlNodePtr(ret_val);
50983: call_tests++;
50984: des_xmlXPathObjectPtr(n_obj, obj, 0);
50985: xmlResetLastError();
50986: if (mem_base != xmlMemBlocks()) {
50987: printf("Leak of %d blocks found in xmlXPtrBuildNodeList",
50988: xmlMemBlocks() - mem_base);
50989: test_ret++;
50990: printf(" %d", n_obj);
50991: printf("\n");
50992: }
50993: }
50994: function_tests++;
50995: #endif
50996:
50997: return(test_ret);
50998: }
50999:
51000:
51001: static int
51002: test_xmlXPtrEval(void) {
51003: int test_ret = 0;
51004:
51005: #if defined(LIBXML_XPTR_ENABLED)
51006: int mem_base;
51007: xmlXPathObjectPtr ret_val;
51008: xmlChar * str; /* the XPointer expression */
51009: int n_str;
51010: xmlXPathContextPtr ctx; /* the XPointer context */
51011: int n_ctx;
51012:
51013: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
51014: for (n_ctx = 0;n_ctx < gen_nb_xmlXPathContextPtr;n_ctx++) {
51015: mem_base = xmlMemBlocks();
51016: str = gen_const_xmlChar_ptr(n_str, 0);
51017: ctx = gen_xmlXPathContextPtr(n_ctx, 1);
51018:
51019: ret_val = xmlXPtrEval((const xmlChar *)str, ctx);
51020: desret_xmlXPathObjectPtr(ret_val);
51021: call_tests++;
51022: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
51023: des_xmlXPathContextPtr(n_ctx, ctx, 1);
51024: xmlResetLastError();
51025: if (mem_base != xmlMemBlocks()) {
51026: printf("Leak of %d blocks found in xmlXPtrEval",
51027: xmlMemBlocks() - mem_base);
51028: test_ret++;
51029: printf(" %d", n_str);
51030: printf(" %d", n_ctx);
51031: printf("\n");
51032: }
51033: }
51034: }
51035: function_tests++;
51036: #endif
51037:
51038: return(test_ret);
51039: }
51040:
51041:
51042: static int
51043: test_xmlXPtrEvalRangePredicate(void) {
51044: int test_ret = 0;
51045:
51046: #if defined(LIBXML_XPTR_ENABLED)
51047: int mem_base;
51048: xmlXPathParserContextPtr ctxt; /* the XPointer Parser context */
51049: int n_ctxt;
51050:
51051: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
51052: mem_base = xmlMemBlocks();
51053: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
51054:
51055: xmlXPtrEvalRangePredicate(ctxt);
51056: call_tests++;
51057: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
51058: xmlResetLastError();
51059: if (mem_base != xmlMemBlocks()) {
51060: printf("Leak of %d blocks found in xmlXPtrEvalRangePredicate",
51061: xmlMemBlocks() - mem_base);
51062: test_ret++;
51063: printf(" %d", n_ctxt);
51064: printf("\n");
51065: }
51066: }
51067: function_tests++;
51068: #endif
51069:
51070: return(test_ret);
51071: }
51072:
51073: #ifdef LIBXML_XPTR_ENABLED
51074:
51075: #define gen_nb_xmlLocationSetPtr 1
51076: static xmlLocationSetPtr gen_xmlLocationSetPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
51077: return(NULL);
51078: }
51079: static void des_xmlLocationSetPtr(int no ATTRIBUTE_UNUSED, xmlLocationSetPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
51080: }
51081: #endif
51082:
51083:
51084: static int
51085: test_xmlXPtrLocationSetAdd(void) {
51086: int test_ret = 0;
51087:
51088: #if defined(LIBXML_XPTR_ENABLED)
51089: int mem_base;
51090: xmlLocationSetPtr cur; /* the initial range set */
51091: int n_cur;
51092: xmlXPathObjectPtr val; /* a new xmlXPathObjectPtr */
51093: int n_val;
51094:
51095: for (n_cur = 0;n_cur < gen_nb_xmlLocationSetPtr;n_cur++) {
51096: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
51097: mem_base = xmlMemBlocks();
51098: cur = gen_xmlLocationSetPtr(n_cur, 0);
51099: val = gen_xmlXPathObjectPtr(n_val, 1);
51100:
51101: xmlXPtrLocationSetAdd(cur, val);
51102: call_tests++;
51103: des_xmlLocationSetPtr(n_cur, cur, 0);
51104: des_xmlXPathObjectPtr(n_val, val, 1);
51105: xmlResetLastError();
51106: if (mem_base != xmlMemBlocks()) {
51107: printf("Leak of %d blocks found in xmlXPtrLocationSetAdd",
51108: xmlMemBlocks() - mem_base);
51109: test_ret++;
51110: printf(" %d", n_cur);
51111: printf(" %d", n_val);
51112: printf("\n");
51113: }
51114: }
51115: }
51116: function_tests++;
51117: #endif
51118:
51119: return(test_ret);
51120: }
51121:
51122:
51123: static int
51124: test_xmlXPtrLocationSetCreate(void) {
51125: int test_ret = 0;
51126:
51127:
51128: /* missing type support */
51129: return(test_ret);
51130: }
51131:
51132:
51133: static int
51134: test_xmlXPtrLocationSetDel(void) {
51135: int test_ret = 0;
51136:
51137: #if defined(LIBXML_XPTR_ENABLED)
51138: int mem_base;
51139: xmlLocationSetPtr cur; /* the initial range set */
51140: int n_cur;
51141: xmlXPathObjectPtr val; /* an xmlXPathObjectPtr */
51142: int n_val;
51143:
51144: for (n_cur = 0;n_cur < gen_nb_xmlLocationSetPtr;n_cur++) {
51145: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
51146: mem_base = xmlMemBlocks();
51147: cur = gen_xmlLocationSetPtr(n_cur, 0);
51148: val = gen_xmlXPathObjectPtr(n_val, 1);
51149:
51150: xmlXPtrLocationSetDel(cur, val);
51151: call_tests++;
51152: des_xmlLocationSetPtr(n_cur, cur, 0);
51153: des_xmlXPathObjectPtr(n_val, val, 1);
51154: xmlResetLastError();
51155: if (mem_base != xmlMemBlocks()) {
51156: printf("Leak of %d blocks found in xmlXPtrLocationSetDel",
51157: xmlMemBlocks() - mem_base);
51158: test_ret++;
51159: printf(" %d", n_cur);
51160: printf(" %d", n_val);
51161: printf("\n");
51162: }
51163: }
51164: }
51165: function_tests++;
51166: #endif
51167:
51168: return(test_ret);
51169: }
51170:
51171:
51172: static int
51173: test_xmlXPtrLocationSetMerge(void) {
51174: int test_ret = 0;
51175:
51176:
51177: /* missing type support */
51178: return(test_ret);
51179: }
51180:
51181:
51182: static int
51183: test_xmlXPtrLocationSetRemove(void) {
51184: int test_ret = 0;
51185:
51186: #if defined(LIBXML_XPTR_ENABLED)
51187: int mem_base;
51188: xmlLocationSetPtr cur; /* the initial range set */
51189: int n_cur;
51190: int val; /* the index to remove */
51191: int n_val;
51192:
51193: for (n_cur = 0;n_cur < gen_nb_xmlLocationSetPtr;n_cur++) {
51194: for (n_val = 0;n_val < gen_nb_int;n_val++) {
51195: mem_base = xmlMemBlocks();
51196: cur = gen_xmlLocationSetPtr(n_cur, 0);
51197: val = gen_int(n_val, 1);
51198:
51199: xmlXPtrLocationSetRemove(cur, val);
51200: call_tests++;
51201: des_xmlLocationSetPtr(n_cur, cur, 0);
51202: des_int(n_val, val, 1);
51203: xmlResetLastError();
51204: if (mem_base != xmlMemBlocks()) {
51205: printf("Leak of %d blocks found in xmlXPtrLocationSetRemove",
51206: xmlMemBlocks() - mem_base);
51207: test_ret++;
51208: printf(" %d", n_cur);
51209: printf(" %d", n_val);
51210: printf("\n");
51211: }
51212: }
51213: }
51214: function_tests++;
51215: #endif
51216:
51217: return(test_ret);
51218: }
51219:
51220:
51221: static int
51222: test_xmlXPtrNewCollapsedRange(void) {
51223: int test_ret = 0;
51224:
51225: #if defined(LIBXML_XPTR_ENABLED)
51226: int mem_base;
51227: xmlXPathObjectPtr ret_val;
51228: xmlNodePtr start; /* the starting and ending node */
51229: int n_start;
51230:
51231: for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
51232: mem_base = xmlMemBlocks();
51233: start = gen_xmlNodePtr(n_start, 0);
51234:
51235: ret_val = xmlXPtrNewCollapsedRange(start);
51236: desret_xmlXPathObjectPtr(ret_val);
51237: call_tests++;
51238: des_xmlNodePtr(n_start, start, 0);
51239: xmlResetLastError();
51240: if (mem_base != xmlMemBlocks()) {
51241: printf("Leak of %d blocks found in xmlXPtrNewCollapsedRange",
51242: xmlMemBlocks() - mem_base);
51243: test_ret++;
51244: printf(" %d", n_start);
51245: printf("\n");
51246: }
51247: }
51248: function_tests++;
51249: #endif
51250:
51251: return(test_ret);
51252: }
51253:
51254:
51255: static int
51256: test_xmlXPtrNewContext(void) {
51257: int test_ret = 0;
51258:
51259:
51260: /* missing type support */
51261: return(test_ret);
51262: }
51263:
51264:
51265: static int
51266: test_xmlXPtrNewLocationSetNodeSet(void) {
51267: int test_ret = 0;
51268:
51269: #if defined(LIBXML_XPTR_ENABLED)
51270: int mem_base;
51271: xmlXPathObjectPtr ret_val;
51272: xmlNodeSetPtr set; /* a node set */
51273: int n_set;
51274:
51275: for (n_set = 0;n_set < gen_nb_xmlNodeSetPtr;n_set++) {
51276: mem_base = xmlMemBlocks();
51277: set = gen_xmlNodeSetPtr(n_set, 0);
51278:
51279: ret_val = xmlXPtrNewLocationSetNodeSet(set);
51280: desret_xmlXPathObjectPtr(ret_val);
51281: call_tests++;
51282: des_xmlNodeSetPtr(n_set, set, 0);
51283: xmlResetLastError();
51284: if (mem_base != xmlMemBlocks()) {
51285: printf("Leak of %d blocks found in xmlXPtrNewLocationSetNodeSet",
51286: xmlMemBlocks() - mem_base);
51287: test_ret++;
51288: printf(" %d", n_set);
51289: printf("\n");
51290: }
51291: }
51292: function_tests++;
51293: #endif
51294:
51295: return(test_ret);
51296: }
51297:
51298:
51299: static int
51300: test_xmlXPtrNewLocationSetNodes(void) {
51301: int test_ret = 0;
51302:
51303: #if defined(LIBXML_XPTR_ENABLED)
51304: int mem_base;
51305: xmlXPathObjectPtr ret_val;
51306: xmlNodePtr start; /* the start NodePtr value */
51307: int n_start;
51308: xmlNodePtr end; /* the end NodePtr value or NULL */
51309: int n_end;
51310:
51311: for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
51312: for (n_end = 0;n_end < gen_nb_xmlNodePtr;n_end++) {
51313: mem_base = xmlMemBlocks();
51314: start = gen_xmlNodePtr(n_start, 0);
51315: end = gen_xmlNodePtr(n_end, 1);
51316:
51317: ret_val = xmlXPtrNewLocationSetNodes(start, end);
51318: desret_xmlXPathObjectPtr(ret_val);
51319: call_tests++;
51320: des_xmlNodePtr(n_start, start, 0);
51321: des_xmlNodePtr(n_end, end, 1);
51322: xmlResetLastError();
51323: if (mem_base != xmlMemBlocks()) {
51324: printf("Leak of %d blocks found in xmlXPtrNewLocationSetNodes",
51325: xmlMemBlocks() - mem_base);
51326: test_ret++;
51327: printf(" %d", n_start);
51328: printf(" %d", n_end);
51329: printf("\n");
51330: }
51331: }
51332: }
51333: function_tests++;
51334: #endif
51335:
51336: return(test_ret);
51337: }
51338:
51339:
51340: static int
51341: test_xmlXPtrNewRange(void) {
51342: int test_ret = 0;
51343:
51344: #if defined(LIBXML_XPTR_ENABLED)
51345: int mem_base;
51346: xmlXPathObjectPtr ret_val;
51347: xmlNodePtr start; /* the starting node */
51348: int n_start;
51349: int startindex; /* the start index */
51350: int n_startindex;
51351: xmlNodePtr end; /* the ending point */
51352: int n_end;
51353: int endindex; /* the ending index */
51354: int n_endindex;
51355:
51356: for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
51357: for (n_startindex = 0;n_startindex < gen_nb_int;n_startindex++) {
51358: for (n_end = 0;n_end < gen_nb_xmlNodePtr;n_end++) {
51359: for (n_endindex = 0;n_endindex < gen_nb_int;n_endindex++) {
51360: mem_base = xmlMemBlocks();
51361: start = gen_xmlNodePtr(n_start, 0);
51362: startindex = gen_int(n_startindex, 1);
51363: end = gen_xmlNodePtr(n_end, 2);
51364: endindex = gen_int(n_endindex, 3);
51365:
51366: ret_val = xmlXPtrNewRange(start, startindex, end, endindex);
51367: desret_xmlXPathObjectPtr(ret_val);
51368: call_tests++;
51369: des_xmlNodePtr(n_start, start, 0);
51370: des_int(n_startindex, startindex, 1);
51371: des_xmlNodePtr(n_end, end, 2);
51372: des_int(n_endindex, endindex, 3);
51373: xmlResetLastError();
51374: if (mem_base != xmlMemBlocks()) {
51375: printf("Leak of %d blocks found in xmlXPtrNewRange",
51376: xmlMemBlocks() - mem_base);
51377: test_ret++;
51378: printf(" %d", n_start);
51379: printf(" %d", n_startindex);
51380: printf(" %d", n_end);
51381: printf(" %d", n_endindex);
51382: printf("\n");
51383: }
51384: }
51385: }
51386: }
51387: }
51388: function_tests++;
51389: #endif
51390:
51391: return(test_ret);
51392: }
51393:
51394:
51395: static int
51396: test_xmlXPtrNewRangeNodeObject(void) {
51397: int test_ret = 0;
51398:
51399: #if defined(LIBXML_XPTR_ENABLED)
51400: int mem_base;
51401: xmlXPathObjectPtr ret_val;
51402: xmlNodePtr start; /* the starting node */
51403: int n_start;
51404: xmlXPathObjectPtr end; /* the ending object */
51405: int n_end;
51406:
51407: for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
51408: for (n_end = 0;n_end < gen_nb_xmlXPathObjectPtr;n_end++) {
51409: mem_base = xmlMemBlocks();
51410: start = gen_xmlNodePtr(n_start, 0);
51411: end = gen_xmlXPathObjectPtr(n_end, 1);
51412:
51413: ret_val = xmlXPtrNewRangeNodeObject(start, end);
51414: desret_xmlXPathObjectPtr(ret_val);
51415: call_tests++;
51416: des_xmlNodePtr(n_start, start, 0);
51417: des_xmlXPathObjectPtr(n_end, end, 1);
51418: xmlResetLastError();
51419: if (mem_base != xmlMemBlocks()) {
51420: printf("Leak of %d blocks found in xmlXPtrNewRangeNodeObject",
51421: xmlMemBlocks() - mem_base);
51422: test_ret++;
51423: printf(" %d", n_start);
51424: printf(" %d", n_end);
51425: printf("\n");
51426: }
51427: }
51428: }
51429: function_tests++;
51430: #endif
51431:
51432: return(test_ret);
51433: }
51434:
51435:
51436: static int
51437: test_xmlXPtrNewRangeNodePoint(void) {
51438: int test_ret = 0;
51439:
51440: #if defined(LIBXML_XPTR_ENABLED)
51441: int mem_base;
51442: xmlXPathObjectPtr ret_val;
51443: xmlNodePtr start; /* the starting node */
51444: int n_start;
51445: xmlXPathObjectPtr end; /* the ending point */
51446: int n_end;
51447:
51448: for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
51449: for (n_end = 0;n_end < gen_nb_xmlXPathObjectPtr;n_end++) {
51450: mem_base = xmlMemBlocks();
51451: start = gen_xmlNodePtr(n_start, 0);
51452: end = gen_xmlXPathObjectPtr(n_end, 1);
51453:
51454: ret_val = xmlXPtrNewRangeNodePoint(start, end);
51455: desret_xmlXPathObjectPtr(ret_val);
51456: call_tests++;
51457: des_xmlNodePtr(n_start, start, 0);
51458: des_xmlXPathObjectPtr(n_end, end, 1);
51459: xmlResetLastError();
51460: if (mem_base != xmlMemBlocks()) {
51461: printf("Leak of %d blocks found in xmlXPtrNewRangeNodePoint",
51462: xmlMemBlocks() - mem_base);
51463: test_ret++;
51464: printf(" %d", n_start);
51465: printf(" %d", n_end);
51466: printf("\n");
51467: }
51468: }
51469: }
51470: function_tests++;
51471: #endif
51472:
51473: return(test_ret);
51474: }
51475:
51476:
51477: static int
51478: test_xmlXPtrNewRangeNodes(void) {
51479: int test_ret = 0;
51480:
51481: #if defined(LIBXML_XPTR_ENABLED)
51482: int mem_base;
51483: xmlXPathObjectPtr ret_val;
51484: xmlNodePtr start; /* the starting node */
51485: int n_start;
51486: xmlNodePtr end; /* the ending node */
51487: int n_end;
51488:
51489: for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
51490: for (n_end = 0;n_end < gen_nb_xmlNodePtr;n_end++) {
51491: mem_base = xmlMemBlocks();
51492: start = gen_xmlNodePtr(n_start, 0);
51493: end = gen_xmlNodePtr(n_end, 1);
51494:
51495: ret_val = xmlXPtrNewRangeNodes(start, end);
51496: desret_xmlXPathObjectPtr(ret_val);
51497: call_tests++;
51498: des_xmlNodePtr(n_start, start, 0);
51499: des_xmlNodePtr(n_end, end, 1);
51500: xmlResetLastError();
51501: if (mem_base != xmlMemBlocks()) {
51502: printf("Leak of %d blocks found in xmlXPtrNewRangeNodes",
51503: xmlMemBlocks() - mem_base);
51504: test_ret++;
51505: printf(" %d", n_start);
51506: printf(" %d", n_end);
51507: printf("\n");
51508: }
51509: }
51510: }
51511: function_tests++;
51512: #endif
51513:
51514: return(test_ret);
51515: }
51516:
51517:
51518: static int
51519: test_xmlXPtrNewRangePointNode(void) {
51520: int test_ret = 0;
51521:
51522: #if defined(LIBXML_XPTR_ENABLED)
51523: int mem_base;
51524: xmlXPathObjectPtr ret_val;
51525: xmlXPathObjectPtr start; /* the starting point */
51526: int n_start;
51527: xmlNodePtr end; /* the ending node */
51528: int n_end;
51529:
51530: for (n_start = 0;n_start < gen_nb_xmlXPathObjectPtr;n_start++) {
51531: for (n_end = 0;n_end < gen_nb_xmlNodePtr;n_end++) {
51532: mem_base = xmlMemBlocks();
51533: start = gen_xmlXPathObjectPtr(n_start, 0);
51534: end = gen_xmlNodePtr(n_end, 1);
51535:
51536: ret_val = xmlXPtrNewRangePointNode(start, end);
51537: desret_xmlXPathObjectPtr(ret_val);
51538: call_tests++;
51539: des_xmlXPathObjectPtr(n_start, start, 0);
51540: des_xmlNodePtr(n_end, end, 1);
51541: xmlResetLastError();
51542: if (mem_base != xmlMemBlocks()) {
51543: printf("Leak of %d blocks found in xmlXPtrNewRangePointNode",
51544: xmlMemBlocks() - mem_base);
51545: test_ret++;
51546: printf(" %d", n_start);
51547: printf(" %d", n_end);
51548: printf("\n");
51549: }
51550: }
51551: }
51552: function_tests++;
51553: #endif
51554:
51555: return(test_ret);
51556: }
51557:
51558:
51559: static int
51560: test_xmlXPtrNewRangePoints(void) {
51561: int test_ret = 0;
51562:
51563: #if defined(LIBXML_XPTR_ENABLED)
51564: int mem_base;
51565: xmlXPathObjectPtr ret_val;
51566: xmlXPathObjectPtr start; /* the starting point */
51567: int n_start;
51568: xmlXPathObjectPtr end; /* the ending point */
51569: int n_end;
51570:
51571: for (n_start = 0;n_start < gen_nb_xmlXPathObjectPtr;n_start++) {
51572: for (n_end = 0;n_end < gen_nb_xmlXPathObjectPtr;n_end++) {
51573: mem_base = xmlMemBlocks();
51574: start = gen_xmlXPathObjectPtr(n_start, 0);
51575: end = gen_xmlXPathObjectPtr(n_end, 1);
51576:
51577: ret_val = xmlXPtrNewRangePoints(start, end);
51578: desret_xmlXPathObjectPtr(ret_val);
51579: call_tests++;
51580: des_xmlXPathObjectPtr(n_start, start, 0);
51581: des_xmlXPathObjectPtr(n_end, end, 1);
51582: xmlResetLastError();
51583: if (mem_base != xmlMemBlocks()) {
51584: printf("Leak of %d blocks found in xmlXPtrNewRangePoints",
51585: xmlMemBlocks() - mem_base);
51586: test_ret++;
51587: printf(" %d", n_start);
51588: printf(" %d", n_end);
51589: printf("\n");
51590: }
51591: }
51592: }
51593: function_tests++;
51594: #endif
51595:
51596: return(test_ret);
51597: }
51598:
51599:
51600: static int
51601: test_xmlXPtrRangeToFunction(void) {
51602: int test_ret = 0;
51603:
51604: #if defined(LIBXML_XPTR_ENABLED)
51605: int mem_base;
51606: xmlXPathParserContextPtr ctxt; /* the XPointer Parser context */
51607: int n_ctxt;
51608: int nargs; /* the number of args */
51609: int n_nargs;
51610:
51611: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
51612: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
51613: mem_base = xmlMemBlocks();
51614: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
51615: nargs = gen_int(n_nargs, 1);
51616:
51617: xmlXPtrRangeToFunction(ctxt, nargs);
51618: call_tests++;
51619: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
51620: des_int(n_nargs, nargs, 1);
51621: xmlResetLastError();
51622: if (mem_base != xmlMemBlocks()) {
51623: printf("Leak of %d blocks found in xmlXPtrRangeToFunction",
51624: xmlMemBlocks() - mem_base);
51625: test_ret++;
51626: printf(" %d", n_ctxt);
51627: printf(" %d", n_nargs);
51628: printf("\n");
51629: }
51630: }
51631: }
51632: function_tests++;
51633: #endif
51634:
51635: return(test_ret);
51636: }
51637:
51638:
51639: static int
51640: test_xmlXPtrWrapLocationSet(void) {
51641: int test_ret = 0;
51642:
51643: #if defined(LIBXML_XPTR_ENABLED)
51644: int mem_base;
51645: xmlXPathObjectPtr ret_val;
51646: xmlLocationSetPtr val; /* the LocationSet value */
51647: int n_val;
51648:
51649: for (n_val = 0;n_val < gen_nb_xmlLocationSetPtr;n_val++) {
51650: mem_base = xmlMemBlocks();
51651: val = gen_xmlLocationSetPtr(n_val, 0);
51652:
51653: ret_val = xmlXPtrWrapLocationSet(val);
51654: desret_xmlXPathObjectPtr(ret_val);
51655: call_tests++;
51656: des_xmlLocationSetPtr(n_val, val, 0);
51657: xmlResetLastError();
51658: if (mem_base != xmlMemBlocks()) {
51659: printf("Leak of %d blocks found in xmlXPtrWrapLocationSet",
51660: xmlMemBlocks() - mem_base);
51661: test_ret++;
51662: printf(" %d", n_val);
51663: printf("\n");
51664: }
51665: }
51666: function_tests++;
51667: #endif
51668:
51669: return(test_ret);
51670: }
51671:
51672: static int
51673: test_xpointer(void) {
51674: int test_ret = 0;
51675:
51676: if (quiet == 0) printf("Testing xpointer : 17 of 21 functions ...\n");
51677: test_ret += test_xmlXPtrBuildNodeList();
51678: test_ret += test_xmlXPtrEval();
51679: test_ret += test_xmlXPtrEvalRangePredicate();
51680: test_ret += test_xmlXPtrLocationSetAdd();
51681: test_ret += test_xmlXPtrLocationSetCreate();
51682: test_ret += test_xmlXPtrLocationSetDel();
51683: test_ret += test_xmlXPtrLocationSetMerge();
51684: test_ret += test_xmlXPtrLocationSetRemove();
51685: test_ret += test_xmlXPtrNewCollapsedRange();
51686: test_ret += test_xmlXPtrNewContext();
51687: test_ret += test_xmlXPtrNewLocationSetNodeSet();
51688: test_ret += test_xmlXPtrNewLocationSetNodes();
51689: test_ret += test_xmlXPtrNewRange();
51690: test_ret += test_xmlXPtrNewRangeNodeObject();
51691: test_ret += test_xmlXPtrNewRangeNodePoint();
51692: test_ret += test_xmlXPtrNewRangeNodes();
51693: test_ret += test_xmlXPtrNewRangePointNode();
51694: test_ret += test_xmlXPtrNewRangePoints();
51695: test_ret += test_xmlXPtrRangeToFunction();
51696: test_ret += test_xmlXPtrWrapLocationSet();
51697:
51698: if (test_ret != 0)
51699: printf("Module xpointer: %d errors\n", test_ret);
51700: return(test_ret);
51701: }
51702: static int
51703: test_module(const char *module) {
51704: if (!strcmp(module, "HTMLparser")) return(test_HTMLparser());
51705: if (!strcmp(module, "HTMLtree")) return(test_HTMLtree());
51706: if (!strcmp(module, "SAX2")) return(test_SAX2());
51707: if (!strcmp(module, "c14n")) return(test_c14n());
51708: if (!strcmp(module, "catalog")) return(test_catalog());
51709: if (!strcmp(module, "chvalid")) return(test_chvalid());
51710: if (!strcmp(module, "debugXML")) return(test_debugXML());
51711: if (!strcmp(module, "dict")) return(test_dict());
51712: if (!strcmp(module, "encoding")) return(test_encoding());
51713: if (!strcmp(module, "entities")) return(test_entities());
51714: if (!strcmp(module, "hash")) return(test_hash());
51715: if (!strcmp(module, "list")) return(test_list());
51716: if (!strcmp(module, "nanoftp")) return(test_nanoftp());
51717: if (!strcmp(module, "nanohttp")) return(test_nanohttp());
51718: if (!strcmp(module, "parser")) return(test_parser());
51719: if (!strcmp(module, "parserInternals")) return(test_parserInternals());
51720: if (!strcmp(module, "pattern")) return(test_pattern());
51721: if (!strcmp(module, "relaxng")) return(test_relaxng());
51722: if (!strcmp(module, "schemasInternals")) return(test_schemasInternals());
51723: if (!strcmp(module, "schematron")) return(test_schematron());
51724: if (!strcmp(module, "tree")) return(test_tree());
51725: if (!strcmp(module, "uri")) return(test_uri());
51726: if (!strcmp(module, "valid")) return(test_valid());
51727: if (!strcmp(module, "xinclude")) return(test_xinclude());
51728: if (!strcmp(module, "xmlIO")) return(test_xmlIO());
51729: if (!strcmp(module, "xmlautomata")) return(test_xmlautomata());
51730: if (!strcmp(module, "xmlerror")) return(test_xmlerror());
51731: if (!strcmp(module, "xmlmodule")) return(test_xmlmodule());
51732: if (!strcmp(module, "xmlreader")) return(test_xmlreader());
51733: if (!strcmp(module, "xmlregexp")) return(test_xmlregexp());
51734: if (!strcmp(module, "xmlsave")) return(test_xmlsave());
51735: if (!strcmp(module, "xmlschemas")) return(test_xmlschemas());
51736: if (!strcmp(module, "xmlschemastypes")) return(test_xmlschemastypes());
51737: if (!strcmp(module, "xmlstring")) return(test_xmlstring());
51738: if (!strcmp(module, "xmlunicode")) return(test_xmlunicode());
51739: if (!strcmp(module, "xmlwriter")) return(test_xmlwriter());
51740: if (!strcmp(module, "xpath")) return(test_xpath());
51741: if (!strcmp(module, "xpathInternals")) return(test_xpathInternals());
51742: if (!strcmp(module, "xpointer")) return(test_xpointer());
51743: return(0);
51744: }
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