Annotation of embedaddon/libxml2/testapi.c, revision 1.1.1.3
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: #include "libxml.h"
12: #include <stdio.h>
13:
14: #include <stdlib.h> /* for putenv() */
15: #include <string.h>
16: #include <libxml/xmlerror.h>
17: #include <libxml/relaxng.h>
18:
19:
20: static int testlibxml2(void);
21: static int test_module(const char *module);
22:
23: static int generic_errors = 0;
24: static int call_tests = 0;
25: static int function_tests = 0;
26:
27: static xmlChar chartab[1024];
28: static int inttab[1024];
29: static unsigned long longtab[1024];
30:
31: static xmlDocPtr api_doc = NULL;
32: static xmlDtdPtr api_dtd = NULL;
33: static xmlNodePtr api_root = NULL;
34: static xmlAttrPtr api_attr = NULL;
35: static xmlNsPtr api_ns = NULL;
36:
37: static void
38: structured_errors(void *userData ATTRIBUTE_UNUSED,
39: xmlErrorPtr error ATTRIBUTE_UNUSED) {
40: generic_errors++;
41: }
42:
43: static void
44: free_api_doc(void) {
45: xmlFreeDoc(api_doc);
46: api_doc = NULL;
47: api_dtd = NULL;
48: api_root = NULL;
49: api_attr = NULL;
50: api_ns = NULL;
51: }
52:
53: static xmlDocPtr
54: get_api_doc(void) {
55: if (api_doc == NULL) {
56: api_doc = xmlReadMemory("<!DOCTYPE root [<!ELEMENT root EMPTY>]><root xmlns:h='http://example.com/' h:foo='bar'/>", 88, "root_test", NULL, 0);
57: api_root = NULL;
58: api_attr = NULL;
59: }
60: return(api_doc);
61: }
62:
63: static xmlDtdPtr
64: get_api_dtd(void) {
65: if ((api_dtd == NULL) || (api_dtd->type != XML_DTD_NODE)) {
66: get_api_doc();
67: if ((api_doc != NULL) && (api_doc->children != NULL) &&
68: (api_doc->children->type == XML_DTD_NODE))
69: api_dtd = (xmlDtdPtr) api_doc->children;
70: }
71: return(api_dtd);
72: }
73:
74: static xmlNodePtr
75: get_api_root(void) {
76: if ((api_root == NULL) || (api_root->type != XML_ELEMENT_NODE)) {
77: get_api_doc();
78: if ((api_doc != NULL) && (api_doc->children != NULL) &&
79: (api_doc->children->next != NULL) &&
80: (api_doc->children->next->type == XML_ELEMENT_NODE))
81: api_root = api_doc->children->next;
82: }
83: return(api_root);
84: }
85:
86: static xmlNsPtr
87: get_api_ns(void) {
88: get_api_root();
89: if (api_root != NULL)
90: api_ns = api_root->nsDef;
91: return(api_ns);
92: }
93:
94: static xmlAttrPtr
95: get_api_attr(void) {
96: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
97: static int nr = 0;
98: xmlChar name[20];
99: #endif
100:
101: if ((api_root == NULL) || (api_root->type != XML_ELEMENT_NODE)) {
102: get_api_root();
103: }
1.1.1.3 ! misho 104: if (api_root == NULL)
1.1 misho 105: return(NULL);
106: if (api_root->properties != NULL) {
107: api_attr = api_root->properties;
108: return(api_root->properties);
109: }
110: api_attr = NULL;
111: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
112: snprintf((char *) name, 20, "foo%d", nr++);
113: api_attr = xmlSetProp(api_root, name, (const xmlChar *) "bar");
114: #endif
115: return(api_attr);
116: }
117:
118: static int quiet = 0;
119:
120: int main(int argc, char **argv) {
121: int ret;
122: int blocks, mem;
123:
1.1.1.3 ! misho 124: #ifdef HAVE_PUTENV
1.1 misho 125: /* access to the proxy can slow up regression tests a lot */
126: putenv((char *) "http_proxy=");
1.1.1.3 ! misho 127: #endif
1.1 misho 128:
129: memset(chartab, 0, sizeof(chartab));
130: strncpy((char *) chartab, " chartab\n", 20);
131: memset(inttab, 0, sizeof(inttab));
132: memset(longtab, 0, sizeof(longtab));
133:
134: xmlInitParser();
135: #ifdef LIBXML_SCHEMAS_ENABLED
136: xmlRelaxNGInitTypes();
137: #endif
138:
139: LIBXML_TEST_VERSION
140:
141: xmlSetStructuredErrorFunc(NULL, structured_errors);
142:
143: if (argc >= 2) {
144: if (!strcmp(argv[1], "-q")) {
145: quiet = 1;
146: if (argc >= 3)
147: ret = test_module(argv[2]);
148: else
149: ret = testlibxml2();
150: } else {
151: ret = test_module(argv[1]);
152: }
153: } else
154: ret = testlibxml2();
155:
156: xmlCleanupParser();
157: blocks = xmlMemBlocks();
158: mem = xmlMemUsed();
159: if ((blocks != 0) || (mem != 0)) {
160: printf("testapi leaked %d bytes in %d blocks\n", mem, blocks);
161: }
162: xmlMemoryDump();
163:
164: return (ret != 0);
165: }
166:
167: #include <libxml/HTMLparser.h>
168: #include <libxml/HTMLtree.h>
169: #include <libxml/catalog.h>
170: #include <libxml/chvalid.h>
171: #include <libxml/dict.h>
172: #include <libxml/encoding.h>
173: #include <libxml/entities.h>
174: #include <libxml/hash.h>
175: #include <libxml/list.h>
176: #include <libxml/nanoftp.h>
177: #include <libxml/nanohttp.h>
178: #include <libxml/parser.h>
179: #include <libxml/parserInternals.h>
180: #include <libxml/pattern.h>
181: #include <libxml/relaxng.h>
182: #include <libxml/schemasInternals.h>
183: #include <libxml/schematron.h>
184: #include <libxml/tree.h>
185: #include <libxml/uri.h>
186: #include <libxml/valid.h>
187: #include <libxml/xinclude.h>
188: #include <libxml/xmlIO.h>
189: #include <libxml/xmlerror.h>
190: #include <libxml/xmlreader.h>
191: #include <libxml/xmlsave.h>
192: #include <libxml/xmlschemas.h>
193: #include <libxml/xmlschemastypes.h>
194: #include <libxml/xmlstring.h>
195: #include <libxml/xmlwriter.h>
196: #include <libxml/xpath.h>
197: #include <libxml/xpointer.h>
198: #include <libxml/debugXML.h>
199:
1.1.1.3 ! misho 200: /*
1.1 misho 201: We manually define xmlErrMemory because it's normal declaration
202: is "hidden" by #ifdef IN_LIBXML
203: */
204: void xmlErrMemory(xmlParserCtxtPtr ctxt, const char *extra);
205:
206: /*
207: We need some "remote" addresses, but want to avoid getting into
208: name resolution delays, so we use these
209: */
210: #define REMOTE1GOOD "http://localhost/"
211: #define REMOTE1BAD "http:http://http"
212: #define REMOTE2GOOD "ftp://localhost/foo"
213:
214: #define gen_nb_void_ptr 2
215:
216: static void *gen_void_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
217: return(NULL);
218: }
219: static void des_void_ptr(int no ATTRIBUTE_UNUSED, void *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
220: }
221:
222: #if 0
223: #define gen_nb_const_void_ptr 2
224:
225: static const void *gen_const_void_ptr(int no, int nr ATTRIBUTE_UNUSED) {
226: if (no == 0) return((const void *) "immutable string");
227: return(NULL);
228: }
229: static void des_const_void_ptr(int no ATTRIBUTE_UNUSED, const void *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
230: }
231: #endif
232:
233: #define gen_nb_userdata 3
234:
235: static void *gen_userdata(int no, int nr ATTRIBUTE_UNUSED) {
236: if (no == 0) return((void *) &call_tests);
237: if (no == 1) return((void *) -1);
238: return(NULL);
239: }
240: static void des_userdata(int no ATTRIBUTE_UNUSED, void *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
241: }
242:
243:
244: #define gen_nb_int 4
245:
246: static int gen_int(int no, int nr ATTRIBUTE_UNUSED) {
247: if (no == 0) return(0);
248: if (no == 1) return(1);
249: if (no == 2) return(-1);
250: if (no == 3) return(122);
251: return(-1);
252: }
253:
254: static void des_int(int no ATTRIBUTE_UNUSED, int val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
255: }
256:
257: #define gen_nb_parseroptions 5
258:
259: static int gen_parseroptions(int no, int nr ATTRIBUTE_UNUSED) {
260: if (no == 0) return(XML_PARSE_NOBLANKS | XML_PARSE_RECOVER);
261: if (no == 1) return(XML_PARSE_NOENT | XML_PARSE_DTDLOAD | XML_PARSE_DTDATTR | XML_PARSE_DTDVALID | XML_PARSE_NOCDATA);
262: if (no == 2) return(XML_PARSE_XINCLUDE | XML_PARSE_NOXINCNODE | XML_PARSE_NSCLEAN);
263: if (no == 3) return(XML_PARSE_XINCLUDE | XML_PARSE_NODICT);
264: return(XML_PARSE_SAX1);
265: }
266:
267: static void des_parseroptions(int no ATTRIBUTE_UNUSED, int val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
268: }
269:
270: #if 0
271: #define gen_nb_long 5
272:
273: static long gen_long(int no, int nr ATTRIBUTE_UNUSED) {
274: if (no == 0) return(0);
275: if (no == 1) return(1);
276: if (no == 2) return(-1);
277: if (no == 3) return(122);
278: return(-1);
279: }
280:
281: static void des_long(int no ATTRIBUTE_UNUSED, long val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
282: }
283: #endif
284:
285: #define gen_nb_xmlChar 4
286:
287: static xmlChar gen_xmlChar(int no, int nr ATTRIBUTE_UNUSED) {
288: if (no == 0) return('a');
289: if (no == 1) return(' ');
1.1.1.3 ! misho 290: if (no == 2) return((xmlChar) '\xf8');
1.1 misho 291: return(0);
292: }
293:
294: static void des_xmlChar(int no ATTRIBUTE_UNUSED, xmlChar val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
295: }
296:
297: #define gen_nb_unsigned_int 3
298:
299: static unsigned int gen_unsigned_int(int no, int nr ATTRIBUTE_UNUSED) {
300: if (no == 0) return(0);
301: if (no == 1) return(1);
302: if (no == 2) return(122);
303: return((unsigned int) -1);
304: }
305:
306: static void des_unsigned_int(int no ATTRIBUTE_UNUSED, unsigned int val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
307: }
308:
309: #define gen_nb_unsigned_long 4
310:
311: static unsigned long gen_unsigned_long(int no, int nr ATTRIBUTE_UNUSED) {
312: if (no == 0) return(0);
313: if (no == 1) return(1);
314: if (no == 2) return(122);
315: return((unsigned long) -1);
316: }
317:
318: static void des_unsigned_long(int no ATTRIBUTE_UNUSED, unsigned long val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
319: }
320:
321: #define gen_nb_double 4
322:
323: static double gen_double(int no, int nr ATTRIBUTE_UNUSED) {
324: if (no == 0) return(0);
325: if (no == 1) return(-1.1);
326: #if defined(LIBXML_XPATH_ENABLED)
327: if (no == 2) return(xmlXPathNAN);
328: #endif
329: return(-1);
330: }
331:
332: static void des_double(int no ATTRIBUTE_UNUSED, double val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
333: }
334:
335: #define gen_nb_unsigned_long_ptr 2
336:
337: static unsigned long *gen_unsigned_long_ptr(int no, int nr) {
338: if (no == 0) return(&longtab[nr]);
339: return(NULL);
340: }
341:
342: static void des_unsigned_long_ptr(int no ATTRIBUTE_UNUSED, unsigned long *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
343: }
344:
345: #define gen_nb_int_ptr 2
346:
347: static int *gen_int_ptr(int no, int nr) {
348: if (no == 0) return(&inttab[nr]);
349: return(NULL);
350: }
351:
352: static void des_int_ptr(int no ATTRIBUTE_UNUSED, int *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
353: }
354:
355: #define gen_nb_const_char_ptr 4
356:
357: static char *gen_const_char_ptr(int no, int nr ATTRIBUTE_UNUSED) {
358: if (no == 0) return((char *) "foo");
359: if (no == 1) return((char *) "<foo/>");
360: if (no == 2) return((char *) "test/ent2");
361: return(NULL);
362: }
363: static void des_const_char_ptr(int no ATTRIBUTE_UNUSED, const char *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
364: }
365:
366: #define gen_nb_xmlChar_ptr 2
367:
368: static xmlChar *gen_xmlChar_ptr(int no, int nr ATTRIBUTE_UNUSED) {
369: if (no == 0) return(&chartab[0]);
370: return(NULL);
371: }
372: static void des_xmlChar_ptr(int no ATTRIBUTE_UNUSED, xmlChar *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
373: }
374:
375: #define gen_nb_FILE_ptr 2
376:
377: static FILE *gen_FILE_ptr(int no, int nr ATTRIBUTE_UNUSED) {
378: if (no == 0) return(fopen("test.out", "a+"));
379: return(NULL);
380: }
381: static void des_FILE_ptr(int no ATTRIBUTE_UNUSED, FILE *val, int nr ATTRIBUTE_UNUSED) {
382: if (val != NULL) fclose(val);
383: }
384:
385: #define gen_nb_debug_FILE_ptr 2
386: static FILE *gen_debug_FILE_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
387: return(fopen("test.out", "a+"));
388: }
389: static void des_debug_FILE_ptr(int no ATTRIBUTE_UNUSED, FILE *val, int nr ATTRIBUTE_UNUSED) {
390: if (val != NULL) fclose(val);
391: }
392:
393: #define gen_nb_const_xmlChar_ptr 5
394:
395: static xmlChar *gen_const_xmlChar_ptr(int no, int nr ATTRIBUTE_UNUSED) {
396: if (no == 0) return((xmlChar *) "foo");
397: if (no == 1) return((xmlChar *) "<foo/>");
1.1.1.3 ! misho 398: if (no == 2) return((xmlChar *) "n" "\xf8" "ne");
1.1 misho 399: if (no == 3) return((xmlChar *) " 2ab ");
400: return(NULL);
401: }
402: static void des_const_xmlChar_ptr(int no ATTRIBUTE_UNUSED, const xmlChar *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
403: }
404:
405: #define gen_nb_filepath 8
406:
407: static const char *gen_filepath(int no, int nr ATTRIBUTE_UNUSED) {
408: if (no == 0) return("missing.xml");
409: if (no == 1) return("<foo/>");
410: if (no == 2) return("test/ent2");
411: if (no == 3) return("test/valid/REC-xml-19980210.xml");
412: if (no == 4) return("test/valid/dtds/xhtml1-strict.dtd");
413: if (no == 5) return(REMOTE1GOOD);
414: if (no == 6) return(REMOTE1BAD);
415: return(NULL);
416: }
417: static void des_filepath(int no ATTRIBUTE_UNUSED, const char *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
418: }
419:
420: #define gen_nb_eaten_name 2
421:
422: static xmlChar *gen_eaten_name(int no, int nr ATTRIBUTE_UNUSED) {
423: if (no == 0) return(xmlStrdup(BAD_CAST "eaten"));
424: return(NULL);
425: }
426: static void des_eaten_name(int no ATTRIBUTE_UNUSED, xmlChar *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
427: }
428:
429: #define gen_nb_fileoutput 6
430:
431: static const char *gen_fileoutput(int no, int nr ATTRIBUTE_UNUSED) {
432: if (no == 0) return("/missing.xml");
433: if (no == 1) return("<foo/>");
434: if (no == 2) return(REMOTE2GOOD);
435: if (no == 3) return(REMOTE1GOOD);
436: if (no == 4) return(REMOTE1BAD);
437: return(NULL);
438: }
439: static void des_fileoutput(int no ATTRIBUTE_UNUSED, const char *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
440: }
441:
442: #define gen_nb_xmlParserCtxtPtr 3
443: static xmlParserCtxtPtr gen_xmlParserCtxtPtr(int no, int nr ATTRIBUTE_UNUSED) {
444: if (no == 0) return(xmlNewParserCtxt());
445: if (no == 1) return(xmlCreateMemoryParserCtxt("<doc/>", 6));
446: return(NULL);
447: }
448: static void des_xmlParserCtxtPtr(int no ATTRIBUTE_UNUSED, xmlParserCtxtPtr val, int nr ATTRIBUTE_UNUSED) {
449: if (val != NULL)
450: xmlFreeParserCtxt(val);
451: }
452:
453: #define gen_nb_xmlSAXHandlerPtr 2
454: static xmlSAXHandlerPtr gen_xmlSAXHandlerPtr(int no, int nr ATTRIBUTE_UNUSED) {
455: #ifdef LIBXML_SAX1_ENABLED
456: if (no == 0) return((xmlSAXHandlerPtr) &xmlDefaultSAXHandler);
457: #endif
458: return(NULL);
459: }
460: static void des_xmlSAXHandlerPtr(int no ATTRIBUTE_UNUSED, xmlSAXHandlerPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
461: }
462:
463: #define gen_nb_xmlValidCtxtPtr 2
464: static xmlValidCtxtPtr gen_xmlValidCtxtPtr(int no, int nr ATTRIBUTE_UNUSED) {
465: #ifdef LIBXML_VALID_ENABLED
466: if (no == 0) return(xmlNewValidCtxt());
467: #endif
468: return(NULL);
469: }
470: static void des_xmlValidCtxtPtr(int no ATTRIBUTE_UNUSED, xmlValidCtxtPtr val, int nr ATTRIBUTE_UNUSED) {
471: #ifdef LIBXML_VALID_ENABLED
472: if (val != NULL)
473: xmlFreeValidCtxt(val);
474: #endif
475: }
476:
477: #define gen_nb_xmlParserInputBufferPtr 8
478:
479: static xmlParserInputBufferPtr gen_xmlParserInputBufferPtr(int no, int nr ATTRIBUTE_UNUSED) {
480: if (no == 0) return(xmlParserInputBufferCreateFilename("missing.xml", XML_CHAR_ENCODING_NONE));
481: if (no == 1) return(xmlParserInputBufferCreateFilename("<foo/>", XML_CHAR_ENCODING_NONE));
482: if (no == 2) return(xmlParserInputBufferCreateFilename("test/ent2", XML_CHAR_ENCODING_NONE));
483: if (no == 3) return(xmlParserInputBufferCreateFilename("test/valid/REC-xml-19980210.xml", XML_CHAR_ENCODING_NONE));
484: if (no == 4) return(xmlParserInputBufferCreateFilename("test/valid/dtds/xhtml1-strict.dtd", XML_CHAR_ENCODING_NONE));
485: if (no == 5) return(xmlParserInputBufferCreateFilename(REMOTE1GOOD, XML_CHAR_ENCODING_NONE));
486: if (no == 6) return(xmlParserInputBufferCreateFilename(REMOTE1BAD, XML_CHAR_ENCODING_NONE));
487: return(NULL);
488: }
489: static void des_xmlParserInputBufferPtr(int no ATTRIBUTE_UNUSED, xmlParserInputBufferPtr val, int nr ATTRIBUTE_UNUSED) {
490: xmlFreeParserInputBuffer(val);
491: }
492:
493: #define gen_nb_xmlDocPtr 4
494: static xmlDocPtr gen_xmlDocPtr(int no, int nr ATTRIBUTE_UNUSED) {
495: if (no == 0) return(xmlNewDoc(BAD_CAST "1.0"));
496: if (no == 1) return(xmlReadMemory("<foo/>", 6, "test", NULL, 0));
497: if (no == 2) return(xmlReadMemory("<!DOCTYPE foo []> <foo/>", 24, "test", NULL, 0));
498: return(NULL);
499: }
500: static void des_xmlDocPtr(int no ATTRIBUTE_UNUSED, xmlDocPtr val, int nr ATTRIBUTE_UNUSED) {
501: if ((val != NULL) && (val != api_doc) && (val->doc != api_doc))
502: xmlFreeDoc(val);
503: }
504:
505: #define gen_nb_xmlAttrPtr 2
506: static xmlAttrPtr gen_xmlAttrPtr(int no, int nr ATTRIBUTE_UNUSED) {
507: if (no == 0) return(get_api_attr());
508: return(NULL);
509: }
510: static void des_xmlAttrPtr(int no, xmlAttrPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
511: if (no == 0) free_api_doc();
512: }
513:
514: #define gen_nb_xmlDictPtr 2
515: static xmlDictPtr gen_xmlDictPtr(int no, int nr ATTRIBUTE_UNUSED) {
516: if (no == 0) return(xmlDictCreate());
517: return(NULL);
518: }
519: static void des_xmlDictPtr(int no ATTRIBUTE_UNUSED, xmlDictPtr val, int nr ATTRIBUTE_UNUSED) {
520: if (val != NULL)
521: xmlDictFree(val);
522: }
523:
524: #define gen_nb_xmlNodePtr 3
525: static xmlNodePtr gen_xmlNodePtr(int no, int nr ATTRIBUTE_UNUSED) {
526: if (no == 0) return(xmlNewPI(BAD_CAST "test", NULL));
527: if (no == 1) return(get_api_root());
528: return(NULL);
529: /* if (no == 2) return((xmlNodePtr) get_api_doc()); */
530: }
531: static void des_xmlNodePtr(int no, xmlNodePtr val, int nr ATTRIBUTE_UNUSED) {
532: if (no == 1) {
533: free_api_doc();
534: } else if (val != NULL) {
535: xmlUnlinkNode(val);
536: xmlFreeNode(val);
537: }
538: }
539:
540: #define gen_nb_xmlDtdPtr 3
541: static xmlDtdPtr gen_xmlDtdPtr(int no, int nr ATTRIBUTE_UNUSED) {
1.1.1.3 ! misho 542: if (no == 0)
1.1 misho 543: return(xmlNewDtd(NULL, BAD_CAST "dtd", BAD_CAST"foo", BAD_CAST"bar"));
544: if (no == 1) return(get_api_dtd());
545: return(NULL);
546: }
547: static void des_xmlDtdPtr(int no, xmlDtdPtr val, int nr ATTRIBUTE_UNUSED) {
548: if (no == 1) free_api_doc();
549: else if (val != NULL) {
550: xmlUnlinkNode((xmlNodePtr) val);
551: xmlFreeNode((xmlNodePtr) val);
552: }
553: }
554:
555: #define gen_nb_xmlNsPtr 2
556: static xmlNsPtr gen_xmlNsPtr(int no, int nr ATTRIBUTE_UNUSED) {
557: if (no == 0) return(get_api_ns());
558: return(NULL);
559: }
560: static void des_xmlNsPtr(int no, xmlNsPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
561: if (no == 0) free_api_doc();
562: }
563:
564: #define gen_nb_xmlNodePtr_in 3
565: static xmlNodePtr gen_xmlNodePtr_in(int no, int nr ATTRIBUTE_UNUSED) {
566: if (no == 0) return(xmlNewPI(BAD_CAST "test", NULL));
567: if (no == 0) return(xmlNewText(BAD_CAST "text"));
568: return(NULL);
569: }
570: static void des_xmlNodePtr_in(int no ATTRIBUTE_UNUSED, xmlNodePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
571: }
572:
573: #ifdef LIBXML_WRITER_ENABLED
574: #define gen_nb_xmlTextWriterPtr 2
575: static xmlTextWriterPtr gen_xmlTextWriterPtr(int no, int nr ATTRIBUTE_UNUSED) {
576: if (no == 0) return(xmlNewTextWriterFilename("test.out", 0));
577: return(NULL);
578: }
579: static void des_xmlTextWriterPtr(int no ATTRIBUTE_UNUSED, xmlTextWriterPtr val, int nr ATTRIBUTE_UNUSED) {
580: if (val != NULL) xmlFreeTextWriter(val);
581: }
582: #endif
583:
584: #ifdef LIBXML_READER_ENABLED
585: #define gen_nb_xmlTextReaderPtr 4
586: static xmlTextReaderPtr gen_xmlTextReaderPtr(int no, int nr ATTRIBUTE_UNUSED) {
587: if (no == 0) return(xmlNewTextReaderFilename("test/ent2"));
588: if (no == 1) return(xmlNewTextReaderFilename("test/valid/REC-xml-19980210.xml"));
589: if (no == 2) return(xmlNewTextReaderFilename("test/valid/dtds/xhtml1-strict.dtd"));
590: return(NULL);
591: }
592: static void des_xmlTextReaderPtr(int no ATTRIBUTE_UNUSED, xmlTextReaderPtr val, int nr ATTRIBUTE_UNUSED) {
593: if (val != NULL) xmlFreeTextReader(val);
594: }
595: #endif
596:
597: #define gen_nb_xmlBufferPtr 3
1.1.1.2 misho 598: static const xmlChar *static_buf_content = (xmlChar *)"a static buffer";
1.1 misho 599: static xmlBufferPtr gen_xmlBufferPtr(int no, int nr ATTRIBUTE_UNUSED) {
600: if (no == 0) return(xmlBufferCreate());
601: if (no == 1) return(xmlBufferCreateStatic((void *)static_buf_content, 13));
602: return(NULL);
603: }
604: static void des_xmlBufferPtr(int no ATTRIBUTE_UNUSED, xmlBufferPtr val, int nr ATTRIBUTE_UNUSED) {
605: if (val != NULL) {
606: xmlBufferFree(val);
607: }
608: }
609:
610: #define gen_nb_xmlListPtr 2
611: static xmlListPtr gen_xmlListPtr(int no, int nr ATTRIBUTE_UNUSED) {
612: if (no == 0) return(xmlListCreate(NULL, NULL));
613: return(NULL);
614: }
615: static void des_xmlListPtr(int no ATTRIBUTE_UNUSED, xmlListPtr val, int nr ATTRIBUTE_UNUSED) {
616: if (val != NULL) {
617: xmlListDelete(val);
618: }
619: }
620:
621: #define gen_nb_xmlHashTablePtr 2
622: static xmlHashTablePtr gen_xmlHashTablePtr(int no, int nr ATTRIBUTE_UNUSED) {
623: if (no == 0) return(xmlHashCreate(10));
624: return(NULL);
625: }
626: static void des_xmlHashTablePtr(int no ATTRIBUTE_UNUSED, xmlHashTablePtr val, int nr ATTRIBUTE_UNUSED) {
627: if (val != NULL) {
628: xmlHashFree(val, NULL);
629: }
630: }
631:
632: #include <libxml/xpathInternals.h>
633:
634: #ifdef LIBXML_XPATH_ENABLED
635: #define gen_nb_xmlXPathObjectPtr 5
636: static xmlXPathObjectPtr gen_xmlXPathObjectPtr(int no, int nr ATTRIBUTE_UNUSED) {
637: if (no == 0) return(xmlXPathNewString(BAD_CAST "string object"));
638: if (no == 1) return(xmlXPathNewFloat(1.1));
639: if (no == 2) return(xmlXPathNewBoolean(1));
640: if (no == 3) return(xmlXPathNewNodeSet(NULL));
641: return(NULL);
642: }
643: static void des_xmlXPathObjectPtr(int no ATTRIBUTE_UNUSED, xmlXPathObjectPtr val, int nr ATTRIBUTE_UNUSED) {
644: if (val != NULL) {
645: xmlXPathFreeObject(val);
646: }
647: }
648: #endif
649:
650: #ifdef LIBXML_OUTPUT_ENABLED
651: #define gen_nb_xmlOutputBufferPtr 2
652: static xmlOutputBufferPtr gen_xmlOutputBufferPtr(int no, int nr ATTRIBUTE_UNUSED) {
653: if (no == 0) return(xmlOutputBufferCreateFilename("test.out", NULL, 0));
654: return(NULL);
655: }
656: static void des_xmlOutputBufferPtr(int no ATTRIBUTE_UNUSED, xmlOutputBufferPtr val, int nr ATTRIBUTE_UNUSED) {
657: if (val != NULL) {
658: xmlOutputBufferClose(val);
659: }
660: }
661: #endif
662:
663: #ifdef LIBXML_FTP_ENABLED
664: #define gen_nb_xmlNanoFTPCtxtPtr 4
665: static void *gen_xmlNanoFTPCtxtPtr(int no, int nr ATTRIBUTE_UNUSED) {
666: if (no == 0) return(xmlNanoFTPNewCtxt(REMOTE2GOOD));
667: if (no == 1) return(xmlNanoFTPNewCtxt(REMOTE1GOOD));
668: if (no == 2) return(xmlNanoFTPNewCtxt("foo"));
669: return(NULL);
670: }
671: static void des_xmlNanoFTPCtxtPtr(int no ATTRIBUTE_UNUSED, void *val, int nr ATTRIBUTE_UNUSED) {
672: if (val != NULL) {
673: xmlNanoFTPFreeCtxt(val);
674: }
675: }
676: #endif
677:
678: #ifdef LIBXML_HTTP_ENABLED
679: #define gen_nb_xmlNanoHTTPCtxtPtr 1
680: static void *gen_xmlNanoHTTPCtxtPtr(int no, int nr ATTRIBUTE_UNUSED) {
681: if (no == 0) return(xmlNanoHTTPOpen(REMOTE1GOOD, NULL));
682: if (no == 1) return(xmlNanoHTTPOpen(REMOTE2GOOD, NULL));
683: if (no == 2) return(xmlNanoHTTPOpen(REMOTE1BAD, NULL));
684: return(NULL);
685: }
686: static void des_xmlNanoHTTPCtxtPtr(int no ATTRIBUTE_UNUSED, void *val, int nr ATTRIBUTE_UNUSED) {
687: if (val != NULL) {
688: xmlNanoHTTPClose(val);
689: }
690: }
691: #endif
692:
693: #define gen_nb_xmlCharEncoding 4
694: static xmlCharEncoding gen_xmlCharEncoding(int no, int nr ATTRIBUTE_UNUSED) {
695: if (no == 0) return(XML_CHAR_ENCODING_UTF8);
696: if (no == 1) return(XML_CHAR_ENCODING_NONE);
697: if (no == 2) return(XML_CHAR_ENCODING_8859_1);
698: return(XML_CHAR_ENCODING_ERROR);
699: }
700: static void des_xmlCharEncoding(int no ATTRIBUTE_UNUSED, xmlCharEncoding val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
701: }
702:
703: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
704:
705: #define gen_nb_xmlExpCtxtPtr 1
706: static xmlExpCtxtPtr gen_xmlExpCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
707: return(NULL);
708: }
709: static void des_xmlExpCtxtPtr(int no ATTRIBUTE_UNUSED, xmlExpCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
710: }
711:
712: #define gen_nb_xmlExpNodePtr 1
713: static xmlExpNodePtr gen_xmlExpNodePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
714: return(NULL);
715: }
716: static void des_xmlExpNodePtr(int no ATTRIBUTE_UNUSED, xmlExpNodePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
717: }
718:
719: #endif
720:
721: #if defined(LIBXML_SCHEMAS_ENABLED)
722: #define gen_nb_xmlSchemaPtr 1
723: static xmlSchemaPtr gen_xmlSchemaPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
724: return(NULL);
725: }
726: static void des_xmlSchemaPtr(int no ATTRIBUTE_UNUSED, xmlSchemaPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
727: }
728:
729: #define gen_nb_xmlSchemaValidCtxtPtr 1
730: static xmlSchemaValidCtxtPtr gen_xmlSchemaValidCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
731: return(NULL);
732: }
733: static void des_xmlSchemaValidCtxtPtr(int no ATTRIBUTE_UNUSED, xmlSchemaValidCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
734: }
735:
736: #endif /* LIBXML_SCHEMAS_ENABLED */
737:
738: #define gen_nb_xmlHashDeallocator 2
1.1.1.3 ! misho 739: static void
1.1 misho 740: test_xmlHashDeallocator(void *payload ATTRIBUTE_UNUSED, xmlChar *name ATTRIBUTE_UNUSED) {
741: }
742:
743: static xmlHashDeallocator gen_xmlHashDeallocator(int no, int nr ATTRIBUTE_UNUSED) {
744: if (no == 0) return(test_xmlHashDeallocator);
745: return(NULL);
746: }
747: static void des_xmlHashDeallocator(int no ATTRIBUTE_UNUSED, xmlHashDeallocator val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
748: }
749:
750:
751: static void desret_int(int val ATTRIBUTE_UNUSED) {
752: }
753: static void desret_xmlChar(xmlChar val ATTRIBUTE_UNUSED) {
754: }
755: static void desret_long(long val ATTRIBUTE_UNUSED) {
756: }
757: static void desret_unsigned_long(unsigned long val ATTRIBUTE_UNUSED) {
758: }
759: static void desret_double(double val ATTRIBUTE_UNUSED) {
760: }
761: static void desret_xmlCharEncoding(xmlCharEncoding val ATTRIBUTE_UNUSED) {
762: }
763: #if 0
764: static void desret_const_void_ptr(void *val ATTRIBUTE_UNUSED) {
765: }
766: #endif
767: static void desret_void_ptr(void *val ATTRIBUTE_UNUSED) {
768: }
769: static void desret_const_char_ptr(const char *val ATTRIBUTE_UNUSED) {
770: }
771: static void desret_const_xmlChar_ptr(const xmlChar *val ATTRIBUTE_UNUSED) {
772: }
773: static void desret_xmlChar_ptr(xmlChar *val) {
774: if (val != NULL)
775: xmlFree(val);
776: }
777: static void desret_xmlDocPtr(xmlDocPtr val) {
778: if (val != api_doc)
779: xmlFreeDoc(val);
780: }
781: static void desret_xmlDictPtr(xmlDictPtr val) {
782: xmlDictFree(val);
783: }
784: #ifdef LIBXML_OUTPUT_ENABLED
785: static void desret_xmlOutputBufferPtr(xmlOutputBufferPtr val) {
786: xmlOutputBufferClose(val);
787: }
788: #endif
789: #ifdef LIBXML_READER_ENABLED
790: static void desret_xmlTextReaderPtr(xmlTextReaderPtr val) {
791: xmlFreeTextReader(val);
792: }
793: #endif
794: static void desret_xmlNodePtr(xmlNodePtr val) {
795: if ((val != NULL) && (val != api_root) && (val != (xmlNodePtr) api_doc)) {
796: xmlUnlinkNode(val);
797: xmlFreeNode(val);
798: }
799: }
800: static void desret_xmlAttrPtr(xmlAttrPtr val) {
801: if (val != NULL) {
802: xmlUnlinkNode((xmlNodePtr) val);
803: xmlFreeNode((xmlNodePtr) val);
804: }
805: }
806: static void desret_xmlEntityPtr(xmlEntityPtr val) {
807: if (val != NULL) {
808: xmlUnlinkNode((xmlNodePtr) val);
809: xmlFreeNode((xmlNodePtr) val);
810: }
811: }
812: static void desret_xmlElementPtr(xmlElementPtr val) {
813: if (val != NULL) {
814: xmlUnlinkNode((xmlNodePtr) val);
815: }
816: }
817: static void desret_xmlAttributePtr(xmlAttributePtr val) {
818: if (val != NULL) {
819: xmlUnlinkNode((xmlNodePtr) val);
820: }
821: }
822: static void desret_xmlNsPtr(xmlNsPtr val ATTRIBUTE_UNUSED) {
823: }
824: static void desret_xmlDtdPtr(xmlDtdPtr val) {
825: desret_xmlNodePtr((xmlNodePtr)val);
826: }
827: #ifdef LIBXML_XPATH_ENABLED
828: static void desret_xmlXPathObjectPtr(xmlXPathObjectPtr val) {
829: xmlXPathFreeObject(val);
830: }
831: static void desret_xmlNodeSetPtr(xmlNodeSetPtr val) {
832: xmlXPathFreeNodeSet(val);
833: }
834: #endif
835: static void desret_xmlParserCtxtPtr(xmlParserCtxtPtr val) {
836: xmlFreeParserCtxt(val);
837: }
838: static void desret_xmlParserInputBufferPtr(xmlParserInputBufferPtr val) {
839: xmlFreeParserInputBuffer(val);
840: }
841: static void desret_xmlParserInputPtr(xmlParserInputPtr val) {
842: xmlFreeInputStream(val);
843: }
844: #ifdef LIBXML_WRITER_ENABLED
845: static void desret_xmlTextWriterPtr(xmlTextWriterPtr val) {
846: xmlFreeTextWriter(val);
847: }
848: #endif
849: static void desret_xmlBufferPtr(xmlBufferPtr val) {
850: xmlBufferFree(val);
851: }
852: #ifdef LIBXML_SCHEMAS_ENABLED
853: static void desret_xmlSchemaParserCtxtPtr(xmlSchemaParserCtxtPtr val) {
854: xmlSchemaFreeParserCtxt(val);
855: }
856: static void desret_xmlSchemaTypePtr(xmlSchemaTypePtr val ATTRIBUTE_UNUSED) {
857: }
858: static void desret_xmlRelaxNGParserCtxtPtr(xmlRelaxNGParserCtxtPtr val) {
859: xmlRelaxNGFreeParserCtxt(val);
860: }
861: #endif
862: #ifdef LIBXML_HTML_ENABLED
863: static void desret_const_htmlEntityDesc_ptr(const htmlEntityDesc * val ATTRIBUTE_UNUSED) {
864: }
865: #endif
866: #ifdef LIBXML_HTTP_ENABLED
867: static void desret_xmlNanoHTTPCtxtPtr(void *val) {
868: xmlNanoHTTPClose(val);
869: }
870: #endif
871: #ifdef LIBXML_FTP_ENABLED
872: static void desret_xmlNanoFTPCtxtPtr(void *val) {
873: xmlNanoFTPClose(val);
874: }
875: #endif
876: /* cut and pasted from autogenerated to avoid troubles */
877: #define gen_nb_const_xmlChar_ptr_ptr 1
878: static xmlChar ** gen_const_xmlChar_ptr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
879: return(NULL);
880: }
881: static void des_const_xmlChar_ptr_ptr(int no ATTRIBUTE_UNUSED, const xmlChar ** val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
882: }
883:
884: #define gen_nb_unsigned_char_ptr 1
885: static unsigned char * gen_unsigned_char_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
886: return(NULL);
887: }
888: static void des_unsigned_char_ptr(int no ATTRIBUTE_UNUSED, unsigned char * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
889: }
890:
891: #define gen_nb_const_unsigned_char_ptr 1
892: static unsigned char * gen_const_unsigned_char_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
893: return(NULL);
894: }
895: static void des_const_unsigned_char_ptr(int no ATTRIBUTE_UNUSED, const unsigned char * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
896: }
897:
898: #ifdef LIBXML_HTML_ENABLED
899: #define gen_nb_const_htmlNodePtr 1
900: static htmlNodePtr gen_const_htmlNodePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
901: return(NULL);
902: }
903: static void des_const_htmlNodePtr(int no ATTRIBUTE_UNUSED, const htmlNodePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
904: }
905: #endif
906:
907: #ifdef LIBXML_HTML_ENABLED
908: #define gen_nb_htmlDocPtr 3
909: static htmlDocPtr gen_htmlDocPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
910: if (no == 0) return(htmlNewDoc(NULL, NULL));
911: if (no == 1) return(htmlReadMemory("<html/>", 7, "test", NULL, 0));
912: return(NULL);
913: }
914: static void des_htmlDocPtr(int no ATTRIBUTE_UNUSED, htmlDocPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
915: if ((val != NULL) && (val != api_doc) && (val->doc != api_doc))
916: xmlFreeDoc(val);
917: }
918: static void desret_htmlDocPtr(htmlDocPtr val) {
919: if ((val != NULL) && (val != api_doc) && (val->doc != api_doc))
920: xmlFreeDoc(val);
921: }
922: #define gen_nb_htmlParserCtxtPtr 3
923: static htmlParserCtxtPtr gen_htmlParserCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
924: if (no == 0) return(xmlNewParserCtxt());
925: if (no == 1) return(htmlCreateMemoryParserCtxt("<html/>", 7));
926: return(NULL);
927: }
928: static void des_htmlParserCtxtPtr(int no ATTRIBUTE_UNUSED, htmlParserCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
929: if (val != NULL)
930: htmlFreeParserCtxt(val);
931: }
932: static void desret_htmlParserCtxtPtr(htmlParserCtxtPtr val) {
933: if (val != NULL)
934: htmlFreeParserCtxt(val);
935: }
936: #endif
937:
938: #ifdef LIBXML_XPATH_ENABLED
939: #define gen_nb_xmlNodeSetPtr 1
940: static xmlNodeSetPtr gen_xmlNodeSetPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
941: return(NULL);
942: }
943: static void des_xmlNodeSetPtr(int no ATTRIBUTE_UNUSED, xmlNodeSetPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
944: }
945: #endif
946:
947: #ifdef LIBXML_DEBUG_ENABLED
948: #ifdef LIBXML_XPATH_ENABLED
949: #define gen_nb_xmlShellCtxtPtr 1
950: static xmlShellCtxtPtr gen_xmlShellCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
951: return(NULL);
952: }
953: static void des_xmlShellCtxtPtr(int no ATTRIBUTE_UNUSED, xmlShellCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
954: }
955: #endif
956: #endif
957:
958: #ifdef LIBXML_PATTERN_ENABLED
959: #define gen_nb_xmlPatternPtr 1
960: static xmlPatternPtr gen_xmlPatternPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
961: return(NULL);
962: }
963: static void des_xmlPatternPtr(int no ATTRIBUTE_UNUSED, xmlPatternPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
964: }
965: #endif
966:
967: #define gen_nb_xmlElementContentPtr 1
968: static xmlElementContentPtr gen_xmlElementContentPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
969: return(NULL);
970: }
971: static void des_xmlElementContentPtr(int no ATTRIBUTE_UNUSED, xmlElementContentPtr val, int nr ATTRIBUTE_UNUSED) {
972: if (val != NULL)
973: xmlFreeElementContent(val);
974: }
975: static void desret_xmlElementContentPtr(xmlElementContentPtr val) {
976: if (val != NULL)
977: xmlFreeElementContent(val);
978: }
979:
980: #define gen_nb_xmlParserNodeInfoSeqPtr 1
981: static xmlParserNodeInfoSeqPtr gen_xmlParserNodeInfoSeqPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
982: return(NULL);
983: }
984: static void des_xmlParserNodeInfoSeqPtr(int no ATTRIBUTE_UNUSED, xmlParserNodeInfoSeqPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
985: }
986:
987: static void desret_const_xmlParserNodeInfo_ptr(const xmlParserNodeInfo *val ATTRIBUTE_UNUSED) {
988: }
989:
990: #define gen_nb_void_ptr_ptr 1
991: static void ** gen_void_ptr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
992: return(NULL);
993: }
994: static void des_void_ptr_ptr(int no ATTRIBUTE_UNUSED, void ** val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
995: }
996:
997: /************************************************************************
998: * *
999: * WARNING: end of the manually maintained part of the test code *
1000: * do not remove or alter the CUT HERE line *
1001: * *
1002: ************************************************************************/
1003:
1004: /* CUT HERE: everything below that line is generated */
1005: #ifdef LIBXML_HTML_ENABLED
1006: static void desret_htmlStatus(htmlStatus val ATTRIBUTE_UNUSED) {
1007: }
1008:
1009: #endif
1010:
1011: #define gen_nb_xmlAttributeDefault 4
1012: static xmlAttributeDefault gen_xmlAttributeDefault(int no, int nr ATTRIBUTE_UNUSED) {
1013: if (no == 1) return(XML_ATTRIBUTE_FIXED);
1014: if (no == 2) return(XML_ATTRIBUTE_IMPLIED);
1015: if (no == 3) return(XML_ATTRIBUTE_NONE);
1016: if (no == 4) return(XML_ATTRIBUTE_REQUIRED);
1017: return(0);
1018: }
1019:
1020: static void des_xmlAttributeDefault(int no ATTRIBUTE_UNUSED, xmlAttributeDefault val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1021: }
1022:
1023: #define gen_nb_xmlAttributeType 4
1024: static xmlAttributeType gen_xmlAttributeType(int no, int nr ATTRIBUTE_UNUSED) {
1025: if (no == 1) return(XML_ATTRIBUTE_CDATA);
1026: if (no == 2) return(XML_ATTRIBUTE_ENTITIES);
1027: if (no == 3) return(XML_ATTRIBUTE_ENTITY);
1028: if (no == 4) return(XML_ATTRIBUTE_ENUMERATION);
1029: return(0);
1030: }
1031:
1032: static void des_xmlAttributeType(int no ATTRIBUTE_UNUSED, xmlAttributeType val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1033: }
1034:
1035: #define gen_nb_xmlBufferAllocationScheme 4
1036: static xmlBufferAllocationScheme gen_xmlBufferAllocationScheme(int no, int nr ATTRIBUTE_UNUSED) {
1037: if (no == 1) return(XML_BUFFER_ALLOC_DOUBLEIT);
1038: if (no == 2) return(XML_BUFFER_ALLOC_EXACT);
1.1.1.2 misho 1039: if (no == 3) return(XML_BUFFER_ALLOC_HYBRID);
1040: if (no == 4) return(XML_BUFFER_ALLOC_IMMUTABLE);
1.1 misho 1041: return(0);
1042: }
1043:
1044: static void des_xmlBufferAllocationScheme(int no ATTRIBUTE_UNUSED, xmlBufferAllocationScheme val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1045: }
1046:
1047: static void desret_xmlBufferAllocationScheme(xmlBufferAllocationScheme val ATTRIBUTE_UNUSED) {
1048: }
1049:
1050: #ifdef LIBXML_CATALOG_ENABLED
1051: #define gen_nb_xmlCatalogAllow 4
1052: static xmlCatalogAllow gen_xmlCatalogAllow(int no, int nr ATTRIBUTE_UNUSED) {
1053: if (no == 1) return(XML_CATA_ALLOW_ALL);
1054: if (no == 2) return(XML_CATA_ALLOW_DOCUMENT);
1055: if (no == 3) return(XML_CATA_ALLOW_GLOBAL);
1056: if (no == 4) return(XML_CATA_ALLOW_NONE);
1057: return(0);
1058: }
1059:
1060: static void des_xmlCatalogAllow(int no ATTRIBUTE_UNUSED, xmlCatalogAllow val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1061: }
1062:
1063: static void desret_xmlCatalogAllow(xmlCatalogAllow val ATTRIBUTE_UNUSED) {
1064: }
1065:
1066: #endif
1067:
1068: #ifdef LIBXML_CATALOG_ENABLED
1069: #define gen_nb_xmlCatalogPrefer 3
1070: static xmlCatalogPrefer gen_xmlCatalogPrefer(int no, int nr ATTRIBUTE_UNUSED) {
1071: if (no == 1) return(XML_CATA_PREFER_NONE);
1072: if (no == 2) return(XML_CATA_PREFER_PUBLIC);
1073: if (no == 3) return(XML_CATA_PREFER_SYSTEM);
1074: return(0);
1075: }
1076:
1077: static void des_xmlCatalogPrefer(int no ATTRIBUTE_UNUSED, xmlCatalogPrefer val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1078: }
1079:
1080: static void desret_xmlCatalogPrefer(xmlCatalogPrefer val ATTRIBUTE_UNUSED) {
1081: }
1082:
1083: #endif
1084:
1085: #define gen_nb_xmlElementContentType 4
1086: static xmlElementContentType gen_xmlElementContentType(int no, int nr ATTRIBUTE_UNUSED) {
1087: if (no == 1) return(XML_ELEMENT_CONTENT_ELEMENT);
1088: if (no == 2) return(XML_ELEMENT_CONTENT_OR);
1089: if (no == 3) return(XML_ELEMENT_CONTENT_PCDATA);
1090: if (no == 4) return(XML_ELEMENT_CONTENT_SEQ);
1091: return(0);
1092: }
1093:
1094: static void des_xmlElementContentType(int no ATTRIBUTE_UNUSED, xmlElementContentType val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1095: }
1096:
1097: #define gen_nb_xmlElementTypeVal 4
1098: static xmlElementTypeVal gen_xmlElementTypeVal(int no, int nr ATTRIBUTE_UNUSED) {
1099: if (no == 1) return(XML_ELEMENT_TYPE_ANY);
1100: if (no == 2) return(XML_ELEMENT_TYPE_ELEMENT);
1101: if (no == 3) return(XML_ELEMENT_TYPE_EMPTY);
1102: if (no == 4) return(XML_ELEMENT_TYPE_MIXED);
1103: return(0);
1104: }
1105:
1106: static void des_xmlElementTypeVal(int no ATTRIBUTE_UNUSED, xmlElementTypeVal val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1107: }
1108:
1109: #define gen_nb_xmlFeature 4
1110: static xmlFeature gen_xmlFeature(int no, int nr ATTRIBUTE_UNUSED) {
1111: if (no == 1) return(XML_WITH_AUTOMATA);
1112: if (no == 2) return(XML_WITH_C14N);
1113: if (no == 3) return(XML_WITH_CATALOG);
1114: if (no == 4) return(XML_WITH_DEBUG);
1115: return(0);
1116: }
1117:
1118: static void des_xmlFeature(int no ATTRIBUTE_UNUSED, xmlFeature val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1119: }
1120:
1121: static void desret_xmlParserErrors(xmlParserErrors val ATTRIBUTE_UNUSED) {
1122: }
1123:
1124: #ifdef LIBXML_SCHEMAS_ENABLED
1125: #define gen_nb_xmlSchemaValType 4
1126: static xmlSchemaValType gen_xmlSchemaValType(int no, int nr ATTRIBUTE_UNUSED) {
1127: if (no == 1) return(XML_SCHEMAS_ANYSIMPLETYPE);
1128: if (no == 2) return(XML_SCHEMAS_ANYTYPE);
1129: if (no == 3) return(XML_SCHEMAS_ANYURI);
1130: if (no == 4) return(XML_SCHEMAS_BASE64BINARY);
1131: return(0);
1132: }
1133:
1134: static void des_xmlSchemaValType(int no ATTRIBUTE_UNUSED, xmlSchemaValType val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1135: }
1136:
1137: static void desret_xmlSchemaValType(xmlSchemaValType val ATTRIBUTE_UNUSED) {
1138: }
1139:
1140: #endif
1141:
1142: #ifdef LIBXML_SCHEMAS_ENABLED
1143: #define gen_nb_xmlSchemaWhitespaceValueType 4
1144: static xmlSchemaWhitespaceValueType gen_xmlSchemaWhitespaceValueType(int no, int nr ATTRIBUTE_UNUSED) {
1145: if (no == 1) return(XML_SCHEMA_WHITESPACE_COLLAPSE);
1146: if (no == 2) return(XML_SCHEMA_WHITESPACE_PRESERVE);
1147: if (no == 3) return(XML_SCHEMA_WHITESPACE_REPLACE);
1148: if (no == 4) return(XML_SCHEMA_WHITESPACE_UNKNOWN);
1149: return(0);
1150: }
1151:
1152: static void des_xmlSchemaWhitespaceValueType(int no ATTRIBUTE_UNUSED, xmlSchemaWhitespaceValueType val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1153: }
1154:
1155: #endif
1156:
1157: #include <libxml/HTMLparser.h>
1158: #include <libxml/HTMLtree.h>
1159: #include <libxml/SAX2.h>
1160: #include <libxml/c14n.h>
1161: #include <libxml/catalog.h>
1162: #include <libxml/chvalid.h>
1163: #include <libxml/debugXML.h>
1164: #include <libxml/dict.h>
1165: #include <libxml/encoding.h>
1166: #include <libxml/entities.h>
1167: #include <libxml/hash.h>
1168: #include <libxml/list.h>
1169: #include <libxml/nanoftp.h>
1170: #include <libxml/nanohttp.h>
1171: #include <libxml/parser.h>
1172: #include <libxml/parserInternals.h>
1173: #include <libxml/pattern.h>
1174: #include <libxml/relaxng.h>
1175: #include <libxml/schemasInternals.h>
1176: #include <libxml/schematron.h>
1177: #include <libxml/tree.h>
1178: #include <libxml/uri.h>
1179: #include <libxml/valid.h>
1180: #include <libxml/xinclude.h>
1181: #include <libxml/xmlIO.h>
1182: #include <libxml/xmlautomata.h>
1183: #include <libxml/xmlerror.h>
1184: #include <libxml/xmlmodule.h>
1185: #include <libxml/xmlreader.h>
1186: #include <libxml/xmlregexp.h>
1187: #include <libxml/xmlsave.h>
1188: #include <libxml/xmlschemas.h>
1189: #include <libxml/xmlschemastypes.h>
1190: #include <libxml/xmlstring.h>
1191: #include <libxml/xmlunicode.h>
1192: #include <libxml/xmlwriter.h>
1193: #include <libxml/xpath.h>
1194: #include <libxml/xpathInternals.h>
1195: #include <libxml/xpointer.h>
1196: static int test_HTMLparser(void);
1197: static int test_HTMLtree(void);
1198: static int test_SAX2(void);
1199: static int test_c14n(void);
1200: static int test_catalog(void);
1201: static int test_chvalid(void);
1202: static int test_debugXML(void);
1203: static int test_dict(void);
1204: static int test_encoding(void);
1205: static int test_entities(void);
1206: static int test_hash(void);
1207: static int test_list(void);
1208: static int test_nanoftp(void);
1209: static int test_nanohttp(void);
1210: static int test_parser(void);
1211: static int test_parserInternals(void);
1212: static int test_pattern(void);
1213: static int test_relaxng(void);
1214: static int test_schemasInternals(void);
1215: static int test_schematron(void);
1216: static int test_tree(void);
1217: static int test_uri(void);
1218: static int test_valid(void);
1219: static int test_xinclude(void);
1220: static int test_xmlIO(void);
1221: static int test_xmlautomata(void);
1222: static int test_xmlerror(void);
1223: static int test_xmlmodule(void);
1224: static int test_xmlreader(void);
1225: static int test_xmlregexp(void);
1226: static int test_xmlsave(void);
1227: static int test_xmlschemas(void);
1228: static int test_xmlschemastypes(void);
1229: static int test_xmlstring(void);
1230: static int test_xmlunicode(void);
1231: static int test_xmlwriter(void);
1232: static int test_xpath(void);
1233: static int test_xpathInternals(void);
1234: static int test_xpointer(void);
1235:
1236: /**
1237: * testlibxml2:
1238: *
1239: * Main entry point of the tester for the full libxml2 module,
1240: * it calls all the tester entry point for each module.
1241: *
1242: * Returns the number of error found
1243: */
1244: static int
1245: testlibxml2(void)
1246: {
1247: int test_ret = 0;
1248:
1249: test_ret += test_HTMLparser();
1250: test_ret += test_HTMLtree();
1251: test_ret += test_SAX2();
1252: test_ret += test_c14n();
1253: test_ret += test_catalog();
1254: test_ret += test_chvalid();
1255: test_ret += test_debugXML();
1256: test_ret += test_dict();
1257: test_ret += test_encoding();
1258: test_ret += test_entities();
1259: test_ret += test_hash();
1260: test_ret += test_list();
1261: test_ret += test_nanoftp();
1262: test_ret += test_nanohttp();
1263: test_ret += test_parser();
1264: test_ret += test_parserInternals();
1265: test_ret += test_pattern();
1266: test_ret += test_relaxng();
1267: test_ret += test_schemasInternals();
1268: test_ret += test_schematron();
1269: test_ret += test_tree();
1270: test_ret += test_uri();
1271: test_ret += test_valid();
1272: test_ret += test_xinclude();
1273: test_ret += test_xmlIO();
1274: test_ret += test_xmlautomata();
1275: test_ret += test_xmlerror();
1276: test_ret += test_xmlmodule();
1277: test_ret += test_xmlreader();
1278: test_ret += test_xmlregexp();
1279: test_ret += test_xmlsave();
1280: test_ret += test_xmlschemas();
1281: test_ret += test_xmlschemastypes();
1282: test_ret += test_xmlstring();
1283: test_ret += test_xmlunicode();
1284: test_ret += test_xmlwriter();
1285: test_ret += test_xpath();
1286: test_ret += test_xpathInternals();
1287: test_ret += test_xpointer();
1288:
1289: printf("Total: %d functions, %d tests, %d errors\n",
1290: function_tests, call_tests, test_ret);
1291: return(test_ret);
1292: }
1293:
1294:
1295: static int
1296: test_UTF8ToHtml(void) {
1297: int test_ret = 0;
1298:
1299: #if defined(LIBXML_HTML_ENABLED)
1300: int mem_base;
1301: int ret_val;
1302: unsigned char * out; /* a pointer to an array of bytes to store the result */
1303: int n_out;
1304: int * outlen; /* the length of @out */
1305: int n_outlen;
1306: unsigned char * in; /* a pointer to an array of UTF-8 chars */
1307: int n_in;
1308: int * inlen; /* the length of @in */
1309: int n_inlen;
1310:
1311: for (n_out = 0;n_out < gen_nb_unsigned_char_ptr;n_out++) {
1312: for (n_outlen = 0;n_outlen < gen_nb_int_ptr;n_outlen++) {
1313: for (n_in = 0;n_in < gen_nb_const_unsigned_char_ptr;n_in++) {
1314: for (n_inlen = 0;n_inlen < gen_nb_int_ptr;n_inlen++) {
1315: mem_base = xmlMemBlocks();
1316: out = gen_unsigned_char_ptr(n_out, 0);
1317: outlen = gen_int_ptr(n_outlen, 1);
1318: in = gen_const_unsigned_char_ptr(n_in, 2);
1319: inlen = gen_int_ptr(n_inlen, 3);
1320:
1321: ret_val = UTF8ToHtml(out, outlen, (const unsigned char *)in, inlen);
1322: desret_int(ret_val);
1323: call_tests++;
1324: des_unsigned_char_ptr(n_out, out, 0);
1325: des_int_ptr(n_outlen, outlen, 1);
1326: des_const_unsigned_char_ptr(n_in, (const unsigned char *)in, 2);
1327: des_int_ptr(n_inlen, inlen, 3);
1328: xmlResetLastError();
1329: if (mem_base != xmlMemBlocks()) {
1330: printf("Leak of %d blocks found in UTF8ToHtml",
1331: xmlMemBlocks() - mem_base);
1332: test_ret++;
1333: printf(" %d", n_out);
1334: printf(" %d", n_outlen);
1335: printf(" %d", n_in);
1336: printf(" %d", n_inlen);
1337: printf("\n");
1338: }
1339: }
1340: }
1341: }
1342: }
1343: function_tests++;
1344: #endif
1345:
1346: return(test_ret);
1347: }
1348:
1349: #ifdef LIBXML_HTML_ENABLED
1350:
1351: #define gen_nb_const_htmlElemDesc_ptr 1
1352: static htmlElemDesc * gen_const_htmlElemDesc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1353: return(NULL);
1354: }
1355: static void des_const_htmlElemDesc_ptr(int no ATTRIBUTE_UNUSED, const htmlElemDesc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1356: }
1357: #endif
1358:
1359:
1360: static int
1361: test_htmlAttrAllowed(void) {
1362: int test_ret = 0;
1363:
1364: #if defined(LIBXML_HTML_ENABLED)
1365: int mem_base;
1366: htmlStatus ret_val;
1367: htmlElemDesc * elt; /* HTML element */
1368: int n_elt;
1369: xmlChar * attr; /* HTML attribute */
1370: int n_attr;
1371: int legacy; /* whether to allow deprecated attributes */
1372: int n_legacy;
1373:
1374: for (n_elt = 0;n_elt < gen_nb_const_htmlElemDesc_ptr;n_elt++) {
1375: for (n_attr = 0;n_attr < gen_nb_const_xmlChar_ptr;n_attr++) {
1376: for (n_legacy = 0;n_legacy < gen_nb_int;n_legacy++) {
1377: mem_base = xmlMemBlocks();
1378: elt = gen_const_htmlElemDesc_ptr(n_elt, 0);
1379: attr = gen_const_xmlChar_ptr(n_attr, 1);
1380: legacy = gen_int(n_legacy, 2);
1381:
1382: ret_val = htmlAttrAllowed((const htmlElemDesc *)elt, (const xmlChar *)attr, legacy);
1383: desret_htmlStatus(ret_val);
1384: call_tests++;
1385: des_const_htmlElemDesc_ptr(n_elt, (const htmlElemDesc *)elt, 0);
1386: des_const_xmlChar_ptr(n_attr, (const xmlChar *)attr, 1);
1387: des_int(n_legacy, legacy, 2);
1388: xmlResetLastError();
1389: if (mem_base != xmlMemBlocks()) {
1390: printf("Leak of %d blocks found in htmlAttrAllowed",
1391: xmlMemBlocks() - mem_base);
1392: test_ret++;
1393: printf(" %d", n_elt);
1394: printf(" %d", n_attr);
1395: printf(" %d", n_legacy);
1396: printf("\n");
1397: }
1398: }
1399: }
1400: }
1401: function_tests++;
1402: #endif
1403:
1404: return(test_ret);
1405: }
1406:
1407: #ifdef LIBXML_HTML_ENABLED
1408:
1409: #define gen_nb_htmlNodePtr 1
1410: static htmlNodePtr gen_htmlNodePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1411: return(NULL);
1412: }
1413: static void des_htmlNodePtr(int no ATTRIBUTE_UNUSED, htmlNodePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1414: }
1415: #endif
1416:
1417:
1418: static int
1419: test_htmlAutoCloseTag(void) {
1420: int test_ret = 0;
1421:
1422: #if defined(LIBXML_HTML_ENABLED)
1423: int mem_base;
1424: int ret_val;
1425: htmlDocPtr doc; /* the HTML document */
1426: int n_doc;
1427: xmlChar * name; /* The tag name */
1428: int n_name;
1429: htmlNodePtr elem; /* the HTML element */
1430: int n_elem;
1431:
1432: for (n_doc = 0;n_doc < gen_nb_htmlDocPtr;n_doc++) {
1433: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
1434: for (n_elem = 0;n_elem < gen_nb_htmlNodePtr;n_elem++) {
1435: mem_base = xmlMemBlocks();
1436: doc = gen_htmlDocPtr(n_doc, 0);
1437: name = gen_const_xmlChar_ptr(n_name, 1);
1438: elem = gen_htmlNodePtr(n_elem, 2);
1439:
1440: ret_val = htmlAutoCloseTag(doc, (const xmlChar *)name, elem);
1441: desret_int(ret_val);
1442: call_tests++;
1443: des_htmlDocPtr(n_doc, doc, 0);
1444: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
1445: des_htmlNodePtr(n_elem, elem, 2);
1446: xmlResetLastError();
1447: if (mem_base != xmlMemBlocks()) {
1448: printf("Leak of %d blocks found in htmlAutoCloseTag",
1449: xmlMemBlocks() - mem_base);
1450: test_ret++;
1451: printf(" %d", n_doc);
1452: printf(" %d", n_name);
1453: printf(" %d", n_elem);
1454: printf("\n");
1455: }
1456: }
1457: }
1458: }
1459: function_tests++;
1460: #endif
1461:
1462: return(test_ret);
1463: }
1464:
1465:
1466: static int
1467: test_htmlCreateMemoryParserCtxt(void) {
1468: int test_ret = 0;
1469:
1470: #if defined(LIBXML_HTML_ENABLED)
1471: int mem_base;
1472: htmlParserCtxtPtr ret_val;
1473: char * buffer; /* a pointer to a char array */
1474: int n_buffer;
1475: int size; /* the size of the array */
1476: int n_size;
1477:
1478: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
1479: for (n_size = 0;n_size < gen_nb_int;n_size++) {
1480: mem_base = xmlMemBlocks();
1481: buffer = gen_const_char_ptr(n_buffer, 0);
1482: size = gen_int(n_size, 1);
1483:
1484: ret_val = htmlCreateMemoryParserCtxt((const char *)buffer, size);
1485: desret_htmlParserCtxtPtr(ret_val);
1486: call_tests++;
1487: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
1488: des_int(n_size, size, 1);
1489: xmlResetLastError();
1490: if (mem_base != xmlMemBlocks()) {
1491: printf("Leak of %d blocks found in htmlCreateMemoryParserCtxt",
1492: xmlMemBlocks() - mem_base);
1493: test_ret++;
1494: printf(" %d", n_buffer);
1495: printf(" %d", n_size);
1496: printf("\n");
1497: }
1498: }
1499: }
1500: function_tests++;
1501: #endif
1502:
1503: return(test_ret);
1504: }
1505:
1506: #ifdef LIBXML_HTML_ENABLED
1507:
1508: #define gen_nb_htmlSAXHandlerPtr 1
1509: static htmlSAXHandlerPtr gen_htmlSAXHandlerPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1510: return(NULL);
1511: }
1512: static void des_htmlSAXHandlerPtr(int no ATTRIBUTE_UNUSED, htmlSAXHandlerPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1513: }
1514: #endif
1515:
1516:
1517: static int
1518: test_htmlCreatePushParserCtxt(void) {
1519: int test_ret = 0;
1520:
1521: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_PUSH_ENABLED)
1522: int mem_base;
1523: htmlParserCtxtPtr ret_val;
1524: htmlSAXHandlerPtr sax; /* a SAX handler */
1525: int n_sax;
1526: void * user_data; /* The user data returned on SAX callbacks */
1527: int n_user_data;
1528: char * chunk; /* a pointer to an array of chars */
1529: int n_chunk;
1530: int size; /* number of chars in the array */
1531: int n_size;
1532: const char * filename; /* an optional file name or URI */
1533: int n_filename;
1534: xmlCharEncoding enc; /* an optional encoding */
1535: int n_enc;
1536:
1537: for (n_sax = 0;n_sax < gen_nb_htmlSAXHandlerPtr;n_sax++) {
1538: for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
1539: for (n_chunk = 0;n_chunk < gen_nb_const_char_ptr;n_chunk++) {
1540: for (n_size = 0;n_size < gen_nb_int;n_size++) {
1541: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
1542: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
1543: mem_base = xmlMemBlocks();
1544: sax = gen_htmlSAXHandlerPtr(n_sax, 0);
1545: user_data = gen_userdata(n_user_data, 1);
1546: chunk = gen_const_char_ptr(n_chunk, 2);
1547: size = gen_int(n_size, 3);
1548: filename = gen_fileoutput(n_filename, 4);
1549: enc = gen_xmlCharEncoding(n_enc, 5);
1550:
1551: ret_val = htmlCreatePushParserCtxt(sax, user_data, (const char *)chunk, size, filename, enc);
1552: desret_htmlParserCtxtPtr(ret_val);
1553: call_tests++;
1554: des_htmlSAXHandlerPtr(n_sax, sax, 0);
1555: des_userdata(n_user_data, user_data, 1);
1556: des_const_char_ptr(n_chunk, (const char *)chunk, 2);
1557: des_int(n_size, size, 3);
1558: des_fileoutput(n_filename, filename, 4);
1559: des_xmlCharEncoding(n_enc, enc, 5);
1560: xmlResetLastError();
1561: if (mem_base != xmlMemBlocks()) {
1562: printf("Leak of %d blocks found in htmlCreatePushParserCtxt",
1563: xmlMemBlocks() - mem_base);
1564: test_ret++;
1565: printf(" %d", n_sax);
1566: printf(" %d", n_user_data);
1567: printf(" %d", n_chunk);
1568: printf(" %d", n_size);
1569: printf(" %d", n_filename);
1570: printf(" %d", n_enc);
1571: printf("\n");
1572: }
1573: }
1574: }
1575: }
1576: }
1577: }
1578: }
1579: function_tests++;
1580: #endif
1581:
1582: return(test_ret);
1583: }
1584:
1585:
1586: static int
1587: test_htmlCtxtReadDoc(void) {
1588: int test_ret = 0;
1589:
1590: #if defined(LIBXML_HTML_ENABLED)
1591: int mem_base;
1592: htmlDocPtr ret_val;
1593: htmlParserCtxtPtr ctxt; /* an HTML parser context */
1594: int n_ctxt;
1595: xmlChar * cur; /* a pointer to a zero terminated string */
1596: int n_cur;
1597: const char * URL; /* the base URL to use for the document */
1598: int n_URL;
1599: char * encoding; /* the document encoding, or NULL */
1600: int n_encoding;
1601: int options; /* a combination of htmlParserOption(s) */
1602: int n_options;
1603:
1604: for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
1605: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
1606: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
1607: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
1608: for (n_options = 0;n_options < gen_nb_int;n_options++) {
1609: mem_base = xmlMemBlocks();
1610: ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
1611: cur = gen_const_xmlChar_ptr(n_cur, 1);
1612: URL = gen_filepath(n_URL, 2);
1613: encoding = gen_const_char_ptr(n_encoding, 3);
1614: options = gen_int(n_options, 4);
1615:
1616: ret_val = htmlCtxtReadDoc(ctxt, (const xmlChar *)cur, URL, (const char *)encoding, options);
1617: desret_htmlDocPtr(ret_val);
1618: call_tests++;
1619: des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
1620: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 1);
1621: des_filepath(n_URL, URL, 2);
1622: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
1623: des_int(n_options, options, 4);
1624: xmlResetLastError();
1625: if (mem_base != xmlMemBlocks()) {
1626: printf("Leak of %d blocks found in htmlCtxtReadDoc",
1627: xmlMemBlocks() - mem_base);
1628: test_ret++;
1629: printf(" %d", n_ctxt);
1630: printf(" %d", n_cur);
1631: printf(" %d", n_URL);
1632: printf(" %d", n_encoding);
1633: printf(" %d", n_options);
1634: printf("\n");
1635: }
1636: }
1637: }
1638: }
1639: }
1640: }
1641: function_tests++;
1642: #endif
1643:
1644: return(test_ret);
1645: }
1646:
1647:
1648: static int
1649: test_htmlCtxtReadFile(void) {
1650: int test_ret = 0;
1651:
1652: #if defined(LIBXML_HTML_ENABLED)
1653: htmlDocPtr ret_val;
1654: htmlParserCtxtPtr ctxt; /* an HTML parser context */
1655: int n_ctxt;
1656: const char * filename; /* a file or URL */
1657: int n_filename;
1658: char * encoding; /* the document encoding, or NULL */
1659: int n_encoding;
1660: int options; /* a combination of htmlParserOption(s) */
1661: int n_options;
1662:
1663: for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
1664: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
1665: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
1666: for (n_options = 0;n_options < gen_nb_int;n_options++) {
1667: ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
1668: filename = gen_filepath(n_filename, 1);
1669: encoding = gen_const_char_ptr(n_encoding, 2);
1670: options = gen_int(n_options, 3);
1671:
1672: ret_val = htmlCtxtReadFile(ctxt, filename, (const char *)encoding, options);
1673: desret_htmlDocPtr(ret_val);
1674: call_tests++;
1675: des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
1676: des_filepath(n_filename, filename, 1);
1677: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
1678: des_int(n_options, options, 3);
1679: xmlResetLastError();
1680: }
1681: }
1682: }
1683: }
1684: function_tests++;
1685: #endif
1686:
1687: return(test_ret);
1688: }
1689:
1690:
1691: static int
1692: test_htmlCtxtReadMemory(void) {
1693: int test_ret = 0;
1694:
1695: #if defined(LIBXML_HTML_ENABLED)
1696: int mem_base;
1697: htmlDocPtr ret_val;
1698: htmlParserCtxtPtr ctxt; /* an HTML parser context */
1699: int n_ctxt;
1700: char * buffer; /* a pointer to a char array */
1701: int n_buffer;
1702: int size; /* the size of the array */
1703: int n_size;
1704: const char * URL; /* the base URL to use for the document */
1705: int n_URL;
1706: char * encoding; /* the document encoding, or NULL */
1707: int n_encoding;
1708: int options; /* a combination of htmlParserOption(s) */
1709: int n_options;
1710:
1711: for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
1712: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
1713: for (n_size = 0;n_size < gen_nb_int;n_size++) {
1714: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
1715: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
1716: for (n_options = 0;n_options < gen_nb_int;n_options++) {
1717: mem_base = xmlMemBlocks();
1718: ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
1719: buffer = gen_const_char_ptr(n_buffer, 1);
1720: size = gen_int(n_size, 2);
1721: URL = gen_filepath(n_URL, 3);
1722: encoding = gen_const_char_ptr(n_encoding, 4);
1723: options = gen_int(n_options, 5);
1724:
1725: ret_val = htmlCtxtReadMemory(ctxt, (const char *)buffer, size, URL, (const char *)encoding, options);
1726: desret_htmlDocPtr(ret_val);
1727: call_tests++;
1728: des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
1729: des_const_char_ptr(n_buffer, (const char *)buffer, 1);
1730: des_int(n_size, size, 2);
1731: des_filepath(n_URL, URL, 3);
1732: des_const_char_ptr(n_encoding, (const char *)encoding, 4);
1733: des_int(n_options, options, 5);
1734: xmlResetLastError();
1735: if (mem_base != xmlMemBlocks()) {
1736: printf("Leak of %d blocks found in htmlCtxtReadMemory",
1737: xmlMemBlocks() - mem_base);
1738: test_ret++;
1739: printf(" %d", n_ctxt);
1740: printf(" %d", n_buffer);
1741: printf(" %d", n_size);
1742: printf(" %d", n_URL);
1743: printf(" %d", n_encoding);
1744: printf(" %d", n_options);
1745: printf("\n");
1746: }
1747: }
1748: }
1749: }
1750: }
1751: }
1752: }
1753: function_tests++;
1754: #endif
1755:
1756: return(test_ret);
1757: }
1758:
1759:
1760: static int
1761: test_htmlCtxtReset(void) {
1762: int test_ret = 0;
1763:
1764: #if defined(LIBXML_HTML_ENABLED)
1765: int mem_base;
1766: htmlParserCtxtPtr ctxt; /* an HTML parser context */
1767: int n_ctxt;
1768:
1769: for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
1770: mem_base = xmlMemBlocks();
1771: ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
1772:
1773: htmlCtxtReset(ctxt);
1774: call_tests++;
1775: des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
1776: xmlResetLastError();
1777: if (mem_base != xmlMemBlocks()) {
1778: printf("Leak of %d blocks found in htmlCtxtReset",
1779: xmlMemBlocks() - mem_base);
1780: test_ret++;
1781: printf(" %d", n_ctxt);
1782: printf("\n");
1783: }
1784: }
1785: function_tests++;
1786: #endif
1787:
1788: return(test_ret);
1789: }
1790:
1791:
1792: static int
1793: test_htmlCtxtUseOptions(void) {
1794: int test_ret = 0;
1795:
1796: #if defined(LIBXML_HTML_ENABLED)
1797: int mem_base;
1798: int ret_val;
1799: htmlParserCtxtPtr ctxt; /* an HTML parser context */
1800: int n_ctxt;
1801: int options; /* a combination of htmlParserOption(s) */
1802: int n_options;
1803:
1804: for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
1805: for (n_options = 0;n_options < gen_nb_int;n_options++) {
1806: mem_base = xmlMemBlocks();
1807: ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
1808: options = gen_int(n_options, 1);
1809:
1810: ret_val = htmlCtxtUseOptions(ctxt, options);
1811: desret_int(ret_val);
1812: call_tests++;
1813: des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
1814: des_int(n_options, options, 1);
1815: xmlResetLastError();
1816: if (mem_base != xmlMemBlocks()) {
1817: printf("Leak of %d blocks found in htmlCtxtUseOptions",
1818: xmlMemBlocks() - mem_base);
1819: test_ret++;
1820: printf(" %d", n_ctxt);
1821: printf(" %d", n_options);
1822: printf("\n");
1823: }
1824: }
1825: }
1826: function_tests++;
1827: #endif
1828:
1829: return(test_ret);
1830: }
1831:
1832:
1833: static int
1834: test_htmlElementAllowedHere(void) {
1835: int test_ret = 0;
1836:
1837: #if defined(LIBXML_HTML_ENABLED)
1838: int mem_base;
1839: int ret_val;
1840: htmlElemDesc * parent; /* HTML parent element */
1841: int n_parent;
1842: xmlChar * elt; /* HTML element */
1843: int n_elt;
1844:
1845: for (n_parent = 0;n_parent < gen_nb_const_htmlElemDesc_ptr;n_parent++) {
1846: for (n_elt = 0;n_elt < gen_nb_const_xmlChar_ptr;n_elt++) {
1847: mem_base = xmlMemBlocks();
1848: parent = gen_const_htmlElemDesc_ptr(n_parent, 0);
1849: elt = gen_const_xmlChar_ptr(n_elt, 1);
1850:
1851: ret_val = htmlElementAllowedHere((const htmlElemDesc *)parent, (const xmlChar *)elt);
1852: desret_int(ret_val);
1853: call_tests++;
1854: des_const_htmlElemDesc_ptr(n_parent, (const htmlElemDesc *)parent, 0);
1855: des_const_xmlChar_ptr(n_elt, (const xmlChar *)elt, 1);
1856: xmlResetLastError();
1857: if (mem_base != xmlMemBlocks()) {
1858: printf("Leak of %d blocks found in htmlElementAllowedHere",
1859: xmlMemBlocks() - mem_base);
1860: test_ret++;
1861: printf(" %d", n_parent);
1862: printf(" %d", n_elt);
1863: printf("\n");
1864: }
1865: }
1866: }
1867: function_tests++;
1868: #endif
1869:
1870: return(test_ret);
1871: }
1872:
1873:
1874: static int
1875: test_htmlElementStatusHere(void) {
1876: int test_ret = 0;
1877:
1878: #if defined(LIBXML_HTML_ENABLED)
1879: int mem_base;
1880: htmlStatus ret_val;
1881: htmlElemDesc * parent; /* HTML parent element */
1882: int n_parent;
1883: htmlElemDesc * elt; /* HTML element */
1884: int n_elt;
1885:
1886: for (n_parent = 0;n_parent < gen_nb_const_htmlElemDesc_ptr;n_parent++) {
1887: for (n_elt = 0;n_elt < gen_nb_const_htmlElemDesc_ptr;n_elt++) {
1888: mem_base = xmlMemBlocks();
1889: parent = gen_const_htmlElemDesc_ptr(n_parent, 0);
1890: elt = gen_const_htmlElemDesc_ptr(n_elt, 1);
1891:
1892: ret_val = htmlElementStatusHere((const htmlElemDesc *)parent, (const htmlElemDesc *)elt);
1893: desret_htmlStatus(ret_val);
1894: call_tests++;
1895: des_const_htmlElemDesc_ptr(n_parent, (const htmlElemDesc *)parent, 0);
1896: des_const_htmlElemDesc_ptr(n_elt, (const htmlElemDesc *)elt, 1);
1897: xmlResetLastError();
1898: if (mem_base != xmlMemBlocks()) {
1899: printf("Leak of %d blocks found in htmlElementStatusHere",
1900: xmlMemBlocks() - mem_base);
1901: test_ret++;
1902: printf(" %d", n_parent);
1903: printf(" %d", n_elt);
1904: printf("\n");
1905: }
1906: }
1907: }
1908: function_tests++;
1909: #endif
1910:
1911: return(test_ret);
1912: }
1913:
1914:
1915: static int
1916: test_htmlEncodeEntities(void) {
1917: int test_ret = 0;
1918:
1919: #if defined(LIBXML_HTML_ENABLED)
1920: int mem_base;
1921: int ret_val;
1922: unsigned char * out; /* a pointer to an array of bytes to store the result */
1923: int n_out;
1924: int * outlen; /* the length of @out */
1925: int n_outlen;
1926: unsigned char * in; /* a pointer to an array of UTF-8 chars */
1927: int n_in;
1928: int * inlen; /* the length of @in */
1929: int n_inlen;
1930: int quoteChar; /* the quote character to escape (' or ") or zero. */
1931: int n_quoteChar;
1932:
1933: for (n_out = 0;n_out < gen_nb_unsigned_char_ptr;n_out++) {
1934: for (n_outlen = 0;n_outlen < gen_nb_int_ptr;n_outlen++) {
1935: for (n_in = 0;n_in < gen_nb_const_unsigned_char_ptr;n_in++) {
1936: for (n_inlen = 0;n_inlen < gen_nb_int_ptr;n_inlen++) {
1937: for (n_quoteChar = 0;n_quoteChar < gen_nb_int;n_quoteChar++) {
1938: mem_base = xmlMemBlocks();
1939: out = gen_unsigned_char_ptr(n_out, 0);
1940: outlen = gen_int_ptr(n_outlen, 1);
1941: in = gen_const_unsigned_char_ptr(n_in, 2);
1942: inlen = gen_int_ptr(n_inlen, 3);
1943: quoteChar = gen_int(n_quoteChar, 4);
1944:
1945: ret_val = htmlEncodeEntities(out, outlen, (const unsigned char *)in, inlen, quoteChar);
1946: desret_int(ret_val);
1947: call_tests++;
1948: des_unsigned_char_ptr(n_out, out, 0);
1949: des_int_ptr(n_outlen, outlen, 1);
1950: des_const_unsigned_char_ptr(n_in, (const unsigned char *)in, 2);
1951: des_int_ptr(n_inlen, inlen, 3);
1952: des_int(n_quoteChar, quoteChar, 4);
1953: xmlResetLastError();
1954: if (mem_base != xmlMemBlocks()) {
1955: printf("Leak of %d blocks found in htmlEncodeEntities",
1956: xmlMemBlocks() - mem_base);
1957: test_ret++;
1958: printf(" %d", n_out);
1959: printf(" %d", n_outlen);
1960: printf(" %d", n_in);
1961: printf(" %d", n_inlen);
1962: printf(" %d", n_quoteChar);
1963: printf("\n");
1964: }
1965: }
1966: }
1967: }
1968: }
1969: }
1970: function_tests++;
1971: #endif
1972:
1973: return(test_ret);
1974: }
1975:
1976:
1977: static int
1978: test_htmlEntityLookup(void) {
1979: int test_ret = 0;
1980:
1981: #if defined(LIBXML_HTML_ENABLED)
1982: int mem_base;
1983: const htmlEntityDesc * ret_val;
1984: xmlChar * name; /* the entity name */
1985: int n_name;
1986:
1987: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
1988: mem_base = xmlMemBlocks();
1989: name = gen_const_xmlChar_ptr(n_name, 0);
1990:
1991: ret_val = htmlEntityLookup((const xmlChar *)name);
1992: desret_const_htmlEntityDesc_ptr(ret_val);
1993: call_tests++;
1994: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
1995: xmlResetLastError();
1996: if (mem_base != xmlMemBlocks()) {
1997: printf("Leak of %d blocks found in htmlEntityLookup",
1998: xmlMemBlocks() - mem_base);
1999: test_ret++;
2000: printf(" %d", n_name);
2001: printf("\n");
2002: }
2003: }
2004: function_tests++;
2005: #endif
2006:
2007: return(test_ret);
2008: }
2009:
2010:
2011: static int
2012: test_htmlEntityValueLookup(void) {
2013: int test_ret = 0;
2014:
2015: #if defined(LIBXML_HTML_ENABLED)
2016: int mem_base;
2017: const htmlEntityDesc * ret_val;
2018: unsigned int value; /* the entity's unicode value */
2019: int n_value;
2020:
2021: for (n_value = 0;n_value < gen_nb_unsigned_int;n_value++) {
2022: mem_base = xmlMemBlocks();
2023: value = gen_unsigned_int(n_value, 0);
2024:
2025: ret_val = htmlEntityValueLookup(value);
2026: desret_const_htmlEntityDesc_ptr(ret_val);
2027: call_tests++;
2028: des_unsigned_int(n_value, value, 0);
2029: xmlResetLastError();
2030: if (mem_base != xmlMemBlocks()) {
2031: printf("Leak of %d blocks found in htmlEntityValueLookup",
2032: xmlMemBlocks() - mem_base);
2033: test_ret++;
2034: printf(" %d", n_value);
2035: printf("\n");
2036: }
2037: }
2038: function_tests++;
2039: #endif
2040:
2041: return(test_ret);
2042: }
2043:
2044:
2045: static int
2046: test_htmlHandleOmittedElem(void) {
2047: int test_ret = 0;
2048:
2049: #if defined(LIBXML_HTML_ENABLED)
2050: int mem_base;
2051: int ret_val;
2052: int val; /* int 0 or 1 */
2053: int n_val;
2054:
2055: for (n_val = 0;n_val < gen_nb_int;n_val++) {
2056: mem_base = xmlMemBlocks();
2057: val = gen_int(n_val, 0);
2058:
2059: ret_val = htmlHandleOmittedElem(val);
2060: desret_int(ret_val);
2061: call_tests++;
2062: des_int(n_val, val, 0);
2063: xmlResetLastError();
2064: if (mem_base != xmlMemBlocks()) {
2065: printf("Leak of %d blocks found in htmlHandleOmittedElem",
2066: xmlMemBlocks() - mem_base);
2067: test_ret++;
2068: printf(" %d", n_val);
2069: printf("\n");
2070: }
2071: }
2072: function_tests++;
2073: #endif
2074:
2075: return(test_ret);
2076: }
2077:
2078:
2079: static int
2080: test_htmlIsAutoClosed(void) {
2081: int test_ret = 0;
2082:
2083: #if defined(LIBXML_HTML_ENABLED)
2084: int mem_base;
2085: int ret_val;
2086: htmlDocPtr doc; /* the HTML document */
2087: int n_doc;
2088: htmlNodePtr elem; /* the HTML element */
2089: int n_elem;
2090:
2091: for (n_doc = 0;n_doc < gen_nb_htmlDocPtr;n_doc++) {
2092: for (n_elem = 0;n_elem < gen_nb_htmlNodePtr;n_elem++) {
2093: mem_base = xmlMemBlocks();
2094: doc = gen_htmlDocPtr(n_doc, 0);
2095: elem = gen_htmlNodePtr(n_elem, 1);
2096:
2097: ret_val = htmlIsAutoClosed(doc, elem);
2098: desret_int(ret_val);
2099: call_tests++;
2100: des_htmlDocPtr(n_doc, doc, 0);
2101: des_htmlNodePtr(n_elem, elem, 1);
2102: xmlResetLastError();
2103: if (mem_base != xmlMemBlocks()) {
2104: printf("Leak of %d blocks found in htmlIsAutoClosed",
2105: xmlMemBlocks() - mem_base);
2106: test_ret++;
2107: printf(" %d", n_doc);
2108: printf(" %d", n_elem);
2109: printf("\n");
2110: }
2111: }
2112: }
2113: function_tests++;
2114: #endif
2115:
2116: return(test_ret);
2117: }
2118:
2119:
2120: static int
2121: test_htmlIsScriptAttribute(void) {
2122: int test_ret = 0;
2123:
2124: #if defined(LIBXML_HTML_ENABLED)
2125: int mem_base;
2126: int ret_val;
2127: xmlChar * name; /* an attribute name */
2128: int n_name;
2129:
2130: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
2131: mem_base = xmlMemBlocks();
2132: name = gen_const_xmlChar_ptr(n_name, 0);
2133:
2134: ret_val = htmlIsScriptAttribute((const xmlChar *)name);
2135: desret_int(ret_val);
2136: call_tests++;
2137: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
2138: xmlResetLastError();
2139: if (mem_base != xmlMemBlocks()) {
2140: printf("Leak of %d blocks found in htmlIsScriptAttribute",
2141: xmlMemBlocks() - mem_base);
2142: test_ret++;
2143: printf(" %d", n_name);
2144: printf("\n");
2145: }
2146: }
2147: function_tests++;
2148: #endif
2149:
2150: return(test_ret);
2151: }
2152:
2153:
2154: static int
2155: test_htmlNewParserCtxt(void) {
2156: int test_ret = 0;
2157:
2158: #if defined(LIBXML_HTML_ENABLED)
2159: int mem_base;
2160: htmlParserCtxtPtr ret_val;
2161:
2162: mem_base = xmlMemBlocks();
2163:
2164: ret_val = htmlNewParserCtxt();
2165: desret_htmlParserCtxtPtr(ret_val);
2166: call_tests++;
2167: xmlResetLastError();
2168: if (mem_base != xmlMemBlocks()) {
2169: printf("Leak of %d blocks found in htmlNewParserCtxt",
2170: xmlMemBlocks() - mem_base);
2171: test_ret++;
2172: printf("\n");
2173: }
2174: function_tests++;
2175: #endif
2176:
2177: return(test_ret);
2178: }
2179:
2180:
2181: static int
2182: test_htmlNodeStatus(void) {
2183: int test_ret = 0;
2184:
2185: #if defined(LIBXML_HTML_ENABLED)
2186: int mem_base;
2187: htmlStatus ret_val;
2188: htmlNodePtr node; /* an htmlNodePtr in a tree */
2189: int n_node;
2190: int legacy; /* whether to allow deprecated elements (YES is faster here for Element nodes) */
2191: int n_legacy;
2192:
2193: for (n_node = 0;n_node < gen_nb_const_htmlNodePtr;n_node++) {
2194: for (n_legacy = 0;n_legacy < gen_nb_int;n_legacy++) {
2195: mem_base = xmlMemBlocks();
2196: node = gen_const_htmlNodePtr(n_node, 0);
2197: legacy = gen_int(n_legacy, 1);
2198:
2199: ret_val = htmlNodeStatus((const htmlNodePtr)node, legacy);
2200: desret_htmlStatus(ret_val);
2201: call_tests++;
2202: des_const_htmlNodePtr(n_node, (const htmlNodePtr)node, 0);
2203: des_int(n_legacy, legacy, 1);
2204: xmlResetLastError();
2205: if (mem_base != xmlMemBlocks()) {
2206: printf("Leak of %d blocks found in htmlNodeStatus",
2207: xmlMemBlocks() - mem_base);
2208: test_ret++;
2209: printf(" %d", n_node);
2210: printf(" %d", n_legacy);
2211: printf("\n");
2212: }
2213: }
2214: }
2215: function_tests++;
2216: #endif
2217:
2218: return(test_ret);
2219: }
2220:
2221:
2222: static int
2223: test_htmlParseCharRef(void) {
2224: int test_ret = 0;
2225:
2226: #if defined(LIBXML_HTML_ENABLED)
2227: int mem_base;
2228: int ret_val;
2229: htmlParserCtxtPtr ctxt; /* an HTML parser context */
2230: int n_ctxt;
2231:
2232: for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
2233: mem_base = xmlMemBlocks();
2234: ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
2235:
2236: ret_val = htmlParseCharRef(ctxt);
2237: desret_int(ret_val);
2238: call_tests++;
2239: des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
2240: xmlResetLastError();
2241: if (mem_base != xmlMemBlocks()) {
2242: printf("Leak of %d blocks found in htmlParseCharRef",
2243: xmlMemBlocks() - mem_base);
2244: test_ret++;
2245: printf(" %d", n_ctxt);
2246: printf("\n");
2247: }
2248: }
2249: function_tests++;
2250: #endif
2251:
2252: return(test_ret);
2253: }
2254:
2255:
2256: static int
2257: test_htmlParseChunk(void) {
2258: int test_ret = 0;
2259:
2260: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_PUSH_ENABLED)
2261: int mem_base;
2262: int ret_val;
2263: htmlParserCtxtPtr ctxt; /* an HTML parser context */
2264: int n_ctxt;
2265: char * chunk; /* an char array */
2266: int n_chunk;
2267: int size; /* the size in byte of the chunk */
2268: int n_size;
2269: int terminate; /* last chunk indicator */
2270: int n_terminate;
2271:
2272: for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
2273: for (n_chunk = 0;n_chunk < gen_nb_const_char_ptr;n_chunk++) {
2274: for (n_size = 0;n_size < gen_nb_int;n_size++) {
2275: for (n_terminate = 0;n_terminate < gen_nb_int;n_terminate++) {
2276: mem_base = xmlMemBlocks();
2277: ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
2278: chunk = gen_const_char_ptr(n_chunk, 1);
2279: size = gen_int(n_size, 2);
2280: terminate = gen_int(n_terminate, 3);
2281:
2282: ret_val = htmlParseChunk(ctxt, (const char *)chunk, size, terminate);
2283: if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;}
2284: desret_int(ret_val);
2285: call_tests++;
2286: des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
2287: des_const_char_ptr(n_chunk, (const char *)chunk, 1);
2288: des_int(n_size, size, 2);
2289: des_int(n_terminate, terminate, 3);
2290: xmlResetLastError();
2291: if (mem_base != xmlMemBlocks()) {
2292: printf("Leak of %d blocks found in htmlParseChunk",
2293: xmlMemBlocks() - mem_base);
2294: test_ret++;
2295: printf(" %d", n_ctxt);
2296: printf(" %d", n_chunk);
2297: printf(" %d", n_size);
2298: printf(" %d", n_terminate);
2299: printf("\n");
2300: }
2301: }
2302: }
2303: }
2304: }
2305: function_tests++;
2306: #endif
2307:
2308: return(test_ret);
2309: }
2310:
2311:
2312: static int
2313: test_htmlParseDoc(void) {
2314: int test_ret = 0;
2315:
2316: #if defined(LIBXML_HTML_ENABLED)
2317: int mem_base;
2318: htmlDocPtr ret_val;
2319: xmlChar * cur; /* a pointer to an array of xmlChar */
2320: int n_cur;
2321: char * encoding; /* a free form C string describing the HTML document encoding, or NULL */
2322: int n_encoding;
2323:
2324: for (n_cur = 0;n_cur < gen_nb_xmlChar_ptr;n_cur++) {
2325: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
2326: mem_base = xmlMemBlocks();
2327: cur = gen_xmlChar_ptr(n_cur, 0);
2328: encoding = gen_const_char_ptr(n_encoding, 1);
2329:
2330: ret_val = htmlParseDoc(cur, (const char *)encoding);
2331: desret_htmlDocPtr(ret_val);
2332: call_tests++;
2333: des_xmlChar_ptr(n_cur, cur, 0);
2334: des_const_char_ptr(n_encoding, (const char *)encoding, 1);
2335: xmlResetLastError();
2336: if (mem_base != xmlMemBlocks()) {
2337: printf("Leak of %d blocks found in htmlParseDoc",
2338: xmlMemBlocks() - mem_base);
2339: test_ret++;
2340: printf(" %d", n_cur);
2341: printf(" %d", n_encoding);
2342: printf("\n");
2343: }
2344: }
2345: }
2346: function_tests++;
2347: #endif
2348:
2349: return(test_ret);
2350: }
2351:
2352:
2353: static int
2354: test_htmlParseDocument(void) {
2355: int test_ret = 0;
2356:
2357: #if defined(LIBXML_HTML_ENABLED)
2358: int mem_base;
2359: int ret_val;
2360: htmlParserCtxtPtr ctxt; /* an HTML parser context */
2361: int n_ctxt;
2362:
2363: for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
2364: mem_base = xmlMemBlocks();
2365: ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
2366:
2367: ret_val = htmlParseDocument(ctxt);
2368: if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;}
2369: desret_int(ret_val);
2370: call_tests++;
2371: des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
2372: xmlResetLastError();
2373: if (mem_base != xmlMemBlocks()) {
2374: printf("Leak of %d blocks found in htmlParseDocument",
2375: xmlMemBlocks() - mem_base);
2376: test_ret++;
2377: printf(" %d", n_ctxt);
2378: printf("\n");
2379: }
2380: }
2381: function_tests++;
2382: #endif
2383:
2384: return(test_ret);
2385: }
2386:
2387:
2388: static int
2389: test_htmlParseElement(void) {
2390: int test_ret = 0;
2391:
2392: #if defined(LIBXML_HTML_ENABLED)
2393: int mem_base;
2394: htmlParserCtxtPtr ctxt; /* an HTML parser context */
2395: int n_ctxt;
2396:
2397: for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
2398: mem_base = xmlMemBlocks();
2399: ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
2400:
2401: htmlParseElement(ctxt);
2402: call_tests++;
2403: des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
2404: xmlResetLastError();
2405: if (mem_base != xmlMemBlocks()) {
2406: printf("Leak of %d blocks found in htmlParseElement",
2407: xmlMemBlocks() - mem_base);
2408: test_ret++;
2409: printf(" %d", n_ctxt);
2410: printf("\n");
2411: }
2412: }
2413: function_tests++;
2414: #endif
2415:
2416: return(test_ret);
2417: }
2418:
2419:
2420: static int
2421: test_htmlParseEntityRef(void) {
2422: int test_ret = 0;
2423:
2424: #if defined(LIBXML_HTML_ENABLED)
2425: int mem_base;
2426: const htmlEntityDesc * ret_val;
2427: htmlParserCtxtPtr ctxt; /* an HTML parser context */
2428: int n_ctxt;
2429: xmlChar ** str; /* location to store the entity name */
2430: int n_str;
2431:
2432: for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
2433: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr_ptr;n_str++) {
2434: mem_base = xmlMemBlocks();
2435: ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
2436: str = gen_const_xmlChar_ptr_ptr(n_str, 1);
2437:
2438: ret_val = htmlParseEntityRef(ctxt, (const xmlChar **)str);
2439: desret_const_htmlEntityDesc_ptr(ret_val);
2440: call_tests++;
2441: des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
2442: des_const_xmlChar_ptr_ptr(n_str, (const xmlChar **)str, 1);
2443: xmlResetLastError();
2444: if (mem_base != xmlMemBlocks()) {
2445: printf("Leak of %d blocks found in htmlParseEntityRef",
2446: xmlMemBlocks() - mem_base);
2447: test_ret++;
2448: printf(" %d", n_ctxt);
2449: printf(" %d", n_str);
2450: printf("\n");
2451: }
2452: }
2453: }
2454: function_tests++;
2455: #endif
2456:
2457: return(test_ret);
2458: }
2459:
2460:
2461: static int
2462: test_htmlParseFile(void) {
2463: int test_ret = 0;
2464:
2465: #if defined(LIBXML_HTML_ENABLED)
2466: htmlDocPtr ret_val;
2467: const char * filename; /* the filename */
2468: int n_filename;
2469: char * encoding; /* a free form C string describing the HTML document encoding, or NULL */
2470: int n_encoding;
2471:
2472: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
2473: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
2474: filename = gen_filepath(n_filename, 0);
2475: encoding = gen_const_char_ptr(n_encoding, 1);
2476:
2477: ret_val = htmlParseFile(filename, (const char *)encoding);
2478: desret_htmlDocPtr(ret_val);
2479: call_tests++;
2480: des_filepath(n_filename, filename, 0);
2481: des_const_char_ptr(n_encoding, (const char *)encoding, 1);
2482: xmlResetLastError();
2483: }
2484: }
2485: function_tests++;
2486: #endif
2487:
2488: return(test_ret);
2489: }
2490:
2491:
2492: static int
2493: test_htmlReadDoc(void) {
2494: int test_ret = 0;
2495:
2496: #if defined(LIBXML_HTML_ENABLED)
2497: int mem_base;
2498: htmlDocPtr ret_val;
2499: xmlChar * cur; /* a pointer to a zero terminated string */
2500: int n_cur;
2501: const char * URL; /* the base URL to use for the document */
2502: int n_URL;
2503: char * encoding; /* the document encoding, or NULL */
2504: int n_encoding;
2505: int options; /* a combination of htmlParserOption(s) */
2506: int n_options;
2507:
2508: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
2509: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
2510: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
2511: for (n_options = 0;n_options < gen_nb_int;n_options++) {
2512: mem_base = xmlMemBlocks();
2513: cur = gen_const_xmlChar_ptr(n_cur, 0);
2514: URL = gen_filepath(n_URL, 1);
2515: encoding = gen_const_char_ptr(n_encoding, 2);
2516: options = gen_int(n_options, 3);
2517:
2518: ret_val = htmlReadDoc((const xmlChar *)cur, URL, (const char *)encoding, options);
2519: desret_htmlDocPtr(ret_val);
2520: call_tests++;
2521: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
2522: des_filepath(n_URL, URL, 1);
2523: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
2524: des_int(n_options, options, 3);
2525: xmlResetLastError();
2526: if (mem_base != xmlMemBlocks()) {
2527: printf("Leak of %d blocks found in htmlReadDoc",
2528: xmlMemBlocks() - mem_base);
2529: test_ret++;
2530: printf(" %d", n_cur);
2531: printf(" %d", n_URL);
2532: printf(" %d", n_encoding);
2533: printf(" %d", n_options);
2534: printf("\n");
2535: }
2536: }
2537: }
2538: }
2539: }
2540: function_tests++;
2541: #endif
2542:
2543: return(test_ret);
2544: }
2545:
2546:
2547: static int
2548: test_htmlReadFile(void) {
2549: int test_ret = 0;
2550:
2551: #if defined(LIBXML_HTML_ENABLED)
2552: int mem_base;
2553: htmlDocPtr ret_val;
2554: const char * filename; /* a file or URL */
2555: int n_filename;
2556: char * encoding; /* the document encoding, or NULL */
2557: int n_encoding;
2558: int options; /* a combination of htmlParserOption(s) */
2559: int n_options;
2560:
2561: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
2562: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
2563: for (n_options = 0;n_options < gen_nb_int;n_options++) {
2564: mem_base = xmlMemBlocks();
2565: filename = gen_filepath(n_filename, 0);
2566: encoding = gen_const_char_ptr(n_encoding, 1);
2567: options = gen_int(n_options, 2);
2568:
2569: ret_val = htmlReadFile(filename, (const char *)encoding, options);
2570: desret_htmlDocPtr(ret_val);
2571: call_tests++;
2572: des_filepath(n_filename, filename, 0);
2573: des_const_char_ptr(n_encoding, (const char *)encoding, 1);
2574: des_int(n_options, options, 2);
2575: xmlResetLastError();
2576: if (mem_base != xmlMemBlocks()) {
2577: printf("Leak of %d blocks found in htmlReadFile",
2578: xmlMemBlocks() - mem_base);
2579: test_ret++;
2580: printf(" %d", n_filename);
2581: printf(" %d", n_encoding);
2582: printf(" %d", n_options);
2583: printf("\n");
2584: }
2585: }
2586: }
2587: }
2588: function_tests++;
2589: #endif
2590:
2591: return(test_ret);
2592: }
2593:
2594:
2595: static int
2596: test_htmlReadMemory(void) {
2597: int test_ret = 0;
2598:
2599: #if defined(LIBXML_HTML_ENABLED)
2600: int mem_base;
2601: htmlDocPtr ret_val;
2602: char * buffer; /* a pointer to a char array */
2603: int n_buffer;
2604: int size; /* the size of the array */
2605: int n_size;
2606: const char * URL; /* the base URL to use for the document */
2607: int n_URL;
2608: char * encoding; /* the document encoding, or NULL */
2609: int n_encoding;
2610: int options; /* a combination of htmlParserOption(s) */
2611: int n_options;
2612:
2613: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
2614: for (n_size = 0;n_size < gen_nb_int;n_size++) {
2615: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
2616: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
2617: for (n_options = 0;n_options < gen_nb_int;n_options++) {
2618: mem_base = xmlMemBlocks();
2619: buffer = gen_const_char_ptr(n_buffer, 0);
2620: size = gen_int(n_size, 1);
2621: URL = gen_filepath(n_URL, 2);
2622: encoding = gen_const_char_ptr(n_encoding, 3);
2623: options = gen_int(n_options, 4);
2624:
2625: ret_val = htmlReadMemory((const char *)buffer, size, URL, (const char *)encoding, options);
2626: desret_htmlDocPtr(ret_val);
2627: call_tests++;
2628: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
2629: des_int(n_size, size, 1);
2630: des_filepath(n_URL, URL, 2);
2631: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
2632: des_int(n_options, options, 4);
2633: xmlResetLastError();
2634: if (mem_base != xmlMemBlocks()) {
2635: printf("Leak of %d blocks found in htmlReadMemory",
2636: xmlMemBlocks() - mem_base);
2637: test_ret++;
2638: printf(" %d", n_buffer);
2639: printf(" %d", n_size);
2640: printf(" %d", n_URL);
2641: printf(" %d", n_encoding);
2642: printf(" %d", n_options);
2643: printf("\n");
2644: }
2645: }
2646: }
2647: }
2648: }
2649: }
2650: function_tests++;
2651: #endif
2652:
2653: return(test_ret);
2654: }
2655:
2656:
2657: static int
2658: test_htmlSAXParseDoc(void) {
2659: int test_ret = 0;
2660:
2661: #if defined(LIBXML_HTML_ENABLED)
2662: int mem_base;
2663: htmlDocPtr ret_val;
2664: xmlChar * cur; /* a pointer to an array of xmlChar */
2665: int n_cur;
2666: char * encoding; /* a free form C string describing the HTML document encoding, or NULL */
2667: int n_encoding;
2668: htmlSAXHandlerPtr sax; /* the SAX handler block */
2669: int n_sax;
2670: void * userData; /* if using SAX, this pointer will be provided on callbacks. */
2671: int n_userData;
2672:
2673: for (n_cur = 0;n_cur < gen_nb_xmlChar_ptr;n_cur++) {
2674: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
2675: for (n_sax = 0;n_sax < gen_nb_htmlSAXHandlerPtr;n_sax++) {
2676: for (n_userData = 0;n_userData < gen_nb_userdata;n_userData++) {
2677: mem_base = xmlMemBlocks();
2678: cur = gen_xmlChar_ptr(n_cur, 0);
2679: encoding = gen_const_char_ptr(n_encoding, 1);
2680: sax = gen_htmlSAXHandlerPtr(n_sax, 2);
2681: userData = gen_userdata(n_userData, 3);
2682:
2683: ret_val = htmlSAXParseDoc(cur, (const char *)encoding, sax, userData);
2684: desret_htmlDocPtr(ret_val);
2685: call_tests++;
2686: des_xmlChar_ptr(n_cur, cur, 0);
2687: des_const_char_ptr(n_encoding, (const char *)encoding, 1);
2688: des_htmlSAXHandlerPtr(n_sax, sax, 2);
2689: des_userdata(n_userData, userData, 3);
2690: xmlResetLastError();
2691: if (mem_base != xmlMemBlocks()) {
2692: printf("Leak of %d blocks found in htmlSAXParseDoc",
2693: xmlMemBlocks() - mem_base);
2694: test_ret++;
2695: printf(" %d", n_cur);
2696: printf(" %d", n_encoding);
2697: printf(" %d", n_sax);
2698: printf(" %d", n_userData);
2699: printf("\n");
2700: }
2701: }
2702: }
2703: }
2704: }
2705: function_tests++;
2706: #endif
2707:
2708: return(test_ret);
2709: }
2710:
2711:
2712: static int
2713: test_htmlSAXParseFile(void) {
2714: int test_ret = 0;
2715:
2716: #if defined(LIBXML_HTML_ENABLED)
2717: int mem_base;
2718: htmlDocPtr ret_val;
2719: const char * filename; /* the filename */
2720: int n_filename;
2721: char * encoding; /* a free form C string describing the HTML document encoding, or NULL */
2722: int n_encoding;
2723: htmlSAXHandlerPtr sax; /* the SAX handler block */
2724: int n_sax;
2725: void * userData; /* if using SAX, this pointer will be provided on callbacks. */
2726: int n_userData;
2727:
2728: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
2729: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
2730: for (n_sax = 0;n_sax < gen_nb_htmlSAXHandlerPtr;n_sax++) {
2731: for (n_userData = 0;n_userData < gen_nb_userdata;n_userData++) {
2732: mem_base = xmlMemBlocks();
2733: filename = gen_filepath(n_filename, 0);
2734: encoding = gen_const_char_ptr(n_encoding, 1);
2735: sax = gen_htmlSAXHandlerPtr(n_sax, 2);
2736: userData = gen_userdata(n_userData, 3);
2737:
2738: ret_val = htmlSAXParseFile(filename, (const char *)encoding, sax, userData);
2739: desret_htmlDocPtr(ret_val);
2740: call_tests++;
2741: des_filepath(n_filename, filename, 0);
2742: des_const_char_ptr(n_encoding, (const char *)encoding, 1);
2743: des_htmlSAXHandlerPtr(n_sax, sax, 2);
2744: des_userdata(n_userData, userData, 3);
2745: xmlResetLastError();
2746: if (mem_base != xmlMemBlocks()) {
2747: printf("Leak of %d blocks found in htmlSAXParseFile",
2748: xmlMemBlocks() - mem_base);
2749: test_ret++;
2750: printf(" %d", n_filename);
2751: printf(" %d", n_encoding);
2752: printf(" %d", n_sax);
2753: printf(" %d", n_userData);
2754: printf("\n");
2755: }
2756: }
2757: }
2758: }
2759: }
2760: function_tests++;
2761: #endif
2762:
2763: return(test_ret);
2764: }
2765:
2766:
2767: static int
2768: test_htmlTagLookup(void) {
2769: int test_ret = 0;
2770:
2771:
2772: /* missing type support */
2773: return(test_ret);
2774: }
2775:
2776: static int
2777: test_HTMLparser(void) {
2778: int test_ret = 0;
2779:
2780: if (quiet == 0) printf("Testing HTMLparser : 32 of 38 functions ...\n");
2781: test_ret += test_UTF8ToHtml();
2782: test_ret += test_htmlAttrAllowed();
2783: test_ret += test_htmlAutoCloseTag();
2784: test_ret += test_htmlCreateMemoryParserCtxt();
2785: test_ret += test_htmlCreatePushParserCtxt();
2786: test_ret += test_htmlCtxtReadDoc();
2787: test_ret += test_htmlCtxtReadFile();
2788: test_ret += test_htmlCtxtReadMemory();
2789: test_ret += test_htmlCtxtReset();
2790: test_ret += test_htmlCtxtUseOptions();
2791: test_ret += test_htmlElementAllowedHere();
2792: test_ret += test_htmlElementStatusHere();
2793: test_ret += test_htmlEncodeEntities();
2794: test_ret += test_htmlEntityLookup();
2795: test_ret += test_htmlEntityValueLookup();
2796: test_ret += test_htmlHandleOmittedElem();
2797: test_ret += test_htmlIsAutoClosed();
2798: test_ret += test_htmlIsScriptAttribute();
2799: test_ret += test_htmlNewParserCtxt();
2800: test_ret += test_htmlNodeStatus();
2801: test_ret += test_htmlParseCharRef();
2802: test_ret += test_htmlParseChunk();
2803: test_ret += test_htmlParseDoc();
2804: test_ret += test_htmlParseDocument();
2805: test_ret += test_htmlParseElement();
2806: test_ret += test_htmlParseEntityRef();
2807: test_ret += test_htmlParseFile();
2808: test_ret += test_htmlReadDoc();
2809: test_ret += test_htmlReadFile();
2810: test_ret += test_htmlReadMemory();
2811: test_ret += test_htmlSAXParseDoc();
2812: test_ret += test_htmlSAXParseFile();
2813: test_ret += test_htmlTagLookup();
2814:
2815: if (test_ret != 0)
2816: printf("Module HTMLparser: %d errors\n", test_ret);
2817: return(test_ret);
2818: }
2819:
2820: static int
2821: test_htmlDocContentDumpFormatOutput(void) {
2822: int test_ret = 0;
2823:
2824: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
2825: int mem_base;
2826: xmlOutputBufferPtr buf; /* the HTML buffer output */
2827: int n_buf;
2828: xmlDocPtr cur; /* the document */
2829: int n_cur;
2830: char * encoding; /* the encoding string */
2831: int n_encoding;
2832: int format; /* should formatting spaces been added */
2833: int n_format;
2834:
2835: for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
2836: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
2837: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
2838: for (n_format = 0;n_format < gen_nb_int;n_format++) {
2839: mem_base = xmlMemBlocks();
2840: buf = gen_xmlOutputBufferPtr(n_buf, 0);
2841: cur = gen_xmlDocPtr(n_cur, 1);
2842: encoding = gen_const_char_ptr(n_encoding, 2);
2843: format = gen_int(n_format, 3);
2844:
2845: htmlDocContentDumpFormatOutput(buf, cur, (const char *)encoding, format);
2846: call_tests++;
2847: des_xmlOutputBufferPtr(n_buf, buf, 0);
2848: des_xmlDocPtr(n_cur, cur, 1);
2849: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
2850: des_int(n_format, format, 3);
2851: xmlResetLastError();
2852: if (mem_base != xmlMemBlocks()) {
2853: printf("Leak of %d blocks found in htmlDocContentDumpFormatOutput",
2854: xmlMemBlocks() - mem_base);
2855: test_ret++;
2856: printf(" %d", n_buf);
2857: printf(" %d", n_cur);
2858: printf(" %d", n_encoding);
2859: printf(" %d", n_format);
2860: printf("\n");
2861: }
2862: }
2863: }
2864: }
2865: }
2866: function_tests++;
2867: #endif
2868:
2869: return(test_ret);
2870: }
2871:
2872:
2873: static int
2874: test_htmlDocContentDumpOutput(void) {
2875: int test_ret = 0;
2876:
2877: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
2878: int mem_base;
2879: xmlOutputBufferPtr buf; /* the HTML buffer output */
2880: int n_buf;
2881: xmlDocPtr cur; /* the document */
2882: int n_cur;
2883: char * encoding; /* the encoding string */
2884: int n_encoding;
2885:
2886: for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
2887: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
2888: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
2889: mem_base = xmlMemBlocks();
2890: buf = gen_xmlOutputBufferPtr(n_buf, 0);
2891: cur = gen_xmlDocPtr(n_cur, 1);
2892: encoding = gen_const_char_ptr(n_encoding, 2);
2893:
2894: htmlDocContentDumpOutput(buf, cur, (const char *)encoding);
2895: call_tests++;
2896: des_xmlOutputBufferPtr(n_buf, buf, 0);
2897: des_xmlDocPtr(n_cur, cur, 1);
2898: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
2899: xmlResetLastError();
2900: if (mem_base != xmlMemBlocks()) {
2901: printf("Leak of %d blocks found in htmlDocContentDumpOutput",
2902: xmlMemBlocks() - mem_base);
2903: test_ret++;
2904: printf(" %d", n_buf);
2905: printf(" %d", n_cur);
2906: printf(" %d", n_encoding);
2907: printf("\n");
2908: }
2909: }
2910: }
2911: }
2912: function_tests++;
2913: #endif
2914:
2915: return(test_ret);
2916: }
2917:
2918:
2919: static int
2920: test_htmlDocDump(void) {
2921: int test_ret = 0;
2922:
2923: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
2924: int mem_base;
2925: int ret_val;
2926: FILE * f; /* the FILE* */
2927: int n_f;
2928: xmlDocPtr cur; /* the document */
2929: int n_cur;
2930:
2931: for (n_f = 0;n_f < gen_nb_FILE_ptr;n_f++) {
2932: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
2933: mem_base = xmlMemBlocks();
2934: f = gen_FILE_ptr(n_f, 0);
2935: cur = gen_xmlDocPtr(n_cur, 1);
2936:
2937: ret_val = htmlDocDump(f, cur);
2938: desret_int(ret_val);
2939: call_tests++;
2940: des_FILE_ptr(n_f, f, 0);
2941: des_xmlDocPtr(n_cur, cur, 1);
2942: xmlResetLastError();
2943: if (mem_base != xmlMemBlocks()) {
2944: printf("Leak of %d blocks found in htmlDocDump",
2945: xmlMemBlocks() - mem_base);
2946: test_ret++;
2947: printf(" %d", n_f);
2948: printf(" %d", n_cur);
2949: printf("\n");
2950: }
2951: }
2952: }
2953: function_tests++;
2954: #endif
2955:
2956: return(test_ret);
2957: }
2958:
2959:
2960: #define gen_nb_xmlChar_ptr_ptr 1
2961: static xmlChar ** gen_xmlChar_ptr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
2962: return(NULL);
2963: }
2964: static void des_xmlChar_ptr_ptr(int no ATTRIBUTE_UNUSED, xmlChar ** val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
2965: }
2966:
2967: static int
2968: test_htmlDocDumpMemory(void) {
2969: int test_ret = 0;
2970:
2971: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
2972: int mem_base;
2973: xmlDocPtr cur; /* the document */
2974: int n_cur;
2975: xmlChar ** mem; /* OUT: the memory pointer */
2976: int n_mem;
2977: int * size; /* OUT: the memory length */
2978: int n_size;
2979:
2980: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
2981: for (n_mem = 0;n_mem < gen_nb_xmlChar_ptr_ptr;n_mem++) {
2982: for (n_size = 0;n_size < gen_nb_int_ptr;n_size++) {
2983: mem_base = xmlMemBlocks();
2984: cur = gen_xmlDocPtr(n_cur, 0);
2985: mem = gen_xmlChar_ptr_ptr(n_mem, 1);
2986: size = gen_int_ptr(n_size, 2);
2987:
2988: htmlDocDumpMemory(cur, mem, size);
2989: call_tests++;
2990: des_xmlDocPtr(n_cur, cur, 0);
2991: des_xmlChar_ptr_ptr(n_mem, mem, 1);
2992: des_int_ptr(n_size, size, 2);
2993: xmlResetLastError();
2994: if (mem_base != xmlMemBlocks()) {
2995: printf("Leak of %d blocks found in htmlDocDumpMemory",
2996: xmlMemBlocks() - mem_base);
2997: test_ret++;
2998: printf(" %d", n_cur);
2999: printf(" %d", n_mem);
3000: printf(" %d", n_size);
3001: printf("\n");
3002: }
3003: }
3004: }
3005: }
3006: function_tests++;
3007: #endif
3008:
3009: return(test_ret);
3010: }
3011:
3012:
3013: static int
3014: test_htmlDocDumpMemoryFormat(void) {
3015: int test_ret = 0;
3016:
3017: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
3018: int mem_base;
3019: xmlDocPtr cur; /* the document */
3020: int n_cur;
3021: xmlChar ** mem; /* OUT: the memory pointer */
3022: int n_mem;
3023: int * size; /* OUT: the memory length */
3024: int n_size;
3025: int format; /* should formatting spaces been added */
3026: int n_format;
3027:
3028: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
3029: for (n_mem = 0;n_mem < gen_nb_xmlChar_ptr_ptr;n_mem++) {
3030: for (n_size = 0;n_size < gen_nb_int_ptr;n_size++) {
3031: for (n_format = 0;n_format < gen_nb_int;n_format++) {
3032: mem_base = xmlMemBlocks();
3033: cur = gen_xmlDocPtr(n_cur, 0);
3034: mem = gen_xmlChar_ptr_ptr(n_mem, 1);
3035: size = gen_int_ptr(n_size, 2);
3036: format = gen_int(n_format, 3);
3037:
3038: htmlDocDumpMemoryFormat(cur, mem, size, format);
3039: call_tests++;
3040: des_xmlDocPtr(n_cur, cur, 0);
3041: des_xmlChar_ptr_ptr(n_mem, mem, 1);
3042: des_int_ptr(n_size, size, 2);
3043: des_int(n_format, format, 3);
3044: xmlResetLastError();
3045: if (mem_base != xmlMemBlocks()) {
3046: printf("Leak of %d blocks found in htmlDocDumpMemoryFormat",
3047: xmlMemBlocks() - mem_base);
3048: test_ret++;
3049: printf(" %d", n_cur);
3050: printf(" %d", n_mem);
3051: printf(" %d", n_size);
3052: printf(" %d", n_format);
3053: printf("\n");
3054: }
3055: }
3056: }
3057: }
3058: }
3059: function_tests++;
3060: #endif
3061:
3062: return(test_ret);
3063: }
3064:
3065:
3066: static int
3067: test_htmlGetMetaEncoding(void) {
3068: int test_ret = 0;
3069:
3070: #if defined(LIBXML_HTML_ENABLED)
3071: int mem_base;
3072: const xmlChar * ret_val;
3073: htmlDocPtr doc; /* the document */
3074: int n_doc;
3075:
3076: for (n_doc = 0;n_doc < gen_nb_htmlDocPtr;n_doc++) {
3077: mem_base = xmlMemBlocks();
3078: doc = gen_htmlDocPtr(n_doc, 0);
3079:
3080: ret_val = htmlGetMetaEncoding(doc);
3081: desret_const_xmlChar_ptr(ret_val);
3082: call_tests++;
3083: des_htmlDocPtr(n_doc, doc, 0);
3084: xmlResetLastError();
3085: if (mem_base != xmlMemBlocks()) {
3086: printf("Leak of %d blocks found in htmlGetMetaEncoding",
3087: xmlMemBlocks() - mem_base);
3088: test_ret++;
3089: printf(" %d", n_doc);
3090: printf("\n");
3091: }
3092: }
3093: function_tests++;
3094: #endif
3095:
3096: return(test_ret);
3097: }
3098:
3099:
3100: static int
3101: test_htmlIsBooleanAttr(void) {
3102: int test_ret = 0;
3103:
3104: #if defined(LIBXML_HTML_ENABLED)
3105: int mem_base;
3106: int ret_val;
3107: xmlChar * name; /* the name of the attribute to check */
3108: int n_name;
3109:
3110: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
3111: mem_base = xmlMemBlocks();
3112: name = gen_const_xmlChar_ptr(n_name, 0);
3113:
3114: ret_val = htmlIsBooleanAttr((const xmlChar *)name);
3115: desret_int(ret_val);
3116: call_tests++;
3117: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
3118: xmlResetLastError();
3119: if (mem_base != xmlMemBlocks()) {
3120: printf("Leak of %d blocks found in htmlIsBooleanAttr",
3121: xmlMemBlocks() - mem_base);
3122: test_ret++;
3123: printf(" %d", n_name);
3124: printf("\n");
3125: }
3126: }
3127: function_tests++;
3128: #endif
3129:
3130: return(test_ret);
3131: }
3132:
3133:
3134: static int
3135: test_htmlNewDoc(void) {
3136: int test_ret = 0;
3137:
3138: #if defined(LIBXML_HTML_ENABLED)
3139: int mem_base;
3140: htmlDocPtr ret_val;
3141: xmlChar * URI; /* URI for the dtd, or NULL */
3142: int n_URI;
3143: xmlChar * ExternalID; /* the external ID of the DTD, or NULL */
3144: int n_ExternalID;
3145:
3146: for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
3147: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
3148: mem_base = xmlMemBlocks();
3149: URI = gen_const_xmlChar_ptr(n_URI, 0);
3150: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 1);
3151:
3152: ret_val = htmlNewDoc((const xmlChar *)URI, (const xmlChar *)ExternalID);
3153: desret_htmlDocPtr(ret_val);
3154: call_tests++;
3155: des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 0);
3156: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 1);
3157: xmlResetLastError();
3158: if (mem_base != xmlMemBlocks()) {
3159: printf("Leak of %d blocks found in htmlNewDoc",
3160: xmlMemBlocks() - mem_base);
3161: test_ret++;
3162: printf(" %d", n_URI);
3163: printf(" %d", n_ExternalID);
3164: printf("\n");
3165: }
3166: }
3167: }
3168: function_tests++;
3169: #endif
3170:
3171: return(test_ret);
3172: }
3173:
3174:
3175: static int
3176: test_htmlNewDocNoDtD(void) {
3177: int test_ret = 0;
3178:
3179: #if defined(LIBXML_HTML_ENABLED)
3180: int mem_base;
3181: htmlDocPtr ret_val;
3182: xmlChar * URI; /* URI for the dtd, or NULL */
3183: int n_URI;
3184: xmlChar * ExternalID; /* the external ID of the DTD, or NULL */
3185: int n_ExternalID;
3186:
3187: for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
3188: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
3189: mem_base = xmlMemBlocks();
3190: URI = gen_const_xmlChar_ptr(n_URI, 0);
3191: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 1);
3192:
3193: ret_val = htmlNewDocNoDtD((const xmlChar *)URI, (const xmlChar *)ExternalID);
3194: desret_htmlDocPtr(ret_val);
3195: call_tests++;
3196: des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 0);
3197: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 1);
3198: xmlResetLastError();
3199: if (mem_base != xmlMemBlocks()) {
3200: printf("Leak of %d blocks found in htmlNewDocNoDtD",
3201: xmlMemBlocks() - mem_base);
3202: test_ret++;
3203: printf(" %d", n_URI);
3204: printf(" %d", n_ExternalID);
3205: printf("\n");
3206: }
3207: }
3208: }
3209: function_tests++;
3210: #endif
3211:
3212: return(test_ret);
3213: }
3214:
3215:
3216: static int
3217: test_htmlNodeDump(void) {
3218: int test_ret = 0;
3219:
3220: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
3221: int mem_base;
3222: int ret_val;
3223: xmlBufferPtr buf; /* the HTML buffer output */
3224: int n_buf;
3225: xmlDocPtr doc; /* the document */
3226: int n_doc;
3227: xmlNodePtr cur; /* the current node */
3228: int n_cur;
3229:
3230: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
3231: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
3232: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
3233: mem_base = xmlMemBlocks();
3234: buf = gen_xmlBufferPtr(n_buf, 0);
3235: doc = gen_xmlDocPtr(n_doc, 1);
3236: cur = gen_xmlNodePtr(n_cur, 2);
3237:
3238: ret_val = htmlNodeDump(buf, doc, cur);
3239: desret_int(ret_val);
3240: call_tests++;
3241: des_xmlBufferPtr(n_buf, buf, 0);
3242: des_xmlDocPtr(n_doc, doc, 1);
3243: des_xmlNodePtr(n_cur, cur, 2);
3244: xmlResetLastError();
3245: if (mem_base != xmlMemBlocks()) {
3246: printf("Leak of %d blocks found in htmlNodeDump",
3247: xmlMemBlocks() - mem_base);
3248: test_ret++;
3249: printf(" %d", n_buf);
3250: printf(" %d", n_doc);
3251: printf(" %d", n_cur);
3252: printf("\n");
3253: }
3254: }
3255: }
3256: }
3257: function_tests++;
3258: #endif
3259:
3260: return(test_ret);
3261: }
3262:
3263:
3264: static int
3265: test_htmlNodeDumpFile(void) {
3266: int test_ret = 0;
3267:
3268: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
3269: int mem_base;
3270: FILE * out; /* the FILE pointer */
3271: int n_out;
3272: xmlDocPtr doc; /* the document */
3273: int n_doc;
3274: xmlNodePtr cur; /* the current node */
3275: int n_cur;
3276:
3277: for (n_out = 0;n_out < gen_nb_FILE_ptr;n_out++) {
3278: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
3279: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
3280: mem_base = xmlMemBlocks();
3281: out = gen_FILE_ptr(n_out, 0);
3282: doc = gen_xmlDocPtr(n_doc, 1);
3283: cur = gen_xmlNodePtr(n_cur, 2);
3284:
3285: htmlNodeDumpFile(out, doc, cur);
3286: call_tests++;
3287: des_FILE_ptr(n_out, out, 0);
3288: des_xmlDocPtr(n_doc, doc, 1);
3289: des_xmlNodePtr(n_cur, cur, 2);
3290: xmlResetLastError();
3291: if (mem_base != xmlMemBlocks()) {
3292: printf("Leak of %d blocks found in htmlNodeDumpFile",
3293: xmlMemBlocks() - mem_base);
3294: test_ret++;
3295: printf(" %d", n_out);
3296: printf(" %d", n_doc);
3297: printf(" %d", n_cur);
3298: printf("\n");
3299: }
3300: }
3301: }
3302: }
3303: function_tests++;
3304: #endif
3305:
3306: return(test_ret);
3307: }
3308:
3309:
3310: static int
3311: test_htmlNodeDumpFileFormat(void) {
3312: int test_ret = 0;
3313:
3314: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
3315: int mem_base;
3316: int ret_val;
3317: FILE * out; /* the FILE pointer */
3318: int n_out;
3319: xmlDocPtr doc; /* the document */
3320: int n_doc;
3321: xmlNodePtr cur; /* the current node */
3322: int n_cur;
3323: char * encoding; /* the document encoding */
3324: int n_encoding;
3325: int format; /* should formatting spaces been added */
3326: int n_format;
3327:
3328: for (n_out = 0;n_out < gen_nb_FILE_ptr;n_out++) {
3329: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
3330: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
3331: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
3332: for (n_format = 0;n_format < gen_nb_int;n_format++) {
3333: mem_base = xmlMemBlocks();
3334: out = gen_FILE_ptr(n_out, 0);
3335: doc = gen_xmlDocPtr(n_doc, 1);
3336: cur = gen_xmlNodePtr(n_cur, 2);
3337: encoding = gen_const_char_ptr(n_encoding, 3);
3338: format = gen_int(n_format, 4);
3339:
3340: ret_val = htmlNodeDumpFileFormat(out, doc, cur, (const char *)encoding, format);
3341: desret_int(ret_val);
3342: call_tests++;
3343: des_FILE_ptr(n_out, out, 0);
3344: des_xmlDocPtr(n_doc, doc, 1);
3345: des_xmlNodePtr(n_cur, cur, 2);
3346: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
3347: des_int(n_format, format, 4);
3348: xmlResetLastError();
3349: if (mem_base != xmlMemBlocks()) {
3350: printf("Leak of %d blocks found in htmlNodeDumpFileFormat",
3351: xmlMemBlocks() - mem_base);
3352: test_ret++;
3353: printf(" %d", n_out);
3354: printf(" %d", n_doc);
3355: printf(" %d", n_cur);
3356: printf(" %d", n_encoding);
3357: printf(" %d", n_format);
3358: printf("\n");
3359: }
3360: }
3361: }
3362: }
3363: }
3364: }
3365: function_tests++;
3366: #endif
3367:
3368: return(test_ret);
3369: }
3370:
3371:
3372: static int
3373: test_htmlNodeDumpFormatOutput(void) {
3374: int test_ret = 0;
3375:
3376: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
3377: int mem_base;
3378: xmlOutputBufferPtr buf; /* the HTML buffer output */
3379: int n_buf;
3380: xmlDocPtr doc; /* the document */
3381: int n_doc;
3382: xmlNodePtr cur; /* the current node */
3383: int n_cur;
3384: char * encoding; /* the encoding string */
3385: int n_encoding;
3386: int format; /* should formatting spaces been added */
3387: int n_format;
3388:
3389: for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
3390: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
3391: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
3392: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
3393: for (n_format = 0;n_format < gen_nb_int;n_format++) {
3394: mem_base = xmlMemBlocks();
3395: buf = gen_xmlOutputBufferPtr(n_buf, 0);
3396: doc = gen_xmlDocPtr(n_doc, 1);
3397: cur = gen_xmlNodePtr(n_cur, 2);
3398: encoding = gen_const_char_ptr(n_encoding, 3);
3399: format = gen_int(n_format, 4);
3400:
3401: htmlNodeDumpFormatOutput(buf, doc, cur, (const char *)encoding, format);
3402: call_tests++;
3403: des_xmlOutputBufferPtr(n_buf, buf, 0);
3404: des_xmlDocPtr(n_doc, doc, 1);
3405: des_xmlNodePtr(n_cur, cur, 2);
3406: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
3407: des_int(n_format, format, 4);
3408: xmlResetLastError();
3409: if (mem_base != xmlMemBlocks()) {
3410: printf("Leak of %d blocks found in htmlNodeDumpFormatOutput",
3411: xmlMemBlocks() - mem_base);
3412: test_ret++;
3413: printf(" %d", n_buf);
3414: printf(" %d", n_doc);
3415: printf(" %d", n_cur);
3416: printf(" %d", n_encoding);
3417: printf(" %d", n_format);
3418: printf("\n");
3419: }
3420: }
3421: }
3422: }
3423: }
3424: }
3425: function_tests++;
3426: #endif
3427:
3428: return(test_ret);
3429: }
3430:
3431:
3432: static int
3433: test_htmlNodeDumpOutput(void) {
3434: int test_ret = 0;
3435:
3436: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
3437: int mem_base;
3438: xmlOutputBufferPtr buf; /* the HTML buffer output */
3439: int n_buf;
3440: xmlDocPtr doc; /* the document */
3441: int n_doc;
3442: xmlNodePtr cur; /* the current node */
3443: int n_cur;
3444: char * encoding; /* the encoding string */
3445: int n_encoding;
3446:
3447: for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
3448: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
3449: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
3450: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
3451: mem_base = xmlMemBlocks();
3452: buf = gen_xmlOutputBufferPtr(n_buf, 0);
3453: doc = gen_xmlDocPtr(n_doc, 1);
3454: cur = gen_xmlNodePtr(n_cur, 2);
3455: encoding = gen_const_char_ptr(n_encoding, 3);
3456:
3457: htmlNodeDumpOutput(buf, doc, cur, (const char *)encoding);
3458: call_tests++;
3459: des_xmlOutputBufferPtr(n_buf, buf, 0);
3460: des_xmlDocPtr(n_doc, doc, 1);
3461: des_xmlNodePtr(n_cur, cur, 2);
3462: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
3463: xmlResetLastError();
3464: if (mem_base != xmlMemBlocks()) {
3465: printf("Leak of %d blocks found in htmlNodeDumpOutput",
3466: xmlMemBlocks() - mem_base);
3467: test_ret++;
3468: printf(" %d", n_buf);
3469: printf(" %d", n_doc);
3470: printf(" %d", n_cur);
3471: printf(" %d", n_encoding);
3472: printf("\n");
3473: }
3474: }
3475: }
3476: }
3477: }
3478: function_tests++;
3479: #endif
3480:
3481: return(test_ret);
3482: }
3483:
3484:
3485: static int
3486: test_htmlSaveFile(void) {
3487: int test_ret = 0;
3488:
3489: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
3490: int mem_base;
3491: int ret_val;
3492: const char * filename; /* the filename (or URL) */
3493: int n_filename;
3494: xmlDocPtr cur; /* the document */
3495: int n_cur;
3496:
3497: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
3498: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
3499: mem_base = xmlMemBlocks();
3500: filename = gen_fileoutput(n_filename, 0);
3501: cur = gen_xmlDocPtr(n_cur, 1);
3502:
3503: ret_val = htmlSaveFile(filename, cur);
3504: desret_int(ret_val);
3505: call_tests++;
3506: des_fileoutput(n_filename, filename, 0);
3507: des_xmlDocPtr(n_cur, cur, 1);
3508: xmlResetLastError();
3509: if (mem_base != xmlMemBlocks()) {
3510: printf("Leak of %d blocks found in htmlSaveFile",
3511: xmlMemBlocks() - mem_base);
3512: test_ret++;
3513: printf(" %d", n_filename);
3514: printf(" %d", n_cur);
3515: printf("\n");
3516: }
3517: }
3518: }
3519: function_tests++;
3520: #endif
3521:
3522: return(test_ret);
3523: }
3524:
3525:
3526: static int
3527: test_htmlSaveFileEnc(void) {
3528: int test_ret = 0;
3529:
3530: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
3531: int mem_base;
3532: int ret_val;
3533: const char * filename; /* the filename */
3534: int n_filename;
3535: xmlDocPtr cur; /* the document */
3536: int n_cur;
3537: char * encoding; /* the document encoding */
3538: int n_encoding;
3539:
3540: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
3541: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
3542: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
3543: mem_base = xmlMemBlocks();
3544: filename = gen_fileoutput(n_filename, 0);
3545: cur = gen_xmlDocPtr(n_cur, 1);
3546: encoding = gen_const_char_ptr(n_encoding, 2);
3547:
3548: ret_val = htmlSaveFileEnc(filename, cur, (const char *)encoding);
3549: desret_int(ret_val);
3550: call_tests++;
3551: des_fileoutput(n_filename, filename, 0);
3552: des_xmlDocPtr(n_cur, cur, 1);
3553: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
3554: xmlResetLastError();
3555: if (mem_base != xmlMemBlocks()) {
3556: printf("Leak of %d blocks found in htmlSaveFileEnc",
3557: xmlMemBlocks() - mem_base);
3558: test_ret++;
3559: printf(" %d", n_filename);
3560: printf(" %d", n_cur);
3561: printf(" %d", n_encoding);
3562: printf("\n");
3563: }
3564: }
3565: }
3566: }
3567: function_tests++;
3568: #endif
3569:
3570: return(test_ret);
3571: }
3572:
3573:
3574: static int
3575: test_htmlSaveFileFormat(void) {
3576: int test_ret = 0;
3577:
3578: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
3579: int mem_base;
3580: int ret_val;
3581: const char * filename; /* the filename */
3582: int n_filename;
3583: xmlDocPtr cur; /* the document */
3584: int n_cur;
3585: char * encoding; /* the document encoding */
3586: int n_encoding;
3587: int format; /* should formatting spaces been added */
3588: int n_format;
3589:
3590: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
3591: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
3592: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
3593: for (n_format = 0;n_format < gen_nb_int;n_format++) {
3594: mem_base = xmlMemBlocks();
3595: filename = gen_fileoutput(n_filename, 0);
3596: cur = gen_xmlDocPtr(n_cur, 1);
3597: encoding = gen_const_char_ptr(n_encoding, 2);
3598: format = gen_int(n_format, 3);
3599:
3600: ret_val = htmlSaveFileFormat(filename, cur, (const char *)encoding, format);
3601: desret_int(ret_val);
3602: call_tests++;
3603: des_fileoutput(n_filename, filename, 0);
3604: des_xmlDocPtr(n_cur, cur, 1);
3605: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
3606: des_int(n_format, format, 3);
3607: xmlResetLastError();
3608: if (mem_base != xmlMemBlocks()) {
3609: printf("Leak of %d blocks found in htmlSaveFileFormat",
3610: xmlMemBlocks() - mem_base);
3611: test_ret++;
3612: printf(" %d", n_filename);
3613: printf(" %d", n_cur);
3614: printf(" %d", n_encoding);
3615: printf(" %d", n_format);
3616: printf("\n");
3617: }
3618: }
3619: }
3620: }
3621: }
3622: function_tests++;
3623: #endif
3624:
3625: return(test_ret);
3626: }
3627:
3628:
3629: static int
3630: test_htmlSetMetaEncoding(void) {
3631: int test_ret = 0;
3632:
3633: #if defined(LIBXML_HTML_ENABLED)
3634: int mem_base;
3635: int ret_val;
3636: htmlDocPtr doc; /* the document */
3637: int n_doc;
3638: xmlChar * encoding; /* the encoding string */
3639: int n_encoding;
3640:
3641: for (n_doc = 0;n_doc < gen_nb_htmlDocPtr;n_doc++) {
3642: for (n_encoding = 0;n_encoding < gen_nb_const_xmlChar_ptr;n_encoding++) {
3643: mem_base = xmlMemBlocks();
3644: doc = gen_htmlDocPtr(n_doc, 0);
3645: encoding = gen_const_xmlChar_ptr(n_encoding, 1);
3646:
3647: ret_val = htmlSetMetaEncoding(doc, (const xmlChar *)encoding);
3648: desret_int(ret_val);
3649: call_tests++;
3650: des_htmlDocPtr(n_doc, doc, 0);
3651: des_const_xmlChar_ptr(n_encoding, (const xmlChar *)encoding, 1);
3652: xmlResetLastError();
3653: if (mem_base != xmlMemBlocks()) {
3654: printf("Leak of %d blocks found in htmlSetMetaEncoding",
3655: xmlMemBlocks() - mem_base);
3656: test_ret++;
3657: printf(" %d", n_doc);
3658: printf(" %d", n_encoding);
3659: printf("\n");
3660: }
3661: }
3662: }
3663: function_tests++;
3664: #endif
3665:
3666: return(test_ret);
3667: }
3668:
3669: static int
3670: test_HTMLtree(void) {
3671: int test_ret = 0;
3672:
3673: if (quiet == 0) printf("Testing HTMLtree : 18 of 18 functions ...\n");
3674: test_ret += test_htmlDocContentDumpFormatOutput();
3675: test_ret += test_htmlDocContentDumpOutput();
3676: test_ret += test_htmlDocDump();
3677: test_ret += test_htmlDocDumpMemory();
3678: test_ret += test_htmlDocDumpMemoryFormat();
3679: test_ret += test_htmlGetMetaEncoding();
3680: test_ret += test_htmlIsBooleanAttr();
3681: test_ret += test_htmlNewDoc();
3682: test_ret += test_htmlNewDocNoDtD();
3683: test_ret += test_htmlNodeDump();
3684: test_ret += test_htmlNodeDumpFile();
3685: test_ret += test_htmlNodeDumpFileFormat();
3686: test_ret += test_htmlNodeDumpFormatOutput();
3687: test_ret += test_htmlNodeDumpOutput();
3688: test_ret += test_htmlSaveFile();
3689: test_ret += test_htmlSaveFileEnc();
3690: test_ret += test_htmlSaveFileFormat();
3691: test_ret += test_htmlSetMetaEncoding();
3692:
3693: if (test_ret != 0)
3694: printf("Module HTMLtree: %d errors\n", test_ret);
3695: return(test_ret);
3696: }
3697:
3698: static int
3699: test_docbDefaultSAXHandlerInit(void) {
3700: int test_ret = 0;
3701:
3702: #if defined(LIBXML_DOCB_ENABLED)
3703: #ifdef LIBXML_DOCB_ENABLED
3704: int mem_base;
3705:
3706: mem_base = xmlMemBlocks();
3707:
3708: docbDefaultSAXHandlerInit();
3709: call_tests++;
3710: xmlResetLastError();
3711: if (mem_base != xmlMemBlocks()) {
3712: printf("Leak of %d blocks found in docbDefaultSAXHandlerInit",
3713: xmlMemBlocks() - mem_base);
3714: test_ret++;
3715: printf("\n");
3716: }
3717: function_tests++;
3718: #endif
3719: #endif
3720:
3721: return(test_ret);
3722: }
3723:
3724:
3725: static int
3726: test_htmlDefaultSAXHandlerInit(void) {
3727: int test_ret = 0;
3728:
3729: #if defined(LIBXML_HTML_ENABLED)
3730: #ifdef LIBXML_HTML_ENABLED
3731: int mem_base;
3732:
3733: mem_base = xmlMemBlocks();
3734:
3735: htmlDefaultSAXHandlerInit();
3736: call_tests++;
3737: xmlResetLastError();
3738: if (mem_base != xmlMemBlocks()) {
3739: printf("Leak of %d blocks found in htmlDefaultSAXHandlerInit",
3740: xmlMemBlocks() - mem_base);
3741: test_ret++;
3742: printf("\n");
3743: }
3744: function_tests++;
3745: #endif
3746: #endif
3747:
3748: return(test_ret);
3749: }
3750:
3751:
3752: static int
3753: test_xmlDefaultSAXHandlerInit(void) {
3754: int test_ret = 0;
3755:
3756: int mem_base;
3757:
3758: mem_base = xmlMemBlocks();
3759:
3760: xmlDefaultSAXHandlerInit();
3761: call_tests++;
3762: xmlResetLastError();
3763: if (mem_base != xmlMemBlocks()) {
3764: printf("Leak of %d blocks found in xmlDefaultSAXHandlerInit",
3765: xmlMemBlocks() - mem_base);
3766: test_ret++;
3767: printf("\n");
3768: }
3769: function_tests++;
3770:
3771: return(test_ret);
3772: }
3773:
3774:
3775: #define gen_nb_xmlEnumerationPtr 1
3776: static xmlEnumerationPtr gen_xmlEnumerationPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
3777: return(NULL);
3778: }
3779: static void des_xmlEnumerationPtr(int no ATTRIBUTE_UNUSED, xmlEnumerationPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
3780: }
3781:
3782: static int
3783: test_xmlSAX2AttributeDecl(void) {
3784: int test_ret = 0;
3785:
3786: int mem_base;
3787: void * ctx; /* the user data (XML parser context) */
3788: int n_ctx;
3789: xmlChar * elem; /* the name of the element */
3790: int n_elem;
3791: xmlChar * fullname; /* the attribute name */
3792: int n_fullname;
3793: int type; /* the attribute type */
3794: int n_type;
3795: int def; /* the type of default value */
3796: int n_def;
3797: xmlChar * defaultValue; /* the attribute default value */
3798: int n_defaultValue;
3799: xmlEnumerationPtr tree; /* the tree of enumerated value set */
3800: int n_tree;
3801:
3802: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
3803: for (n_elem = 0;n_elem < gen_nb_const_xmlChar_ptr;n_elem++) {
3804: for (n_fullname = 0;n_fullname < gen_nb_const_xmlChar_ptr;n_fullname++) {
3805: for (n_type = 0;n_type < gen_nb_int;n_type++) {
3806: for (n_def = 0;n_def < gen_nb_int;n_def++) {
3807: for (n_defaultValue = 0;n_defaultValue < gen_nb_const_xmlChar_ptr;n_defaultValue++) {
3808: for (n_tree = 0;n_tree < gen_nb_xmlEnumerationPtr;n_tree++) {
3809: mem_base = xmlMemBlocks();
3810: ctx = gen_void_ptr(n_ctx, 0);
3811: elem = gen_const_xmlChar_ptr(n_elem, 1);
3812: fullname = gen_const_xmlChar_ptr(n_fullname, 2);
3813: type = gen_int(n_type, 3);
3814: def = gen_int(n_def, 4);
3815: defaultValue = gen_const_xmlChar_ptr(n_defaultValue, 5);
3816: tree = gen_xmlEnumerationPtr(n_tree, 6);
3817:
3818: xmlSAX2AttributeDecl(ctx, (const xmlChar *)elem, (const xmlChar *)fullname, type, def, (const xmlChar *)defaultValue, tree);
3819: call_tests++;
3820: des_void_ptr(n_ctx, ctx, 0);
3821: des_const_xmlChar_ptr(n_elem, (const xmlChar *)elem, 1);
3822: des_const_xmlChar_ptr(n_fullname, (const xmlChar *)fullname, 2);
3823: des_int(n_type, type, 3);
3824: des_int(n_def, def, 4);
3825: des_const_xmlChar_ptr(n_defaultValue, (const xmlChar *)defaultValue, 5);
3826: des_xmlEnumerationPtr(n_tree, tree, 6);
3827: xmlResetLastError();
3828: if (mem_base != xmlMemBlocks()) {
3829: printf("Leak of %d blocks found in xmlSAX2AttributeDecl",
3830: xmlMemBlocks() - mem_base);
3831: test_ret++;
3832: printf(" %d", n_ctx);
3833: printf(" %d", n_elem);
3834: printf(" %d", n_fullname);
3835: printf(" %d", n_type);
3836: printf(" %d", n_def);
3837: printf(" %d", n_defaultValue);
3838: printf(" %d", n_tree);
3839: printf("\n");
3840: }
3841: }
3842: }
3843: }
3844: }
3845: }
3846: }
3847: }
3848: function_tests++;
3849:
3850: return(test_ret);
3851: }
3852:
3853:
3854: static int
3855: test_xmlSAX2CDataBlock(void) {
3856: int test_ret = 0;
3857:
3858: int mem_base;
3859: void * ctx; /* the user data (XML parser context) */
3860: int n_ctx;
3861: xmlChar * value; /* The pcdata content */
3862: int n_value;
3863: int len; /* the block length */
3864: int n_len;
3865:
3866: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
3867: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
3868: for (n_len = 0;n_len < gen_nb_int;n_len++) {
3869: mem_base = xmlMemBlocks();
3870: ctx = gen_void_ptr(n_ctx, 0);
3871: value = gen_const_xmlChar_ptr(n_value, 1);
3872: len = gen_int(n_len, 2);
3873:
3874: xmlSAX2CDataBlock(ctx, (const xmlChar *)value, len);
3875: call_tests++;
3876: des_void_ptr(n_ctx, ctx, 0);
3877: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
3878: des_int(n_len, len, 2);
3879: xmlResetLastError();
3880: if (mem_base != xmlMemBlocks()) {
3881: printf("Leak of %d blocks found in xmlSAX2CDataBlock",
3882: xmlMemBlocks() - mem_base);
3883: test_ret++;
3884: printf(" %d", n_ctx);
3885: printf(" %d", n_value);
3886: printf(" %d", n_len);
3887: printf("\n");
3888: }
3889: }
3890: }
3891: }
3892: function_tests++;
3893:
3894: return(test_ret);
3895: }
3896:
3897:
3898: static int
3899: test_xmlSAX2Characters(void) {
3900: int test_ret = 0;
3901:
3902: int mem_base;
3903: void * ctx; /* the user data (XML parser context) */
3904: int n_ctx;
3905: xmlChar * ch; /* a xmlChar string */
3906: int n_ch;
3907: int len; /* the number of xmlChar */
3908: int n_len;
3909:
3910: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
3911: for (n_ch = 0;n_ch < gen_nb_const_xmlChar_ptr;n_ch++) {
3912: for (n_len = 0;n_len < gen_nb_int;n_len++) {
3913: mem_base = xmlMemBlocks();
3914: ctx = gen_void_ptr(n_ctx, 0);
3915: ch = gen_const_xmlChar_ptr(n_ch, 1);
3916: len = gen_int(n_len, 2);
3917:
3918: xmlSAX2Characters(ctx, (const xmlChar *)ch, len);
3919: call_tests++;
3920: des_void_ptr(n_ctx, ctx, 0);
3921: des_const_xmlChar_ptr(n_ch, (const xmlChar *)ch, 1);
3922: des_int(n_len, len, 2);
3923: xmlResetLastError();
3924: if (mem_base != xmlMemBlocks()) {
3925: printf("Leak of %d blocks found in xmlSAX2Characters",
3926: xmlMemBlocks() - mem_base);
3927: test_ret++;
3928: printf(" %d", n_ctx);
3929: printf(" %d", n_ch);
3930: printf(" %d", n_len);
3931: printf("\n");
3932: }
3933: }
3934: }
3935: }
3936: function_tests++;
3937:
3938: return(test_ret);
3939: }
3940:
3941:
3942: static int
3943: test_xmlSAX2Comment(void) {
3944: int test_ret = 0;
3945:
3946: int mem_base;
3947: void * ctx; /* the user data (XML parser context) */
3948: int n_ctx;
3949: xmlChar * value; /* the xmlSAX2Comment content */
3950: int n_value;
3951:
3952: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
3953: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
3954: mem_base = xmlMemBlocks();
3955: ctx = gen_void_ptr(n_ctx, 0);
3956: value = gen_const_xmlChar_ptr(n_value, 1);
3957:
3958: xmlSAX2Comment(ctx, (const xmlChar *)value);
3959: call_tests++;
3960: des_void_ptr(n_ctx, ctx, 0);
3961: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
3962: xmlResetLastError();
3963: if (mem_base != xmlMemBlocks()) {
3964: printf("Leak of %d blocks found in xmlSAX2Comment",
3965: xmlMemBlocks() - mem_base);
3966: test_ret++;
3967: printf(" %d", n_ctx);
3968: printf(" %d", n_value);
3969: printf("\n");
3970: }
3971: }
3972: }
3973: function_tests++;
3974:
3975: return(test_ret);
3976: }
3977:
3978:
3979: static int
3980: test_xmlSAX2ElementDecl(void) {
3981: int test_ret = 0;
3982:
3983: int mem_base;
3984: void * ctx; /* the user data (XML parser context) */
3985: int n_ctx;
3986: xmlChar * name; /* the element name */
3987: int n_name;
3988: int type; /* the element type */
3989: int n_type;
3990: xmlElementContentPtr content; /* the element value tree */
3991: int n_content;
3992:
3993: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
3994: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
3995: for (n_type = 0;n_type < gen_nb_int;n_type++) {
3996: for (n_content = 0;n_content < gen_nb_xmlElementContentPtr;n_content++) {
3997: mem_base = xmlMemBlocks();
3998: ctx = gen_void_ptr(n_ctx, 0);
3999: name = gen_const_xmlChar_ptr(n_name, 1);
4000: type = gen_int(n_type, 2);
4001: content = gen_xmlElementContentPtr(n_content, 3);
4002:
4003: xmlSAX2ElementDecl(ctx, (const xmlChar *)name, type, content);
4004: call_tests++;
4005: des_void_ptr(n_ctx, ctx, 0);
4006: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
4007: des_int(n_type, type, 2);
4008: des_xmlElementContentPtr(n_content, content, 3);
4009: xmlResetLastError();
4010: if (mem_base != xmlMemBlocks()) {
4011: printf("Leak of %d blocks found in xmlSAX2ElementDecl",
4012: xmlMemBlocks() - mem_base);
4013: test_ret++;
4014: printf(" %d", n_ctx);
4015: printf(" %d", n_name);
4016: printf(" %d", n_type);
4017: printf(" %d", n_content);
4018: printf("\n");
4019: }
4020: }
4021: }
4022: }
4023: }
4024: function_tests++;
4025:
4026: return(test_ret);
4027: }
4028:
4029:
4030: static int
4031: test_xmlSAX2EndDocument(void) {
4032: int test_ret = 0;
4033:
4034: int mem_base;
4035: void * ctx; /* the user data (XML parser context) */
4036: int n_ctx;
4037:
4038: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4039: mem_base = xmlMemBlocks();
4040: ctx = gen_void_ptr(n_ctx, 0);
4041:
4042: xmlSAX2EndDocument(ctx);
4043: call_tests++;
4044: des_void_ptr(n_ctx, ctx, 0);
4045: xmlResetLastError();
4046: if (mem_base != xmlMemBlocks()) {
4047: printf("Leak of %d blocks found in xmlSAX2EndDocument",
4048: xmlMemBlocks() - mem_base);
4049: test_ret++;
4050: printf(" %d", n_ctx);
4051: printf("\n");
4052: }
4053: }
4054: function_tests++;
4055:
4056: return(test_ret);
4057: }
4058:
4059:
4060: static int
4061: test_xmlSAX2EndElement(void) {
4062: int test_ret = 0;
4063:
4064: #if defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_DOCB_ENABLED)
4065: #ifdef LIBXML_SAX1_ENABLED
4066: int mem_base;
4067: void * ctx; /* the user data (XML parser context) */
4068: int n_ctx;
4069: xmlChar * name; /* The element name */
4070: int n_name;
4071:
4072: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4073: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
4074: mem_base = xmlMemBlocks();
4075: ctx = gen_void_ptr(n_ctx, 0);
4076: name = gen_const_xmlChar_ptr(n_name, 1);
4077:
4078: xmlSAX2EndElement(ctx, (const xmlChar *)name);
4079: call_tests++;
4080: des_void_ptr(n_ctx, ctx, 0);
4081: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
4082: xmlResetLastError();
4083: if (mem_base != xmlMemBlocks()) {
4084: printf("Leak of %d blocks found in xmlSAX2EndElement",
4085: xmlMemBlocks() - mem_base);
4086: test_ret++;
4087: printf(" %d", n_ctx);
4088: printf(" %d", n_name);
4089: printf("\n");
4090: }
4091: }
4092: }
4093: function_tests++;
4094: #endif
4095: #endif
4096:
4097: return(test_ret);
4098: }
4099:
4100:
4101: static int
4102: test_xmlSAX2EndElementNs(void) {
4103: int test_ret = 0;
4104:
4105: int mem_base;
4106: void * ctx; /* the user data (XML parser context) */
4107: int n_ctx;
4108: xmlChar * localname; /* the local name of the element */
4109: int n_localname;
4110: xmlChar * prefix; /* the element namespace prefix if available */
4111: int n_prefix;
4112: xmlChar * URI; /* the element namespace name if available */
4113: int n_URI;
4114:
4115: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4116: for (n_localname = 0;n_localname < gen_nb_const_xmlChar_ptr;n_localname++) {
4117: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
4118: for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
4119: mem_base = xmlMemBlocks();
4120: ctx = gen_void_ptr(n_ctx, 0);
4121: localname = gen_const_xmlChar_ptr(n_localname, 1);
4122: prefix = gen_const_xmlChar_ptr(n_prefix, 2);
4123: URI = gen_const_xmlChar_ptr(n_URI, 3);
4124:
4125: xmlSAX2EndElementNs(ctx, (const xmlChar *)localname, (const xmlChar *)prefix, (const xmlChar *)URI);
4126: call_tests++;
4127: des_void_ptr(n_ctx, ctx, 0);
4128: des_const_xmlChar_ptr(n_localname, (const xmlChar *)localname, 1);
4129: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 2);
4130: des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 3);
4131: xmlResetLastError();
4132: if (mem_base != xmlMemBlocks()) {
4133: printf("Leak of %d blocks found in xmlSAX2EndElementNs",
4134: xmlMemBlocks() - mem_base);
4135: test_ret++;
4136: printf(" %d", n_ctx);
4137: printf(" %d", n_localname);
4138: printf(" %d", n_prefix);
4139: printf(" %d", n_URI);
4140: printf("\n");
4141: }
4142: }
4143: }
4144: }
4145: }
4146: function_tests++;
4147:
4148: return(test_ret);
4149: }
4150:
4151:
4152: static int
4153: test_xmlSAX2EntityDecl(void) {
4154: int test_ret = 0;
4155:
4156: int mem_base;
4157: void * ctx; /* the user data (XML parser context) */
4158: int n_ctx;
4159: xmlChar * name; /* the entity name */
4160: int n_name;
4161: int type; /* the entity type */
4162: int n_type;
4163: xmlChar * publicId; /* The public ID of the entity */
4164: int n_publicId;
4165: xmlChar * systemId; /* The system ID of the entity */
4166: int n_systemId;
4167: xmlChar * content; /* the entity value (without processing). */
4168: int n_content;
4169:
4170: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4171: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
4172: for (n_type = 0;n_type < gen_nb_int;n_type++) {
4173: for (n_publicId = 0;n_publicId < gen_nb_const_xmlChar_ptr;n_publicId++) {
4174: for (n_systemId = 0;n_systemId < gen_nb_const_xmlChar_ptr;n_systemId++) {
4175: for (n_content = 0;n_content < gen_nb_xmlChar_ptr;n_content++) {
4176: mem_base = xmlMemBlocks();
4177: ctx = gen_void_ptr(n_ctx, 0);
4178: name = gen_const_xmlChar_ptr(n_name, 1);
4179: type = gen_int(n_type, 2);
4180: publicId = gen_const_xmlChar_ptr(n_publicId, 3);
4181: systemId = gen_const_xmlChar_ptr(n_systemId, 4);
4182: content = gen_xmlChar_ptr(n_content, 5);
4183:
4184: xmlSAX2EntityDecl(ctx, (const xmlChar *)name, type, (const xmlChar *)publicId, (const xmlChar *)systemId, content);
4185: call_tests++;
4186: des_void_ptr(n_ctx, ctx, 0);
4187: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
4188: des_int(n_type, type, 2);
4189: des_const_xmlChar_ptr(n_publicId, (const xmlChar *)publicId, 3);
4190: des_const_xmlChar_ptr(n_systemId, (const xmlChar *)systemId, 4);
4191: des_xmlChar_ptr(n_content, content, 5);
4192: xmlResetLastError();
4193: if (mem_base != xmlMemBlocks()) {
4194: printf("Leak of %d blocks found in xmlSAX2EntityDecl",
4195: xmlMemBlocks() - mem_base);
4196: test_ret++;
4197: printf(" %d", n_ctx);
4198: printf(" %d", n_name);
4199: printf(" %d", n_type);
4200: printf(" %d", n_publicId);
4201: printf(" %d", n_systemId);
4202: printf(" %d", n_content);
4203: printf("\n");
4204: }
4205: }
4206: }
4207: }
4208: }
4209: }
4210: }
4211: function_tests++;
4212:
4213: return(test_ret);
4214: }
4215:
4216:
4217: static int
4218: test_xmlSAX2ExternalSubset(void) {
4219: int test_ret = 0;
4220:
4221: int mem_base;
4222: void * ctx; /* the user data (XML parser context) */
4223: int n_ctx;
4224: xmlChar * name; /* the root element name */
4225: int n_name;
4226: xmlChar * ExternalID; /* the external ID */
4227: int n_ExternalID;
4228: xmlChar * SystemID; /* the SYSTEM ID (e.g. filename or URL) */
4229: int n_SystemID;
4230:
4231: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4232: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
4233: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
4234: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
4235: mem_base = xmlMemBlocks();
4236: ctx = gen_void_ptr(n_ctx, 0);
4237: name = gen_const_xmlChar_ptr(n_name, 1);
4238: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 2);
4239: SystemID = gen_const_xmlChar_ptr(n_SystemID, 3);
4240:
4241: xmlSAX2ExternalSubset(ctx, (const xmlChar *)name, (const xmlChar *)ExternalID, (const xmlChar *)SystemID);
4242: call_tests++;
4243: des_void_ptr(n_ctx, ctx, 0);
4244: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
4245: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 2);
4246: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 3);
4247: xmlResetLastError();
4248: if (mem_base != xmlMemBlocks()) {
4249: printf("Leak of %d blocks found in xmlSAX2ExternalSubset",
4250: xmlMemBlocks() - mem_base);
4251: test_ret++;
4252: printf(" %d", n_ctx);
4253: printf(" %d", n_name);
4254: printf(" %d", n_ExternalID);
4255: printf(" %d", n_SystemID);
4256: printf("\n");
4257: }
4258: }
4259: }
4260: }
4261: }
4262: function_tests++;
4263:
4264: return(test_ret);
4265: }
4266:
4267:
4268: static int
4269: test_xmlSAX2GetColumnNumber(void) {
4270: int test_ret = 0;
4271:
4272: int mem_base;
4273: int ret_val;
4274: void * ctx; /* the user data (XML parser context) */
4275: int n_ctx;
4276:
4277: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4278: mem_base = xmlMemBlocks();
4279: ctx = gen_void_ptr(n_ctx, 0);
4280:
4281: ret_val = xmlSAX2GetColumnNumber(ctx);
4282: desret_int(ret_val);
4283: call_tests++;
4284: des_void_ptr(n_ctx, ctx, 0);
4285: xmlResetLastError();
4286: if (mem_base != xmlMemBlocks()) {
4287: printf("Leak of %d blocks found in xmlSAX2GetColumnNumber",
4288: xmlMemBlocks() - mem_base);
4289: test_ret++;
4290: printf(" %d", n_ctx);
4291: printf("\n");
4292: }
4293: }
4294: function_tests++;
4295:
4296: return(test_ret);
4297: }
4298:
4299:
4300: static int
4301: test_xmlSAX2GetEntity(void) {
4302: int test_ret = 0;
4303:
4304: int mem_base;
4305: xmlEntityPtr ret_val;
4306: void * ctx; /* the user data (XML parser context) */
4307: int n_ctx;
4308: xmlChar * name; /* The entity name */
4309: int n_name;
4310:
4311: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4312: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
4313: mem_base = xmlMemBlocks();
4314: ctx = gen_void_ptr(n_ctx, 0);
4315: name = gen_const_xmlChar_ptr(n_name, 1);
4316:
4317: ret_val = xmlSAX2GetEntity(ctx, (const xmlChar *)name);
4318: desret_xmlEntityPtr(ret_val);
4319: call_tests++;
4320: des_void_ptr(n_ctx, ctx, 0);
4321: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
4322: xmlResetLastError();
4323: if (mem_base != xmlMemBlocks()) {
4324: printf("Leak of %d blocks found in xmlSAX2GetEntity",
4325: xmlMemBlocks() - mem_base);
4326: test_ret++;
4327: printf(" %d", n_ctx);
4328: printf(" %d", n_name);
4329: printf("\n");
4330: }
4331: }
4332: }
4333: function_tests++;
4334:
4335: return(test_ret);
4336: }
4337:
4338:
4339: static int
4340: test_xmlSAX2GetLineNumber(void) {
4341: int test_ret = 0;
4342:
4343: int mem_base;
4344: int ret_val;
4345: void * ctx; /* the user data (XML parser context) */
4346: int n_ctx;
4347:
4348: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4349: mem_base = xmlMemBlocks();
4350: ctx = gen_void_ptr(n_ctx, 0);
4351:
4352: ret_val = xmlSAX2GetLineNumber(ctx);
4353: desret_int(ret_val);
4354: call_tests++;
4355: des_void_ptr(n_ctx, ctx, 0);
4356: xmlResetLastError();
4357: if (mem_base != xmlMemBlocks()) {
4358: printf("Leak of %d blocks found in xmlSAX2GetLineNumber",
4359: xmlMemBlocks() - mem_base);
4360: test_ret++;
4361: printf(" %d", n_ctx);
4362: printf("\n");
4363: }
4364: }
4365: function_tests++;
4366:
4367: return(test_ret);
4368: }
4369:
4370:
4371: static int
4372: test_xmlSAX2GetParameterEntity(void) {
4373: int test_ret = 0;
4374:
4375: int mem_base;
4376: xmlEntityPtr ret_val;
4377: void * ctx; /* the user data (XML parser context) */
4378: int n_ctx;
4379: xmlChar * name; /* The entity name */
4380: int n_name;
4381:
4382: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4383: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
4384: mem_base = xmlMemBlocks();
4385: ctx = gen_void_ptr(n_ctx, 0);
4386: name = gen_const_xmlChar_ptr(n_name, 1);
4387:
4388: ret_val = xmlSAX2GetParameterEntity(ctx, (const xmlChar *)name);
4389: desret_xmlEntityPtr(ret_val);
4390: call_tests++;
4391: des_void_ptr(n_ctx, ctx, 0);
4392: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
4393: xmlResetLastError();
4394: if (mem_base != xmlMemBlocks()) {
4395: printf("Leak of %d blocks found in xmlSAX2GetParameterEntity",
4396: xmlMemBlocks() - mem_base);
4397: test_ret++;
4398: printf(" %d", n_ctx);
4399: printf(" %d", n_name);
4400: printf("\n");
4401: }
4402: }
4403: }
4404: function_tests++;
4405:
4406: return(test_ret);
4407: }
4408:
4409:
4410: static int
4411: test_xmlSAX2GetPublicId(void) {
4412: int test_ret = 0;
4413:
4414: int mem_base;
4415: const xmlChar * ret_val;
4416: void * ctx; /* the user data (XML parser context) */
4417: int n_ctx;
4418:
4419: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4420: mem_base = xmlMemBlocks();
4421: ctx = gen_void_ptr(n_ctx, 0);
4422:
4423: ret_val = xmlSAX2GetPublicId(ctx);
4424: desret_const_xmlChar_ptr(ret_val);
4425: call_tests++;
4426: des_void_ptr(n_ctx, ctx, 0);
4427: xmlResetLastError();
4428: if (mem_base != xmlMemBlocks()) {
4429: printf("Leak of %d blocks found in xmlSAX2GetPublicId",
4430: xmlMemBlocks() - mem_base);
4431: test_ret++;
4432: printf(" %d", n_ctx);
4433: printf("\n");
4434: }
4435: }
4436: function_tests++;
4437:
4438: return(test_ret);
4439: }
4440:
4441:
4442: static int
4443: test_xmlSAX2GetSystemId(void) {
4444: int test_ret = 0;
4445:
4446: int mem_base;
4447: const xmlChar * ret_val;
4448: void * ctx; /* the user data (XML parser context) */
4449: int n_ctx;
4450:
4451: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4452: mem_base = xmlMemBlocks();
4453: ctx = gen_void_ptr(n_ctx, 0);
4454:
4455: ret_val = xmlSAX2GetSystemId(ctx);
4456: desret_const_xmlChar_ptr(ret_val);
4457: call_tests++;
4458: des_void_ptr(n_ctx, ctx, 0);
4459: xmlResetLastError();
4460: if (mem_base != xmlMemBlocks()) {
4461: printf("Leak of %d blocks found in xmlSAX2GetSystemId",
4462: xmlMemBlocks() - mem_base);
4463: test_ret++;
4464: printf(" %d", n_ctx);
4465: printf("\n");
4466: }
4467: }
4468: function_tests++;
4469:
4470: return(test_ret);
4471: }
4472:
4473:
4474: static int
4475: test_xmlSAX2HasExternalSubset(void) {
4476: int test_ret = 0;
4477:
4478: int mem_base;
4479: int ret_val;
4480: void * ctx; /* the user data (XML parser context) */
4481: int n_ctx;
4482:
4483: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4484: mem_base = xmlMemBlocks();
4485: ctx = gen_void_ptr(n_ctx, 0);
4486:
4487: ret_val = xmlSAX2HasExternalSubset(ctx);
4488: desret_int(ret_val);
4489: call_tests++;
4490: des_void_ptr(n_ctx, ctx, 0);
4491: xmlResetLastError();
4492: if (mem_base != xmlMemBlocks()) {
4493: printf("Leak of %d blocks found in xmlSAX2HasExternalSubset",
4494: xmlMemBlocks() - mem_base);
4495: test_ret++;
4496: printf(" %d", n_ctx);
4497: printf("\n");
4498: }
4499: }
4500: function_tests++;
4501:
4502: return(test_ret);
4503: }
4504:
4505:
4506: static int
4507: test_xmlSAX2HasInternalSubset(void) {
4508: int test_ret = 0;
4509:
4510: int mem_base;
4511: int ret_val;
4512: void * ctx; /* the user data (XML parser context) */
4513: int n_ctx;
4514:
4515: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4516: mem_base = xmlMemBlocks();
4517: ctx = gen_void_ptr(n_ctx, 0);
4518:
4519: ret_val = xmlSAX2HasInternalSubset(ctx);
4520: desret_int(ret_val);
4521: call_tests++;
4522: des_void_ptr(n_ctx, ctx, 0);
4523: xmlResetLastError();
4524: if (mem_base != xmlMemBlocks()) {
4525: printf("Leak of %d blocks found in xmlSAX2HasInternalSubset",
4526: xmlMemBlocks() - mem_base);
4527: test_ret++;
4528: printf(" %d", n_ctx);
4529: printf("\n");
4530: }
4531: }
4532: function_tests++;
4533:
4534: return(test_ret);
4535: }
4536:
4537:
4538: static int
4539: test_xmlSAX2IgnorableWhitespace(void) {
4540: int test_ret = 0;
4541:
4542: int mem_base;
4543: void * ctx; /* the user data (XML parser context) */
4544: int n_ctx;
4545: xmlChar * ch; /* a xmlChar string */
4546: int n_ch;
4547: int len; /* the number of xmlChar */
4548: int n_len;
4549:
4550: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4551: for (n_ch = 0;n_ch < gen_nb_const_xmlChar_ptr;n_ch++) {
4552: for (n_len = 0;n_len < gen_nb_int;n_len++) {
4553: mem_base = xmlMemBlocks();
4554: ctx = gen_void_ptr(n_ctx, 0);
4555: ch = gen_const_xmlChar_ptr(n_ch, 1);
4556: len = gen_int(n_len, 2);
4557:
4558: xmlSAX2IgnorableWhitespace(ctx, (const xmlChar *)ch, len);
4559: call_tests++;
4560: des_void_ptr(n_ctx, ctx, 0);
4561: des_const_xmlChar_ptr(n_ch, (const xmlChar *)ch, 1);
4562: des_int(n_len, len, 2);
4563: xmlResetLastError();
4564: if (mem_base != xmlMemBlocks()) {
4565: printf("Leak of %d blocks found in xmlSAX2IgnorableWhitespace",
4566: xmlMemBlocks() - mem_base);
4567: test_ret++;
4568: printf(" %d", n_ctx);
4569: printf(" %d", n_ch);
4570: printf(" %d", n_len);
4571: printf("\n");
4572: }
4573: }
4574: }
4575: }
4576: function_tests++;
4577:
4578: return(test_ret);
4579: }
4580:
4581:
4582: #define gen_nb_xmlSAXHandler_ptr 1
4583: static xmlSAXHandler * gen_xmlSAXHandler_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
4584: return(NULL);
4585: }
4586: static void des_xmlSAXHandler_ptr(int no ATTRIBUTE_UNUSED, xmlSAXHandler * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
4587: }
4588:
4589: static int
4590: test_xmlSAX2InitDefaultSAXHandler(void) {
4591: int test_ret = 0;
4592:
4593: int mem_base;
4594: xmlSAXHandler * hdlr; /* the SAX handler */
4595: int n_hdlr;
4596: int warning; /* flag if non-zero sets the handler warning procedure */
4597: int n_warning;
4598:
4599: for (n_hdlr = 0;n_hdlr < gen_nb_xmlSAXHandler_ptr;n_hdlr++) {
4600: for (n_warning = 0;n_warning < gen_nb_int;n_warning++) {
4601: mem_base = xmlMemBlocks();
4602: hdlr = gen_xmlSAXHandler_ptr(n_hdlr, 0);
4603: warning = gen_int(n_warning, 1);
4604:
4605: xmlSAX2InitDefaultSAXHandler(hdlr, warning);
4606: call_tests++;
4607: des_xmlSAXHandler_ptr(n_hdlr, hdlr, 0);
4608: des_int(n_warning, warning, 1);
4609: xmlResetLastError();
4610: if (mem_base != xmlMemBlocks()) {
4611: printf("Leak of %d blocks found in xmlSAX2InitDefaultSAXHandler",
4612: xmlMemBlocks() - mem_base);
4613: test_ret++;
4614: printf(" %d", n_hdlr);
4615: printf(" %d", n_warning);
4616: printf("\n");
4617: }
4618: }
4619: }
4620: function_tests++;
4621:
4622: return(test_ret);
4623: }
4624:
4625:
4626: static int
4627: test_xmlSAX2InitDocbDefaultSAXHandler(void) {
4628: int test_ret = 0;
4629:
4630: #if defined(LIBXML_DOCB_ENABLED)
4631: int mem_base;
4632: xmlSAXHandler * hdlr; /* the SAX handler */
4633: int n_hdlr;
4634:
4635: for (n_hdlr = 0;n_hdlr < gen_nb_xmlSAXHandler_ptr;n_hdlr++) {
4636: mem_base = xmlMemBlocks();
4637: hdlr = gen_xmlSAXHandler_ptr(n_hdlr, 0);
4638:
4639: xmlSAX2InitDocbDefaultSAXHandler(hdlr);
4640: call_tests++;
4641: des_xmlSAXHandler_ptr(n_hdlr, hdlr, 0);
4642: xmlResetLastError();
4643: if (mem_base != xmlMemBlocks()) {
4644: printf("Leak of %d blocks found in xmlSAX2InitDocbDefaultSAXHandler",
4645: xmlMemBlocks() - mem_base);
4646: test_ret++;
4647: printf(" %d", n_hdlr);
4648: printf("\n");
4649: }
4650: }
4651: function_tests++;
4652: #endif
4653:
4654: return(test_ret);
4655: }
4656:
4657:
4658: static int
4659: test_xmlSAX2InitHtmlDefaultSAXHandler(void) {
4660: int test_ret = 0;
4661:
4662: #if defined(LIBXML_HTML_ENABLED)
4663: int mem_base;
4664: xmlSAXHandler * hdlr; /* the SAX handler */
4665: int n_hdlr;
4666:
4667: for (n_hdlr = 0;n_hdlr < gen_nb_xmlSAXHandler_ptr;n_hdlr++) {
4668: mem_base = xmlMemBlocks();
4669: hdlr = gen_xmlSAXHandler_ptr(n_hdlr, 0);
4670:
4671: xmlSAX2InitHtmlDefaultSAXHandler(hdlr);
4672: call_tests++;
4673: des_xmlSAXHandler_ptr(n_hdlr, hdlr, 0);
4674: xmlResetLastError();
4675: if (mem_base != xmlMemBlocks()) {
4676: printf("Leak of %d blocks found in xmlSAX2InitHtmlDefaultSAXHandler",
4677: xmlMemBlocks() - mem_base);
4678: test_ret++;
4679: printf(" %d", n_hdlr);
4680: printf("\n");
4681: }
4682: }
4683: function_tests++;
4684: #endif
4685:
4686: return(test_ret);
4687: }
4688:
4689:
4690: static int
4691: test_xmlSAX2InternalSubset(void) {
4692: int test_ret = 0;
4693:
4694: int mem_base;
4695: void * ctx; /* the user data (XML parser context) */
4696: int n_ctx;
4697: xmlChar * name; /* the root element name */
4698: int n_name;
4699: xmlChar * ExternalID; /* the external ID */
4700: int n_ExternalID;
4701: xmlChar * SystemID; /* the SYSTEM ID (e.g. filename or URL) */
4702: int n_SystemID;
4703:
4704: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4705: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
4706: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
4707: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
4708: mem_base = xmlMemBlocks();
4709: ctx = gen_void_ptr(n_ctx, 0);
4710: name = gen_const_xmlChar_ptr(n_name, 1);
4711: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 2);
4712: SystemID = gen_const_xmlChar_ptr(n_SystemID, 3);
4713:
4714: xmlSAX2InternalSubset(ctx, (const xmlChar *)name, (const xmlChar *)ExternalID, (const xmlChar *)SystemID);
4715: call_tests++;
4716: des_void_ptr(n_ctx, ctx, 0);
4717: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
4718: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 2);
4719: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 3);
4720: xmlResetLastError();
4721: if (mem_base != xmlMemBlocks()) {
4722: printf("Leak of %d blocks found in xmlSAX2InternalSubset",
4723: xmlMemBlocks() - mem_base);
4724: test_ret++;
4725: printf(" %d", n_ctx);
4726: printf(" %d", n_name);
4727: printf(" %d", n_ExternalID);
4728: printf(" %d", n_SystemID);
4729: printf("\n");
4730: }
4731: }
4732: }
4733: }
4734: }
4735: function_tests++;
4736:
4737: return(test_ret);
4738: }
4739:
4740:
4741: static int
4742: test_xmlSAX2IsStandalone(void) {
4743: int test_ret = 0;
4744:
4745: int mem_base;
4746: int ret_val;
4747: void * ctx; /* the user data (XML parser context) */
4748: int n_ctx;
4749:
4750: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4751: mem_base = xmlMemBlocks();
4752: ctx = gen_void_ptr(n_ctx, 0);
4753:
4754: ret_val = xmlSAX2IsStandalone(ctx);
4755: desret_int(ret_val);
4756: call_tests++;
4757: des_void_ptr(n_ctx, ctx, 0);
4758: xmlResetLastError();
4759: if (mem_base != xmlMemBlocks()) {
4760: printf("Leak of %d blocks found in xmlSAX2IsStandalone",
4761: xmlMemBlocks() - mem_base);
4762: test_ret++;
4763: printf(" %d", n_ctx);
4764: printf("\n");
4765: }
4766: }
4767: function_tests++;
4768:
4769: return(test_ret);
4770: }
4771:
4772:
4773: static int
4774: test_xmlSAX2NotationDecl(void) {
4775: int test_ret = 0;
4776:
4777: int mem_base;
4778: void * ctx; /* the user data (XML parser context) */
4779: int n_ctx;
4780: xmlChar * name; /* The name of the notation */
4781: int n_name;
4782: xmlChar * publicId; /* The public ID of the entity */
4783: int n_publicId;
4784: xmlChar * systemId; /* The system ID of the entity */
4785: int n_systemId;
4786:
4787: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4788: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
4789: for (n_publicId = 0;n_publicId < gen_nb_const_xmlChar_ptr;n_publicId++) {
4790: for (n_systemId = 0;n_systemId < gen_nb_const_xmlChar_ptr;n_systemId++) {
4791: mem_base = xmlMemBlocks();
4792: ctx = gen_void_ptr(n_ctx, 0);
4793: name = gen_const_xmlChar_ptr(n_name, 1);
4794: publicId = gen_const_xmlChar_ptr(n_publicId, 2);
4795: systemId = gen_const_xmlChar_ptr(n_systemId, 3);
4796:
4797: xmlSAX2NotationDecl(ctx, (const xmlChar *)name, (const xmlChar *)publicId, (const xmlChar *)systemId);
4798: call_tests++;
4799: des_void_ptr(n_ctx, ctx, 0);
4800: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
4801: des_const_xmlChar_ptr(n_publicId, (const xmlChar *)publicId, 2);
4802: des_const_xmlChar_ptr(n_systemId, (const xmlChar *)systemId, 3);
4803: xmlResetLastError();
4804: if (mem_base != xmlMemBlocks()) {
4805: printf("Leak of %d blocks found in xmlSAX2NotationDecl",
4806: xmlMemBlocks() - mem_base);
4807: test_ret++;
4808: printf(" %d", n_ctx);
4809: printf(" %d", n_name);
4810: printf(" %d", n_publicId);
4811: printf(" %d", n_systemId);
4812: printf("\n");
4813: }
4814: }
4815: }
4816: }
4817: }
4818: function_tests++;
4819:
4820: return(test_ret);
4821: }
4822:
4823:
4824: static int
4825: test_xmlSAX2ProcessingInstruction(void) {
4826: int test_ret = 0;
4827:
4828: int mem_base;
4829: void * ctx; /* the user data (XML parser context) */
4830: int n_ctx;
4831: xmlChar * target; /* the target name */
4832: int n_target;
4833: xmlChar * data; /* the PI data's */
4834: int n_data;
4835:
4836: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4837: for (n_target = 0;n_target < gen_nb_const_xmlChar_ptr;n_target++) {
4838: for (n_data = 0;n_data < gen_nb_const_xmlChar_ptr;n_data++) {
4839: mem_base = xmlMemBlocks();
4840: ctx = gen_void_ptr(n_ctx, 0);
4841: target = gen_const_xmlChar_ptr(n_target, 1);
4842: data = gen_const_xmlChar_ptr(n_data, 2);
4843:
4844: xmlSAX2ProcessingInstruction(ctx, (const xmlChar *)target, (const xmlChar *)data);
4845: call_tests++;
4846: des_void_ptr(n_ctx, ctx, 0);
4847: des_const_xmlChar_ptr(n_target, (const xmlChar *)target, 1);
4848: des_const_xmlChar_ptr(n_data, (const xmlChar *)data, 2);
4849: xmlResetLastError();
4850: if (mem_base != xmlMemBlocks()) {
4851: printf("Leak of %d blocks found in xmlSAX2ProcessingInstruction",
4852: xmlMemBlocks() - mem_base);
4853: test_ret++;
4854: printf(" %d", n_ctx);
4855: printf(" %d", n_target);
4856: printf(" %d", n_data);
4857: printf("\n");
4858: }
4859: }
4860: }
4861: }
4862: function_tests++;
4863:
4864: return(test_ret);
4865: }
4866:
4867:
4868: static int
4869: test_xmlSAX2Reference(void) {
4870: int test_ret = 0;
4871:
4872: int mem_base;
4873: void * ctx; /* the user data (XML parser context) */
4874: int n_ctx;
4875: xmlChar * name; /* The entity name */
4876: int n_name;
4877:
4878: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4879: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
4880: mem_base = xmlMemBlocks();
4881: ctx = gen_void_ptr(n_ctx, 0);
4882: name = gen_const_xmlChar_ptr(n_name, 1);
4883:
4884: xmlSAX2Reference(ctx, (const xmlChar *)name);
4885: call_tests++;
4886: des_void_ptr(n_ctx, ctx, 0);
4887: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
4888: xmlResetLastError();
4889: if (mem_base != xmlMemBlocks()) {
4890: printf("Leak of %d blocks found in xmlSAX2Reference",
4891: xmlMemBlocks() - mem_base);
4892: test_ret++;
4893: printf(" %d", n_ctx);
4894: printf(" %d", n_name);
4895: printf("\n");
4896: }
4897: }
4898: }
4899: function_tests++;
4900:
4901: return(test_ret);
4902: }
4903:
4904:
4905: static int
4906: test_xmlSAX2ResolveEntity(void) {
4907: int test_ret = 0;
4908:
4909: int mem_base;
4910: xmlParserInputPtr ret_val;
4911: void * ctx; /* the user data (XML parser context) */
4912: int n_ctx;
4913: xmlChar * publicId; /* The public ID of the entity */
4914: int n_publicId;
4915: xmlChar * systemId; /* The system ID of the entity */
4916: int n_systemId;
4917:
4918: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4919: for (n_publicId = 0;n_publicId < gen_nb_const_xmlChar_ptr;n_publicId++) {
4920: for (n_systemId = 0;n_systemId < gen_nb_const_xmlChar_ptr;n_systemId++) {
4921: mem_base = xmlMemBlocks();
4922: ctx = gen_void_ptr(n_ctx, 0);
4923: publicId = gen_const_xmlChar_ptr(n_publicId, 1);
4924: systemId = gen_const_xmlChar_ptr(n_systemId, 2);
4925:
4926: ret_val = xmlSAX2ResolveEntity(ctx, (const xmlChar *)publicId, (const xmlChar *)systemId);
4927: desret_xmlParserInputPtr(ret_val);
4928: call_tests++;
4929: des_void_ptr(n_ctx, ctx, 0);
4930: des_const_xmlChar_ptr(n_publicId, (const xmlChar *)publicId, 1);
4931: des_const_xmlChar_ptr(n_systemId, (const xmlChar *)systemId, 2);
4932: xmlResetLastError();
4933: if (mem_base != xmlMemBlocks()) {
4934: printf("Leak of %d blocks found in xmlSAX2ResolveEntity",
4935: xmlMemBlocks() - mem_base);
4936: test_ret++;
4937: printf(" %d", n_ctx);
4938: printf(" %d", n_publicId);
4939: printf(" %d", n_systemId);
4940: printf("\n");
4941: }
4942: }
4943: }
4944: }
4945: function_tests++;
4946:
4947: return(test_ret);
4948: }
4949:
4950:
4951: #define gen_nb_xmlSAXLocatorPtr 1
4952: static xmlSAXLocatorPtr gen_xmlSAXLocatorPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
4953: return(NULL);
4954: }
4955: static void des_xmlSAXLocatorPtr(int no ATTRIBUTE_UNUSED, xmlSAXLocatorPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
4956: }
4957:
4958: static int
4959: test_xmlSAX2SetDocumentLocator(void) {
4960: int test_ret = 0;
4961:
4962: int mem_base;
4963: void * ctx; /* the user data (XML parser context) */
4964: int n_ctx;
4965: xmlSAXLocatorPtr loc; /* A SAX Locator */
4966: int n_loc;
4967:
4968: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4969: for (n_loc = 0;n_loc < gen_nb_xmlSAXLocatorPtr;n_loc++) {
4970: mem_base = xmlMemBlocks();
4971: ctx = gen_void_ptr(n_ctx, 0);
4972: loc = gen_xmlSAXLocatorPtr(n_loc, 1);
4973:
4974: xmlSAX2SetDocumentLocator(ctx, loc);
4975: call_tests++;
4976: des_void_ptr(n_ctx, ctx, 0);
4977: des_xmlSAXLocatorPtr(n_loc, loc, 1);
4978: xmlResetLastError();
4979: if (mem_base != xmlMemBlocks()) {
4980: printf("Leak of %d blocks found in xmlSAX2SetDocumentLocator",
4981: xmlMemBlocks() - mem_base);
4982: test_ret++;
4983: printf(" %d", n_ctx);
4984: printf(" %d", n_loc);
4985: printf("\n");
4986: }
4987: }
4988: }
4989: function_tests++;
4990:
4991: return(test_ret);
4992: }
4993:
4994:
4995: static int
4996: test_xmlSAX2StartDocument(void) {
4997: int test_ret = 0;
4998:
4999: int mem_base;
5000: void * ctx; /* the user data (XML parser context) */
5001: int n_ctx;
5002:
5003: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
5004: mem_base = xmlMemBlocks();
5005: ctx = gen_void_ptr(n_ctx, 0);
5006:
5007: xmlSAX2StartDocument(ctx);
5008: call_tests++;
5009: des_void_ptr(n_ctx, ctx, 0);
5010: xmlResetLastError();
5011: if (mem_base != xmlMemBlocks()) {
5012: printf("Leak of %d blocks found in xmlSAX2StartDocument",
5013: xmlMemBlocks() - mem_base);
5014: test_ret++;
5015: printf(" %d", n_ctx);
5016: printf("\n");
5017: }
5018: }
5019: function_tests++;
5020:
5021: return(test_ret);
5022: }
5023:
5024:
5025: static int
5026: test_xmlSAX2StartElement(void) {
5027: int test_ret = 0;
5028:
5029: #if defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_DOCB_ENABLED)
5030: #ifdef LIBXML_SAX1_ENABLED
5031: int mem_base;
5032: void * ctx; /* the user data (XML parser context) */
5033: int n_ctx;
5034: xmlChar * fullname; /* The element name, including namespace prefix */
5035: int n_fullname;
5036: xmlChar ** atts; /* An array of name/value attributes pairs, NULL terminated */
5037: int n_atts;
5038:
5039: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
5040: for (n_fullname = 0;n_fullname < gen_nb_const_xmlChar_ptr;n_fullname++) {
5041: for (n_atts = 0;n_atts < gen_nb_const_xmlChar_ptr_ptr;n_atts++) {
5042: mem_base = xmlMemBlocks();
5043: ctx = gen_void_ptr(n_ctx, 0);
5044: fullname = gen_const_xmlChar_ptr(n_fullname, 1);
5045: atts = gen_const_xmlChar_ptr_ptr(n_atts, 2);
5046:
5047: xmlSAX2StartElement(ctx, (const xmlChar *)fullname, (const xmlChar **)atts);
5048: call_tests++;
5049: des_void_ptr(n_ctx, ctx, 0);
5050: des_const_xmlChar_ptr(n_fullname, (const xmlChar *)fullname, 1);
5051: des_const_xmlChar_ptr_ptr(n_atts, (const xmlChar **)atts, 2);
5052: xmlResetLastError();
5053: if (mem_base != xmlMemBlocks()) {
5054: printf("Leak of %d blocks found in xmlSAX2StartElement",
5055: xmlMemBlocks() - mem_base);
5056: test_ret++;
5057: printf(" %d", n_ctx);
5058: printf(" %d", n_fullname);
5059: printf(" %d", n_atts);
5060: printf("\n");
5061: }
5062: }
5063: }
5064: }
5065: function_tests++;
5066: #endif
5067: #endif
5068:
5069: return(test_ret);
5070: }
5071:
5072:
5073: static int
5074: test_xmlSAX2StartElementNs(void) {
5075: int test_ret = 0;
5076:
5077: int mem_base;
5078: void * ctx; /* the user data (XML parser context) */
5079: int n_ctx;
5080: xmlChar * localname; /* the local name of the element */
5081: int n_localname;
5082: xmlChar * prefix; /* the element namespace prefix if available */
5083: int n_prefix;
5084: xmlChar * URI; /* the element namespace name if available */
5085: int n_URI;
5086: int nb_namespaces; /* number of namespace definitions on that node */
5087: int n_nb_namespaces;
5088: xmlChar ** namespaces; /* pointer to the array of prefix/URI pairs namespace definitions */
5089: int n_namespaces;
5090: int nb_attributes; /* the number of attributes on that node */
5091: int n_nb_attributes;
5092: int nb_defaulted; /* the number of defaulted attributes. */
5093: int n_nb_defaulted;
5094: xmlChar ** attributes; /* pointer to the array of (localname/prefix/URI/value/end) attribute values. */
5095: int n_attributes;
5096:
5097: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
5098: for (n_localname = 0;n_localname < gen_nb_const_xmlChar_ptr;n_localname++) {
5099: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
5100: for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
5101: for (n_nb_namespaces = 0;n_nb_namespaces < gen_nb_int;n_nb_namespaces++) {
5102: for (n_namespaces = 0;n_namespaces < gen_nb_const_xmlChar_ptr_ptr;n_namespaces++) {
5103: for (n_nb_attributes = 0;n_nb_attributes < gen_nb_int;n_nb_attributes++) {
5104: for (n_nb_defaulted = 0;n_nb_defaulted < gen_nb_int;n_nb_defaulted++) {
5105: for (n_attributes = 0;n_attributes < gen_nb_const_xmlChar_ptr_ptr;n_attributes++) {
5106: mem_base = xmlMemBlocks();
5107: ctx = gen_void_ptr(n_ctx, 0);
5108: localname = gen_const_xmlChar_ptr(n_localname, 1);
5109: prefix = gen_const_xmlChar_ptr(n_prefix, 2);
5110: URI = gen_const_xmlChar_ptr(n_URI, 3);
5111: nb_namespaces = gen_int(n_nb_namespaces, 4);
5112: namespaces = gen_const_xmlChar_ptr_ptr(n_namespaces, 5);
5113: nb_attributes = gen_int(n_nb_attributes, 6);
5114: nb_defaulted = gen_int(n_nb_defaulted, 7);
5115: attributes = gen_const_xmlChar_ptr_ptr(n_attributes, 8);
5116:
5117: xmlSAX2StartElementNs(ctx, (const xmlChar *)localname, (const xmlChar *)prefix, (const xmlChar *)URI, nb_namespaces, (const xmlChar **)namespaces, nb_attributes, nb_defaulted, (const xmlChar **)attributes);
5118: call_tests++;
5119: des_void_ptr(n_ctx, ctx, 0);
5120: des_const_xmlChar_ptr(n_localname, (const xmlChar *)localname, 1);
5121: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 2);
5122: des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 3);
5123: des_int(n_nb_namespaces, nb_namespaces, 4);
5124: des_const_xmlChar_ptr_ptr(n_namespaces, (const xmlChar **)namespaces, 5);
5125: des_int(n_nb_attributes, nb_attributes, 6);
5126: des_int(n_nb_defaulted, nb_defaulted, 7);
5127: des_const_xmlChar_ptr_ptr(n_attributes, (const xmlChar **)attributes, 8);
5128: xmlResetLastError();
5129: if (mem_base != xmlMemBlocks()) {
5130: printf("Leak of %d blocks found in xmlSAX2StartElementNs",
5131: xmlMemBlocks() - mem_base);
5132: test_ret++;
5133: printf(" %d", n_ctx);
5134: printf(" %d", n_localname);
5135: printf(" %d", n_prefix);
5136: printf(" %d", n_URI);
5137: printf(" %d", n_nb_namespaces);
5138: printf(" %d", n_namespaces);
5139: printf(" %d", n_nb_attributes);
5140: printf(" %d", n_nb_defaulted);
5141: printf(" %d", n_attributes);
5142: printf("\n");
5143: }
5144: }
5145: }
5146: }
5147: }
5148: }
5149: }
5150: }
5151: }
5152: }
5153: function_tests++;
5154:
5155: return(test_ret);
5156: }
5157:
5158:
5159: static int
5160: test_xmlSAX2UnparsedEntityDecl(void) {
5161: int test_ret = 0;
5162:
5163: int mem_base;
5164: void * ctx; /* the user data (XML parser context) */
5165: int n_ctx;
5166: xmlChar * name; /* The name of the entity */
5167: int n_name;
5168: xmlChar * publicId; /* The public ID of the entity */
5169: int n_publicId;
5170: xmlChar * systemId; /* The system ID of the entity */
5171: int n_systemId;
5172: xmlChar * notationName; /* the name of the notation */
5173: int n_notationName;
5174:
5175: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
5176: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
5177: for (n_publicId = 0;n_publicId < gen_nb_const_xmlChar_ptr;n_publicId++) {
5178: for (n_systemId = 0;n_systemId < gen_nb_const_xmlChar_ptr;n_systemId++) {
5179: for (n_notationName = 0;n_notationName < gen_nb_const_xmlChar_ptr;n_notationName++) {
5180: mem_base = xmlMemBlocks();
5181: ctx = gen_void_ptr(n_ctx, 0);
5182: name = gen_const_xmlChar_ptr(n_name, 1);
5183: publicId = gen_const_xmlChar_ptr(n_publicId, 2);
5184: systemId = gen_const_xmlChar_ptr(n_systemId, 3);
5185: notationName = gen_const_xmlChar_ptr(n_notationName, 4);
5186:
5187: xmlSAX2UnparsedEntityDecl(ctx, (const xmlChar *)name, (const xmlChar *)publicId, (const xmlChar *)systemId, (const xmlChar *)notationName);
5188: call_tests++;
5189: des_void_ptr(n_ctx, ctx, 0);
5190: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
5191: des_const_xmlChar_ptr(n_publicId, (const xmlChar *)publicId, 2);
5192: des_const_xmlChar_ptr(n_systemId, (const xmlChar *)systemId, 3);
5193: des_const_xmlChar_ptr(n_notationName, (const xmlChar *)notationName, 4);
5194: xmlResetLastError();
5195: if (mem_base != xmlMemBlocks()) {
5196: printf("Leak of %d blocks found in xmlSAX2UnparsedEntityDecl",
5197: xmlMemBlocks() - mem_base);
5198: test_ret++;
5199: printf(" %d", n_ctx);
5200: printf(" %d", n_name);
5201: printf(" %d", n_publicId);
5202: printf(" %d", n_systemId);
5203: printf(" %d", n_notationName);
5204: printf("\n");
5205: }
5206: }
5207: }
5208: }
5209: }
5210: }
5211: function_tests++;
5212:
5213: return(test_ret);
5214: }
5215:
5216:
5217: static int
5218: test_xmlSAXDefaultVersion(void) {
5219: int test_ret = 0;
5220:
5221: #if defined(LIBXML_SAX1_ENABLED)
5222: #ifdef LIBXML_SAX1_ENABLED
5223: int mem_base;
5224: int ret_val;
5225: int version; /* the version, 1 or 2 */
5226: int n_version;
5227:
5228: for (n_version = 0;n_version < gen_nb_int;n_version++) {
5229: mem_base = xmlMemBlocks();
5230: version = gen_int(n_version, 0);
5231:
5232: ret_val = xmlSAXDefaultVersion(version);
5233: desret_int(ret_val);
5234: call_tests++;
5235: des_int(n_version, version, 0);
5236: xmlResetLastError();
5237: if (mem_base != xmlMemBlocks()) {
5238: printf("Leak of %d blocks found in xmlSAXDefaultVersion",
5239: xmlMemBlocks() - mem_base);
5240: test_ret++;
5241: printf(" %d", n_version);
5242: printf("\n");
5243: }
5244: }
5245: function_tests++;
5246: #endif
5247: #endif
5248:
5249: return(test_ret);
5250: }
5251:
5252:
5253: static int
5254: test_xmlSAXVersion(void) {
5255: int test_ret = 0;
5256:
5257: int mem_base;
5258: int ret_val;
5259: xmlSAXHandler * hdlr; /* the SAX handler */
5260: int n_hdlr;
5261: int version; /* the version, 1 or 2 */
5262: int n_version;
5263:
5264: for (n_hdlr = 0;n_hdlr < gen_nb_xmlSAXHandler_ptr;n_hdlr++) {
5265: for (n_version = 0;n_version < gen_nb_int;n_version++) {
5266: mem_base = xmlMemBlocks();
5267: hdlr = gen_xmlSAXHandler_ptr(n_hdlr, 0);
5268: version = gen_int(n_version, 1);
5269:
5270: ret_val = xmlSAXVersion(hdlr, version);
5271: desret_int(ret_val);
5272: call_tests++;
5273: des_xmlSAXHandler_ptr(n_hdlr, hdlr, 0);
5274: des_int(n_version, version, 1);
5275: xmlResetLastError();
5276: if (mem_base != xmlMemBlocks()) {
5277: printf("Leak of %d blocks found in xmlSAXVersion",
5278: xmlMemBlocks() - mem_base);
5279: test_ret++;
5280: printf(" %d", n_hdlr);
5281: printf(" %d", n_version);
5282: printf("\n");
5283: }
5284: }
5285: }
5286: function_tests++;
5287:
5288: return(test_ret);
5289: }
5290:
5291: static int
5292: test_SAX2(void) {
5293: int test_ret = 0;
5294:
5295: if (quiet == 0) printf("Testing SAX2 : 38 of 38 functions ...\n");
5296: test_ret += test_docbDefaultSAXHandlerInit();
5297: test_ret += test_htmlDefaultSAXHandlerInit();
5298: test_ret += test_xmlDefaultSAXHandlerInit();
5299: test_ret += test_xmlSAX2AttributeDecl();
5300: test_ret += test_xmlSAX2CDataBlock();
5301: test_ret += test_xmlSAX2Characters();
5302: test_ret += test_xmlSAX2Comment();
5303: test_ret += test_xmlSAX2ElementDecl();
5304: test_ret += test_xmlSAX2EndDocument();
5305: test_ret += test_xmlSAX2EndElement();
5306: test_ret += test_xmlSAX2EndElementNs();
5307: test_ret += test_xmlSAX2EntityDecl();
5308: test_ret += test_xmlSAX2ExternalSubset();
5309: test_ret += test_xmlSAX2GetColumnNumber();
5310: test_ret += test_xmlSAX2GetEntity();
5311: test_ret += test_xmlSAX2GetLineNumber();
5312: test_ret += test_xmlSAX2GetParameterEntity();
5313: test_ret += test_xmlSAX2GetPublicId();
5314: test_ret += test_xmlSAX2GetSystemId();
5315: test_ret += test_xmlSAX2HasExternalSubset();
5316: test_ret += test_xmlSAX2HasInternalSubset();
5317: test_ret += test_xmlSAX2IgnorableWhitespace();
5318: test_ret += test_xmlSAX2InitDefaultSAXHandler();
5319: test_ret += test_xmlSAX2InitDocbDefaultSAXHandler();
5320: test_ret += test_xmlSAX2InitHtmlDefaultSAXHandler();
5321: test_ret += test_xmlSAX2InternalSubset();
5322: test_ret += test_xmlSAX2IsStandalone();
5323: test_ret += test_xmlSAX2NotationDecl();
5324: test_ret += test_xmlSAX2ProcessingInstruction();
5325: test_ret += test_xmlSAX2Reference();
5326: test_ret += test_xmlSAX2ResolveEntity();
5327: test_ret += test_xmlSAX2SetDocumentLocator();
5328: test_ret += test_xmlSAX2StartDocument();
5329: test_ret += test_xmlSAX2StartElement();
5330: test_ret += test_xmlSAX2StartElementNs();
5331: test_ret += test_xmlSAX2UnparsedEntityDecl();
5332: test_ret += test_xmlSAXDefaultVersion();
5333: test_ret += test_xmlSAXVersion();
5334:
5335: if (test_ret != 0)
5336: printf("Module SAX2: %d errors\n", test_ret);
5337: return(test_ret);
5338: }
5339:
5340: static int
5341: test_xmlC14NDocDumpMemory(void) {
5342: int test_ret = 0;
5343:
5344: #if defined(LIBXML_C14N_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
5345: int mem_base;
5346: int ret_val;
5347: xmlDocPtr doc; /* the XML document for canonization */
5348: int n_doc;
5349: xmlNodeSetPtr nodes; /* the nodes set to be included in the canonized image or NULL if all document nodes should be included */
5350: int n_nodes;
5351: int mode; /* the c14n mode (see @xmlC14NMode) */
5352: int n_mode;
5353: 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) */
5354: int n_inclusive_ns_prefixes;
5355: int with_comments; /* include comments in the result (!=0) or not (==0) */
5356: int n_with_comments;
5357: 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 */
5358: int n_doc_txt_ptr;
5359:
5360: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
5361: for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
5362: for (n_mode = 0;n_mode < gen_nb_int;n_mode++) {
5363: for (n_inclusive_ns_prefixes = 0;n_inclusive_ns_prefixes < gen_nb_xmlChar_ptr_ptr;n_inclusive_ns_prefixes++) {
5364: for (n_with_comments = 0;n_with_comments < gen_nb_int;n_with_comments++) {
5365: for (n_doc_txt_ptr = 0;n_doc_txt_ptr < gen_nb_xmlChar_ptr_ptr;n_doc_txt_ptr++) {
5366: mem_base = xmlMemBlocks();
5367: doc = gen_xmlDocPtr(n_doc, 0);
5368: nodes = gen_xmlNodeSetPtr(n_nodes, 1);
5369: mode = gen_int(n_mode, 2);
5370: inclusive_ns_prefixes = gen_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, 3);
5371: with_comments = gen_int(n_with_comments, 4);
5372: doc_txt_ptr = gen_xmlChar_ptr_ptr(n_doc_txt_ptr, 5);
5373:
5374: ret_val = xmlC14NDocDumpMemory(doc, nodes, mode, inclusive_ns_prefixes, with_comments, doc_txt_ptr);
5375: desret_int(ret_val);
5376: call_tests++;
5377: des_xmlDocPtr(n_doc, doc, 0);
5378: des_xmlNodeSetPtr(n_nodes, nodes, 1);
5379: des_int(n_mode, mode, 2);
5380: des_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, inclusive_ns_prefixes, 3);
5381: des_int(n_with_comments, with_comments, 4);
5382: des_xmlChar_ptr_ptr(n_doc_txt_ptr, doc_txt_ptr, 5);
5383: xmlResetLastError();
5384: if (mem_base != xmlMemBlocks()) {
5385: printf("Leak of %d blocks found in xmlC14NDocDumpMemory",
5386: xmlMemBlocks() - mem_base);
5387: test_ret++;
5388: printf(" %d", n_doc);
5389: printf(" %d", n_nodes);
5390: printf(" %d", n_mode);
5391: printf(" %d", n_inclusive_ns_prefixes);
5392: printf(" %d", n_with_comments);
5393: printf(" %d", n_doc_txt_ptr);
5394: printf("\n");
5395: }
5396: }
5397: }
5398: }
5399: }
5400: }
5401: }
5402: function_tests++;
5403: #endif
5404:
5405: return(test_ret);
5406: }
5407:
5408:
5409: static int
5410: test_xmlC14NDocSave(void) {
5411: int test_ret = 0;
5412:
5413: #if defined(LIBXML_C14N_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
5414: int mem_base;
5415: int ret_val;
5416: xmlDocPtr doc; /* the XML document for canonization */
5417: int n_doc;
5418: xmlNodeSetPtr nodes; /* the nodes set to be included in the canonized image or NULL if all document nodes should be included */
5419: int n_nodes;
5420: int mode; /* the c14n mode (see @xmlC14NMode) */
5421: int n_mode;
5422: 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) */
5423: int n_inclusive_ns_prefixes;
5424: int with_comments; /* include comments in the result (!=0) or not (==0) */
5425: int n_with_comments;
5426: const char * filename; /* the filename to store canonical XML image */
5427: int n_filename;
5428: int compression; /* the compression level (zlib requred): -1 - libxml default, 0 - uncompressed, >0 - compression level */
5429: int n_compression;
5430:
5431: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
5432: for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
5433: for (n_mode = 0;n_mode < gen_nb_int;n_mode++) {
5434: for (n_inclusive_ns_prefixes = 0;n_inclusive_ns_prefixes < gen_nb_xmlChar_ptr_ptr;n_inclusive_ns_prefixes++) {
5435: for (n_with_comments = 0;n_with_comments < gen_nb_int;n_with_comments++) {
5436: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
5437: for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
5438: mem_base = xmlMemBlocks();
5439: doc = gen_xmlDocPtr(n_doc, 0);
5440: nodes = gen_xmlNodeSetPtr(n_nodes, 1);
5441: mode = gen_int(n_mode, 2);
5442: inclusive_ns_prefixes = gen_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, 3);
5443: with_comments = gen_int(n_with_comments, 4);
5444: filename = gen_fileoutput(n_filename, 5);
5445: compression = gen_int(n_compression, 6);
5446:
5447: ret_val = xmlC14NDocSave(doc, nodes, mode, inclusive_ns_prefixes, with_comments, filename, compression);
5448: desret_int(ret_val);
5449: call_tests++;
5450: des_xmlDocPtr(n_doc, doc, 0);
5451: des_xmlNodeSetPtr(n_nodes, nodes, 1);
5452: des_int(n_mode, mode, 2);
5453: des_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, inclusive_ns_prefixes, 3);
5454: des_int(n_with_comments, with_comments, 4);
5455: des_fileoutput(n_filename, filename, 5);
5456: des_int(n_compression, compression, 6);
5457: xmlResetLastError();
5458: if (mem_base != xmlMemBlocks()) {
5459: printf("Leak of %d blocks found in xmlC14NDocSave",
5460: xmlMemBlocks() - mem_base);
5461: test_ret++;
5462: printf(" %d", n_doc);
5463: printf(" %d", n_nodes);
5464: printf(" %d", n_mode);
5465: printf(" %d", n_inclusive_ns_prefixes);
5466: printf(" %d", n_with_comments);
5467: printf(" %d", n_filename);
5468: printf(" %d", n_compression);
5469: printf("\n");
5470: }
5471: }
5472: }
5473: }
5474: }
5475: }
5476: }
5477: }
5478: function_tests++;
5479: #endif
5480:
5481: return(test_ret);
5482: }
5483:
5484:
5485: static int
5486: test_xmlC14NDocSaveTo(void) {
5487: int test_ret = 0;
5488:
5489: #if defined(LIBXML_C14N_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
5490: int mem_base;
5491: int ret_val;
5492: xmlDocPtr doc; /* the XML document for canonization */
5493: int n_doc;
5494: xmlNodeSetPtr nodes; /* the nodes set to be included in the canonized image or NULL if all document nodes should be included */
5495: int n_nodes;
5496: int mode; /* the c14n mode (see @xmlC14NMode) */
5497: int n_mode;
5498: 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) */
5499: int n_inclusive_ns_prefixes;
5500: int with_comments; /* include comments in the result (!=0) or not (==0) */
5501: int n_with_comments;
5502: xmlOutputBufferPtr buf; /* the output buffer to store canonical XML; this buffer MUST have encoder==NULL because C14N requires UTF-8 output */
5503: int n_buf;
5504:
5505: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
5506: for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
5507: for (n_mode = 0;n_mode < gen_nb_int;n_mode++) {
5508: for (n_inclusive_ns_prefixes = 0;n_inclusive_ns_prefixes < gen_nb_xmlChar_ptr_ptr;n_inclusive_ns_prefixes++) {
5509: for (n_with_comments = 0;n_with_comments < gen_nb_int;n_with_comments++) {
5510: for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
5511: mem_base = xmlMemBlocks();
5512: doc = gen_xmlDocPtr(n_doc, 0);
5513: nodes = gen_xmlNodeSetPtr(n_nodes, 1);
5514: mode = gen_int(n_mode, 2);
5515: inclusive_ns_prefixes = gen_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, 3);
5516: with_comments = gen_int(n_with_comments, 4);
5517: buf = gen_xmlOutputBufferPtr(n_buf, 5);
5518:
5519: ret_val = xmlC14NDocSaveTo(doc, nodes, mode, inclusive_ns_prefixes, with_comments, buf);
5520: desret_int(ret_val);
5521: call_tests++;
5522: des_xmlDocPtr(n_doc, doc, 0);
5523: des_xmlNodeSetPtr(n_nodes, nodes, 1);
5524: des_int(n_mode, mode, 2);
5525: des_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, inclusive_ns_prefixes, 3);
5526: des_int(n_with_comments, with_comments, 4);
5527: des_xmlOutputBufferPtr(n_buf, buf, 5);
5528: xmlResetLastError();
5529: if (mem_base != xmlMemBlocks()) {
5530: printf("Leak of %d blocks found in xmlC14NDocSaveTo",
5531: xmlMemBlocks() - mem_base);
5532: test_ret++;
5533: printf(" %d", n_doc);
5534: printf(" %d", n_nodes);
5535: printf(" %d", n_mode);
5536: printf(" %d", n_inclusive_ns_prefixes);
5537: printf(" %d", n_with_comments);
5538: printf(" %d", n_buf);
5539: printf("\n");
5540: }
5541: }
5542: }
5543: }
5544: }
5545: }
5546: }
5547: function_tests++;
5548: #endif
5549:
5550: return(test_ret);
5551: }
5552:
5553:
5554: static int
5555: test_xmlC14NExecute(void) {
5556: int test_ret = 0;
5557:
5558:
5559: /* missing type support */
5560: return(test_ret);
5561: }
5562:
5563: static int
5564: test_c14n(void) {
5565: int test_ret = 0;
5566:
5567: if (quiet == 0) printf("Testing c14n : 3 of 4 functions ...\n");
5568: test_ret += test_xmlC14NDocDumpMemory();
5569: test_ret += test_xmlC14NDocSave();
5570: test_ret += test_xmlC14NDocSaveTo();
5571: test_ret += test_xmlC14NExecute();
5572:
5573: if (test_ret != 0)
5574: printf("Module c14n: %d errors\n", test_ret);
5575: return(test_ret);
5576: }
5577: #ifdef LIBXML_CATALOG_ENABLED
5578:
5579: #define gen_nb_xmlCatalogPtr 1
5580: static xmlCatalogPtr gen_xmlCatalogPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
5581: return(NULL);
5582: }
5583: static void des_xmlCatalogPtr(int no ATTRIBUTE_UNUSED, xmlCatalogPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
5584: }
5585: #endif
5586:
5587:
5588: static int
5589: test_xmlACatalogAdd(void) {
5590: int test_ret = 0;
5591:
5592: #if defined(LIBXML_CATALOG_ENABLED)
5593: int mem_base;
5594: int ret_val;
5595: xmlCatalogPtr catal; /* a Catalog */
5596: int n_catal;
5597: xmlChar * type; /* the type of record to add to the catalog */
5598: int n_type;
5599: xmlChar * orig; /* the system, public or prefix to match */
5600: int n_orig;
5601: xmlChar * replace; /* the replacement value for the match */
5602: int n_replace;
5603:
5604: for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
5605: for (n_type = 0;n_type < gen_nb_const_xmlChar_ptr;n_type++) {
5606: for (n_orig = 0;n_orig < gen_nb_const_xmlChar_ptr;n_orig++) {
5607: for (n_replace = 0;n_replace < gen_nb_const_xmlChar_ptr;n_replace++) {
5608: mem_base = xmlMemBlocks();
5609: catal = gen_xmlCatalogPtr(n_catal, 0);
5610: type = gen_const_xmlChar_ptr(n_type, 1);
5611: orig = gen_const_xmlChar_ptr(n_orig, 2);
5612: replace = gen_const_xmlChar_ptr(n_replace, 3);
5613:
5614: ret_val = xmlACatalogAdd(catal, (const xmlChar *)type, (const xmlChar *)orig, (const xmlChar *)replace);
5615: desret_int(ret_val);
5616: call_tests++;
5617: des_xmlCatalogPtr(n_catal, catal, 0);
5618: des_const_xmlChar_ptr(n_type, (const xmlChar *)type, 1);
5619: des_const_xmlChar_ptr(n_orig, (const xmlChar *)orig, 2);
5620: des_const_xmlChar_ptr(n_replace, (const xmlChar *)replace, 3);
5621: xmlResetLastError();
5622: if (mem_base != xmlMemBlocks()) {
5623: printf("Leak of %d blocks found in xmlACatalogAdd",
5624: xmlMemBlocks() - mem_base);
5625: test_ret++;
5626: printf(" %d", n_catal);
5627: printf(" %d", n_type);
5628: printf(" %d", n_orig);
5629: printf(" %d", n_replace);
5630: printf("\n");
5631: }
5632: }
5633: }
5634: }
5635: }
5636: function_tests++;
5637: #endif
5638:
5639: return(test_ret);
5640: }
5641:
5642:
5643: static int
5644: test_xmlACatalogDump(void) {
5645: int test_ret = 0;
5646:
5647: #if defined(LIBXML_CATALOG_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
5648: int mem_base;
5649: xmlCatalogPtr catal; /* a Catalog */
5650: int n_catal;
5651: FILE * out; /* the file. */
5652: int n_out;
5653:
5654: for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
5655: for (n_out = 0;n_out < gen_nb_FILE_ptr;n_out++) {
5656: mem_base = xmlMemBlocks();
5657: catal = gen_xmlCatalogPtr(n_catal, 0);
5658: out = gen_FILE_ptr(n_out, 1);
5659:
5660: xmlACatalogDump(catal, out);
5661: call_tests++;
5662: des_xmlCatalogPtr(n_catal, catal, 0);
5663: des_FILE_ptr(n_out, out, 1);
5664: xmlResetLastError();
5665: if (mem_base != xmlMemBlocks()) {
5666: printf("Leak of %d blocks found in xmlACatalogDump",
5667: xmlMemBlocks() - mem_base);
5668: test_ret++;
5669: printf(" %d", n_catal);
5670: printf(" %d", n_out);
5671: printf("\n");
5672: }
5673: }
5674: }
5675: function_tests++;
5676: #endif
5677:
5678: return(test_ret);
5679: }
5680:
5681:
5682: static int
5683: test_xmlACatalogRemove(void) {
5684: int test_ret = 0;
5685:
5686: #if defined(LIBXML_CATALOG_ENABLED)
5687: int mem_base;
5688: int ret_val;
5689: xmlCatalogPtr catal; /* a Catalog */
5690: int n_catal;
5691: xmlChar * value; /* the value to remove */
5692: int n_value;
5693:
5694: for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
5695: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
5696: mem_base = xmlMemBlocks();
5697: catal = gen_xmlCatalogPtr(n_catal, 0);
5698: value = gen_const_xmlChar_ptr(n_value, 1);
5699:
5700: ret_val = xmlACatalogRemove(catal, (const xmlChar *)value);
5701: desret_int(ret_val);
5702: call_tests++;
5703: des_xmlCatalogPtr(n_catal, catal, 0);
5704: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
5705: xmlResetLastError();
5706: if (mem_base != xmlMemBlocks()) {
5707: printf("Leak of %d blocks found in xmlACatalogRemove",
5708: xmlMemBlocks() - mem_base);
5709: test_ret++;
5710: printf(" %d", n_catal);
5711: printf(" %d", n_value);
5712: printf("\n");
5713: }
5714: }
5715: }
5716: function_tests++;
5717: #endif
5718:
5719: return(test_ret);
5720: }
5721:
5722:
5723: static int
5724: test_xmlACatalogResolve(void) {
5725: int test_ret = 0;
5726:
5727: #if defined(LIBXML_CATALOG_ENABLED)
5728: int mem_base;
5729: xmlChar * ret_val;
5730: xmlCatalogPtr catal; /* a Catalog */
5731: int n_catal;
5732: xmlChar * pubID; /* the public ID string */
5733: int n_pubID;
5734: xmlChar * sysID; /* the system ID string */
5735: int n_sysID;
5736:
5737: for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
5738: for (n_pubID = 0;n_pubID < gen_nb_const_xmlChar_ptr;n_pubID++) {
5739: for (n_sysID = 0;n_sysID < gen_nb_const_xmlChar_ptr;n_sysID++) {
5740: mem_base = xmlMemBlocks();
5741: catal = gen_xmlCatalogPtr(n_catal, 0);
5742: pubID = gen_const_xmlChar_ptr(n_pubID, 1);
5743: sysID = gen_const_xmlChar_ptr(n_sysID, 2);
5744:
5745: ret_val = xmlACatalogResolve(catal, (const xmlChar *)pubID, (const xmlChar *)sysID);
5746: desret_xmlChar_ptr(ret_val);
5747: call_tests++;
5748: des_xmlCatalogPtr(n_catal, catal, 0);
5749: des_const_xmlChar_ptr(n_pubID, (const xmlChar *)pubID, 1);
5750: des_const_xmlChar_ptr(n_sysID, (const xmlChar *)sysID, 2);
5751: xmlResetLastError();
5752: if (mem_base != xmlMemBlocks()) {
5753: printf("Leak of %d blocks found in xmlACatalogResolve",
5754: xmlMemBlocks() - mem_base);
5755: test_ret++;
5756: printf(" %d", n_catal);
5757: printf(" %d", n_pubID);
5758: printf(" %d", n_sysID);
5759: printf("\n");
5760: }
5761: }
5762: }
5763: }
5764: function_tests++;
5765: #endif
5766:
5767: return(test_ret);
5768: }
5769:
5770:
5771: static int
5772: test_xmlACatalogResolvePublic(void) {
5773: int test_ret = 0;
5774:
5775: #if defined(LIBXML_CATALOG_ENABLED)
5776: int mem_base;
5777: xmlChar * ret_val;
5778: xmlCatalogPtr catal; /* a Catalog */
5779: int n_catal;
5780: xmlChar * pubID; /* the public ID string */
5781: int n_pubID;
5782:
5783: for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
5784: for (n_pubID = 0;n_pubID < gen_nb_const_xmlChar_ptr;n_pubID++) {
5785: mem_base = xmlMemBlocks();
5786: catal = gen_xmlCatalogPtr(n_catal, 0);
5787: pubID = gen_const_xmlChar_ptr(n_pubID, 1);
5788:
5789: ret_val = xmlACatalogResolvePublic(catal, (const xmlChar *)pubID);
5790: desret_xmlChar_ptr(ret_val);
5791: call_tests++;
5792: des_xmlCatalogPtr(n_catal, catal, 0);
5793: des_const_xmlChar_ptr(n_pubID, (const xmlChar *)pubID, 1);
5794: xmlResetLastError();
5795: if (mem_base != xmlMemBlocks()) {
5796: printf("Leak of %d blocks found in xmlACatalogResolvePublic",
5797: xmlMemBlocks() - mem_base);
5798: test_ret++;
5799: printf(" %d", n_catal);
5800: printf(" %d", n_pubID);
5801: printf("\n");
5802: }
5803: }
5804: }
5805: function_tests++;
5806: #endif
5807:
5808: return(test_ret);
5809: }
5810:
5811:
5812: static int
5813: test_xmlACatalogResolveSystem(void) {
5814: int test_ret = 0;
5815:
5816: #if defined(LIBXML_CATALOG_ENABLED)
5817: int mem_base;
5818: xmlChar * ret_val;
5819: xmlCatalogPtr catal; /* a Catalog */
5820: int n_catal;
5821: xmlChar * sysID; /* the system ID string */
5822: int n_sysID;
5823:
5824: for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
5825: for (n_sysID = 0;n_sysID < gen_nb_const_xmlChar_ptr;n_sysID++) {
5826: mem_base = xmlMemBlocks();
5827: catal = gen_xmlCatalogPtr(n_catal, 0);
5828: sysID = gen_const_xmlChar_ptr(n_sysID, 1);
5829:
5830: ret_val = xmlACatalogResolveSystem(catal, (const xmlChar *)sysID);
5831: desret_xmlChar_ptr(ret_val);
5832: call_tests++;
5833: des_xmlCatalogPtr(n_catal, catal, 0);
5834: des_const_xmlChar_ptr(n_sysID, (const xmlChar *)sysID, 1);
5835: xmlResetLastError();
5836: if (mem_base != xmlMemBlocks()) {
5837: printf("Leak of %d blocks found in xmlACatalogResolveSystem",
5838: xmlMemBlocks() - mem_base);
5839: test_ret++;
5840: printf(" %d", n_catal);
5841: printf(" %d", n_sysID);
5842: printf("\n");
5843: }
5844: }
5845: }
5846: function_tests++;
5847: #endif
5848:
5849: return(test_ret);
5850: }
5851:
5852:
5853: static int
5854: test_xmlACatalogResolveURI(void) {
5855: int test_ret = 0;
5856:
5857: #if defined(LIBXML_CATALOG_ENABLED)
5858: int mem_base;
5859: xmlChar * ret_val;
5860: xmlCatalogPtr catal; /* a Catalog */
5861: int n_catal;
5862: xmlChar * URI; /* the URI */
5863: int n_URI;
5864:
5865: for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
5866: for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
5867: mem_base = xmlMemBlocks();
5868: catal = gen_xmlCatalogPtr(n_catal, 0);
5869: URI = gen_const_xmlChar_ptr(n_URI, 1);
5870:
5871: ret_val = xmlACatalogResolveURI(catal, (const xmlChar *)URI);
5872: desret_xmlChar_ptr(ret_val);
5873: call_tests++;
5874: des_xmlCatalogPtr(n_catal, catal, 0);
5875: des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 1);
5876: xmlResetLastError();
5877: if (mem_base != xmlMemBlocks()) {
5878: printf("Leak of %d blocks found in xmlACatalogResolveURI",
5879: xmlMemBlocks() - mem_base);
5880: test_ret++;
5881: printf(" %d", n_catal);
5882: printf(" %d", n_URI);
5883: printf("\n");
5884: }
5885: }
5886: }
5887: function_tests++;
5888: #endif
5889:
5890: return(test_ret);
5891: }
5892:
5893:
5894: static int
5895: test_xmlCatalogAdd(void) {
5896: int test_ret = 0;
5897:
5898: #if defined(LIBXML_CATALOG_ENABLED)
5899: int mem_base;
5900: int ret_val;
5901: xmlChar * type; /* the type of record to add to the catalog */
5902: int n_type;
5903: xmlChar * orig; /* the system, public or prefix to match */
5904: int n_orig;
5905: xmlChar * replace; /* the replacement value for the match */
5906: int n_replace;
5907:
5908: for (n_type = 0;n_type < gen_nb_const_xmlChar_ptr;n_type++) {
5909: for (n_orig = 0;n_orig < gen_nb_const_xmlChar_ptr;n_orig++) {
5910: for (n_replace = 0;n_replace < gen_nb_const_xmlChar_ptr;n_replace++) {
5911: mem_base = xmlMemBlocks();
5912: type = gen_const_xmlChar_ptr(n_type, 0);
5913: orig = gen_const_xmlChar_ptr(n_orig, 1);
5914: replace = gen_const_xmlChar_ptr(n_replace, 2);
5915:
5916: ret_val = xmlCatalogAdd((const xmlChar *)type, (const xmlChar *)orig, (const xmlChar *)replace);
5917: desret_int(ret_val);
5918: call_tests++;
5919: des_const_xmlChar_ptr(n_type, (const xmlChar *)type, 0);
5920: des_const_xmlChar_ptr(n_orig, (const xmlChar *)orig, 1);
5921: des_const_xmlChar_ptr(n_replace, (const xmlChar *)replace, 2);
5922: xmlResetLastError();
5923: if (mem_base != xmlMemBlocks()) {
5924: printf("Leak of %d blocks found in xmlCatalogAdd",
5925: xmlMemBlocks() - mem_base);
5926: test_ret++;
5927: printf(" %d", n_type);
5928: printf(" %d", n_orig);
5929: printf(" %d", n_replace);
5930: printf("\n");
5931: }
5932: }
5933: }
5934: }
5935: function_tests++;
5936: #endif
5937:
5938: return(test_ret);
5939: }
5940:
5941:
5942: static int
5943: test_xmlCatalogCleanup(void) {
5944: int test_ret = 0;
5945:
5946: #if defined(LIBXML_CATALOG_ENABLED)
5947:
5948:
5949: xmlCatalogCleanup();
5950: call_tests++;
5951: xmlResetLastError();
5952: function_tests++;
5953: #endif
5954:
5955: return(test_ret);
5956: }
5957:
5958:
5959: static int
5960: test_xmlCatalogConvert(void) {
5961: int test_ret = 0;
5962:
5963: #if defined(LIBXML_CATALOG_ENABLED)
5964: int ret_val;
5965:
5966:
5967: ret_val = xmlCatalogConvert();
5968: desret_int(ret_val);
5969: call_tests++;
5970: xmlResetLastError();
5971: function_tests++;
5972: #endif
5973:
5974: return(test_ret);
5975: }
5976:
5977:
5978: static int
5979: test_xmlCatalogDump(void) {
5980: int test_ret = 0;
5981:
5982: #if defined(LIBXML_CATALOG_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
5983: int mem_base;
5984: FILE * out; /* the file. */
5985: int n_out;
5986:
5987: for (n_out = 0;n_out < gen_nb_FILE_ptr;n_out++) {
5988: mem_base = xmlMemBlocks();
5989: out = gen_FILE_ptr(n_out, 0);
5990:
5991: xmlCatalogDump(out);
5992: call_tests++;
5993: des_FILE_ptr(n_out, out, 0);
5994: xmlResetLastError();
5995: if (mem_base != xmlMemBlocks()) {
5996: printf("Leak of %d blocks found in xmlCatalogDump",
5997: xmlMemBlocks() - mem_base);
5998: test_ret++;
5999: printf(" %d", n_out);
6000: printf("\n");
6001: }
6002: }
6003: function_tests++;
6004: #endif
6005:
6006: return(test_ret);
6007: }
6008:
6009:
6010: static int
6011: test_xmlCatalogGetDefaults(void) {
6012: int test_ret = 0;
6013:
6014: #if defined(LIBXML_CATALOG_ENABLED)
6015: int mem_base;
6016: xmlCatalogAllow ret_val;
6017:
6018: mem_base = xmlMemBlocks();
6019:
6020: ret_val = xmlCatalogGetDefaults();
6021: desret_xmlCatalogAllow(ret_val);
6022: call_tests++;
6023: xmlResetLastError();
6024: if (mem_base != xmlMemBlocks()) {
6025: printf("Leak of %d blocks found in xmlCatalogGetDefaults",
6026: xmlMemBlocks() - mem_base);
6027: test_ret++;
6028: printf("\n");
6029: }
6030: function_tests++;
6031: #endif
6032:
6033: return(test_ret);
6034: }
6035:
6036:
6037: static int
6038: test_xmlCatalogIsEmpty(void) {
6039: int test_ret = 0;
6040:
6041: #if defined(LIBXML_CATALOG_ENABLED)
6042: int mem_base;
6043: int ret_val;
6044: xmlCatalogPtr catal; /* should this create an SGML catalog */
6045: int n_catal;
6046:
6047: for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
6048: mem_base = xmlMemBlocks();
6049: catal = gen_xmlCatalogPtr(n_catal, 0);
6050:
6051: ret_val = xmlCatalogIsEmpty(catal);
6052: desret_int(ret_val);
6053: call_tests++;
6054: des_xmlCatalogPtr(n_catal, catal, 0);
6055: xmlResetLastError();
6056: if (mem_base != xmlMemBlocks()) {
6057: printf("Leak of %d blocks found in xmlCatalogIsEmpty",
6058: xmlMemBlocks() - mem_base);
6059: test_ret++;
6060: printf(" %d", n_catal);
6061: printf("\n");
6062: }
6063: }
6064: function_tests++;
6065: #endif
6066:
6067: return(test_ret);
6068: }
6069:
6070:
6071: static int
6072: test_xmlCatalogLocalResolve(void) {
6073: int test_ret = 0;
6074:
6075: #if defined(LIBXML_CATALOG_ENABLED)
6076: int mem_base;
6077: xmlChar * ret_val;
6078: void * catalogs; /* a document's list of catalogs */
6079: int n_catalogs;
6080: xmlChar * pubID; /* the public ID string */
6081: int n_pubID;
6082: xmlChar * sysID; /* the system ID string */
6083: int n_sysID;
6084:
6085: for (n_catalogs = 0;n_catalogs < gen_nb_void_ptr;n_catalogs++) {
6086: for (n_pubID = 0;n_pubID < gen_nb_const_xmlChar_ptr;n_pubID++) {
6087: for (n_sysID = 0;n_sysID < gen_nb_const_xmlChar_ptr;n_sysID++) {
6088: mem_base = xmlMemBlocks();
6089: catalogs = gen_void_ptr(n_catalogs, 0);
6090: pubID = gen_const_xmlChar_ptr(n_pubID, 1);
6091: sysID = gen_const_xmlChar_ptr(n_sysID, 2);
6092:
6093: ret_val = xmlCatalogLocalResolve(catalogs, (const xmlChar *)pubID, (const xmlChar *)sysID);
6094: desret_xmlChar_ptr(ret_val);
6095: call_tests++;
6096: des_void_ptr(n_catalogs, catalogs, 0);
6097: des_const_xmlChar_ptr(n_pubID, (const xmlChar *)pubID, 1);
6098: des_const_xmlChar_ptr(n_sysID, (const xmlChar *)sysID, 2);
6099: xmlResetLastError();
6100: if (mem_base != xmlMemBlocks()) {
6101: printf("Leak of %d blocks found in xmlCatalogLocalResolve",
6102: xmlMemBlocks() - mem_base);
6103: test_ret++;
6104: printf(" %d", n_catalogs);
6105: printf(" %d", n_pubID);
6106: printf(" %d", n_sysID);
6107: printf("\n");
6108: }
6109: }
6110: }
6111: }
6112: function_tests++;
6113: #endif
6114:
6115: return(test_ret);
6116: }
6117:
6118:
6119: static int
6120: test_xmlCatalogLocalResolveURI(void) {
6121: int test_ret = 0;
6122:
6123: #if defined(LIBXML_CATALOG_ENABLED)
6124: int mem_base;
6125: xmlChar * ret_val;
6126: void * catalogs; /* a document's list of catalogs */
6127: int n_catalogs;
6128: xmlChar * URI; /* the URI */
6129: int n_URI;
6130:
6131: for (n_catalogs = 0;n_catalogs < gen_nb_void_ptr;n_catalogs++) {
6132: for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
6133: mem_base = xmlMemBlocks();
6134: catalogs = gen_void_ptr(n_catalogs, 0);
6135: URI = gen_const_xmlChar_ptr(n_URI, 1);
6136:
6137: ret_val = xmlCatalogLocalResolveURI(catalogs, (const xmlChar *)URI);
6138: desret_xmlChar_ptr(ret_val);
6139: call_tests++;
6140: des_void_ptr(n_catalogs, catalogs, 0);
6141: des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 1);
6142: xmlResetLastError();
6143: if (mem_base != xmlMemBlocks()) {
6144: printf("Leak of %d blocks found in xmlCatalogLocalResolveURI",
6145: xmlMemBlocks() - mem_base);
6146: test_ret++;
6147: printf(" %d", n_catalogs);
6148: printf(" %d", n_URI);
6149: printf("\n");
6150: }
6151: }
6152: }
6153: function_tests++;
6154: #endif
6155:
6156: return(test_ret);
6157: }
6158:
6159:
6160: static int
6161: test_xmlCatalogRemove(void) {
6162: int test_ret = 0;
6163:
6164: #if defined(LIBXML_CATALOG_ENABLED)
6165: int ret_val;
6166: xmlChar * value; /* the value to remove */
6167: int n_value;
6168:
6169: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
6170: value = gen_const_xmlChar_ptr(n_value, 0);
6171:
6172: ret_val = xmlCatalogRemove((const xmlChar *)value);
6173: desret_int(ret_val);
6174: call_tests++;
6175: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
6176: xmlResetLastError();
6177: }
6178: function_tests++;
6179: #endif
6180:
6181: return(test_ret);
6182: }
6183:
6184:
6185: static int
6186: test_xmlCatalogResolve(void) {
6187: int test_ret = 0;
6188:
6189: #if defined(LIBXML_CATALOG_ENABLED)
6190: xmlChar * ret_val;
6191: xmlChar * pubID; /* the public ID string */
6192: int n_pubID;
6193: xmlChar * sysID; /* the system ID string */
6194: int n_sysID;
6195:
6196: for (n_pubID = 0;n_pubID < gen_nb_const_xmlChar_ptr;n_pubID++) {
6197: for (n_sysID = 0;n_sysID < gen_nb_const_xmlChar_ptr;n_sysID++) {
6198: pubID = gen_const_xmlChar_ptr(n_pubID, 0);
6199: sysID = gen_const_xmlChar_ptr(n_sysID, 1);
6200:
6201: ret_val = xmlCatalogResolve((const xmlChar *)pubID, (const xmlChar *)sysID);
6202: desret_xmlChar_ptr(ret_val);
6203: call_tests++;
6204: des_const_xmlChar_ptr(n_pubID, (const xmlChar *)pubID, 0);
6205: des_const_xmlChar_ptr(n_sysID, (const xmlChar *)sysID, 1);
6206: xmlResetLastError();
6207: }
6208: }
6209: function_tests++;
6210: #endif
6211:
6212: return(test_ret);
6213: }
6214:
6215:
6216: static int
6217: test_xmlCatalogResolvePublic(void) {
6218: int test_ret = 0;
6219:
6220: #if defined(LIBXML_CATALOG_ENABLED)
6221: int mem_base;
6222: xmlChar * ret_val;
6223: xmlChar * pubID; /* the public ID string */
6224: int n_pubID;
6225:
6226: for (n_pubID = 0;n_pubID < gen_nb_const_xmlChar_ptr;n_pubID++) {
6227: mem_base = xmlMemBlocks();
6228: pubID = gen_const_xmlChar_ptr(n_pubID, 0);
6229:
6230: ret_val = xmlCatalogResolvePublic((const xmlChar *)pubID);
6231: desret_xmlChar_ptr(ret_val);
6232: call_tests++;
6233: des_const_xmlChar_ptr(n_pubID, (const xmlChar *)pubID, 0);
6234: xmlResetLastError();
6235: if (mem_base != xmlMemBlocks()) {
6236: printf("Leak of %d blocks found in xmlCatalogResolvePublic",
6237: xmlMemBlocks() - mem_base);
6238: test_ret++;
6239: printf(" %d", n_pubID);
6240: printf("\n");
6241: }
6242: }
6243: function_tests++;
6244: #endif
6245:
6246: return(test_ret);
6247: }
6248:
6249:
6250: static int
6251: test_xmlCatalogResolveSystem(void) {
6252: int test_ret = 0;
6253:
6254: #if defined(LIBXML_CATALOG_ENABLED)
6255: int mem_base;
6256: xmlChar * ret_val;
6257: xmlChar * sysID; /* the system ID string */
6258: int n_sysID;
6259:
6260: for (n_sysID = 0;n_sysID < gen_nb_const_xmlChar_ptr;n_sysID++) {
6261: mem_base = xmlMemBlocks();
6262: sysID = gen_const_xmlChar_ptr(n_sysID, 0);
6263:
6264: ret_val = xmlCatalogResolveSystem((const xmlChar *)sysID);
6265: desret_xmlChar_ptr(ret_val);
6266: call_tests++;
6267: des_const_xmlChar_ptr(n_sysID, (const xmlChar *)sysID, 0);
6268: xmlResetLastError();
6269: if (mem_base != xmlMemBlocks()) {
6270: printf("Leak of %d blocks found in xmlCatalogResolveSystem",
6271: xmlMemBlocks() - mem_base);
6272: test_ret++;
6273: printf(" %d", n_sysID);
6274: printf("\n");
6275: }
6276: }
6277: function_tests++;
6278: #endif
6279:
6280: return(test_ret);
6281: }
6282:
6283:
6284: static int
6285: test_xmlCatalogResolveURI(void) {
6286: int test_ret = 0;
6287:
6288: #if defined(LIBXML_CATALOG_ENABLED)
6289: int mem_base;
6290: xmlChar * ret_val;
6291: xmlChar * URI; /* the URI */
6292: int n_URI;
6293:
6294: for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
6295: mem_base = xmlMemBlocks();
6296: URI = gen_const_xmlChar_ptr(n_URI, 0);
6297:
6298: ret_val = xmlCatalogResolveURI((const xmlChar *)URI);
6299: desret_xmlChar_ptr(ret_val);
6300: call_tests++;
6301: des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 0);
6302: xmlResetLastError();
6303: if (mem_base != xmlMemBlocks()) {
6304: printf("Leak of %d blocks found in xmlCatalogResolveURI",
6305: xmlMemBlocks() - mem_base);
6306: test_ret++;
6307: printf(" %d", n_URI);
6308: printf("\n");
6309: }
6310: }
6311: function_tests++;
6312: #endif
6313:
6314: return(test_ret);
6315: }
6316:
6317:
6318: static int
6319: test_xmlCatalogSetDefaultPrefer(void) {
6320: int test_ret = 0;
6321:
6322: #if defined(LIBXML_CATALOG_ENABLED)
6323: int mem_base;
6324: xmlCatalogPrefer ret_val;
6325: xmlCatalogPrefer prefer; /* the default preference for delegation */
6326: int n_prefer;
6327:
6328: for (n_prefer = 0;n_prefer < gen_nb_xmlCatalogPrefer;n_prefer++) {
6329: mem_base = xmlMemBlocks();
6330: prefer = gen_xmlCatalogPrefer(n_prefer, 0);
6331:
6332: ret_val = xmlCatalogSetDefaultPrefer(prefer);
6333: desret_xmlCatalogPrefer(ret_val);
6334: call_tests++;
6335: des_xmlCatalogPrefer(n_prefer, prefer, 0);
6336: xmlResetLastError();
6337: if (mem_base != xmlMemBlocks()) {
6338: printf("Leak of %d blocks found in xmlCatalogSetDefaultPrefer",
6339: xmlMemBlocks() - mem_base);
6340: test_ret++;
6341: printf(" %d", n_prefer);
6342: printf("\n");
6343: }
6344: }
6345: function_tests++;
6346: #endif
6347:
6348: return(test_ret);
6349: }
6350:
6351:
6352: static int
6353: test_xmlCatalogSetDefaults(void) {
6354: int test_ret = 0;
6355:
6356: #if defined(LIBXML_CATALOG_ENABLED)
6357: int mem_base;
6358: xmlCatalogAllow allow; /* what catalogs should be accepted */
6359: int n_allow;
6360:
6361: for (n_allow = 0;n_allow < gen_nb_xmlCatalogAllow;n_allow++) {
6362: mem_base = xmlMemBlocks();
6363: allow = gen_xmlCatalogAllow(n_allow, 0);
6364:
6365: xmlCatalogSetDefaults(allow);
6366: call_tests++;
6367: des_xmlCatalogAllow(n_allow, allow, 0);
6368: xmlResetLastError();
6369: if (mem_base != xmlMemBlocks()) {
6370: printf("Leak of %d blocks found in xmlCatalogSetDefaults",
6371: xmlMemBlocks() - mem_base);
6372: test_ret++;
6373: printf(" %d", n_allow);
6374: printf("\n");
6375: }
6376: }
6377: function_tests++;
6378: #endif
6379:
6380: return(test_ret);
6381: }
6382:
6383:
6384: static int
6385: test_xmlConvertSGMLCatalog(void) {
6386: int test_ret = 0;
6387:
6388: #if defined(LIBXML_CATALOG_ENABLED)
6389: int mem_base;
6390: int ret_val;
6391: xmlCatalogPtr catal; /* the catalog */
6392: int n_catal;
6393:
6394: for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
6395: mem_base = xmlMemBlocks();
6396: catal = gen_xmlCatalogPtr(n_catal, 0);
6397:
6398: ret_val = xmlConvertSGMLCatalog(catal);
6399: desret_int(ret_val);
6400: call_tests++;
6401: des_xmlCatalogPtr(n_catal, catal, 0);
6402: xmlResetLastError();
6403: if (mem_base != xmlMemBlocks()) {
6404: printf("Leak of %d blocks found in xmlConvertSGMLCatalog",
6405: xmlMemBlocks() - mem_base);
6406: test_ret++;
6407: printf(" %d", n_catal);
6408: printf("\n");
6409: }
6410: }
6411: function_tests++;
6412: #endif
6413:
6414: return(test_ret);
6415: }
6416:
6417:
6418: static int
6419: test_xmlInitializeCatalog(void) {
6420: int test_ret = 0;
6421:
6422: #if defined(LIBXML_CATALOG_ENABLED)
6423: int mem_base;
6424:
6425: mem_base = xmlMemBlocks();
6426:
6427: xmlInitializeCatalog();
6428: call_tests++;
6429: xmlResetLastError();
6430: if (mem_base != xmlMemBlocks()) {
6431: printf("Leak of %d blocks found in xmlInitializeCatalog",
6432: xmlMemBlocks() - mem_base);
6433: test_ret++;
6434: printf("\n");
6435: }
6436: function_tests++;
6437: #endif
6438:
6439: return(test_ret);
6440: }
6441:
6442:
6443: static int
6444: test_xmlLoadACatalog(void) {
6445: int test_ret = 0;
6446:
6447:
6448: /* missing type support */
6449: return(test_ret);
6450: }
6451:
6452:
6453: static int
6454: test_xmlLoadCatalog(void) {
6455: int test_ret = 0;
6456:
6457: #if defined(LIBXML_CATALOG_ENABLED)
6458: int ret_val;
6459: const char * filename; /* a file path */
6460: int n_filename;
6461:
6462: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
6463: filename = gen_filepath(n_filename, 0);
6464:
6465: ret_val = xmlLoadCatalog(filename);
6466: desret_int(ret_val);
6467: call_tests++;
6468: des_filepath(n_filename, filename, 0);
6469: xmlResetLastError();
6470: }
6471: function_tests++;
6472: #endif
6473:
6474: return(test_ret);
6475: }
6476:
6477:
6478: static int
6479: test_xmlLoadCatalogs(void) {
6480: int test_ret = 0;
6481:
6482: #if defined(LIBXML_CATALOG_ENABLED)
6483: char * pathss; /* a list of directories separated by a colon or a space. */
6484: int n_pathss;
6485:
6486: for (n_pathss = 0;n_pathss < gen_nb_const_char_ptr;n_pathss++) {
6487: pathss = gen_const_char_ptr(n_pathss, 0);
6488:
6489: xmlLoadCatalogs((const char *)pathss);
6490: call_tests++;
6491: des_const_char_ptr(n_pathss, (const char *)pathss, 0);
6492: xmlResetLastError();
6493: }
6494: function_tests++;
6495: #endif
6496:
6497: return(test_ret);
6498: }
6499:
6500:
6501: static int
6502: test_xmlLoadSGMLSuperCatalog(void) {
6503: int test_ret = 0;
6504:
6505:
6506: /* missing type support */
6507: return(test_ret);
6508: }
6509:
6510:
6511: static int
6512: test_xmlNewCatalog(void) {
6513: int test_ret = 0;
6514:
6515:
6516: /* missing type support */
6517: return(test_ret);
6518: }
6519:
6520:
6521: static int
6522: test_xmlParseCatalogFile(void) {
6523: int test_ret = 0;
6524:
6525: #if defined(LIBXML_CATALOG_ENABLED)
6526: int mem_base;
6527: xmlDocPtr ret_val;
6528: const char * filename; /* the filename */
6529: int n_filename;
6530:
6531: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
6532: mem_base = xmlMemBlocks();
6533: filename = gen_filepath(n_filename, 0);
6534:
6535: ret_val = xmlParseCatalogFile(filename);
6536: desret_xmlDocPtr(ret_val);
6537: call_tests++;
6538: des_filepath(n_filename, filename, 0);
6539: xmlResetLastError();
6540: if (mem_base != xmlMemBlocks()) {
6541: printf("Leak of %d blocks found in xmlParseCatalogFile",
6542: xmlMemBlocks() - mem_base);
6543: test_ret++;
6544: printf(" %d", n_filename);
6545: printf("\n");
6546: }
6547: }
6548: function_tests++;
6549: #endif
6550:
6551: return(test_ret);
6552: }
6553:
6554: static int
6555: test_catalog(void) {
6556: int test_ret = 0;
6557:
6558: if (quiet == 0) printf("Testing catalog : 27 of 36 functions ...\n");
6559: test_ret += test_xmlACatalogAdd();
6560: test_ret += test_xmlACatalogDump();
6561: test_ret += test_xmlACatalogRemove();
6562: test_ret += test_xmlACatalogResolve();
6563: test_ret += test_xmlACatalogResolvePublic();
6564: test_ret += test_xmlACatalogResolveSystem();
6565: test_ret += test_xmlACatalogResolveURI();
6566: test_ret += test_xmlCatalogAdd();
6567: test_ret += test_xmlCatalogCleanup();
6568: test_ret += test_xmlCatalogConvert();
6569: test_ret += test_xmlCatalogDump();
6570: test_ret += test_xmlCatalogGetDefaults();
6571: test_ret += test_xmlCatalogIsEmpty();
6572: test_ret += test_xmlCatalogLocalResolve();
6573: test_ret += test_xmlCatalogLocalResolveURI();
6574: test_ret += test_xmlCatalogRemove();
6575: test_ret += test_xmlCatalogResolve();
6576: test_ret += test_xmlCatalogResolvePublic();
6577: test_ret += test_xmlCatalogResolveSystem();
6578: test_ret += test_xmlCatalogResolveURI();
6579: test_ret += test_xmlCatalogSetDefaultPrefer();
6580: test_ret += test_xmlCatalogSetDefaults();
6581: test_ret += test_xmlConvertSGMLCatalog();
6582: test_ret += test_xmlInitializeCatalog();
6583: test_ret += test_xmlLoadACatalog();
6584: test_ret += test_xmlLoadCatalog();
6585: test_ret += test_xmlLoadCatalogs();
6586: test_ret += test_xmlLoadSGMLSuperCatalog();
6587: test_ret += test_xmlNewCatalog();
6588: test_ret += test_xmlParseCatalogFile();
6589:
6590: if (test_ret != 0)
6591: printf("Module catalog: %d errors\n", test_ret);
6592: return(test_ret);
6593: }
6594:
6595: #define gen_nb_const_xmlChRangeGroup_ptr 1
6596: static xmlChRangeGroup * gen_const_xmlChRangeGroup_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
6597: return(NULL);
6598: }
6599: static void des_const_xmlChRangeGroup_ptr(int no ATTRIBUTE_UNUSED, const xmlChRangeGroup * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
6600: }
6601:
6602: static int
6603: test_xmlCharInRange(void) {
6604: int test_ret = 0;
6605:
6606: int mem_base;
6607: int ret_val;
6608: unsigned int val; /* character to be validated */
6609: int n_val;
6610: xmlChRangeGroup * rptr; /* pointer to range to be used to validate */
6611: int n_rptr;
6612:
6613: for (n_val = 0;n_val < gen_nb_unsigned_int;n_val++) {
6614: for (n_rptr = 0;n_rptr < gen_nb_const_xmlChRangeGroup_ptr;n_rptr++) {
6615: mem_base = xmlMemBlocks();
6616: val = gen_unsigned_int(n_val, 0);
6617: rptr = gen_const_xmlChRangeGroup_ptr(n_rptr, 1);
6618:
6619: ret_val = xmlCharInRange(val, (const xmlChRangeGroup *)rptr);
6620: desret_int(ret_val);
6621: call_tests++;
6622: des_unsigned_int(n_val, val, 0);
6623: des_const_xmlChRangeGroup_ptr(n_rptr, (const xmlChRangeGroup *)rptr, 1);
6624: xmlResetLastError();
6625: if (mem_base != xmlMemBlocks()) {
6626: printf("Leak of %d blocks found in xmlCharInRange",
6627: xmlMemBlocks() - mem_base);
6628: test_ret++;
6629: printf(" %d", n_val);
6630: printf(" %d", n_rptr);
6631: printf("\n");
6632: }
6633: }
6634: }
6635: function_tests++;
6636:
6637: return(test_ret);
6638: }
6639:
6640:
6641: static int
6642: test_xmlIsBaseChar(void) {
6643: int test_ret = 0;
6644:
6645: int mem_base;
6646: int ret_val;
6647: unsigned int ch; /* character to validate */
6648: int n_ch;
6649:
6650: for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
6651: mem_base = xmlMemBlocks();
6652: ch = gen_unsigned_int(n_ch, 0);
6653:
6654: ret_val = xmlIsBaseChar(ch);
6655: desret_int(ret_val);
6656: call_tests++;
6657: des_unsigned_int(n_ch, ch, 0);
6658: xmlResetLastError();
6659: if (mem_base != xmlMemBlocks()) {
6660: printf("Leak of %d blocks found in xmlIsBaseChar",
6661: xmlMemBlocks() - mem_base);
6662: test_ret++;
6663: printf(" %d", n_ch);
6664: printf("\n");
6665: }
6666: }
6667: function_tests++;
6668:
6669: return(test_ret);
6670: }
6671:
6672:
6673: static int
6674: test_xmlIsBlank(void) {
6675: int test_ret = 0;
6676:
6677: int mem_base;
6678: int ret_val;
6679: unsigned int ch; /* character to validate */
6680: int n_ch;
6681:
6682: for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
6683: mem_base = xmlMemBlocks();
6684: ch = gen_unsigned_int(n_ch, 0);
6685:
6686: ret_val = xmlIsBlank(ch);
6687: desret_int(ret_val);
6688: call_tests++;
6689: des_unsigned_int(n_ch, ch, 0);
6690: xmlResetLastError();
6691: if (mem_base != xmlMemBlocks()) {
6692: printf("Leak of %d blocks found in xmlIsBlank",
6693: xmlMemBlocks() - mem_base);
6694: test_ret++;
6695: printf(" %d", n_ch);
6696: printf("\n");
6697: }
6698: }
6699: function_tests++;
6700:
6701: return(test_ret);
6702: }
6703:
6704:
6705: static int
6706: test_xmlIsChar(void) {
6707: int test_ret = 0;
6708:
6709: int mem_base;
6710: int ret_val;
6711: unsigned int ch; /* character to validate */
6712: int n_ch;
6713:
6714: for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
6715: mem_base = xmlMemBlocks();
6716: ch = gen_unsigned_int(n_ch, 0);
6717:
6718: ret_val = xmlIsChar(ch);
6719: desret_int(ret_val);
6720: call_tests++;
6721: des_unsigned_int(n_ch, ch, 0);
6722: xmlResetLastError();
6723: if (mem_base != xmlMemBlocks()) {
6724: printf("Leak of %d blocks found in xmlIsChar",
6725: xmlMemBlocks() - mem_base);
6726: test_ret++;
6727: printf(" %d", n_ch);
6728: printf("\n");
6729: }
6730: }
6731: function_tests++;
6732:
6733: return(test_ret);
6734: }
6735:
6736:
6737: static int
6738: test_xmlIsCombining(void) {
6739: int test_ret = 0;
6740:
6741: int mem_base;
6742: int ret_val;
6743: unsigned int ch; /* character to validate */
6744: int n_ch;
6745:
6746: for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
6747: mem_base = xmlMemBlocks();
6748: ch = gen_unsigned_int(n_ch, 0);
6749:
6750: ret_val = xmlIsCombining(ch);
6751: desret_int(ret_val);
6752: call_tests++;
6753: des_unsigned_int(n_ch, ch, 0);
6754: xmlResetLastError();
6755: if (mem_base != xmlMemBlocks()) {
6756: printf("Leak of %d blocks found in xmlIsCombining",
6757: xmlMemBlocks() - mem_base);
6758: test_ret++;
6759: printf(" %d", n_ch);
6760: printf("\n");
6761: }
6762: }
6763: function_tests++;
6764:
6765: return(test_ret);
6766: }
6767:
6768:
6769: static int
6770: test_xmlIsDigit(void) {
6771: int test_ret = 0;
6772:
6773: int mem_base;
6774: int ret_val;
6775: unsigned int ch; /* character to validate */
6776: int n_ch;
6777:
6778: for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
6779: mem_base = xmlMemBlocks();
6780: ch = gen_unsigned_int(n_ch, 0);
6781:
6782: ret_val = xmlIsDigit(ch);
6783: desret_int(ret_val);
6784: call_tests++;
6785: des_unsigned_int(n_ch, ch, 0);
6786: xmlResetLastError();
6787: if (mem_base != xmlMemBlocks()) {
6788: printf("Leak of %d blocks found in xmlIsDigit",
6789: xmlMemBlocks() - mem_base);
6790: test_ret++;
6791: printf(" %d", n_ch);
6792: printf("\n");
6793: }
6794: }
6795: function_tests++;
6796:
6797: return(test_ret);
6798: }
6799:
6800:
6801: static int
6802: test_xmlIsExtender(void) {
6803: int test_ret = 0;
6804:
6805: int mem_base;
6806: int ret_val;
6807: unsigned int ch; /* character to validate */
6808: int n_ch;
6809:
6810: for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
6811: mem_base = xmlMemBlocks();
6812: ch = gen_unsigned_int(n_ch, 0);
6813:
6814: ret_val = xmlIsExtender(ch);
6815: desret_int(ret_val);
6816: call_tests++;
6817: des_unsigned_int(n_ch, ch, 0);
6818: xmlResetLastError();
6819: if (mem_base != xmlMemBlocks()) {
6820: printf("Leak of %d blocks found in xmlIsExtender",
6821: xmlMemBlocks() - mem_base);
6822: test_ret++;
6823: printf(" %d", n_ch);
6824: printf("\n");
6825: }
6826: }
6827: function_tests++;
6828:
6829: return(test_ret);
6830: }
6831:
6832:
6833: static int
6834: test_xmlIsIdeographic(void) {
6835: int test_ret = 0;
6836:
6837: int mem_base;
6838: int ret_val;
6839: unsigned int ch; /* character to validate */
6840: int n_ch;
6841:
6842: for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
6843: mem_base = xmlMemBlocks();
6844: ch = gen_unsigned_int(n_ch, 0);
6845:
6846: ret_val = xmlIsIdeographic(ch);
6847: desret_int(ret_val);
6848: call_tests++;
6849: des_unsigned_int(n_ch, ch, 0);
6850: xmlResetLastError();
6851: if (mem_base != xmlMemBlocks()) {
6852: printf("Leak of %d blocks found in xmlIsIdeographic",
6853: xmlMemBlocks() - mem_base);
6854: test_ret++;
6855: printf(" %d", n_ch);
6856: printf("\n");
6857: }
6858: }
6859: function_tests++;
6860:
6861: return(test_ret);
6862: }
6863:
6864:
6865: static int
6866: test_xmlIsPubidChar(void) {
6867: int test_ret = 0;
6868:
6869: int mem_base;
6870: int ret_val;
6871: unsigned int ch; /* character to validate */
6872: int n_ch;
6873:
6874: for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
6875: mem_base = xmlMemBlocks();
6876: ch = gen_unsigned_int(n_ch, 0);
6877:
6878: ret_val = xmlIsPubidChar(ch);
6879: desret_int(ret_val);
6880: call_tests++;
6881: des_unsigned_int(n_ch, ch, 0);
6882: xmlResetLastError();
6883: if (mem_base != xmlMemBlocks()) {
6884: printf("Leak of %d blocks found in xmlIsPubidChar",
6885: xmlMemBlocks() - mem_base);
6886: test_ret++;
6887: printf(" %d", n_ch);
6888: printf("\n");
6889: }
6890: }
6891: function_tests++;
6892:
6893: return(test_ret);
6894: }
6895:
6896: static int
6897: test_chvalid(void) {
6898: int test_ret = 0;
6899:
6900: if (quiet == 0) printf("Testing chvalid : 9 of 9 functions ...\n");
6901: test_ret += test_xmlCharInRange();
6902: test_ret += test_xmlIsBaseChar();
6903: test_ret += test_xmlIsBlank();
6904: test_ret += test_xmlIsChar();
6905: test_ret += test_xmlIsCombining();
6906: test_ret += test_xmlIsDigit();
6907: test_ret += test_xmlIsExtender();
6908: test_ret += test_xmlIsIdeographic();
6909: test_ret += test_xmlIsPubidChar();
6910:
6911: if (test_ret != 0)
6912: printf("Module chvalid: %d errors\n", test_ret);
6913: return(test_ret);
6914: }
6915:
6916: static int
6917: test_xmlBoolToText(void) {
6918: int test_ret = 0;
6919:
6920: #if defined(LIBXML_DEBUG_ENABLED)
6921: int mem_base;
6922: const char * ret_val;
6923: int boolval; /* a bool to turn into text */
6924: int n_boolval;
6925:
6926: for (n_boolval = 0;n_boolval < gen_nb_int;n_boolval++) {
6927: mem_base = xmlMemBlocks();
6928: boolval = gen_int(n_boolval, 0);
6929:
6930: ret_val = xmlBoolToText(boolval);
6931: desret_const_char_ptr(ret_val);
6932: call_tests++;
6933: des_int(n_boolval, boolval, 0);
6934: xmlResetLastError();
6935: if (mem_base != xmlMemBlocks()) {
6936: printf("Leak of %d blocks found in xmlBoolToText",
6937: xmlMemBlocks() - mem_base);
6938: test_ret++;
6939: printf(" %d", n_boolval);
6940: printf("\n");
6941: }
6942: }
6943: function_tests++;
6944: #endif
6945:
6946: return(test_ret);
6947: }
6948:
6949:
6950: static int
6951: test_xmlDebugCheckDocument(void) {
6952: int test_ret = 0;
6953:
6954: #if defined(LIBXML_DEBUG_ENABLED)
6955: int mem_base;
6956: int ret_val;
6957: FILE * output; /* the FILE * for the output */
6958: int n_output;
6959: xmlDocPtr doc; /* the document */
6960: int n_doc;
6961:
6962: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
6963: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
6964: mem_base = xmlMemBlocks();
6965: output = gen_debug_FILE_ptr(n_output, 0);
6966: doc = gen_xmlDocPtr(n_doc, 1);
6967:
6968: ret_val = xmlDebugCheckDocument(output, doc);
6969: desret_int(ret_val);
6970: call_tests++;
6971: des_debug_FILE_ptr(n_output, output, 0);
6972: des_xmlDocPtr(n_doc, doc, 1);
6973: xmlResetLastError();
6974: if (mem_base != xmlMemBlocks()) {
6975: printf("Leak of %d blocks found in xmlDebugCheckDocument",
6976: xmlMemBlocks() - mem_base);
6977: test_ret++;
6978: printf(" %d", n_output);
6979: printf(" %d", n_doc);
6980: printf("\n");
6981: }
6982: }
6983: }
6984: function_tests++;
6985: #endif
6986:
6987: return(test_ret);
6988: }
6989:
6990:
6991: static int
6992: test_xmlDebugDumpAttr(void) {
6993: int test_ret = 0;
6994:
6995: #if defined(LIBXML_DEBUG_ENABLED)
6996: int mem_base;
6997: FILE * output; /* the FILE * for the output */
6998: int n_output;
6999: xmlAttrPtr attr; /* the attribute */
7000: int n_attr;
7001: int depth; /* the indentation level. */
7002: int n_depth;
7003:
7004: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
7005: for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
7006: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
7007: mem_base = xmlMemBlocks();
7008: output = gen_debug_FILE_ptr(n_output, 0);
7009: attr = gen_xmlAttrPtr(n_attr, 1);
7010: depth = gen_int(n_depth, 2);
7011:
7012: xmlDebugDumpAttr(output, attr, depth);
7013: call_tests++;
7014: des_debug_FILE_ptr(n_output, output, 0);
7015: des_xmlAttrPtr(n_attr, attr, 1);
7016: des_int(n_depth, depth, 2);
7017: xmlResetLastError();
7018: if (mem_base != xmlMemBlocks()) {
7019: printf("Leak of %d blocks found in xmlDebugDumpAttr",
7020: xmlMemBlocks() - mem_base);
7021: test_ret++;
7022: printf(" %d", n_output);
7023: printf(" %d", n_attr);
7024: printf(" %d", n_depth);
7025: printf("\n");
7026: }
7027: }
7028: }
7029: }
7030: function_tests++;
7031: #endif
7032:
7033: return(test_ret);
7034: }
7035:
7036:
7037: static int
7038: test_xmlDebugDumpAttrList(void) {
7039: int test_ret = 0;
7040:
7041: #if defined(LIBXML_DEBUG_ENABLED)
7042: int mem_base;
7043: FILE * output; /* the FILE * for the output */
7044: int n_output;
7045: xmlAttrPtr attr; /* the attribute list */
7046: int n_attr;
7047: int depth; /* the indentation level. */
7048: int n_depth;
7049:
7050: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
7051: for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
7052: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
7053: mem_base = xmlMemBlocks();
7054: output = gen_debug_FILE_ptr(n_output, 0);
7055: attr = gen_xmlAttrPtr(n_attr, 1);
7056: depth = gen_int(n_depth, 2);
7057:
7058: xmlDebugDumpAttrList(output, attr, depth);
7059: call_tests++;
7060: des_debug_FILE_ptr(n_output, output, 0);
7061: des_xmlAttrPtr(n_attr, attr, 1);
7062: des_int(n_depth, depth, 2);
7063: xmlResetLastError();
7064: if (mem_base != xmlMemBlocks()) {
7065: printf("Leak of %d blocks found in xmlDebugDumpAttrList",
7066: xmlMemBlocks() - mem_base);
7067: test_ret++;
7068: printf(" %d", n_output);
7069: printf(" %d", n_attr);
7070: printf(" %d", n_depth);
7071: printf("\n");
7072: }
7073: }
7074: }
7075: }
7076: function_tests++;
7077: #endif
7078:
7079: return(test_ret);
7080: }
7081:
7082:
7083: static int
7084: test_xmlDebugDumpDTD(void) {
7085: int test_ret = 0;
7086:
7087: #if defined(LIBXML_DEBUG_ENABLED)
7088: int mem_base;
7089: FILE * output; /* the FILE * for the output */
7090: int n_output;
7091: xmlDtdPtr dtd; /* the DTD */
7092: int n_dtd;
7093:
7094: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
7095: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
7096: mem_base = xmlMemBlocks();
7097: output = gen_debug_FILE_ptr(n_output, 0);
7098: dtd = gen_xmlDtdPtr(n_dtd, 1);
7099:
7100: xmlDebugDumpDTD(output, dtd);
7101: call_tests++;
7102: des_debug_FILE_ptr(n_output, output, 0);
7103: des_xmlDtdPtr(n_dtd, dtd, 1);
7104: xmlResetLastError();
7105: if (mem_base != xmlMemBlocks()) {
7106: printf("Leak of %d blocks found in xmlDebugDumpDTD",
7107: xmlMemBlocks() - mem_base);
7108: test_ret++;
7109: printf(" %d", n_output);
7110: printf(" %d", n_dtd);
7111: printf("\n");
7112: }
7113: }
7114: }
7115: function_tests++;
7116: #endif
7117:
7118: return(test_ret);
7119: }
7120:
7121:
7122: static int
7123: test_xmlDebugDumpDocument(void) {
7124: int test_ret = 0;
7125:
7126: #if defined(LIBXML_DEBUG_ENABLED)
7127: int mem_base;
7128: FILE * output; /* the FILE * for the output */
7129: int n_output;
7130: xmlDocPtr doc; /* the document */
7131: int n_doc;
7132:
7133: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
7134: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
7135: mem_base = xmlMemBlocks();
7136: output = gen_debug_FILE_ptr(n_output, 0);
7137: doc = gen_xmlDocPtr(n_doc, 1);
7138:
7139: xmlDebugDumpDocument(output, doc);
7140: call_tests++;
7141: des_debug_FILE_ptr(n_output, output, 0);
7142: des_xmlDocPtr(n_doc, doc, 1);
7143: xmlResetLastError();
7144: if (mem_base != xmlMemBlocks()) {
7145: printf("Leak of %d blocks found in xmlDebugDumpDocument",
7146: xmlMemBlocks() - mem_base);
7147: test_ret++;
7148: printf(" %d", n_output);
7149: printf(" %d", n_doc);
7150: printf("\n");
7151: }
7152: }
7153: }
7154: function_tests++;
7155: #endif
7156:
7157: return(test_ret);
7158: }
7159:
7160:
7161: static int
7162: test_xmlDebugDumpDocumentHead(void) {
7163: int test_ret = 0;
7164:
7165: #if defined(LIBXML_DEBUG_ENABLED)
7166: int mem_base;
7167: FILE * output; /* the FILE * for the output */
7168: int n_output;
7169: xmlDocPtr doc; /* the document */
7170: int n_doc;
7171:
7172: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
7173: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
7174: mem_base = xmlMemBlocks();
7175: output = gen_debug_FILE_ptr(n_output, 0);
7176: doc = gen_xmlDocPtr(n_doc, 1);
7177:
7178: xmlDebugDumpDocumentHead(output, doc);
7179: call_tests++;
7180: des_debug_FILE_ptr(n_output, output, 0);
7181: des_xmlDocPtr(n_doc, doc, 1);
7182: xmlResetLastError();
7183: if (mem_base != xmlMemBlocks()) {
7184: printf("Leak of %d blocks found in xmlDebugDumpDocumentHead",
7185: xmlMemBlocks() - mem_base);
7186: test_ret++;
7187: printf(" %d", n_output);
7188: printf(" %d", n_doc);
7189: printf("\n");
7190: }
7191: }
7192: }
7193: function_tests++;
7194: #endif
7195:
7196: return(test_ret);
7197: }
7198:
7199:
7200: static int
7201: test_xmlDebugDumpEntities(void) {
7202: int test_ret = 0;
7203:
7204: #if defined(LIBXML_DEBUG_ENABLED)
7205: int mem_base;
7206: FILE * output; /* the FILE * for the output */
7207: int n_output;
7208: xmlDocPtr doc; /* the document */
7209: int n_doc;
7210:
7211: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
7212: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
7213: mem_base = xmlMemBlocks();
7214: output = gen_debug_FILE_ptr(n_output, 0);
7215: doc = gen_xmlDocPtr(n_doc, 1);
7216:
7217: xmlDebugDumpEntities(output, doc);
7218: call_tests++;
7219: des_debug_FILE_ptr(n_output, output, 0);
7220: des_xmlDocPtr(n_doc, doc, 1);
7221: xmlResetLastError();
7222: if (mem_base != xmlMemBlocks()) {
7223: printf("Leak of %d blocks found in xmlDebugDumpEntities",
7224: xmlMemBlocks() - mem_base);
7225: test_ret++;
7226: printf(" %d", n_output);
7227: printf(" %d", n_doc);
7228: printf("\n");
7229: }
7230: }
7231: }
7232: function_tests++;
7233: #endif
7234:
7235: return(test_ret);
7236: }
7237:
7238:
7239: static int
7240: test_xmlDebugDumpNode(void) {
7241: int test_ret = 0;
7242:
7243: #if defined(LIBXML_DEBUG_ENABLED)
7244: int mem_base;
7245: FILE * output; /* the FILE * for the output */
7246: int n_output;
7247: xmlNodePtr node; /* the node */
7248: int n_node;
7249: int depth; /* the indentation level. */
7250: int n_depth;
7251:
7252: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
7253: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7254: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
7255: mem_base = xmlMemBlocks();
7256: output = gen_debug_FILE_ptr(n_output, 0);
7257: node = gen_xmlNodePtr(n_node, 1);
7258: depth = gen_int(n_depth, 2);
7259:
7260: xmlDebugDumpNode(output, node, depth);
7261: call_tests++;
7262: des_debug_FILE_ptr(n_output, output, 0);
7263: des_xmlNodePtr(n_node, node, 1);
7264: des_int(n_depth, depth, 2);
7265: xmlResetLastError();
7266: if (mem_base != xmlMemBlocks()) {
7267: printf("Leak of %d blocks found in xmlDebugDumpNode",
7268: xmlMemBlocks() - mem_base);
7269: test_ret++;
7270: printf(" %d", n_output);
7271: printf(" %d", n_node);
7272: printf(" %d", n_depth);
7273: printf("\n");
7274: }
7275: }
7276: }
7277: }
7278: function_tests++;
7279: #endif
7280:
7281: return(test_ret);
7282: }
7283:
7284:
7285: static int
7286: test_xmlDebugDumpNodeList(void) {
7287: int test_ret = 0;
7288:
7289: #if defined(LIBXML_DEBUG_ENABLED)
7290: int mem_base;
7291: FILE * output; /* the FILE * for the output */
7292: int n_output;
7293: xmlNodePtr node; /* the node list */
7294: int n_node;
7295: int depth; /* the indentation level. */
7296: int n_depth;
7297:
7298: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
7299: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7300: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
7301: mem_base = xmlMemBlocks();
7302: output = gen_debug_FILE_ptr(n_output, 0);
7303: node = gen_xmlNodePtr(n_node, 1);
7304: depth = gen_int(n_depth, 2);
7305:
7306: xmlDebugDumpNodeList(output, node, depth);
7307: call_tests++;
7308: des_debug_FILE_ptr(n_output, output, 0);
7309: des_xmlNodePtr(n_node, node, 1);
7310: des_int(n_depth, depth, 2);
7311: xmlResetLastError();
7312: if (mem_base != xmlMemBlocks()) {
7313: printf("Leak of %d blocks found in xmlDebugDumpNodeList",
7314: xmlMemBlocks() - mem_base);
7315: test_ret++;
7316: printf(" %d", n_output);
7317: printf(" %d", n_node);
7318: printf(" %d", n_depth);
7319: printf("\n");
7320: }
7321: }
7322: }
7323: }
7324: function_tests++;
7325: #endif
7326:
7327: return(test_ret);
7328: }
7329:
7330:
7331: static int
7332: test_xmlDebugDumpOneNode(void) {
7333: int test_ret = 0;
7334:
7335: #if defined(LIBXML_DEBUG_ENABLED)
7336: int mem_base;
7337: FILE * output; /* the FILE * for the output */
7338: int n_output;
7339: xmlNodePtr node; /* the node */
7340: int n_node;
7341: int depth; /* the indentation level. */
7342: int n_depth;
7343:
7344: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
7345: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7346: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
7347: mem_base = xmlMemBlocks();
7348: output = gen_debug_FILE_ptr(n_output, 0);
7349: node = gen_xmlNodePtr(n_node, 1);
7350: depth = gen_int(n_depth, 2);
7351:
7352: xmlDebugDumpOneNode(output, node, depth);
7353: call_tests++;
7354: des_debug_FILE_ptr(n_output, output, 0);
7355: des_xmlNodePtr(n_node, node, 1);
7356: des_int(n_depth, depth, 2);
7357: xmlResetLastError();
7358: if (mem_base != xmlMemBlocks()) {
7359: printf("Leak of %d blocks found in xmlDebugDumpOneNode",
7360: xmlMemBlocks() - mem_base);
7361: test_ret++;
7362: printf(" %d", n_output);
7363: printf(" %d", n_node);
7364: printf(" %d", n_depth);
7365: printf("\n");
7366: }
7367: }
7368: }
7369: }
7370: function_tests++;
7371: #endif
7372:
7373: return(test_ret);
7374: }
7375:
7376:
7377: static int
7378: test_xmlDebugDumpString(void) {
7379: int test_ret = 0;
7380:
7381: #if defined(LIBXML_DEBUG_ENABLED)
7382: int mem_base;
7383: FILE * output; /* the FILE * for the output */
7384: int n_output;
7385: xmlChar * str; /* the string */
7386: int n_str;
7387:
7388: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
7389: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
7390: mem_base = xmlMemBlocks();
7391: output = gen_debug_FILE_ptr(n_output, 0);
7392: str = gen_const_xmlChar_ptr(n_str, 1);
7393:
7394: xmlDebugDumpString(output, (const xmlChar *)str);
7395: call_tests++;
7396: des_debug_FILE_ptr(n_output, output, 0);
7397: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
7398: xmlResetLastError();
7399: if (mem_base != xmlMemBlocks()) {
7400: printf("Leak of %d blocks found in xmlDebugDumpString",
7401: xmlMemBlocks() - mem_base);
7402: test_ret++;
7403: printf(" %d", n_output);
7404: printf(" %d", n_str);
7405: printf("\n");
7406: }
7407: }
7408: }
7409: function_tests++;
7410: #endif
7411:
7412: return(test_ret);
7413: }
7414:
7415:
7416: static int
7417: test_xmlLsCountNode(void) {
7418: int test_ret = 0;
7419:
7420: #if defined(LIBXML_DEBUG_ENABLED)
7421: int mem_base;
7422: int ret_val;
7423: xmlNodePtr node; /* the node to count */
7424: int n_node;
7425:
7426: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7427: mem_base = xmlMemBlocks();
7428: node = gen_xmlNodePtr(n_node, 0);
7429:
7430: ret_val = xmlLsCountNode(node);
7431: desret_int(ret_val);
7432: call_tests++;
7433: des_xmlNodePtr(n_node, node, 0);
7434: xmlResetLastError();
7435: if (mem_base != xmlMemBlocks()) {
7436: printf("Leak of %d blocks found in xmlLsCountNode",
7437: xmlMemBlocks() - mem_base);
7438: test_ret++;
7439: printf(" %d", n_node);
7440: printf("\n");
7441: }
7442: }
7443: function_tests++;
7444: #endif
7445:
7446: return(test_ret);
7447: }
7448:
7449:
7450: static int
7451: test_xmlLsOneNode(void) {
7452: int test_ret = 0;
7453:
7454: #if defined(LIBXML_DEBUG_ENABLED)
7455: int mem_base;
7456: FILE * output; /* the FILE * for the output */
7457: int n_output;
7458: xmlNodePtr node; /* the node to dump */
7459: int n_node;
7460:
7461: for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
7462: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7463: mem_base = xmlMemBlocks();
7464: output = gen_debug_FILE_ptr(n_output, 0);
7465: node = gen_xmlNodePtr(n_node, 1);
7466:
7467: xmlLsOneNode(output, node);
7468: call_tests++;
7469: des_debug_FILE_ptr(n_output, output, 0);
7470: des_xmlNodePtr(n_node, node, 1);
7471: xmlResetLastError();
7472: if (mem_base != xmlMemBlocks()) {
7473: printf("Leak of %d blocks found in xmlLsOneNode",
7474: xmlMemBlocks() - mem_base);
7475: test_ret++;
7476: printf(" %d", n_output);
7477: printf(" %d", n_node);
7478: printf("\n");
7479: }
7480: }
7481: }
7482: function_tests++;
7483: #endif
7484:
7485: return(test_ret);
7486: }
7487:
7488:
7489: #define gen_nb_char_ptr 1
7490: static char * gen_char_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
7491: return(NULL);
7492: }
7493: static void des_char_ptr(int no ATTRIBUTE_UNUSED, char * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
7494: }
7495:
7496: static int
7497: test_xmlShell(void) {
7498: int test_ret = 0;
7499:
7500:
7501: /* missing type support */
7502: return(test_ret);
7503: }
7504:
7505:
7506: static int
7507: test_xmlShellBase(void) {
7508: int test_ret = 0;
7509:
7510: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
7511: int mem_base;
7512: int ret_val;
7513: xmlShellCtxtPtr ctxt; /* the shell context */
7514: int n_ctxt;
7515: char * arg; /* unused */
7516: int n_arg;
7517: xmlNodePtr node; /* a node */
7518: int n_node;
7519: xmlNodePtr node2; /* unused */
7520: int n_node2;
7521:
7522: for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
7523: for (n_arg = 0;n_arg < gen_nb_char_ptr;n_arg++) {
7524: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7525: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
7526: mem_base = xmlMemBlocks();
7527: ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
7528: arg = gen_char_ptr(n_arg, 1);
7529: node = gen_xmlNodePtr(n_node, 2);
7530: node2 = gen_xmlNodePtr(n_node2, 3);
7531:
7532: ret_val = xmlShellBase(ctxt, arg, node, node2);
7533: desret_int(ret_val);
7534: call_tests++;
7535: des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
7536: des_char_ptr(n_arg, arg, 1);
7537: des_xmlNodePtr(n_node, node, 2);
7538: des_xmlNodePtr(n_node2, node2, 3);
7539: xmlResetLastError();
7540: if (mem_base != xmlMemBlocks()) {
7541: printf("Leak of %d blocks found in xmlShellBase",
7542: xmlMemBlocks() - mem_base);
7543: test_ret++;
7544: printf(" %d", n_ctxt);
7545: printf(" %d", n_arg);
7546: printf(" %d", n_node);
7547: printf(" %d", n_node2);
7548: printf("\n");
7549: }
7550: }
7551: }
7552: }
7553: }
7554: function_tests++;
7555: #endif
7556:
7557: return(test_ret);
7558: }
7559:
7560:
7561: static int
7562: test_xmlShellCat(void) {
7563: int test_ret = 0;
7564:
7565: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
7566: int mem_base;
7567: int ret_val;
7568: xmlShellCtxtPtr ctxt; /* the shell context */
7569: int n_ctxt;
7570: char * arg; /* unused */
7571: int n_arg;
7572: xmlNodePtr node; /* a node */
7573: int n_node;
7574: xmlNodePtr node2; /* unused */
7575: int n_node2;
7576:
7577: for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
7578: for (n_arg = 0;n_arg < gen_nb_char_ptr;n_arg++) {
7579: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7580: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
7581: mem_base = xmlMemBlocks();
7582: ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
7583: arg = gen_char_ptr(n_arg, 1);
7584: node = gen_xmlNodePtr(n_node, 2);
7585: node2 = gen_xmlNodePtr(n_node2, 3);
7586:
7587: ret_val = xmlShellCat(ctxt, arg, node, node2);
7588: desret_int(ret_val);
7589: call_tests++;
7590: des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
7591: des_char_ptr(n_arg, arg, 1);
7592: des_xmlNodePtr(n_node, node, 2);
7593: des_xmlNodePtr(n_node2, node2, 3);
7594: xmlResetLastError();
7595: if (mem_base != xmlMemBlocks()) {
7596: printf("Leak of %d blocks found in xmlShellCat",
7597: xmlMemBlocks() - mem_base);
7598: test_ret++;
7599: printf(" %d", n_ctxt);
7600: printf(" %d", n_arg);
7601: printf(" %d", n_node);
7602: printf(" %d", n_node2);
7603: printf("\n");
7604: }
7605: }
7606: }
7607: }
7608: }
7609: function_tests++;
7610: #endif
7611:
7612: return(test_ret);
7613: }
7614:
7615:
7616: static int
7617: test_xmlShellDir(void) {
7618: int test_ret = 0;
7619:
7620: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
7621: int mem_base;
7622: int ret_val;
7623: xmlShellCtxtPtr ctxt; /* the shell context */
7624: int n_ctxt;
7625: char * arg; /* unused */
7626: int n_arg;
7627: xmlNodePtr node; /* a node */
7628: int n_node;
7629: xmlNodePtr node2; /* unused */
7630: int n_node2;
7631:
7632: for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
7633: for (n_arg = 0;n_arg < gen_nb_char_ptr;n_arg++) {
7634: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7635: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
7636: mem_base = xmlMemBlocks();
7637: ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
7638: arg = gen_char_ptr(n_arg, 1);
7639: node = gen_xmlNodePtr(n_node, 2);
7640: node2 = gen_xmlNodePtr(n_node2, 3);
7641:
7642: ret_val = xmlShellDir(ctxt, arg, node, node2);
7643: desret_int(ret_val);
7644: call_tests++;
7645: des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
7646: des_char_ptr(n_arg, arg, 1);
7647: des_xmlNodePtr(n_node, node, 2);
7648: des_xmlNodePtr(n_node2, node2, 3);
7649: xmlResetLastError();
7650: if (mem_base != xmlMemBlocks()) {
7651: printf("Leak of %d blocks found in xmlShellDir",
7652: xmlMemBlocks() - mem_base);
7653: test_ret++;
7654: printf(" %d", n_ctxt);
7655: printf(" %d", n_arg);
7656: printf(" %d", n_node);
7657: printf(" %d", n_node2);
7658: printf("\n");
7659: }
7660: }
7661: }
7662: }
7663: }
7664: function_tests++;
7665: #endif
7666:
7667: return(test_ret);
7668: }
7669:
7670:
7671: static int
7672: test_xmlShellDu(void) {
7673: int test_ret = 0;
7674:
7675: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
7676: int mem_base;
7677: int ret_val;
7678: xmlShellCtxtPtr ctxt; /* the shell context */
7679: int n_ctxt;
7680: char * arg; /* unused */
7681: int n_arg;
7682: xmlNodePtr tree; /* a node defining a subtree */
7683: int n_tree;
7684: xmlNodePtr node2; /* unused */
7685: int n_node2;
7686:
7687: for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
7688: for (n_arg = 0;n_arg < gen_nb_char_ptr;n_arg++) {
7689: for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) {
7690: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
7691: mem_base = xmlMemBlocks();
7692: ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
7693: arg = gen_char_ptr(n_arg, 1);
7694: tree = gen_xmlNodePtr(n_tree, 2);
7695: node2 = gen_xmlNodePtr(n_node2, 3);
7696:
7697: ret_val = xmlShellDu(ctxt, arg, tree, node2);
7698: desret_int(ret_val);
7699: call_tests++;
7700: des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
7701: des_char_ptr(n_arg, arg, 1);
7702: des_xmlNodePtr(n_tree, tree, 2);
7703: des_xmlNodePtr(n_node2, node2, 3);
7704: xmlResetLastError();
7705: if (mem_base != xmlMemBlocks()) {
7706: printf("Leak of %d blocks found in xmlShellDu",
7707: xmlMemBlocks() - mem_base);
7708: test_ret++;
7709: printf(" %d", n_ctxt);
7710: printf(" %d", n_arg);
7711: printf(" %d", n_tree);
7712: printf(" %d", n_node2);
7713: printf("\n");
7714: }
7715: }
7716: }
7717: }
7718: }
7719: function_tests++;
7720: #endif
7721:
7722: return(test_ret);
7723: }
7724:
7725:
7726: static int
7727: test_xmlShellList(void) {
7728: int test_ret = 0;
7729:
7730: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
7731: int mem_base;
7732: int ret_val;
7733: xmlShellCtxtPtr ctxt; /* the shell context */
7734: int n_ctxt;
7735: char * arg; /* unused */
7736: int n_arg;
7737: xmlNodePtr node; /* a node */
7738: int n_node;
7739: xmlNodePtr node2; /* unused */
7740: int n_node2;
7741:
7742: for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
7743: for (n_arg = 0;n_arg < gen_nb_char_ptr;n_arg++) {
7744: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7745: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
7746: mem_base = xmlMemBlocks();
7747: ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
7748: arg = gen_char_ptr(n_arg, 1);
7749: node = gen_xmlNodePtr(n_node, 2);
7750: node2 = gen_xmlNodePtr(n_node2, 3);
7751:
7752: ret_val = xmlShellList(ctxt, arg, node, node2);
7753: desret_int(ret_val);
7754: call_tests++;
7755: des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
7756: des_char_ptr(n_arg, arg, 1);
7757: des_xmlNodePtr(n_node, node, 2);
7758: des_xmlNodePtr(n_node2, node2, 3);
7759: xmlResetLastError();
7760: if (mem_base != xmlMemBlocks()) {
7761: printf("Leak of %d blocks found in xmlShellList",
7762: xmlMemBlocks() - mem_base);
7763: test_ret++;
7764: printf(" %d", n_ctxt);
7765: printf(" %d", n_arg);
7766: printf(" %d", n_node);
7767: printf(" %d", n_node2);
7768: printf("\n");
7769: }
7770: }
7771: }
7772: }
7773: }
7774: function_tests++;
7775: #endif
7776:
7777: return(test_ret);
7778: }
7779:
7780:
7781: static int
7782: test_xmlShellLoad(void) {
7783: int test_ret = 0;
7784:
7785: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
7786: int mem_base;
7787: int ret_val;
7788: xmlShellCtxtPtr ctxt; /* the shell context */
7789: int n_ctxt;
7790: char * filename; /* the file name */
7791: int n_filename;
7792: xmlNodePtr node; /* unused */
7793: int n_node;
7794: xmlNodePtr node2; /* unused */
7795: int n_node2;
7796:
7797: for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
7798: for (n_filename = 0;n_filename < gen_nb_char_ptr;n_filename++) {
7799: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7800: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
7801: mem_base = xmlMemBlocks();
7802: ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
7803: filename = gen_char_ptr(n_filename, 1);
7804: node = gen_xmlNodePtr(n_node, 2);
7805: node2 = gen_xmlNodePtr(n_node2, 3);
7806:
7807: ret_val = xmlShellLoad(ctxt, filename, node, node2);
7808: desret_int(ret_val);
7809: call_tests++;
7810: des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
7811: des_char_ptr(n_filename, filename, 1);
7812: des_xmlNodePtr(n_node, node, 2);
7813: des_xmlNodePtr(n_node2, node2, 3);
7814: xmlResetLastError();
7815: if (mem_base != xmlMemBlocks()) {
7816: printf("Leak of %d blocks found in xmlShellLoad",
7817: xmlMemBlocks() - mem_base);
7818: test_ret++;
7819: printf(" %d", n_ctxt);
7820: printf(" %d", n_filename);
7821: printf(" %d", n_node);
7822: printf(" %d", n_node2);
7823: printf("\n");
7824: }
7825: }
7826: }
7827: }
7828: }
7829: function_tests++;
7830: #endif
7831:
7832: return(test_ret);
7833: }
7834:
7835:
7836: static int
7837: test_xmlShellPrintXPathResult(void) {
7838: int test_ret = 0;
7839:
7840: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
7841: int mem_base;
7842: xmlXPathObjectPtr list; /* a valid result generated by an xpath evaluation */
7843: int n_list;
7844:
7845: for (n_list = 0;n_list < gen_nb_xmlXPathObjectPtr;n_list++) {
7846: mem_base = xmlMemBlocks();
7847: list = gen_xmlXPathObjectPtr(n_list, 0);
7848:
7849: xmlShellPrintXPathResult(list);
7850: call_tests++;
7851: des_xmlXPathObjectPtr(n_list, list, 0);
7852: xmlResetLastError();
7853: if (mem_base != xmlMemBlocks()) {
7854: printf("Leak of %d blocks found in xmlShellPrintXPathResult",
7855: xmlMemBlocks() - mem_base);
7856: test_ret++;
7857: printf(" %d", n_list);
7858: printf("\n");
7859: }
7860: }
7861: function_tests++;
7862: #endif
7863:
7864: return(test_ret);
7865: }
7866:
7867:
7868: static int
7869: test_xmlShellPwd(void) {
7870: int test_ret = 0;
7871:
7872: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
7873: int mem_base;
7874: int ret_val;
7875: xmlShellCtxtPtr ctxt; /* the shell context */
7876: int n_ctxt;
7877: char * buffer; /* the output buffer */
7878: int n_buffer;
7879: xmlNodePtr node; /* a node */
7880: int n_node;
7881: xmlNodePtr node2; /* unused */
7882: int n_node2;
7883:
7884: for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
7885: for (n_buffer = 0;n_buffer < gen_nb_char_ptr;n_buffer++) {
7886: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7887: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
7888: mem_base = xmlMemBlocks();
7889: ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
7890: buffer = gen_char_ptr(n_buffer, 1);
7891: node = gen_xmlNodePtr(n_node, 2);
7892: node2 = gen_xmlNodePtr(n_node2, 3);
7893:
7894: ret_val = xmlShellPwd(ctxt, buffer, node, node2);
7895: desret_int(ret_val);
7896: call_tests++;
7897: des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
7898: des_char_ptr(n_buffer, buffer, 1);
7899: des_xmlNodePtr(n_node, node, 2);
7900: des_xmlNodePtr(n_node2, node2, 3);
7901: xmlResetLastError();
7902: if (mem_base != xmlMemBlocks()) {
7903: printf("Leak of %d blocks found in xmlShellPwd",
7904: xmlMemBlocks() - mem_base);
7905: test_ret++;
7906: printf(" %d", n_ctxt);
7907: printf(" %d", n_buffer);
7908: printf(" %d", n_node);
7909: printf(" %d", n_node2);
7910: printf("\n");
7911: }
7912: }
7913: }
7914: }
7915: }
7916: function_tests++;
7917: #endif
7918:
7919: return(test_ret);
7920: }
7921:
7922:
7923: static int
7924: test_xmlShellSave(void) {
7925: int test_ret = 0;
7926:
7927: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
7928: int mem_base;
7929: int ret_val;
7930: xmlShellCtxtPtr ctxt; /* the shell context */
7931: int n_ctxt;
7932: char * filename; /* the file name (optional) */
7933: int n_filename;
7934: xmlNodePtr node; /* unused */
7935: int n_node;
7936: xmlNodePtr node2; /* unused */
7937: int n_node2;
7938:
7939: for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
7940: for (n_filename = 0;n_filename < gen_nb_char_ptr;n_filename++) {
7941: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7942: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
7943: mem_base = xmlMemBlocks();
7944: ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
7945: filename = gen_char_ptr(n_filename, 1);
7946: node = gen_xmlNodePtr(n_node, 2);
7947: node2 = gen_xmlNodePtr(n_node2, 3);
7948:
7949: ret_val = xmlShellSave(ctxt, filename, node, node2);
7950: desret_int(ret_val);
7951: call_tests++;
7952: des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
7953: des_char_ptr(n_filename, filename, 1);
7954: des_xmlNodePtr(n_node, node, 2);
7955: des_xmlNodePtr(n_node2, node2, 3);
7956: xmlResetLastError();
7957: if (mem_base != xmlMemBlocks()) {
7958: printf("Leak of %d blocks found in xmlShellSave",
7959: xmlMemBlocks() - mem_base);
7960: test_ret++;
7961: printf(" %d", n_ctxt);
7962: printf(" %d", n_filename);
7963: printf(" %d", n_node);
7964: printf(" %d", n_node2);
7965: printf("\n");
7966: }
7967: }
7968: }
7969: }
7970: }
7971: function_tests++;
7972: #endif
7973:
7974: return(test_ret);
7975: }
7976:
7977:
7978: static int
7979: test_xmlShellValidate(void) {
7980: int test_ret = 0;
7981:
7982: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_VALID_ENABLED)
7983: int mem_base;
7984: int ret_val;
7985: xmlShellCtxtPtr ctxt; /* the shell context */
7986: int n_ctxt;
7987: char * dtd; /* the DTD URI (optional) */
7988: int n_dtd;
7989: xmlNodePtr node; /* unused */
7990: int n_node;
7991: xmlNodePtr node2; /* unused */
7992: int n_node2;
7993:
7994: for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
7995: for (n_dtd = 0;n_dtd < gen_nb_char_ptr;n_dtd++) {
7996: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7997: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
7998: mem_base = xmlMemBlocks();
7999: ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
8000: dtd = gen_char_ptr(n_dtd, 1);
8001: node = gen_xmlNodePtr(n_node, 2);
8002: node2 = gen_xmlNodePtr(n_node2, 3);
8003:
8004: ret_val = xmlShellValidate(ctxt, dtd, node, node2);
8005: desret_int(ret_val);
8006: call_tests++;
8007: des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
8008: des_char_ptr(n_dtd, dtd, 1);
8009: des_xmlNodePtr(n_node, node, 2);
8010: des_xmlNodePtr(n_node2, node2, 3);
8011: xmlResetLastError();
8012: if (mem_base != xmlMemBlocks()) {
8013: printf("Leak of %d blocks found in xmlShellValidate",
8014: xmlMemBlocks() - mem_base);
8015: test_ret++;
8016: printf(" %d", n_ctxt);
8017: printf(" %d", n_dtd);
8018: printf(" %d", n_node);
8019: printf(" %d", n_node2);
8020: printf("\n");
8021: }
8022: }
8023: }
8024: }
8025: }
8026: function_tests++;
8027: #endif
8028:
8029: return(test_ret);
8030: }
8031:
8032:
8033: static int
8034: test_xmlShellWrite(void) {
8035: int test_ret = 0;
8036:
8037: #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
8038: int mem_base;
8039: int ret_val;
8040: xmlShellCtxtPtr ctxt; /* the shell context */
8041: int n_ctxt;
8042: char * filename; /* the file name */
8043: int n_filename;
8044: xmlNodePtr node; /* a node in the tree */
8045: int n_node;
8046: xmlNodePtr node2; /* unused */
8047: int n_node2;
8048:
8049: for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
8050: for (n_filename = 0;n_filename < gen_nb_char_ptr;n_filename++) {
8051: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
8052: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
8053: mem_base = xmlMemBlocks();
8054: ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
8055: filename = gen_char_ptr(n_filename, 1);
8056: node = gen_xmlNodePtr(n_node, 2);
8057: node2 = gen_xmlNodePtr(n_node2, 3);
8058:
8059: ret_val = xmlShellWrite(ctxt, filename, node, node2);
8060: desret_int(ret_val);
8061: call_tests++;
8062: des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
8063: des_char_ptr(n_filename, filename, 1);
8064: des_xmlNodePtr(n_node, node, 2);
8065: des_xmlNodePtr(n_node2, node2, 3);
8066: xmlResetLastError();
8067: if (mem_base != xmlMemBlocks()) {
8068: printf("Leak of %d blocks found in xmlShellWrite",
8069: xmlMemBlocks() - mem_base);
8070: test_ret++;
8071: printf(" %d", n_ctxt);
8072: printf(" %d", n_filename);
8073: printf(" %d", n_node);
8074: printf(" %d", n_node2);
8075: printf("\n");
8076: }
8077: }
8078: }
8079: }
8080: }
8081: function_tests++;
8082: #endif
8083:
8084: return(test_ret);
8085: }
8086:
8087: static int
8088: test_debugXML(void) {
8089: int test_ret = 0;
8090:
8091: if (quiet == 0) printf("Testing debugXML : 25 of 28 functions ...\n");
8092: test_ret += test_xmlBoolToText();
8093: test_ret += test_xmlDebugCheckDocument();
8094: test_ret += test_xmlDebugDumpAttr();
8095: test_ret += test_xmlDebugDumpAttrList();
8096: test_ret += test_xmlDebugDumpDTD();
8097: test_ret += test_xmlDebugDumpDocument();
8098: test_ret += test_xmlDebugDumpDocumentHead();
8099: test_ret += test_xmlDebugDumpEntities();
8100: test_ret += test_xmlDebugDumpNode();
8101: test_ret += test_xmlDebugDumpNodeList();
8102: test_ret += test_xmlDebugDumpOneNode();
8103: test_ret += test_xmlDebugDumpString();
8104: test_ret += test_xmlLsCountNode();
8105: test_ret += test_xmlLsOneNode();
8106: test_ret += test_xmlShell();
8107: test_ret += test_xmlShellBase();
8108: test_ret += test_xmlShellCat();
8109: test_ret += test_xmlShellDir();
8110: test_ret += test_xmlShellDu();
8111: test_ret += test_xmlShellList();
8112: test_ret += test_xmlShellLoad();
8113: test_ret += test_xmlShellPrintXPathResult();
8114: test_ret += test_xmlShellPwd();
8115: test_ret += test_xmlShellSave();
8116: test_ret += test_xmlShellValidate();
8117: test_ret += test_xmlShellWrite();
8118:
8119: if (test_ret != 0)
8120: printf("Module debugXML: %d errors\n", test_ret);
8121: return(test_ret);
8122: }
8123:
8124: static int
8125: test_xmlDictCleanup(void) {
8126: int test_ret = 0;
8127:
8128: int mem_base;
8129:
8130: mem_base = xmlMemBlocks();
8131:
8132: xmlDictCleanup();
8133: call_tests++;
8134: xmlResetLastError();
8135: if (mem_base != xmlMemBlocks()) {
8136: printf("Leak of %d blocks found in xmlDictCleanup",
8137: xmlMemBlocks() - mem_base);
8138: test_ret++;
8139: printf("\n");
8140: }
8141: function_tests++;
8142:
8143: return(test_ret);
8144: }
8145:
8146:
8147: static int
8148: test_xmlDictCreate(void) {
8149: int test_ret = 0;
8150:
8151: int mem_base;
8152: xmlDictPtr ret_val;
8153:
8154: mem_base = xmlMemBlocks();
8155:
8156: ret_val = xmlDictCreate();
8157: desret_xmlDictPtr(ret_val);
8158: call_tests++;
8159: xmlResetLastError();
8160: if (mem_base != xmlMemBlocks()) {
8161: printf("Leak of %d blocks found in xmlDictCreate",
8162: xmlMemBlocks() - mem_base);
8163: test_ret++;
8164: printf("\n");
8165: }
8166: function_tests++;
8167:
8168: return(test_ret);
8169: }
8170:
8171:
8172: static int
8173: test_xmlDictCreateSub(void) {
8174: int test_ret = 0;
8175:
8176: int mem_base;
8177: xmlDictPtr ret_val;
8178: xmlDictPtr sub; /* an existing dictionnary */
8179: int n_sub;
8180:
8181: for (n_sub = 0;n_sub < gen_nb_xmlDictPtr;n_sub++) {
8182: mem_base = xmlMemBlocks();
8183: sub = gen_xmlDictPtr(n_sub, 0);
8184:
8185: ret_val = xmlDictCreateSub(sub);
8186: desret_xmlDictPtr(ret_val);
8187: call_tests++;
8188: des_xmlDictPtr(n_sub, sub, 0);
8189: xmlResetLastError();
8190: if (mem_base != xmlMemBlocks()) {
8191: printf("Leak of %d blocks found in xmlDictCreateSub",
8192: xmlMemBlocks() - mem_base);
8193: test_ret++;
8194: printf(" %d", n_sub);
8195: printf("\n");
8196: }
8197: }
8198: function_tests++;
8199:
8200: return(test_ret);
8201: }
8202:
8203:
8204: static int
8205: test_xmlDictExists(void) {
8206: int test_ret = 0;
8207:
8208: int mem_base;
8209: const xmlChar * ret_val;
8210: xmlDictPtr dict; /* the dictionnary */
8211: int n_dict;
8212: xmlChar * name; /* the name of the userdata */
8213: int n_name;
8214: int len; /* the length of the name, if -1 it is recomputed */
8215: int n_len;
8216:
8217: for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) {
8218: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
8219: for (n_len = 0;n_len < gen_nb_int;n_len++) {
8220: mem_base = xmlMemBlocks();
8221: dict = gen_xmlDictPtr(n_dict, 0);
8222: name = gen_const_xmlChar_ptr(n_name, 1);
8223: len = gen_int(n_len, 2);
8224:
8225: ret_val = xmlDictExists(dict, (const xmlChar *)name, len);
8226: desret_const_xmlChar_ptr(ret_val);
8227: call_tests++;
8228: des_xmlDictPtr(n_dict, dict, 0);
8229: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
8230: des_int(n_len, len, 2);
8231: xmlResetLastError();
8232: if (mem_base != xmlMemBlocks()) {
8233: printf("Leak of %d blocks found in xmlDictExists",
8234: xmlMemBlocks() - mem_base);
8235: test_ret++;
8236: printf(" %d", n_dict);
8237: printf(" %d", n_name);
8238: printf(" %d", n_len);
8239: printf("\n");
8240: }
8241: }
8242: }
8243: }
8244: function_tests++;
8245:
8246: return(test_ret);
8247: }
8248:
8249:
8250: static int
1.1.1.3 ! misho 8251: test_xmlDictGetUsage(void) {
! 8252: int test_ret = 0;
! 8253:
! 8254:
! 8255: /* missing type support */
! 8256: return(test_ret);
! 8257: }
! 8258:
! 8259:
! 8260: static int
1.1 misho 8261: test_xmlDictLookup(void) {
8262: int test_ret = 0;
8263:
8264: int mem_base;
8265: const xmlChar * ret_val;
8266: xmlDictPtr dict; /* the dictionnary */
8267: int n_dict;
8268: xmlChar * name; /* the name of the userdata */
8269: int n_name;
8270: int len; /* the length of the name, if -1 it is recomputed */
8271: int n_len;
8272:
8273: for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) {
8274: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
8275: for (n_len = 0;n_len < gen_nb_int;n_len++) {
8276: mem_base = xmlMemBlocks();
8277: dict = gen_xmlDictPtr(n_dict, 0);
8278: name = gen_const_xmlChar_ptr(n_name, 1);
8279: len = gen_int(n_len, 2);
8280:
8281: ret_val = xmlDictLookup(dict, (const xmlChar *)name, len);
8282: desret_const_xmlChar_ptr(ret_val);
8283: call_tests++;
8284: des_xmlDictPtr(n_dict, dict, 0);
8285: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
8286: des_int(n_len, len, 2);
8287: xmlResetLastError();
8288: if (mem_base != xmlMemBlocks()) {
8289: printf("Leak of %d blocks found in xmlDictLookup",
8290: xmlMemBlocks() - mem_base);
8291: test_ret++;
8292: printf(" %d", n_dict);
8293: printf(" %d", n_name);
8294: printf(" %d", n_len);
8295: printf("\n");
8296: }
8297: }
8298: }
8299: }
8300: function_tests++;
8301:
8302: return(test_ret);
8303: }
8304:
8305:
8306: static int
8307: test_xmlDictOwns(void) {
8308: int test_ret = 0;
8309:
8310: int mem_base;
8311: int ret_val;
8312: xmlDictPtr dict; /* the dictionnary */
8313: int n_dict;
8314: xmlChar * str; /* the string */
8315: int n_str;
8316:
8317: for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) {
8318: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
8319: mem_base = xmlMemBlocks();
8320: dict = gen_xmlDictPtr(n_dict, 0);
8321: str = gen_const_xmlChar_ptr(n_str, 1);
8322:
8323: ret_val = xmlDictOwns(dict, (const xmlChar *)str);
8324: desret_int(ret_val);
8325: call_tests++;
8326: des_xmlDictPtr(n_dict, dict, 0);
8327: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
8328: xmlResetLastError();
8329: if (mem_base != xmlMemBlocks()) {
8330: printf("Leak of %d blocks found in xmlDictOwns",
8331: xmlMemBlocks() - mem_base);
8332: test_ret++;
8333: printf(" %d", n_dict);
8334: printf(" %d", n_str);
8335: printf("\n");
8336: }
8337: }
8338: }
8339: function_tests++;
8340:
8341: return(test_ret);
8342: }
8343:
8344:
8345: static int
8346: test_xmlDictQLookup(void) {
8347: int test_ret = 0;
8348:
8349: int mem_base;
8350: const xmlChar * ret_val;
8351: xmlDictPtr dict; /* the dictionnary */
8352: int n_dict;
8353: xmlChar * prefix; /* the prefix */
8354: int n_prefix;
8355: xmlChar * name; /* the name */
8356: int n_name;
8357:
8358: for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) {
8359: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
8360: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
8361: mem_base = xmlMemBlocks();
8362: dict = gen_xmlDictPtr(n_dict, 0);
8363: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
8364: name = gen_const_xmlChar_ptr(n_name, 2);
8365:
8366: ret_val = xmlDictQLookup(dict, (const xmlChar *)prefix, (const xmlChar *)name);
8367: desret_const_xmlChar_ptr(ret_val);
8368: call_tests++;
8369: des_xmlDictPtr(n_dict, dict, 0);
8370: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
8371: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
8372: xmlResetLastError();
8373: if (mem_base != xmlMemBlocks()) {
8374: printf("Leak of %d blocks found in xmlDictQLookup",
8375: xmlMemBlocks() - mem_base);
8376: test_ret++;
8377: printf(" %d", n_dict);
8378: printf(" %d", n_prefix);
8379: printf(" %d", n_name);
8380: printf("\n");
8381: }
8382: }
8383: }
8384: }
8385: function_tests++;
8386:
8387: return(test_ret);
8388: }
8389:
8390:
8391: static int
8392: test_xmlDictReference(void) {
8393: int test_ret = 0;
8394:
8395: int mem_base;
8396: int ret_val;
8397: xmlDictPtr dict; /* the dictionnary */
8398: int n_dict;
8399:
8400: for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) {
8401: mem_base = xmlMemBlocks();
8402: dict = gen_xmlDictPtr(n_dict, 0);
8403:
8404: ret_val = xmlDictReference(dict);
8405: xmlDictFree(dict);
8406: desret_int(ret_val);
8407: call_tests++;
8408: des_xmlDictPtr(n_dict, dict, 0);
8409: xmlResetLastError();
8410: if (mem_base != xmlMemBlocks()) {
8411: printf("Leak of %d blocks found in xmlDictReference",
8412: xmlMemBlocks() - mem_base);
8413: test_ret++;
8414: printf(" %d", n_dict);
8415: printf("\n");
8416: }
8417: }
8418: function_tests++;
8419:
8420: return(test_ret);
8421: }
8422:
8423:
8424: static int
1.1.1.3 ! misho 8425: test_xmlDictSetLimit(void) {
! 8426: int test_ret = 0;
! 8427:
! 8428:
! 8429: /* missing type support */
! 8430: return(test_ret);
! 8431: }
! 8432:
! 8433:
! 8434: static int
1.1 misho 8435: test_xmlDictSize(void) {
8436: int test_ret = 0;
8437:
8438: int mem_base;
8439: int ret_val;
8440: xmlDictPtr dict; /* the dictionnary */
8441: int n_dict;
8442:
8443: for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) {
8444: mem_base = xmlMemBlocks();
8445: dict = gen_xmlDictPtr(n_dict, 0);
8446:
8447: ret_val = xmlDictSize(dict);
8448: desret_int(ret_val);
8449: call_tests++;
8450: des_xmlDictPtr(n_dict, dict, 0);
8451: xmlResetLastError();
8452: if (mem_base != xmlMemBlocks()) {
8453: printf("Leak of %d blocks found in xmlDictSize",
8454: xmlMemBlocks() - mem_base);
8455: test_ret++;
8456: printf(" %d", n_dict);
8457: printf("\n");
8458: }
8459: }
8460: function_tests++;
8461:
8462: return(test_ret);
8463: }
8464:
1.1.1.2 misho 8465:
8466: static int
8467: test_xmlInitializeDict(void) {
8468: int test_ret = 0;
8469:
8470: int mem_base;
8471: int ret_val;
8472:
8473: mem_base = xmlMemBlocks();
8474:
8475: ret_val = xmlInitializeDict();
8476: desret_int(ret_val);
8477: call_tests++;
8478: xmlResetLastError();
8479: if (mem_base != xmlMemBlocks()) {
8480: printf("Leak of %d blocks found in xmlInitializeDict",
8481: xmlMemBlocks() - mem_base);
8482: test_ret++;
8483: printf("\n");
8484: }
8485: function_tests++;
8486:
8487: return(test_ret);
8488: }
8489:
1.1 misho 8490: static int
8491: test_dict(void) {
8492: int test_ret = 0;
8493:
1.1.1.3 ! misho 8494: if (quiet == 0) printf("Testing dict : 10 of 13 functions ...\n");
1.1 misho 8495: test_ret += test_xmlDictCleanup();
8496: test_ret += test_xmlDictCreate();
8497: test_ret += test_xmlDictCreateSub();
8498: test_ret += test_xmlDictExists();
1.1.1.3 ! misho 8499: test_ret += test_xmlDictGetUsage();
1.1 misho 8500: test_ret += test_xmlDictLookup();
8501: test_ret += test_xmlDictOwns();
8502: test_ret += test_xmlDictQLookup();
8503: test_ret += test_xmlDictReference();
1.1.1.3 ! misho 8504: test_ret += test_xmlDictSetLimit();
1.1 misho 8505: test_ret += test_xmlDictSize();
1.1.1.2 misho 8506: test_ret += test_xmlInitializeDict();
1.1 misho 8507:
8508: if (test_ret != 0)
8509: printf("Module dict: %d errors\n", test_ret);
8510: return(test_ret);
8511: }
8512:
8513: static int
8514: test_UTF8Toisolat1(void) {
8515: int test_ret = 0;
8516:
8517: #if defined(LIBXML_OUTPUT_ENABLED)
8518: #ifdef LIBXML_OUTPUT_ENABLED
8519: int mem_base;
8520: int ret_val;
8521: unsigned char * out; /* a pointer to an array of bytes to store the result */
8522: int n_out;
8523: int * outlen; /* the length of @out */
8524: int n_outlen;
8525: unsigned char * in; /* a pointer to an array of UTF-8 chars */
8526: int n_in;
8527: int * inlen; /* the length of @in */
8528: int n_inlen;
8529:
8530: for (n_out = 0;n_out < gen_nb_unsigned_char_ptr;n_out++) {
8531: for (n_outlen = 0;n_outlen < gen_nb_int_ptr;n_outlen++) {
8532: for (n_in = 0;n_in < gen_nb_const_unsigned_char_ptr;n_in++) {
8533: for (n_inlen = 0;n_inlen < gen_nb_int_ptr;n_inlen++) {
8534: mem_base = xmlMemBlocks();
8535: out = gen_unsigned_char_ptr(n_out, 0);
8536: outlen = gen_int_ptr(n_outlen, 1);
8537: in = gen_const_unsigned_char_ptr(n_in, 2);
8538: inlen = gen_int_ptr(n_inlen, 3);
8539:
8540: ret_val = UTF8Toisolat1(out, outlen, (const unsigned char *)in, inlen);
8541: desret_int(ret_val);
8542: call_tests++;
8543: des_unsigned_char_ptr(n_out, out, 0);
8544: des_int_ptr(n_outlen, outlen, 1);
8545: des_const_unsigned_char_ptr(n_in, (const unsigned char *)in, 2);
8546: des_int_ptr(n_inlen, inlen, 3);
8547: xmlResetLastError();
8548: if (mem_base != xmlMemBlocks()) {
8549: printf("Leak of %d blocks found in UTF8Toisolat1",
8550: xmlMemBlocks() - mem_base);
8551: test_ret++;
8552: printf(" %d", n_out);
8553: printf(" %d", n_outlen);
8554: printf(" %d", n_in);
8555: printf(" %d", n_inlen);
8556: printf("\n");
8557: }
8558: }
8559: }
8560: }
8561: }
8562: function_tests++;
8563: #endif
8564: #endif
8565:
8566: return(test_ret);
8567: }
8568:
8569:
8570: static int
8571: test_isolat1ToUTF8(void) {
8572: int test_ret = 0;
8573:
8574: int mem_base;
8575: int ret_val;
8576: unsigned char * out; /* a pointer to an array of bytes to store the result */
8577: int n_out;
8578: int * outlen; /* the length of @out */
8579: int n_outlen;
8580: unsigned char * in; /* a pointer to an array of ISO Latin 1 chars */
8581: int n_in;
8582: int * inlen; /* the length of @in */
8583: int n_inlen;
8584:
8585: for (n_out = 0;n_out < gen_nb_unsigned_char_ptr;n_out++) {
8586: for (n_outlen = 0;n_outlen < gen_nb_int_ptr;n_outlen++) {
8587: for (n_in = 0;n_in < gen_nb_const_unsigned_char_ptr;n_in++) {
8588: for (n_inlen = 0;n_inlen < gen_nb_int_ptr;n_inlen++) {
8589: mem_base = xmlMemBlocks();
8590: out = gen_unsigned_char_ptr(n_out, 0);
8591: outlen = gen_int_ptr(n_outlen, 1);
8592: in = gen_const_unsigned_char_ptr(n_in, 2);
8593: inlen = gen_int_ptr(n_inlen, 3);
8594:
8595: ret_val = isolat1ToUTF8(out, outlen, (const unsigned char *)in, inlen);
8596: desret_int(ret_val);
8597: call_tests++;
8598: des_unsigned_char_ptr(n_out, out, 0);
8599: des_int_ptr(n_outlen, outlen, 1);
8600: des_const_unsigned_char_ptr(n_in, (const unsigned char *)in, 2);
8601: des_int_ptr(n_inlen, inlen, 3);
8602: xmlResetLastError();
8603: if (mem_base != xmlMemBlocks()) {
8604: printf("Leak of %d blocks found in isolat1ToUTF8",
8605: xmlMemBlocks() - mem_base);
8606: test_ret++;
8607: printf(" %d", n_out);
8608: printf(" %d", n_outlen);
8609: printf(" %d", n_in);
8610: printf(" %d", n_inlen);
8611: printf("\n");
8612: }
8613: }
8614: }
8615: }
8616: }
8617: function_tests++;
8618:
8619: return(test_ret);
8620: }
8621:
8622:
8623: static int
8624: test_xmlAddEncodingAlias(void) {
8625: int test_ret = 0;
8626:
8627: int ret_val;
8628: char * name; /* the encoding name as parsed, in UTF-8 format (ASCII actually) */
8629: int n_name;
8630: char * alias; /* the alias name as parsed, in UTF-8 format (ASCII actually) */
8631: int n_alias;
8632:
8633: for (n_name = 0;n_name < gen_nb_const_char_ptr;n_name++) {
8634: for (n_alias = 0;n_alias < gen_nb_const_char_ptr;n_alias++) {
8635: name = gen_const_char_ptr(n_name, 0);
8636: alias = gen_const_char_ptr(n_alias, 1);
8637:
8638: ret_val = xmlAddEncodingAlias((const char *)name, (const char *)alias);
8639: desret_int(ret_val);
8640: call_tests++;
8641: des_const_char_ptr(n_name, (const char *)name, 0);
8642: des_const_char_ptr(n_alias, (const char *)alias, 1);
8643: xmlResetLastError();
8644: }
8645: }
8646: function_tests++;
8647:
8648: return(test_ret);
8649: }
8650:
8651:
8652: #define gen_nb_xmlCharEncodingHandler_ptr 1
8653: static xmlCharEncodingHandler * gen_xmlCharEncodingHandler_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
8654: return(NULL);
8655: }
8656: static void des_xmlCharEncodingHandler_ptr(int no ATTRIBUTE_UNUSED, xmlCharEncodingHandler * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
8657: }
8658:
8659: static int
8660: test_xmlCharEncCloseFunc(void) {
8661: int test_ret = 0;
8662:
8663: int mem_base;
8664: int ret_val;
8665: xmlCharEncodingHandler * handler; /* char enconding transformation data structure */
8666: int n_handler;
8667:
8668: for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandler_ptr;n_handler++) {
8669: mem_base = xmlMemBlocks();
8670: handler = gen_xmlCharEncodingHandler_ptr(n_handler, 0);
8671:
8672: ret_val = xmlCharEncCloseFunc(handler);
8673: desret_int(ret_val);
8674: call_tests++;
8675: des_xmlCharEncodingHandler_ptr(n_handler, handler, 0);
8676: xmlResetLastError();
8677: if (mem_base != xmlMemBlocks()) {
8678: printf("Leak of %d blocks found in xmlCharEncCloseFunc",
8679: xmlMemBlocks() - mem_base);
8680: test_ret++;
8681: printf(" %d", n_handler);
8682: printf("\n");
8683: }
8684: }
8685: function_tests++;
8686:
8687: return(test_ret);
8688: }
8689:
8690:
8691: static int
8692: test_xmlCharEncFirstLine(void) {
8693: int test_ret = 0;
8694:
8695: int mem_base;
8696: int ret_val;
8697: xmlCharEncodingHandler * handler; /* char enconding transformation data structure */
8698: int n_handler;
8699: xmlBufferPtr out; /* an xmlBuffer for the output. */
8700: int n_out;
8701: xmlBufferPtr in; /* an xmlBuffer for the input */
8702: int n_in;
8703:
8704: for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandler_ptr;n_handler++) {
8705: for (n_out = 0;n_out < gen_nb_xmlBufferPtr;n_out++) {
8706: for (n_in = 0;n_in < gen_nb_xmlBufferPtr;n_in++) {
8707: mem_base = xmlMemBlocks();
8708: handler = gen_xmlCharEncodingHandler_ptr(n_handler, 0);
8709: out = gen_xmlBufferPtr(n_out, 1);
8710: in = gen_xmlBufferPtr(n_in, 2);
8711:
8712: ret_val = xmlCharEncFirstLine(handler, out, in);
8713: desret_int(ret_val);
8714: call_tests++;
8715: des_xmlCharEncodingHandler_ptr(n_handler, handler, 0);
8716: des_xmlBufferPtr(n_out, out, 1);
8717: des_xmlBufferPtr(n_in, in, 2);
8718: xmlResetLastError();
8719: if (mem_base != xmlMemBlocks()) {
8720: printf("Leak of %d blocks found in xmlCharEncFirstLine",
8721: xmlMemBlocks() - mem_base);
8722: test_ret++;
8723: printf(" %d", n_handler);
8724: printf(" %d", n_out);
8725: printf(" %d", n_in);
8726: printf("\n");
8727: }
8728: }
8729: }
8730: }
8731: function_tests++;
8732:
8733: return(test_ret);
8734: }
8735:
8736:
8737: static int
8738: test_xmlCharEncInFunc(void) {
8739: int test_ret = 0;
8740:
8741: int mem_base;
8742: int ret_val;
8743: xmlCharEncodingHandler * handler; /* char encoding transformation data structure */
8744: int n_handler;
8745: xmlBufferPtr out; /* an xmlBuffer for the output. */
8746: int n_out;
8747: xmlBufferPtr in; /* an xmlBuffer for the input */
8748: int n_in;
8749:
8750: for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandler_ptr;n_handler++) {
8751: for (n_out = 0;n_out < gen_nb_xmlBufferPtr;n_out++) {
8752: for (n_in = 0;n_in < gen_nb_xmlBufferPtr;n_in++) {
8753: mem_base = xmlMemBlocks();
8754: handler = gen_xmlCharEncodingHandler_ptr(n_handler, 0);
8755: out = gen_xmlBufferPtr(n_out, 1);
8756: in = gen_xmlBufferPtr(n_in, 2);
8757:
8758: ret_val = xmlCharEncInFunc(handler, out, in);
8759: desret_int(ret_val);
8760: call_tests++;
8761: des_xmlCharEncodingHandler_ptr(n_handler, handler, 0);
8762: des_xmlBufferPtr(n_out, out, 1);
8763: des_xmlBufferPtr(n_in, in, 2);
8764: xmlResetLastError();
8765: if (mem_base != xmlMemBlocks()) {
8766: printf("Leak of %d blocks found in xmlCharEncInFunc",
8767: xmlMemBlocks() - mem_base);
8768: test_ret++;
8769: printf(" %d", n_handler);
8770: printf(" %d", n_out);
8771: printf(" %d", n_in);
8772: printf("\n");
8773: }
8774: }
8775: }
8776: }
8777: function_tests++;
8778:
8779: return(test_ret);
8780: }
8781:
8782:
8783: static int
8784: test_xmlCharEncOutFunc(void) {
8785: int test_ret = 0;
8786:
8787: int mem_base;
8788: int ret_val;
8789: xmlCharEncodingHandler * handler; /* char enconding transformation data structure */
8790: int n_handler;
8791: xmlBufferPtr out; /* an xmlBuffer for the output. */
8792: int n_out;
8793: xmlBufferPtr in; /* an xmlBuffer for the input */
8794: int n_in;
8795:
8796: for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandler_ptr;n_handler++) {
8797: for (n_out = 0;n_out < gen_nb_xmlBufferPtr;n_out++) {
8798: for (n_in = 0;n_in < gen_nb_xmlBufferPtr;n_in++) {
8799: mem_base = xmlMemBlocks();
8800: handler = gen_xmlCharEncodingHandler_ptr(n_handler, 0);
8801: out = gen_xmlBufferPtr(n_out, 1);
8802: in = gen_xmlBufferPtr(n_in, 2);
8803:
8804: ret_val = xmlCharEncOutFunc(handler, out, in);
8805: desret_int(ret_val);
8806: call_tests++;
8807: des_xmlCharEncodingHandler_ptr(n_handler, handler, 0);
8808: des_xmlBufferPtr(n_out, out, 1);
8809: des_xmlBufferPtr(n_in, in, 2);
8810: xmlResetLastError();
8811: if (mem_base != xmlMemBlocks()) {
8812: printf("Leak of %d blocks found in xmlCharEncOutFunc",
8813: xmlMemBlocks() - mem_base);
8814: test_ret++;
8815: printf(" %d", n_handler);
8816: printf(" %d", n_out);
8817: printf(" %d", n_in);
8818: printf("\n");
8819: }
8820: }
8821: }
8822: }
8823: function_tests++;
8824:
8825: return(test_ret);
8826: }
8827:
8828:
8829: static int
8830: test_xmlCleanupCharEncodingHandlers(void) {
8831: int test_ret = 0;
8832:
8833:
8834:
8835: xmlCleanupCharEncodingHandlers();
8836: call_tests++;
8837: xmlResetLastError();
8838: function_tests++;
8839:
8840: return(test_ret);
8841: }
8842:
8843:
8844: static int
8845: test_xmlCleanupEncodingAliases(void) {
8846: int test_ret = 0;
8847:
8848: int mem_base;
8849:
8850: mem_base = xmlMemBlocks();
8851:
8852: xmlCleanupEncodingAliases();
8853: call_tests++;
8854: xmlResetLastError();
8855: if (mem_base != xmlMemBlocks()) {
8856: printf("Leak of %d blocks found in xmlCleanupEncodingAliases",
8857: xmlMemBlocks() - mem_base);
8858: test_ret++;
8859: printf("\n");
8860: }
8861: function_tests++;
8862:
8863: return(test_ret);
8864: }
8865:
8866:
8867: static int
8868: test_xmlDelEncodingAlias(void) {
8869: int test_ret = 0;
8870:
8871: int mem_base;
8872: int ret_val;
8873: char * alias; /* the alias name as parsed, in UTF-8 format (ASCII actually) */
8874: int n_alias;
8875:
8876: for (n_alias = 0;n_alias < gen_nb_const_char_ptr;n_alias++) {
8877: mem_base = xmlMemBlocks();
8878: alias = gen_const_char_ptr(n_alias, 0);
8879:
8880: ret_val = xmlDelEncodingAlias((const char *)alias);
8881: desret_int(ret_val);
8882: call_tests++;
8883: des_const_char_ptr(n_alias, (const char *)alias, 0);
8884: xmlResetLastError();
8885: if (mem_base != xmlMemBlocks()) {
8886: printf("Leak of %d blocks found in xmlDelEncodingAlias",
8887: xmlMemBlocks() - mem_base);
8888: test_ret++;
8889: printf(" %d", n_alias);
8890: printf("\n");
8891: }
8892: }
8893: function_tests++;
8894:
8895: return(test_ret);
8896: }
8897:
8898:
8899: static int
8900: test_xmlDetectCharEncoding(void) {
8901: int test_ret = 0;
8902:
8903: int mem_base;
8904: xmlCharEncoding ret_val;
8905: 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). */
8906: int n_in;
8907: int len; /* pointer to the length of the buffer */
8908: int n_len;
8909:
8910: for (n_in = 0;n_in < gen_nb_const_unsigned_char_ptr;n_in++) {
8911: for (n_len = 0;n_len < gen_nb_int;n_len++) {
8912: mem_base = xmlMemBlocks();
8913: in = gen_const_unsigned_char_ptr(n_in, 0);
8914: len = gen_int(n_len, 1);
8915:
8916: ret_val = xmlDetectCharEncoding((const unsigned char *)in, len);
8917: desret_xmlCharEncoding(ret_val);
8918: call_tests++;
8919: des_const_unsigned_char_ptr(n_in, (const unsigned char *)in, 0);
8920: des_int(n_len, len, 1);
8921: xmlResetLastError();
8922: if (mem_base != xmlMemBlocks()) {
8923: printf("Leak of %d blocks found in xmlDetectCharEncoding",
8924: xmlMemBlocks() - mem_base);
8925: test_ret++;
8926: printf(" %d", n_in);
8927: printf(" %d", n_len);
8928: printf("\n");
8929: }
8930: }
8931: }
8932: function_tests++;
8933:
8934: return(test_ret);
8935: }
8936:
8937:
8938: static int
8939: test_xmlFindCharEncodingHandler(void) {
8940: int test_ret = 0;
8941:
8942:
8943: /* missing type support */
8944: return(test_ret);
8945: }
8946:
8947:
8948: static int
8949: test_xmlGetCharEncodingHandler(void) {
8950: int test_ret = 0;
8951:
8952:
8953: /* missing type support */
8954: return(test_ret);
8955: }
8956:
8957:
8958: static int
8959: test_xmlGetCharEncodingName(void) {
8960: int test_ret = 0;
8961:
8962: int mem_base;
8963: const char * ret_val;
8964: xmlCharEncoding enc; /* the encoding */
8965: int n_enc;
8966:
8967: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
8968: mem_base = xmlMemBlocks();
8969: enc = gen_xmlCharEncoding(n_enc, 0);
8970:
8971: ret_val = xmlGetCharEncodingName(enc);
8972: desret_const_char_ptr(ret_val);
8973: call_tests++;
8974: des_xmlCharEncoding(n_enc, enc, 0);
8975: xmlResetLastError();
8976: if (mem_base != xmlMemBlocks()) {
8977: printf("Leak of %d blocks found in xmlGetCharEncodingName",
8978: xmlMemBlocks() - mem_base);
8979: test_ret++;
8980: printf(" %d", n_enc);
8981: printf("\n");
8982: }
8983: }
8984: function_tests++;
8985:
8986: return(test_ret);
8987: }
8988:
8989:
8990: static int
8991: test_xmlGetEncodingAlias(void) {
8992: int test_ret = 0;
8993:
8994: int mem_base;
8995: const char * ret_val;
8996: char * alias; /* the alias name as parsed, in UTF-8 format (ASCII actually) */
8997: int n_alias;
8998:
8999: for (n_alias = 0;n_alias < gen_nb_const_char_ptr;n_alias++) {
9000: mem_base = xmlMemBlocks();
9001: alias = gen_const_char_ptr(n_alias, 0);
9002:
9003: ret_val = xmlGetEncodingAlias((const char *)alias);
9004: desret_const_char_ptr(ret_val);
9005: call_tests++;
9006: des_const_char_ptr(n_alias, (const char *)alias, 0);
9007: xmlResetLastError();
9008: if (mem_base != xmlMemBlocks()) {
9009: printf("Leak of %d blocks found in xmlGetEncodingAlias",
9010: xmlMemBlocks() - mem_base);
9011: test_ret++;
9012: printf(" %d", n_alias);
9013: printf("\n");
9014: }
9015: }
9016: function_tests++;
9017:
9018: return(test_ret);
9019: }
9020:
9021:
9022: static int
9023: test_xmlInitCharEncodingHandlers(void) {
9024: int test_ret = 0;
9025:
9026:
9027:
9028: xmlInitCharEncodingHandlers();
9029: call_tests++;
9030: xmlResetLastError();
9031: function_tests++;
9032:
9033: return(test_ret);
9034: }
9035:
9036:
9037: static int
9038: test_xmlNewCharEncodingHandler(void) {
9039: int test_ret = 0;
9040:
9041:
9042: /* missing type support */
9043: return(test_ret);
9044: }
9045:
9046:
9047: static int
9048: test_xmlParseCharEncoding(void) {
9049: int test_ret = 0;
9050:
9051: int mem_base;
9052: xmlCharEncoding ret_val;
9053: char * name; /* the encoding name as parsed, in UTF-8 format (ASCII actually) */
9054: int n_name;
9055:
9056: for (n_name = 0;n_name < gen_nb_const_char_ptr;n_name++) {
9057: mem_base = xmlMemBlocks();
9058: name = gen_const_char_ptr(n_name, 0);
9059:
9060: ret_val = xmlParseCharEncoding((const char *)name);
9061: desret_xmlCharEncoding(ret_val);
9062: call_tests++;
9063: des_const_char_ptr(n_name, (const char *)name, 0);
9064: xmlResetLastError();
9065: if (mem_base != xmlMemBlocks()) {
9066: printf("Leak of %d blocks found in xmlParseCharEncoding",
9067: xmlMemBlocks() - mem_base);
9068: test_ret++;
9069: printf(" %d", n_name);
9070: printf("\n");
9071: }
9072: }
9073: function_tests++;
9074:
9075: return(test_ret);
9076: }
9077:
9078:
9079: #define gen_nb_xmlCharEncodingHandlerPtr 1
9080: static xmlCharEncodingHandlerPtr gen_xmlCharEncodingHandlerPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
9081: return(NULL);
9082: }
9083: static void des_xmlCharEncodingHandlerPtr(int no ATTRIBUTE_UNUSED, xmlCharEncodingHandlerPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
9084: }
9085:
9086: static int
9087: test_xmlRegisterCharEncodingHandler(void) {
9088: int test_ret = 0;
9089:
9090: int mem_base;
9091: xmlCharEncodingHandlerPtr handler; /* the xmlCharEncodingHandlerPtr handler block */
9092: int n_handler;
9093:
9094: for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandlerPtr;n_handler++) {
9095: mem_base = xmlMemBlocks();
9096: handler = gen_xmlCharEncodingHandlerPtr(n_handler, 0);
9097:
9098: xmlRegisterCharEncodingHandler(handler);
9099: call_tests++;
9100: des_xmlCharEncodingHandlerPtr(n_handler, handler, 0);
9101: xmlResetLastError();
9102: if (mem_base != xmlMemBlocks()) {
9103: printf("Leak of %d blocks found in xmlRegisterCharEncodingHandler",
9104: xmlMemBlocks() - mem_base);
9105: test_ret++;
9106: printf(" %d", n_handler);
9107: printf("\n");
9108: }
9109: }
9110: function_tests++;
9111:
9112: return(test_ret);
9113: }
9114:
9115: static int
9116: test_encoding(void) {
9117: int test_ret = 0;
9118:
9119: if (quiet == 0) printf("Testing encoding : 16 of 19 functions ...\n");
9120: test_ret += test_UTF8Toisolat1();
9121: test_ret += test_isolat1ToUTF8();
9122: test_ret += test_xmlAddEncodingAlias();
9123: test_ret += test_xmlCharEncCloseFunc();
9124: test_ret += test_xmlCharEncFirstLine();
9125: test_ret += test_xmlCharEncInFunc();
9126: test_ret += test_xmlCharEncOutFunc();
9127: test_ret += test_xmlCleanupCharEncodingHandlers();
9128: test_ret += test_xmlCleanupEncodingAliases();
9129: test_ret += test_xmlDelEncodingAlias();
9130: test_ret += test_xmlDetectCharEncoding();
9131: test_ret += test_xmlFindCharEncodingHandler();
9132: test_ret += test_xmlGetCharEncodingHandler();
9133: test_ret += test_xmlGetCharEncodingName();
9134: test_ret += test_xmlGetEncodingAlias();
9135: test_ret += test_xmlInitCharEncodingHandlers();
9136: test_ret += test_xmlNewCharEncodingHandler();
9137: test_ret += test_xmlParseCharEncoding();
9138: test_ret += test_xmlRegisterCharEncodingHandler();
9139:
9140: if (test_ret != 0)
9141: printf("Module encoding: %d errors\n", test_ret);
9142: return(test_ret);
9143: }
9144:
9145: static int
9146: test_xmlAddDocEntity(void) {
9147: int test_ret = 0;
9148:
9149: int mem_base;
9150: xmlEntityPtr ret_val;
9151: xmlDocPtr doc; /* the document */
9152: int n_doc;
9153: xmlChar * name; /* the entity name */
9154: int n_name;
9155: int type; /* the entity type XML_xxx_yyy_ENTITY */
9156: int n_type;
9157: xmlChar * ExternalID; /* the entity external ID if available */
9158: int n_ExternalID;
9159: xmlChar * SystemID; /* the entity system ID if available */
9160: int n_SystemID;
9161: xmlChar * content; /* the entity content */
9162: int n_content;
9163:
9164: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
9165: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9166: for (n_type = 0;n_type < gen_nb_int;n_type++) {
9167: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
9168: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
9169: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
9170: mem_base = xmlMemBlocks();
9171: doc = gen_xmlDocPtr(n_doc, 0);
9172: name = gen_const_xmlChar_ptr(n_name, 1);
9173: type = gen_int(n_type, 2);
9174: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 3);
9175: SystemID = gen_const_xmlChar_ptr(n_SystemID, 4);
9176: content = gen_const_xmlChar_ptr(n_content, 5);
9177:
9178: ret_val = xmlAddDocEntity(doc, (const xmlChar *)name, type, (const xmlChar *)ExternalID, (const xmlChar *)SystemID, (const xmlChar *)content);
9179: desret_xmlEntityPtr(ret_val);
9180: call_tests++;
9181: des_xmlDocPtr(n_doc, doc, 0);
9182: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9183: des_int(n_type, type, 2);
9184: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 3);
9185: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 4);
9186: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 5);
9187: xmlResetLastError();
9188: if (mem_base != xmlMemBlocks()) {
9189: printf("Leak of %d blocks found in xmlAddDocEntity",
9190: xmlMemBlocks() - mem_base);
9191: test_ret++;
9192: printf(" %d", n_doc);
9193: printf(" %d", n_name);
9194: printf(" %d", n_type);
9195: printf(" %d", n_ExternalID);
9196: printf(" %d", n_SystemID);
9197: printf(" %d", n_content);
9198: printf("\n");
9199: }
9200: }
9201: }
9202: }
9203: }
9204: }
9205: }
9206: function_tests++;
9207:
9208: return(test_ret);
9209: }
9210:
9211:
9212: static int
9213: test_xmlAddDtdEntity(void) {
9214: int test_ret = 0;
9215:
9216: int mem_base;
9217: xmlEntityPtr ret_val;
9218: xmlDocPtr doc; /* the document */
9219: int n_doc;
9220: xmlChar * name; /* the entity name */
9221: int n_name;
9222: int type; /* the entity type XML_xxx_yyy_ENTITY */
9223: int n_type;
9224: xmlChar * ExternalID; /* the entity external ID if available */
9225: int n_ExternalID;
9226: xmlChar * SystemID; /* the entity system ID if available */
9227: int n_SystemID;
9228: xmlChar * content; /* the entity content */
9229: int n_content;
9230:
9231: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
9232: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9233: for (n_type = 0;n_type < gen_nb_int;n_type++) {
9234: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
9235: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
9236: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
9237: mem_base = xmlMemBlocks();
9238: doc = gen_xmlDocPtr(n_doc, 0);
9239: name = gen_const_xmlChar_ptr(n_name, 1);
9240: type = gen_int(n_type, 2);
9241: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 3);
9242: SystemID = gen_const_xmlChar_ptr(n_SystemID, 4);
9243: content = gen_const_xmlChar_ptr(n_content, 5);
9244:
9245: ret_val = xmlAddDtdEntity(doc, (const xmlChar *)name, type, (const xmlChar *)ExternalID, (const xmlChar *)SystemID, (const xmlChar *)content);
9246: desret_xmlEntityPtr(ret_val);
9247: call_tests++;
9248: des_xmlDocPtr(n_doc, doc, 0);
9249: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9250: des_int(n_type, type, 2);
9251: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 3);
9252: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 4);
9253: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 5);
9254: xmlResetLastError();
9255: if (mem_base != xmlMemBlocks()) {
9256: printf("Leak of %d blocks found in xmlAddDtdEntity",
9257: xmlMemBlocks() - mem_base);
9258: test_ret++;
9259: printf(" %d", n_doc);
9260: printf(" %d", n_name);
9261: printf(" %d", n_type);
9262: printf(" %d", n_ExternalID);
9263: printf(" %d", n_SystemID);
9264: printf(" %d", n_content);
9265: printf("\n");
9266: }
9267: }
9268: }
9269: }
9270: }
9271: }
9272: }
9273: function_tests++;
9274:
9275: return(test_ret);
9276: }
9277:
9278:
9279: static int
9280: test_xmlCleanupPredefinedEntities(void) {
9281: int test_ret = 0;
9282:
9283: #if defined(LIBXML_LEGACY_ENABLED)
9284: #ifdef LIBXML_LEGACY_ENABLED
9285: int mem_base;
9286:
9287: mem_base = xmlMemBlocks();
9288:
9289: xmlCleanupPredefinedEntities();
9290: call_tests++;
9291: xmlResetLastError();
9292: if (mem_base != xmlMemBlocks()) {
9293: printf("Leak of %d blocks found in xmlCleanupPredefinedEntities",
9294: xmlMemBlocks() - mem_base);
9295: test_ret++;
9296: printf("\n");
9297: }
9298: function_tests++;
9299: #endif
9300: #endif
9301:
9302: return(test_ret);
9303: }
9304:
9305:
9306: #define gen_nb_xmlEntitiesTablePtr 1
9307: static xmlEntitiesTablePtr gen_xmlEntitiesTablePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
9308: return(NULL);
9309: }
9310: static void des_xmlEntitiesTablePtr(int no ATTRIBUTE_UNUSED, xmlEntitiesTablePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
9311: }
9312:
9313: static int
9314: test_xmlCopyEntitiesTable(void) {
9315: int test_ret = 0;
9316:
9317:
9318: /* missing type support */
9319: return(test_ret);
9320: }
9321:
9322:
9323: static int
9324: test_xmlCreateEntitiesTable(void) {
9325: int test_ret = 0;
9326:
9327:
9328: /* missing type support */
9329: return(test_ret);
9330: }
9331:
9332:
9333: static int
9334: test_xmlDumpEntitiesTable(void) {
9335: int test_ret = 0;
9336:
9337: #if defined(LIBXML_OUTPUT_ENABLED)
9338: int mem_base;
9339: xmlBufferPtr buf; /* An XML buffer. */
9340: int n_buf;
9341: xmlEntitiesTablePtr table; /* An entity table */
9342: int n_table;
9343:
9344: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
9345: for (n_table = 0;n_table < gen_nb_xmlEntitiesTablePtr;n_table++) {
9346: mem_base = xmlMemBlocks();
9347: buf = gen_xmlBufferPtr(n_buf, 0);
9348: table = gen_xmlEntitiesTablePtr(n_table, 1);
9349:
9350: xmlDumpEntitiesTable(buf, table);
9351: call_tests++;
9352: des_xmlBufferPtr(n_buf, buf, 0);
9353: des_xmlEntitiesTablePtr(n_table, table, 1);
9354: xmlResetLastError();
9355: if (mem_base != xmlMemBlocks()) {
9356: printf("Leak of %d blocks found in xmlDumpEntitiesTable",
9357: xmlMemBlocks() - mem_base);
9358: test_ret++;
9359: printf(" %d", n_buf);
9360: printf(" %d", n_table);
9361: printf("\n");
9362: }
9363: }
9364: }
9365: function_tests++;
9366: #endif
9367:
9368: return(test_ret);
9369: }
9370:
9371:
9372: #define gen_nb_xmlEntityPtr 1
9373: static xmlEntityPtr gen_xmlEntityPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
9374: return(NULL);
9375: }
9376: static void des_xmlEntityPtr(int no ATTRIBUTE_UNUSED, xmlEntityPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
9377: }
9378:
9379: static int
9380: test_xmlDumpEntityDecl(void) {
9381: int test_ret = 0;
9382:
9383: #if defined(LIBXML_OUTPUT_ENABLED)
9384: int mem_base;
9385: xmlBufferPtr buf; /* An XML buffer. */
9386: int n_buf;
9387: xmlEntityPtr ent; /* An entity table */
9388: int n_ent;
9389:
9390: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
9391: for (n_ent = 0;n_ent < gen_nb_xmlEntityPtr;n_ent++) {
9392: mem_base = xmlMemBlocks();
9393: buf = gen_xmlBufferPtr(n_buf, 0);
9394: ent = gen_xmlEntityPtr(n_ent, 1);
9395:
9396: xmlDumpEntityDecl(buf, ent);
9397: call_tests++;
9398: des_xmlBufferPtr(n_buf, buf, 0);
9399: des_xmlEntityPtr(n_ent, ent, 1);
9400: xmlResetLastError();
9401: if (mem_base != xmlMemBlocks()) {
9402: printf("Leak of %d blocks found in xmlDumpEntityDecl",
9403: xmlMemBlocks() - mem_base);
9404: test_ret++;
9405: printf(" %d", n_buf);
9406: printf(" %d", n_ent);
9407: printf("\n");
9408: }
9409: }
9410: }
9411: function_tests++;
9412: #endif
9413:
9414: return(test_ret);
9415: }
9416:
9417:
9418: static int
9419: test_xmlEncodeEntitiesReentrant(void) {
9420: int test_ret = 0;
9421:
9422: int mem_base;
9423: xmlChar * ret_val;
9424: xmlDocPtr doc; /* the document containing the string */
9425: int n_doc;
9426: xmlChar * input; /* A string to convert to XML. */
9427: int n_input;
9428:
9429: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
9430: for (n_input = 0;n_input < gen_nb_const_xmlChar_ptr;n_input++) {
9431: mem_base = xmlMemBlocks();
9432: doc = gen_xmlDocPtr(n_doc, 0);
9433: input = gen_const_xmlChar_ptr(n_input, 1);
9434:
9435: ret_val = xmlEncodeEntitiesReentrant(doc, (const xmlChar *)input);
9436: desret_xmlChar_ptr(ret_val);
9437: call_tests++;
9438: des_xmlDocPtr(n_doc, doc, 0);
9439: des_const_xmlChar_ptr(n_input, (const xmlChar *)input, 1);
9440: xmlResetLastError();
9441: if (mem_base != xmlMemBlocks()) {
9442: printf("Leak of %d blocks found in xmlEncodeEntitiesReentrant",
9443: xmlMemBlocks() - mem_base);
9444: test_ret++;
9445: printf(" %d", n_doc);
9446: printf(" %d", n_input);
9447: printf("\n");
9448: }
9449: }
9450: }
9451: function_tests++;
9452:
9453: return(test_ret);
9454: }
9455:
9456:
9457: static int
9458: test_xmlEncodeSpecialChars(void) {
9459: int test_ret = 0;
9460:
9461: int mem_base;
9462: xmlChar * ret_val;
9463: xmlDocPtr doc; /* the document containing the string */
9464: int n_doc;
9465: xmlChar * input; /* A string to convert to XML. */
9466: int n_input;
9467:
9468: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
9469: for (n_input = 0;n_input < gen_nb_const_xmlChar_ptr;n_input++) {
9470: mem_base = xmlMemBlocks();
9471: doc = gen_xmlDocPtr(n_doc, 0);
9472: input = gen_const_xmlChar_ptr(n_input, 1);
9473:
9474: ret_val = xmlEncodeSpecialChars(doc, (const xmlChar *)input);
9475: desret_xmlChar_ptr(ret_val);
9476: call_tests++;
9477: des_xmlDocPtr(n_doc, doc, 0);
9478: des_const_xmlChar_ptr(n_input, (const xmlChar *)input, 1);
9479: xmlResetLastError();
9480: if (mem_base != xmlMemBlocks()) {
9481: printf("Leak of %d blocks found in xmlEncodeSpecialChars",
9482: xmlMemBlocks() - mem_base);
9483: test_ret++;
9484: printf(" %d", n_doc);
9485: printf(" %d", n_input);
9486: printf("\n");
9487: }
9488: }
9489: }
9490: function_tests++;
9491:
9492: return(test_ret);
9493: }
9494:
9495:
9496: static int
9497: test_xmlGetDocEntity(void) {
9498: int test_ret = 0;
9499:
9500: int mem_base;
9501: xmlEntityPtr ret_val;
9502: xmlDocPtr doc; /* the document referencing the entity */
9503: int n_doc;
9504: xmlChar * name; /* the entity name */
9505: int n_name;
9506:
9507: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
9508: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9509: mem_base = xmlMemBlocks();
9510: doc = gen_xmlDocPtr(n_doc, 0);
9511: name = gen_const_xmlChar_ptr(n_name, 1);
9512:
9513: ret_val = xmlGetDocEntity(doc, (const xmlChar *)name);
9514: desret_xmlEntityPtr(ret_val);
9515: call_tests++;
9516: des_xmlDocPtr(n_doc, doc, 0);
9517: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9518: xmlResetLastError();
9519: if (mem_base != xmlMemBlocks()) {
9520: printf("Leak of %d blocks found in xmlGetDocEntity",
9521: xmlMemBlocks() - mem_base);
9522: test_ret++;
9523: printf(" %d", n_doc);
9524: printf(" %d", n_name);
9525: printf("\n");
9526: }
9527: }
9528: }
9529: function_tests++;
9530:
9531: return(test_ret);
9532: }
9533:
9534:
9535: static int
9536: test_xmlGetDtdEntity(void) {
9537: int test_ret = 0;
9538:
9539: int mem_base;
9540: xmlEntityPtr ret_val;
9541: xmlDocPtr doc; /* the document referencing the entity */
9542: int n_doc;
9543: xmlChar * name; /* the entity name */
9544: int n_name;
9545:
9546: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
9547: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9548: mem_base = xmlMemBlocks();
9549: doc = gen_xmlDocPtr(n_doc, 0);
9550: name = gen_const_xmlChar_ptr(n_name, 1);
9551:
9552: ret_val = xmlGetDtdEntity(doc, (const xmlChar *)name);
9553: desret_xmlEntityPtr(ret_val);
9554: call_tests++;
9555: des_xmlDocPtr(n_doc, doc, 0);
9556: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9557: xmlResetLastError();
9558: if (mem_base != xmlMemBlocks()) {
9559: printf("Leak of %d blocks found in xmlGetDtdEntity",
9560: xmlMemBlocks() - mem_base);
9561: test_ret++;
9562: printf(" %d", n_doc);
9563: printf(" %d", n_name);
9564: printf("\n");
9565: }
9566: }
9567: }
9568: function_tests++;
9569:
9570: return(test_ret);
9571: }
9572:
9573:
9574: static int
9575: test_xmlGetParameterEntity(void) {
9576: int test_ret = 0;
9577:
9578: int mem_base;
9579: xmlEntityPtr ret_val;
9580: xmlDocPtr doc; /* the document referencing the entity */
9581: int n_doc;
9582: xmlChar * name; /* the entity name */
9583: int n_name;
9584:
9585: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
9586: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9587: mem_base = xmlMemBlocks();
9588: doc = gen_xmlDocPtr(n_doc, 0);
9589: name = gen_const_xmlChar_ptr(n_name, 1);
9590:
9591: ret_val = xmlGetParameterEntity(doc, (const xmlChar *)name);
9592: desret_xmlEntityPtr(ret_val);
9593: call_tests++;
9594: des_xmlDocPtr(n_doc, doc, 0);
9595: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9596: xmlResetLastError();
9597: if (mem_base != xmlMemBlocks()) {
9598: printf("Leak of %d blocks found in xmlGetParameterEntity",
9599: xmlMemBlocks() - mem_base);
9600: test_ret++;
9601: printf(" %d", n_doc);
9602: printf(" %d", n_name);
9603: printf("\n");
9604: }
9605: }
9606: }
9607: function_tests++;
9608:
9609: return(test_ret);
9610: }
9611:
9612:
9613: static int
9614: test_xmlGetPredefinedEntity(void) {
9615: int test_ret = 0;
9616:
9617: int mem_base;
9618: xmlEntityPtr ret_val;
9619: xmlChar * name; /* the entity name */
9620: int n_name;
9621:
9622: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9623: mem_base = xmlMemBlocks();
9624: name = gen_const_xmlChar_ptr(n_name, 0);
9625:
9626: ret_val = xmlGetPredefinedEntity((const xmlChar *)name);
9627: desret_xmlEntityPtr(ret_val);
9628: call_tests++;
9629: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
9630: xmlResetLastError();
9631: if (mem_base != xmlMemBlocks()) {
9632: printf("Leak of %d blocks found in xmlGetPredefinedEntity",
9633: xmlMemBlocks() - mem_base);
9634: test_ret++;
9635: printf(" %d", n_name);
9636: printf("\n");
9637: }
9638: }
9639: function_tests++;
9640:
9641: return(test_ret);
9642: }
9643:
9644:
9645: static int
9646: test_xmlInitializePredefinedEntities(void) {
9647: int test_ret = 0;
9648:
9649: #if defined(LIBXML_LEGACY_ENABLED)
9650: #ifdef LIBXML_LEGACY_ENABLED
9651: int mem_base;
9652:
9653: mem_base = xmlMemBlocks();
9654:
9655: xmlInitializePredefinedEntities();
9656: call_tests++;
9657: xmlResetLastError();
9658: if (mem_base != xmlMemBlocks()) {
9659: printf("Leak of %d blocks found in xmlInitializePredefinedEntities",
9660: xmlMemBlocks() - mem_base);
9661: test_ret++;
9662: printf("\n");
9663: }
9664: function_tests++;
9665: #endif
9666: #endif
9667:
9668: return(test_ret);
9669: }
9670:
9671:
9672: static int
9673: test_xmlNewEntity(void) {
9674: int test_ret = 0;
9675:
9676: int mem_base;
9677: xmlEntityPtr ret_val;
9678: xmlDocPtr doc; /* the document */
9679: int n_doc;
9680: xmlChar * name; /* the entity name */
9681: int n_name;
9682: int type; /* the entity type XML_xxx_yyy_ENTITY */
9683: int n_type;
9684: xmlChar * ExternalID; /* the entity external ID if available */
9685: int n_ExternalID;
9686: xmlChar * SystemID; /* the entity system ID if available */
9687: int n_SystemID;
9688: xmlChar * content; /* the entity content */
9689: int n_content;
9690:
9691: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
9692: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9693: for (n_type = 0;n_type < gen_nb_int;n_type++) {
9694: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
9695: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
9696: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
9697: mem_base = xmlMemBlocks();
9698: doc = gen_xmlDocPtr(n_doc, 0);
9699: name = gen_const_xmlChar_ptr(n_name, 1);
9700: type = gen_int(n_type, 2);
9701: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 3);
9702: SystemID = gen_const_xmlChar_ptr(n_SystemID, 4);
9703: content = gen_const_xmlChar_ptr(n_content, 5);
9704:
9705: ret_val = xmlNewEntity(doc, (const xmlChar *)name, type, (const xmlChar *)ExternalID, (const xmlChar *)SystemID, (const xmlChar *)content);
9706: desret_xmlEntityPtr(ret_val);
9707: call_tests++;
9708: des_xmlDocPtr(n_doc, doc, 0);
9709: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9710: des_int(n_type, type, 2);
9711: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 3);
9712: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 4);
9713: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 5);
9714: xmlResetLastError();
9715: if (mem_base != xmlMemBlocks()) {
9716: printf("Leak of %d blocks found in xmlNewEntity",
9717: xmlMemBlocks() - mem_base);
9718: test_ret++;
9719: printf(" %d", n_doc);
9720: printf(" %d", n_name);
9721: printf(" %d", n_type);
9722: printf(" %d", n_ExternalID);
9723: printf(" %d", n_SystemID);
9724: printf(" %d", n_content);
9725: printf("\n");
9726: }
9727: }
9728: }
9729: }
9730: }
9731: }
9732: }
9733: function_tests++;
9734:
9735: return(test_ret);
9736: }
9737:
9738: static int
9739: test_entities(void) {
9740: int test_ret = 0;
9741:
9742: if (quiet == 0) printf("Testing entities : 13 of 17 functions ...\n");
9743: test_ret += test_xmlAddDocEntity();
9744: test_ret += test_xmlAddDtdEntity();
9745: test_ret += test_xmlCleanupPredefinedEntities();
9746: test_ret += test_xmlCopyEntitiesTable();
9747: test_ret += test_xmlCreateEntitiesTable();
9748: test_ret += test_xmlDumpEntitiesTable();
9749: test_ret += test_xmlDumpEntityDecl();
9750: test_ret += test_xmlEncodeEntitiesReentrant();
9751: test_ret += test_xmlEncodeSpecialChars();
9752: test_ret += test_xmlGetDocEntity();
9753: test_ret += test_xmlGetDtdEntity();
9754: test_ret += test_xmlGetParameterEntity();
9755: test_ret += test_xmlGetPredefinedEntity();
9756: test_ret += test_xmlInitializePredefinedEntities();
9757: test_ret += test_xmlNewEntity();
9758:
9759: if (test_ret != 0)
9760: printf("Module entities: %d errors\n", test_ret);
9761: return(test_ret);
9762: }
9763:
9764: static int
9765: test_xmlHashAddEntry(void) {
9766: int test_ret = 0;
9767:
9768: int mem_base;
9769: int ret_val;
9770: xmlHashTablePtr table; /* the hash table */
9771: int n_table;
9772: xmlChar * name; /* the name of the userdata */
9773: int n_name;
9774: void * userdata; /* a pointer to the userdata */
9775: int n_userdata;
9776:
9777: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
9778: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9779: for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) {
9780: mem_base = xmlMemBlocks();
9781: table = gen_xmlHashTablePtr(n_table, 0);
9782: name = gen_const_xmlChar_ptr(n_name, 1);
9783: userdata = gen_userdata(n_userdata, 2);
9784:
9785: ret_val = xmlHashAddEntry(table, (const xmlChar *)name, userdata);
9786: desret_int(ret_val);
9787: call_tests++;
9788: des_xmlHashTablePtr(n_table, table, 0);
9789: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9790: des_userdata(n_userdata, userdata, 2);
9791: xmlResetLastError();
9792: if (mem_base != xmlMemBlocks()) {
9793: printf("Leak of %d blocks found in xmlHashAddEntry",
9794: xmlMemBlocks() - mem_base);
9795: test_ret++;
9796: printf(" %d", n_table);
9797: printf(" %d", n_name);
9798: printf(" %d", n_userdata);
9799: printf("\n");
9800: }
9801: }
9802: }
9803: }
9804: function_tests++;
9805:
9806: return(test_ret);
9807: }
9808:
9809:
9810: static int
9811: test_xmlHashAddEntry2(void) {
9812: int test_ret = 0;
9813:
9814: int mem_base;
9815: int ret_val;
9816: xmlHashTablePtr table; /* the hash table */
9817: int n_table;
9818: xmlChar * name; /* the name of the userdata */
9819: int n_name;
9820: xmlChar * name2; /* a second name of the userdata */
9821: int n_name2;
9822: void * userdata; /* a pointer to the userdata */
9823: int n_userdata;
9824:
9825: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
9826: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9827: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
9828: for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) {
9829: mem_base = xmlMemBlocks();
9830: table = gen_xmlHashTablePtr(n_table, 0);
9831: name = gen_const_xmlChar_ptr(n_name, 1);
9832: name2 = gen_const_xmlChar_ptr(n_name2, 2);
9833: userdata = gen_userdata(n_userdata, 3);
9834:
9835: ret_val = xmlHashAddEntry2(table, (const xmlChar *)name, (const xmlChar *)name2, userdata);
9836: desret_int(ret_val);
9837: call_tests++;
9838: des_xmlHashTablePtr(n_table, table, 0);
9839: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9840: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
9841: des_userdata(n_userdata, userdata, 3);
9842: xmlResetLastError();
9843: if (mem_base != xmlMemBlocks()) {
9844: printf("Leak of %d blocks found in xmlHashAddEntry2",
9845: xmlMemBlocks() - mem_base);
9846: test_ret++;
9847: printf(" %d", n_table);
9848: printf(" %d", n_name);
9849: printf(" %d", n_name2);
9850: printf(" %d", n_userdata);
9851: printf("\n");
9852: }
9853: }
9854: }
9855: }
9856: }
9857: function_tests++;
9858:
9859: return(test_ret);
9860: }
9861:
9862:
9863: static int
9864: test_xmlHashAddEntry3(void) {
9865: int test_ret = 0;
9866:
9867: int mem_base;
9868: int ret_val;
9869: xmlHashTablePtr table; /* the hash table */
9870: int n_table;
9871: xmlChar * name; /* the name of the userdata */
9872: int n_name;
9873: xmlChar * name2; /* a second name of the userdata */
9874: int n_name2;
9875: xmlChar * name3; /* a third name of the userdata */
9876: int n_name3;
9877: void * userdata; /* a pointer to the userdata */
9878: int n_userdata;
9879:
9880: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
9881: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9882: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
9883: for (n_name3 = 0;n_name3 < gen_nb_const_xmlChar_ptr;n_name3++) {
9884: for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) {
9885: mem_base = xmlMemBlocks();
9886: table = gen_xmlHashTablePtr(n_table, 0);
9887: name = gen_const_xmlChar_ptr(n_name, 1);
9888: name2 = gen_const_xmlChar_ptr(n_name2, 2);
9889: name3 = gen_const_xmlChar_ptr(n_name3, 3);
9890: userdata = gen_userdata(n_userdata, 4);
9891:
9892: ret_val = xmlHashAddEntry3(table, (const xmlChar *)name, (const xmlChar *)name2, (const xmlChar *)name3, userdata);
9893: desret_int(ret_val);
9894: call_tests++;
9895: des_xmlHashTablePtr(n_table, table, 0);
9896: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9897: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
9898: des_const_xmlChar_ptr(n_name3, (const xmlChar *)name3, 3);
9899: des_userdata(n_userdata, userdata, 4);
9900: xmlResetLastError();
9901: if (mem_base != xmlMemBlocks()) {
9902: printf("Leak of %d blocks found in xmlHashAddEntry3",
9903: xmlMemBlocks() - mem_base);
9904: test_ret++;
9905: printf(" %d", n_table);
9906: printf(" %d", n_name);
9907: printf(" %d", n_name2);
9908: printf(" %d", n_name3);
9909: printf(" %d", n_userdata);
9910: printf("\n");
9911: }
9912: }
9913: }
9914: }
9915: }
9916: }
9917: function_tests++;
9918:
9919: return(test_ret);
9920: }
9921:
9922:
9923: static int
9924: test_xmlHashCopy(void) {
9925: int test_ret = 0;
9926:
9927:
9928: /* missing type support */
9929: return(test_ret);
9930: }
9931:
9932:
9933: static int
9934: test_xmlHashCreate(void) {
9935: int test_ret = 0;
9936:
9937:
9938: /* missing type support */
9939: return(test_ret);
9940: }
9941:
9942:
9943: static int
9944: test_xmlHashCreateDict(void) {
9945: int test_ret = 0;
9946:
9947:
9948: /* missing type support */
9949: return(test_ret);
9950: }
9951:
9952:
9953: static int
9954: test_xmlHashLookup(void) {
9955: int test_ret = 0;
9956:
9957: int mem_base;
9958: void * ret_val;
9959: xmlHashTablePtr table; /* the hash table */
9960: int n_table;
9961: xmlChar * name; /* the name of the userdata */
9962: int n_name;
9963:
9964: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
9965: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9966: mem_base = xmlMemBlocks();
9967: table = gen_xmlHashTablePtr(n_table, 0);
9968: name = gen_const_xmlChar_ptr(n_name, 1);
9969:
9970: ret_val = xmlHashLookup(table, (const xmlChar *)name);
9971: desret_void_ptr(ret_val);
9972: call_tests++;
9973: des_xmlHashTablePtr(n_table, table, 0);
9974: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9975: xmlResetLastError();
9976: if (mem_base != xmlMemBlocks()) {
9977: printf("Leak of %d blocks found in xmlHashLookup",
9978: xmlMemBlocks() - mem_base);
9979: test_ret++;
9980: printf(" %d", n_table);
9981: printf(" %d", n_name);
9982: printf("\n");
9983: }
9984: }
9985: }
9986: function_tests++;
9987:
9988: return(test_ret);
9989: }
9990:
9991:
9992: static int
9993: test_xmlHashLookup2(void) {
9994: int test_ret = 0;
9995:
9996: int mem_base;
9997: void * ret_val;
9998: xmlHashTablePtr table; /* the hash table */
9999: int n_table;
10000: xmlChar * name; /* the name of the userdata */
10001: int n_name;
10002: xmlChar * name2; /* a second name of the userdata */
10003: int n_name2;
10004:
10005: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10006: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10007: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
10008: mem_base = xmlMemBlocks();
10009: table = gen_xmlHashTablePtr(n_table, 0);
10010: name = gen_const_xmlChar_ptr(n_name, 1);
10011: name2 = gen_const_xmlChar_ptr(n_name2, 2);
10012:
10013: ret_val = xmlHashLookup2(table, (const xmlChar *)name, (const xmlChar *)name2);
10014: desret_void_ptr(ret_val);
10015: call_tests++;
10016: des_xmlHashTablePtr(n_table, table, 0);
10017: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
10018: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
10019: xmlResetLastError();
10020: if (mem_base != xmlMemBlocks()) {
10021: printf("Leak of %d blocks found in xmlHashLookup2",
10022: xmlMemBlocks() - mem_base);
10023: test_ret++;
10024: printf(" %d", n_table);
10025: printf(" %d", n_name);
10026: printf(" %d", n_name2);
10027: printf("\n");
10028: }
10029: }
10030: }
10031: }
10032: function_tests++;
10033:
10034: return(test_ret);
10035: }
10036:
10037:
10038: static int
10039: test_xmlHashLookup3(void) {
10040: int test_ret = 0;
10041:
10042: int mem_base;
10043: void * ret_val;
10044: xmlHashTablePtr table; /* the hash table */
10045: int n_table;
10046: xmlChar * name; /* the name of the userdata */
10047: int n_name;
10048: xmlChar * name2; /* a second name of the userdata */
10049: int n_name2;
10050: xmlChar * name3; /* a third name of the userdata */
10051: int n_name3;
10052:
10053: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10054: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10055: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
10056: for (n_name3 = 0;n_name3 < gen_nb_const_xmlChar_ptr;n_name3++) {
10057: mem_base = xmlMemBlocks();
10058: table = gen_xmlHashTablePtr(n_table, 0);
10059: name = gen_const_xmlChar_ptr(n_name, 1);
10060: name2 = gen_const_xmlChar_ptr(n_name2, 2);
10061: name3 = gen_const_xmlChar_ptr(n_name3, 3);
10062:
10063: ret_val = xmlHashLookup3(table, (const xmlChar *)name, (const xmlChar *)name2, (const xmlChar *)name3);
10064: desret_void_ptr(ret_val);
10065: call_tests++;
10066: des_xmlHashTablePtr(n_table, table, 0);
10067: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
10068: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
10069: des_const_xmlChar_ptr(n_name3, (const xmlChar *)name3, 3);
10070: xmlResetLastError();
10071: if (mem_base != xmlMemBlocks()) {
10072: printf("Leak of %d blocks found in xmlHashLookup3",
10073: xmlMemBlocks() - mem_base);
10074: test_ret++;
10075: printf(" %d", n_table);
10076: printf(" %d", n_name);
10077: printf(" %d", n_name2);
10078: printf(" %d", n_name3);
10079: printf("\n");
10080: }
10081: }
10082: }
10083: }
10084: }
10085: function_tests++;
10086:
10087: return(test_ret);
10088: }
10089:
10090:
10091: static int
10092: test_xmlHashQLookup(void) {
10093: int test_ret = 0;
10094:
10095: int mem_base;
10096: void * ret_val;
10097: xmlHashTablePtr table; /* the hash table */
10098: int n_table;
10099: xmlChar * prefix; /* the prefix of the userdata */
10100: int n_prefix;
10101: xmlChar * name; /* the name of the userdata */
10102: int n_name;
10103:
10104: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10105: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
10106: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10107: mem_base = xmlMemBlocks();
10108: table = gen_xmlHashTablePtr(n_table, 0);
10109: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
10110: name = gen_const_xmlChar_ptr(n_name, 2);
10111:
10112: ret_val = xmlHashQLookup(table, (const xmlChar *)prefix, (const xmlChar *)name);
10113: desret_void_ptr(ret_val);
10114: call_tests++;
10115: des_xmlHashTablePtr(n_table, table, 0);
10116: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
10117: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
10118: xmlResetLastError();
10119: if (mem_base != xmlMemBlocks()) {
10120: printf("Leak of %d blocks found in xmlHashQLookup",
10121: xmlMemBlocks() - mem_base);
10122: test_ret++;
10123: printf(" %d", n_table);
10124: printf(" %d", n_prefix);
10125: printf(" %d", n_name);
10126: printf("\n");
10127: }
10128: }
10129: }
10130: }
10131: function_tests++;
10132:
10133: return(test_ret);
10134: }
10135:
10136:
10137: static int
10138: test_xmlHashQLookup2(void) {
10139: int test_ret = 0;
10140:
10141: int mem_base;
10142: void * ret_val;
10143: xmlHashTablePtr table; /* the hash table */
10144: int n_table;
10145: xmlChar * prefix; /* the prefix of the userdata */
10146: int n_prefix;
10147: xmlChar * name; /* the name of the userdata */
10148: int n_name;
10149: xmlChar * prefix2; /* the second prefix of the userdata */
10150: int n_prefix2;
10151: xmlChar * name2; /* a second name of the userdata */
10152: int n_name2;
10153:
10154: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10155: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
10156: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10157: for (n_prefix2 = 0;n_prefix2 < gen_nb_const_xmlChar_ptr;n_prefix2++) {
10158: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
10159: mem_base = xmlMemBlocks();
10160: table = gen_xmlHashTablePtr(n_table, 0);
10161: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
10162: name = gen_const_xmlChar_ptr(n_name, 2);
10163: prefix2 = gen_const_xmlChar_ptr(n_prefix2, 3);
10164: name2 = gen_const_xmlChar_ptr(n_name2, 4);
10165:
10166: ret_val = xmlHashQLookup2(table, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)prefix2, (const xmlChar *)name2);
10167: desret_void_ptr(ret_val);
10168: call_tests++;
10169: des_xmlHashTablePtr(n_table, table, 0);
10170: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
10171: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
10172: des_const_xmlChar_ptr(n_prefix2, (const xmlChar *)prefix2, 3);
10173: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 4);
10174: xmlResetLastError();
10175: if (mem_base != xmlMemBlocks()) {
10176: printf("Leak of %d blocks found in xmlHashQLookup2",
10177: xmlMemBlocks() - mem_base);
10178: test_ret++;
10179: printf(" %d", n_table);
10180: printf(" %d", n_prefix);
10181: printf(" %d", n_name);
10182: printf(" %d", n_prefix2);
10183: printf(" %d", n_name2);
10184: printf("\n");
10185: }
10186: }
10187: }
10188: }
10189: }
10190: }
10191: function_tests++;
10192:
10193: return(test_ret);
10194: }
10195:
10196:
10197: static int
10198: test_xmlHashQLookup3(void) {
10199: int test_ret = 0;
10200:
10201: int mem_base;
10202: void * ret_val;
10203: xmlHashTablePtr table; /* the hash table */
10204: int n_table;
10205: xmlChar * prefix; /* the prefix of the userdata */
10206: int n_prefix;
10207: xmlChar * name; /* the name of the userdata */
10208: int n_name;
10209: xmlChar * prefix2; /* the second prefix of the userdata */
10210: int n_prefix2;
10211: xmlChar * name2; /* a second name of the userdata */
10212: int n_name2;
10213: xmlChar * prefix3; /* the third prefix of the userdata */
10214: int n_prefix3;
10215: xmlChar * name3; /* a third name of the userdata */
10216: int n_name3;
10217:
10218: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10219: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
10220: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10221: for (n_prefix2 = 0;n_prefix2 < gen_nb_const_xmlChar_ptr;n_prefix2++) {
10222: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
10223: for (n_prefix3 = 0;n_prefix3 < gen_nb_const_xmlChar_ptr;n_prefix3++) {
10224: for (n_name3 = 0;n_name3 < gen_nb_const_xmlChar_ptr;n_name3++) {
10225: mem_base = xmlMemBlocks();
10226: table = gen_xmlHashTablePtr(n_table, 0);
10227: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
10228: name = gen_const_xmlChar_ptr(n_name, 2);
10229: prefix2 = gen_const_xmlChar_ptr(n_prefix2, 3);
10230: name2 = gen_const_xmlChar_ptr(n_name2, 4);
10231: prefix3 = gen_const_xmlChar_ptr(n_prefix3, 5);
10232: name3 = gen_const_xmlChar_ptr(n_name3, 6);
10233:
10234: ret_val = xmlHashQLookup3(table, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)prefix2, (const xmlChar *)name2, (const xmlChar *)prefix3, (const xmlChar *)name3);
10235: desret_void_ptr(ret_val);
10236: call_tests++;
10237: des_xmlHashTablePtr(n_table, table, 0);
10238: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
10239: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
10240: des_const_xmlChar_ptr(n_prefix2, (const xmlChar *)prefix2, 3);
10241: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 4);
10242: des_const_xmlChar_ptr(n_prefix3, (const xmlChar *)prefix3, 5);
10243: des_const_xmlChar_ptr(n_name3, (const xmlChar *)name3, 6);
10244: xmlResetLastError();
10245: if (mem_base != xmlMemBlocks()) {
10246: printf("Leak of %d blocks found in xmlHashQLookup3",
10247: xmlMemBlocks() - mem_base);
10248: test_ret++;
10249: printf(" %d", n_table);
10250: printf(" %d", n_prefix);
10251: printf(" %d", n_name);
10252: printf(" %d", n_prefix2);
10253: printf(" %d", n_name2);
10254: printf(" %d", n_prefix3);
10255: printf(" %d", n_name3);
10256: printf("\n");
10257: }
10258: }
10259: }
10260: }
10261: }
10262: }
10263: }
10264: }
10265: function_tests++;
10266:
10267: return(test_ret);
10268: }
10269:
10270:
10271: static int
10272: test_xmlHashRemoveEntry(void) {
10273: int test_ret = 0;
10274:
10275: int mem_base;
10276: int ret_val;
10277: xmlHashTablePtr table; /* the hash table */
10278: int n_table;
10279: xmlChar * name; /* the name of the userdata */
10280: int n_name;
10281: xmlHashDeallocator f; /* the deallocator function for removed item (if any) */
10282: int n_f;
10283:
10284: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10285: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10286: for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) {
10287: mem_base = xmlMemBlocks();
10288: table = gen_xmlHashTablePtr(n_table, 0);
10289: name = gen_const_xmlChar_ptr(n_name, 1);
10290: f = gen_xmlHashDeallocator(n_f, 2);
10291:
10292: ret_val = xmlHashRemoveEntry(table, (const xmlChar *)name, f);
10293: desret_int(ret_val);
10294: call_tests++;
10295: des_xmlHashTablePtr(n_table, table, 0);
10296: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
10297: des_xmlHashDeallocator(n_f, f, 2);
10298: xmlResetLastError();
10299: if (mem_base != xmlMemBlocks()) {
10300: printf("Leak of %d blocks found in xmlHashRemoveEntry",
10301: xmlMemBlocks() - mem_base);
10302: test_ret++;
10303: printf(" %d", n_table);
10304: printf(" %d", n_name);
10305: printf(" %d", n_f);
10306: printf("\n");
10307: }
10308: }
10309: }
10310: }
10311: function_tests++;
10312:
10313: return(test_ret);
10314: }
10315:
10316:
10317: static int
10318: test_xmlHashRemoveEntry2(void) {
10319: int test_ret = 0;
10320:
10321: int mem_base;
10322: int ret_val;
10323: xmlHashTablePtr table; /* the hash table */
10324: int n_table;
10325: xmlChar * name; /* the name of the userdata */
10326: int n_name;
10327: xmlChar * name2; /* a second name of the userdata */
10328: int n_name2;
10329: xmlHashDeallocator f; /* the deallocator function for removed item (if any) */
10330: int n_f;
10331:
10332: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10333: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10334: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
10335: for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) {
10336: mem_base = xmlMemBlocks();
10337: table = gen_xmlHashTablePtr(n_table, 0);
10338: name = gen_const_xmlChar_ptr(n_name, 1);
10339: name2 = gen_const_xmlChar_ptr(n_name2, 2);
10340: f = gen_xmlHashDeallocator(n_f, 3);
10341:
10342: ret_val = xmlHashRemoveEntry2(table, (const xmlChar *)name, (const xmlChar *)name2, f);
10343: desret_int(ret_val);
10344: call_tests++;
10345: des_xmlHashTablePtr(n_table, table, 0);
10346: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
10347: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
10348: des_xmlHashDeallocator(n_f, f, 3);
10349: xmlResetLastError();
10350: if (mem_base != xmlMemBlocks()) {
10351: printf("Leak of %d blocks found in xmlHashRemoveEntry2",
10352: xmlMemBlocks() - mem_base);
10353: test_ret++;
10354: printf(" %d", n_table);
10355: printf(" %d", n_name);
10356: printf(" %d", n_name2);
10357: printf(" %d", n_f);
10358: printf("\n");
10359: }
10360: }
10361: }
10362: }
10363: }
10364: function_tests++;
10365:
10366: return(test_ret);
10367: }
10368:
10369:
10370: static int
10371: test_xmlHashRemoveEntry3(void) {
10372: int test_ret = 0;
10373:
10374: int mem_base;
10375: int ret_val;
10376: xmlHashTablePtr table; /* the hash table */
10377: int n_table;
10378: xmlChar * name; /* the name of the userdata */
10379: int n_name;
10380: xmlChar * name2; /* a second name of the userdata */
10381: int n_name2;
10382: xmlChar * name3; /* a third name of the userdata */
10383: int n_name3;
10384: xmlHashDeallocator f; /* the deallocator function for removed item (if any) */
10385: int n_f;
10386:
10387: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10388: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10389: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
10390: for (n_name3 = 0;n_name3 < gen_nb_const_xmlChar_ptr;n_name3++) {
10391: for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) {
10392: mem_base = xmlMemBlocks();
10393: table = gen_xmlHashTablePtr(n_table, 0);
10394: name = gen_const_xmlChar_ptr(n_name, 1);
10395: name2 = gen_const_xmlChar_ptr(n_name2, 2);
10396: name3 = gen_const_xmlChar_ptr(n_name3, 3);
10397: f = gen_xmlHashDeallocator(n_f, 4);
10398:
10399: ret_val = xmlHashRemoveEntry3(table, (const xmlChar *)name, (const xmlChar *)name2, (const xmlChar *)name3, f);
10400: desret_int(ret_val);
10401: call_tests++;
10402: des_xmlHashTablePtr(n_table, table, 0);
10403: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
10404: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
10405: des_const_xmlChar_ptr(n_name3, (const xmlChar *)name3, 3);
10406: des_xmlHashDeallocator(n_f, f, 4);
10407: xmlResetLastError();
10408: if (mem_base != xmlMemBlocks()) {
10409: printf("Leak of %d blocks found in xmlHashRemoveEntry3",
10410: xmlMemBlocks() - mem_base);
10411: test_ret++;
10412: printf(" %d", n_table);
10413: printf(" %d", n_name);
10414: printf(" %d", n_name2);
10415: printf(" %d", n_name3);
10416: printf(" %d", n_f);
10417: printf("\n");
10418: }
10419: }
10420: }
10421: }
10422: }
10423: }
10424: function_tests++;
10425:
10426: return(test_ret);
10427: }
10428:
10429:
10430: static int
10431: test_xmlHashScan(void) {
10432: int test_ret = 0;
10433:
10434:
10435: /* missing type support */
10436: return(test_ret);
10437: }
10438:
10439:
10440: static int
10441: test_xmlHashScan3(void) {
10442: int test_ret = 0;
10443:
10444:
10445: /* missing type support */
10446: return(test_ret);
10447: }
10448:
10449:
10450: static int
10451: test_xmlHashScanFull(void) {
10452: int test_ret = 0;
10453:
10454:
10455: /* missing type support */
10456: return(test_ret);
10457: }
10458:
10459:
10460: static int
10461: test_xmlHashScanFull3(void) {
10462: int test_ret = 0;
10463:
10464:
10465: /* missing type support */
10466: return(test_ret);
10467: }
10468:
10469:
10470: static int
10471: test_xmlHashSize(void) {
10472: int test_ret = 0;
10473:
10474: int mem_base;
10475: int ret_val;
10476: xmlHashTablePtr table; /* the hash table */
10477: int n_table;
10478:
10479: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10480: mem_base = xmlMemBlocks();
10481: table = gen_xmlHashTablePtr(n_table, 0);
10482:
10483: ret_val = xmlHashSize(table);
10484: desret_int(ret_val);
10485: call_tests++;
10486: des_xmlHashTablePtr(n_table, table, 0);
10487: xmlResetLastError();
10488: if (mem_base != xmlMemBlocks()) {
10489: printf("Leak of %d blocks found in xmlHashSize",
10490: xmlMemBlocks() - mem_base);
10491: test_ret++;
10492: printf(" %d", n_table);
10493: printf("\n");
10494: }
10495: }
10496: function_tests++;
10497:
10498: return(test_ret);
10499: }
10500:
10501:
10502: static int
10503: test_xmlHashUpdateEntry(void) {
10504: int test_ret = 0;
10505:
10506: int mem_base;
10507: int ret_val;
10508: xmlHashTablePtr table; /* the hash table */
10509: int n_table;
10510: xmlChar * name; /* the name of the userdata */
10511: int n_name;
10512: void * userdata; /* a pointer to the userdata */
10513: int n_userdata;
10514: xmlHashDeallocator f; /* the deallocator function for replaced item (if any) */
10515: int n_f;
10516:
10517: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10518: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10519: for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) {
10520: for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) {
10521: mem_base = xmlMemBlocks();
10522: table = gen_xmlHashTablePtr(n_table, 0);
10523: name = gen_const_xmlChar_ptr(n_name, 1);
10524: userdata = gen_userdata(n_userdata, 2);
10525: f = gen_xmlHashDeallocator(n_f, 3);
10526:
10527: ret_val = xmlHashUpdateEntry(table, (const xmlChar *)name, userdata, f);
10528: desret_int(ret_val);
10529: call_tests++;
10530: des_xmlHashTablePtr(n_table, table, 0);
10531: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
10532: des_userdata(n_userdata, userdata, 2);
10533: des_xmlHashDeallocator(n_f, f, 3);
10534: xmlResetLastError();
10535: if (mem_base != xmlMemBlocks()) {
10536: printf("Leak of %d blocks found in xmlHashUpdateEntry",
10537: xmlMemBlocks() - mem_base);
10538: test_ret++;
10539: printf(" %d", n_table);
10540: printf(" %d", n_name);
10541: printf(" %d", n_userdata);
10542: printf(" %d", n_f);
10543: printf("\n");
10544: }
10545: }
10546: }
10547: }
10548: }
10549: function_tests++;
10550:
10551: return(test_ret);
10552: }
10553:
10554:
10555: static int
10556: test_xmlHashUpdateEntry2(void) {
10557: int test_ret = 0;
10558:
10559: int mem_base;
10560: int ret_val;
10561: xmlHashTablePtr table; /* the hash table */
10562: int n_table;
10563: xmlChar * name; /* the name of the userdata */
10564: int n_name;
10565: xmlChar * name2; /* a second name of the userdata */
10566: int n_name2;
10567: void * userdata; /* a pointer to the userdata */
10568: int n_userdata;
10569: xmlHashDeallocator f; /* the deallocator function for replaced item (if any) */
10570: int n_f;
10571:
10572: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10573: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10574: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
10575: for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) {
10576: for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) {
10577: mem_base = xmlMemBlocks();
10578: table = gen_xmlHashTablePtr(n_table, 0);
10579: name = gen_const_xmlChar_ptr(n_name, 1);
10580: name2 = gen_const_xmlChar_ptr(n_name2, 2);
10581: userdata = gen_userdata(n_userdata, 3);
10582: f = gen_xmlHashDeallocator(n_f, 4);
10583:
10584: ret_val = xmlHashUpdateEntry2(table, (const xmlChar *)name, (const xmlChar *)name2, userdata, f);
10585: desret_int(ret_val);
10586: call_tests++;
10587: des_xmlHashTablePtr(n_table, table, 0);
10588: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
10589: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
10590: des_userdata(n_userdata, userdata, 3);
10591: des_xmlHashDeallocator(n_f, f, 4);
10592: xmlResetLastError();
10593: if (mem_base != xmlMemBlocks()) {
10594: printf("Leak of %d blocks found in xmlHashUpdateEntry2",
10595: xmlMemBlocks() - mem_base);
10596: test_ret++;
10597: printf(" %d", n_table);
10598: printf(" %d", n_name);
10599: printf(" %d", n_name2);
10600: printf(" %d", n_userdata);
10601: printf(" %d", n_f);
10602: printf("\n");
10603: }
10604: }
10605: }
10606: }
10607: }
10608: }
10609: function_tests++;
10610:
10611: return(test_ret);
10612: }
10613:
10614:
10615: static int
10616: test_xmlHashUpdateEntry3(void) {
10617: int test_ret = 0;
10618:
10619: int mem_base;
10620: int ret_val;
10621: xmlHashTablePtr table; /* the hash table */
10622: int n_table;
10623: xmlChar * name; /* the name of the userdata */
10624: int n_name;
10625: xmlChar * name2; /* a second name of the userdata */
10626: int n_name2;
10627: xmlChar * name3; /* a third name of the userdata */
10628: int n_name3;
10629: void * userdata; /* a pointer to the userdata */
10630: int n_userdata;
10631: xmlHashDeallocator f; /* the deallocator function for replaced item (if any) */
10632: int n_f;
10633:
10634: for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10635: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10636: for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
10637: for (n_name3 = 0;n_name3 < gen_nb_const_xmlChar_ptr;n_name3++) {
10638: for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) {
10639: for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) {
10640: mem_base = xmlMemBlocks();
10641: table = gen_xmlHashTablePtr(n_table, 0);
10642: name = gen_const_xmlChar_ptr(n_name, 1);
10643: name2 = gen_const_xmlChar_ptr(n_name2, 2);
10644: name3 = gen_const_xmlChar_ptr(n_name3, 3);
10645: userdata = gen_userdata(n_userdata, 4);
10646: f = gen_xmlHashDeallocator(n_f, 5);
10647:
10648: ret_val = xmlHashUpdateEntry3(table, (const xmlChar *)name, (const xmlChar *)name2, (const xmlChar *)name3, userdata, f);
10649: desret_int(ret_val);
10650: call_tests++;
10651: des_xmlHashTablePtr(n_table, table, 0);
10652: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
10653: des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
10654: des_const_xmlChar_ptr(n_name3, (const xmlChar *)name3, 3);
10655: des_userdata(n_userdata, userdata, 4);
10656: des_xmlHashDeallocator(n_f, f, 5);
10657: xmlResetLastError();
10658: if (mem_base != xmlMemBlocks()) {
10659: printf("Leak of %d blocks found in xmlHashUpdateEntry3",
10660: xmlMemBlocks() - mem_base);
10661: test_ret++;
10662: printf(" %d", n_table);
10663: printf(" %d", n_name);
10664: printf(" %d", n_name2);
10665: printf(" %d", n_name3);
10666: printf(" %d", n_userdata);
10667: printf(" %d", n_f);
10668: printf("\n");
10669: }
10670: }
10671: }
10672: }
10673: }
10674: }
10675: }
10676: function_tests++;
10677:
10678: return(test_ret);
10679: }
10680:
10681: static int
10682: test_hash(void) {
10683: int test_ret = 0;
10684:
10685: if (quiet == 0) printf("Testing hash : 16 of 24 functions ...\n");
10686: test_ret += test_xmlHashAddEntry();
10687: test_ret += test_xmlHashAddEntry2();
10688: test_ret += test_xmlHashAddEntry3();
10689: test_ret += test_xmlHashCopy();
10690: test_ret += test_xmlHashCreate();
10691: test_ret += test_xmlHashCreateDict();
10692: test_ret += test_xmlHashLookup();
10693: test_ret += test_xmlHashLookup2();
10694: test_ret += test_xmlHashLookup3();
10695: test_ret += test_xmlHashQLookup();
10696: test_ret += test_xmlHashQLookup2();
10697: test_ret += test_xmlHashQLookup3();
10698: test_ret += test_xmlHashRemoveEntry();
10699: test_ret += test_xmlHashRemoveEntry2();
10700: test_ret += test_xmlHashRemoveEntry3();
10701: test_ret += test_xmlHashScan();
10702: test_ret += test_xmlHashScan3();
10703: test_ret += test_xmlHashScanFull();
10704: test_ret += test_xmlHashScanFull3();
10705: test_ret += test_xmlHashSize();
10706: test_ret += test_xmlHashUpdateEntry();
10707: test_ret += test_xmlHashUpdateEntry2();
10708: test_ret += test_xmlHashUpdateEntry3();
10709:
10710: if (test_ret != 0)
10711: printf("Module hash: %d errors\n", test_ret);
10712: return(test_ret);
10713: }
10714:
10715: #define gen_nb_xmlLinkPtr 1
10716: static xmlLinkPtr gen_xmlLinkPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
10717: return(NULL);
10718: }
10719: static void des_xmlLinkPtr(int no ATTRIBUTE_UNUSED, xmlLinkPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
10720: }
10721:
10722: static int
10723: test_xmlLinkGetData(void) {
10724: int test_ret = 0;
10725:
10726: int mem_base;
10727: void * ret_val;
10728: xmlLinkPtr lk; /* a link */
10729: int n_lk;
10730:
10731: for (n_lk = 0;n_lk < gen_nb_xmlLinkPtr;n_lk++) {
10732: mem_base = xmlMemBlocks();
10733: lk = gen_xmlLinkPtr(n_lk, 0);
10734:
10735: ret_val = xmlLinkGetData(lk);
10736: desret_void_ptr(ret_val);
10737: call_tests++;
10738: des_xmlLinkPtr(n_lk, lk, 0);
10739: xmlResetLastError();
10740: if (mem_base != xmlMemBlocks()) {
10741: printf("Leak of %d blocks found in xmlLinkGetData",
10742: xmlMemBlocks() - mem_base);
10743: test_ret++;
10744: printf(" %d", n_lk);
10745: printf("\n");
10746: }
10747: }
10748: function_tests++;
10749:
10750: return(test_ret);
10751: }
10752:
10753:
10754: static int
10755: test_xmlListAppend(void) {
10756: int test_ret = 0;
10757:
10758: int mem_base;
10759: int ret_val;
10760: xmlListPtr l; /* a list */
10761: int n_l;
10762: void * data; /* the data */
10763: int n_data;
10764:
10765: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
10766: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
10767: mem_base = xmlMemBlocks();
10768: l = gen_xmlListPtr(n_l, 0);
10769: data = gen_userdata(n_data, 1);
10770:
10771: ret_val = xmlListAppend(l, data);
10772: desret_int(ret_val);
10773: call_tests++;
10774: des_xmlListPtr(n_l, l, 0);
10775: des_userdata(n_data, data, 1);
10776: xmlResetLastError();
10777: if (mem_base != xmlMemBlocks()) {
10778: printf("Leak of %d blocks found in xmlListAppend",
10779: xmlMemBlocks() - mem_base);
10780: test_ret++;
10781: printf(" %d", n_l);
10782: printf(" %d", n_data);
10783: printf("\n");
10784: }
10785: }
10786: }
10787: function_tests++;
10788:
10789: return(test_ret);
10790: }
10791:
10792:
10793: static int
10794: test_xmlListClear(void) {
10795: int test_ret = 0;
10796:
10797: int mem_base;
10798: xmlListPtr l; /* a list */
10799: int n_l;
10800:
10801: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
10802: mem_base = xmlMemBlocks();
10803: l = gen_xmlListPtr(n_l, 0);
10804:
10805: xmlListClear(l);
10806: call_tests++;
10807: des_xmlListPtr(n_l, l, 0);
10808: xmlResetLastError();
10809: if (mem_base != xmlMemBlocks()) {
10810: printf("Leak of %d blocks found in xmlListClear",
10811: xmlMemBlocks() - mem_base);
10812: test_ret++;
10813: printf(" %d", n_l);
10814: printf("\n");
10815: }
10816: }
10817: function_tests++;
10818:
10819: return(test_ret);
10820: }
10821:
10822:
10823: #define gen_nb_const_xmlListPtr 1
10824: static xmlListPtr gen_const_xmlListPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
10825: return(NULL);
10826: }
10827: static void des_const_xmlListPtr(int no ATTRIBUTE_UNUSED, const xmlListPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
10828: }
10829:
10830: static int
10831: test_xmlListCopy(void) {
10832: int test_ret = 0;
10833:
10834: int mem_base;
10835: int ret_val;
10836: xmlListPtr cur; /* the new list */
10837: int n_cur;
10838: xmlListPtr old; /* the old list */
10839: int n_old;
10840:
10841: for (n_cur = 0;n_cur < gen_nb_xmlListPtr;n_cur++) {
10842: for (n_old = 0;n_old < gen_nb_const_xmlListPtr;n_old++) {
10843: mem_base = xmlMemBlocks();
10844: cur = gen_xmlListPtr(n_cur, 0);
10845: old = gen_const_xmlListPtr(n_old, 1);
10846:
10847: ret_val = xmlListCopy(cur, (const xmlListPtr)old);
10848: desret_int(ret_val);
10849: call_tests++;
10850: des_xmlListPtr(n_cur, cur, 0);
10851: des_const_xmlListPtr(n_old, (const xmlListPtr)old, 1);
10852: xmlResetLastError();
10853: if (mem_base != xmlMemBlocks()) {
10854: printf("Leak of %d blocks found in xmlListCopy",
10855: xmlMemBlocks() - mem_base);
10856: test_ret++;
10857: printf(" %d", n_cur);
10858: printf(" %d", n_old);
10859: printf("\n");
10860: }
10861: }
10862: }
10863: function_tests++;
10864:
10865: return(test_ret);
10866: }
10867:
10868:
10869: static int
10870: test_xmlListCreate(void) {
10871: int test_ret = 0;
10872:
10873:
10874: /* missing type support */
10875: return(test_ret);
10876: }
10877:
10878:
10879: static int
10880: test_xmlListDup(void) {
10881: int test_ret = 0;
10882:
10883:
10884: /* missing type support */
10885: return(test_ret);
10886: }
10887:
10888:
10889: static int
10890: test_xmlListEmpty(void) {
10891: int test_ret = 0;
10892:
10893: int mem_base;
10894: int ret_val;
10895: xmlListPtr l; /* a list */
10896: int n_l;
10897:
10898: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
10899: mem_base = xmlMemBlocks();
10900: l = gen_xmlListPtr(n_l, 0);
10901:
10902: ret_val = xmlListEmpty(l);
10903: desret_int(ret_val);
10904: call_tests++;
10905: des_xmlListPtr(n_l, l, 0);
10906: xmlResetLastError();
10907: if (mem_base != xmlMemBlocks()) {
10908: printf("Leak of %d blocks found in xmlListEmpty",
10909: xmlMemBlocks() - mem_base);
10910: test_ret++;
10911: printf(" %d", n_l);
10912: printf("\n");
10913: }
10914: }
10915: function_tests++;
10916:
10917: return(test_ret);
10918: }
10919:
10920:
10921: static int
10922: test_xmlListEnd(void) {
10923: int test_ret = 0;
10924:
10925:
10926: /* missing type support */
10927: return(test_ret);
10928: }
10929:
10930:
10931: static int
10932: test_xmlListFront(void) {
10933: int test_ret = 0;
10934:
10935:
10936: /* missing type support */
10937: return(test_ret);
10938: }
10939:
10940:
10941: static int
10942: test_xmlListInsert(void) {
10943: int test_ret = 0;
10944:
10945: int mem_base;
10946: int ret_val;
10947: xmlListPtr l; /* a list */
10948: int n_l;
10949: void * data; /* the data */
10950: int n_data;
10951:
10952: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
10953: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
10954: mem_base = xmlMemBlocks();
10955: l = gen_xmlListPtr(n_l, 0);
10956: data = gen_userdata(n_data, 1);
10957:
10958: ret_val = xmlListInsert(l, data);
10959: desret_int(ret_val);
10960: call_tests++;
10961: des_xmlListPtr(n_l, l, 0);
10962: des_userdata(n_data, data, 1);
10963: xmlResetLastError();
10964: if (mem_base != xmlMemBlocks()) {
10965: printf("Leak of %d blocks found in xmlListInsert",
10966: xmlMemBlocks() - mem_base);
10967: test_ret++;
10968: printf(" %d", n_l);
10969: printf(" %d", n_data);
10970: printf("\n");
10971: }
10972: }
10973: }
10974: function_tests++;
10975:
10976: return(test_ret);
10977: }
10978:
10979:
10980: static int
10981: test_xmlListMerge(void) {
10982: int test_ret = 0;
10983:
10984: int mem_base;
10985: xmlListPtr l1; /* the original list */
10986: int n_l1;
10987: xmlListPtr l2; /* the new list */
10988: int n_l2;
10989:
10990: for (n_l1 = 0;n_l1 < gen_nb_xmlListPtr;n_l1++) {
10991: for (n_l2 = 0;n_l2 < gen_nb_xmlListPtr;n_l2++) {
10992: mem_base = xmlMemBlocks();
10993: l1 = gen_xmlListPtr(n_l1, 0);
10994: l2 = gen_xmlListPtr(n_l2, 1);
10995:
10996: xmlListMerge(l1, l2);
10997: call_tests++;
10998: des_xmlListPtr(n_l1, l1, 0);
10999: des_xmlListPtr(n_l2, l2, 1);
11000: xmlResetLastError();
11001: if (mem_base != xmlMemBlocks()) {
11002: printf("Leak of %d blocks found in xmlListMerge",
11003: xmlMemBlocks() - mem_base);
11004: test_ret++;
11005: printf(" %d", n_l1);
11006: printf(" %d", n_l2);
11007: printf("\n");
11008: }
11009: }
11010: }
11011: function_tests++;
11012:
11013: return(test_ret);
11014: }
11015:
11016:
11017: static int
11018: test_xmlListPopBack(void) {
11019: int test_ret = 0;
11020:
11021: int mem_base;
11022: xmlListPtr l; /* a list */
11023: int n_l;
11024:
11025: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11026: mem_base = xmlMemBlocks();
11027: l = gen_xmlListPtr(n_l, 0);
11028:
11029: xmlListPopBack(l);
11030: call_tests++;
11031: des_xmlListPtr(n_l, l, 0);
11032: xmlResetLastError();
11033: if (mem_base != xmlMemBlocks()) {
11034: printf("Leak of %d blocks found in xmlListPopBack",
11035: xmlMemBlocks() - mem_base);
11036: test_ret++;
11037: printf(" %d", n_l);
11038: printf("\n");
11039: }
11040: }
11041: function_tests++;
11042:
11043: return(test_ret);
11044: }
11045:
11046:
11047: static int
11048: test_xmlListPopFront(void) {
11049: int test_ret = 0;
11050:
11051: int mem_base;
11052: xmlListPtr l; /* a list */
11053: int n_l;
11054:
11055: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11056: mem_base = xmlMemBlocks();
11057: l = gen_xmlListPtr(n_l, 0);
11058:
11059: xmlListPopFront(l);
11060: call_tests++;
11061: des_xmlListPtr(n_l, l, 0);
11062: xmlResetLastError();
11063: if (mem_base != xmlMemBlocks()) {
11064: printf("Leak of %d blocks found in xmlListPopFront",
11065: xmlMemBlocks() - mem_base);
11066: test_ret++;
11067: printf(" %d", n_l);
11068: printf("\n");
11069: }
11070: }
11071: function_tests++;
11072:
11073: return(test_ret);
11074: }
11075:
11076:
11077: static int
11078: test_xmlListPushBack(void) {
11079: int test_ret = 0;
11080:
11081: int mem_base;
11082: int ret_val;
11083: xmlListPtr l; /* a list */
11084: int n_l;
11085: void * data; /* new data */
11086: int n_data;
11087:
11088: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11089: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
11090: mem_base = xmlMemBlocks();
11091: l = gen_xmlListPtr(n_l, 0);
11092: data = gen_userdata(n_data, 1);
11093:
11094: ret_val = xmlListPushBack(l, data);
11095: desret_int(ret_val);
11096: call_tests++;
11097: des_xmlListPtr(n_l, l, 0);
11098: des_userdata(n_data, data, 1);
11099: xmlResetLastError();
11100: if (mem_base != xmlMemBlocks()) {
11101: printf("Leak of %d blocks found in xmlListPushBack",
11102: xmlMemBlocks() - mem_base);
11103: test_ret++;
11104: printf(" %d", n_l);
11105: printf(" %d", n_data);
11106: printf("\n");
11107: }
11108: }
11109: }
11110: function_tests++;
11111:
11112: return(test_ret);
11113: }
11114:
11115:
11116: static int
11117: test_xmlListPushFront(void) {
11118: int test_ret = 0;
11119:
11120: int mem_base;
11121: int ret_val;
11122: xmlListPtr l; /* a list */
11123: int n_l;
11124: void * data; /* new data */
11125: int n_data;
11126:
11127: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11128: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
11129: mem_base = xmlMemBlocks();
11130: l = gen_xmlListPtr(n_l, 0);
11131: data = gen_userdata(n_data, 1);
11132:
11133: ret_val = xmlListPushFront(l, data);
11134: desret_int(ret_val);
11135: call_tests++;
11136: des_xmlListPtr(n_l, l, 0);
11137: des_userdata(n_data, data, 1);
11138: xmlResetLastError();
11139: if (mem_base != xmlMemBlocks()) {
11140: printf("Leak of %d blocks found in xmlListPushFront",
11141: xmlMemBlocks() - mem_base);
11142: test_ret++;
11143: printf(" %d", n_l);
11144: printf(" %d", n_data);
11145: printf("\n");
11146: }
11147: }
11148: }
11149: function_tests++;
11150:
11151: return(test_ret);
11152: }
11153:
11154:
11155: static int
11156: test_xmlListRemoveAll(void) {
11157: int test_ret = 0;
11158:
11159: int mem_base;
11160: int ret_val;
11161: xmlListPtr l; /* a list */
11162: int n_l;
11163: void * data; /* list data */
11164: int n_data;
11165:
11166: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11167: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
11168: mem_base = xmlMemBlocks();
11169: l = gen_xmlListPtr(n_l, 0);
11170: data = gen_userdata(n_data, 1);
11171:
11172: ret_val = xmlListRemoveAll(l, data);
11173: desret_int(ret_val);
11174: call_tests++;
11175: des_xmlListPtr(n_l, l, 0);
11176: des_userdata(n_data, data, 1);
11177: xmlResetLastError();
11178: if (mem_base != xmlMemBlocks()) {
11179: printf("Leak of %d blocks found in xmlListRemoveAll",
11180: xmlMemBlocks() - mem_base);
11181: test_ret++;
11182: printf(" %d", n_l);
11183: printf(" %d", n_data);
11184: printf("\n");
11185: }
11186: }
11187: }
11188: function_tests++;
11189:
11190: return(test_ret);
11191: }
11192:
11193:
11194: static int
11195: test_xmlListRemoveFirst(void) {
11196: int test_ret = 0;
11197:
11198: int mem_base;
11199: int ret_val;
11200: xmlListPtr l; /* a list */
11201: int n_l;
11202: void * data; /* list data */
11203: int n_data;
11204:
11205: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11206: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
11207: mem_base = xmlMemBlocks();
11208: l = gen_xmlListPtr(n_l, 0);
11209: data = gen_userdata(n_data, 1);
11210:
11211: ret_val = xmlListRemoveFirst(l, data);
11212: desret_int(ret_val);
11213: call_tests++;
11214: des_xmlListPtr(n_l, l, 0);
11215: des_userdata(n_data, data, 1);
11216: xmlResetLastError();
11217: if (mem_base != xmlMemBlocks()) {
11218: printf("Leak of %d blocks found in xmlListRemoveFirst",
11219: xmlMemBlocks() - mem_base);
11220: test_ret++;
11221: printf(" %d", n_l);
11222: printf(" %d", n_data);
11223: printf("\n");
11224: }
11225: }
11226: }
11227: function_tests++;
11228:
11229: return(test_ret);
11230: }
11231:
11232:
11233: static int
11234: test_xmlListRemoveLast(void) {
11235: int test_ret = 0;
11236:
11237: int mem_base;
11238: int ret_val;
11239: xmlListPtr l; /* a list */
11240: int n_l;
11241: void * data; /* list data */
11242: int n_data;
11243:
11244: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11245: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
11246: mem_base = xmlMemBlocks();
11247: l = gen_xmlListPtr(n_l, 0);
11248: data = gen_userdata(n_data, 1);
11249:
11250: ret_val = xmlListRemoveLast(l, data);
11251: desret_int(ret_val);
11252: call_tests++;
11253: des_xmlListPtr(n_l, l, 0);
11254: des_userdata(n_data, data, 1);
11255: xmlResetLastError();
11256: if (mem_base != xmlMemBlocks()) {
11257: printf("Leak of %d blocks found in xmlListRemoveLast",
11258: xmlMemBlocks() - mem_base);
11259: test_ret++;
11260: printf(" %d", n_l);
11261: printf(" %d", n_data);
11262: printf("\n");
11263: }
11264: }
11265: }
11266: function_tests++;
11267:
11268: return(test_ret);
11269: }
11270:
11271:
11272: static int
11273: test_xmlListReverse(void) {
11274: int test_ret = 0;
11275:
11276: int mem_base;
11277: xmlListPtr l; /* a list */
11278: int n_l;
11279:
11280: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11281: mem_base = xmlMemBlocks();
11282: l = gen_xmlListPtr(n_l, 0);
11283:
11284: xmlListReverse(l);
11285: call_tests++;
11286: des_xmlListPtr(n_l, l, 0);
11287: xmlResetLastError();
11288: if (mem_base != xmlMemBlocks()) {
11289: printf("Leak of %d blocks found in xmlListReverse",
11290: xmlMemBlocks() - mem_base);
11291: test_ret++;
11292: printf(" %d", n_l);
11293: printf("\n");
11294: }
11295: }
11296: function_tests++;
11297:
11298: return(test_ret);
11299: }
11300:
11301:
11302: static int
11303: test_xmlListReverseSearch(void) {
11304: int test_ret = 0;
11305:
11306: int mem_base;
11307: void * ret_val;
11308: xmlListPtr l; /* a list */
11309: int n_l;
11310: void * data; /* a search value */
11311: int n_data;
11312:
11313: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11314: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
11315: mem_base = xmlMemBlocks();
11316: l = gen_xmlListPtr(n_l, 0);
11317: data = gen_userdata(n_data, 1);
11318:
11319: ret_val = xmlListReverseSearch(l, data);
11320: desret_void_ptr(ret_val);
11321: call_tests++;
11322: des_xmlListPtr(n_l, l, 0);
11323: des_userdata(n_data, data, 1);
11324: xmlResetLastError();
11325: if (mem_base != xmlMemBlocks()) {
11326: printf("Leak of %d blocks found in xmlListReverseSearch",
11327: xmlMemBlocks() - mem_base);
11328: test_ret++;
11329: printf(" %d", n_l);
11330: printf(" %d", n_data);
11331: printf("\n");
11332: }
11333: }
11334: }
11335: function_tests++;
11336:
11337: return(test_ret);
11338: }
11339:
11340:
11341: static int
11342: test_xmlListReverseWalk(void) {
11343: int test_ret = 0;
11344:
11345:
11346: /* missing type support */
11347: return(test_ret);
11348: }
11349:
11350:
11351: static int
11352: test_xmlListSearch(void) {
11353: int test_ret = 0;
11354:
11355: int mem_base;
11356: void * ret_val;
11357: xmlListPtr l; /* a list */
11358: int n_l;
11359: void * data; /* a search value */
11360: int n_data;
11361:
11362: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11363: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
11364: mem_base = xmlMemBlocks();
11365: l = gen_xmlListPtr(n_l, 0);
11366: data = gen_userdata(n_data, 1);
11367:
11368: ret_val = xmlListSearch(l, data);
11369: desret_void_ptr(ret_val);
11370: call_tests++;
11371: des_xmlListPtr(n_l, l, 0);
11372: des_userdata(n_data, data, 1);
11373: xmlResetLastError();
11374: if (mem_base != xmlMemBlocks()) {
11375: printf("Leak of %d blocks found in xmlListSearch",
11376: xmlMemBlocks() - mem_base);
11377: test_ret++;
11378: printf(" %d", n_l);
11379: printf(" %d", n_data);
11380: printf("\n");
11381: }
11382: }
11383: }
11384: function_tests++;
11385:
11386: return(test_ret);
11387: }
11388:
11389:
11390: static int
11391: test_xmlListSize(void) {
11392: int test_ret = 0;
11393:
11394: int mem_base;
11395: int ret_val;
11396: xmlListPtr l; /* a list */
11397: int n_l;
11398:
11399: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11400: mem_base = xmlMemBlocks();
11401: l = gen_xmlListPtr(n_l, 0);
11402:
11403: ret_val = xmlListSize(l);
11404: desret_int(ret_val);
11405: call_tests++;
11406: des_xmlListPtr(n_l, l, 0);
11407: xmlResetLastError();
11408: if (mem_base != xmlMemBlocks()) {
11409: printf("Leak of %d blocks found in xmlListSize",
11410: xmlMemBlocks() - mem_base);
11411: test_ret++;
11412: printf(" %d", n_l);
11413: printf("\n");
11414: }
11415: }
11416: function_tests++;
11417:
11418: return(test_ret);
11419: }
11420:
11421:
11422: static int
11423: test_xmlListSort(void) {
11424: int test_ret = 0;
11425:
11426: int mem_base;
11427: xmlListPtr l; /* a list */
11428: int n_l;
11429:
11430: for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11431: mem_base = xmlMemBlocks();
11432: l = gen_xmlListPtr(n_l, 0);
11433:
11434: xmlListSort(l);
11435: call_tests++;
11436: des_xmlListPtr(n_l, l, 0);
11437: xmlResetLastError();
11438: if (mem_base != xmlMemBlocks()) {
11439: printf("Leak of %d blocks found in xmlListSort",
11440: xmlMemBlocks() - mem_base);
11441: test_ret++;
11442: printf(" %d", n_l);
11443: printf("\n");
11444: }
11445: }
11446: function_tests++;
11447:
11448: return(test_ret);
11449: }
11450:
11451:
11452: static int
11453: test_xmlListWalk(void) {
11454: int test_ret = 0;
11455:
11456:
11457: /* missing type support */
11458: return(test_ret);
11459: }
11460:
11461: static int
11462: test_list(void) {
11463: int test_ret = 0;
11464:
11465: if (quiet == 0) printf("Testing list : 19 of 26 functions ...\n");
11466: test_ret += test_xmlLinkGetData();
11467: test_ret += test_xmlListAppend();
11468: test_ret += test_xmlListClear();
11469: test_ret += test_xmlListCopy();
11470: test_ret += test_xmlListCreate();
11471: test_ret += test_xmlListDup();
11472: test_ret += test_xmlListEmpty();
11473: test_ret += test_xmlListEnd();
11474: test_ret += test_xmlListFront();
11475: test_ret += test_xmlListInsert();
11476: test_ret += test_xmlListMerge();
11477: test_ret += test_xmlListPopBack();
11478: test_ret += test_xmlListPopFront();
11479: test_ret += test_xmlListPushBack();
11480: test_ret += test_xmlListPushFront();
11481: test_ret += test_xmlListRemoveAll();
11482: test_ret += test_xmlListRemoveFirst();
11483: test_ret += test_xmlListRemoveLast();
11484: test_ret += test_xmlListReverse();
11485: test_ret += test_xmlListReverseSearch();
11486: test_ret += test_xmlListReverseWalk();
11487: test_ret += test_xmlListSearch();
11488: test_ret += test_xmlListSize();
11489: test_ret += test_xmlListSort();
11490: test_ret += test_xmlListWalk();
11491:
11492: if (test_ret != 0)
11493: printf("Module list: %d errors\n", test_ret);
11494: return(test_ret);
11495: }
11496:
11497: static int
11498: test_xmlNanoFTPCheckResponse(void) {
11499: int test_ret = 0;
11500:
11501: #if defined(LIBXML_FTP_ENABLED)
11502: int mem_base;
11503: int ret_val;
11504: void * ctx; /* an FTP context */
11505: int n_ctx;
11506:
11507: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
11508: mem_base = xmlMemBlocks();
11509: ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
11510:
11511: ret_val = xmlNanoFTPCheckResponse(ctx);
11512: desret_int(ret_val);
11513: call_tests++;
11514: des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
11515: xmlResetLastError();
11516: if (mem_base != xmlMemBlocks()) {
11517: printf("Leak of %d blocks found in xmlNanoFTPCheckResponse",
11518: xmlMemBlocks() - mem_base);
11519: test_ret++;
11520: printf(" %d", n_ctx);
11521: printf("\n");
11522: }
11523: }
11524: function_tests++;
11525: #endif
11526:
11527: return(test_ret);
11528: }
11529:
11530:
11531: static int
11532: test_xmlNanoFTPCleanup(void) {
11533: int test_ret = 0;
11534:
11535: #if defined(LIBXML_FTP_ENABLED)
11536: int mem_base;
11537:
11538: mem_base = xmlMemBlocks();
11539:
11540: xmlNanoFTPCleanup();
11541: call_tests++;
11542: xmlResetLastError();
11543: if (mem_base != xmlMemBlocks()) {
11544: printf("Leak of %d blocks found in xmlNanoFTPCleanup",
11545: xmlMemBlocks() - mem_base);
11546: test_ret++;
11547: printf("\n");
11548: }
11549: function_tests++;
11550: #endif
11551:
11552: return(test_ret);
11553: }
11554:
11555:
11556: static int
11557: test_xmlNanoFTPCloseConnection(void) {
11558: int test_ret = 0;
11559:
11560: #if defined(LIBXML_FTP_ENABLED)
11561: int mem_base;
11562: int ret_val;
11563: void * ctx; /* an FTP context */
11564: int n_ctx;
11565:
11566: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
11567: mem_base = xmlMemBlocks();
11568: ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
11569:
11570: ret_val = xmlNanoFTPCloseConnection(ctx);
11571: desret_int(ret_val);
11572: call_tests++;
11573: des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
11574: xmlResetLastError();
11575: if (mem_base != xmlMemBlocks()) {
11576: printf("Leak of %d blocks found in xmlNanoFTPCloseConnection",
11577: xmlMemBlocks() - mem_base);
11578: test_ret++;
11579: printf(" %d", n_ctx);
11580: printf("\n");
11581: }
11582: }
11583: function_tests++;
11584: #endif
11585:
11586: return(test_ret);
11587: }
11588:
11589:
11590: static int
11591: test_xmlNanoFTPCwd(void) {
11592: int test_ret = 0;
11593:
11594: #if defined(LIBXML_FTP_ENABLED)
11595: int mem_base;
11596: int ret_val;
11597: void * ctx; /* an FTP context */
11598: int n_ctx;
11599: char * directory; /* a directory on the server */
11600: int n_directory;
11601:
11602: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
11603: for (n_directory = 0;n_directory < gen_nb_const_char_ptr;n_directory++) {
11604: mem_base = xmlMemBlocks();
11605: ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
11606: directory = gen_const_char_ptr(n_directory, 1);
11607:
11608: ret_val = xmlNanoFTPCwd(ctx, (const char *)directory);
11609: desret_int(ret_val);
11610: call_tests++;
11611: des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
11612: des_const_char_ptr(n_directory, (const char *)directory, 1);
11613: xmlResetLastError();
11614: if (mem_base != xmlMemBlocks()) {
11615: printf("Leak of %d blocks found in xmlNanoFTPCwd",
11616: xmlMemBlocks() - mem_base);
11617: test_ret++;
11618: printf(" %d", n_ctx);
11619: printf(" %d", n_directory);
11620: printf("\n");
11621: }
11622: }
11623: }
11624: function_tests++;
11625: #endif
11626:
11627: return(test_ret);
11628: }
11629:
11630:
11631: static int
11632: test_xmlNanoFTPDele(void) {
11633: int test_ret = 0;
11634:
11635: #if defined(LIBXML_FTP_ENABLED)
11636: int mem_base;
11637: int ret_val;
11638: void * ctx; /* an FTP context */
11639: int n_ctx;
11640: const char * file; /* a file or directory on the server */
11641: int n_file;
11642:
11643: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
11644: for (n_file = 0;n_file < gen_nb_filepath;n_file++) {
11645: mem_base = xmlMemBlocks();
11646: ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
11647: file = gen_filepath(n_file, 1);
11648:
11649: ret_val = xmlNanoFTPDele(ctx, file);
11650: desret_int(ret_val);
11651: call_tests++;
11652: des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
11653: des_filepath(n_file, file, 1);
11654: xmlResetLastError();
11655: if (mem_base != xmlMemBlocks()) {
11656: printf("Leak of %d blocks found in xmlNanoFTPDele",
11657: xmlMemBlocks() - mem_base);
11658: test_ret++;
11659: printf(" %d", n_ctx);
11660: printf(" %d", n_file);
11661: printf("\n");
11662: }
11663: }
11664: }
11665: function_tests++;
11666: #endif
11667:
11668: return(test_ret);
11669: }
11670:
11671:
11672: static int
11673: test_xmlNanoFTPGet(void) {
11674: int test_ret = 0;
11675:
11676:
11677: /* missing type support */
11678: return(test_ret);
11679: }
11680:
11681:
11682: static int
11683: test_xmlNanoFTPGetConnection(void) {
11684: int test_ret = 0;
11685:
11686:
11687: /* missing type support */
11688: return(test_ret);
11689: }
11690:
11691:
11692: static int
11693: test_xmlNanoFTPGetResponse(void) {
11694: int test_ret = 0;
11695:
11696: #if defined(LIBXML_FTP_ENABLED)
11697: int mem_base;
11698: int ret_val;
11699: void * ctx; /* an FTP context */
11700: int n_ctx;
11701:
11702: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
11703: mem_base = xmlMemBlocks();
11704: ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
11705:
11706: ret_val = xmlNanoFTPGetResponse(ctx);
11707: desret_int(ret_val);
11708: call_tests++;
11709: des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
11710: xmlResetLastError();
11711: if (mem_base != xmlMemBlocks()) {
11712: printf("Leak of %d blocks found in xmlNanoFTPGetResponse",
11713: xmlMemBlocks() - mem_base);
11714: test_ret++;
11715: printf(" %d", n_ctx);
11716: printf("\n");
11717: }
11718: }
11719: function_tests++;
11720: #endif
11721:
11722: return(test_ret);
11723: }
11724:
11725:
11726: static int
11727: test_xmlNanoFTPGetSocket(void) {
11728: int test_ret = 0;
11729:
11730:
11731: /* missing type support */
11732: return(test_ret);
11733: }
11734:
11735:
11736: static int
11737: test_xmlNanoFTPInit(void) {
11738: int test_ret = 0;
11739:
11740: #if defined(LIBXML_FTP_ENABLED)
11741: int mem_base;
11742:
11743: mem_base = xmlMemBlocks();
11744:
11745: xmlNanoFTPInit();
11746: call_tests++;
11747: xmlResetLastError();
11748: if (mem_base != xmlMemBlocks()) {
11749: printf("Leak of %d blocks found in xmlNanoFTPInit",
11750: xmlMemBlocks() - mem_base);
11751: test_ret++;
11752: printf("\n");
11753: }
11754: function_tests++;
11755: #endif
11756:
11757: return(test_ret);
11758: }
11759:
11760:
11761: static int
11762: test_xmlNanoFTPList(void) {
11763: int test_ret = 0;
11764:
11765:
11766: /* missing type support */
11767: return(test_ret);
11768: }
11769:
11770:
11771: static int
11772: test_xmlNanoFTPNewCtxt(void) {
11773: int test_ret = 0;
11774:
11775: #if defined(LIBXML_FTP_ENABLED)
11776: int mem_base;
11777: void * ret_val;
11778: const char * URL; /* The URL used to initialize the context */
11779: int n_URL;
11780:
11781: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
11782: mem_base = xmlMemBlocks();
11783: URL = gen_filepath(n_URL, 0);
11784:
11785: ret_val = xmlNanoFTPNewCtxt(URL);
11786: desret_xmlNanoFTPCtxtPtr(ret_val);
11787: call_tests++;
11788: des_filepath(n_URL, URL, 0);
11789: xmlResetLastError();
11790: if (mem_base != xmlMemBlocks()) {
11791: printf("Leak of %d blocks found in xmlNanoFTPNewCtxt",
11792: xmlMemBlocks() - mem_base);
11793: test_ret++;
11794: printf(" %d", n_URL);
11795: printf("\n");
11796: }
11797: }
11798: function_tests++;
11799: #endif
11800:
11801: return(test_ret);
11802: }
11803:
11804:
11805: static int
11806: test_xmlNanoFTPOpen(void) {
11807: int test_ret = 0;
11808:
11809: #if defined(LIBXML_FTP_ENABLED)
11810: int mem_base;
11811: void * ret_val;
11812: const char * URL; /* the URL to the resource */
11813: int n_URL;
11814:
11815: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
11816: mem_base = xmlMemBlocks();
11817: URL = gen_filepath(n_URL, 0);
11818:
11819: ret_val = xmlNanoFTPOpen(URL);
11820: desret_xmlNanoFTPCtxtPtr(ret_val);
11821: call_tests++;
11822: des_filepath(n_URL, URL, 0);
11823: xmlResetLastError();
11824: if (mem_base != xmlMemBlocks()) {
11825: printf("Leak of %d blocks found in xmlNanoFTPOpen",
11826: xmlMemBlocks() - mem_base);
11827: test_ret++;
11828: printf(" %d", n_URL);
11829: printf("\n");
11830: }
11831: }
11832: function_tests++;
11833: #endif
11834:
11835: return(test_ret);
11836: }
11837:
11838:
11839: static int
11840: test_xmlNanoFTPProxy(void) {
11841: int test_ret = 0;
11842:
11843: #if defined(LIBXML_FTP_ENABLED)
11844: char * host; /* the proxy host name */
11845: int n_host;
11846: int port; /* the proxy port */
11847: int n_port;
11848: char * user; /* the proxy user name */
11849: int n_user;
11850: char * passwd; /* the proxy password */
11851: int n_passwd;
11852: int type; /* the type of proxy 1 for using SITE, 2 for USER a@b */
11853: int n_type;
11854:
11855: for (n_host = 0;n_host < gen_nb_const_char_ptr;n_host++) {
11856: for (n_port = 0;n_port < gen_nb_int;n_port++) {
11857: for (n_user = 0;n_user < gen_nb_const_char_ptr;n_user++) {
11858: for (n_passwd = 0;n_passwd < gen_nb_const_char_ptr;n_passwd++) {
11859: for (n_type = 0;n_type < gen_nb_int;n_type++) {
11860: host = gen_const_char_ptr(n_host, 0);
11861: port = gen_int(n_port, 1);
11862: user = gen_const_char_ptr(n_user, 2);
11863: passwd = gen_const_char_ptr(n_passwd, 3);
11864: type = gen_int(n_type, 4);
11865:
11866: xmlNanoFTPProxy((const char *)host, port, (const char *)user, (const char *)passwd, type);
11867: call_tests++;
11868: des_const_char_ptr(n_host, (const char *)host, 0);
11869: des_int(n_port, port, 1);
11870: des_const_char_ptr(n_user, (const char *)user, 2);
11871: des_const_char_ptr(n_passwd, (const char *)passwd, 3);
11872: des_int(n_type, type, 4);
11873: xmlResetLastError();
11874: }
11875: }
11876: }
11877: }
11878: }
11879: function_tests++;
11880: #endif
11881:
11882: return(test_ret);
11883: }
11884:
11885:
11886: static int
11887: test_xmlNanoFTPQuit(void) {
11888: int test_ret = 0;
11889:
11890: #if defined(LIBXML_FTP_ENABLED)
11891: int mem_base;
11892: int ret_val;
11893: void * ctx; /* an FTP context */
11894: int n_ctx;
11895:
11896: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
11897: mem_base = xmlMemBlocks();
11898: ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
11899:
11900: ret_val = xmlNanoFTPQuit(ctx);
11901: desret_int(ret_val);
11902: call_tests++;
11903: des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
11904: xmlResetLastError();
11905: if (mem_base != xmlMemBlocks()) {
11906: printf("Leak of %d blocks found in xmlNanoFTPQuit",
11907: xmlMemBlocks() - mem_base);
11908: test_ret++;
11909: printf(" %d", n_ctx);
11910: printf("\n");
11911: }
11912: }
11913: function_tests++;
11914: #endif
11915:
11916: return(test_ret);
11917: }
11918:
11919:
11920: static int
11921: test_xmlNanoFTPRead(void) {
11922: int test_ret = 0;
11923:
11924: #if defined(LIBXML_FTP_ENABLED)
11925: int mem_base;
11926: int ret_val;
11927: void * ctx; /* the FTP context */
11928: int n_ctx;
11929: void * dest; /* a buffer */
11930: int n_dest;
11931: int len; /* the buffer length */
11932: int n_len;
11933:
11934: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
11935: for (n_dest = 0;n_dest < gen_nb_void_ptr;n_dest++) {
11936: for (n_len = 0;n_len < gen_nb_int;n_len++) {
11937: mem_base = xmlMemBlocks();
11938: ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
11939: dest = gen_void_ptr(n_dest, 1);
11940: len = gen_int(n_len, 2);
11941:
11942: ret_val = xmlNanoFTPRead(ctx, dest, len);
11943: desret_int(ret_val);
11944: call_tests++;
11945: des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
11946: des_void_ptr(n_dest, dest, 1);
11947: des_int(n_len, len, 2);
11948: xmlResetLastError();
11949: if (mem_base != xmlMemBlocks()) {
11950: printf("Leak of %d blocks found in xmlNanoFTPRead",
11951: xmlMemBlocks() - mem_base);
11952: test_ret++;
11953: printf(" %d", n_ctx);
11954: printf(" %d", n_dest);
11955: printf(" %d", n_len);
11956: printf("\n");
11957: }
11958: }
11959: }
11960: }
11961: function_tests++;
11962: #endif
11963:
11964: return(test_ret);
11965: }
11966:
11967:
11968: static int
11969: test_xmlNanoFTPScanProxy(void) {
11970: int test_ret = 0;
11971:
11972: #if defined(LIBXML_FTP_ENABLED)
11973: const char * URL; /* The proxy URL used to initialize the proxy context */
11974: int n_URL;
11975:
11976: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
11977: URL = gen_filepath(n_URL, 0);
11978:
11979: xmlNanoFTPScanProxy(URL);
11980: call_tests++;
11981: des_filepath(n_URL, URL, 0);
11982: xmlResetLastError();
11983: }
11984: function_tests++;
11985: #endif
11986:
11987: return(test_ret);
11988: }
11989:
11990:
11991: static int
11992: test_xmlNanoFTPUpdateURL(void) {
11993: int test_ret = 0;
11994:
11995: #if defined(LIBXML_FTP_ENABLED)
11996: int mem_base;
11997: int ret_val;
11998: void * ctx; /* an FTP context */
11999: int n_ctx;
12000: const char * URL; /* The URL used to update the context */
12001: int n_URL;
12002:
12003: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
12004: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
12005: mem_base = xmlMemBlocks();
12006: ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
12007: URL = gen_filepath(n_URL, 1);
12008:
12009: ret_val = xmlNanoFTPUpdateURL(ctx, URL);
12010: desret_int(ret_val);
12011: call_tests++;
12012: des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
12013: des_filepath(n_URL, URL, 1);
12014: xmlResetLastError();
12015: if (mem_base != xmlMemBlocks()) {
12016: printf("Leak of %d blocks found in xmlNanoFTPUpdateURL",
12017: xmlMemBlocks() - mem_base);
12018: test_ret++;
12019: printf(" %d", n_ctx);
12020: printf(" %d", n_URL);
12021: printf("\n");
12022: }
12023: }
12024: }
12025: function_tests++;
12026: #endif
12027:
12028: return(test_ret);
12029: }
12030:
12031: static int
12032: test_nanoftp(void) {
12033: int test_ret = 0;
12034:
12035: if (quiet == 0) printf("Testing nanoftp : 14 of 22 functions ...\n");
12036: test_ret += test_xmlNanoFTPCheckResponse();
12037: test_ret += test_xmlNanoFTPCleanup();
12038: test_ret += test_xmlNanoFTPCloseConnection();
12039: test_ret += test_xmlNanoFTPCwd();
12040: test_ret += test_xmlNanoFTPDele();
12041: test_ret += test_xmlNanoFTPGet();
12042: test_ret += test_xmlNanoFTPGetConnection();
12043: test_ret += test_xmlNanoFTPGetResponse();
12044: test_ret += test_xmlNanoFTPGetSocket();
12045: test_ret += test_xmlNanoFTPInit();
12046: test_ret += test_xmlNanoFTPList();
12047: test_ret += test_xmlNanoFTPNewCtxt();
12048: test_ret += test_xmlNanoFTPOpen();
12049: test_ret += test_xmlNanoFTPProxy();
12050: test_ret += test_xmlNanoFTPQuit();
12051: test_ret += test_xmlNanoFTPRead();
12052: test_ret += test_xmlNanoFTPScanProxy();
12053: test_ret += test_xmlNanoFTPUpdateURL();
12054:
12055: if (test_ret != 0)
12056: printf("Module nanoftp: %d errors\n", test_ret);
12057: return(test_ret);
12058: }
12059:
12060: static int
12061: test_xmlNanoHTTPAuthHeader(void) {
12062: int test_ret = 0;
12063:
12064: #if defined(LIBXML_HTTP_ENABLED)
12065: int mem_base;
12066: const char * ret_val;
12067: void * ctx; /* the HTTP context */
12068: int n_ctx;
12069:
12070: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
12071: mem_base = xmlMemBlocks();
12072: ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
12073:
12074: ret_val = xmlNanoHTTPAuthHeader(ctx);
12075: desret_const_char_ptr(ret_val);
12076: call_tests++;
12077: des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
12078: xmlResetLastError();
12079: if (mem_base != xmlMemBlocks()) {
12080: printf("Leak of %d blocks found in xmlNanoHTTPAuthHeader",
12081: xmlMemBlocks() - mem_base);
12082: test_ret++;
12083: printf(" %d", n_ctx);
12084: printf("\n");
12085: }
12086: }
12087: function_tests++;
12088: #endif
12089:
12090: return(test_ret);
12091: }
12092:
12093:
12094: static int
12095: test_xmlNanoHTTPCleanup(void) {
12096: int test_ret = 0;
12097:
12098: #if defined(LIBXML_HTTP_ENABLED)
12099: int mem_base;
12100:
12101: mem_base = xmlMemBlocks();
12102:
12103: xmlNanoHTTPCleanup();
12104: call_tests++;
12105: xmlResetLastError();
12106: if (mem_base != xmlMemBlocks()) {
12107: printf("Leak of %d blocks found in xmlNanoHTTPCleanup",
12108: xmlMemBlocks() - mem_base);
12109: test_ret++;
12110: printf("\n");
12111: }
12112: function_tests++;
12113: #endif
12114:
12115: return(test_ret);
12116: }
12117:
12118:
12119: static int
12120: test_xmlNanoHTTPContentLength(void) {
12121: int test_ret = 0;
12122:
12123: #if defined(LIBXML_HTTP_ENABLED)
12124: int mem_base;
12125: int ret_val;
12126: void * ctx; /* the HTTP context */
12127: int n_ctx;
12128:
12129: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
12130: mem_base = xmlMemBlocks();
12131: ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
12132:
12133: ret_val = xmlNanoHTTPContentLength(ctx);
12134: desret_int(ret_val);
12135: call_tests++;
12136: des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
12137: xmlResetLastError();
12138: if (mem_base != xmlMemBlocks()) {
12139: printf("Leak of %d blocks found in xmlNanoHTTPContentLength",
12140: xmlMemBlocks() - mem_base);
12141: test_ret++;
12142: printf(" %d", n_ctx);
12143: printf("\n");
12144: }
12145: }
12146: function_tests++;
12147: #endif
12148:
12149: return(test_ret);
12150: }
12151:
12152:
12153: static int
12154: test_xmlNanoHTTPEncoding(void) {
12155: int test_ret = 0;
12156:
12157: #if defined(LIBXML_HTTP_ENABLED)
12158: int mem_base;
12159: const char * ret_val;
12160: void * ctx; /* the HTTP context */
12161: int n_ctx;
12162:
12163: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
12164: mem_base = xmlMemBlocks();
12165: ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
12166:
12167: ret_val = xmlNanoHTTPEncoding(ctx);
12168: desret_const_char_ptr(ret_val);
12169: call_tests++;
12170: des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
12171: xmlResetLastError();
12172: if (mem_base != xmlMemBlocks()) {
12173: printf("Leak of %d blocks found in xmlNanoHTTPEncoding",
12174: xmlMemBlocks() - mem_base);
12175: test_ret++;
12176: printf(" %d", n_ctx);
12177: printf("\n");
12178: }
12179: }
12180: function_tests++;
12181: #endif
12182:
12183: return(test_ret);
12184: }
12185:
12186:
12187: #define gen_nb_char_ptr_ptr 1
12188: static char ** gen_char_ptr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
12189: return(NULL);
12190: }
12191: static void des_char_ptr_ptr(int no ATTRIBUTE_UNUSED, char ** val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
12192: }
12193:
12194: static int
12195: test_xmlNanoHTTPFetch(void) {
12196: int test_ret = 0;
12197:
12198: #if defined(LIBXML_HTTP_ENABLED)
12199: int mem_base;
12200: int ret_val;
12201: const char * URL; /* The URL to load */
12202: int n_URL;
12203: const char * filename; /* the filename where the content should be saved */
12204: int n_filename;
12205: char ** contentType; /* if available the Content-Type information will be returned at that location */
12206: int n_contentType;
12207:
12208: for (n_URL = 0;n_URL < gen_nb_fileoutput;n_URL++) {
12209: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
12210: for (n_contentType = 0;n_contentType < gen_nb_char_ptr_ptr;n_contentType++) {
12211: mem_base = xmlMemBlocks();
12212: URL = gen_fileoutput(n_URL, 0);
12213: filename = gen_fileoutput(n_filename, 1);
12214: contentType = gen_char_ptr_ptr(n_contentType, 2);
12215:
12216: ret_val = xmlNanoHTTPFetch(URL, filename, contentType);
12217: desret_int(ret_val);
12218: call_tests++;
12219: des_fileoutput(n_URL, URL, 0);
12220: des_fileoutput(n_filename, filename, 1);
12221: des_char_ptr_ptr(n_contentType, contentType, 2);
12222: xmlResetLastError();
12223: if (mem_base != xmlMemBlocks()) {
12224: printf("Leak of %d blocks found in xmlNanoHTTPFetch",
12225: xmlMemBlocks() - mem_base);
12226: test_ret++;
12227: printf(" %d", n_URL);
12228: printf(" %d", n_filename);
12229: printf(" %d", n_contentType);
12230: printf("\n");
12231: }
12232: }
12233: }
12234: }
12235: function_tests++;
12236: #endif
12237:
12238: return(test_ret);
12239: }
12240:
12241:
12242: static int
12243: test_xmlNanoHTTPInit(void) {
12244: int test_ret = 0;
12245:
12246: #if defined(LIBXML_HTTP_ENABLED)
12247: int mem_base;
12248:
12249: mem_base = xmlMemBlocks();
12250:
12251: xmlNanoHTTPInit();
12252: call_tests++;
12253: xmlResetLastError();
12254: if (mem_base != xmlMemBlocks()) {
12255: printf("Leak of %d blocks found in xmlNanoHTTPInit",
12256: xmlMemBlocks() - mem_base);
12257: test_ret++;
12258: printf("\n");
12259: }
12260: function_tests++;
12261: #endif
12262:
12263: return(test_ret);
12264: }
12265:
12266:
12267: static int
12268: test_xmlNanoHTTPMimeType(void) {
12269: int test_ret = 0;
12270:
12271: #if defined(LIBXML_HTTP_ENABLED)
12272: int mem_base;
12273: const char * ret_val;
12274: void * ctx; /* the HTTP context */
12275: int n_ctx;
12276:
12277: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
12278: mem_base = xmlMemBlocks();
12279: ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
12280:
12281: ret_val = xmlNanoHTTPMimeType(ctx);
12282: desret_const_char_ptr(ret_val);
12283: call_tests++;
12284: des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
12285: xmlResetLastError();
12286: if (mem_base != xmlMemBlocks()) {
12287: printf("Leak of %d blocks found in xmlNanoHTTPMimeType",
12288: xmlMemBlocks() - mem_base);
12289: test_ret++;
12290: printf(" %d", n_ctx);
12291: printf("\n");
12292: }
12293: }
12294: function_tests++;
12295: #endif
12296:
12297: return(test_ret);
12298: }
12299:
12300:
12301: static int
12302: test_xmlNanoHTTPOpen(void) {
12303: int test_ret = 0;
12304:
12305: #if defined(LIBXML_HTTP_ENABLED)
12306: int mem_base;
12307: void * ret_val;
12308: const char * URL; /* The URL to load */
12309: int n_URL;
12310: char ** contentType; /* if available the Content-Type information will be returned at that location */
12311: int n_contentType;
12312:
12313: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
12314: for (n_contentType = 0;n_contentType < gen_nb_char_ptr_ptr;n_contentType++) {
12315: mem_base = xmlMemBlocks();
12316: URL = gen_filepath(n_URL, 0);
12317: contentType = gen_char_ptr_ptr(n_contentType, 1);
12318:
12319: ret_val = xmlNanoHTTPOpen(URL, contentType);
12320: desret_xmlNanoHTTPCtxtPtr(ret_val);
12321: call_tests++;
12322: des_filepath(n_URL, URL, 0);
12323: des_char_ptr_ptr(n_contentType, contentType, 1);
12324: xmlResetLastError();
12325: if (mem_base != xmlMemBlocks()) {
12326: printf("Leak of %d blocks found in xmlNanoHTTPOpen",
12327: xmlMemBlocks() - mem_base);
12328: test_ret++;
12329: printf(" %d", n_URL);
12330: printf(" %d", n_contentType);
12331: printf("\n");
12332: }
12333: }
12334: }
12335: function_tests++;
12336: #endif
12337:
12338: return(test_ret);
12339: }
12340:
12341:
12342: static int
12343: test_xmlNanoHTTPOpenRedir(void) {
12344: int test_ret = 0;
12345:
12346: #if defined(LIBXML_HTTP_ENABLED)
12347: int mem_base;
12348: void * ret_val;
12349: const char * URL; /* The URL to load */
12350: int n_URL;
12351: char ** contentType; /* if available the Content-Type information will be returned at that location */
12352: int n_contentType;
12353: char ** redir; /* if available the redirected URL will be returned */
12354: int n_redir;
12355:
12356: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
12357: for (n_contentType = 0;n_contentType < gen_nb_char_ptr_ptr;n_contentType++) {
12358: for (n_redir = 0;n_redir < gen_nb_char_ptr_ptr;n_redir++) {
12359: mem_base = xmlMemBlocks();
12360: URL = gen_filepath(n_URL, 0);
12361: contentType = gen_char_ptr_ptr(n_contentType, 1);
12362: redir = gen_char_ptr_ptr(n_redir, 2);
12363:
12364: ret_val = xmlNanoHTTPOpenRedir(URL, contentType, redir);
12365: desret_xmlNanoHTTPCtxtPtr(ret_val);
12366: call_tests++;
12367: des_filepath(n_URL, URL, 0);
12368: des_char_ptr_ptr(n_contentType, contentType, 1);
12369: des_char_ptr_ptr(n_redir, redir, 2);
12370: xmlResetLastError();
12371: if (mem_base != xmlMemBlocks()) {
12372: printf("Leak of %d blocks found in xmlNanoHTTPOpenRedir",
12373: xmlMemBlocks() - mem_base);
12374: test_ret++;
12375: printf(" %d", n_URL);
12376: printf(" %d", n_contentType);
12377: printf(" %d", n_redir);
12378: printf("\n");
12379: }
12380: }
12381: }
12382: }
12383: function_tests++;
12384: #endif
12385:
12386: return(test_ret);
12387: }
12388:
12389:
12390: static int
12391: test_xmlNanoHTTPRead(void) {
12392: int test_ret = 0;
12393:
12394: #if defined(LIBXML_HTTP_ENABLED)
12395: int mem_base;
12396: int ret_val;
12397: void * ctx; /* the HTTP context */
12398: int n_ctx;
12399: void * dest; /* a buffer */
12400: int n_dest;
12401: int len; /* the buffer length */
12402: int n_len;
12403:
12404: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
12405: for (n_dest = 0;n_dest < gen_nb_void_ptr;n_dest++) {
12406: for (n_len = 0;n_len < gen_nb_int;n_len++) {
12407: mem_base = xmlMemBlocks();
12408: ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
12409: dest = gen_void_ptr(n_dest, 1);
12410: len = gen_int(n_len, 2);
12411:
12412: ret_val = xmlNanoHTTPRead(ctx, dest, len);
12413: desret_int(ret_val);
12414: call_tests++;
12415: des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
12416: des_void_ptr(n_dest, dest, 1);
12417: des_int(n_len, len, 2);
12418: xmlResetLastError();
12419: if (mem_base != xmlMemBlocks()) {
12420: printf("Leak of %d blocks found in xmlNanoHTTPRead",
12421: xmlMemBlocks() - mem_base);
12422: test_ret++;
12423: printf(" %d", n_ctx);
12424: printf(" %d", n_dest);
12425: printf(" %d", n_len);
12426: printf("\n");
12427: }
12428: }
12429: }
12430: }
12431: function_tests++;
12432: #endif
12433:
12434: return(test_ret);
12435: }
12436:
12437:
12438: static int
12439: test_xmlNanoHTTPRedir(void) {
12440: int test_ret = 0;
12441:
12442:
12443: /* missing type support */
12444: return(test_ret);
12445: }
12446:
12447:
12448: static int
12449: test_xmlNanoHTTPReturnCode(void) {
12450: int test_ret = 0;
12451:
12452: #if defined(LIBXML_HTTP_ENABLED)
12453: int mem_base;
12454: int ret_val;
12455: void * ctx; /* the HTTP context */
12456: int n_ctx;
12457:
12458: for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
12459: mem_base = xmlMemBlocks();
12460: ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
12461:
12462: ret_val = xmlNanoHTTPReturnCode(ctx);
12463: desret_int(ret_val);
12464: call_tests++;
12465: des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
12466: xmlResetLastError();
12467: if (mem_base != xmlMemBlocks()) {
12468: printf("Leak of %d blocks found in xmlNanoHTTPReturnCode",
12469: xmlMemBlocks() - mem_base);
12470: test_ret++;
12471: printf(" %d", n_ctx);
12472: printf("\n");
12473: }
12474: }
12475: function_tests++;
12476: #endif
12477:
12478: return(test_ret);
12479: }
12480:
12481:
12482: static int
12483: test_xmlNanoHTTPSave(void) {
12484: int test_ret = 0;
12485:
12486: #if defined(LIBXML_HTTP_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
12487: int mem_base;
12488: int ret_val;
12489: void * ctxt; /* the HTTP context */
12490: int n_ctxt;
12491: const char * filename; /* the filename where the content should be saved */
12492: int n_filename;
12493:
12494: for (n_ctxt = 0;n_ctxt < gen_nb_void_ptr;n_ctxt++) {
12495: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
12496: mem_base = xmlMemBlocks();
12497: ctxt = gen_void_ptr(n_ctxt, 0);
12498: filename = gen_fileoutput(n_filename, 1);
12499:
12500: ret_val = xmlNanoHTTPSave(ctxt, filename);
12501: desret_int(ret_val);
12502: call_tests++;
12503: des_void_ptr(n_ctxt, ctxt, 0);
12504: des_fileoutput(n_filename, filename, 1);
12505: xmlResetLastError();
12506: if (mem_base != xmlMemBlocks()) {
12507: printf("Leak of %d blocks found in xmlNanoHTTPSave",
12508: xmlMemBlocks() - mem_base);
12509: test_ret++;
12510: printf(" %d", n_ctxt);
12511: printf(" %d", n_filename);
12512: printf("\n");
12513: }
12514: }
12515: }
12516: function_tests++;
12517: #endif
12518:
12519: return(test_ret);
12520: }
12521:
12522:
12523: static int
12524: test_xmlNanoHTTPScanProxy(void) {
12525: int test_ret = 0;
12526:
12527: #if defined(LIBXML_HTTP_ENABLED)
12528: const char * URL; /* The proxy URL used to initialize the proxy context */
12529: int n_URL;
12530:
12531: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
12532: URL = gen_filepath(n_URL, 0);
12533:
12534: xmlNanoHTTPScanProxy(URL);
12535: call_tests++;
12536: des_filepath(n_URL, URL, 0);
12537: xmlResetLastError();
12538: }
12539: function_tests++;
12540: #endif
12541:
12542: return(test_ret);
12543: }
12544:
12545: static int
12546: test_nanohttp(void) {
12547: int test_ret = 0;
12548:
12549: if (quiet == 0) printf("Testing nanohttp : 13 of 17 functions ...\n");
12550: test_ret += test_xmlNanoHTTPAuthHeader();
12551: test_ret += test_xmlNanoHTTPCleanup();
12552: test_ret += test_xmlNanoHTTPContentLength();
12553: test_ret += test_xmlNanoHTTPEncoding();
12554: test_ret += test_xmlNanoHTTPFetch();
12555: test_ret += test_xmlNanoHTTPInit();
12556: test_ret += test_xmlNanoHTTPMimeType();
12557: test_ret += test_xmlNanoHTTPOpen();
12558: test_ret += test_xmlNanoHTTPOpenRedir();
12559: test_ret += test_xmlNanoHTTPRead();
12560: test_ret += test_xmlNanoHTTPRedir();
12561: test_ret += test_xmlNanoHTTPReturnCode();
12562: test_ret += test_xmlNanoHTTPSave();
12563: test_ret += test_xmlNanoHTTPScanProxy();
12564:
12565: if (test_ret != 0)
12566: printf("Module nanohttp: %d errors\n", test_ret);
12567: return(test_ret);
12568: }
12569:
12570: static int
12571: test_xmlByteConsumed(void) {
12572: int test_ret = 0;
12573:
12574: int mem_base;
12575: long ret_val;
12576: xmlParserCtxtPtr ctxt; /* an XML parser context */
12577: int n_ctxt;
12578:
12579: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
12580: mem_base = xmlMemBlocks();
12581: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
12582:
12583: ret_val = xmlByteConsumed(ctxt);
12584: desret_long(ret_val);
12585: call_tests++;
12586: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
12587: xmlResetLastError();
12588: if (mem_base != xmlMemBlocks()) {
12589: printf("Leak of %d blocks found in xmlByteConsumed",
12590: xmlMemBlocks() - mem_base);
12591: test_ret++;
12592: printf(" %d", n_ctxt);
12593: printf("\n");
12594: }
12595: }
12596: function_tests++;
12597:
12598: return(test_ret);
12599: }
12600:
12601:
12602: static int
12603: test_xmlClearNodeInfoSeq(void) {
12604: int test_ret = 0;
12605:
12606: int mem_base;
12607: xmlParserNodeInfoSeqPtr seq; /* a node info sequence pointer */
12608: int n_seq;
12609:
12610: for (n_seq = 0;n_seq < gen_nb_xmlParserNodeInfoSeqPtr;n_seq++) {
12611: mem_base = xmlMemBlocks();
12612: seq = gen_xmlParserNodeInfoSeqPtr(n_seq, 0);
12613:
12614: xmlClearNodeInfoSeq(seq);
12615: call_tests++;
12616: des_xmlParserNodeInfoSeqPtr(n_seq, seq, 0);
12617: xmlResetLastError();
12618: if (mem_base != xmlMemBlocks()) {
12619: printf("Leak of %d blocks found in xmlClearNodeInfoSeq",
12620: xmlMemBlocks() - mem_base);
12621: test_ret++;
12622: printf(" %d", n_seq);
12623: printf("\n");
12624: }
12625: }
12626: function_tests++;
12627:
12628: return(test_ret);
12629: }
12630:
12631:
12632: static int
12633: test_xmlClearParserCtxt(void) {
12634: int test_ret = 0;
12635:
12636: int mem_base;
12637: xmlParserCtxtPtr ctxt; /* an XML parser context */
12638: int n_ctxt;
12639:
12640: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
12641: mem_base = xmlMemBlocks();
12642: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
12643:
12644: xmlClearParserCtxt(ctxt);
12645: call_tests++;
12646: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
12647: xmlResetLastError();
12648: if (mem_base != xmlMemBlocks()) {
12649: printf("Leak of %d blocks found in xmlClearParserCtxt",
12650: xmlMemBlocks() - mem_base);
12651: test_ret++;
12652: printf(" %d", n_ctxt);
12653: printf("\n");
12654: }
12655: }
12656: function_tests++;
12657:
12658: return(test_ret);
12659: }
12660:
12661:
12662: static int
12663: test_xmlCreateDocParserCtxt(void) {
12664: int test_ret = 0;
12665:
12666: int mem_base;
12667: xmlParserCtxtPtr ret_val;
12668: xmlChar * cur; /* a pointer to an array of xmlChar */
12669: int n_cur;
12670:
12671: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
12672: mem_base = xmlMemBlocks();
12673: cur = gen_const_xmlChar_ptr(n_cur, 0);
12674:
12675: ret_val = xmlCreateDocParserCtxt((const xmlChar *)cur);
12676: desret_xmlParserCtxtPtr(ret_val);
12677: call_tests++;
12678: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
12679: xmlResetLastError();
12680: if (mem_base != xmlMemBlocks()) {
12681: printf("Leak of %d blocks found in xmlCreateDocParserCtxt",
12682: xmlMemBlocks() - mem_base);
12683: test_ret++;
12684: printf(" %d", n_cur);
12685: printf("\n");
12686: }
12687: }
12688: function_tests++;
12689:
12690: return(test_ret);
12691: }
12692:
12693:
12694: static int
12695: test_xmlCreatePushParserCtxt(void) {
12696: int test_ret = 0;
12697:
12698: #if defined(LIBXML_PUSH_ENABLED)
12699: int mem_base;
12700: xmlParserCtxtPtr ret_val;
12701: xmlSAXHandlerPtr sax; /* a SAX handler */
12702: int n_sax;
12703: void * user_data; /* The user data returned on SAX callbacks */
12704: int n_user_data;
12705: char * chunk; /* a pointer to an array of chars */
12706: int n_chunk;
12707: int size; /* number of chars in the array */
12708: int n_size;
12709: const char * filename; /* an optional file name or URI */
12710: int n_filename;
12711:
12712: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
12713: for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
12714: for (n_chunk = 0;n_chunk < gen_nb_const_char_ptr;n_chunk++) {
12715: for (n_size = 0;n_size < gen_nb_int;n_size++) {
12716: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
12717: mem_base = xmlMemBlocks();
12718: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
12719: user_data = gen_userdata(n_user_data, 1);
12720: chunk = gen_const_char_ptr(n_chunk, 2);
12721: size = gen_int(n_size, 3);
12722: filename = gen_fileoutput(n_filename, 4);
12723:
12724: ret_val = xmlCreatePushParserCtxt(sax, user_data, (const char *)chunk, size, filename);
12725: desret_xmlParserCtxtPtr(ret_val);
12726: call_tests++;
12727: des_xmlSAXHandlerPtr(n_sax, sax, 0);
12728: des_userdata(n_user_data, user_data, 1);
12729: des_const_char_ptr(n_chunk, (const char *)chunk, 2);
12730: des_int(n_size, size, 3);
12731: des_fileoutput(n_filename, filename, 4);
12732: xmlResetLastError();
12733: if (mem_base != xmlMemBlocks()) {
12734: printf("Leak of %d blocks found in xmlCreatePushParserCtxt",
12735: xmlMemBlocks() - mem_base);
12736: test_ret++;
12737: printf(" %d", n_sax);
12738: printf(" %d", n_user_data);
12739: printf(" %d", n_chunk);
12740: printf(" %d", n_size);
12741: printf(" %d", n_filename);
12742: printf("\n");
12743: }
12744: }
12745: }
12746: }
12747: }
12748: }
12749: function_tests++;
12750: #endif
12751:
12752: return(test_ret);
12753: }
12754:
12755:
12756: static int
12757: test_xmlCtxtReadDoc(void) {
12758: int test_ret = 0;
12759:
12760: int mem_base;
12761: xmlDocPtr ret_val;
12762: xmlParserCtxtPtr ctxt; /* an XML parser context */
12763: int n_ctxt;
12764: xmlChar * cur; /* a pointer to a zero terminated string */
12765: int n_cur;
12766: const char * URL; /* the base URL to use for the document */
12767: int n_URL;
12768: char * encoding; /* the document encoding, or NULL */
12769: int n_encoding;
12770: int options; /* a combination of xmlParserOption */
12771: int n_options;
12772:
12773: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
12774: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
12775: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
12776: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
12777: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
12778: mem_base = xmlMemBlocks();
12779: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
12780: cur = gen_const_xmlChar_ptr(n_cur, 1);
12781: URL = gen_filepath(n_URL, 2);
12782: encoding = gen_const_char_ptr(n_encoding, 3);
12783: options = gen_parseroptions(n_options, 4);
12784:
12785: ret_val = xmlCtxtReadDoc(ctxt, (const xmlChar *)cur, URL, (const char *)encoding, options);
12786: desret_xmlDocPtr(ret_val);
12787: call_tests++;
12788: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
12789: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 1);
12790: des_filepath(n_URL, URL, 2);
12791: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
12792: des_parseroptions(n_options, options, 4);
12793: xmlResetLastError();
12794: if (mem_base != xmlMemBlocks()) {
12795: printf("Leak of %d blocks found in xmlCtxtReadDoc",
12796: xmlMemBlocks() - mem_base);
12797: test_ret++;
12798: printf(" %d", n_ctxt);
12799: printf(" %d", n_cur);
12800: printf(" %d", n_URL);
12801: printf(" %d", n_encoding);
12802: printf(" %d", n_options);
12803: printf("\n");
12804: }
12805: }
12806: }
12807: }
12808: }
12809: }
12810: function_tests++;
12811:
12812: return(test_ret);
12813: }
12814:
12815:
12816: static int
12817: test_xmlCtxtReadFile(void) {
12818: int test_ret = 0;
12819:
12820: int mem_base;
12821: xmlDocPtr ret_val;
12822: xmlParserCtxtPtr ctxt; /* an XML parser context */
12823: int n_ctxt;
12824: const char * filename; /* a file or URL */
12825: int n_filename;
12826: char * encoding; /* the document encoding, or NULL */
12827: int n_encoding;
12828: int options; /* a combination of xmlParserOption */
12829: int n_options;
12830:
12831: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
12832: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
12833: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
12834: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
12835: mem_base = xmlMemBlocks();
12836: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
12837: filename = gen_filepath(n_filename, 1);
12838: encoding = gen_const_char_ptr(n_encoding, 2);
12839: options = gen_parseroptions(n_options, 3);
12840:
12841: ret_val = xmlCtxtReadFile(ctxt, filename, (const char *)encoding, options);
12842: desret_xmlDocPtr(ret_val);
12843: call_tests++;
12844: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
12845: des_filepath(n_filename, filename, 1);
12846: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
12847: des_parseroptions(n_options, options, 3);
12848: xmlResetLastError();
12849: if (mem_base != xmlMemBlocks()) {
12850: printf("Leak of %d blocks found in xmlCtxtReadFile",
12851: xmlMemBlocks() - mem_base);
12852: test_ret++;
12853: printf(" %d", n_ctxt);
12854: printf(" %d", n_filename);
12855: printf(" %d", n_encoding);
12856: printf(" %d", n_options);
12857: printf("\n");
12858: }
12859: }
12860: }
12861: }
12862: }
12863: function_tests++;
12864:
12865: return(test_ret);
12866: }
12867:
12868:
12869: static int
12870: test_xmlCtxtReadMemory(void) {
12871: int test_ret = 0;
12872:
12873: int mem_base;
12874: xmlDocPtr ret_val;
12875: xmlParserCtxtPtr ctxt; /* an XML parser context */
12876: int n_ctxt;
12877: char * buffer; /* a pointer to a char array */
12878: int n_buffer;
12879: int size; /* the size of the array */
12880: int n_size;
12881: const char * URL; /* the base URL to use for the document */
12882: int n_URL;
12883: char * encoding; /* the document encoding, or NULL */
12884: int n_encoding;
12885: int options; /* a combination of xmlParserOption */
12886: int n_options;
12887:
12888: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
12889: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
12890: for (n_size = 0;n_size < gen_nb_int;n_size++) {
12891: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
12892: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
12893: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
12894: mem_base = xmlMemBlocks();
12895: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
12896: buffer = gen_const_char_ptr(n_buffer, 1);
12897: size = gen_int(n_size, 2);
12898: URL = gen_filepath(n_URL, 3);
12899: encoding = gen_const_char_ptr(n_encoding, 4);
12900: options = gen_parseroptions(n_options, 5);
12901:
12902: ret_val = xmlCtxtReadMemory(ctxt, (const char *)buffer, size, URL, (const char *)encoding, options);
12903: desret_xmlDocPtr(ret_val);
12904: call_tests++;
12905: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
12906: des_const_char_ptr(n_buffer, (const char *)buffer, 1);
12907: des_int(n_size, size, 2);
12908: des_filepath(n_URL, URL, 3);
12909: des_const_char_ptr(n_encoding, (const char *)encoding, 4);
12910: des_parseroptions(n_options, options, 5);
12911: xmlResetLastError();
12912: if (mem_base != xmlMemBlocks()) {
12913: printf("Leak of %d blocks found in xmlCtxtReadMemory",
12914: xmlMemBlocks() - mem_base);
12915: test_ret++;
12916: printf(" %d", n_ctxt);
12917: printf(" %d", n_buffer);
12918: printf(" %d", n_size);
12919: printf(" %d", n_URL);
12920: printf(" %d", n_encoding);
12921: printf(" %d", n_options);
12922: printf("\n");
12923: }
12924: }
12925: }
12926: }
12927: }
12928: }
12929: }
12930: function_tests++;
12931:
12932: return(test_ret);
12933: }
12934:
12935:
12936: static int
12937: test_xmlCtxtReset(void) {
12938: int test_ret = 0;
12939:
12940: int mem_base;
12941: xmlParserCtxtPtr ctxt; /* an XML parser context */
12942: int n_ctxt;
12943:
12944: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
12945: mem_base = xmlMemBlocks();
12946: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
12947:
12948: xmlCtxtReset(ctxt);
12949: call_tests++;
12950: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
12951: xmlResetLastError();
12952: if (mem_base != xmlMemBlocks()) {
12953: printf("Leak of %d blocks found in xmlCtxtReset",
12954: xmlMemBlocks() - mem_base);
12955: test_ret++;
12956: printf(" %d", n_ctxt);
12957: printf("\n");
12958: }
12959: }
12960: function_tests++;
12961:
12962: return(test_ret);
12963: }
12964:
12965:
12966: static int
12967: test_xmlCtxtResetPush(void) {
12968: int test_ret = 0;
12969:
12970: int mem_base;
12971: int ret_val;
12972: xmlParserCtxtPtr ctxt; /* an XML parser context */
12973: int n_ctxt;
12974: char * chunk; /* a pointer to an array of chars */
12975: int n_chunk;
12976: int size; /* number of chars in the array */
12977: int n_size;
12978: const char * filename; /* an optional file name or URI */
12979: int n_filename;
12980: char * encoding; /* the document encoding, or NULL */
12981: int n_encoding;
12982:
12983: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
12984: for (n_chunk = 0;n_chunk < gen_nb_const_char_ptr;n_chunk++) {
12985: for (n_size = 0;n_size < gen_nb_int;n_size++) {
12986: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
12987: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
12988: mem_base = xmlMemBlocks();
12989: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
12990: chunk = gen_const_char_ptr(n_chunk, 1);
12991: size = gen_int(n_size, 2);
12992: filename = gen_filepath(n_filename, 3);
12993: encoding = gen_const_char_ptr(n_encoding, 4);
12994:
12995: ret_val = xmlCtxtResetPush(ctxt, (const char *)chunk, size, filename, (const char *)encoding);
12996: desret_int(ret_val);
12997: call_tests++;
12998: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
12999: des_const_char_ptr(n_chunk, (const char *)chunk, 1);
13000: des_int(n_size, size, 2);
13001: des_filepath(n_filename, filename, 3);
13002: des_const_char_ptr(n_encoding, (const char *)encoding, 4);
13003: xmlResetLastError();
13004: if (mem_base != xmlMemBlocks()) {
13005: printf("Leak of %d blocks found in xmlCtxtResetPush",
13006: xmlMemBlocks() - mem_base);
13007: test_ret++;
13008: printf(" %d", n_ctxt);
13009: printf(" %d", n_chunk);
13010: printf(" %d", n_size);
13011: printf(" %d", n_filename);
13012: printf(" %d", n_encoding);
13013: printf("\n");
13014: }
13015: }
13016: }
13017: }
13018: }
13019: }
13020: function_tests++;
13021:
13022: return(test_ret);
13023: }
13024:
13025:
13026: static int
13027: test_xmlCtxtUseOptions(void) {
13028: int test_ret = 0;
13029:
13030: int mem_base;
13031: int ret_val;
13032: xmlParserCtxtPtr ctxt; /* an XML parser context */
13033: int n_ctxt;
13034: int options; /* a combination of xmlParserOption */
13035: int n_options;
13036:
13037: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
13038: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
13039: mem_base = xmlMemBlocks();
13040: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
13041: options = gen_parseroptions(n_options, 1);
13042:
13043: ret_val = xmlCtxtUseOptions(ctxt, options);
13044: desret_int(ret_val);
13045: call_tests++;
13046: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
13047: des_parseroptions(n_options, options, 1);
13048: xmlResetLastError();
13049: if (mem_base != xmlMemBlocks()) {
13050: printf("Leak of %d blocks found in xmlCtxtUseOptions",
13051: xmlMemBlocks() - mem_base);
13052: test_ret++;
13053: printf(" %d", n_ctxt);
13054: printf(" %d", n_options);
13055: printf("\n");
13056: }
13057: }
13058: }
13059: function_tests++;
13060:
13061: return(test_ret);
13062: }
13063:
13064:
13065: static int
13066: test_xmlGetExternalEntityLoader(void) {
13067: int test_ret = 0;
13068:
13069:
13070: /* missing type support */
13071: return(test_ret);
13072: }
13073:
13074:
13075: static int
13076: test_xmlGetFeature(void) {
13077: int test_ret = 0;
13078:
13079: #if defined(LIBXML_LEGACY_ENABLED)
13080: #ifdef LIBXML_LEGACY_ENABLED
13081: int mem_base;
13082: int ret_val;
13083: xmlParserCtxtPtr ctxt; /* an XML/HTML parser context */
13084: int n_ctxt;
13085: char * name; /* the feature name */
13086: int n_name;
13087: void * result; /* location to store the result */
13088: int n_result;
13089:
13090: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
13091: for (n_name = 0;n_name < gen_nb_const_char_ptr;n_name++) {
13092: for (n_result = 0;n_result < gen_nb_void_ptr;n_result++) {
13093: mem_base = xmlMemBlocks();
13094: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
13095: name = gen_const_char_ptr(n_name, 1);
13096: result = gen_void_ptr(n_result, 2);
13097:
13098: ret_val = xmlGetFeature(ctxt, (const char *)name, result);
13099: desret_int(ret_val);
13100: call_tests++;
13101: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
13102: des_const_char_ptr(n_name, (const char *)name, 1);
13103: des_void_ptr(n_result, result, 2);
13104: xmlResetLastError();
13105: if (mem_base != xmlMemBlocks()) {
13106: printf("Leak of %d blocks found in xmlGetFeature",
13107: xmlMemBlocks() - mem_base);
13108: test_ret++;
13109: printf(" %d", n_ctxt);
13110: printf(" %d", n_name);
13111: printf(" %d", n_result);
13112: printf("\n");
13113: }
13114: }
13115: }
13116: }
13117: function_tests++;
13118: #endif
13119: #endif
13120:
13121: return(test_ret);
13122: }
13123:
13124:
13125: #define gen_nb_const_char_ptr_ptr 1
13126: static char ** gen_const_char_ptr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
13127: return(NULL);
13128: }
13129: static void des_const_char_ptr_ptr(int no ATTRIBUTE_UNUSED, const char ** val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
13130: }
13131:
13132: static int
13133: test_xmlGetFeaturesList(void) {
13134: int test_ret = 0;
13135:
13136: #if defined(LIBXML_LEGACY_ENABLED)
13137: #ifdef LIBXML_LEGACY_ENABLED
13138: int mem_base;
13139: int ret_val;
13140: int * len; /* the length of the features name array (input/output) */
13141: int n_len;
13142: char ** result; /* an array of string to be filled with the features name. */
13143: int n_result;
13144:
13145: for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
13146: for (n_result = 0;n_result < gen_nb_const_char_ptr_ptr;n_result++) {
13147: mem_base = xmlMemBlocks();
13148: len = gen_int_ptr(n_len, 0);
13149: result = gen_const_char_ptr_ptr(n_result, 1);
13150:
13151: ret_val = xmlGetFeaturesList(len, (const char **)result);
13152: desret_int(ret_val);
13153: call_tests++;
13154: des_int_ptr(n_len, len, 0);
13155: des_const_char_ptr_ptr(n_result, (const char **)result, 1);
13156: xmlResetLastError();
13157: if (mem_base != xmlMemBlocks()) {
13158: printf("Leak of %d blocks found in xmlGetFeaturesList",
13159: xmlMemBlocks() - mem_base);
13160: test_ret++;
13161: printf(" %d", n_len);
13162: printf(" %d", n_result);
13163: printf("\n");
13164: }
13165: }
13166: }
13167: function_tests++;
13168: #endif
13169: #endif
13170:
13171: return(test_ret);
13172: }
13173:
13174:
13175: static int
13176: test_xmlHasFeature(void) {
13177: int test_ret = 0;
13178:
13179: int mem_base;
13180: int ret_val;
13181: xmlFeature feature; /* the feature to be examined */
13182: int n_feature;
13183:
13184: for (n_feature = 0;n_feature < gen_nb_xmlFeature;n_feature++) {
13185: mem_base = xmlMemBlocks();
13186: feature = gen_xmlFeature(n_feature, 0);
13187:
13188: ret_val = xmlHasFeature(feature);
13189: desret_int(ret_val);
13190: call_tests++;
13191: des_xmlFeature(n_feature, feature, 0);
13192: xmlResetLastError();
13193: if (mem_base != xmlMemBlocks()) {
13194: printf("Leak of %d blocks found in xmlHasFeature",
13195: xmlMemBlocks() - mem_base);
13196: test_ret++;
13197: printf(" %d", n_feature);
13198: printf("\n");
13199: }
13200: }
13201: function_tests++;
13202:
13203: return(test_ret);
13204: }
13205:
13206:
13207: static int
13208: test_xmlIOParseDTD(void) {
13209: int test_ret = 0;
13210:
13211: #if defined(LIBXML_VALID_ENABLED)
13212: #ifdef LIBXML_VALID_ENABLED
13213: xmlDtdPtr ret_val;
13214: xmlSAXHandlerPtr sax; /* the SAX handler block or NULL */
13215: int n_sax;
13216: xmlParserInputBufferPtr input; /* an Input Buffer */
13217: int n_input;
13218: xmlCharEncoding enc; /* the charset encoding if known */
13219: int n_enc;
13220:
13221: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
13222: for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) {
13223: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
13224: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
13225: input = gen_xmlParserInputBufferPtr(n_input, 1);
13226: enc = gen_xmlCharEncoding(n_enc, 2);
13227:
13228: ret_val = xmlIOParseDTD(sax, input, enc);
13229: input = NULL;
13230: desret_xmlDtdPtr(ret_val);
13231: call_tests++;
13232: des_xmlSAXHandlerPtr(n_sax, sax, 0);
13233: des_xmlParserInputBufferPtr(n_input, input, 1);
13234: des_xmlCharEncoding(n_enc, enc, 2);
13235: xmlResetLastError();
13236: }
13237: }
13238: }
13239: function_tests++;
13240: #endif
13241: #endif
13242:
13243: return(test_ret);
13244: }
13245:
13246:
13247: static int
13248: test_xmlInitNodeInfoSeq(void) {
13249: int test_ret = 0;
13250:
13251: int mem_base;
13252: xmlParserNodeInfoSeqPtr seq; /* a node info sequence pointer */
13253: int n_seq;
13254:
13255: for (n_seq = 0;n_seq < gen_nb_xmlParserNodeInfoSeqPtr;n_seq++) {
13256: mem_base = xmlMemBlocks();
13257: seq = gen_xmlParserNodeInfoSeqPtr(n_seq, 0);
13258:
13259: xmlInitNodeInfoSeq(seq);
13260: call_tests++;
13261: des_xmlParserNodeInfoSeqPtr(n_seq, seq, 0);
13262: xmlResetLastError();
13263: if (mem_base != xmlMemBlocks()) {
13264: printf("Leak of %d blocks found in xmlInitNodeInfoSeq",
13265: xmlMemBlocks() - mem_base);
13266: test_ret++;
13267: printf(" %d", n_seq);
13268: printf("\n");
13269: }
13270: }
13271: function_tests++;
13272:
13273: return(test_ret);
13274: }
13275:
13276:
13277: static int
13278: test_xmlInitParser(void) {
13279: int test_ret = 0;
13280:
13281: int mem_base;
13282:
13283: mem_base = xmlMemBlocks();
13284:
13285: xmlInitParser();
13286: call_tests++;
13287: xmlResetLastError();
13288: if (mem_base != xmlMemBlocks()) {
13289: printf("Leak of %d blocks found in xmlInitParser",
13290: xmlMemBlocks() - mem_base);
13291: test_ret++;
13292: printf("\n");
13293: }
13294: function_tests++;
13295:
13296: return(test_ret);
13297: }
13298:
13299:
13300: static int
13301: test_xmlInitParserCtxt(void) {
13302: int test_ret = 0;
13303:
13304: int mem_base;
13305: int ret_val;
13306: xmlParserCtxtPtr ctxt; /* an XML parser context */
13307: int n_ctxt;
13308:
13309: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
13310: mem_base = xmlMemBlocks();
13311: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
13312:
13313: ret_val = xmlInitParserCtxt(ctxt);
13314: desret_int(ret_val);
13315: call_tests++;
13316: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
13317: xmlResetLastError();
13318: if (mem_base != xmlMemBlocks()) {
13319: printf("Leak of %d blocks found in xmlInitParserCtxt",
13320: xmlMemBlocks() - mem_base);
13321: test_ret++;
13322: printf(" %d", n_ctxt);
13323: printf("\n");
13324: }
13325: }
13326: function_tests++;
13327:
13328: return(test_ret);
13329: }
13330:
13331:
13332: static int
13333: test_xmlKeepBlanksDefault(void) {
13334: int test_ret = 0;
13335:
13336: int mem_base;
13337: int ret_val;
13338: int val; /* int 0 or 1 */
13339: int n_val;
13340:
13341: for (n_val = 0;n_val < gen_nb_int;n_val++) {
13342: mem_base = xmlMemBlocks();
13343: val = gen_int(n_val, 0);
13344:
13345: ret_val = xmlKeepBlanksDefault(val);
13346: desret_int(ret_val);
13347: call_tests++;
13348: des_int(n_val, val, 0);
13349: xmlResetLastError();
13350: if (mem_base != xmlMemBlocks()) {
13351: printf("Leak of %d blocks found in xmlKeepBlanksDefault",
13352: xmlMemBlocks() - mem_base);
13353: test_ret++;
13354: printf(" %d", n_val);
13355: printf("\n");
13356: }
13357: }
13358: function_tests++;
13359:
13360: return(test_ret);
13361: }
13362:
13363:
13364: static int
13365: test_xmlLineNumbersDefault(void) {
13366: int test_ret = 0;
13367:
13368: int mem_base;
13369: int ret_val;
13370: int val; /* int 0 or 1 */
13371: int n_val;
13372:
13373: for (n_val = 0;n_val < gen_nb_int;n_val++) {
13374: mem_base = xmlMemBlocks();
13375: val = gen_int(n_val, 0);
13376:
13377: ret_val = xmlLineNumbersDefault(val);
13378: desret_int(ret_val);
13379: call_tests++;
13380: des_int(n_val, val, 0);
13381: xmlResetLastError();
13382: if (mem_base != xmlMemBlocks()) {
13383: printf("Leak of %d blocks found in xmlLineNumbersDefault",
13384: xmlMemBlocks() - mem_base);
13385: test_ret++;
13386: printf(" %d", n_val);
13387: printf("\n");
13388: }
13389: }
13390: function_tests++;
13391:
13392: return(test_ret);
13393: }
13394:
13395:
13396: static int
13397: test_xmlLoadExternalEntity(void) {
13398: int test_ret = 0;
13399:
13400: int mem_base;
13401: xmlParserInputPtr ret_val;
13402: const char * URL; /* the URL for the entity to load */
13403: int n_URL;
13404: char * ID; /* the Public ID for the entity to load */
13405: int n_ID;
13406: xmlParserCtxtPtr ctxt; /* the context in which the entity is called or NULL */
13407: int n_ctxt;
13408:
13409: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
13410: for (n_ID = 0;n_ID < gen_nb_const_char_ptr;n_ID++) {
13411: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
13412: mem_base = xmlMemBlocks();
13413: URL = gen_filepath(n_URL, 0);
13414: ID = gen_const_char_ptr(n_ID, 1);
13415: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 2);
13416:
13417: ret_val = xmlLoadExternalEntity(URL, (const char *)ID, ctxt);
13418: desret_xmlParserInputPtr(ret_val);
13419: call_tests++;
13420: des_filepath(n_URL, URL, 0);
13421: des_const_char_ptr(n_ID, (const char *)ID, 1);
13422: des_xmlParserCtxtPtr(n_ctxt, ctxt, 2);
13423: xmlResetLastError();
13424: if (mem_base != xmlMemBlocks()) {
13425: printf("Leak of %d blocks found in xmlLoadExternalEntity",
13426: xmlMemBlocks() - mem_base);
13427: test_ret++;
13428: printf(" %d", n_URL);
13429: printf(" %d", n_ID);
13430: printf(" %d", n_ctxt);
13431: printf("\n");
13432: }
13433: }
13434: }
13435: }
13436: function_tests++;
13437:
13438: return(test_ret);
13439: }
13440:
13441:
13442: static int
13443: test_xmlNewIOInputStream(void) {
13444: int test_ret = 0;
13445:
13446: int mem_base;
13447: xmlParserInputPtr ret_val;
13448: xmlParserCtxtPtr ctxt; /* an XML parser context */
13449: int n_ctxt;
13450: xmlParserInputBufferPtr input; /* an I/O Input */
13451: int n_input;
13452: xmlCharEncoding enc; /* the charset encoding if known */
13453: int n_enc;
13454:
13455: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
13456: for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) {
13457: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
13458: mem_base = xmlMemBlocks();
13459: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
13460: input = gen_xmlParserInputBufferPtr(n_input, 1);
13461: enc = gen_xmlCharEncoding(n_enc, 2);
13462:
13463: ret_val = xmlNewIOInputStream(ctxt, input, enc);
13464: if (ret_val != NULL) input = NULL;
13465: desret_xmlParserInputPtr(ret_val);
13466: call_tests++;
13467: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
13468: des_xmlParserInputBufferPtr(n_input, input, 1);
13469: des_xmlCharEncoding(n_enc, enc, 2);
13470: xmlResetLastError();
13471: if (mem_base != xmlMemBlocks()) {
13472: printf("Leak of %d blocks found in xmlNewIOInputStream",
13473: xmlMemBlocks() - mem_base);
13474: test_ret++;
13475: printf(" %d", n_ctxt);
13476: printf(" %d", n_input);
13477: printf(" %d", n_enc);
13478: printf("\n");
13479: }
13480: }
13481: }
13482: }
13483: function_tests++;
13484:
13485: return(test_ret);
13486: }
13487:
13488:
13489: static int
13490: test_xmlNewParserCtxt(void) {
13491: int test_ret = 0;
13492:
13493: int mem_base;
13494: xmlParserCtxtPtr ret_val;
13495:
13496: mem_base = xmlMemBlocks();
13497:
13498: ret_val = xmlNewParserCtxt();
13499: desret_xmlParserCtxtPtr(ret_val);
13500: call_tests++;
13501: xmlResetLastError();
13502: if (mem_base != xmlMemBlocks()) {
13503: printf("Leak of %d blocks found in xmlNewParserCtxt",
13504: xmlMemBlocks() - mem_base);
13505: test_ret++;
13506: printf("\n");
13507: }
13508: function_tests++;
13509:
13510: return(test_ret);
13511: }
13512:
13513:
13514: #define gen_nb_xmlNodePtr_ptr 1
13515: static xmlNodePtr * gen_xmlNodePtr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
13516: return(NULL);
13517: }
13518: static void des_xmlNodePtr_ptr(int no ATTRIBUTE_UNUSED, xmlNodePtr * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
13519: }
13520:
13521: static int
13522: test_xmlParseBalancedChunkMemory(void) {
13523: int test_ret = 0;
13524:
13525: #if defined(LIBXML_SAX1_ENABLED)
13526: #ifdef LIBXML_SAX1_ENABLED
13527: int mem_base;
13528: int ret_val;
13529: xmlDocPtr doc; /* the document the chunk pertains to */
13530: int n_doc;
13531: xmlSAXHandlerPtr sax; /* the SAX handler bloc (possibly NULL) */
13532: int n_sax;
13533: void * user_data; /* The user data returned on SAX callbacks (possibly NULL) */
13534: int n_user_data;
13535: int depth; /* Used for loop detection, use 0 */
13536: int n_depth;
13537: xmlChar * string; /* the input string in UTF8 or ISO-Latin (zero terminated) */
13538: int n_string;
13539: xmlNodePtr * lst; /* the return value for the set of parsed nodes */
13540: int n_lst;
13541:
13542: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
13543: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
13544: for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
13545: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
13546: for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) {
13547: for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) {
13548: mem_base = xmlMemBlocks();
13549: doc = gen_xmlDocPtr(n_doc, 0);
13550: sax = gen_xmlSAXHandlerPtr(n_sax, 1);
13551: user_data = gen_userdata(n_user_data, 2);
13552: depth = gen_int(n_depth, 3);
13553: string = gen_const_xmlChar_ptr(n_string, 4);
13554: lst = gen_xmlNodePtr_ptr(n_lst, 5);
13555:
13556: #ifdef LIBXML_SAX1_ENABLED
13557: if (sax == (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) user_data = NULL;
13558: #endif
13559:
13560:
13561: ret_val = xmlParseBalancedChunkMemory(doc, sax, user_data, depth, (const xmlChar *)string, lst);
13562: desret_int(ret_val);
13563: call_tests++;
13564: des_xmlDocPtr(n_doc, doc, 0);
13565: des_xmlSAXHandlerPtr(n_sax, sax, 1);
13566: des_userdata(n_user_data, user_data, 2);
13567: des_int(n_depth, depth, 3);
13568: des_const_xmlChar_ptr(n_string, (const xmlChar *)string, 4);
13569: des_xmlNodePtr_ptr(n_lst, lst, 5);
13570: xmlResetLastError();
13571: if (mem_base != xmlMemBlocks()) {
13572: printf("Leak of %d blocks found in xmlParseBalancedChunkMemory",
13573: xmlMemBlocks() - mem_base);
13574: test_ret++;
13575: printf(" %d", n_doc);
13576: printf(" %d", n_sax);
13577: printf(" %d", n_user_data);
13578: printf(" %d", n_depth);
13579: printf(" %d", n_string);
13580: printf(" %d", n_lst);
13581: printf("\n");
13582: }
13583: }
13584: }
13585: }
13586: }
13587: }
13588: }
13589: function_tests++;
13590: #endif
13591: #endif
13592:
13593: return(test_ret);
13594: }
13595:
13596:
13597: static int
13598: test_xmlParseBalancedChunkMemoryRecover(void) {
13599: int test_ret = 0;
13600:
13601: #if defined(LIBXML_SAX1_ENABLED)
13602: #ifdef LIBXML_SAX1_ENABLED
13603: int mem_base;
13604: int ret_val;
13605: xmlDocPtr doc; /* the document the chunk pertains to */
13606: int n_doc;
13607: xmlSAXHandlerPtr sax; /* the SAX handler bloc (possibly NULL) */
13608: int n_sax;
13609: void * user_data; /* The user data returned on SAX callbacks (possibly NULL) */
13610: int n_user_data;
13611: int depth; /* Used for loop detection, use 0 */
13612: int n_depth;
13613: xmlChar * string; /* the input string in UTF8 or ISO-Latin (zero terminated) */
13614: int n_string;
13615: xmlNodePtr * lst; /* the return value for the set of parsed nodes */
13616: int n_lst;
13617: int recover; /* return nodes even if the data is broken (use 0) */
13618: int n_recover;
13619:
13620: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
13621: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
13622: for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
13623: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
13624: for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) {
13625: for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) {
13626: for (n_recover = 0;n_recover < gen_nb_int;n_recover++) {
13627: mem_base = xmlMemBlocks();
13628: doc = gen_xmlDocPtr(n_doc, 0);
13629: sax = gen_xmlSAXHandlerPtr(n_sax, 1);
13630: user_data = gen_userdata(n_user_data, 2);
13631: depth = gen_int(n_depth, 3);
13632: string = gen_const_xmlChar_ptr(n_string, 4);
13633: lst = gen_xmlNodePtr_ptr(n_lst, 5);
13634: recover = gen_int(n_recover, 6);
13635:
13636: #ifdef LIBXML_SAX1_ENABLED
13637: if (sax == (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) user_data = NULL;
13638: #endif
13639:
13640:
13641: ret_val = xmlParseBalancedChunkMemoryRecover(doc, sax, user_data, depth, (const xmlChar *)string, lst, recover);
13642: desret_int(ret_val);
13643: call_tests++;
13644: des_xmlDocPtr(n_doc, doc, 0);
13645: des_xmlSAXHandlerPtr(n_sax, sax, 1);
13646: des_userdata(n_user_data, user_data, 2);
13647: des_int(n_depth, depth, 3);
13648: des_const_xmlChar_ptr(n_string, (const xmlChar *)string, 4);
13649: des_xmlNodePtr_ptr(n_lst, lst, 5);
13650: des_int(n_recover, recover, 6);
13651: xmlResetLastError();
13652: if (mem_base != xmlMemBlocks()) {
13653: printf("Leak of %d blocks found in xmlParseBalancedChunkMemoryRecover",
13654: xmlMemBlocks() - mem_base);
13655: test_ret++;
13656: printf(" %d", n_doc);
13657: printf(" %d", n_sax);
13658: printf(" %d", n_user_data);
13659: printf(" %d", n_depth);
13660: printf(" %d", n_string);
13661: printf(" %d", n_lst);
13662: printf(" %d", n_recover);
13663: printf("\n");
13664: }
13665: }
13666: }
13667: }
13668: }
13669: }
13670: }
13671: }
13672: function_tests++;
13673: #endif
13674: #endif
13675:
13676: return(test_ret);
13677: }
13678:
13679:
13680: static int
13681: test_xmlParseChunk(void) {
13682: int test_ret = 0;
13683:
13684: #if defined(LIBXML_PUSH_ENABLED)
13685: int mem_base;
13686: int ret_val;
13687: xmlParserCtxtPtr ctxt; /* an XML parser context */
13688: int n_ctxt;
13689: char * chunk; /* an char array */
13690: int n_chunk;
13691: int size; /* the size in byte of the chunk */
13692: int n_size;
13693: int terminate; /* last chunk indicator */
13694: int n_terminate;
13695:
13696: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
13697: for (n_chunk = 0;n_chunk < gen_nb_const_char_ptr;n_chunk++) {
13698: for (n_size = 0;n_size < gen_nb_int;n_size++) {
13699: for (n_terminate = 0;n_terminate < gen_nb_int;n_terminate++) {
13700: mem_base = xmlMemBlocks();
13701: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
13702: chunk = gen_const_char_ptr(n_chunk, 1);
13703: size = gen_int(n_size, 2);
13704: terminate = gen_int(n_terminate, 3);
13705:
13706: ret_val = xmlParseChunk(ctxt, (const char *)chunk, size, terminate);
13707: if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;}
13708: desret_int(ret_val);
13709: call_tests++;
13710: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
13711: des_const_char_ptr(n_chunk, (const char *)chunk, 1);
13712: des_int(n_size, size, 2);
13713: des_int(n_terminate, terminate, 3);
13714: xmlResetLastError();
13715: if (mem_base != xmlMemBlocks()) {
13716: printf("Leak of %d blocks found in xmlParseChunk",
13717: xmlMemBlocks() - mem_base);
13718: test_ret++;
13719: printf(" %d", n_ctxt);
13720: printf(" %d", n_chunk);
13721: printf(" %d", n_size);
13722: printf(" %d", n_terminate);
13723: printf("\n");
13724: }
13725: }
13726: }
13727: }
13728: }
13729: function_tests++;
13730: #endif
13731:
13732: return(test_ret);
13733: }
13734:
13735:
13736: static int
13737: test_xmlParseCtxtExternalEntity(void) {
13738: int test_ret = 0;
13739:
13740: int mem_base;
13741: int ret_val;
13742: xmlParserCtxtPtr ctx; /* the existing parsing context */
13743: int n_ctx;
13744: xmlChar * URL; /* the URL for the entity to load */
13745: int n_URL;
13746: xmlChar * ID; /* the System ID for the entity to load */
13747: int n_ID;
13748: xmlNodePtr * lst; /* the return value for the set of parsed nodes */
13749: int n_lst;
13750:
13751: for (n_ctx = 0;n_ctx < gen_nb_xmlParserCtxtPtr;n_ctx++) {
13752: for (n_URL = 0;n_URL < gen_nb_const_xmlChar_ptr;n_URL++) {
13753: for (n_ID = 0;n_ID < gen_nb_const_xmlChar_ptr;n_ID++) {
13754: for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) {
13755: mem_base = xmlMemBlocks();
13756: ctx = gen_xmlParserCtxtPtr(n_ctx, 0);
13757: URL = gen_const_xmlChar_ptr(n_URL, 1);
13758: ID = gen_const_xmlChar_ptr(n_ID, 2);
13759: lst = gen_xmlNodePtr_ptr(n_lst, 3);
13760:
13761: ret_val = xmlParseCtxtExternalEntity(ctx, (const xmlChar *)URL, (const xmlChar *)ID, lst);
13762: desret_int(ret_val);
13763: call_tests++;
13764: des_xmlParserCtxtPtr(n_ctx, ctx, 0);
13765: des_const_xmlChar_ptr(n_URL, (const xmlChar *)URL, 1);
13766: des_const_xmlChar_ptr(n_ID, (const xmlChar *)ID, 2);
13767: des_xmlNodePtr_ptr(n_lst, lst, 3);
13768: xmlResetLastError();
13769: if (mem_base != xmlMemBlocks()) {
13770: printf("Leak of %d blocks found in xmlParseCtxtExternalEntity",
13771: xmlMemBlocks() - mem_base);
13772: test_ret++;
13773: printf(" %d", n_ctx);
13774: printf(" %d", n_URL);
13775: printf(" %d", n_ID);
13776: printf(" %d", n_lst);
13777: printf("\n");
13778: }
13779: }
13780: }
13781: }
13782: }
13783: function_tests++;
13784:
13785: return(test_ret);
13786: }
13787:
13788:
13789: static int
13790: test_xmlParseDTD(void) {
13791: int test_ret = 0;
13792:
13793: #if defined(LIBXML_VALID_ENABLED)
13794: #ifdef LIBXML_VALID_ENABLED
13795: int mem_base;
13796: xmlDtdPtr ret_val;
13797: xmlChar * ExternalID; /* a NAME* containing the External ID of the DTD */
13798: int n_ExternalID;
13799: xmlChar * SystemID; /* a NAME* containing the URL to the DTD */
13800: int n_SystemID;
13801:
13802: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
13803: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
13804: mem_base = xmlMemBlocks();
13805: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 0);
13806: SystemID = gen_const_xmlChar_ptr(n_SystemID, 1);
13807:
13808: ret_val = xmlParseDTD((const xmlChar *)ExternalID, (const xmlChar *)SystemID);
13809: desret_xmlDtdPtr(ret_val);
13810: call_tests++;
13811: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 0);
13812: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 1);
13813: xmlResetLastError();
13814: if (mem_base != xmlMemBlocks()) {
13815: printf("Leak of %d blocks found in xmlParseDTD",
13816: xmlMemBlocks() - mem_base);
13817: test_ret++;
13818: printf(" %d", n_ExternalID);
13819: printf(" %d", n_SystemID);
13820: printf("\n");
13821: }
13822: }
13823: }
13824: function_tests++;
13825: #endif
13826: #endif
13827:
13828: return(test_ret);
13829: }
13830:
13831:
13832: static int
13833: test_xmlParseDoc(void) {
13834: int test_ret = 0;
13835:
13836: #if defined(LIBXML_SAX1_ENABLED)
13837: #ifdef LIBXML_SAX1_ENABLED
13838: int mem_base;
13839: xmlDocPtr ret_val;
13840: xmlChar * cur; /* a pointer to an array of xmlChar */
13841: int n_cur;
13842:
13843: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
13844: mem_base = xmlMemBlocks();
13845: cur = gen_const_xmlChar_ptr(n_cur, 0);
13846:
13847: ret_val = xmlParseDoc((const xmlChar *)cur);
13848: desret_xmlDocPtr(ret_val);
13849: call_tests++;
13850: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
13851: xmlResetLastError();
13852: if (mem_base != xmlMemBlocks()) {
13853: printf("Leak of %d blocks found in xmlParseDoc",
13854: xmlMemBlocks() - mem_base);
13855: test_ret++;
13856: printf(" %d", n_cur);
13857: printf("\n");
13858: }
13859: }
13860: function_tests++;
13861: #endif
13862: #endif
13863:
13864: return(test_ret);
13865: }
13866:
13867:
13868: static int
13869: test_xmlParseDocument(void) {
13870: int test_ret = 0;
13871:
13872: int mem_base;
13873: int ret_val;
13874: xmlParserCtxtPtr ctxt; /* an XML parser context */
13875: int n_ctxt;
13876:
13877: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
13878: mem_base = xmlMemBlocks();
13879: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
13880:
13881: ret_val = xmlParseDocument(ctxt);
13882: if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;}
13883: desret_int(ret_val);
13884: call_tests++;
13885: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
13886: xmlResetLastError();
13887: if (mem_base != xmlMemBlocks()) {
13888: printf("Leak of %d blocks found in xmlParseDocument",
13889: xmlMemBlocks() - mem_base);
13890: test_ret++;
13891: printf(" %d", n_ctxt);
13892: printf("\n");
13893: }
13894: }
13895: function_tests++;
13896:
13897: return(test_ret);
13898: }
13899:
13900:
13901: static int
13902: test_xmlParseEntity(void) {
13903: int test_ret = 0;
13904:
13905: #if defined(LIBXML_SAX1_ENABLED)
13906: #ifdef LIBXML_SAX1_ENABLED
13907: int mem_base;
13908: xmlDocPtr ret_val;
13909: const char * filename; /* the filename */
13910: int n_filename;
13911:
13912: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
13913: mem_base = xmlMemBlocks();
13914: filename = gen_filepath(n_filename, 0);
13915:
13916: ret_val = xmlParseEntity(filename);
13917: desret_xmlDocPtr(ret_val);
13918: call_tests++;
13919: des_filepath(n_filename, filename, 0);
13920: xmlResetLastError();
13921: if (mem_base != xmlMemBlocks()) {
13922: printf("Leak of %d blocks found in xmlParseEntity",
13923: xmlMemBlocks() - mem_base);
13924: test_ret++;
13925: printf(" %d", n_filename);
13926: printf("\n");
13927: }
13928: }
13929: function_tests++;
13930: #endif
13931: #endif
13932:
13933: return(test_ret);
13934: }
13935:
13936:
13937: static int
13938: test_xmlParseExtParsedEnt(void) {
13939: int test_ret = 0;
13940:
13941: int mem_base;
13942: int ret_val;
13943: xmlParserCtxtPtr ctxt; /* an XML parser context */
13944: int n_ctxt;
13945:
13946: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
13947: mem_base = xmlMemBlocks();
13948: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
13949:
13950: ret_val = xmlParseExtParsedEnt(ctxt);
13951: if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;}
13952: desret_int(ret_val);
13953: call_tests++;
13954: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
13955: xmlResetLastError();
13956: if (mem_base != xmlMemBlocks()) {
13957: printf("Leak of %d blocks found in xmlParseExtParsedEnt",
13958: xmlMemBlocks() - mem_base);
13959: test_ret++;
13960: printf(" %d", n_ctxt);
13961: printf("\n");
13962: }
13963: }
13964: function_tests++;
13965:
13966: return(test_ret);
13967: }
13968:
13969:
13970: static int
13971: test_xmlParseExternalEntity(void) {
13972: int test_ret = 0;
13973:
13974: #if defined(LIBXML_SAX1_ENABLED)
13975: #ifdef LIBXML_SAX1_ENABLED
13976: int mem_base;
13977: int ret_val;
13978: xmlDocPtr doc; /* the document the chunk pertains to */
13979: int n_doc;
13980: xmlSAXHandlerPtr sax; /* the SAX handler bloc (possibly NULL) */
13981: int n_sax;
13982: void * user_data; /* The user data returned on SAX callbacks (possibly NULL) */
13983: int n_user_data;
13984: int depth; /* Used for loop detection, use 0 */
13985: int n_depth;
13986: xmlChar * URL; /* the URL for the entity to load */
13987: int n_URL;
13988: xmlChar * ID; /* the System ID for the entity to load */
13989: int n_ID;
13990: xmlNodePtr * lst; /* the return value for the set of parsed nodes */
13991: int n_lst;
13992:
13993: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
13994: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
13995: for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
13996: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
13997: for (n_URL = 0;n_URL < gen_nb_const_xmlChar_ptr;n_URL++) {
13998: for (n_ID = 0;n_ID < gen_nb_const_xmlChar_ptr;n_ID++) {
13999: for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) {
14000: mem_base = xmlMemBlocks();
14001: doc = gen_xmlDocPtr(n_doc, 0);
14002: sax = gen_xmlSAXHandlerPtr(n_sax, 1);
14003: user_data = gen_userdata(n_user_data, 2);
14004: depth = gen_int(n_depth, 3);
14005: URL = gen_const_xmlChar_ptr(n_URL, 4);
14006: ID = gen_const_xmlChar_ptr(n_ID, 5);
14007: lst = gen_xmlNodePtr_ptr(n_lst, 6);
14008:
14009: ret_val = xmlParseExternalEntity(doc, sax, user_data, depth, (const xmlChar *)URL, (const xmlChar *)ID, lst);
14010: desret_int(ret_val);
14011: call_tests++;
14012: des_xmlDocPtr(n_doc, doc, 0);
14013: des_xmlSAXHandlerPtr(n_sax, sax, 1);
14014: des_userdata(n_user_data, user_data, 2);
14015: des_int(n_depth, depth, 3);
14016: des_const_xmlChar_ptr(n_URL, (const xmlChar *)URL, 4);
14017: des_const_xmlChar_ptr(n_ID, (const xmlChar *)ID, 5);
14018: des_xmlNodePtr_ptr(n_lst, lst, 6);
14019: xmlResetLastError();
14020: if (mem_base != xmlMemBlocks()) {
14021: printf("Leak of %d blocks found in xmlParseExternalEntity",
14022: xmlMemBlocks() - mem_base);
14023: test_ret++;
14024: printf(" %d", n_doc);
14025: printf(" %d", n_sax);
14026: printf(" %d", n_user_data);
14027: printf(" %d", n_depth);
14028: printf(" %d", n_URL);
14029: printf(" %d", n_ID);
14030: printf(" %d", n_lst);
14031: printf("\n");
14032: }
14033: }
14034: }
14035: }
14036: }
14037: }
14038: }
14039: }
14040: function_tests++;
14041: #endif
14042: #endif
14043:
14044: return(test_ret);
14045: }
14046:
14047:
14048: static int
14049: test_xmlParseFile(void) {
14050: int test_ret = 0;
14051:
14052: #if defined(LIBXML_SAX1_ENABLED)
14053: #ifdef LIBXML_SAX1_ENABLED
14054: int mem_base;
14055: xmlDocPtr ret_val;
14056: const char * filename; /* the filename */
14057: int n_filename;
14058:
14059: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
14060: mem_base = xmlMemBlocks();
14061: filename = gen_filepath(n_filename, 0);
14062:
14063: ret_val = xmlParseFile(filename);
14064: desret_xmlDocPtr(ret_val);
14065: call_tests++;
14066: des_filepath(n_filename, filename, 0);
14067: xmlResetLastError();
14068: if (mem_base != xmlMemBlocks()) {
14069: printf("Leak of %d blocks found in xmlParseFile",
14070: xmlMemBlocks() - mem_base);
14071: test_ret++;
14072: printf(" %d", n_filename);
14073: printf("\n");
14074: }
14075: }
14076: function_tests++;
14077: #endif
14078: #endif
14079:
14080: return(test_ret);
14081: }
14082:
14083:
14084: static int
14085: test_xmlParseInNodeContext(void) {
14086: int test_ret = 0;
14087:
14088: int mem_base;
14089: xmlParserErrors ret_val;
14090: xmlNodePtr node; /* the context node */
14091: int n_node;
14092: char * data; /* the input string */
14093: int n_data;
14094: int datalen; /* the input string length in bytes */
14095: int n_datalen;
14096: int options; /* a combination of xmlParserOption */
14097: int n_options;
14098: xmlNodePtr * lst; /* the return value for the set of parsed nodes */
14099: int n_lst;
14100:
14101: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
14102: for (n_data = 0;n_data < gen_nb_const_char_ptr;n_data++) {
14103: for (n_datalen = 0;n_datalen < gen_nb_int;n_datalen++) {
14104: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
14105: for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) {
14106: mem_base = xmlMemBlocks();
14107: node = gen_xmlNodePtr(n_node, 0);
14108: data = gen_const_char_ptr(n_data, 1);
14109: datalen = gen_int(n_datalen, 2);
14110: options = gen_parseroptions(n_options, 3);
14111: lst = gen_xmlNodePtr_ptr(n_lst, 4);
14112:
14113: ret_val = xmlParseInNodeContext(node, (const char *)data, datalen, options, lst);
14114: desret_xmlParserErrors(ret_val);
14115: call_tests++;
14116: des_xmlNodePtr(n_node, node, 0);
14117: des_const_char_ptr(n_data, (const char *)data, 1);
14118: des_int(n_datalen, datalen, 2);
14119: des_parseroptions(n_options, options, 3);
14120: des_xmlNodePtr_ptr(n_lst, lst, 4);
14121: xmlResetLastError();
14122: if (mem_base != xmlMemBlocks()) {
14123: printf("Leak of %d blocks found in xmlParseInNodeContext",
14124: xmlMemBlocks() - mem_base);
14125: test_ret++;
14126: printf(" %d", n_node);
14127: printf(" %d", n_data);
14128: printf(" %d", n_datalen);
14129: printf(" %d", n_options);
14130: printf(" %d", n_lst);
14131: printf("\n");
14132: }
14133: }
14134: }
14135: }
14136: }
14137: }
14138: function_tests++;
14139:
14140: return(test_ret);
14141: }
14142:
14143:
14144: static int
14145: test_xmlParseMemory(void) {
14146: int test_ret = 0;
14147:
14148: #if defined(LIBXML_SAX1_ENABLED)
14149: #ifdef LIBXML_SAX1_ENABLED
14150: int mem_base;
14151: xmlDocPtr ret_val;
14152: char * buffer; /* an pointer to a char array */
14153: int n_buffer;
14154: int size; /* the size of the array */
14155: int n_size;
14156:
14157: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
14158: for (n_size = 0;n_size < gen_nb_int;n_size++) {
14159: mem_base = xmlMemBlocks();
14160: buffer = gen_const_char_ptr(n_buffer, 0);
14161: size = gen_int(n_size, 1);
14162:
14163: ret_val = xmlParseMemory((const char *)buffer, size);
14164: desret_xmlDocPtr(ret_val);
14165: call_tests++;
14166: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
14167: des_int(n_size, size, 1);
14168: xmlResetLastError();
14169: if (mem_base != xmlMemBlocks()) {
14170: printf("Leak of %d blocks found in xmlParseMemory",
14171: xmlMemBlocks() - mem_base);
14172: test_ret++;
14173: printf(" %d", n_buffer);
14174: printf(" %d", n_size);
14175: printf("\n");
14176: }
14177: }
14178: }
14179: function_tests++;
14180: #endif
14181: #endif
14182:
14183: return(test_ret);
14184: }
14185:
14186:
14187: #define gen_nb_const_xmlParserNodeInfoPtr 1
14188: static xmlParserNodeInfoPtr gen_const_xmlParserNodeInfoPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14189: return(NULL);
14190: }
14191: static void des_const_xmlParserNodeInfoPtr(int no ATTRIBUTE_UNUSED, const xmlParserNodeInfoPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14192: }
14193:
14194: static int
14195: test_xmlParserAddNodeInfo(void) {
14196: int test_ret = 0;
14197:
14198: int mem_base;
14199: xmlParserCtxtPtr ctxt; /* an XML parser context */
14200: int n_ctxt;
14201: xmlParserNodeInfoPtr info; /* a node info sequence pointer */
14202: int n_info;
14203:
14204: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
14205: for (n_info = 0;n_info < gen_nb_const_xmlParserNodeInfoPtr;n_info++) {
14206: mem_base = xmlMemBlocks();
14207: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
14208: info = gen_const_xmlParserNodeInfoPtr(n_info, 1);
14209:
14210: xmlParserAddNodeInfo(ctxt, (const xmlParserNodeInfoPtr)info);
14211: call_tests++;
14212: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
14213: des_const_xmlParserNodeInfoPtr(n_info, (const xmlParserNodeInfoPtr)info, 1);
14214: xmlResetLastError();
14215: if (mem_base != xmlMemBlocks()) {
14216: printf("Leak of %d blocks found in xmlParserAddNodeInfo",
14217: xmlMemBlocks() - mem_base);
14218: test_ret++;
14219: printf(" %d", n_ctxt);
14220: printf(" %d", n_info);
14221: printf("\n");
14222: }
14223: }
14224: }
14225: function_tests++;
14226:
14227: return(test_ret);
14228: }
14229:
14230:
14231: #define gen_nb_const_xmlParserCtxtPtr 1
14232: static xmlParserCtxtPtr gen_const_xmlParserCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14233: return(NULL);
14234: }
14235: static void des_const_xmlParserCtxtPtr(int no ATTRIBUTE_UNUSED, const xmlParserCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14236: }
14237:
14238: #define gen_nb_const_xmlNodePtr 1
14239: static xmlNodePtr gen_const_xmlNodePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14240: return(NULL);
14241: }
14242: static void des_const_xmlNodePtr(int no ATTRIBUTE_UNUSED, const xmlNodePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14243: }
14244:
14245: static int
14246: test_xmlParserFindNodeInfo(void) {
14247: int test_ret = 0;
14248:
14249: int mem_base;
14250: const xmlParserNodeInfo * ret_val;
14251: xmlParserCtxtPtr ctx; /* an XML parser context */
14252: int n_ctx;
14253: xmlNodePtr node; /* an XML node within the tree */
14254: int n_node;
14255:
14256: for (n_ctx = 0;n_ctx < gen_nb_const_xmlParserCtxtPtr;n_ctx++) {
14257: for (n_node = 0;n_node < gen_nb_const_xmlNodePtr;n_node++) {
14258: mem_base = xmlMemBlocks();
14259: ctx = gen_const_xmlParserCtxtPtr(n_ctx, 0);
14260: node = gen_const_xmlNodePtr(n_node, 1);
14261:
14262: ret_val = xmlParserFindNodeInfo((const xmlParserCtxtPtr)ctx, (const xmlNodePtr)node);
14263: desret_const_xmlParserNodeInfo_ptr(ret_val);
14264: call_tests++;
14265: des_const_xmlParserCtxtPtr(n_ctx, (const xmlParserCtxtPtr)ctx, 0);
14266: des_const_xmlNodePtr(n_node, (const xmlNodePtr)node, 1);
14267: xmlResetLastError();
14268: if (mem_base != xmlMemBlocks()) {
14269: printf("Leak of %d blocks found in xmlParserFindNodeInfo",
14270: xmlMemBlocks() - mem_base);
14271: test_ret++;
14272: printf(" %d", n_ctx);
14273: printf(" %d", n_node);
14274: printf("\n");
14275: }
14276: }
14277: }
14278: function_tests++;
14279:
14280: return(test_ret);
14281: }
14282:
14283:
14284: #define gen_nb_const_xmlParserNodeInfoSeqPtr 1
14285: static xmlParserNodeInfoSeqPtr gen_const_xmlParserNodeInfoSeqPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14286: return(NULL);
14287: }
14288: static void des_const_xmlParserNodeInfoSeqPtr(int no ATTRIBUTE_UNUSED, const xmlParserNodeInfoSeqPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14289: }
14290:
14291: static int
14292: test_xmlParserFindNodeInfoIndex(void) {
14293: int test_ret = 0;
14294:
14295: int mem_base;
14296: unsigned long ret_val;
14297: xmlParserNodeInfoSeqPtr seq; /* a node info sequence pointer */
14298: int n_seq;
14299: xmlNodePtr node; /* an XML node pointer */
14300: int n_node;
14301:
14302: for (n_seq = 0;n_seq < gen_nb_const_xmlParserNodeInfoSeqPtr;n_seq++) {
14303: for (n_node = 0;n_node < gen_nb_const_xmlNodePtr;n_node++) {
14304: mem_base = xmlMemBlocks();
14305: seq = gen_const_xmlParserNodeInfoSeqPtr(n_seq, 0);
14306: node = gen_const_xmlNodePtr(n_node, 1);
14307:
14308: ret_val = xmlParserFindNodeInfoIndex((const xmlParserNodeInfoSeqPtr)seq, (const xmlNodePtr)node);
14309: desret_unsigned_long(ret_val);
14310: call_tests++;
14311: des_const_xmlParserNodeInfoSeqPtr(n_seq, (const xmlParserNodeInfoSeqPtr)seq, 0);
14312: des_const_xmlNodePtr(n_node, (const xmlNodePtr)node, 1);
14313: xmlResetLastError();
14314: if (mem_base != xmlMemBlocks()) {
14315: printf("Leak of %d blocks found in xmlParserFindNodeInfoIndex",
14316: xmlMemBlocks() - mem_base);
14317: test_ret++;
14318: printf(" %d", n_seq);
14319: printf(" %d", n_node);
14320: printf("\n");
14321: }
14322: }
14323: }
14324: function_tests++;
14325:
14326: return(test_ret);
14327: }
14328:
14329:
14330: #define gen_nb_xmlParserInputPtr 1
14331: static xmlParserInputPtr gen_xmlParserInputPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14332: return(NULL);
14333: }
14334: static void des_xmlParserInputPtr(int no ATTRIBUTE_UNUSED, xmlParserInputPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14335: }
14336:
14337: static int
14338: test_xmlParserInputGrow(void) {
14339: int test_ret = 0;
14340:
14341: int mem_base;
14342: int ret_val;
14343: xmlParserInputPtr in; /* an XML parser input */
14344: int n_in;
14345: int len; /* an indicative size for the lookahead */
14346: int n_len;
14347:
14348: for (n_in = 0;n_in < gen_nb_xmlParserInputPtr;n_in++) {
14349: for (n_len = 0;n_len < gen_nb_int;n_len++) {
14350: mem_base = xmlMemBlocks();
14351: in = gen_xmlParserInputPtr(n_in, 0);
14352: len = gen_int(n_len, 1);
14353:
14354: ret_val = xmlParserInputGrow(in, len);
14355: desret_int(ret_val);
14356: call_tests++;
14357: des_xmlParserInputPtr(n_in, in, 0);
14358: des_int(n_len, len, 1);
14359: xmlResetLastError();
14360: if (mem_base != xmlMemBlocks()) {
14361: printf("Leak of %d blocks found in xmlParserInputGrow",
14362: xmlMemBlocks() - mem_base);
14363: test_ret++;
14364: printf(" %d", n_in);
14365: printf(" %d", n_len);
14366: printf("\n");
14367: }
14368: }
14369: }
14370: function_tests++;
14371:
14372: return(test_ret);
14373: }
14374:
14375:
14376: static int
14377: test_xmlParserInputRead(void) {
14378: int test_ret = 0;
14379:
14380: int mem_base;
14381: int ret_val;
14382: xmlParserInputPtr in; /* an XML parser input */
14383: int n_in;
14384: int len; /* an indicative size for the lookahead */
14385: int n_len;
14386:
14387: for (n_in = 0;n_in < gen_nb_xmlParserInputPtr;n_in++) {
14388: for (n_len = 0;n_len < gen_nb_int;n_len++) {
14389: mem_base = xmlMemBlocks();
14390: in = gen_xmlParserInputPtr(n_in, 0);
14391: len = gen_int(n_len, 1);
14392:
14393: ret_val = xmlParserInputRead(in, len);
14394: desret_int(ret_val);
14395: call_tests++;
14396: des_xmlParserInputPtr(n_in, in, 0);
14397: des_int(n_len, len, 1);
14398: xmlResetLastError();
14399: if (mem_base != xmlMemBlocks()) {
14400: printf("Leak of %d blocks found in xmlParserInputRead",
14401: xmlMemBlocks() - mem_base);
14402: test_ret++;
14403: printf(" %d", n_in);
14404: printf(" %d", n_len);
14405: printf("\n");
14406: }
14407: }
14408: }
14409: function_tests++;
14410:
14411: return(test_ret);
14412: }
14413:
14414:
14415: static int
14416: test_xmlPedanticParserDefault(void) {
14417: int test_ret = 0;
14418:
14419: int mem_base;
14420: int ret_val;
14421: int val; /* int 0 or 1 */
14422: int n_val;
14423:
14424: for (n_val = 0;n_val < gen_nb_int;n_val++) {
14425: mem_base = xmlMemBlocks();
14426: val = gen_int(n_val, 0);
14427:
14428: ret_val = xmlPedanticParserDefault(val);
14429: desret_int(ret_val);
14430: call_tests++;
14431: des_int(n_val, val, 0);
14432: xmlResetLastError();
14433: if (mem_base != xmlMemBlocks()) {
14434: printf("Leak of %d blocks found in xmlPedanticParserDefault",
14435: xmlMemBlocks() - mem_base);
14436: test_ret++;
14437: printf(" %d", n_val);
14438: printf("\n");
14439: }
14440: }
14441: function_tests++;
14442:
14443: return(test_ret);
14444: }
14445:
14446:
14447: static int
14448: test_xmlReadDoc(void) {
14449: int test_ret = 0;
14450:
14451: int mem_base;
14452: xmlDocPtr ret_val;
14453: xmlChar * cur; /* a pointer to a zero terminated string */
14454: int n_cur;
14455: const char * URL; /* the base URL to use for the document */
14456: int n_URL;
14457: char * encoding; /* the document encoding, or NULL */
14458: int n_encoding;
14459: int options; /* a combination of xmlParserOption */
14460: int n_options;
14461:
14462: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
14463: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
14464: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
14465: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
14466: mem_base = xmlMemBlocks();
14467: cur = gen_const_xmlChar_ptr(n_cur, 0);
14468: URL = gen_filepath(n_URL, 1);
14469: encoding = gen_const_char_ptr(n_encoding, 2);
14470: options = gen_parseroptions(n_options, 3);
14471:
14472: ret_val = xmlReadDoc((const xmlChar *)cur, URL, (const char *)encoding, options);
14473: desret_xmlDocPtr(ret_val);
14474: call_tests++;
14475: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
14476: des_filepath(n_URL, URL, 1);
14477: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
14478: des_parseroptions(n_options, options, 3);
14479: xmlResetLastError();
14480: if (mem_base != xmlMemBlocks()) {
14481: printf("Leak of %d blocks found in xmlReadDoc",
14482: xmlMemBlocks() - mem_base);
14483: test_ret++;
14484: printf(" %d", n_cur);
14485: printf(" %d", n_URL);
14486: printf(" %d", n_encoding);
14487: printf(" %d", n_options);
14488: printf("\n");
14489: }
14490: }
14491: }
14492: }
14493: }
14494: function_tests++;
14495:
14496: return(test_ret);
14497: }
14498:
14499:
14500: static int
14501: test_xmlReadFile(void) {
14502: int test_ret = 0;
14503:
14504: int mem_base;
14505: xmlDocPtr ret_val;
14506: const char * filename; /* a file or URL */
14507: int n_filename;
14508: char * encoding; /* the document encoding, or NULL */
14509: int n_encoding;
14510: int options; /* a combination of xmlParserOption */
14511: int n_options;
14512:
14513: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
14514: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
14515: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
14516: mem_base = xmlMemBlocks();
14517: filename = gen_filepath(n_filename, 0);
14518: encoding = gen_const_char_ptr(n_encoding, 1);
14519: options = gen_parseroptions(n_options, 2);
14520:
14521: ret_val = xmlReadFile(filename, (const char *)encoding, options);
14522: desret_xmlDocPtr(ret_val);
14523: call_tests++;
14524: des_filepath(n_filename, filename, 0);
14525: des_const_char_ptr(n_encoding, (const char *)encoding, 1);
14526: des_parseroptions(n_options, options, 2);
14527: xmlResetLastError();
14528: if (mem_base != xmlMemBlocks()) {
14529: printf("Leak of %d blocks found in xmlReadFile",
14530: xmlMemBlocks() - mem_base);
14531: test_ret++;
14532: printf(" %d", n_filename);
14533: printf(" %d", n_encoding);
14534: printf(" %d", n_options);
14535: printf("\n");
14536: }
14537: }
14538: }
14539: }
14540: function_tests++;
14541:
14542: return(test_ret);
14543: }
14544:
14545:
14546: static int
14547: test_xmlReadMemory(void) {
14548: int test_ret = 0;
14549:
14550: int mem_base;
14551: xmlDocPtr ret_val;
14552: char * buffer; /* a pointer to a char array */
14553: int n_buffer;
14554: int size; /* the size of the array */
14555: int n_size;
14556: const char * URL; /* the base URL to use for the document */
14557: int n_URL;
14558: char * encoding; /* the document encoding, or NULL */
14559: int n_encoding;
14560: int options; /* a combination of xmlParserOption */
14561: int n_options;
14562:
14563: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
14564: for (n_size = 0;n_size < gen_nb_int;n_size++) {
14565: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
14566: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
14567: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
14568: mem_base = xmlMemBlocks();
14569: buffer = gen_const_char_ptr(n_buffer, 0);
14570: size = gen_int(n_size, 1);
14571: URL = gen_filepath(n_URL, 2);
14572: encoding = gen_const_char_ptr(n_encoding, 3);
14573: options = gen_parseroptions(n_options, 4);
14574:
14575: ret_val = xmlReadMemory((const char *)buffer, size, URL, (const char *)encoding, options);
14576: desret_xmlDocPtr(ret_val);
14577: call_tests++;
14578: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
14579: des_int(n_size, size, 1);
14580: des_filepath(n_URL, URL, 2);
14581: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
14582: des_parseroptions(n_options, options, 4);
14583: xmlResetLastError();
14584: if (mem_base != xmlMemBlocks()) {
14585: printf("Leak of %d blocks found in xmlReadMemory",
14586: xmlMemBlocks() - mem_base);
14587: test_ret++;
14588: printf(" %d", n_buffer);
14589: printf(" %d", n_size);
14590: printf(" %d", n_URL);
14591: printf(" %d", n_encoding);
14592: printf(" %d", n_options);
14593: printf("\n");
14594: }
14595: }
14596: }
14597: }
14598: }
14599: }
14600: function_tests++;
14601:
14602: return(test_ret);
14603: }
14604:
14605:
14606: static int
14607: test_xmlRecoverDoc(void) {
14608: int test_ret = 0;
14609:
14610: #if defined(LIBXML_SAX1_ENABLED)
14611: #ifdef LIBXML_SAX1_ENABLED
14612: int mem_base;
14613: xmlDocPtr ret_val;
14614: xmlChar * cur; /* a pointer to an array of xmlChar */
14615: int n_cur;
14616:
14617: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
14618: mem_base = xmlMemBlocks();
14619: cur = gen_const_xmlChar_ptr(n_cur, 0);
14620:
14621: ret_val = xmlRecoverDoc((const xmlChar *)cur);
14622: desret_xmlDocPtr(ret_val);
14623: call_tests++;
14624: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
14625: xmlResetLastError();
14626: if (mem_base != xmlMemBlocks()) {
14627: printf("Leak of %d blocks found in xmlRecoverDoc",
14628: xmlMemBlocks() - mem_base);
14629: test_ret++;
14630: printf(" %d", n_cur);
14631: printf("\n");
14632: }
14633: }
14634: function_tests++;
14635: #endif
14636: #endif
14637:
14638: return(test_ret);
14639: }
14640:
14641:
14642: static int
14643: test_xmlRecoverFile(void) {
14644: int test_ret = 0;
14645:
14646: #if defined(LIBXML_SAX1_ENABLED)
14647: #ifdef LIBXML_SAX1_ENABLED
14648: int mem_base;
14649: xmlDocPtr ret_val;
14650: const char * filename; /* the filename */
14651: int n_filename;
14652:
14653: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
14654: mem_base = xmlMemBlocks();
14655: filename = gen_filepath(n_filename, 0);
14656:
14657: ret_val = xmlRecoverFile(filename);
14658: desret_xmlDocPtr(ret_val);
14659: call_tests++;
14660: des_filepath(n_filename, filename, 0);
14661: xmlResetLastError();
14662: if (mem_base != xmlMemBlocks()) {
14663: printf("Leak of %d blocks found in xmlRecoverFile",
14664: xmlMemBlocks() - mem_base);
14665: test_ret++;
14666: printf(" %d", n_filename);
14667: printf("\n");
14668: }
14669: }
14670: function_tests++;
14671: #endif
14672: #endif
14673:
14674: return(test_ret);
14675: }
14676:
14677:
14678: static int
14679: test_xmlRecoverMemory(void) {
14680: int test_ret = 0;
14681:
14682: #if defined(LIBXML_SAX1_ENABLED)
14683: #ifdef LIBXML_SAX1_ENABLED
14684: int mem_base;
14685: xmlDocPtr ret_val;
14686: char * buffer; /* an pointer to a char array */
14687: int n_buffer;
14688: int size; /* the size of the array */
14689: int n_size;
14690:
14691: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
14692: for (n_size = 0;n_size < gen_nb_int;n_size++) {
14693: mem_base = xmlMemBlocks();
14694: buffer = gen_const_char_ptr(n_buffer, 0);
14695: size = gen_int(n_size, 1);
14696:
14697: ret_val = xmlRecoverMemory((const char *)buffer, size);
14698: desret_xmlDocPtr(ret_val);
14699: call_tests++;
14700: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
14701: des_int(n_size, size, 1);
14702: xmlResetLastError();
14703: if (mem_base != xmlMemBlocks()) {
14704: printf("Leak of %d blocks found in xmlRecoverMemory",
14705: xmlMemBlocks() - mem_base);
14706: test_ret++;
14707: printf(" %d", n_buffer);
14708: printf(" %d", n_size);
14709: printf("\n");
14710: }
14711: }
14712: }
14713: function_tests++;
14714: #endif
14715: #endif
14716:
14717: return(test_ret);
14718: }
14719:
14720:
14721: static int
14722: test_xmlSAXParseDTD(void) {
14723: int test_ret = 0;
14724:
14725: #if defined(LIBXML_VALID_ENABLED)
14726: #ifdef LIBXML_SAX1_ENABLED
14727: int mem_base;
14728: xmlDtdPtr ret_val;
14729: xmlSAXHandlerPtr sax; /* the SAX handler block */
14730: int n_sax;
14731: xmlChar * ExternalID; /* a NAME* containing the External ID of the DTD */
14732: int n_ExternalID;
14733: xmlChar * SystemID; /* a NAME* containing the URL to the DTD */
14734: int n_SystemID;
14735:
14736: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
14737: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
14738: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
14739: mem_base = xmlMemBlocks();
14740: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
14741: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 1);
14742: SystemID = gen_const_xmlChar_ptr(n_SystemID, 2);
14743:
14744: ret_val = xmlSAXParseDTD(sax, (const xmlChar *)ExternalID, (const xmlChar *)SystemID);
14745: desret_xmlDtdPtr(ret_val);
14746: call_tests++;
14747: des_xmlSAXHandlerPtr(n_sax, sax, 0);
14748: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 1);
14749: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 2);
14750: xmlResetLastError();
14751: if (mem_base != xmlMemBlocks()) {
14752: printf("Leak of %d blocks found in xmlSAXParseDTD",
14753: xmlMemBlocks() - mem_base);
14754: test_ret++;
14755: printf(" %d", n_sax);
14756: printf(" %d", n_ExternalID);
14757: printf(" %d", n_SystemID);
14758: printf("\n");
14759: }
14760: }
14761: }
14762: }
14763: function_tests++;
14764: #endif
14765: #endif
14766:
14767: return(test_ret);
14768: }
14769:
14770:
14771: static int
14772: test_xmlSAXParseDoc(void) {
14773: int test_ret = 0;
14774:
14775: #if defined(LIBXML_SAX1_ENABLED)
14776: #ifdef LIBXML_SAX1_ENABLED
14777: int mem_base;
14778: xmlDocPtr ret_val;
14779: xmlSAXHandlerPtr sax; /* the SAX handler block */
14780: int n_sax;
14781: xmlChar * cur; /* a pointer to an array of xmlChar */
14782: int n_cur;
14783: int recovery; /* work in recovery mode, i.e. tries to read no Well Formed documents */
14784: int n_recovery;
14785:
14786: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
14787: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
14788: for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) {
14789: mem_base = xmlMemBlocks();
14790: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
14791: cur = gen_const_xmlChar_ptr(n_cur, 1);
14792: recovery = gen_int(n_recovery, 2);
14793:
14794: ret_val = xmlSAXParseDoc(sax, (const xmlChar *)cur, recovery);
14795: desret_xmlDocPtr(ret_val);
14796: call_tests++;
14797: des_xmlSAXHandlerPtr(n_sax, sax, 0);
14798: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 1);
14799: des_int(n_recovery, recovery, 2);
14800: xmlResetLastError();
14801: if (mem_base != xmlMemBlocks()) {
14802: printf("Leak of %d blocks found in xmlSAXParseDoc",
14803: xmlMemBlocks() - mem_base);
14804: test_ret++;
14805: printf(" %d", n_sax);
14806: printf(" %d", n_cur);
14807: printf(" %d", n_recovery);
14808: printf("\n");
14809: }
14810: }
14811: }
14812: }
14813: function_tests++;
14814: #endif
14815: #endif
14816:
14817: return(test_ret);
14818: }
14819:
14820:
14821: static int
14822: test_xmlSAXParseEntity(void) {
14823: int test_ret = 0;
14824:
14825: #if defined(LIBXML_SAX1_ENABLED)
14826: #ifdef LIBXML_SAX1_ENABLED
14827: int mem_base;
14828: xmlDocPtr ret_val;
14829: xmlSAXHandlerPtr sax; /* the SAX handler block */
14830: int n_sax;
14831: const char * filename; /* the filename */
14832: int n_filename;
14833:
14834: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
14835: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
14836: mem_base = xmlMemBlocks();
14837: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
14838: filename = gen_filepath(n_filename, 1);
14839:
14840: ret_val = xmlSAXParseEntity(sax, filename);
14841: desret_xmlDocPtr(ret_val);
14842: call_tests++;
14843: des_xmlSAXHandlerPtr(n_sax, sax, 0);
14844: des_filepath(n_filename, filename, 1);
14845: xmlResetLastError();
14846: if (mem_base != xmlMemBlocks()) {
14847: printf("Leak of %d blocks found in xmlSAXParseEntity",
14848: xmlMemBlocks() - mem_base);
14849: test_ret++;
14850: printf(" %d", n_sax);
14851: printf(" %d", n_filename);
14852: printf("\n");
14853: }
14854: }
14855: }
14856: function_tests++;
14857: #endif
14858: #endif
14859:
14860: return(test_ret);
14861: }
14862:
14863:
14864: static int
14865: test_xmlSAXParseFile(void) {
14866: int test_ret = 0;
14867:
14868: #if defined(LIBXML_SAX1_ENABLED)
14869: #ifdef LIBXML_SAX1_ENABLED
14870: int mem_base;
14871: xmlDocPtr ret_val;
14872: xmlSAXHandlerPtr sax; /* the SAX handler block */
14873: int n_sax;
14874: const char * filename; /* the filename */
14875: int n_filename;
14876: int recovery; /* work in recovery mode, i.e. tries to read no Well Formed documents */
14877: int n_recovery;
14878:
14879: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
14880: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
14881: for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) {
14882: mem_base = xmlMemBlocks();
14883: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
14884: filename = gen_filepath(n_filename, 1);
14885: recovery = gen_int(n_recovery, 2);
14886:
14887: ret_val = xmlSAXParseFile(sax, filename, recovery);
14888: desret_xmlDocPtr(ret_val);
14889: call_tests++;
14890: des_xmlSAXHandlerPtr(n_sax, sax, 0);
14891: des_filepath(n_filename, filename, 1);
14892: des_int(n_recovery, recovery, 2);
14893: xmlResetLastError();
14894: if (mem_base != xmlMemBlocks()) {
14895: printf("Leak of %d blocks found in xmlSAXParseFile",
14896: xmlMemBlocks() - mem_base);
14897: test_ret++;
14898: printf(" %d", n_sax);
14899: printf(" %d", n_filename);
14900: printf(" %d", n_recovery);
14901: printf("\n");
14902: }
14903: }
14904: }
14905: }
14906: function_tests++;
14907: #endif
14908: #endif
14909:
14910: return(test_ret);
14911: }
14912:
14913:
14914: static int
14915: test_xmlSAXParseFileWithData(void) {
14916: int test_ret = 0;
14917:
14918: #if defined(LIBXML_SAX1_ENABLED)
14919: #ifdef LIBXML_SAX1_ENABLED
14920: int mem_base;
14921: xmlDocPtr ret_val;
14922: xmlSAXHandlerPtr sax; /* the SAX handler block */
14923: int n_sax;
14924: const char * filename; /* the filename */
14925: int n_filename;
14926: int recovery; /* work in recovery mode, i.e. tries to read no Well Formed documents */
14927: int n_recovery;
14928: void * data; /* the userdata */
14929: int n_data;
14930:
14931: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
14932: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
14933: for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) {
14934: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
14935: mem_base = xmlMemBlocks();
14936: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
14937: filename = gen_filepath(n_filename, 1);
14938: recovery = gen_int(n_recovery, 2);
14939: data = gen_userdata(n_data, 3);
14940:
14941: ret_val = xmlSAXParseFileWithData(sax, filename, recovery, data);
14942: desret_xmlDocPtr(ret_val);
14943: call_tests++;
14944: des_xmlSAXHandlerPtr(n_sax, sax, 0);
14945: des_filepath(n_filename, filename, 1);
14946: des_int(n_recovery, recovery, 2);
14947: des_userdata(n_data, data, 3);
14948: xmlResetLastError();
14949: if (mem_base != xmlMemBlocks()) {
14950: printf("Leak of %d blocks found in xmlSAXParseFileWithData",
14951: xmlMemBlocks() - mem_base);
14952: test_ret++;
14953: printf(" %d", n_sax);
14954: printf(" %d", n_filename);
14955: printf(" %d", n_recovery);
14956: printf(" %d", n_data);
14957: printf("\n");
14958: }
14959: }
14960: }
14961: }
14962: }
14963: function_tests++;
14964: #endif
14965: #endif
14966:
14967: return(test_ret);
14968: }
14969:
14970:
14971: static int
14972: test_xmlSAXParseMemory(void) {
14973: int test_ret = 0;
14974:
14975: #if defined(LIBXML_SAX1_ENABLED)
14976: #ifdef LIBXML_SAX1_ENABLED
14977: int mem_base;
14978: xmlDocPtr ret_val;
14979: xmlSAXHandlerPtr sax; /* the SAX handler block */
14980: int n_sax;
14981: char * buffer; /* an pointer to a char array */
14982: int n_buffer;
14983: int size; /* the size of the array */
14984: int n_size;
14985: int recovery; /* work in recovery mode, i.e. tries to read not Well Formed documents */
14986: int n_recovery;
14987:
14988: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
14989: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
14990: for (n_size = 0;n_size < gen_nb_int;n_size++) {
14991: for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) {
14992: mem_base = xmlMemBlocks();
14993: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
14994: buffer = gen_const_char_ptr(n_buffer, 1);
14995: size = gen_int(n_size, 2);
14996: recovery = gen_int(n_recovery, 3);
14997:
14998: ret_val = xmlSAXParseMemory(sax, (const char *)buffer, size, recovery);
14999: desret_xmlDocPtr(ret_val);
15000: call_tests++;
15001: des_xmlSAXHandlerPtr(n_sax, sax, 0);
15002: des_const_char_ptr(n_buffer, (const char *)buffer, 1);
15003: des_int(n_size, size, 2);
15004: des_int(n_recovery, recovery, 3);
15005: xmlResetLastError();
15006: if (mem_base != xmlMemBlocks()) {
15007: printf("Leak of %d blocks found in xmlSAXParseMemory",
15008: xmlMemBlocks() - mem_base);
15009: test_ret++;
15010: printf(" %d", n_sax);
15011: printf(" %d", n_buffer);
15012: printf(" %d", n_size);
15013: printf(" %d", n_recovery);
15014: printf("\n");
15015: }
15016: }
15017: }
15018: }
15019: }
15020: function_tests++;
15021: #endif
15022: #endif
15023:
15024: return(test_ret);
15025: }
15026:
15027:
15028: static int
15029: test_xmlSAXParseMemoryWithData(void) {
15030: int test_ret = 0;
15031:
15032: #if defined(LIBXML_SAX1_ENABLED)
15033: #ifdef LIBXML_SAX1_ENABLED
15034: int mem_base;
15035: xmlDocPtr ret_val;
15036: xmlSAXHandlerPtr sax; /* the SAX handler block */
15037: int n_sax;
15038: char * buffer; /* an pointer to a char array */
15039: int n_buffer;
15040: int size; /* the size of the array */
15041: int n_size;
15042: int recovery; /* work in recovery mode, i.e. tries to read no Well Formed documents */
15043: int n_recovery;
15044: void * data; /* the userdata */
15045: int n_data;
15046:
15047: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
15048: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
15049: for (n_size = 0;n_size < gen_nb_int;n_size++) {
15050: for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) {
15051: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
15052: mem_base = xmlMemBlocks();
15053: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
15054: buffer = gen_const_char_ptr(n_buffer, 1);
15055: size = gen_int(n_size, 2);
15056: recovery = gen_int(n_recovery, 3);
15057: data = gen_userdata(n_data, 4);
15058:
15059: ret_val = xmlSAXParseMemoryWithData(sax, (const char *)buffer, size, recovery, data);
15060: desret_xmlDocPtr(ret_val);
15061: call_tests++;
15062: des_xmlSAXHandlerPtr(n_sax, sax, 0);
15063: des_const_char_ptr(n_buffer, (const char *)buffer, 1);
15064: des_int(n_size, size, 2);
15065: des_int(n_recovery, recovery, 3);
15066: des_userdata(n_data, data, 4);
15067: xmlResetLastError();
15068: if (mem_base != xmlMemBlocks()) {
15069: printf("Leak of %d blocks found in xmlSAXParseMemoryWithData",
15070: xmlMemBlocks() - mem_base);
15071: test_ret++;
15072: printf(" %d", n_sax);
15073: printf(" %d", n_buffer);
15074: printf(" %d", n_size);
15075: printf(" %d", n_recovery);
15076: printf(" %d", n_data);
15077: printf("\n");
15078: }
15079: }
15080: }
15081: }
15082: }
15083: }
15084: function_tests++;
15085: #endif
15086: #endif
15087:
15088: return(test_ret);
15089: }
15090:
15091:
15092: static int
15093: test_xmlSAXUserParseFile(void) {
15094: int test_ret = 0;
15095:
15096: #if defined(LIBXML_SAX1_ENABLED)
15097: #ifdef LIBXML_SAX1_ENABLED
15098: int mem_base;
15099: int ret_val;
15100: xmlSAXHandlerPtr sax; /* a SAX handler */
15101: int n_sax;
15102: void * user_data; /* The user data returned on SAX callbacks */
15103: int n_user_data;
15104: const char * filename; /* a file name */
15105: int n_filename;
15106:
15107: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
15108: for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
15109: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
15110: mem_base = xmlMemBlocks();
15111: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
15112: user_data = gen_userdata(n_user_data, 1);
15113: filename = gen_filepath(n_filename, 2);
15114:
15115: #ifdef LIBXML_SAX1_ENABLED
15116: if (sax == (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) user_data = NULL;
15117: #endif
15118:
15119:
15120: ret_val = xmlSAXUserParseFile(sax, user_data, filename);
15121: desret_int(ret_val);
15122: call_tests++;
15123: des_xmlSAXHandlerPtr(n_sax, sax, 0);
15124: des_userdata(n_user_data, user_data, 1);
15125: des_filepath(n_filename, filename, 2);
15126: xmlResetLastError();
15127: if (mem_base != xmlMemBlocks()) {
15128: printf("Leak of %d blocks found in xmlSAXUserParseFile",
15129: xmlMemBlocks() - mem_base);
15130: test_ret++;
15131: printf(" %d", n_sax);
15132: printf(" %d", n_user_data);
15133: printf(" %d", n_filename);
15134: printf("\n");
15135: }
15136: }
15137: }
15138: }
15139: function_tests++;
15140: #endif
15141: #endif
15142:
15143: return(test_ret);
15144: }
15145:
15146:
15147: static int
15148: test_xmlSAXUserParseMemory(void) {
15149: int test_ret = 0;
15150:
15151: #if defined(LIBXML_SAX1_ENABLED)
15152: #ifdef LIBXML_SAX1_ENABLED
15153: int mem_base;
15154: int ret_val;
15155: xmlSAXHandlerPtr sax; /* a SAX handler */
15156: int n_sax;
15157: void * user_data; /* The user data returned on SAX callbacks */
15158: int n_user_data;
15159: char * buffer; /* an in-memory XML document input */
15160: int n_buffer;
15161: int size; /* the length of the XML document in bytes */
15162: int n_size;
15163:
15164: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
15165: for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
15166: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
15167: for (n_size = 0;n_size < gen_nb_int;n_size++) {
15168: mem_base = xmlMemBlocks();
15169: sax = gen_xmlSAXHandlerPtr(n_sax, 0);
15170: user_data = gen_userdata(n_user_data, 1);
15171: buffer = gen_const_char_ptr(n_buffer, 2);
15172: size = gen_int(n_size, 3);
15173:
15174: #ifdef LIBXML_SAX1_ENABLED
15175: if (sax == (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) user_data = NULL;
15176: #endif
15177:
15178:
15179: ret_val = xmlSAXUserParseMemory(sax, user_data, (const char *)buffer, size);
15180: desret_int(ret_val);
15181: call_tests++;
15182: des_xmlSAXHandlerPtr(n_sax, sax, 0);
15183: des_userdata(n_user_data, user_data, 1);
15184: des_const_char_ptr(n_buffer, (const char *)buffer, 2);
15185: des_int(n_size, size, 3);
15186: xmlResetLastError();
15187: if (mem_base != xmlMemBlocks()) {
15188: printf("Leak of %d blocks found in xmlSAXUserParseMemory",
15189: xmlMemBlocks() - mem_base);
15190: test_ret++;
15191: printf(" %d", n_sax);
15192: printf(" %d", n_user_data);
15193: printf(" %d", n_buffer);
15194: printf(" %d", n_size);
15195: printf("\n");
15196: }
15197: }
15198: }
15199: }
15200: }
15201: function_tests++;
15202: #endif
15203: #endif
15204:
15205: return(test_ret);
15206: }
15207:
15208:
15209: static int
15210: test_xmlSetExternalEntityLoader(void) {
15211: int test_ret = 0;
15212:
15213:
15214: /* missing type support */
15215: return(test_ret);
15216: }
15217:
15218:
15219: static int
15220: test_xmlSetFeature(void) {
15221: int test_ret = 0;
15222:
15223: #if defined(LIBXML_LEGACY_ENABLED)
15224: #ifdef LIBXML_LEGACY_ENABLED
15225: int mem_base;
15226: int ret_val;
15227: xmlParserCtxtPtr ctxt; /* an XML/HTML parser context */
15228: int n_ctxt;
15229: char * name; /* the feature name */
15230: int n_name;
15231: void * value; /* pointer to the location of the new value */
15232: int n_value;
15233:
15234: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15235: for (n_name = 0;n_name < gen_nb_const_char_ptr;n_name++) {
15236: for (n_value = 0;n_value < gen_nb_void_ptr;n_value++) {
15237: mem_base = xmlMemBlocks();
15238: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15239: name = gen_const_char_ptr(n_name, 1);
15240: value = gen_void_ptr(n_value, 2);
15241:
15242: ret_val = xmlSetFeature(ctxt, (const char *)name, value);
15243: desret_int(ret_val);
15244: call_tests++;
15245: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15246: des_const_char_ptr(n_name, (const char *)name, 1);
15247: des_void_ptr(n_value, value, 2);
15248: xmlResetLastError();
15249: if (mem_base != xmlMemBlocks()) {
15250: printf("Leak of %d blocks found in xmlSetFeature",
15251: xmlMemBlocks() - mem_base);
15252: test_ret++;
15253: printf(" %d", n_ctxt);
15254: printf(" %d", n_name);
15255: printf(" %d", n_value);
15256: printf("\n");
15257: }
15258: }
15259: }
15260: }
15261: function_tests++;
15262: #endif
15263: #endif
15264:
15265: return(test_ret);
15266: }
15267:
15268:
15269: static int
15270: test_xmlSetupParserForBuffer(void) {
15271: int test_ret = 0;
15272:
15273: #if defined(LIBXML_SAX1_ENABLED)
15274: #ifdef LIBXML_SAX1_ENABLED
15275: int mem_base;
15276: xmlParserCtxtPtr ctxt; /* an XML parser context */
15277: int n_ctxt;
15278: xmlChar * buffer; /* a xmlChar * buffer */
15279: int n_buffer;
15280: const char * filename; /* a file name */
15281: int n_filename;
15282:
15283: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15284: for (n_buffer = 0;n_buffer < gen_nb_const_xmlChar_ptr;n_buffer++) {
15285: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
15286: mem_base = xmlMemBlocks();
15287: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15288: buffer = gen_const_xmlChar_ptr(n_buffer, 1);
15289: filename = gen_filepath(n_filename, 2);
15290:
15291: xmlSetupParserForBuffer(ctxt, (const xmlChar *)buffer, filename);
15292: call_tests++;
15293: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15294: des_const_xmlChar_ptr(n_buffer, (const xmlChar *)buffer, 1);
15295: des_filepath(n_filename, filename, 2);
15296: xmlResetLastError();
15297: if (mem_base != xmlMemBlocks()) {
15298: printf("Leak of %d blocks found in xmlSetupParserForBuffer",
15299: xmlMemBlocks() - mem_base);
15300: test_ret++;
15301: printf(" %d", n_ctxt);
15302: printf(" %d", n_buffer);
15303: printf(" %d", n_filename);
15304: printf("\n");
15305: }
15306: }
15307: }
15308: }
15309: function_tests++;
15310: #endif
15311: #endif
15312:
15313: return(test_ret);
15314: }
15315:
15316:
15317: static int
15318: test_xmlStopParser(void) {
15319: int test_ret = 0;
15320:
15321: #ifdef LIBXML_PUSH_ENABLED
15322: int mem_base;
15323: xmlParserCtxtPtr ctxt; /* an XML parser context */
15324: int n_ctxt;
15325:
15326: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15327: mem_base = xmlMemBlocks();
15328: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15329:
15330: xmlStopParser(ctxt);
15331: call_tests++;
15332: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15333: xmlResetLastError();
15334: if (mem_base != xmlMemBlocks()) {
15335: printf("Leak of %d blocks found in xmlStopParser",
15336: xmlMemBlocks() - mem_base);
15337: test_ret++;
15338: printf(" %d", n_ctxt);
15339: printf("\n");
15340: }
15341: }
15342: function_tests++;
15343: #endif
15344:
15345: return(test_ret);
15346: }
15347:
15348:
15349: static int
15350: test_xmlSubstituteEntitiesDefault(void) {
15351: int test_ret = 0;
15352:
15353: int mem_base;
15354: int ret_val;
15355: int val; /* int 0 or 1 */
15356: int n_val;
15357:
15358: for (n_val = 0;n_val < gen_nb_int;n_val++) {
15359: mem_base = xmlMemBlocks();
15360: val = gen_int(n_val, 0);
15361:
15362: ret_val = xmlSubstituteEntitiesDefault(val);
15363: desret_int(ret_val);
15364: call_tests++;
15365: des_int(n_val, val, 0);
15366: xmlResetLastError();
15367: if (mem_base != xmlMemBlocks()) {
15368: printf("Leak of %d blocks found in xmlSubstituteEntitiesDefault",
15369: xmlMemBlocks() - mem_base);
15370: test_ret++;
15371: printf(" %d", n_val);
15372: printf("\n");
15373: }
15374: }
15375: function_tests++;
15376:
15377: return(test_ret);
15378: }
15379:
15380: static int
15381: test_parser(void) {
15382: int test_ret = 0;
15383:
15384: if (quiet == 0) printf("Testing parser : 61 of 70 functions ...\n");
15385: test_ret += test_xmlByteConsumed();
15386: test_ret += test_xmlClearNodeInfoSeq();
15387: test_ret += test_xmlClearParserCtxt();
15388: test_ret += test_xmlCreateDocParserCtxt();
15389: test_ret += test_xmlCreatePushParserCtxt();
15390: test_ret += test_xmlCtxtReadDoc();
15391: test_ret += test_xmlCtxtReadFile();
15392: test_ret += test_xmlCtxtReadMemory();
15393: test_ret += test_xmlCtxtReset();
15394: test_ret += test_xmlCtxtResetPush();
15395: test_ret += test_xmlCtxtUseOptions();
15396: test_ret += test_xmlGetExternalEntityLoader();
15397: test_ret += test_xmlGetFeature();
15398: test_ret += test_xmlGetFeaturesList();
15399: test_ret += test_xmlHasFeature();
15400: test_ret += test_xmlIOParseDTD();
15401: test_ret += test_xmlInitNodeInfoSeq();
15402: test_ret += test_xmlInitParser();
15403: test_ret += test_xmlInitParserCtxt();
15404: test_ret += test_xmlKeepBlanksDefault();
15405: test_ret += test_xmlLineNumbersDefault();
15406: test_ret += test_xmlLoadExternalEntity();
15407: test_ret += test_xmlNewIOInputStream();
15408: test_ret += test_xmlNewParserCtxt();
15409: test_ret += test_xmlParseBalancedChunkMemory();
15410: test_ret += test_xmlParseBalancedChunkMemoryRecover();
15411: test_ret += test_xmlParseChunk();
15412: test_ret += test_xmlParseCtxtExternalEntity();
15413: test_ret += test_xmlParseDTD();
15414: test_ret += test_xmlParseDoc();
15415: test_ret += test_xmlParseDocument();
15416: test_ret += test_xmlParseEntity();
15417: test_ret += test_xmlParseExtParsedEnt();
15418: test_ret += test_xmlParseExternalEntity();
15419: test_ret += test_xmlParseFile();
15420: test_ret += test_xmlParseInNodeContext();
15421: test_ret += test_xmlParseMemory();
15422: test_ret += test_xmlParserAddNodeInfo();
15423: test_ret += test_xmlParserFindNodeInfo();
15424: test_ret += test_xmlParserFindNodeInfoIndex();
15425: test_ret += test_xmlParserInputGrow();
15426: test_ret += test_xmlParserInputRead();
15427: test_ret += test_xmlPedanticParserDefault();
15428: test_ret += test_xmlReadDoc();
15429: test_ret += test_xmlReadFile();
15430: test_ret += test_xmlReadMemory();
15431: test_ret += test_xmlRecoverDoc();
15432: test_ret += test_xmlRecoverFile();
15433: test_ret += test_xmlRecoverMemory();
15434: test_ret += test_xmlSAXParseDTD();
15435: test_ret += test_xmlSAXParseDoc();
15436: test_ret += test_xmlSAXParseEntity();
15437: test_ret += test_xmlSAXParseFile();
15438: test_ret += test_xmlSAXParseFileWithData();
15439: test_ret += test_xmlSAXParseMemory();
15440: test_ret += test_xmlSAXParseMemoryWithData();
15441: test_ret += test_xmlSAXUserParseFile();
15442: test_ret += test_xmlSAXUserParseMemory();
15443: test_ret += test_xmlSetExternalEntityLoader();
15444: test_ret += test_xmlSetFeature();
15445: test_ret += test_xmlSetupParserForBuffer();
15446: test_ret += test_xmlStopParser();
15447: test_ret += test_xmlSubstituteEntitiesDefault();
15448:
15449: if (test_ret != 0)
15450: printf("Module parser: %d errors\n", test_ret);
15451: return(test_ret);
15452: }
15453:
15454: static int
15455: test_htmlCreateFileParserCtxt(void) {
15456: int test_ret = 0;
15457:
15458: #if defined(LIBXML_HTML_ENABLED)
15459: int mem_base;
15460: htmlParserCtxtPtr ret_val;
15461: const char * filename; /* the filename */
15462: int n_filename;
15463: char * encoding; /* a free form C string describing the HTML document encoding, or NULL */
15464: int n_encoding;
15465:
15466: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
15467: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
15468: mem_base = xmlMemBlocks();
15469: filename = gen_fileoutput(n_filename, 0);
15470: encoding = gen_const_char_ptr(n_encoding, 1);
15471:
15472: ret_val = htmlCreateFileParserCtxt(filename, (const char *)encoding);
15473: desret_htmlParserCtxtPtr(ret_val);
15474: call_tests++;
15475: des_fileoutput(n_filename, filename, 0);
15476: des_const_char_ptr(n_encoding, (const char *)encoding, 1);
15477: xmlResetLastError();
15478: if (mem_base != xmlMemBlocks()) {
15479: printf("Leak of %d blocks found in htmlCreateFileParserCtxt",
15480: xmlMemBlocks() - mem_base);
15481: test_ret++;
15482: printf(" %d", n_filename);
15483: printf(" %d", n_encoding);
15484: printf("\n");
15485: }
15486: }
15487: }
15488: function_tests++;
15489: #endif
15490:
15491: return(test_ret);
15492: }
15493:
15494:
15495: static int
15496: test_htmlInitAutoClose(void) {
15497: int test_ret = 0;
15498:
15499: #if defined(LIBXML_HTML_ENABLED)
15500: int mem_base;
15501:
15502: mem_base = xmlMemBlocks();
15503:
15504: htmlInitAutoClose();
15505: call_tests++;
15506: xmlResetLastError();
15507: if (mem_base != xmlMemBlocks()) {
15508: printf("Leak of %d blocks found in htmlInitAutoClose",
15509: xmlMemBlocks() - mem_base);
15510: test_ret++;
15511: printf("\n");
15512: }
15513: function_tests++;
15514: #endif
15515:
15516: return(test_ret);
15517: }
15518:
15519:
15520: static int
15521: test_inputPop(void) {
15522: int test_ret = 0;
15523:
15524: int mem_base;
15525: xmlParserInputPtr ret_val;
15526: xmlParserCtxtPtr ctxt; /* an XML parser context */
15527: int n_ctxt;
15528:
15529: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15530: mem_base = xmlMemBlocks();
15531: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15532:
15533: ret_val = inputPop(ctxt);
15534: desret_xmlParserInputPtr(ret_val);
15535: call_tests++;
15536: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15537: xmlResetLastError();
15538: if (mem_base != xmlMemBlocks()) {
15539: printf("Leak of %d blocks found in inputPop",
15540: xmlMemBlocks() - mem_base);
15541: test_ret++;
15542: printf(" %d", n_ctxt);
15543: printf("\n");
15544: }
15545: }
15546: function_tests++;
15547:
15548: return(test_ret);
15549: }
15550:
15551:
15552: static int
15553: test_inputPush(void) {
15554: int test_ret = 0;
15555:
15556: int mem_base;
15557: int ret_val;
15558: xmlParserCtxtPtr ctxt; /* an XML parser context */
15559: int n_ctxt;
15560: xmlParserInputPtr value; /* the parser input */
15561: int n_value;
15562:
15563: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15564: for (n_value = 0;n_value < gen_nb_xmlParserInputPtr;n_value++) {
15565: mem_base = xmlMemBlocks();
15566: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15567: value = gen_xmlParserInputPtr(n_value, 1);
15568:
15569: ret_val = inputPush(ctxt, value);
15570: desret_int(ret_val);
15571: call_tests++;
15572: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15573: des_xmlParserInputPtr(n_value, value, 1);
15574: xmlResetLastError();
15575: if (mem_base != xmlMemBlocks()) {
15576: printf("Leak of %d blocks found in inputPush",
15577: xmlMemBlocks() - mem_base);
15578: test_ret++;
15579: printf(" %d", n_ctxt);
15580: printf(" %d", n_value);
15581: printf("\n");
15582: }
15583: }
15584: }
15585: function_tests++;
15586:
15587: return(test_ret);
15588: }
15589:
15590:
15591: static int
15592: test_namePop(void) {
15593: int test_ret = 0;
15594:
15595: int mem_base;
15596: const xmlChar * ret_val;
15597: xmlParserCtxtPtr ctxt; /* an XML parser context */
15598: int n_ctxt;
15599:
15600: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15601: mem_base = xmlMemBlocks();
15602: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15603:
15604: ret_val = namePop(ctxt);
15605: desret_const_xmlChar_ptr(ret_val);
15606: call_tests++;
15607: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15608: xmlResetLastError();
15609: if (mem_base != xmlMemBlocks()) {
15610: printf("Leak of %d blocks found in namePop",
15611: xmlMemBlocks() - mem_base);
15612: test_ret++;
15613: printf(" %d", n_ctxt);
15614: printf("\n");
15615: }
15616: }
15617: function_tests++;
15618:
15619: return(test_ret);
15620: }
15621:
15622:
15623: static int
15624: test_namePush(void) {
15625: int test_ret = 0;
15626:
15627: int mem_base;
15628: int ret_val;
15629: xmlParserCtxtPtr ctxt; /* an XML parser context */
15630: int n_ctxt;
15631: xmlChar * value; /* the element name */
15632: int n_value;
15633:
15634: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15635: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
15636: mem_base = xmlMemBlocks();
15637: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15638: value = gen_const_xmlChar_ptr(n_value, 1);
15639:
15640: ret_val = namePush(ctxt, (const xmlChar *)value);
15641: desret_int(ret_val);
15642: call_tests++;
15643: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15644: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
15645: xmlResetLastError();
15646: if (mem_base != xmlMemBlocks()) {
15647: printf("Leak of %d blocks found in namePush",
15648: xmlMemBlocks() - mem_base);
15649: test_ret++;
15650: printf(" %d", n_ctxt);
15651: printf(" %d", n_value);
15652: printf("\n");
15653: }
15654: }
15655: }
15656: function_tests++;
15657:
15658: return(test_ret);
15659: }
15660:
15661:
15662: static int
15663: test_nodePop(void) {
15664: int test_ret = 0;
15665:
15666: int mem_base;
15667: xmlNodePtr ret_val;
15668: xmlParserCtxtPtr ctxt; /* an XML parser context */
15669: int n_ctxt;
15670:
15671: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15672: mem_base = xmlMemBlocks();
15673: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15674:
15675: ret_val = nodePop(ctxt);
15676: desret_xmlNodePtr(ret_val);
15677: call_tests++;
15678: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15679: xmlResetLastError();
15680: if (mem_base != xmlMemBlocks()) {
15681: printf("Leak of %d blocks found in nodePop",
15682: xmlMemBlocks() - mem_base);
15683: test_ret++;
15684: printf(" %d", n_ctxt);
15685: printf("\n");
15686: }
15687: }
15688: function_tests++;
15689:
15690: return(test_ret);
15691: }
15692:
15693:
15694: static int
15695: test_nodePush(void) {
15696: int test_ret = 0;
15697:
15698: int mem_base;
15699: int ret_val;
15700: xmlParserCtxtPtr ctxt; /* an XML parser context */
15701: int n_ctxt;
15702: xmlNodePtr value; /* the element node */
15703: int n_value;
15704:
15705: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15706: for (n_value = 0;n_value < gen_nb_xmlNodePtr;n_value++) {
15707: mem_base = xmlMemBlocks();
15708: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15709: value = gen_xmlNodePtr(n_value, 1);
15710:
15711: ret_val = nodePush(ctxt, value);
15712: desret_int(ret_val);
15713: call_tests++;
15714: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15715: des_xmlNodePtr(n_value, value, 1);
15716: xmlResetLastError();
15717: if (mem_base != xmlMemBlocks()) {
15718: printf("Leak of %d blocks found in nodePush",
15719: xmlMemBlocks() - mem_base);
15720: test_ret++;
15721: printf(" %d", n_ctxt);
15722: printf(" %d", n_value);
15723: printf("\n");
15724: }
15725: }
15726: }
15727: function_tests++;
15728:
15729: return(test_ret);
15730: }
15731:
15732:
15733: static int
15734: test_xmlCheckLanguageID(void) {
15735: int test_ret = 0;
15736:
15737: int mem_base;
15738: int ret_val;
15739: xmlChar * lang; /* pointer to the string value */
15740: int n_lang;
15741:
15742: for (n_lang = 0;n_lang < gen_nb_const_xmlChar_ptr;n_lang++) {
15743: mem_base = xmlMemBlocks();
15744: lang = gen_const_xmlChar_ptr(n_lang, 0);
15745:
15746: ret_val = xmlCheckLanguageID((const xmlChar *)lang);
15747: desret_int(ret_val);
15748: call_tests++;
15749: des_const_xmlChar_ptr(n_lang, (const xmlChar *)lang, 0);
15750: xmlResetLastError();
15751: if (mem_base != xmlMemBlocks()) {
15752: printf("Leak of %d blocks found in xmlCheckLanguageID",
15753: xmlMemBlocks() - mem_base);
15754: test_ret++;
15755: printf(" %d", n_lang);
15756: printf("\n");
15757: }
15758: }
15759: function_tests++;
15760:
15761: return(test_ret);
15762: }
15763:
15764:
15765: static int
15766: test_xmlCopyChar(void) {
15767: int test_ret = 0;
15768:
15769: int mem_base;
15770: int ret_val;
15771: int len; /* Ignored, compatibility */
15772: int n_len;
15773: xmlChar * out; /* pointer to an array of xmlChar */
15774: int n_out;
15775: int val; /* the char value */
15776: int n_val;
15777:
15778: for (n_len = 0;n_len < gen_nb_int;n_len++) {
15779: for (n_out = 0;n_out < gen_nb_xmlChar_ptr;n_out++) {
15780: for (n_val = 0;n_val < gen_nb_int;n_val++) {
15781: mem_base = xmlMemBlocks();
15782: len = gen_int(n_len, 0);
15783: out = gen_xmlChar_ptr(n_out, 1);
15784: val = gen_int(n_val, 2);
15785:
15786: ret_val = xmlCopyChar(len, out, val);
15787: desret_int(ret_val);
15788: call_tests++;
15789: des_int(n_len, len, 0);
15790: des_xmlChar_ptr(n_out, out, 1);
15791: des_int(n_val, val, 2);
15792: xmlResetLastError();
15793: if (mem_base != xmlMemBlocks()) {
15794: printf("Leak of %d blocks found in xmlCopyChar",
15795: xmlMemBlocks() - mem_base);
15796: test_ret++;
15797: printf(" %d", n_len);
15798: printf(" %d", n_out);
15799: printf(" %d", n_val);
15800: printf("\n");
15801: }
15802: }
15803: }
15804: }
15805: function_tests++;
15806:
15807: return(test_ret);
15808: }
15809:
15810:
15811: static int
15812: test_xmlCopyCharMultiByte(void) {
15813: int test_ret = 0;
15814:
15815: int mem_base;
15816: int ret_val;
15817: xmlChar * out; /* pointer to an array of xmlChar */
15818: int n_out;
15819: int val; /* the char value */
15820: int n_val;
15821:
15822: for (n_out = 0;n_out < gen_nb_xmlChar_ptr;n_out++) {
15823: for (n_val = 0;n_val < gen_nb_int;n_val++) {
15824: mem_base = xmlMemBlocks();
15825: out = gen_xmlChar_ptr(n_out, 0);
15826: val = gen_int(n_val, 1);
15827:
15828: ret_val = xmlCopyCharMultiByte(out, val);
15829: desret_int(ret_val);
15830: call_tests++;
15831: des_xmlChar_ptr(n_out, out, 0);
15832: des_int(n_val, val, 1);
15833: xmlResetLastError();
15834: if (mem_base != xmlMemBlocks()) {
15835: printf("Leak of %d blocks found in xmlCopyCharMultiByte",
15836: xmlMemBlocks() - mem_base);
15837: test_ret++;
15838: printf(" %d", n_out);
15839: printf(" %d", n_val);
15840: printf("\n");
15841: }
15842: }
15843: }
15844: function_tests++;
15845:
15846: return(test_ret);
15847: }
15848:
15849:
15850: static int
15851: test_xmlCreateEntityParserCtxt(void) {
15852: int test_ret = 0;
15853:
15854: int mem_base;
15855: xmlParserCtxtPtr ret_val;
15856: xmlChar * URL; /* the entity URL */
15857: int n_URL;
15858: xmlChar * ID; /* the entity PUBLIC ID */
15859: int n_ID;
15860: xmlChar * base; /* a possible base for the target URI */
15861: int n_base;
15862:
15863: for (n_URL = 0;n_URL < gen_nb_const_xmlChar_ptr;n_URL++) {
15864: for (n_ID = 0;n_ID < gen_nb_const_xmlChar_ptr;n_ID++) {
15865: for (n_base = 0;n_base < gen_nb_const_xmlChar_ptr;n_base++) {
15866: mem_base = xmlMemBlocks();
15867: URL = gen_const_xmlChar_ptr(n_URL, 0);
15868: ID = gen_const_xmlChar_ptr(n_ID, 1);
15869: base = gen_const_xmlChar_ptr(n_base, 2);
15870:
15871: ret_val = xmlCreateEntityParserCtxt((const xmlChar *)URL, (const xmlChar *)ID, (const xmlChar *)base);
15872: desret_xmlParserCtxtPtr(ret_val);
15873: call_tests++;
15874: des_const_xmlChar_ptr(n_URL, (const xmlChar *)URL, 0);
15875: des_const_xmlChar_ptr(n_ID, (const xmlChar *)ID, 1);
15876: des_const_xmlChar_ptr(n_base, (const xmlChar *)base, 2);
15877: xmlResetLastError();
15878: if (mem_base != xmlMemBlocks()) {
15879: printf("Leak of %d blocks found in xmlCreateEntityParserCtxt",
15880: xmlMemBlocks() - mem_base);
15881: test_ret++;
15882: printf(" %d", n_URL);
15883: printf(" %d", n_ID);
15884: printf(" %d", n_base);
15885: printf("\n");
15886: }
15887: }
15888: }
15889: }
15890: function_tests++;
15891:
15892: return(test_ret);
15893: }
15894:
15895:
15896: static int
15897: test_xmlCreateFileParserCtxt(void) {
15898: int test_ret = 0;
15899:
15900: int mem_base;
15901: xmlParserCtxtPtr ret_val;
15902: const char * filename; /* the filename */
15903: int n_filename;
15904:
15905: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
15906: mem_base = xmlMemBlocks();
15907: filename = gen_fileoutput(n_filename, 0);
15908:
15909: ret_val = xmlCreateFileParserCtxt(filename);
15910: desret_xmlParserCtxtPtr(ret_val);
15911: call_tests++;
15912: des_fileoutput(n_filename, filename, 0);
15913: xmlResetLastError();
15914: if (mem_base != xmlMemBlocks()) {
15915: printf("Leak of %d blocks found in xmlCreateFileParserCtxt",
15916: xmlMemBlocks() - mem_base);
15917: test_ret++;
15918: printf(" %d", n_filename);
15919: printf("\n");
15920: }
15921: }
15922: function_tests++;
15923:
15924: return(test_ret);
15925: }
15926:
15927:
15928: static int
15929: test_xmlCreateMemoryParserCtxt(void) {
15930: int test_ret = 0;
15931:
15932: int mem_base;
15933: xmlParserCtxtPtr ret_val;
15934: char * buffer; /* a pointer to a char array */
15935: int n_buffer;
15936: int size; /* the size of the array */
15937: int n_size;
15938:
15939: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
15940: for (n_size = 0;n_size < gen_nb_int;n_size++) {
15941: mem_base = xmlMemBlocks();
15942: buffer = gen_const_char_ptr(n_buffer, 0);
15943: size = gen_int(n_size, 1);
15944:
15945: ret_val = xmlCreateMemoryParserCtxt((const char *)buffer, size);
15946: desret_xmlParserCtxtPtr(ret_val);
15947: call_tests++;
15948: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
15949: des_int(n_size, size, 1);
15950: xmlResetLastError();
15951: if (mem_base != xmlMemBlocks()) {
15952: printf("Leak of %d blocks found in xmlCreateMemoryParserCtxt",
15953: xmlMemBlocks() - mem_base);
15954: test_ret++;
15955: printf(" %d", n_buffer);
15956: printf(" %d", n_size);
15957: printf("\n");
15958: }
15959: }
15960: }
15961: function_tests++;
15962:
15963: return(test_ret);
15964: }
15965:
15966:
15967: static int
15968: test_xmlCreateURLParserCtxt(void) {
15969: int test_ret = 0;
15970:
15971: int mem_base;
15972: xmlParserCtxtPtr ret_val;
15973: const char * filename; /* the filename or URL */
15974: int n_filename;
15975: int options; /* a combination of xmlParserOption */
15976: int n_options;
15977:
15978: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
15979: for (n_options = 0;n_options < gen_nb_int;n_options++) {
15980: mem_base = xmlMemBlocks();
15981: filename = gen_fileoutput(n_filename, 0);
15982: options = gen_int(n_options, 1);
15983:
15984: ret_val = xmlCreateURLParserCtxt(filename, options);
15985: desret_xmlParserCtxtPtr(ret_val);
15986: call_tests++;
15987: des_fileoutput(n_filename, filename, 0);
15988: des_int(n_options, options, 1);
15989: xmlResetLastError();
15990: if (mem_base != xmlMemBlocks()) {
15991: printf("Leak of %d blocks found in xmlCreateURLParserCtxt",
15992: xmlMemBlocks() - mem_base);
15993: test_ret++;
15994: printf(" %d", n_filename);
15995: printf(" %d", n_options);
15996: printf("\n");
15997: }
15998: }
15999: }
16000: function_tests++;
16001:
16002: return(test_ret);
16003: }
16004:
16005:
16006: static int
16007: test_xmlCurrentChar(void) {
16008: int test_ret = 0;
16009:
16010: int mem_base;
16011: int ret_val;
16012: xmlParserCtxtPtr ctxt; /* the XML parser context */
16013: int n_ctxt;
16014: int * len; /* pointer to the length of the char read */
16015: int n_len;
16016:
16017: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16018: for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
16019: mem_base = xmlMemBlocks();
16020: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16021: len = gen_int_ptr(n_len, 1);
16022:
16023: ret_val = xmlCurrentChar(ctxt, len);
16024: desret_int(ret_val);
16025: call_tests++;
16026: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16027: des_int_ptr(n_len, len, 1);
16028: xmlResetLastError();
16029: if (mem_base != xmlMemBlocks()) {
16030: printf("Leak of %d blocks found in xmlCurrentChar",
16031: xmlMemBlocks() - mem_base);
16032: test_ret++;
16033: printf(" %d", n_ctxt);
16034: printf(" %d", n_len);
16035: printf("\n");
16036: }
16037: }
16038: }
16039: function_tests++;
16040:
16041: return(test_ret);
16042: }
16043:
16044:
16045: static int
16046: test_xmlErrMemory(void) {
16047: int test_ret = 0;
16048:
16049: int mem_base;
16050: xmlParserCtxtPtr ctxt; /* an XML parser context */
16051: int n_ctxt;
16052: char * extra; /* extra informations */
16053: int n_extra;
16054:
16055: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16056: for (n_extra = 0;n_extra < gen_nb_const_char_ptr;n_extra++) {
16057: mem_base = xmlMemBlocks();
16058: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16059: extra = gen_const_char_ptr(n_extra, 1);
16060:
16061: xmlErrMemory(ctxt, (const char *)extra);
16062: call_tests++;
16063: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16064: des_const_char_ptr(n_extra, (const char *)extra, 1);
16065: xmlResetLastError();
16066: if (mem_base != xmlMemBlocks()) {
16067: printf("Leak of %d blocks found in xmlErrMemory",
16068: xmlMemBlocks() - mem_base);
16069: test_ret++;
16070: printf(" %d", n_ctxt);
16071: printf(" %d", n_extra);
16072: printf("\n");
16073: }
16074: }
16075: }
16076: function_tests++;
16077:
16078: return(test_ret);
16079: }
16080:
16081:
16082: static int
16083: test_xmlIsLetter(void) {
16084: int test_ret = 0;
16085:
16086: int mem_base;
16087: int ret_val;
16088: int c; /* an unicode character (int) */
16089: int n_c;
16090:
16091: for (n_c = 0;n_c < gen_nb_int;n_c++) {
16092: mem_base = xmlMemBlocks();
16093: c = gen_int(n_c, 0);
16094:
16095: ret_val = xmlIsLetter(c);
16096: desret_int(ret_val);
16097: call_tests++;
16098: des_int(n_c, c, 0);
16099: xmlResetLastError();
16100: if (mem_base != xmlMemBlocks()) {
16101: printf("Leak of %d blocks found in xmlIsLetter",
16102: xmlMemBlocks() - mem_base);
16103: test_ret++;
16104: printf(" %d", n_c);
16105: printf("\n");
16106: }
16107: }
16108: function_tests++;
16109:
16110: return(test_ret);
16111: }
16112:
16113:
16114: static int
16115: test_xmlNewEntityInputStream(void) {
16116: int test_ret = 0;
16117:
16118: int mem_base;
16119: xmlParserInputPtr ret_val;
16120: xmlParserCtxtPtr ctxt; /* an XML parser context */
16121: int n_ctxt;
16122: xmlEntityPtr entity; /* an Entity pointer */
16123: int n_entity;
16124:
16125: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16126: for (n_entity = 0;n_entity < gen_nb_xmlEntityPtr;n_entity++) {
16127: mem_base = xmlMemBlocks();
16128: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16129: entity = gen_xmlEntityPtr(n_entity, 1);
16130:
16131: ret_val = xmlNewEntityInputStream(ctxt, entity);
16132: desret_xmlParserInputPtr(ret_val);
16133: call_tests++;
16134: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16135: des_xmlEntityPtr(n_entity, entity, 1);
16136: xmlResetLastError();
16137: if (mem_base != xmlMemBlocks()) {
16138: printf("Leak of %d blocks found in xmlNewEntityInputStream",
16139: xmlMemBlocks() - mem_base);
16140: test_ret++;
16141: printf(" %d", n_ctxt);
16142: printf(" %d", n_entity);
16143: printf("\n");
16144: }
16145: }
16146: }
16147: function_tests++;
16148:
16149: return(test_ret);
16150: }
16151:
16152:
16153: static int
16154: test_xmlNewInputFromFile(void) {
16155: int test_ret = 0;
16156:
16157: int mem_base;
16158: xmlParserInputPtr ret_val;
16159: xmlParserCtxtPtr ctxt; /* an XML parser context */
16160: int n_ctxt;
16161: const char * filename; /* the filename to use as entity */
16162: int n_filename;
16163:
16164: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16165: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
16166: mem_base = xmlMemBlocks();
16167: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16168: filename = gen_filepath(n_filename, 1);
16169:
16170: ret_val = xmlNewInputFromFile(ctxt, filename);
16171: desret_xmlParserInputPtr(ret_val);
16172: call_tests++;
16173: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16174: des_filepath(n_filename, filename, 1);
16175: xmlResetLastError();
16176: if (mem_base != xmlMemBlocks()) {
16177: printf("Leak of %d blocks found in xmlNewInputFromFile",
16178: xmlMemBlocks() - mem_base);
16179: test_ret++;
16180: printf(" %d", n_ctxt);
16181: printf(" %d", n_filename);
16182: printf("\n");
16183: }
16184: }
16185: }
16186: function_tests++;
16187:
16188: return(test_ret);
16189: }
16190:
16191:
16192: static int
16193: test_xmlNewInputStream(void) {
16194: int test_ret = 0;
16195:
16196: int mem_base;
16197: xmlParserInputPtr ret_val;
16198: xmlParserCtxtPtr ctxt; /* an XML parser context */
16199: int n_ctxt;
16200:
16201: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16202: mem_base = xmlMemBlocks();
16203: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16204:
16205: ret_val = xmlNewInputStream(ctxt);
16206: desret_xmlParserInputPtr(ret_val);
16207: call_tests++;
16208: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16209: xmlResetLastError();
16210: if (mem_base != xmlMemBlocks()) {
16211: printf("Leak of %d blocks found in xmlNewInputStream",
16212: xmlMemBlocks() - mem_base);
16213: test_ret++;
16214: printf(" %d", n_ctxt);
16215: printf("\n");
16216: }
16217: }
16218: function_tests++;
16219:
16220: return(test_ret);
16221: }
16222:
16223:
16224: static int
16225: test_xmlNewStringInputStream(void) {
16226: int test_ret = 0;
16227:
16228: int mem_base;
16229: xmlParserInputPtr ret_val;
16230: xmlParserCtxtPtr ctxt; /* an XML parser context */
16231: int n_ctxt;
16232: xmlChar * buffer; /* an memory buffer */
16233: int n_buffer;
16234:
16235: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16236: for (n_buffer = 0;n_buffer < gen_nb_const_xmlChar_ptr;n_buffer++) {
16237: mem_base = xmlMemBlocks();
16238: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16239: buffer = gen_const_xmlChar_ptr(n_buffer, 1);
16240:
16241: ret_val = xmlNewStringInputStream(ctxt, (const xmlChar *)buffer);
16242: desret_xmlParserInputPtr(ret_val);
16243: call_tests++;
16244: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16245: des_const_xmlChar_ptr(n_buffer, (const xmlChar *)buffer, 1);
16246: xmlResetLastError();
16247: if (mem_base != xmlMemBlocks()) {
16248: printf("Leak of %d blocks found in xmlNewStringInputStream",
16249: xmlMemBlocks() - mem_base);
16250: test_ret++;
16251: printf(" %d", n_ctxt);
16252: printf(" %d", n_buffer);
16253: printf("\n");
16254: }
16255: }
16256: }
16257: function_tests++;
16258:
16259: return(test_ret);
16260: }
16261:
16262:
16263: static int
16264: test_xmlNextChar(void) {
16265: int test_ret = 0;
16266:
16267: int mem_base;
16268: xmlParserCtxtPtr ctxt; /* the XML parser context */
16269: int n_ctxt;
16270:
16271: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16272: mem_base = xmlMemBlocks();
16273: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16274:
16275: xmlNextChar(ctxt);
16276: call_tests++;
16277: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16278: xmlResetLastError();
16279: if (mem_base != xmlMemBlocks()) {
16280: printf("Leak of %d blocks found in xmlNextChar",
16281: xmlMemBlocks() - mem_base);
16282: test_ret++;
16283: printf(" %d", n_ctxt);
16284: printf("\n");
16285: }
16286: }
16287: function_tests++;
16288:
16289: return(test_ret);
16290: }
16291:
16292:
16293: static int
16294: test_xmlParserInputShrink(void) {
16295: int test_ret = 0;
16296:
16297: int mem_base;
16298: xmlParserInputPtr in; /* an XML parser input */
16299: int n_in;
16300:
16301: for (n_in = 0;n_in < gen_nb_xmlParserInputPtr;n_in++) {
16302: mem_base = xmlMemBlocks();
16303: in = gen_xmlParserInputPtr(n_in, 0);
16304:
16305: xmlParserInputShrink(in);
16306: call_tests++;
16307: des_xmlParserInputPtr(n_in, in, 0);
16308: xmlResetLastError();
16309: if (mem_base != xmlMemBlocks()) {
16310: printf("Leak of %d blocks found in xmlParserInputShrink",
16311: xmlMemBlocks() - mem_base);
16312: test_ret++;
16313: printf(" %d", n_in);
16314: printf("\n");
16315: }
16316: }
16317: function_tests++;
16318:
16319: return(test_ret);
16320: }
16321:
16322:
16323: static int
16324: test_xmlPopInput(void) {
16325: int test_ret = 0;
16326:
16327: int mem_base;
16328: xmlChar ret_val;
16329: xmlParserCtxtPtr ctxt; /* an XML parser context */
16330: int n_ctxt;
16331:
16332: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16333: mem_base = xmlMemBlocks();
16334: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16335:
16336: ret_val = xmlPopInput(ctxt);
16337: desret_xmlChar(ret_val);
16338: call_tests++;
16339: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16340: xmlResetLastError();
16341: if (mem_base != xmlMemBlocks()) {
16342: printf("Leak of %d blocks found in xmlPopInput",
16343: xmlMemBlocks() - mem_base);
16344: test_ret++;
16345: printf(" %d", n_ctxt);
16346: printf("\n");
16347: }
16348: }
16349: function_tests++;
16350:
16351: return(test_ret);
16352: }
16353:
16354:
16355: static int
16356: test_xmlPushInput(void) {
16357: int test_ret = 0;
16358:
16359: int mem_base;
16360: int ret_val;
16361: xmlParserCtxtPtr ctxt; /* an XML parser context */
16362: int n_ctxt;
16363: xmlParserInputPtr input; /* an XML parser input fragment (entity, XML fragment ...). */
16364: int n_input;
16365:
16366: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16367: for (n_input = 0;n_input < gen_nb_xmlParserInputPtr;n_input++) {
16368: mem_base = xmlMemBlocks();
16369: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16370: input = gen_xmlParserInputPtr(n_input, 1);
16371:
16372: ret_val = xmlPushInput(ctxt, input);
16373: desret_int(ret_val);
16374: call_tests++;
16375: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16376: des_xmlParserInputPtr(n_input, input, 1);
16377: xmlResetLastError();
16378: if (mem_base != xmlMemBlocks()) {
16379: printf("Leak of %d blocks found in xmlPushInput",
16380: xmlMemBlocks() - mem_base);
16381: test_ret++;
16382: printf(" %d", n_ctxt);
16383: printf(" %d", n_input);
16384: printf("\n");
16385: }
16386: }
16387: }
16388: function_tests++;
16389:
16390: return(test_ret);
16391: }
16392:
16393:
16394: static int
16395: test_xmlSetEntityReferenceFunc(void) {
16396: int test_ret = 0;
16397:
16398:
16399: /* missing type support */
16400: return(test_ret);
16401: }
16402:
16403:
16404: static int
16405: test_xmlSplitQName(void) {
16406: int test_ret = 0;
16407:
16408: int mem_base;
16409: xmlChar * ret_val;
16410: xmlParserCtxtPtr ctxt; /* an XML parser context */
16411: int n_ctxt;
16412: xmlChar * name; /* an XML parser context */
16413: int n_name;
16414: xmlChar ** prefix; /* a xmlChar ** */
16415: int n_prefix;
16416:
16417: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16418: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
16419: for (n_prefix = 0;n_prefix < gen_nb_xmlChar_ptr_ptr;n_prefix++) {
16420: mem_base = xmlMemBlocks();
16421: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16422: name = gen_const_xmlChar_ptr(n_name, 1);
16423: prefix = gen_xmlChar_ptr_ptr(n_prefix, 2);
16424:
16425: ret_val = xmlSplitQName(ctxt, (const xmlChar *)name, prefix);
16426: desret_xmlChar_ptr(ret_val);
16427: call_tests++;
16428: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16429: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
16430: des_xmlChar_ptr_ptr(n_prefix, prefix, 2);
16431: xmlResetLastError();
16432: if (mem_base != xmlMemBlocks()) {
16433: printf("Leak of %d blocks found in xmlSplitQName",
16434: xmlMemBlocks() - mem_base);
16435: test_ret++;
16436: printf(" %d", n_ctxt);
16437: printf(" %d", n_name);
16438: printf(" %d", n_prefix);
16439: printf("\n");
16440: }
16441: }
16442: }
16443: }
16444: function_tests++;
16445:
16446: return(test_ret);
16447: }
16448:
16449:
16450: static int
16451: test_xmlStringCurrentChar(void) {
16452: int test_ret = 0;
16453:
16454: int mem_base;
16455: int ret_val;
16456: xmlParserCtxtPtr ctxt; /* the XML parser context */
16457: int n_ctxt;
16458: xmlChar * cur; /* pointer to the beginning of the char */
16459: int n_cur;
16460: int * len; /* pointer to the length of the char read */
16461: int n_len;
16462:
16463: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16464: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
16465: for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
16466: mem_base = xmlMemBlocks();
16467: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16468: cur = gen_const_xmlChar_ptr(n_cur, 1);
16469: len = gen_int_ptr(n_len, 2);
16470:
16471: ret_val = xmlStringCurrentChar(ctxt, (const xmlChar *)cur, len);
16472: desret_int(ret_val);
16473: call_tests++;
16474: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16475: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 1);
16476: des_int_ptr(n_len, len, 2);
16477: xmlResetLastError();
16478: if (mem_base != xmlMemBlocks()) {
16479: printf("Leak of %d blocks found in xmlStringCurrentChar",
16480: xmlMemBlocks() - mem_base);
16481: test_ret++;
16482: printf(" %d", n_ctxt);
16483: printf(" %d", n_cur);
16484: printf(" %d", n_len);
16485: printf("\n");
16486: }
16487: }
16488: }
16489: }
16490: function_tests++;
16491:
16492: return(test_ret);
16493: }
16494:
16495:
16496: static int
16497: test_xmlStringDecodeEntities(void) {
16498: int test_ret = 0;
16499:
16500: int mem_base;
16501: xmlChar * ret_val;
16502: xmlParserCtxtPtr ctxt; /* the parser context */
16503: int n_ctxt;
16504: xmlChar * str; /* the input string */
16505: int n_str;
16506: int what; /* combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF */
16507: int n_what;
16508: xmlChar end; /* an end marker xmlChar, 0 if none */
16509: int n_end;
16510: xmlChar end2; /* an end marker xmlChar, 0 if none */
16511: int n_end2;
16512: xmlChar end3; /* an end marker xmlChar, 0 if none */
16513: int n_end3;
16514:
16515: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16516: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
16517: for (n_what = 0;n_what < gen_nb_int;n_what++) {
16518: for (n_end = 0;n_end < gen_nb_xmlChar;n_end++) {
16519: for (n_end2 = 0;n_end2 < gen_nb_xmlChar;n_end2++) {
16520: for (n_end3 = 0;n_end3 < gen_nb_xmlChar;n_end3++) {
16521: mem_base = xmlMemBlocks();
16522: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16523: str = gen_const_xmlChar_ptr(n_str, 1);
16524: what = gen_int(n_what, 2);
16525: end = gen_xmlChar(n_end, 3);
16526: end2 = gen_xmlChar(n_end2, 4);
16527: end3 = gen_xmlChar(n_end3, 5);
16528:
16529: ret_val = xmlStringDecodeEntities(ctxt, (const xmlChar *)str, what, end, end2, end3);
16530: desret_xmlChar_ptr(ret_val);
16531: call_tests++;
16532: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16533: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
16534: des_int(n_what, what, 2);
16535: des_xmlChar(n_end, end, 3);
16536: des_xmlChar(n_end2, end2, 4);
16537: des_xmlChar(n_end3, end3, 5);
16538: xmlResetLastError();
16539: if (mem_base != xmlMemBlocks()) {
16540: printf("Leak of %d blocks found in xmlStringDecodeEntities",
16541: xmlMemBlocks() - mem_base);
16542: test_ret++;
16543: printf(" %d", n_ctxt);
16544: printf(" %d", n_str);
16545: printf(" %d", n_what);
16546: printf(" %d", n_end);
16547: printf(" %d", n_end2);
16548: printf(" %d", n_end3);
16549: printf("\n");
16550: }
16551: }
16552: }
16553: }
16554: }
16555: }
16556: }
16557: function_tests++;
16558:
16559: return(test_ret);
16560: }
16561:
16562:
16563: static int
16564: test_xmlStringLenDecodeEntities(void) {
16565: int test_ret = 0;
16566:
16567: int mem_base;
16568: xmlChar * ret_val;
16569: xmlParserCtxtPtr ctxt; /* the parser context */
16570: int n_ctxt;
16571: xmlChar * str; /* the input string */
16572: int n_str;
16573: int len; /* the string length */
16574: int n_len;
16575: int what; /* combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF */
16576: int n_what;
16577: xmlChar end; /* an end marker xmlChar, 0 if none */
16578: int n_end;
16579: xmlChar end2; /* an end marker xmlChar, 0 if none */
16580: int n_end2;
16581: xmlChar end3; /* an end marker xmlChar, 0 if none */
16582: int n_end3;
16583:
16584: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16585: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
16586: for (n_len = 0;n_len < gen_nb_int;n_len++) {
16587: for (n_what = 0;n_what < gen_nb_int;n_what++) {
16588: for (n_end = 0;n_end < gen_nb_xmlChar;n_end++) {
16589: for (n_end2 = 0;n_end2 < gen_nb_xmlChar;n_end2++) {
16590: for (n_end3 = 0;n_end3 < gen_nb_xmlChar;n_end3++) {
16591: mem_base = xmlMemBlocks();
16592: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16593: str = gen_const_xmlChar_ptr(n_str, 1);
16594: len = gen_int(n_len, 2);
16595: what = gen_int(n_what, 3);
16596: end = gen_xmlChar(n_end, 4);
16597: end2 = gen_xmlChar(n_end2, 5);
16598: end3 = gen_xmlChar(n_end3, 6);
16599:
16600: ret_val = xmlStringLenDecodeEntities(ctxt, (const xmlChar *)str, len, what, end, end2, end3);
16601: desret_xmlChar_ptr(ret_val);
16602: call_tests++;
16603: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16604: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
16605: des_int(n_len, len, 2);
16606: des_int(n_what, what, 3);
16607: des_xmlChar(n_end, end, 4);
16608: des_xmlChar(n_end2, end2, 5);
16609: des_xmlChar(n_end3, end3, 6);
16610: xmlResetLastError();
16611: if (mem_base != xmlMemBlocks()) {
16612: printf("Leak of %d blocks found in xmlStringLenDecodeEntities",
16613: xmlMemBlocks() - mem_base);
16614: test_ret++;
16615: printf(" %d", n_ctxt);
16616: printf(" %d", n_str);
16617: printf(" %d", n_len);
16618: printf(" %d", n_what);
16619: printf(" %d", n_end);
16620: printf(" %d", n_end2);
16621: printf(" %d", n_end3);
16622: printf("\n");
16623: }
16624: }
16625: }
16626: }
16627: }
16628: }
16629: }
16630: }
16631: function_tests++;
16632:
16633: return(test_ret);
16634: }
16635:
16636:
16637: static int
16638: test_xmlSwitchEncoding(void) {
16639: int test_ret = 0;
16640:
16641: int mem_base;
16642: int ret_val;
16643: xmlParserCtxtPtr ctxt; /* the parser context */
16644: int n_ctxt;
16645: xmlCharEncoding enc; /* the encoding value (number) */
16646: int n_enc;
16647:
16648: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16649: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
16650: mem_base = xmlMemBlocks();
16651: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16652: enc = gen_xmlCharEncoding(n_enc, 1);
16653:
16654: ret_val = xmlSwitchEncoding(ctxt, enc);
16655: desret_int(ret_val);
16656: call_tests++;
16657: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16658: des_xmlCharEncoding(n_enc, enc, 1);
16659: xmlResetLastError();
16660: if (mem_base != xmlMemBlocks()) {
16661: printf("Leak of %d blocks found in xmlSwitchEncoding",
16662: xmlMemBlocks() - mem_base);
16663: test_ret++;
16664: printf(" %d", n_ctxt);
16665: printf(" %d", n_enc);
16666: printf("\n");
16667: }
16668: }
16669: }
16670: function_tests++;
16671:
16672: return(test_ret);
16673: }
16674:
16675:
16676: static int
16677: test_xmlSwitchInputEncoding(void) {
16678: int test_ret = 0;
16679:
16680: int mem_base;
16681: int ret_val;
16682: xmlParserCtxtPtr ctxt; /* the parser context */
16683: int n_ctxt;
16684: xmlParserInputPtr input; /* the input stream */
16685: int n_input;
16686: xmlCharEncodingHandlerPtr handler; /* the encoding handler */
16687: int n_handler;
16688:
16689: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16690: for (n_input = 0;n_input < gen_nb_xmlParserInputPtr;n_input++) {
16691: for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandlerPtr;n_handler++) {
16692: mem_base = xmlMemBlocks();
16693: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16694: input = gen_xmlParserInputPtr(n_input, 1);
16695: handler = gen_xmlCharEncodingHandlerPtr(n_handler, 2);
16696:
16697: ret_val = xmlSwitchInputEncoding(ctxt, input, handler);
16698: desret_int(ret_val);
16699: call_tests++;
16700: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16701: des_xmlParserInputPtr(n_input, input, 1);
16702: des_xmlCharEncodingHandlerPtr(n_handler, handler, 2);
16703: xmlResetLastError();
16704: if (mem_base != xmlMemBlocks()) {
16705: printf("Leak of %d blocks found in xmlSwitchInputEncoding",
16706: xmlMemBlocks() - mem_base);
16707: test_ret++;
16708: printf(" %d", n_ctxt);
16709: printf(" %d", n_input);
16710: printf(" %d", n_handler);
16711: printf("\n");
16712: }
16713: }
16714: }
16715: }
16716: function_tests++;
16717:
16718: return(test_ret);
16719: }
16720:
16721:
16722: static int
16723: test_xmlSwitchToEncoding(void) {
16724: int test_ret = 0;
16725:
16726: int mem_base;
16727: int ret_val;
16728: xmlParserCtxtPtr ctxt; /* the parser context */
16729: int n_ctxt;
16730: xmlCharEncodingHandlerPtr handler; /* the encoding handler */
16731: int n_handler;
16732:
16733: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16734: for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandlerPtr;n_handler++) {
16735: mem_base = xmlMemBlocks();
16736: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16737: handler = gen_xmlCharEncodingHandlerPtr(n_handler, 1);
16738:
16739: ret_val = xmlSwitchToEncoding(ctxt, handler);
16740: desret_int(ret_val);
16741: call_tests++;
16742: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16743: des_xmlCharEncodingHandlerPtr(n_handler, handler, 1);
16744: xmlResetLastError();
16745: if (mem_base != xmlMemBlocks()) {
16746: printf("Leak of %d blocks found in xmlSwitchToEncoding",
16747: xmlMemBlocks() - mem_base);
16748: test_ret++;
16749: printf(" %d", n_ctxt);
16750: printf(" %d", n_handler);
16751: printf("\n");
16752: }
16753: }
16754: }
16755: function_tests++;
16756:
16757: return(test_ret);
16758: }
16759:
16760: static int
16761: test_parserInternals(void) {
16762: int test_ret = 0;
16763:
16764: if (quiet == 0) printf("Testing parserInternals : 33 of 90 functions ...\n");
16765: test_ret += test_htmlCreateFileParserCtxt();
16766: test_ret += test_htmlInitAutoClose();
16767: test_ret += test_inputPop();
16768: test_ret += test_inputPush();
16769: test_ret += test_namePop();
16770: test_ret += test_namePush();
16771: test_ret += test_nodePop();
16772: test_ret += test_nodePush();
16773: test_ret += test_xmlCheckLanguageID();
16774: test_ret += test_xmlCopyChar();
16775: test_ret += test_xmlCopyCharMultiByte();
16776: test_ret += test_xmlCreateEntityParserCtxt();
16777: test_ret += test_xmlCreateFileParserCtxt();
16778: test_ret += test_xmlCreateMemoryParserCtxt();
16779: test_ret += test_xmlCreateURLParserCtxt();
16780: test_ret += test_xmlCurrentChar();
16781: test_ret += test_xmlErrMemory();
16782: test_ret += test_xmlIsLetter();
16783: test_ret += test_xmlNewEntityInputStream();
16784: test_ret += test_xmlNewInputFromFile();
16785: test_ret += test_xmlNewInputStream();
16786: test_ret += test_xmlNewStringInputStream();
16787: test_ret += test_xmlNextChar();
16788: test_ret += test_xmlParserInputShrink();
16789: test_ret += test_xmlPopInput();
16790: test_ret += test_xmlPushInput();
16791: test_ret += test_xmlSetEntityReferenceFunc();
16792: test_ret += test_xmlSplitQName();
16793: test_ret += test_xmlStringCurrentChar();
16794: test_ret += test_xmlStringDecodeEntities();
16795: test_ret += test_xmlStringLenDecodeEntities();
16796: test_ret += test_xmlSwitchEncoding();
16797: test_ret += test_xmlSwitchInputEncoding();
16798: test_ret += test_xmlSwitchToEncoding();
16799:
16800: if (test_ret != 0)
16801: printf("Module parserInternals: %d errors\n", test_ret);
16802: return(test_ret);
16803: }
16804:
16805: static int
16806: test_xmlPatternFromRoot(void) {
16807: int test_ret = 0;
16808:
16809: #if defined(LIBXML_PATTERN_ENABLED)
16810: int mem_base;
16811: int ret_val;
16812: xmlPatternPtr comp; /* the precompiled pattern */
16813: int n_comp;
16814:
16815: for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) {
16816: mem_base = xmlMemBlocks();
16817: comp = gen_xmlPatternPtr(n_comp, 0);
16818:
16819: ret_val = xmlPatternFromRoot(comp);
16820: desret_int(ret_val);
16821: call_tests++;
16822: des_xmlPatternPtr(n_comp, comp, 0);
16823: xmlResetLastError();
16824: if (mem_base != xmlMemBlocks()) {
16825: printf("Leak of %d blocks found in xmlPatternFromRoot",
16826: xmlMemBlocks() - mem_base);
16827: test_ret++;
16828: printf(" %d", n_comp);
16829: printf("\n");
16830: }
16831: }
16832: function_tests++;
16833: #endif
16834:
16835: return(test_ret);
16836: }
16837:
16838:
16839: static int
16840: test_xmlPatternGetStreamCtxt(void) {
16841: int test_ret = 0;
16842:
16843:
16844: /* missing type support */
16845: return(test_ret);
16846: }
16847:
16848:
16849: static int
16850: test_xmlPatternMatch(void) {
16851: int test_ret = 0;
16852:
16853: #if defined(LIBXML_PATTERN_ENABLED)
16854: int mem_base;
16855: int ret_val;
16856: xmlPatternPtr comp; /* the precompiled pattern */
16857: int n_comp;
16858: xmlNodePtr node; /* a node */
16859: int n_node;
16860:
16861: for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) {
16862: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
16863: mem_base = xmlMemBlocks();
16864: comp = gen_xmlPatternPtr(n_comp, 0);
16865: node = gen_xmlNodePtr(n_node, 1);
16866:
16867: ret_val = xmlPatternMatch(comp, node);
16868: desret_int(ret_val);
16869: call_tests++;
16870: des_xmlPatternPtr(n_comp, comp, 0);
16871: des_xmlNodePtr(n_node, node, 1);
16872: xmlResetLastError();
16873: if (mem_base != xmlMemBlocks()) {
16874: printf("Leak of %d blocks found in xmlPatternMatch",
16875: xmlMemBlocks() - mem_base);
16876: test_ret++;
16877: printf(" %d", n_comp);
16878: printf(" %d", n_node);
16879: printf("\n");
16880: }
16881: }
16882: }
16883: function_tests++;
16884: #endif
16885:
16886: return(test_ret);
16887: }
16888:
16889:
16890: static int
16891: test_xmlPatternMaxDepth(void) {
16892: int test_ret = 0;
16893:
16894: #if defined(LIBXML_PATTERN_ENABLED)
16895: int mem_base;
16896: int ret_val;
16897: xmlPatternPtr comp; /* the precompiled pattern */
16898: int n_comp;
16899:
16900: for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) {
16901: mem_base = xmlMemBlocks();
16902: comp = gen_xmlPatternPtr(n_comp, 0);
16903:
16904: ret_val = xmlPatternMaxDepth(comp);
16905: desret_int(ret_val);
16906: call_tests++;
16907: des_xmlPatternPtr(n_comp, comp, 0);
16908: xmlResetLastError();
16909: if (mem_base != xmlMemBlocks()) {
16910: printf("Leak of %d blocks found in xmlPatternMaxDepth",
16911: xmlMemBlocks() - mem_base);
16912: test_ret++;
16913: printf(" %d", n_comp);
16914: printf("\n");
16915: }
16916: }
16917: function_tests++;
16918: #endif
16919:
16920: return(test_ret);
16921: }
16922:
16923:
16924: static int
16925: test_xmlPatternMinDepth(void) {
16926: int test_ret = 0;
16927:
16928: #if defined(LIBXML_PATTERN_ENABLED)
16929: int mem_base;
16930: int ret_val;
16931: xmlPatternPtr comp; /* the precompiled pattern */
16932: int n_comp;
16933:
16934: for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) {
16935: mem_base = xmlMemBlocks();
16936: comp = gen_xmlPatternPtr(n_comp, 0);
16937:
16938: ret_val = xmlPatternMinDepth(comp);
16939: desret_int(ret_val);
16940: call_tests++;
16941: des_xmlPatternPtr(n_comp, comp, 0);
16942: xmlResetLastError();
16943: if (mem_base != xmlMemBlocks()) {
16944: printf("Leak of %d blocks found in xmlPatternMinDepth",
16945: xmlMemBlocks() - mem_base);
16946: test_ret++;
16947: printf(" %d", n_comp);
16948: printf("\n");
16949: }
16950: }
16951: function_tests++;
16952: #endif
16953:
16954: return(test_ret);
16955: }
16956:
16957:
16958: static int
16959: test_xmlPatternStreamable(void) {
16960: int test_ret = 0;
16961:
16962: #if defined(LIBXML_PATTERN_ENABLED)
16963: int mem_base;
16964: int ret_val;
16965: xmlPatternPtr comp; /* the precompiled pattern */
16966: int n_comp;
16967:
16968: for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) {
16969: mem_base = xmlMemBlocks();
16970: comp = gen_xmlPatternPtr(n_comp, 0);
16971:
16972: ret_val = xmlPatternStreamable(comp);
16973: desret_int(ret_val);
16974: call_tests++;
16975: des_xmlPatternPtr(n_comp, comp, 0);
16976: xmlResetLastError();
16977: if (mem_base != xmlMemBlocks()) {
16978: printf("Leak of %d blocks found in xmlPatternStreamable",
16979: xmlMemBlocks() - mem_base);
16980: test_ret++;
16981: printf(" %d", n_comp);
16982: printf("\n");
16983: }
16984: }
16985: function_tests++;
16986: #endif
16987:
16988: return(test_ret);
16989: }
16990:
16991:
16992: static int
16993: test_xmlPatterncompile(void) {
16994: int test_ret = 0;
16995:
16996:
16997: /* missing type support */
16998: return(test_ret);
16999: }
17000:
17001: #ifdef LIBXML_PATTERN_ENABLED
17002:
17003: #define gen_nb_xmlStreamCtxtPtr 1
17004: static xmlStreamCtxtPtr gen_xmlStreamCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17005: return(NULL);
17006: }
17007: static void des_xmlStreamCtxtPtr(int no ATTRIBUTE_UNUSED, xmlStreamCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17008: }
17009: #endif
17010:
17011:
17012: static int
17013: test_xmlStreamPop(void) {
17014: int test_ret = 0;
17015:
17016: #if defined(LIBXML_PATTERN_ENABLED)
17017: int mem_base;
17018: int ret_val;
17019: xmlStreamCtxtPtr stream; /* the stream context */
17020: int n_stream;
17021:
17022: for (n_stream = 0;n_stream < gen_nb_xmlStreamCtxtPtr;n_stream++) {
17023: mem_base = xmlMemBlocks();
17024: stream = gen_xmlStreamCtxtPtr(n_stream, 0);
17025:
17026: ret_val = xmlStreamPop(stream);
17027: desret_int(ret_val);
17028: call_tests++;
17029: des_xmlStreamCtxtPtr(n_stream, stream, 0);
17030: xmlResetLastError();
17031: if (mem_base != xmlMemBlocks()) {
17032: printf("Leak of %d blocks found in xmlStreamPop",
17033: xmlMemBlocks() - mem_base);
17034: test_ret++;
17035: printf(" %d", n_stream);
17036: printf("\n");
17037: }
17038: }
17039: function_tests++;
17040: #endif
17041:
17042: return(test_ret);
17043: }
17044:
17045:
17046: static int
17047: test_xmlStreamPush(void) {
17048: int test_ret = 0;
17049:
17050: #if defined(LIBXML_PATTERN_ENABLED)
17051: int mem_base;
17052: int ret_val;
17053: xmlStreamCtxtPtr stream; /* the stream context */
17054: int n_stream;
17055: xmlChar * name; /* the current name */
17056: int n_name;
17057: xmlChar * ns; /* the namespace name */
17058: int n_ns;
17059:
17060: for (n_stream = 0;n_stream < gen_nb_xmlStreamCtxtPtr;n_stream++) {
17061: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
17062: for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) {
17063: mem_base = xmlMemBlocks();
17064: stream = gen_xmlStreamCtxtPtr(n_stream, 0);
17065: name = gen_const_xmlChar_ptr(n_name, 1);
17066: ns = gen_const_xmlChar_ptr(n_ns, 2);
17067:
17068: ret_val = xmlStreamPush(stream, (const xmlChar *)name, (const xmlChar *)ns);
17069: desret_int(ret_val);
17070: call_tests++;
17071: des_xmlStreamCtxtPtr(n_stream, stream, 0);
17072: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
17073: des_const_xmlChar_ptr(n_ns, (const xmlChar *)ns, 2);
17074: xmlResetLastError();
17075: if (mem_base != xmlMemBlocks()) {
17076: printf("Leak of %d blocks found in xmlStreamPush",
17077: xmlMemBlocks() - mem_base);
17078: test_ret++;
17079: printf(" %d", n_stream);
17080: printf(" %d", n_name);
17081: printf(" %d", n_ns);
17082: printf("\n");
17083: }
17084: }
17085: }
17086: }
17087: function_tests++;
17088: #endif
17089:
17090: return(test_ret);
17091: }
17092:
17093:
17094: static int
17095: test_xmlStreamPushAttr(void) {
17096: int test_ret = 0;
17097:
17098: #if defined(LIBXML_PATTERN_ENABLED)
17099: int mem_base;
17100: int ret_val;
17101: xmlStreamCtxtPtr stream; /* the stream context */
17102: int n_stream;
17103: xmlChar * name; /* the current name */
17104: int n_name;
17105: xmlChar * ns; /* the namespace name */
17106: int n_ns;
17107:
17108: for (n_stream = 0;n_stream < gen_nb_xmlStreamCtxtPtr;n_stream++) {
17109: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
17110: for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) {
17111: mem_base = xmlMemBlocks();
17112: stream = gen_xmlStreamCtxtPtr(n_stream, 0);
17113: name = gen_const_xmlChar_ptr(n_name, 1);
17114: ns = gen_const_xmlChar_ptr(n_ns, 2);
17115:
17116: ret_val = xmlStreamPushAttr(stream, (const xmlChar *)name, (const xmlChar *)ns);
17117: desret_int(ret_val);
17118: call_tests++;
17119: des_xmlStreamCtxtPtr(n_stream, stream, 0);
17120: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
17121: des_const_xmlChar_ptr(n_ns, (const xmlChar *)ns, 2);
17122: xmlResetLastError();
17123: if (mem_base != xmlMemBlocks()) {
17124: printf("Leak of %d blocks found in xmlStreamPushAttr",
17125: xmlMemBlocks() - mem_base);
17126: test_ret++;
17127: printf(" %d", n_stream);
17128: printf(" %d", n_name);
17129: printf(" %d", n_ns);
17130: printf("\n");
17131: }
17132: }
17133: }
17134: }
17135: function_tests++;
17136: #endif
17137:
17138: return(test_ret);
17139: }
17140:
17141:
17142: static int
17143: test_xmlStreamPushNode(void) {
17144: int test_ret = 0;
17145:
17146: #if defined(LIBXML_PATTERN_ENABLED)
17147: int mem_base;
17148: int ret_val;
17149: xmlStreamCtxtPtr stream; /* the stream context */
17150: int n_stream;
17151: xmlChar * name; /* the current name */
17152: int n_name;
17153: xmlChar * ns; /* the namespace name */
17154: int n_ns;
17155: int nodeType; /* the type of the node being pushed */
17156: int n_nodeType;
17157:
17158: for (n_stream = 0;n_stream < gen_nb_xmlStreamCtxtPtr;n_stream++) {
17159: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
17160: for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) {
17161: for (n_nodeType = 0;n_nodeType < gen_nb_int;n_nodeType++) {
17162: mem_base = xmlMemBlocks();
17163: stream = gen_xmlStreamCtxtPtr(n_stream, 0);
17164: name = gen_const_xmlChar_ptr(n_name, 1);
17165: ns = gen_const_xmlChar_ptr(n_ns, 2);
17166: nodeType = gen_int(n_nodeType, 3);
17167:
17168: ret_val = xmlStreamPushNode(stream, (const xmlChar *)name, (const xmlChar *)ns, nodeType);
17169: desret_int(ret_val);
17170: call_tests++;
17171: des_xmlStreamCtxtPtr(n_stream, stream, 0);
17172: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
17173: des_const_xmlChar_ptr(n_ns, (const xmlChar *)ns, 2);
17174: des_int(n_nodeType, nodeType, 3);
17175: xmlResetLastError();
17176: if (mem_base != xmlMemBlocks()) {
17177: printf("Leak of %d blocks found in xmlStreamPushNode",
17178: xmlMemBlocks() - mem_base);
17179: test_ret++;
17180: printf(" %d", n_stream);
17181: printf(" %d", n_name);
17182: printf(" %d", n_ns);
17183: printf(" %d", n_nodeType);
17184: printf("\n");
17185: }
17186: }
17187: }
17188: }
17189: }
17190: function_tests++;
17191: #endif
17192:
17193: return(test_ret);
17194: }
17195:
17196:
17197: static int
17198: test_xmlStreamWantsAnyNode(void) {
17199: int test_ret = 0;
17200:
17201: #if defined(LIBXML_PATTERN_ENABLED)
17202: int mem_base;
17203: int ret_val;
17204: xmlStreamCtxtPtr streamCtxt; /* the stream context */
17205: int n_streamCtxt;
17206:
17207: for (n_streamCtxt = 0;n_streamCtxt < gen_nb_xmlStreamCtxtPtr;n_streamCtxt++) {
17208: mem_base = xmlMemBlocks();
17209: streamCtxt = gen_xmlStreamCtxtPtr(n_streamCtxt, 0);
17210:
17211: ret_val = xmlStreamWantsAnyNode(streamCtxt);
17212: desret_int(ret_val);
17213: call_tests++;
17214: des_xmlStreamCtxtPtr(n_streamCtxt, streamCtxt, 0);
17215: xmlResetLastError();
17216: if (mem_base != xmlMemBlocks()) {
17217: printf("Leak of %d blocks found in xmlStreamWantsAnyNode",
17218: xmlMemBlocks() - mem_base);
17219: test_ret++;
17220: printf(" %d", n_streamCtxt);
17221: printf("\n");
17222: }
17223: }
17224: function_tests++;
17225: #endif
17226:
17227: return(test_ret);
17228: }
17229:
17230: static int
17231: test_pattern(void) {
17232: int test_ret = 0;
17233:
17234: if (quiet == 0) printf("Testing pattern : 10 of 15 functions ...\n");
17235: test_ret += test_xmlPatternFromRoot();
17236: test_ret += test_xmlPatternGetStreamCtxt();
17237: test_ret += test_xmlPatternMatch();
17238: test_ret += test_xmlPatternMaxDepth();
17239: test_ret += test_xmlPatternMinDepth();
17240: test_ret += test_xmlPatternStreamable();
17241: test_ret += test_xmlPatterncompile();
17242: test_ret += test_xmlStreamPop();
17243: test_ret += test_xmlStreamPush();
17244: test_ret += test_xmlStreamPushAttr();
17245: test_ret += test_xmlStreamPushNode();
17246: test_ret += test_xmlStreamWantsAnyNode();
17247:
17248: if (test_ret != 0)
17249: printf("Module pattern: %d errors\n", test_ret);
17250: return(test_ret);
17251: }
17252: #ifdef LIBXML_SCHEMAS_ENABLED
17253:
17254: #define gen_nb_xmlRelaxNGPtr 1
17255: static xmlRelaxNGPtr gen_xmlRelaxNGPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17256: return(NULL);
17257: }
17258: static void des_xmlRelaxNGPtr(int no ATTRIBUTE_UNUSED, xmlRelaxNGPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17259: }
17260: #endif
17261:
17262:
17263: static int
17264: test_xmlRelaxNGDump(void) {
17265: int test_ret = 0;
17266:
17267: #if defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
17268: int mem_base;
17269: FILE * output; /* the file output */
17270: int n_output;
17271: xmlRelaxNGPtr schema; /* a schema structure */
17272: int n_schema;
17273:
17274: for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
17275: for (n_schema = 0;n_schema < gen_nb_xmlRelaxNGPtr;n_schema++) {
17276: mem_base = xmlMemBlocks();
17277: output = gen_FILE_ptr(n_output, 0);
17278: schema = gen_xmlRelaxNGPtr(n_schema, 1);
17279:
17280: xmlRelaxNGDump(output, schema);
17281: call_tests++;
17282: des_FILE_ptr(n_output, output, 0);
17283: des_xmlRelaxNGPtr(n_schema, schema, 1);
17284: xmlResetLastError();
17285: if (mem_base != xmlMemBlocks()) {
17286: printf("Leak of %d blocks found in xmlRelaxNGDump",
17287: xmlMemBlocks() - mem_base);
17288: test_ret++;
17289: printf(" %d", n_output);
17290: printf(" %d", n_schema);
17291: printf("\n");
17292: }
17293: }
17294: }
17295: function_tests++;
17296: #endif
17297:
17298: return(test_ret);
17299: }
17300:
17301:
17302: static int
17303: test_xmlRelaxNGDumpTree(void) {
17304: int test_ret = 0;
17305:
17306: #if defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
17307: int mem_base;
17308: FILE * output; /* the file output */
17309: int n_output;
17310: xmlRelaxNGPtr schema; /* a schema structure */
17311: int n_schema;
17312:
17313: for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
17314: for (n_schema = 0;n_schema < gen_nb_xmlRelaxNGPtr;n_schema++) {
17315: mem_base = xmlMemBlocks();
17316: output = gen_FILE_ptr(n_output, 0);
17317: schema = gen_xmlRelaxNGPtr(n_schema, 1);
17318:
17319: xmlRelaxNGDumpTree(output, schema);
17320: call_tests++;
17321: des_FILE_ptr(n_output, output, 0);
17322: des_xmlRelaxNGPtr(n_schema, schema, 1);
17323: xmlResetLastError();
17324: if (mem_base != xmlMemBlocks()) {
17325: printf("Leak of %d blocks found in xmlRelaxNGDumpTree",
17326: xmlMemBlocks() - mem_base);
17327: test_ret++;
17328: printf(" %d", n_output);
17329: printf(" %d", n_schema);
17330: printf("\n");
17331: }
17332: }
17333: }
17334: function_tests++;
17335: #endif
17336:
17337: return(test_ret);
17338: }
17339:
17340: #ifdef LIBXML_SCHEMAS_ENABLED
17341:
17342: #define gen_nb_xmlRelaxNGParserCtxtPtr 1
17343: static xmlRelaxNGParserCtxtPtr gen_xmlRelaxNGParserCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17344: return(NULL);
17345: }
17346: static void des_xmlRelaxNGParserCtxtPtr(int no ATTRIBUTE_UNUSED, xmlRelaxNGParserCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17347: }
17348: #endif
17349:
17350: #ifdef LIBXML_SCHEMAS_ENABLED
17351:
17352: #define gen_nb_xmlRelaxNGValidityErrorFunc_ptr 1
17353: static xmlRelaxNGValidityErrorFunc * gen_xmlRelaxNGValidityErrorFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17354: return(NULL);
17355: }
17356: static void des_xmlRelaxNGValidityErrorFunc_ptr(int no ATTRIBUTE_UNUSED, xmlRelaxNGValidityErrorFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17357: }
17358: #endif
17359:
17360: #ifdef LIBXML_SCHEMAS_ENABLED
17361:
17362: #define gen_nb_xmlRelaxNGValidityWarningFunc_ptr 1
17363: static xmlRelaxNGValidityWarningFunc * gen_xmlRelaxNGValidityWarningFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17364: return(NULL);
17365: }
17366: static void des_xmlRelaxNGValidityWarningFunc_ptr(int no ATTRIBUTE_UNUSED, xmlRelaxNGValidityWarningFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17367: }
17368: #endif
17369:
17370:
17371: static int
17372: test_xmlRelaxNGGetParserErrors(void) {
17373: int test_ret = 0;
17374:
17375: #if defined(LIBXML_SCHEMAS_ENABLED)
17376: int mem_base;
17377: int ret_val;
17378: xmlRelaxNGParserCtxtPtr ctxt; /* a Relax-NG validation context */
17379: int n_ctxt;
17380: xmlRelaxNGValidityErrorFunc * err; /* the error callback result */
17381: int n_err;
17382: xmlRelaxNGValidityWarningFunc * warn; /* the warning callback result */
17383: int n_warn;
17384: void ** ctx; /* contextual data for the callbacks result */
17385: int n_ctx;
17386:
17387: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGParserCtxtPtr;n_ctxt++) {
17388: for (n_err = 0;n_err < gen_nb_xmlRelaxNGValidityErrorFunc_ptr;n_err++) {
17389: for (n_warn = 0;n_warn < gen_nb_xmlRelaxNGValidityWarningFunc_ptr;n_warn++) {
17390: for (n_ctx = 0;n_ctx < gen_nb_void_ptr_ptr;n_ctx++) {
17391: mem_base = xmlMemBlocks();
17392: ctxt = gen_xmlRelaxNGParserCtxtPtr(n_ctxt, 0);
17393: err = gen_xmlRelaxNGValidityErrorFunc_ptr(n_err, 1);
17394: warn = gen_xmlRelaxNGValidityWarningFunc_ptr(n_warn, 2);
17395: ctx = gen_void_ptr_ptr(n_ctx, 3);
17396:
17397: ret_val = xmlRelaxNGGetParserErrors(ctxt, err, warn, ctx);
17398: desret_int(ret_val);
17399: call_tests++;
17400: des_xmlRelaxNGParserCtxtPtr(n_ctxt, ctxt, 0);
17401: des_xmlRelaxNGValidityErrorFunc_ptr(n_err, err, 1);
17402: des_xmlRelaxNGValidityWarningFunc_ptr(n_warn, warn, 2);
17403: des_void_ptr_ptr(n_ctx, ctx, 3);
17404: xmlResetLastError();
17405: if (mem_base != xmlMemBlocks()) {
17406: printf("Leak of %d blocks found in xmlRelaxNGGetParserErrors",
17407: xmlMemBlocks() - mem_base);
17408: test_ret++;
17409: printf(" %d", n_ctxt);
17410: printf(" %d", n_err);
17411: printf(" %d", n_warn);
17412: printf(" %d", n_ctx);
17413: printf("\n");
17414: }
17415: }
17416: }
17417: }
17418: }
17419: function_tests++;
17420: #endif
17421:
17422: return(test_ret);
17423: }
17424:
17425: #ifdef LIBXML_SCHEMAS_ENABLED
17426:
17427: #define gen_nb_xmlRelaxNGValidCtxtPtr 1
17428: static xmlRelaxNGValidCtxtPtr gen_xmlRelaxNGValidCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17429: return(NULL);
17430: }
17431: static void des_xmlRelaxNGValidCtxtPtr(int no ATTRIBUTE_UNUSED, xmlRelaxNGValidCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17432: }
17433: #endif
17434:
17435:
17436: static int
17437: test_xmlRelaxNGGetValidErrors(void) {
17438: int test_ret = 0;
17439:
17440: #if defined(LIBXML_SCHEMAS_ENABLED)
17441: int mem_base;
17442: int ret_val;
17443: xmlRelaxNGValidCtxtPtr ctxt; /* a Relax-NG validation context */
17444: int n_ctxt;
17445: xmlRelaxNGValidityErrorFunc * err; /* the error function result */
17446: int n_err;
17447: xmlRelaxNGValidityWarningFunc * warn; /* the warning function result */
17448: int n_warn;
17449: void ** ctx; /* the functions context result */
17450: int n_ctx;
17451:
17452: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
17453: for (n_err = 0;n_err < gen_nb_xmlRelaxNGValidityErrorFunc_ptr;n_err++) {
17454: for (n_warn = 0;n_warn < gen_nb_xmlRelaxNGValidityWarningFunc_ptr;n_warn++) {
17455: for (n_ctx = 0;n_ctx < gen_nb_void_ptr_ptr;n_ctx++) {
17456: mem_base = xmlMemBlocks();
17457: ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
17458: err = gen_xmlRelaxNGValidityErrorFunc_ptr(n_err, 1);
17459: warn = gen_xmlRelaxNGValidityWarningFunc_ptr(n_warn, 2);
17460: ctx = gen_void_ptr_ptr(n_ctx, 3);
17461:
17462: ret_val = xmlRelaxNGGetValidErrors(ctxt, err, warn, ctx);
17463: desret_int(ret_val);
17464: call_tests++;
17465: des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
17466: des_xmlRelaxNGValidityErrorFunc_ptr(n_err, err, 1);
17467: des_xmlRelaxNGValidityWarningFunc_ptr(n_warn, warn, 2);
17468: des_void_ptr_ptr(n_ctx, ctx, 3);
17469: xmlResetLastError();
17470: if (mem_base != xmlMemBlocks()) {
17471: printf("Leak of %d blocks found in xmlRelaxNGGetValidErrors",
17472: xmlMemBlocks() - mem_base);
17473: test_ret++;
17474: printf(" %d", n_ctxt);
17475: printf(" %d", n_err);
17476: printf(" %d", n_warn);
17477: printf(" %d", n_ctx);
17478: printf("\n");
17479: }
17480: }
17481: }
17482: }
17483: }
17484: function_tests++;
17485: #endif
17486:
17487: return(test_ret);
17488: }
17489:
17490:
17491: static int
17492: test_xmlRelaxNGInitTypes(void) {
17493: int test_ret = 0;
17494:
17495: #if defined(LIBXML_SCHEMAS_ENABLED)
17496: int mem_base;
17497: int ret_val;
17498:
17499: mem_base = xmlMemBlocks();
17500:
17501: ret_val = xmlRelaxNGInitTypes();
17502: desret_int(ret_val);
17503: call_tests++;
17504: xmlResetLastError();
17505: if (mem_base != xmlMemBlocks()) {
17506: printf("Leak of %d blocks found in xmlRelaxNGInitTypes",
17507: xmlMemBlocks() - mem_base);
17508: test_ret++;
17509: printf("\n");
17510: }
17511: function_tests++;
17512: #endif
17513:
17514: return(test_ret);
17515: }
17516:
17517:
17518: static int
17519: test_xmlRelaxNGNewDocParserCtxt(void) {
17520: int test_ret = 0;
17521:
17522: #if defined(LIBXML_SCHEMAS_ENABLED)
17523: int mem_base;
17524: xmlRelaxNGParserCtxtPtr ret_val;
17525: xmlDocPtr doc; /* a preparsed document tree */
17526: int n_doc;
17527:
17528: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
17529: mem_base = xmlMemBlocks();
17530: doc = gen_xmlDocPtr(n_doc, 0);
17531:
17532: ret_val = xmlRelaxNGNewDocParserCtxt(doc);
17533: desret_xmlRelaxNGParserCtxtPtr(ret_val);
17534: call_tests++;
17535: des_xmlDocPtr(n_doc, doc, 0);
17536: xmlResetLastError();
17537: if (mem_base != xmlMemBlocks()) {
17538: printf("Leak of %d blocks found in xmlRelaxNGNewDocParserCtxt",
17539: xmlMemBlocks() - mem_base);
17540: test_ret++;
17541: printf(" %d", n_doc);
17542: printf("\n");
17543: }
17544: }
17545: function_tests++;
17546: #endif
17547:
17548: return(test_ret);
17549: }
17550:
17551:
17552: static int
17553: test_xmlRelaxNGNewMemParserCtxt(void) {
17554: int test_ret = 0;
17555:
17556: #if defined(LIBXML_SCHEMAS_ENABLED)
17557: int mem_base;
17558: xmlRelaxNGParserCtxtPtr ret_val;
17559: char * buffer; /* a pointer to a char array containing the schemas */
17560: int n_buffer;
17561: int size; /* the size of the array */
17562: int n_size;
17563:
17564: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
17565: for (n_size = 0;n_size < gen_nb_int;n_size++) {
17566: mem_base = xmlMemBlocks();
17567: buffer = gen_const_char_ptr(n_buffer, 0);
17568: size = gen_int(n_size, 1);
17569:
17570: ret_val = xmlRelaxNGNewMemParserCtxt((const char *)buffer, size);
17571: desret_xmlRelaxNGParserCtxtPtr(ret_val);
17572: call_tests++;
17573: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
17574: des_int(n_size, size, 1);
17575: xmlResetLastError();
17576: if (mem_base != xmlMemBlocks()) {
17577: printf("Leak of %d blocks found in xmlRelaxNGNewMemParserCtxt",
17578: xmlMemBlocks() - mem_base);
17579: test_ret++;
17580: printf(" %d", n_buffer);
17581: printf(" %d", n_size);
17582: printf("\n");
17583: }
17584: }
17585: }
17586: function_tests++;
17587: #endif
17588:
17589: return(test_ret);
17590: }
17591:
17592:
17593: static int
17594: test_xmlRelaxNGNewParserCtxt(void) {
17595: int test_ret = 0;
17596:
17597: #if defined(LIBXML_SCHEMAS_ENABLED)
17598: int mem_base;
17599: xmlRelaxNGParserCtxtPtr ret_val;
17600: char * URL; /* the location of the schema */
17601: int n_URL;
17602:
17603: for (n_URL = 0;n_URL < gen_nb_const_char_ptr;n_URL++) {
17604: mem_base = xmlMemBlocks();
17605: URL = gen_const_char_ptr(n_URL, 0);
17606:
17607: ret_val = xmlRelaxNGNewParserCtxt((const char *)URL);
17608: desret_xmlRelaxNGParserCtxtPtr(ret_val);
17609: call_tests++;
17610: des_const_char_ptr(n_URL, (const char *)URL, 0);
17611: xmlResetLastError();
17612: if (mem_base != xmlMemBlocks()) {
17613: printf("Leak of %d blocks found in xmlRelaxNGNewParserCtxt",
17614: xmlMemBlocks() - mem_base);
17615: test_ret++;
17616: printf(" %d", n_URL);
17617: printf("\n");
17618: }
17619: }
17620: function_tests++;
17621: #endif
17622:
17623: return(test_ret);
17624: }
17625:
17626:
17627: static int
17628: test_xmlRelaxNGNewValidCtxt(void) {
17629: int test_ret = 0;
17630:
17631:
17632: /* missing type support */
17633: return(test_ret);
17634: }
17635:
17636:
17637: static int
17638: test_xmlRelaxNGParse(void) {
17639: int test_ret = 0;
17640:
17641:
17642: /* missing type support */
17643: return(test_ret);
17644: }
17645:
17646:
17647: static int
17648: test_xmlRelaxNGSetParserErrors(void) {
17649: int test_ret = 0;
17650:
17651:
17652: /* missing type support */
17653: return(test_ret);
17654: }
17655:
17656:
17657: static int
17658: test_xmlRelaxNGSetParserStructuredErrors(void) {
17659: int test_ret = 0;
17660:
17661:
17662: /* missing type support */
17663: return(test_ret);
17664: }
17665:
17666:
17667: static int
17668: test_xmlRelaxNGSetValidErrors(void) {
17669: int test_ret = 0;
17670:
17671:
17672: /* missing type support */
17673: return(test_ret);
17674: }
17675:
17676:
17677: static int
17678: test_xmlRelaxNGSetValidStructuredErrors(void) {
17679: int test_ret = 0;
17680:
17681:
17682: /* missing type support */
17683: return(test_ret);
17684: }
17685:
17686:
17687: static int
17688: test_xmlRelaxNGValidateDoc(void) {
17689: int test_ret = 0;
17690:
17691: #if defined(LIBXML_SCHEMAS_ENABLED)
17692: int mem_base;
17693: int ret_val;
17694: xmlRelaxNGValidCtxtPtr ctxt; /* a Relax-NG validation context */
17695: int n_ctxt;
17696: xmlDocPtr doc; /* a parsed document tree */
17697: int n_doc;
17698:
17699: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
17700: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
17701: mem_base = xmlMemBlocks();
17702: ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
17703: doc = gen_xmlDocPtr(n_doc, 1);
17704:
17705: ret_val = xmlRelaxNGValidateDoc(ctxt, doc);
17706: desret_int(ret_val);
17707: call_tests++;
17708: des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
17709: des_xmlDocPtr(n_doc, doc, 1);
17710: xmlResetLastError();
17711: if (mem_base != xmlMemBlocks()) {
17712: printf("Leak of %d blocks found in xmlRelaxNGValidateDoc",
17713: xmlMemBlocks() - mem_base);
17714: test_ret++;
17715: printf(" %d", n_ctxt);
17716: printf(" %d", n_doc);
17717: printf("\n");
17718: }
17719: }
17720: }
17721: function_tests++;
17722: #endif
17723:
17724: return(test_ret);
17725: }
17726:
17727:
17728: static int
17729: test_xmlRelaxNGValidateFullElement(void) {
17730: int test_ret = 0;
17731:
17732: #if defined(LIBXML_SCHEMAS_ENABLED)
17733: int mem_base;
17734: int ret_val;
17735: xmlRelaxNGValidCtxtPtr ctxt; /* the validation context */
17736: int n_ctxt;
17737: xmlDocPtr doc; /* a document instance */
17738: int n_doc;
17739: xmlNodePtr elem; /* an element instance */
17740: int n_elem;
17741:
17742: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
17743: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
17744: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
17745: mem_base = xmlMemBlocks();
17746: ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
17747: doc = gen_xmlDocPtr(n_doc, 1);
17748: elem = gen_xmlNodePtr(n_elem, 2);
17749:
17750: ret_val = xmlRelaxNGValidateFullElement(ctxt, doc, elem);
17751: desret_int(ret_val);
17752: call_tests++;
17753: des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
17754: des_xmlDocPtr(n_doc, doc, 1);
17755: des_xmlNodePtr(n_elem, elem, 2);
17756: xmlResetLastError();
17757: if (mem_base != xmlMemBlocks()) {
17758: printf("Leak of %d blocks found in xmlRelaxNGValidateFullElement",
17759: xmlMemBlocks() - mem_base);
17760: test_ret++;
17761: printf(" %d", n_ctxt);
17762: printf(" %d", n_doc);
17763: printf(" %d", n_elem);
17764: printf("\n");
17765: }
17766: }
17767: }
17768: }
17769: function_tests++;
17770: #endif
17771:
17772: return(test_ret);
17773: }
17774:
17775:
17776: static int
17777: test_xmlRelaxNGValidatePopElement(void) {
17778: int test_ret = 0;
17779:
17780: #if defined(LIBXML_SCHEMAS_ENABLED)
17781: int mem_base;
17782: int ret_val;
17783: xmlRelaxNGValidCtxtPtr ctxt; /* the RelaxNG validation context */
17784: int n_ctxt;
17785: xmlDocPtr doc; /* a document instance */
17786: int n_doc;
17787: xmlNodePtr elem; /* an element instance */
17788: int n_elem;
17789:
17790: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
17791: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
17792: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
17793: mem_base = xmlMemBlocks();
17794: ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
17795: doc = gen_xmlDocPtr(n_doc, 1);
17796: elem = gen_xmlNodePtr(n_elem, 2);
17797:
17798: ret_val = xmlRelaxNGValidatePopElement(ctxt, doc, elem);
17799: desret_int(ret_val);
17800: call_tests++;
17801: des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
17802: des_xmlDocPtr(n_doc, doc, 1);
17803: des_xmlNodePtr(n_elem, elem, 2);
17804: xmlResetLastError();
17805: if (mem_base != xmlMemBlocks()) {
17806: printf("Leak of %d blocks found in xmlRelaxNGValidatePopElement",
17807: xmlMemBlocks() - mem_base);
17808: test_ret++;
17809: printf(" %d", n_ctxt);
17810: printf(" %d", n_doc);
17811: printf(" %d", n_elem);
17812: printf("\n");
17813: }
17814: }
17815: }
17816: }
17817: function_tests++;
17818: #endif
17819:
17820: return(test_ret);
17821: }
17822:
17823:
17824: static int
17825: test_xmlRelaxNGValidatePushCData(void) {
17826: int test_ret = 0;
17827:
17828: #if defined(LIBXML_SCHEMAS_ENABLED)
17829: int mem_base;
17830: int ret_val;
17831: xmlRelaxNGValidCtxtPtr ctxt; /* the RelaxNG validation context */
17832: int n_ctxt;
17833: xmlChar * data; /* some character data read */
17834: int n_data;
1.1.1.3 ! misho 17835: int len; /* the length of the data */
1.1 misho 17836: int n_len;
17837:
17838: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
17839: for (n_data = 0;n_data < gen_nb_const_xmlChar_ptr;n_data++) {
17840: for (n_len = 0;n_len < gen_nb_int;n_len++) {
17841: mem_base = xmlMemBlocks();
17842: ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
17843: data = gen_const_xmlChar_ptr(n_data, 1);
17844: len = gen_int(n_len, 2);
17845:
17846: ret_val = xmlRelaxNGValidatePushCData(ctxt, (const xmlChar *)data, len);
17847: desret_int(ret_val);
17848: call_tests++;
17849: des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
17850: des_const_xmlChar_ptr(n_data, (const xmlChar *)data, 1);
17851: des_int(n_len, len, 2);
17852: xmlResetLastError();
17853: if (mem_base != xmlMemBlocks()) {
17854: printf("Leak of %d blocks found in xmlRelaxNGValidatePushCData",
17855: xmlMemBlocks() - mem_base);
17856: test_ret++;
17857: printf(" %d", n_ctxt);
17858: printf(" %d", n_data);
17859: printf(" %d", n_len);
17860: printf("\n");
17861: }
17862: }
17863: }
17864: }
17865: function_tests++;
17866: #endif
17867:
17868: return(test_ret);
17869: }
17870:
17871:
17872: static int
17873: test_xmlRelaxNGValidatePushElement(void) {
17874: int test_ret = 0;
17875:
17876: #if defined(LIBXML_SCHEMAS_ENABLED)
17877: int mem_base;
17878: int ret_val;
17879: xmlRelaxNGValidCtxtPtr ctxt; /* the validation context */
17880: int n_ctxt;
17881: xmlDocPtr doc; /* a document instance */
17882: int n_doc;
17883: xmlNodePtr elem; /* an element instance */
17884: int n_elem;
17885:
17886: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
17887: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
17888: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
17889: mem_base = xmlMemBlocks();
17890: ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
17891: doc = gen_xmlDocPtr(n_doc, 1);
17892: elem = gen_xmlNodePtr(n_elem, 2);
17893:
17894: ret_val = xmlRelaxNGValidatePushElement(ctxt, doc, elem);
17895: desret_int(ret_val);
17896: call_tests++;
17897: des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
17898: des_xmlDocPtr(n_doc, doc, 1);
17899: des_xmlNodePtr(n_elem, elem, 2);
17900: xmlResetLastError();
17901: if (mem_base != xmlMemBlocks()) {
17902: printf("Leak of %d blocks found in xmlRelaxNGValidatePushElement",
17903: xmlMemBlocks() - mem_base);
17904: test_ret++;
17905: printf(" %d", n_ctxt);
17906: printf(" %d", n_doc);
17907: printf(" %d", n_elem);
17908: printf("\n");
17909: }
17910: }
17911: }
17912: }
17913: function_tests++;
17914: #endif
17915:
17916: return(test_ret);
17917: }
17918:
17919:
17920: static int
17921: test_xmlRelaxParserSetFlag(void) {
17922: int test_ret = 0;
17923:
17924: #if defined(LIBXML_SCHEMAS_ENABLED)
17925: int mem_base;
17926: int ret_val;
17927: xmlRelaxNGParserCtxtPtr ctxt; /* a RelaxNG parser context */
17928: int n_ctxt;
17929: int flags; /* a set of flags values */
17930: int n_flags;
17931:
17932: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGParserCtxtPtr;n_ctxt++) {
17933: for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
17934: mem_base = xmlMemBlocks();
17935: ctxt = gen_xmlRelaxNGParserCtxtPtr(n_ctxt, 0);
17936: flags = gen_int(n_flags, 1);
17937:
17938: ret_val = xmlRelaxParserSetFlag(ctxt, flags);
17939: desret_int(ret_val);
17940: call_tests++;
17941: des_xmlRelaxNGParserCtxtPtr(n_ctxt, ctxt, 0);
17942: des_int(n_flags, flags, 1);
17943: xmlResetLastError();
17944: if (mem_base != xmlMemBlocks()) {
17945: printf("Leak of %d blocks found in xmlRelaxParserSetFlag",
17946: xmlMemBlocks() - mem_base);
17947: test_ret++;
17948: printf(" %d", n_ctxt);
17949: printf(" %d", n_flags);
17950: printf("\n");
17951: }
17952: }
17953: }
17954: function_tests++;
17955: #endif
17956:
17957: return(test_ret);
17958: }
17959:
17960: static int
17961: test_relaxng(void) {
17962: int test_ret = 0;
17963:
17964: if (quiet == 0) printf("Testing relaxng : 14 of 24 functions ...\n");
17965: test_ret += test_xmlRelaxNGDump();
17966: test_ret += test_xmlRelaxNGDumpTree();
17967: test_ret += test_xmlRelaxNGGetParserErrors();
17968: test_ret += test_xmlRelaxNGGetValidErrors();
17969: test_ret += test_xmlRelaxNGInitTypes();
17970: test_ret += test_xmlRelaxNGNewDocParserCtxt();
17971: test_ret += test_xmlRelaxNGNewMemParserCtxt();
17972: test_ret += test_xmlRelaxNGNewParserCtxt();
17973: test_ret += test_xmlRelaxNGNewValidCtxt();
17974: test_ret += test_xmlRelaxNGParse();
17975: test_ret += test_xmlRelaxNGSetParserErrors();
17976: test_ret += test_xmlRelaxNGSetParserStructuredErrors();
17977: test_ret += test_xmlRelaxNGSetValidErrors();
17978: test_ret += test_xmlRelaxNGSetValidStructuredErrors();
17979: test_ret += test_xmlRelaxNGValidateDoc();
17980: test_ret += test_xmlRelaxNGValidateFullElement();
17981: test_ret += test_xmlRelaxNGValidatePopElement();
17982: test_ret += test_xmlRelaxNGValidatePushCData();
17983: test_ret += test_xmlRelaxNGValidatePushElement();
17984: test_ret += test_xmlRelaxParserSetFlag();
17985:
17986: if (test_ret != 0)
17987: printf("Module relaxng: %d errors\n", test_ret);
17988: return(test_ret);
17989: }
17990: static int
17991: test_schemasInternals(void) {
17992: int test_ret = 0;
17993:
17994: if (quiet == 0) printf("Testing schemasInternals : 0 of 2 functions ...\n");
17995:
17996: if (test_ret != 0)
17997: printf("Module schemasInternals: %d errors\n", test_ret);
17998: return(test_ret);
17999: }
18000:
18001: static int
18002: test_xmlSchematronNewDocParserCtxt(void) {
18003: int test_ret = 0;
18004:
18005:
18006: /* missing type support */
18007: return(test_ret);
18008: }
18009:
18010:
18011: static int
18012: test_xmlSchematronNewMemParserCtxt(void) {
18013: int test_ret = 0;
18014:
18015:
18016: /* missing type support */
18017: return(test_ret);
18018: }
18019:
18020:
18021: static int
18022: test_xmlSchematronNewParserCtxt(void) {
18023: int test_ret = 0;
18024:
18025:
18026: /* missing type support */
18027: return(test_ret);
18028: }
18029:
18030: #ifdef LIBXML_SCHEMATRON_ENABLED
18031:
18032: #define gen_nb_xmlSchematronPtr 1
18033: static xmlSchematronPtr gen_xmlSchematronPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
18034: return(NULL);
18035: }
18036: static void des_xmlSchematronPtr(int no ATTRIBUTE_UNUSED, xmlSchematronPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
18037: }
18038: #endif
18039:
18040:
18041: static int
18042: test_xmlSchematronNewValidCtxt(void) {
18043: int test_ret = 0;
18044:
18045:
18046: /* missing type support */
18047: return(test_ret);
18048: }
18049:
18050: #ifdef LIBXML_SCHEMATRON_ENABLED
18051:
18052: #define gen_nb_xmlSchematronParserCtxtPtr 1
18053: static xmlSchematronParserCtxtPtr gen_xmlSchematronParserCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
18054: return(NULL);
18055: }
18056: static void des_xmlSchematronParserCtxtPtr(int no ATTRIBUTE_UNUSED, xmlSchematronParserCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
18057: }
18058: #endif
18059:
18060:
18061: static int
18062: test_xmlSchematronParse(void) {
18063: int test_ret = 0;
18064:
18065:
18066: /* missing type support */
18067: return(test_ret);
18068: }
18069:
18070: #ifdef LIBXML_SCHEMATRON_ENABLED
18071:
18072: #define gen_nb_xmlSchematronValidCtxtPtr 1
18073: static xmlSchematronValidCtxtPtr gen_xmlSchematronValidCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
18074: return(NULL);
18075: }
18076: static void des_xmlSchematronValidCtxtPtr(int no ATTRIBUTE_UNUSED, xmlSchematronValidCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
18077: }
18078: #endif
18079:
18080:
18081: static int
18082: test_xmlSchematronSetValidStructuredErrors(void) {
18083: int test_ret = 0;
18084:
18085:
18086: /* missing type support */
18087: return(test_ret);
18088: }
18089:
18090:
18091: static int
18092: test_xmlSchematronValidateDoc(void) {
18093: int test_ret = 0;
18094:
18095: #if defined(LIBXML_SCHEMATRON_ENABLED)
18096: int mem_base;
18097: int ret_val;
18098: xmlSchematronValidCtxtPtr ctxt; /* the schema validation context */
18099: int n_ctxt;
18100: xmlDocPtr instance; /* the document instace tree */
18101: int n_instance;
18102:
18103: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchematronValidCtxtPtr;n_ctxt++) {
18104: for (n_instance = 0;n_instance < gen_nb_xmlDocPtr;n_instance++) {
18105: mem_base = xmlMemBlocks();
18106: ctxt = gen_xmlSchematronValidCtxtPtr(n_ctxt, 0);
18107: instance = gen_xmlDocPtr(n_instance, 1);
18108:
18109: ret_val = xmlSchematronValidateDoc(ctxt, instance);
18110: desret_int(ret_val);
18111: call_tests++;
18112: des_xmlSchematronValidCtxtPtr(n_ctxt, ctxt, 0);
18113: des_xmlDocPtr(n_instance, instance, 1);
18114: xmlResetLastError();
18115: if (mem_base != xmlMemBlocks()) {
18116: printf("Leak of %d blocks found in xmlSchematronValidateDoc",
18117: xmlMemBlocks() - mem_base);
18118: test_ret++;
18119: printf(" %d", n_ctxt);
18120: printf(" %d", n_instance);
18121: printf("\n");
18122: }
18123: }
18124: }
18125: function_tests++;
18126: #endif
18127:
18128: return(test_ret);
18129: }
18130:
18131: static int
18132: test_schematron(void) {
18133: int test_ret = 0;
18134:
18135: if (quiet == 0) printf("Testing schematron : 1 of 10 functions ...\n");
18136: test_ret += test_xmlSchematronNewDocParserCtxt();
18137: test_ret += test_xmlSchematronNewMemParserCtxt();
18138: test_ret += test_xmlSchematronNewParserCtxt();
18139: test_ret += test_xmlSchematronNewValidCtxt();
18140: test_ret += test_xmlSchematronParse();
18141: test_ret += test_xmlSchematronSetValidStructuredErrors();
18142: test_ret += test_xmlSchematronValidateDoc();
18143:
18144: if (test_ret != 0)
18145: printf("Module schematron: %d errors\n", test_ret);
18146: return(test_ret);
18147: }
18148:
18149: static int
18150: test_xmlAddChild(void) {
18151: int test_ret = 0;
18152:
18153: int mem_base;
18154: xmlNodePtr ret_val;
18155: xmlNodePtr parent; /* the parent node */
18156: int n_parent;
18157: xmlNodePtr cur; /* the child node */
18158: int n_cur;
18159:
18160: for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
18161: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr_in;n_cur++) {
18162: mem_base = xmlMemBlocks();
18163: parent = gen_xmlNodePtr(n_parent, 0);
18164: cur = gen_xmlNodePtr_in(n_cur, 1);
18165:
18166: ret_val = xmlAddChild(parent, cur);
18167: if (ret_val == NULL) { xmlFreeNode(cur) ; cur = NULL ; }
18168: desret_xmlNodePtr(ret_val);
18169: call_tests++;
18170: des_xmlNodePtr(n_parent, parent, 0);
18171: des_xmlNodePtr_in(n_cur, cur, 1);
18172: xmlResetLastError();
18173: if (mem_base != xmlMemBlocks()) {
18174: printf("Leak of %d blocks found in xmlAddChild",
18175: xmlMemBlocks() - mem_base);
18176: test_ret++;
18177: printf(" %d", n_parent);
18178: printf(" %d", n_cur);
18179: printf("\n");
18180: }
18181: }
18182: }
18183: function_tests++;
18184:
18185: return(test_ret);
18186: }
18187:
18188:
18189: static int
18190: test_xmlAddChildList(void) {
18191: int test_ret = 0;
18192:
18193: int mem_base;
18194: xmlNodePtr ret_val;
18195: xmlNodePtr parent; /* the parent node */
18196: int n_parent;
18197: xmlNodePtr cur; /* the first node in the list */
18198: int n_cur;
18199:
18200: for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
18201: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr_in;n_cur++) {
18202: mem_base = xmlMemBlocks();
18203: parent = gen_xmlNodePtr(n_parent, 0);
18204: cur = gen_xmlNodePtr_in(n_cur, 1);
18205:
18206: ret_val = xmlAddChildList(parent, cur);
18207: if (ret_val == NULL) { xmlFreeNodeList(cur) ; cur = NULL ; }
18208: desret_xmlNodePtr(ret_val);
18209: call_tests++;
18210: des_xmlNodePtr(n_parent, parent, 0);
18211: des_xmlNodePtr_in(n_cur, cur, 1);
18212: xmlResetLastError();
18213: if (mem_base != xmlMemBlocks()) {
18214: printf("Leak of %d blocks found in xmlAddChildList",
18215: xmlMemBlocks() - mem_base);
18216: test_ret++;
18217: printf(" %d", n_parent);
18218: printf(" %d", n_cur);
18219: printf("\n");
18220: }
18221: }
18222: }
18223: function_tests++;
18224:
18225: return(test_ret);
18226: }
18227:
18228:
18229: static int
18230: test_xmlAddNextSibling(void) {
18231: int test_ret = 0;
18232:
18233: int mem_base;
18234: xmlNodePtr ret_val;
18235: xmlNodePtr cur; /* the child node */
18236: int n_cur;
18237: xmlNodePtr elem; /* the new node */
18238: int n_elem;
18239:
18240: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
18241: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr_in;n_elem++) {
18242: mem_base = xmlMemBlocks();
18243: cur = gen_xmlNodePtr(n_cur, 0);
18244: elem = gen_xmlNodePtr_in(n_elem, 1);
18245:
18246: ret_val = xmlAddNextSibling(cur, elem);
18247: if (ret_val == NULL) { xmlFreeNode(elem) ; elem = NULL ; }
18248: desret_xmlNodePtr(ret_val);
18249: call_tests++;
18250: des_xmlNodePtr(n_cur, cur, 0);
18251: des_xmlNodePtr_in(n_elem, elem, 1);
18252: xmlResetLastError();
18253: if (mem_base != xmlMemBlocks()) {
18254: printf("Leak of %d blocks found in xmlAddNextSibling",
18255: xmlMemBlocks() - mem_base);
18256: test_ret++;
18257: printf(" %d", n_cur);
18258: printf(" %d", n_elem);
18259: printf("\n");
18260: }
18261: }
18262: }
18263: function_tests++;
18264:
18265: return(test_ret);
18266: }
18267:
18268:
18269: static int
18270: test_xmlAddPrevSibling(void) {
18271: int test_ret = 0;
18272:
18273: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
18274: int mem_base;
18275: xmlNodePtr ret_val;
18276: xmlNodePtr cur; /* the child node */
18277: int n_cur;
18278: xmlNodePtr elem; /* the new node */
18279: int n_elem;
18280:
18281: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
18282: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr_in;n_elem++) {
18283: mem_base = xmlMemBlocks();
18284: cur = gen_xmlNodePtr(n_cur, 0);
18285: elem = gen_xmlNodePtr_in(n_elem, 1);
18286:
18287: ret_val = xmlAddPrevSibling(cur, elem);
18288: if (ret_val == NULL) { xmlFreeNode(elem) ; elem = NULL ; }
18289: desret_xmlNodePtr(ret_val);
18290: call_tests++;
18291: des_xmlNodePtr(n_cur, cur, 0);
18292: des_xmlNodePtr_in(n_elem, elem, 1);
18293: xmlResetLastError();
18294: if (mem_base != xmlMemBlocks()) {
18295: printf("Leak of %d blocks found in xmlAddPrevSibling",
18296: xmlMemBlocks() - mem_base);
18297: test_ret++;
18298: printf(" %d", n_cur);
18299: printf(" %d", n_elem);
18300: printf("\n");
18301: }
18302: }
18303: }
18304: function_tests++;
18305: #endif
18306:
18307: return(test_ret);
18308: }
18309:
18310:
18311: static int
18312: test_xmlAddSibling(void) {
18313: int test_ret = 0;
18314:
18315: int mem_base;
18316: xmlNodePtr ret_val;
18317: xmlNodePtr cur; /* the child node */
18318: int n_cur;
18319: xmlNodePtr elem; /* the new node */
18320: int n_elem;
18321:
18322: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
18323: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr_in;n_elem++) {
18324: mem_base = xmlMemBlocks();
18325: cur = gen_xmlNodePtr(n_cur, 0);
18326: elem = gen_xmlNodePtr_in(n_elem, 1);
18327:
18328: ret_val = xmlAddSibling(cur, elem);
18329: if (ret_val == NULL) { xmlFreeNode(elem) ; elem = NULL ; }
18330: desret_xmlNodePtr(ret_val);
18331: call_tests++;
18332: des_xmlNodePtr(n_cur, cur, 0);
18333: des_xmlNodePtr_in(n_elem, elem, 1);
18334: xmlResetLastError();
18335: if (mem_base != xmlMemBlocks()) {
18336: printf("Leak of %d blocks found in xmlAddSibling",
18337: xmlMemBlocks() - mem_base);
18338: test_ret++;
18339: printf(" %d", n_cur);
18340: printf(" %d", n_elem);
18341: printf("\n");
18342: }
18343: }
18344: }
18345: function_tests++;
18346:
18347: return(test_ret);
18348: }
18349:
18350:
18351: static int
18352: test_xmlAttrSerializeTxtContent(void) {
18353: int test_ret = 0;
18354:
18355: #if defined(LIBXML_OUTPUT_ENABLED)
18356: #ifdef LIBXML_OUTPUT_ENABLED
18357: int mem_base;
18358: xmlBufferPtr buf; /* the XML buffer output */
18359: int n_buf;
18360: xmlDocPtr doc; /* the document */
18361: int n_doc;
18362: xmlAttrPtr attr; /* the attribute node */
18363: int n_attr;
18364: xmlChar * string; /* the text content */
18365: int n_string;
18366:
18367: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18368: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
18369: for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
18370: for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) {
18371: mem_base = xmlMemBlocks();
18372: buf = gen_xmlBufferPtr(n_buf, 0);
18373: doc = gen_xmlDocPtr(n_doc, 1);
18374: attr = gen_xmlAttrPtr(n_attr, 2);
18375: string = gen_const_xmlChar_ptr(n_string, 3);
18376:
18377: xmlAttrSerializeTxtContent(buf, doc, attr, (const xmlChar *)string);
18378: call_tests++;
18379: des_xmlBufferPtr(n_buf, buf, 0);
18380: des_xmlDocPtr(n_doc, doc, 1);
18381: des_xmlAttrPtr(n_attr, attr, 2);
18382: des_const_xmlChar_ptr(n_string, (const xmlChar *)string, 3);
18383: xmlResetLastError();
18384: if (mem_base != xmlMemBlocks()) {
18385: printf("Leak of %d blocks found in xmlAttrSerializeTxtContent",
18386: xmlMemBlocks() - mem_base);
18387: test_ret++;
18388: printf(" %d", n_buf);
18389: printf(" %d", n_doc);
18390: printf(" %d", n_attr);
18391: printf(" %d", n_string);
18392: printf("\n");
18393: }
18394: }
18395: }
18396: }
18397: }
18398: function_tests++;
18399: #endif
18400: #endif
18401:
18402: return(test_ret);
18403: }
18404:
18405:
1.1.1.3 ! misho 18406: #define gen_nb_const_xmlBufPtr 1
! 18407: static xmlBufPtr gen_const_xmlBufPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 18408: return(NULL);
! 18409: }
! 18410: static void des_const_xmlBufPtr(int no ATTRIBUTE_UNUSED, const xmlBufPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 18411: }
! 18412:
! 18413: static int
! 18414: test_xmlBufContent(void) {
! 18415: int test_ret = 0;
! 18416:
! 18417: int mem_base;
! 18418: xmlChar * ret_val;
! 18419: xmlBufPtr buf; /* the buffer */
! 18420: int n_buf;
! 18421:
! 18422: for (n_buf = 0;n_buf < gen_nb_const_xmlBufPtr;n_buf++) {
! 18423: mem_base = xmlMemBlocks();
! 18424: buf = gen_const_xmlBufPtr(n_buf, 0);
! 18425:
! 18426: ret_val = xmlBufContent((const xmlBufPtr)buf);
! 18427: desret_xmlChar_ptr(ret_val);
! 18428: call_tests++;
! 18429: des_const_xmlBufPtr(n_buf, (const xmlBufPtr)buf, 0);
! 18430: xmlResetLastError();
! 18431: if (mem_base != xmlMemBlocks()) {
! 18432: printf("Leak of %d blocks found in xmlBufContent",
! 18433: xmlMemBlocks() - mem_base);
! 18434: test_ret++;
! 18435: printf(" %d", n_buf);
! 18436: printf("\n");
! 18437: }
! 18438: }
! 18439: function_tests++;
! 18440:
! 18441: return(test_ret);
! 18442: }
! 18443:
! 18444:
! 18445: static int
! 18446: test_xmlBufEnd(void) {
! 18447: int test_ret = 0;
! 18448:
! 18449: int mem_base;
! 18450: xmlChar * ret_val;
! 18451: xmlBufPtr buf; /* the buffer */
! 18452: int n_buf;
! 18453:
! 18454: for (n_buf = 0;n_buf < gen_nb_const_xmlBufPtr;n_buf++) {
! 18455: mem_base = xmlMemBlocks();
! 18456: buf = gen_const_xmlBufPtr(n_buf, 0);
! 18457:
! 18458: ret_val = xmlBufEnd((const xmlBufPtr)buf);
! 18459: desret_xmlChar_ptr(ret_val);
! 18460: call_tests++;
! 18461: des_const_xmlBufPtr(n_buf, (const xmlBufPtr)buf, 0);
! 18462: xmlResetLastError();
! 18463: if (mem_base != xmlMemBlocks()) {
! 18464: printf("Leak of %d blocks found in xmlBufEnd",
! 18465: xmlMemBlocks() - mem_base);
! 18466: test_ret++;
! 18467: printf(" %d", n_buf);
! 18468: printf("\n");
! 18469: }
! 18470: }
! 18471: function_tests++;
! 18472:
! 18473: return(test_ret);
! 18474: }
! 18475:
! 18476:
! 18477: #define gen_nb_xmlBufPtr 1
! 18478: static xmlBufPtr gen_xmlBufPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 18479: return(NULL);
! 18480: }
! 18481: static void des_xmlBufPtr(int no ATTRIBUTE_UNUSED, xmlBufPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
! 18482: }
! 18483:
! 18484: static int
! 18485: test_xmlBufGetNodeContent(void) {
! 18486: int test_ret = 0;
! 18487:
! 18488: int mem_base;
! 18489: int ret_val;
! 18490: xmlBufPtr buf; /* a buffer xmlBufPtr */
! 18491: int n_buf;
! 18492: xmlNodePtr cur; /* the node being read */
! 18493: int n_cur;
! 18494:
! 18495: for (n_buf = 0;n_buf < gen_nb_xmlBufPtr;n_buf++) {
! 18496: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
! 18497: mem_base = xmlMemBlocks();
! 18498: buf = gen_xmlBufPtr(n_buf, 0);
! 18499: cur = gen_xmlNodePtr(n_cur, 1);
! 18500:
! 18501: ret_val = xmlBufGetNodeContent(buf, cur);
! 18502: desret_int(ret_val);
! 18503: call_tests++;
! 18504: des_xmlBufPtr(n_buf, buf, 0);
! 18505: des_xmlNodePtr(n_cur, cur, 1);
! 18506: xmlResetLastError();
! 18507: if (mem_base != xmlMemBlocks()) {
! 18508: printf("Leak of %d blocks found in xmlBufGetNodeContent",
! 18509: xmlMemBlocks() - mem_base);
! 18510: test_ret++;
! 18511: printf(" %d", n_buf);
! 18512: printf(" %d", n_cur);
! 18513: printf("\n");
! 18514: }
! 18515: }
! 18516: }
! 18517: function_tests++;
! 18518:
! 18519: return(test_ret);
! 18520: }
! 18521:
! 18522:
! 18523: static int
! 18524: test_xmlBufNodeDump(void) {
! 18525: int test_ret = 0;
! 18526:
! 18527:
! 18528: /* missing type support */
! 18529: return(test_ret);
! 18530: }
! 18531:
! 18532:
! 18533: static int
! 18534: test_xmlBufShrink(void) {
! 18535: int test_ret = 0;
! 18536:
! 18537:
! 18538: /* missing type support */
! 18539: return(test_ret);
! 18540: }
! 18541:
! 18542:
! 18543: static int
! 18544: test_xmlBufUse(void) {
! 18545: int test_ret = 0;
! 18546:
! 18547:
! 18548: /* missing type support */
! 18549: return(test_ret);
! 18550: }
! 18551:
! 18552:
1.1 misho 18553: static int
18554: test_xmlBufferAdd(void) {
18555: int test_ret = 0;
18556:
18557: int mem_base;
18558: int ret_val;
18559: xmlBufferPtr buf; /* the buffer to dump */
18560: int n_buf;
18561: xmlChar * str; /* the #xmlChar string */
18562: int n_str;
18563: int len; /* the number of #xmlChar to add */
18564: int n_len;
18565:
18566: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18567: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
18568: for (n_len = 0;n_len < gen_nb_int;n_len++) {
18569: mem_base = xmlMemBlocks();
18570: buf = gen_xmlBufferPtr(n_buf, 0);
18571: str = gen_const_xmlChar_ptr(n_str, 1);
18572: len = gen_int(n_len, 2);
18573:
18574: ret_val = xmlBufferAdd(buf, (const xmlChar *)str, len);
18575: desret_int(ret_val);
18576: call_tests++;
18577: des_xmlBufferPtr(n_buf, buf, 0);
18578: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
18579: des_int(n_len, len, 2);
18580: xmlResetLastError();
18581: if (mem_base != xmlMemBlocks()) {
18582: printf("Leak of %d blocks found in xmlBufferAdd",
18583: xmlMemBlocks() - mem_base);
18584: test_ret++;
18585: printf(" %d", n_buf);
18586: printf(" %d", n_str);
18587: printf(" %d", n_len);
18588: printf("\n");
18589: }
18590: }
18591: }
18592: }
18593: function_tests++;
18594:
18595: return(test_ret);
18596: }
18597:
18598:
18599: static int
18600: test_xmlBufferAddHead(void) {
18601: int test_ret = 0;
18602:
18603: int mem_base;
18604: int ret_val;
18605: xmlBufferPtr buf; /* the buffer */
18606: int n_buf;
18607: xmlChar * str; /* the #xmlChar string */
18608: int n_str;
18609: int len; /* the number of #xmlChar to add */
18610: int n_len;
18611:
18612: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18613: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
18614: for (n_len = 0;n_len < gen_nb_int;n_len++) {
18615: mem_base = xmlMemBlocks();
18616: buf = gen_xmlBufferPtr(n_buf, 0);
18617: str = gen_const_xmlChar_ptr(n_str, 1);
18618: len = gen_int(n_len, 2);
18619:
18620: ret_val = xmlBufferAddHead(buf, (const xmlChar *)str, len);
18621: desret_int(ret_val);
18622: call_tests++;
18623: des_xmlBufferPtr(n_buf, buf, 0);
18624: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
18625: des_int(n_len, len, 2);
18626: xmlResetLastError();
18627: if (mem_base != xmlMemBlocks()) {
18628: printf("Leak of %d blocks found in xmlBufferAddHead",
18629: xmlMemBlocks() - mem_base);
18630: test_ret++;
18631: printf(" %d", n_buf);
18632: printf(" %d", n_str);
18633: printf(" %d", n_len);
18634: printf("\n");
18635: }
18636: }
18637: }
18638: }
18639: function_tests++;
18640:
18641: return(test_ret);
18642: }
18643:
18644:
18645: static int
18646: test_xmlBufferCCat(void) {
18647: int test_ret = 0;
18648:
18649: int mem_base;
18650: int ret_val;
18651: xmlBufferPtr buf; /* the buffer to dump */
18652: int n_buf;
18653: char * str; /* the C char string */
18654: int n_str;
18655:
18656: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18657: for (n_str = 0;n_str < gen_nb_const_char_ptr;n_str++) {
18658: mem_base = xmlMemBlocks();
18659: buf = gen_xmlBufferPtr(n_buf, 0);
18660: str = gen_const_char_ptr(n_str, 1);
18661:
18662: ret_val = xmlBufferCCat(buf, (const char *)str);
18663: desret_int(ret_val);
18664: call_tests++;
18665: des_xmlBufferPtr(n_buf, buf, 0);
18666: des_const_char_ptr(n_str, (const char *)str, 1);
18667: xmlResetLastError();
18668: if (mem_base != xmlMemBlocks()) {
18669: printf("Leak of %d blocks found in xmlBufferCCat",
18670: xmlMemBlocks() - mem_base);
18671: test_ret++;
18672: printf(" %d", n_buf);
18673: printf(" %d", n_str);
18674: printf("\n");
18675: }
18676: }
18677: }
18678: function_tests++;
18679:
18680: return(test_ret);
18681: }
18682:
18683:
18684: static int
18685: test_xmlBufferCat(void) {
18686: int test_ret = 0;
18687:
18688: int mem_base;
18689: int ret_val;
18690: xmlBufferPtr buf; /* the buffer to add to */
18691: int n_buf;
18692: xmlChar * str; /* the #xmlChar string */
18693: int n_str;
18694:
18695: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18696: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
18697: mem_base = xmlMemBlocks();
18698: buf = gen_xmlBufferPtr(n_buf, 0);
18699: str = gen_const_xmlChar_ptr(n_str, 1);
18700:
18701: ret_val = xmlBufferCat(buf, (const xmlChar *)str);
18702: desret_int(ret_val);
18703: call_tests++;
18704: des_xmlBufferPtr(n_buf, buf, 0);
18705: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
18706: xmlResetLastError();
18707: if (mem_base != xmlMemBlocks()) {
18708: printf("Leak of %d blocks found in xmlBufferCat",
18709: xmlMemBlocks() - mem_base);
18710: test_ret++;
18711: printf(" %d", n_buf);
18712: printf(" %d", n_str);
18713: printf("\n");
18714: }
18715: }
18716: }
18717: function_tests++;
18718:
18719: return(test_ret);
18720: }
18721:
18722:
18723: #define gen_nb_const_xmlBufferPtr 1
18724: static xmlBufferPtr gen_const_xmlBufferPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
18725: return(NULL);
18726: }
18727: static void des_const_xmlBufferPtr(int no ATTRIBUTE_UNUSED, const xmlBufferPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
18728: }
18729:
18730: static int
18731: test_xmlBufferContent(void) {
18732: int test_ret = 0;
18733:
18734: int mem_base;
18735: const xmlChar * ret_val;
18736: xmlBufferPtr buf; /* the buffer */
18737: int n_buf;
18738:
18739: for (n_buf = 0;n_buf < gen_nb_const_xmlBufferPtr;n_buf++) {
18740: mem_base = xmlMemBlocks();
18741: buf = gen_const_xmlBufferPtr(n_buf, 0);
18742:
18743: ret_val = xmlBufferContent((const xmlBufferPtr)buf);
18744: desret_const_xmlChar_ptr(ret_val);
18745: call_tests++;
18746: des_const_xmlBufferPtr(n_buf, (const xmlBufferPtr)buf, 0);
18747: xmlResetLastError();
18748: if (mem_base != xmlMemBlocks()) {
18749: printf("Leak of %d blocks found in xmlBufferContent",
18750: xmlMemBlocks() - mem_base);
18751: test_ret++;
18752: printf(" %d", n_buf);
18753: printf("\n");
18754: }
18755: }
18756: function_tests++;
18757:
18758: return(test_ret);
18759: }
18760:
18761:
18762: static int
18763: test_xmlBufferCreate(void) {
18764: int test_ret = 0;
18765:
18766: int mem_base;
18767: xmlBufferPtr ret_val;
18768:
18769: mem_base = xmlMemBlocks();
18770:
18771: ret_val = xmlBufferCreate();
18772: desret_xmlBufferPtr(ret_val);
18773: call_tests++;
18774: xmlResetLastError();
18775: if (mem_base != xmlMemBlocks()) {
18776: printf("Leak of %d blocks found in xmlBufferCreate",
18777: xmlMemBlocks() - mem_base);
18778: test_ret++;
18779: printf("\n");
18780: }
18781: function_tests++;
18782:
18783: return(test_ret);
18784: }
18785:
18786:
18787: static int
18788: test_xmlBufferCreateSize(void) {
18789: int test_ret = 0;
18790:
18791:
18792: /* missing type support */
18793: return(test_ret);
18794: }
18795:
18796:
18797: static int
18798: test_xmlBufferCreateStatic(void) {
18799: int test_ret = 0;
18800:
18801:
18802: /* missing type support */
18803: return(test_ret);
18804: }
18805:
18806:
18807: static int
1.1.1.2 misho 18808: test_xmlBufferDetach(void) {
18809: int test_ret = 0;
18810:
18811: int mem_base;
18812: xmlChar * ret_val;
18813: xmlBufferPtr buf; /* the buffer */
18814: int n_buf;
18815:
18816: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18817: mem_base = xmlMemBlocks();
18818: buf = gen_xmlBufferPtr(n_buf, 0);
18819:
18820: ret_val = xmlBufferDetach(buf);
18821: desret_xmlChar_ptr(ret_val);
18822: call_tests++;
18823: des_xmlBufferPtr(n_buf, buf, 0);
18824: xmlResetLastError();
18825: if (mem_base != xmlMemBlocks()) {
18826: printf("Leak of %d blocks found in xmlBufferDetach",
18827: xmlMemBlocks() - mem_base);
18828: test_ret++;
18829: printf(" %d", n_buf);
18830: printf("\n");
18831: }
18832: }
18833: function_tests++;
18834:
18835: return(test_ret);
18836: }
18837:
18838:
18839: static int
1.1 misho 18840: test_xmlBufferEmpty(void) {
18841: int test_ret = 0;
18842:
18843: int mem_base;
18844: xmlBufferPtr buf; /* the buffer */
18845: int n_buf;
18846:
18847: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18848: mem_base = xmlMemBlocks();
18849: buf = gen_xmlBufferPtr(n_buf, 0);
18850:
18851: xmlBufferEmpty(buf);
18852: call_tests++;
18853: des_xmlBufferPtr(n_buf, buf, 0);
18854: xmlResetLastError();
18855: if (mem_base != xmlMemBlocks()) {
18856: printf("Leak of %d blocks found in xmlBufferEmpty",
18857: xmlMemBlocks() - mem_base);
18858: test_ret++;
18859: printf(" %d", n_buf);
18860: printf("\n");
18861: }
18862: }
18863: function_tests++;
18864:
18865: return(test_ret);
18866: }
18867:
18868:
18869: static int
18870: test_xmlBufferGrow(void) {
18871: int test_ret = 0;
18872:
18873: int mem_base;
18874: int ret_val;
18875: xmlBufferPtr buf; /* the buffer */
18876: int n_buf;
18877: unsigned int len; /* the minimum free size to allocate */
18878: int n_len;
18879:
18880: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18881: for (n_len = 0;n_len < gen_nb_unsigned_int;n_len++) {
18882: mem_base = xmlMemBlocks();
18883: buf = gen_xmlBufferPtr(n_buf, 0);
18884: len = gen_unsigned_int(n_len, 1);
18885:
18886: ret_val = xmlBufferGrow(buf, len);
18887: desret_int(ret_val);
18888: call_tests++;
18889: des_xmlBufferPtr(n_buf, buf, 0);
18890: des_unsigned_int(n_len, len, 1);
18891: xmlResetLastError();
18892: if (mem_base != xmlMemBlocks()) {
18893: printf("Leak of %d blocks found in xmlBufferGrow",
18894: xmlMemBlocks() - mem_base);
18895: test_ret++;
18896: printf(" %d", n_buf);
18897: printf(" %d", n_len);
18898: printf("\n");
18899: }
18900: }
18901: }
18902: function_tests++;
18903:
18904: return(test_ret);
18905: }
18906:
18907:
18908: static int
18909: test_xmlBufferLength(void) {
18910: int test_ret = 0;
18911:
18912: int mem_base;
18913: int ret_val;
18914: xmlBufferPtr buf; /* the buffer */
18915: int n_buf;
18916:
18917: for (n_buf = 0;n_buf < gen_nb_const_xmlBufferPtr;n_buf++) {
18918: mem_base = xmlMemBlocks();
18919: buf = gen_const_xmlBufferPtr(n_buf, 0);
18920:
18921: ret_val = xmlBufferLength((const xmlBufferPtr)buf);
18922: desret_int(ret_val);
18923: call_tests++;
18924: des_const_xmlBufferPtr(n_buf, (const xmlBufferPtr)buf, 0);
18925: xmlResetLastError();
18926: if (mem_base != xmlMemBlocks()) {
18927: printf("Leak of %d blocks found in xmlBufferLength",
18928: xmlMemBlocks() - mem_base);
18929: test_ret++;
18930: printf(" %d", n_buf);
18931: printf("\n");
18932: }
18933: }
18934: function_tests++;
18935:
18936: return(test_ret);
18937: }
18938:
18939:
18940: static int
18941: test_xmlBufferResize(void) {
18942: int test_ret = 0;
18943:
18944: int mem_base;
18945: int ret_val;
18946: xmlBufferPtr buf; /* the buffer to resize */
18947: int n_buf;
18948: unsigned int size; /* the desired size */
18949: int n_size;
18950:
18951: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18952: for (n_size = 0;n_size < gen_nb_unsigned_int;n_size++) {
18953: mem_base = xmlMemBlocks();
18954: buf = gen_xmlBufferPtr(n_buf, 0);
18955: size = gen_unsigned_int(n_size, 1);
18956:
18957: ret_val = xmlBufferResize(buf, size);
18958: desret_int(ret_val);
18959: call_tests++;
18960: des_xmlBufferPtr(n_buf, buf, 0);
18961: des_unsigned_int(n_size, size, 1);
18962: xmlResetLastError();
18963: if (mem_base != xmlMemBlocks()) {
18964: printf("Leak of %d blocks found in xmlBufferResize",
18965: xmlMemBlocks() - mem_base);
18966: test_ret++;
18967: printf(" %d", n_buf);
18968: printf(" %d", n_size);
18969: printf("\n");
18970: }
18971: }
18972: }
18973: function_tests++;
18974:
18975: return(test_ret);
18976: }
18977:
18978:
18979: static int
18980: test_xmlBufferSetAllocationScheme(void) {
18981: int test_ret = 0;
18982:
18983: int mem_base;
18984: xmlBufferPtr buf; /* the buffer to tune */
18985: int n_buf;
18986: xmlBufferAllocationScheme scheme; /* allocation scheme to use */
18987: int n_scheme;
18988:
18989: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18990: for (n_scheme = 0;n_scheme < gen_nb_xmlBufferAllocationScheme;n_scheme++) {
18991: mem_base = xmlMemBlocks();
18992: buf = gen_xmlBufferPtr(n_buf, 0);
18993: scheme = gen_xmlBufferAllocationScheme(n_scheme, 1);
18994:
18995: xmlBufferSetAllocationScheme(buf, scheme);
18996: if ((buf != NULL) && (scheme == XML_BUFFER_ALLOC_IMMUTABLE) && (buf->content != NULL) && (buf->content != static_buf_content)) { xmlFree(buf->content); buf->content = NULL;}
18997: call_tests++;
18998: des_xmlBufferPtr(n_buf, buf, 0);
18999: des_xmlBufferAllocationScheme(n_scheme, scheme, 1);
19000: xmlResetLastError();
19001: if (mem_base != xmlMemBlocks()) {
19002: printf("Leak of %d blocks found in xmlBufferSetAllocationScheme",
19003: xmlMemBlocks() - mem_base);
19004: test_ret++;
19005: printf(" %d", n_buf);
19006: printf(" %d", n_scheme);
19007: printf("\n");
19008: }
19009: }
19010: }
19011: function_tests++;
19012:
19013: return(test_ret);
19014: }
19015:
19016:
19017: static int
19018: test_xmlBufferShrink(void) {
19019: int test_ret = 0;
19020:
19021: int mem_base;
19022: int ret_val;
19023: xmlBufferPtr buf; /* the buffer to dump */
19024: int n_buf;
19025: unsigned int len; /* the number of xmlChar to remove */
19026: int n_len;
19027:
19028: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
19029: for (n_len = 0;n_len < gen_nb_unsigned_int;n_len++) {
19030: mem_base = xmlMemBlocks();
19031: buf = gen_xmlBufferPtr(n_buf, 0);
19032: len = gen_unsigned_int(n_len, 1);
19033:
19034: ret_val = xmlBufferShrink(buf, len);
19035: desret_int(ret_val);
19036: call_tests++;
19037: des_xmlBufferPtr(n_buf, buf, 0);
19038: des_unsigned_int(n_len, len, 1);
19039: xmlResetLastError();
19040: if (mem_base != xmlMemBlocks()) {
19041: printf("Leak of %d blocks found in xmlBufferShrink",
19042: xmlMemBlocks() - mem_base);
19043: test_ret++;
19044: printf(" %d", n_buf);
19045: printf(" %d", n_len);
19046: printf("\n");
19047: }
19048: }
19049: }
19050: function_tests++;
19051:
19052: return(test_ret);
19053: }
19054:
19055:
19056: static int
19057: test_xmlBufferWriteCHAR(void) {
19058: int test_ret = 0;
19059:
19060: int mem_base;
19061: xmlBufferPtr buf; /* the XML buffer */
19062: int n_buf;
19063: xmlChar * string; /* the string to add */
19064: int n_string;
19065:
19066: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
19067: for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) {
19068: mem_base = xmlMemBlocks();
19069: buf = gen_xmlBufferPtr(n_buf, 0);
19070: string = gen_const_xmlChar_ptr(n_string, 1);
19071:
19072: xmlBufferWriteCHAR(buf, (const xmlChar *)string);
19073: call_tests++;
19074: des_xmlBufferPtr(n_buf, buf, 0);
19075: des_const_xmlChar_ptr(n_string, (const xmlChar *)string, 1);
19076: xmlResetLastError();
19077: if (mem_base != xmlMemBlocks()) {
19078: printf("Leak of %d blocks found in xmlBufferWriteCHAR",
19079: xmlMemBlocks() - mem_base);
19080: test_ret++;
19081: printf(" %d", n_buf);
19082: printf(" %d", n_string);
19083: printf("\n");
19084: }
19085: }
19086: }
19087: function_tests++;
19088:
19089: return(test_ret);
19090: }
19091:
19092:
19093: static int
19094: test_xmlBufferWriteChar(void) {
19095: int test_ret = 0;
19096:
19097: int mem_base;
19098: xmlBufferPtr buf; /* the XML buffer output */
19099: int n_buf;
19100: char * string; /* the string to add */
19101: int n_string;
19102:
19103: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
19104: for (n_string = 0;n_string < gen_nb_const_char_ptr;n_string++) {
19105: mem_base = xmlMemBlocks();
19106: buf = gen_xmlBufferPtr(n_buf, 0);
19107: string = gen_const_char_ptr(n_string, 1);
19108:
19109: xmlBufferWriteChar(buf, (const char *)string);
19110: call_tests++;
19111: des_xmlBufferPtr(n_buf, buf, 0);
19112: des_const_char_ptr(n_string, (const char *)string, 1);
19113: xmlResetLastError();
19114: if (mem_base != xmlMemBlocks()) {
19115: printf("Leak of %d blocks found in xmlBufferWriteChar",
19116: xmlMemBlocks() - mem_base);
19117: test_ret++;
19118: printf(" %d", n_buf);
19119: printf(" %d", n_string);
19120: printf("\n");
19121: }
19122: }
19123: }
19124: function_tests++;
19125:
19126: return(test_ret);
19127: }
19128:
19129:
19130: static int
19131: test_xmlBufferWriteQuotedString(void) {
19132: int test_ret = 0;
19133:
19134: int mem_base;
19135: xmlBufferPtr buf; /* the XML buffer output */
19136: int n_buf;
19137: xmlChar * string; /* the string to add */
19138: int n_string;
19139:
19140: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
19141: for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) {
19142: mem_base = xmlMemBlocks();
19143: buf = gen_xmlBufferPtr(n_buf, 0);
19144: string = gen_const_xmlChar_ptr(n_string, 1);
19145:
19146: xmlBufferWriteQuotedString(buf, (const xmlChar *)string);
19147: call_tests++;
19148: des_xmlBufferPtr(n_buf, buf, 0);
19149: des_const_xmlChar_ptr(n_string, (const xmlChar *)string, 1);
19150: xmlResetLastError();
19151: if (mem_base != xmlMemBlocks()) {
19152: printf("Leak of %d blocks found in xmlBufferWriteQuotedString",
19153: xmlMemBlocks() - mem_base);
19154: test_ret++;
19155: printf(" %d", n_buf);
19156: printf(" %d", n_string);
19157: printf("\n");
19158: }
19159: }
19160: }
19161: function_tests++;
19162:
19163: return(test_ret);
19164: }
19165:
19166:
19167: static int
19168: test_xmlBuildQName(void) {
19169: int test_ret = 0;
19170:
19171: int mem_base;
19172: xmlChar * ret_val;
19173: xmlChar * ncname; /* the Name */
19174: int n_ncname;
19175: xmlChar * prefix; /* the prefix */
19176: int n_prefix;
19177: xmlChar * memory; /* preallocated memory */
19178: int n_memory;
19179: int len; /* preallocated memory length */
19180: int n_len;
19181:
19182: for (n_ncname = 0;n_ncname < gen_nb_const_xmlChar_ptr;n_ncname++) {
19183: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
19184: for (n_memory = 0;n_memory < gen_nb_xmlChar_ptr;n_memory++) {
19185: for (n_len = 0;n_len < gen_nb_int;n_len++) {
19186: mem_base = xmlMemBlocks();
19187: ncname = gen_const_xmlChar_ptr(n_ncname, 0);
19188: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
19189: memory = gen_xmlChar_ptr(n_memory, 2);
19190: len = gen_int(n_len, 3);
19191:
19192: ret_val = xmlBuildQName((const xmlChar *)ncname, (const xmlChar *)prefix, memory, len);
19193: if ((ret_val != NULL) && (ret_val != ncname) &&
19194: (ret_val != prefix) && (ret_val != memory))
19195: xmlFree(ret_val);
19196: ret_val = NULL;
19197: desret_xmlChar_ptr(ret_val);
19198: call_tests++;
19199: des_const_xmlChar_ptr(n_ncname, (const xmlChar *)ncname, 0);
19200: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
19201: des_xmlChar_ptr(n_memory, memory, 2);
19202: des_int(n_len, len, 3);
19203: xmlResetLastError();
19204: if (mem_base != xmlMemBlocks()) {
19205: printf("Leak of %d blocks found in xmlBuildQName",
19206: xmlMemBlocks() - mem_base);
19207: test_ret++;
19208: printf(" %d", n_ncname);
19209: printf(" %d", n_prefix);
19210: printf(" %d", n_memory);
19211: printf(" %d", n_len);
19212: printf("\n");
19213: }
19214: }
19215: }
19216: }
19217: }
19218: function_tests++;
19219:
19220: return(test_ret);
19221: }
19222:
19223:
19224: static int
19225: test_xmlChildElementCount(void) {
19226: int test_ret = 0;
19227:
19228: #if defined(LIBXML_TREE_ENABLED)
19229: int mem_base;
19230: unsigned long ret_val;
19231: xmlNodePtr parent; /* the parent node */
19232: int n_parent;
19233:
19234: for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
19235: mem_base = xmlMemBlocks();
19236: parent = gen_xmlNodePtr(n_parent, 0);
19237:
19238: ret_val = xmlChildElementCount(parent);
19239: desret_unsigned_long(ret_val);
19240: call_tests++;
19241: des_xmlNodePtr(n_parent, parent, 0);
19242: xmlResetLastError();
19243: if (mem_base != xmlMemBlocks()) {
19244: printf("Leak of %d blocks found in xmlChildElementCount",
19245: xmlMemBlocks() - mem_base);
19246: test_ret++;
19247: printf(" %d", n_parent);
19248: printf("\n");
19249: }
19250: }
19251: function_tests++;
19252: #endif
19253:
19254: return(test_ret);
19255: }
19256:
19257:
19258: static int
19259: test_xmlCopyDoc(void) {
19260: int test_ret = 0;
19261:
19262: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
19263: int mem_base;
19264: xmlDocPtr ret_val;
19265: xmlDocPtr doc; /* the document */
19266: int n_doc;
19267: int recursive; /* if not zero do a recursive copy. */
19268: int n_recursive;
19269:
19270: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
19271: for (n_recursive = 0;n_recursive < gen_nb_int;n_recursive++) {
19272: mem_base = xmlMemBlocks();
19273: doc = gen_xmlDocPtr(n_doc, 0);
19274: recursive = gen_int(n_recursive, 1);
19275:
19276: ret_val = xmlCopyDoc(doc, recursive);
19277: desret_xmlDocPtr(ret_val);
19278: call_tests++;
19279: des_xmlDocPtr(n_doc, doc, 0);
19280: des_int(n_recursive, recursive, 1);
19281: xmlResetLastError();
19282: if (mem_base != xmlMemBlocks()) {
19283: printf("Leak of %d blocks found in xmlCopyDoc",
19284: xmlMemBlocks() - mem_base);
19285: test_ret++;
19286: printf(" %d", n_doc);
19287: printf(" %d", n_recursive);
19288: printf("\n");
19289: }
19290: }
19291: }
19292: function_tests++;
19293: #endif
19294:
19295: return(test_ret);
19296: }
19297:
19298:
19299: static int
19300: test_xmlCopyDtd(void) {
19301: int test_ret = 0;
19302:
19303: #if defined(LIBXML_TREE_ENABLED)
19304: int mem_base;
19305: xmlDtdPtr ret_val;
19306: xmlDtdPtr dtd; /* the dtd */
19307: int n_dtd;
19308:
19309: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
19310: mem_base = xmlMemBlocks();
19311: dtd = gen_xmlDtdPtr(n_dtd, 0);
19312:
19313: ret_val = xmlCopyDtd(dtd);
19314: desret_xmlDtdPtr(ret_val);
19315: call_tests++;
19316: des_xmlDtdPtr(n_dtd, dtd, 0);
19317: xmlResetLastError();
19318: if (mem_base != xmlMemBlocks()) {
19319: printf("Leak of %d blocks found in xmlCopyDtd",
19320: xmlMemBlocks() - mem_base);
19321: test_ret++;
19322: printf(" %d", n_dtd);
19323: printf("\n");
19324: }
19325: }
19326: function_tests++;
19327: #endif
19328:
19329: return(test_ret);
19330: }
19331:
19332:
19333: static int
19334: test_xmlCopyNamespace(void) {
19335: int test_ret = 0;
19336:
19337: int mem_base;
19338: xmlNsPtr ret_val;
19339: xmlNsPtr cur; /* the namespace */
19340: int n_cur;
19341:
19342: for (n_cur = 0;n_cur < gen_nb_xmlNsPtr;n_cur++) {
19343: mem_base = xmlMemBlocks();
19344: cur = gen_xmlNsPtr(n_cur, 0);
19345:
19346: ret_val = xmlCopyNamespace(cur);
19347: if (ret_val != NULL) xmlFreeNs(ret_val);
19348: desret_xmlNsPtr(ret_val);
19349: call_tests++;
19350: des_xmlNsPtr(n_cur, cur, 0);
19351: xmlResetLastError();
19352: if (mem_base != xmlMemBlocks()) {
19353: printf("Leak of %d blocks found in xmlCopyNamespace",
19354: xmlMemBlocks() - mem_base);
19355: test_ret++;
19356: printf(" %d", n_cur);
19357: printf("\n");
19358: }
19359: }
19360: function_tests++;
19361:
19362: return(test_ret);
19363: }
19364:
19365:
19366: static int
19367: test_xmlCopyNamespaceList(void) {
19368: int test_ret = 0;
19369:
19370: int mem_base;
19371: xmlNsPtr ret_val;
19372: xmlNsPtr cur; /* the first namespace */
19373: int n_cur;
19374:
19375: for (n_cur = 0;n_cur < gen_nb_xmlNsPtr;n_cur++) {
19376: mem_base = xmlMemBlocks();
19377: cur = gen_xmlNsPtr(n_cur, 0);
19378:
19379: ret_val = xmlCopyNamespaceList(cur);
19380: if (ret_val != NULL) xmlFreeNsList(ret_val);
19381: desret_xmlNsPtr(ret_val);
19382: call_tests++;
19383: des_xmlNsPtr(n_cur, cur, 0);
19384: xmlResetLastError();
19385: if (mem_base != xmlMemBlocks()) {
19386: printf("Leak of %d blocks found in xmlCopyNamespaceList",
19387: xmlMemBlocks() - mem_base);
19388: test_ret++;
19389: printf(" %d", n_cur);
19390: printf("\n");
19391: }
19392: }
19393: function_tests++;
19394:
19395: return(test_ret);
19396: }
19397:
19398:
19399: static int
19400: test_xmlCopyNode(void) {
19401: int test_ret = 0;
19402:
19403: int mem_base;
19404: xmlNodePtr ret_val;
19405: xmlNodePtr node; /* the node */
19406: int n_node;
19407: int extended; /* if 1 do a recursive copy (properties, namespaces and children when applicable) if 2 copy properties and namespaces (when applicable) */
19408: int n_extended;
19409:
19410: for (n_node = 0;n_node < gen_nb_const_xmlNodePtr;n_node++) {
19411: for (n_extended = 0;n_extended < gen_nb_int;n_extended++) {
19412: mem_base = xmlMemBlocks();
19413: node = gen_const_xmlNodePtr(n_node, 0);
19414: extended = gen_int(n_extended, 1);
19415:
19416: ret_val = xmlCopyNode((const xmlNodePtr)node, extended);
19417: desret_xmlNodePtr(ret_val);
19418: call_tests++;
19419: des_const_xmlNodePtr(n_node, (const xmlNodePtr)node, 0);
19420: des_int(n_extended, extended, 1);
19421: xmlResetLastError();
19422: if (mem_base != xmlMemBlocks()) {
19423: printf("Leak of %d blocks found in xmlCopyNode",
19424: xmlMemBlocks() - mem_base);
19425: test_ret++;
19426: printf(" %d", n_node);
19427: printf(" %d", n_extended);
19428: printf("\n");
19429: }
19430: }
19431: }
19432: function_tests++;
19433:
19434: return(test_ret);
19435: }
19436:
19437:
19438: static int
19439: test_xmlCopyNodeList(void) {
19440: int test_ret = 0;
19441:
19442: int mem_base;
19443: xmlNodePtr ret_val;
19444: xmlNodePtr node; /* the first node in the list. */
19445: int n_node;
19446:
19447: for (n_node = 0;n_node < gen_nb_const_xmlNodePtr;n_node++) {
19448: mem_base = xmlMemBlocks();
19449: node = gen_const_xmlNodePtr(n_node, 0);
19450:
19451: ret_val = xmlCopyNodeList((const xmlNodePtr)node);
19452: desret_xmlNodePtr(ret_val);
19453: call_tests++;
19454: des_const_xmlNodePtr(n_node, (const xmlNodePtr)node, 0);
19455: xmlResetLastError();
19456: if (mem_base != xmlMemBlocks()) {
19457: printf("Leak of %d blocks found in xmlCopyNodeList",
19458: xmlMemBlocks() - mem_base);
19459: test_ret++;
19460: printf(" %d", n_node);
19461: printf("\n");
19462: }
19463: }
19464: function_tests++;
19465:
19466: return(test_ret);
19467: }
19468:
19469:
19470: static int
19471: test_xmlCopyProp(void) {
19472: int test_ret = 0;
19473:
19474: int mem_base;
19475: xmlAttrPtr ret_val;
19476: xmlNodePtr target; /* the element where the attribute will be grafted */
19477: int n_target;
19478: xmlAttrPtr cur; /* the attribute */
19479: int n_cur;
19480:
19481: for (n_target = 0;n_target < gen_nb_xmlNodePtr;n_target++) {
19482: for (n_cur = 0;n_cur < gen_nb_xmlAttrPtr;n_cur++) {
19483: mem_base = xmlMemBlocks();
19484: target = gen_xmlNodePtr(n_target, 0);
19485: cur = gen_xmlAttrPtr(n_cur, 1);
19486:
19487: ret_val = xmlCopyProp(target, cur);
19488: desret_xmlAttrPtr(ret_val);
19489: call_tests++;
19490: des_xmlNodePtr(n_target, target, 0);
19491: des_xmlAttrPtr(n_cur, cur, 1);
19492: xmlResetLastError();
19493: if (mem_base != xmlMemBlocks()) {
19494: printf("Leak of %d blocks found in xmlCopyProp",
19495: xmlMemBlocks() - mem_base);
19496: test_ret++;
19497: printf(" %d", n_target);
19498: printf(" %d", n_cur);
19499: printf("\n");
19500: }
19501: }
19502: }
19503: function_tests++;
19504:
19505: return(test_ret);
19506: }
19507:
19508:
19509: static int
19510: test_xmlCopyPropList(void) {
19511: int test_ret = 0;
19512:
19513: int mem_base;
19514: xmlAttrPtr ret_val;
19515: xmlNodePtr target; /* the element where the attributes will be grafted */
19516: int n_target;
19517: xmlAttrPtr cur; /* the first attribute */
19518: int n_cur;
19519:
19520: for (n_target = 0;n_target < gen_nb_xmlNodePtr;n_target++) {
19521: for (n_cur = 0;n_cur < gen_nb_xmlAttrPtr;n_cur++) {
19522: mem_base = xmlMemBlocks();
19523: target = gen_xmlNodePtr(n_target, 0);
19524: cur = gen_xmlAttrPtr(n_cur, 1);
19525:
19526: ret_val = xmlCopyPropList(target, cur);
19527: desret_xmlAttrPtr(ret_val);
19528: call_tests++;
19529: des_xmlNodePtr(n_target, target, 0);
19530: des_xmlAttrPtr(n_cur, cur, 1);
19531: xmlResetLastError();
19532: if (mem_base != xmlMemBlocks()) {
19533: printf("Leak of %d blocks found in xmlCopyPropList",
19534: xmlMemBlocks() - mem_base);
19535: test_ret++;
19536: printf(" %d", n_target);
19537: printf(" %d", n_cur);
19538: printf("\n");
19539: }
19540: }
19541: }
19542: function_tests++;
19543:
19544: return(test_ret);
19545: }
19546:
19547:
19548: static int
19549: test_xmlCreateIntSubset(void) {
19550: int test_ret = 0;
19551:
19552: int mem_base;
19553: xmlDtdPtr ret_val;
19554: xmlDocPtr doc; /* the document pointer */
19555: int n_doc;
19556: xmlChar * name; /* the DTD name */
19557: int n_name;
19558: xmlChar * ExternalID; /* the external (PUBLIC) ID */
19559: int n_ExternalID;
19560: xmlChar * SystemID; /* the system ID */
19561: int n_SystemID;
19562:
19563: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
19564: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
19565: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
19566: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
19567: mem_base = xmlMemBlocks();
19568: doc = gen_xmlDocPtr(n_doc, 0);
19569: name = gen_const_xmlChar_ptr(n_name, 1);
19570: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 2);
19571: SystemID = gen_const_xmlChar_ptr(n_SystemID, 3);
19572:
19573: ret_val = xmlCreateIntSubset(doc, (const xmlChar *)name, (const xmlChar *)ExternalID, (const xmlChar *)SystemID);
19574: desret_xmlDtdPtr(ret_val);
19575: call_tests++;
19576: des_xmlDocPtr(n_doc, doc, 0);
19577: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
19578: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 2);
19579: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 3);
19580: xmlResetLastError();
19581: if (mem_base != xmlMemBlocks()) {
19582: printf("Leak of %d blocks found in xmlCreateIntSubset",
19583: xmlMemBlocks() - mem_base);
19584: test_ret++;
19585: printf(" %d", n_doc);
19586: printf(" %d", n_name);
19587: printf(" %d", n_ExternalID);
19588: printf(" %d", n_SystemID);
19589: printf("\n");
19590: }
19591: }
19592: }
19593: }
19594: }
19595: function_tests++;
19596:
19597: return(test_ret);
19598: }
19599:
19600:
19601: #define gen_nb_xmlDOMWrapCtxtPtr 1
19602: static xmlDOMWrapCtxtPtr gen_xmlDOMWrapCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
19603: return(NULL);
19604: }
19605: static void des_xmlDOMWrapCtxtPtr(int no ATTRIBUTE_UNUSED, xmlDOMWrapCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
19606: }
19607:
19608: static int
19609: test_xmlDOMWrapAdoptNode(void) {
19610: int test_ret = 0;
19611:
19612: int mem_base;
19613: int ret_val;
19614: xmlDOMWrapCtxtPtr ctxt; /* the optional context for custom processing */
19615: int n_ctxt;
19616: xmlDocPtr sourceDoc; /* the optional sourceDoc */
19617: int n_sourceDoc;
19618: xmlNodePtr node; /* the node to start with */
19619: int n_node;
19620: xmlDocPtr destDoc; /* the destination doc */
19621: int n_destDoc;
19622: xmlNodePtr destParent; /* the optional new parent of @node in @destDoc */
19623: int n_destParent;
19624: int options; /* option flags */
19625: int n_options;
19626:
19627: for (n_ctxt = 0;n_ctxt < gen_nb_xmlDOMWrapCtxtPtr;n_ctxt++) {
19628: for (n_sourceDoc = 0;n_sourceDoc < gen_nb_xmlDocPtr;n_sourceDoc++) {
19629: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
19630: for (n_destDoc = 0;n_destDoc < gen_nb_xmlDocPtr;n_destDoc++) {
19631: for (n_destParent = 0;n_destParent < gen_nb_xmlNodePtr;n_destParent++) {
19632: for (n_options = 0;n_options < gen_nb_int;n_options++) {
19633: mem_base = xmlMemBlocks();
19634: ctxt = gen_xmlDOMWrapCtxtPtr(n_ctxt, 0);
19635: sourceDoc = gen_xmlDocPtr(n_sourceDoc, 1);
19636: node = gen_xmlNodePtr(n_node, 2);
19637: destDoc = gen_xmlDocPtr(n_destDoc, 3);
19638: destParent = gen_xmlNodePtr(n_destParent, 4);
19639: options = gen_int(n_options, 5);
19640:
19641: ret_val = xmlDOMWrapAdoptNode(ctxt, sourceDoc, node, destDoc, destParent, options);
19642: if ((node != NULL) && (node->parent == NULL)) {xmlUnlinkNode(node);xmlFreeNode(node);node = NULL;}
19643: desret_int(ret_val);
19644: call_tests++;
19645: des_xmlDOMWrapCtxtPtr(n_ctxt, ctxt, 0);
19646: des_xmlDocPtr(n_sourceDoc, sourceDoc, 1);
19647: des_xmlNodePtr(n_node, node, 2);
19648: des_xmlDocPtr(n_destDoc, destDoc, 3);
19649: des_xmlNodePtr(n_destParent, destParent, 4);
19650: des_int(n_options, options, 5);
19651: xmlResetLastError();
19652: if (mem_base != xmlMemBlocks()) {
19653: printf("Leak of %d blocks found in xmlDOMWrapAdoptNode",
19654: xmlMemBlocks() - mem_base);
19655: test_ret++;
19656: printf(" %d", n_ctxt);
19657: printf(" %d", n_sourceDoc);
19658: printf(" %d", n_node);
19659: printf(" %d", n_destDoc);
19660: printf(" %d", n_destParent);
19661: printf(" %d", n_options);
19662: printf("\n");
19663: }
19664: }
19665: }
19666: }
19667: }
19668: }
19669: }
19670: function_tests++;
19671:
19672: return(test_ret);
19673: }
19674:
19675:
19676: static int
19677: test_xmlDOMWrapCloneNode(void) {
19678: int test_ret = 0;
19679:
19680: int mem_base;
19681: int ret_val;
19682: xmlDOMWrapCtxtPtr ctxt; /* the optional context for custom processing */
19683: int n_ctxt;
19684: xmlDocPtr sourceDoc; /* the optional sourceDoc */
19685: int n_sourceDoc;
19686: xmlNodePtr node; /* the node to start with */
19687: int n_node;
19688: xmlNodePtr * resNode; /* the clone of the given @node */
19689: int n_resNode;
19690: xmlDocPtr destDoc; /* the destination doc */
19691: int n_destDoc;
19692: xmlNodePtr destParent; /* the optional new parent of @node in @destDoc */
19693: int n_destParent;
19694: int deep; /* descend into child if set */
19695: int n_deep;
19696: int options; /* option flags */
19697: int n_options;
19698:
19699: for (n_ctxt = 0;n_ctxt < gen_nb_xmlDOMWrapCtxtPtr;n_ctxt++) {
19700: for (n_sourceDoc = 0;n_sourceDoc < gen_nb_xmlDocPtr;n_sourceDoc++) {
19701: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
19702: for (n_resNode = 0;n_resNode < gen_nb_xmlNodePtr_ptr;n_resNode++) {
19703: for (n_destDoc = 0;n_destDoc < gen_nb_xmlDocPtr;n_destDoc++) {
19704: for (n_destParent = 0;n_destParent < gen_nb_xmlNodePtr;n_destParent++) {
19705: for (n_deep = 0;n_deep < gen_nb_int;n_deep++) {
19706: for (n_options = 0;n_options < gen_nb_int;n_options++) {
19707: mem_base = xmlMemBlocks();
19708: ctxt = gen_xmlDOMWrapCtxtPtr(n_ctxt, 0);
19709: sourceDoc = gen_xmlDocPtr(n_sourceDoc, 1);
19710: node = gen_xmlNodePtr(n_node, 2);
19711: resNode = gen_xmlNodePtr_ptr(n_resNode, 3);
19712: destDoc = gen_xmlDocPtr(n_destDoc, 4);
19713: destParent = gen_xmlNodePtr(n_destParent, 5);
19714: deep = gen_int(n_deep, 6);
19715: options = gen_int(n_options, 7);
19716:
19717: ret_val = xmlDOMWrapCloneNode(ctxt, sourceDoc, node, resNode, destDoc, destParent, deep, options);
19718: desret_int(ret_val);
19719: call_tests++;
19720: des_xmlDOMWrapCtxtPtr(n_ctxt, ctxt, 0);
19721: des_xmlDocPtr(n_sourceDoc, sourceDoc, 1);
19722: des_xmlNodePtr(n_node, node, 2);
19723: des_xmlNodePtr_ptr(n_resNode, resNode, 3);
19724: des_xmlDocPtr(n_destDoc, destDoc, 4);
19725: des_xmlNodePtr(n_destParent, destParent, 5);
19726: des_int(n_deep, deep, 6);
19727: des_int(n_options, options, 7);
19728: xmlResetLastError();
19729: if (mem_base != xmlMemBlocks()) {
19730: printf("Leak of %d blocks found in xmlDOMWrapCloneNode",
19731: xmlMemBlocks() - mem_base);
19732: test_ret++;
19733: printf(" %d", n_ctxt);
19734: printf(" %d", n_sourceDoc);
19735: printf(" %d", n_node);
19736: printf(" %d", n_resNode);
19737: printf(" %d", n_destDoc);
19738: printf(" %d", n_destParent);
19739: printf(" %d", n_deep);
19740: printf(" %d", n_options);
19741: printf("\n");
19742: }
19743: }
19744: }
19745: }
19746: }
19747: }
19748: }
19749: }
19750: }
19751: function_tests++;
19752:
19753: return(test_ret);
19754: }
19755:
19756:
19757: static int
19758: test_xmlDOMWrapNewCtxt(void) {
19759: int test_ret = 0;
19760:
19761:
19762: /* missing type support */
19763: return(test_ret);
19764: }
19765:
19766:
19767: static int
19768: test_xmlDOMWrapReconcileNamespaces(void) {
19769: int test_ret = 0;
19770:
19771: int mem_base;
19772: int ret_val;
19773: xmlDOMWrapCtxtPtr ctxt; /* DOM wrapper context, unused at the moment */
19774: int n_ctxt;
19775: xmlNodePtr elem; /* the element-node */
19776: int n_elem;
19777: int options; /* option flags */
19778: int n_options;
19779:
19780: for (n_ctxt = 0;n_ctxt < gen_nb_xmlDOMWrapCtxtPtr;n_ctxt++) {
19781: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
19782: for (n_options = 0;n_options < gen_nb_int;n_options++) {
19783: mem_base = xmlMemBlocks();
19784: ctxt = gen_xmlDOMWrapCtxtPtr(n_ctxt, 0);
19785: elem = gen_xmlNodePtr(n_elem, 1);
19786: options = gen_int(n_options, 2);
19787:
19788: ret_val = xmlDOMWrapReconcileNamespaces(ctxt, elem, options);
19789: desret_int(ret_val);
19790: call_tests++;
19791: des_xmlDOMWrapCtxtPtr(n_ctxt, ctxt, 0);
19792: des_xmlNodePtr(n_elem, elem, 1);
19793: des_int(n_options, options, 2);
19794: xmlResetLastError();
19795: if (mem_base != xmlMemBlocks()) {
19796: printf("Leak of %d blocks found in xmlDOMWrapReconcileNamespaces",
19797: xmlMemBlocks() - mem_base);
19798: test_ret++;
19799: printf(" %d", n_ctxt);
19800: printf(" %d", n_elem);
19801: printf(" %d", n_options);
19802: printf("\n");
19803: }
19804: }
19805: }
19806: }
19807: function_tests++;
19808:
19809: return(test_ret);
19810: }
19811:
19812:
19813: static int
19814: test_xmlDOMWrapRemoveNode(void) {
19815: int test_ret = 0;
19816:
19817: int mem_base;
19818: int ret_val;
19819: xmlDOMWrapCtxtPtr ctxt; /* a DOM wrapper context */
19820: int n_ctxt;
19821: xmlDocPtr doc; /* the doc */
19822: int n_doc;
19823: xmlNodePtr node; /* the node to be removed. */
19824: int n_node;
19825: int options; /* set of options, unused at the moment */
19826: int n_options;
19827:
19828: for (n_ctxt = 0;n_ctxt < gen_nb_xmlDOMWrapCtxtPtr;n_ctxt++) {
19829: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
19830: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
19831: for (n_options = 0;n_options < gen_nb_int;n_options++) {
19832: mem_base = xmlMemBlocks();
19833: ctxt = gen_xmlDOMWrapCtxtPtr(n_ctxt, 0);
19834: doc = gen_xmlDocPtr(n_doc, 1);
19835: node = gen_xmlNodePtr(n_node, 2);
19836: options = gen_int(n_options, 3);
19837:
19838: ret_val = xmlDOMWrapRemoveNode(ctxt, doc, node, options);
19839: desret_int(ret_val);
19840: call_tests++;
19841: des_xmlDOMWrapCtxtPtr(n_ctxt, ctxt, 0);
19842: des_xmlDocPtr(n_doc, doc, 1);
19843: des_xmlNodePtr(n_node, node, 2);
19844: des_int(n_options, options, 3);
19845: xmlResetLastError();
19846: if (mem_base != xmlMemBlocks()) {
19847: printf("Leak of %d blocks found in xmlDOMWrapRemoveNode",
19848: xmlMemBlocks() - mem_base);
19849: test_ret++;
19850: printf(" %d", n_ctxt);
19851: printf(" %d", n_doc);
19852: printf(" %d", n_node);
19853: printf(" %d", n_options);
19854: printf("\n");
19855: }
19856: }
19857: }
19858: }
19859: }
19860: function_tests++;
19861:
19862: return(test_ret);
19863: }
19864:
19865:
19866: static int
19867: test_xmlDocCopyNode(void) {
19868: int test_ret = 0;
19869:
19870: int mem_base;
19871: xmlNodePtr ret_val;
19872: xmlNodePtr node; /* the node */
19873: int n_node;
19874: xmlDocPtr doc; /* the document */
19875: int n_doc;
19876: int extended; /* if 1 do a recursive copy (properties, namespaces and children when applicable) if 2 copy properties and namespaces (when applicable) */
19877: int n_extended;
19878:
19879: for (n_node = 0;n_node < gen_nb_const_xmlNodePtr;n_node++) {
19880: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
19881: for (n_extended = 0;n_extended < gen_nb_int;n_extended++) {
19882: mem_base = xmlMemBlocks();
19883: node = gen_const_xmlNodePtr(n_node, 0);
19884: doc = gen_xmlDocPtr(n_doc, 1);
19885: extended = gen_int(n_extended, 2);
19886:
19887: ret_val = xmlDocCopyNode((const xmlNodePtr)node, doc, extended);
19888: desret_xmlNodePtr(ret_val);
19889: call_tests++;
19890: des_const_xmlNodePtr(n_node, (const xmlNodePtr)node, 0);
19891: des_xmlDocPtr(n_doc, doc, 1);
19892: des_int(n_extended, extended, 2);
19893: xmlResetLastError();
19894: if (mem_base != xmlMemBlocks()) {
19895: printf("Leak of %d blocks found in xmlDocCopyNode",
19896: xmlMemBlocks() - mem_base);
19897: test_ret++;
19898: printf(" %d", n_node);
19899: printf(" %d", n_doc);
19900: printf(" %d", n_extended);
19901: printf("\n");
19902: }
19903: }
19904: }
19905: }
19906: function_tests++;
19907:
19908: return(test_ret);
19909: }
19910:
19911:
19912: static int
19913: test_xmlDocCopyNodeList(void) {
19914: int test_ret = 0;
19915:
19916: int mem_base;
19917: xmlNodePtr ret_val;
19918: xmlDocPtr doc; /* the target document */
19919: int n_doc;
19920: xmlNodePtr node; /* the first node in the list. */
19921: int n_node;
19922:
19923: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
19924: for (n_node = 0;n_node < gen_nb_const_xmlNodePtr;n_node++) {
19925: mem_base = xmlMemBlocks();
19926: doc = gen_xmlDocPtr(n_doc, 0);
19927: node = gen_const_xmlNodePtr(n_node, 1);
19928:
19929: ret_val = xmlDocCopyNodeList(doc, (const xmlNodePtr)node);
19930: desret_xmlNodePtr(ret_val);
19931: call_tests++;
19932: des_xmlDocPtr(n_doc, doc, 0);
19933: des_const_xmlNodePtr(n_node, (const xmlNodePtr)node, 1);
19934: xmlResetLastError();
19935: if (mem_base != xmlMemBlocks()) {
19936: printf("Leak of %d blocks found in xmlDocCopyNodeList",
19937: xmlMemBlocks() - mem_base);
19938: test_ret++;
19939: printf(" %d", n_doc);
19940: printf(" %d", n_node);
19941: printf("\n");
19942: }
19943: }
19944: }
19945: function_tests++;
19946:
19947: return(test_ret);
19948: }
19949:
19950:
19951: static int
19952: test_xmlDocDump(void) {
19953: int test_ret = 0;
19954:
19955: #if defined(LIBXML_OUTPUT_ENABLED)
19956: int mem_base;
19957: int ret_val;
19958: FILE * f; /* the FILE* */
19959: int n_f;
19960: xmlDocPtr cur; /* the document */
19961: int n_cur;
19962:
19963: for (n_f = 0;n_f < gen_nb_FILE_ptr;n_f++) {
19964: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
19965: mem_base = xmlMemBlocks();
19966: f = gen_FILE_ptr(n_f, 0);
19967: cur = gen_xmlDocPtr(n_cur, 1);
19968:
19969: ret_val = xmlDocDump(f, cur);
19970: desret_int(ret_val);
19971: call_tests++;
19972: des_FILE_ptr(n_f, f, 0);
19973: des_xmlDocPtr(n_cur, cur, 1);
19974: xmlResetLastError();
19975: if (mem_base != xmlMemBlocks()) {
19976: printf("Leak of %d blocks found in xmlDocDump",
19977: xmlMemBlocks() - mem_base);
19978: test_ret++;
19979: printf(" %d", n_f);
19980: printf(" %d", n_cur);
19981: printf("\n");
19982: }
19983: }
19984: }
19985: function_tests++;
19986: #endif
19987:
19988: return(test_ret);
19989: }
19990:
19991:
19992: static int
19993: test_xmlDocDumpFormatMemory(void) {
19994: int test_ret = 0;
19995:
19996: #if defined(LIBXML_OUTPUT_ENABLED)
19997: int mem_base;
19998: xmlDocPtr cur; /* the document */
19999: int n_cur;
20000: xmlChar ** mem; /* OUT: the memory pointer */
20001: int n_mem;
20002: int * size; /* OUT: the memory length */
20003: int n_size;
20004: int format; /* should formatting spaces been added */
20005: int n_format;
20006:
20007: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
20008: for (n_mem = 0;n_mem < gen_nb_xmlChar_ptr_ptr;n_mem++) {
20009: for (n_size = 0;n_size < gen_nb_int_ptr;n_size++) {
20010: for (n_format = 0;n_format < gen_nb_int;n_format++) {
20011: mem_base = xmlMemBlocks();
20012: cur = gen_xmlDocPtr(n_cur, 0);
20013: mem = gen_xmlChar_ptr_ptr(n_mem, 1);
20014: size = gen_int_ptr(n_size, 2);
20015: format = gen_int(n_format, 3);
20016:
20017: xmlDocDumpFormatMemory(cur, mem, size, format);
20018: call_tests++;
20019: des_xmlDocPtr(n_cur, cur, 0);
20020: des_xmlChar_ptr_ptr(n_mem, mem, 1);
20021: des_int_ptr(n_size, size, 2);
20022: des_int(n_format, format, 3);
20023: xmlResetLastError();
20024: if (mem_base != xmlMemBlocks()) {
20025: printf("Leak of %d blocks found in xmlDocDumpFormatMemory",
20026: xmlMemBlocks() - mem_base);
20027: test_ret++;
20028: printf(" %d", n_cur);
20029: printf(" %d", n_mem);
20030: printf(" %d", n_size);
20031: printf(" %d", n_format);
20032: printf("\n");
20033: }
20034: }
20035: }
20036: }
20037: }
20038: function_tests++;
20039: #endif
20040:
20041: return(test_ret);
20042: }
20043:
20044:
20045: static int
20046: test_xmlDocDumpFormatMemoryEnc(void) {
20047: int test_ret = 0;
20048:
20049: #if defined(LIBXML_OUTPUT_ENABLED)
20050: int mem_base;
20051: xmlDocPtr out_doc; /* Document to generate XML text from */
20052: int n_out_doc;
20053: xmlChar ** doc_txt_ptr; /* Memory pointer for allocated XML text */
20054: int n_doc_txt_ptr;
20055: int * doc_txt_len; /* Length of the generated XML text */
20056: int n_doc_txt_len;
20057: char * txt_encoding; /* Character encoding to use when generating XML text */
20058: int n_txt_encoding;
20059: int format; /* should formatting spaces been added */
20060: int n_format;
20061:
20062: for (n_out_doc = 0;n_out_doc < gen_nb_xmlDocPtr;n_out_doc++) {
20063: for (n_doc_txt_ptr = 0;n_doc_txt_ptr < gen_nb_xmlChar_ptr_ptr;n_doc_txt_ptr++) {
20064: for (n_doc_txt_len = 0;n_doc_txt_len < gen_nb_int_ptr;n_doc_txt_len++) {
20065: for (n_txt_encoding = 0;n_txt_encoding < gen_nb_const_char_ptr;n_txt_encoding++) {
20066: for (n_format = 0;n_format < gen_nb_int;n_format++) {
20067: mem_base = xmlMemBlocks();
20068: out_doc = gen_xmlDocPtr(n_out_doc, 0);
20069: doc_txt_ptr = gen_xmlChar_ptr_ptr(n_doc_txt_ptr, 1);
20070: doc_txt_len = gen_int_ptr(n_doc_txt_len, 2);
20071: txt_encoding = gen_const_char_ptr(n_txt_encoding, 3);
20072: format = gen_int(n_format, 4);
20073:
20074: xmlDocDumpFormatMemoryEnc(out_doc, doc_txt_ptr, doc_txt_len, (const char *)txt_encoding, format);
20075: call_tests++;
20076: des_xmlDocPtr(n_out_doc, out_doc, 0);
20077: des_xmlChar_ptr_ptr(n_doc_txt_ptr, doc_txt_ptr, 1);
20078: des_int_ptr(n_doc_txt_len, doc_txt_len, 2);
20079: des_const_char_ptr(n_txt_encoding, (const char *)txt_encoding, 3);
20080: des_int(n_format, format, 4);
20081: xmlResetLastError();
20082: if (mem_base != xmlMemBlocks()) {
20083: printf("Leak of %d blocks found in xmlDocDumpFormatMemoryEnc",
20084: xmlMemBlocks() - mem_base);
20085: test_ret++;
20086: printf(" %d", n_out_doc);
20087: printf(" %d", n_doc_txt_ptr);
20088: printf(" %d", n_doc_txt_len);
20089: printf(" %d", n_txt_encoding);
20090: printf(" %d", n_format);
20091: printf("\n");
20092: }
20093: }
20094: }
20095: }
20096: }
20097: }
20098: function_tests++;
20099: #endif
20100:
20101: return(test_ret);
20102: }
20103:
20104:
20105: static int
20106: test_xmlDocDumpMemory(void) {
20107: int test_ret = 0;
20108:
20109: #if defined(LIBXML_OUTPUT_ENABLED)
20110: int mem_base;
20111: xmlDocPtr cur; /* the document */
20112: int n_cur;
20113: xmlChar ** mem; /* OUT: the memory pointer */
20114: int n_mem;
20115: int * size; /* OUT: the memory length */
20116: int n_size;
20117:
20118: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
20119: for (n_mem = 0;n_mem < gen_nb_xmlChar_ptr_ptr;n_mem++) {
20120: for (n_size = 0;n_size < gen_nb_int_ptr;n_size++) {
20121: mem_base = xmlMemBlocks();
20122: cur = gen_xmlDocPtr(n_cur, 0);
20123: mem = gen_xmlChar_ptr_ptr(n_mem, 1);
20124: size = gen_int_ptr(n_size, 2);
20125:
20126: xmlDocDumpMemory(cur, mem, size);
20127: call_tests++;
20128: des_xmlDocPtr(n_cur, cur, 0);
20129: des_xmlChar_ptr_ptr(n_mem, mem, 1);
20130: des_int_ptr(n_size, size, 2);
20131: xmlResetLastError();
20132: if (mem_base != xmlMemBlocks()) {
20133: printf("Leak of %d blocks found in xmlDocDumpMemory",
20134: xmlMemBlocks() - mem_base);
20135: test_ret++;
20136: printf(" %d", n_cur);
20137: printf(" %d", n_mem);
20138: printf(" %d", n_size);
20139: printf("\n");
20140: }
20141: }
20142: }
20143: }
20144: function_tests++;
20145: #endif
20146:
20147: return(test_ret);
20148: }
20149:
20150:
20151: static int
20152: test_xmlDocDumpMemoryEnc(void) {
20153: int test_ret = 0;
20154:
20155: #if defined(LIBXML_OUTPUT_ENABLED)
20156: int mem_base;
20157: xmlDocPtr out_doc; /* Document to generate XML text from */
20158: int n_out_doc;
20159: xmlChar ** doc_txt_ptr; /* Memory pointer for allocated XML text */
20160: int n_doc_txt_ptr;
20161: int * doc_txt_len; /* Length of the generated XML text */
20162: int n_doc_txt_len;
20163: char * txt_encoding; /* Character encoding to use when generating XML text */
20164: int n_txt_encoding;
20165:
20166: for (n_out_doc = 0;n_out_doc < gen_nb_xmlDocPtr;n_out_doc++) {
20167: for (n_doc_txt_ptr = 0;n_doc_txt_ptr < gen_nb_xmlChar_ptr_ptr;n_doc_txt_ptr++) {
20168: for (n_doc_txt_len = 0;n_doc_txt_len < gen_nb_int_ptr;n_doc_txt_len++) {
20169: for (n_txt_encoding = 0;n_txt_encoding < gen_nb_const_char_ptr;n_txt_encoding++) {
20170: mem_base = xmlMemBlocks();
20171: out_doc = gen_xmlDocPtr(n_out_doc, 0);
20172: doc_txt_ptr = gen_xmlChar_ptr_ptr(n_doc_txt_ptr, 1);
20173: doc_txt_len = gen_int_ptr(n_doc_txt_len, 2);
20174: txt_encoding = gen_const_char_ptr(n_txt_encoding, 3);
20175:
20176: xmlDocDumpMemoryEnc(out_doc, doc_txt_ptr, doc_txt_len, (const char *)txt_encoding);
20177: call_tests++;
20178: des_xmlDocPtr(n_out_doc, out_doc, 0);
20179: des_xmlChar_ptr_ptr(n_doc_txt_ptr, doc_txt_ptr, 1);
20180: des_int_ptr(n_doc_txt_len, doc_txt_len, 2);
20181: des_const_char_ptr(n_txt_encoding, (const char *)txt_encoding, 3);
20182: xmlResetLastError();
20183: if (mem_base != xmlMemBlocks()) {
20184: printf("Leak of %d blocks found in xmlDocDumpMemoryEnc",
20185: xmlMemBlocks() - mem_base);
20186: test_ret++;
20187: printf(" %d", n_out_doc);
20188: printf(" %d", n_doc_txt_ptr);
20189: printf(" %d", n_doc_txt_len);
20190: printf(" %d", n_txt_encoding);
20191: printf("\n");
20192: }
20193: }
20194: }
20195: }
20196: }
20197: function_tests++;
20198: #endif
20199:
20200: return(test_ret);
20201: }
20202:
20203:
20204: static int
20205: test_xmlDocFormatDump(void) {
20206: int test_ret = 0;
20207:
20208: #if defined(LIBXML_OUTPUT_ENABLED)
20209: int mem_base;
20210: int ret_val;
20211: FILE * f; /* the FILE* */
20212: int n_f;
20213: xmlDocPtr cur; /* the document */
20214: int n_cur;
20215: int format; /* should formatting spaces been added */
20216: int n_format;
20217:
20218: for (n_f = 0;n_f < gen_nb_FILE_ptr;n_f++) {
20219: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
20220: for (n_format = 0;n_format < gen_nb_int;n_format++) {
20221: mem_base = xmlMemBlocks();
20222: f = gen_FILE_ptr(n_f, 0);
20223: cur = gen_xmlDocPtr(n_cur, 1);
20224: format = gen_int(n_format, 2);
20225:
20226: ret_val = xmlDocFormatDump(f, cur, format);
20227: desret_int(ret_val);
20228: call_tests++;
20229: des_FILE_ptr(n_f, f, 0);
20230: des_xmlDocPtr(n_cur, cur, 1);
20231: des_int(n_format, format, 2);
20232: xmlResetLastError();
20233: if (mem_base != xmlMemBlocks()) {
20234: printf("Leak of %d blocks found in xmlDocFormatDump",
20235: xmlMemBlocks() - mem_base);
20236: test_ret++;
20237: printf(" %d", n_f);
20238: printf(" %d", n_cur);
20239: printf(" %d", n_format);
20240: printf("\n");
20241: }
20242: }
20243: }
20244: }
20245: function_tests++;
20246: #endif
20247:
20248: return(test_ret);
20249: }
20250:
20251:
20252: static int
20253: test_xmlDocGetRootElement(void) {
20254: int test_ret = 0;
20255:
20256: int mem_base;
20257: xmlNodePtr ret_val;
20258: xmlDocPtr doc; /* the document */
20259: int n_doc;
20260:
20261: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
20262: mem_base = xmlMemBlocks();
20263: doc = gen_xmlDocPtr(n_doc, 0);
20264:
20265: ret_val = xmlDocGetRootElement(doc);
20266: desret_xmlNodePtr(ret_val);
20267: call_tests++;
20268: des_xmlDocPtr(n_doc, doc, 0);
20269: xmlResetLastError();
20270: if (mem_base != xmlMemBlocks()) {
20271: printf("Leak of %d blocks found in xmlDocGetRootElement",
20272: xmlMemBlocks() - mem_base);
20273: test_ret++;
20274: printf(" %d", n_doc);
20275: printf("\n");
20276: }
20277: }
20278: function_tests++;
20279:
20280: return(test_ret);
20281: }
20282:
20283:
20284: static int
20285: test_xmlDocSetRootElement(void) {
20286: int test_ret = 0;
20287:
20288: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
20289: int mem_base;
20290: xmlNodePtr ret_val;
20291: xmlDocPtr doc; /* the document */
20292: int n_doc;
20293: 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. */
20294: int n_root;
20295:
20296: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
20297: for (n_root = 0;n_root < gen_nb_xmlNodePtr_in;n_root++) {
20298: mem_base = xmlMemBlocks();
20299: doc = gen_xmlDocPtr(n_doc, 0);
20300: root = gen_xmlNodePtr_in(n_root, 1);
20301:
20302: ret_val = xmlDocSetRootElement(doc, root);
20303: if (doc == NULL) { xmlFreeNode(root) ; root = NULL ; }
20304: desret_xmlNodePtr(ret_val);
20305: call_tests++;
20306: des_xmlDocPtr(n_doc, doc, 0);
20307: des_xmlNodePtr_in(n_root, root, 1);
20308: xmlResetLastError();
20309: if (mem_base != xmlMemBlocks()) {
20310: printf("Leak of %d blocks found in xmlDocSetRootElement",
20311: xmlMemBlocks() - mem_base);
20312: test_ret++;
20313: printf(" %d", n_doc);
20314: printf(" %d", n_root);
20315: printf("\n");
20316: }
20317: }
20318: }
20319: function_tests++;
20320: #endif
20321:
20322: return(test_ret);
20323: }
20324:
20325:
20326: static int
20327: test_xmlElemDump(void) {
20328: int test_ret = 0;
20329:
20330: #if defined(LIBXML_OUTPUT_ENABLED)
20331: int mem_base;
20332: FILE * f; /* the FILE * for the output */
20333: int n_f;
20334: xmlDocPtr doc; /* the document */
20335: int n_doc;
20336: xmlNodePtr cur; /* the current node */
20337: int n_cur;
20338:
20339: for (n_f = 0;n_f < gen_nb_FILE_ptr;n_f++) {
20340: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
20341: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
20342: mem_base = xmlMemBlocks();
20343: f = gen_FILE_ptr(n_f, 0);
20344: doc = gen_xmlDocPtr(n_doc, 1);
20345: cur = gen_xmlNodePtr(n_cur, 2);
20346:
20347: xmlElemDump(f, doc, cur);
20348: call_tests++;
20349: des_FILE_ptr(n_f, f, 0);
20350: des_xmlDocPtr(n_doc, doc, 1);
20351: des_xmlNodePtr(n_cur, cur, 2);
20352: xmlResetLastError();
20353: if (mem_base != xmlMemBlocks()) {
20354: printf("Leak of %d blocks found in xmlElemDump",
20355: xmlMemBlocks() - mem_base);
20356: test_ret++;
20357: printf(" %d", n_f);
20358: printf(" %d", n_doc);
20359: printf(" %d", n_cur);
20360: printf("\n");
20361: }
20362: }
20363: }
20364: }
20365: function_tests++;
20366: #endif
20367:
20368: return(test_ret);
20369: }
20370:
20371:
20372: static int
20373: test_xmlFirstElementChild(void) {
20374: int test_ret = 0;
20375:
20376: #if defined(LIBXML_TREE_ENABLED)
20377: int mem_base;
20378: xmlNodePtr ret_val;
20379: xmlNodePtr parent; /* the parent node */
20380: int n_parent;
20381:
20382: for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
20383: mem_base = xmlMemBlocks();
20384: parent = gen_xmlNodePtr(n_parent, 0);
20385:
20386: ret_val = xmlFirstElementChild(parent);
20387: desret_xmlNodePtr(ret_val);
20388: call_tests++;
20389: des_xmlNodePtr(n_parent, parent, 0);
20390: xmlResetLastError();
20391: if (mem_base != xmlMemBlocks()) {
20392: printf("Leak of %d blocks found in xmlFirstElementChild",
20393: xmlMemBlocks() - mem_base);
20394: test_ret++;
20395: printf(" %d", n_parent);
20396: printf("\n");
20397: }
20398: }
20399: function_tests++;
20400: #endif
20401:
20402: return(test_ret);
20403: }
20404:
20405:
20406: static int
20407: test_xmlGetBufferAllocationScheme(void) {
20408: int test_ret = 0;
20409:
20410: int mem_base;
20411: xmlBufferAllocationScheme ret_val;
20412:
20413: mem_base = xmlMemBlocks();
20414:
20415: ret_val = xmlGetBufferAllocationScheme();
20416: desret_xmlBufferAllocationScheme(ret_val);
20417: call_tests++;
20418: xmlResetLastError();
20419: if (mem_base != xmlMemBlocks()) {
20420: printf("Leak of %d blocks found in xmlGetBufferAllocationScheme",
20421: xmlMemBlocks() - mem_base);
20422: test_ret++;
20423: printf("\n");
20424: }
20425: function_tests++;
20426:
20427: return(test_ret);
20428: }
20429:
20430:
20431: static int
20432: test_xmlGetCompressMode(void) {
20433: int test_ret = 0;
20434:
20435: int mem_base;
20436: int ret_val;
20437:
20438: mem_base = xmlMemBlocks();
20439:
20440: ret_val = xmlGetCompressMode();
20441: desret_int(ret_val);
20442: call_tests++;
20443: xmlResetLastError();
20444: if (mem_base != xmlMemBlocks()) {
20445: printf("Leak of %d blocks found in xmlGetCompressMode",
20446: xmlMemBlocks() - mem_base);
20447: test_ret++;
20448: printf("\n");
20449: }
20450: function_tests++;
20451:
20452: return(test_ret);
20453: }
20454:
20455:
20456: static int
20457: test_xmlGetDocCompressMode(void) {
20458: int test_ret = 0;
20459:
20460: int mem_base;
20461: int ret_val;
20462: xmlDocPtr doc; /* the document */
20463: int n_doc;
20464:
20465: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
20466: mem_base = xmlMemBlocks();
20467: doc = gen_xmlDocPtr(n_doc, 0);
20468:
20469: ret_val = xmlGetDocCompressMode(doc);
20470: desret_int(ret_val);
20471: call_tests++;
20472: des_xmlDocPtr(n_doc, doc, 0);
20473: xmlResetLastError();
20474: if (mem_base != xmlMemBlocks()) {
20475: printf("Leak of %d blocks found in xmlGetDocCompressMode",
20476: xmlMemBlocks() - mem_base);
20477: test_ret++;
20478: printf(" %d", n_doc);
20479: printf("\n");
20480: }
20481: }
20482: function_tests++;
20483:
20484: return(test_ret);
20485: }
20486:
20487:
20488: static int
20489: test_xmlGetIntSubset(void) {
20490: int test_ret = 0;
20491:
20492: int mem_base;
20493: xmlDtdPtr ret_val;
20494: xmlDocPtr doc; /* the document pointer */
20495: int n_doc;
20496:
20497: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
20498: mem_base = xmlMemBlocks();
20499: doc = gen_xmlDocPtr(n_doc, 0);
20500:
20501: ret_val = xmlGetIntSubset(doc);
20502: desret_xmlDtdPtr(ret_val);
20503: call_tests++;
20504: des_xmlDocPtr(n_doc, doc, 0);
20505: xmlResetLastError();
20506: if (mem_base != xmlMemBlocks()) {
20507: printf("Leak of %d blocks found in xmlGetIntSubset",
20508: xmlMemBlocks() - mem_base);
20509: test_ret++;
20510: printf(" %d", n_doc);
20511: printf("\n");
20512: }
20513: }
20514: function_tests++;
20515:
20516: return(test_ret);
20517: }
20518:
20519:
20520: static int
20521: test_xmlGetLastChild(void) {
20522: int test_ret = 0;
20523:
20524: int mem_base;
20525: xmlNodePtr ret_val;
20526: xmlNodePtr parent; /* the parent node */
20527: int n_parent;
20528:
20529: for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
20530: mem_base = xmlMemBlocks();
20531: parent = gen_xmlNodePtr(n_parent, 0);
20532:
20533: ret_val = xmlGetLastChild(parent);
20534: desret_xmlNodePtr(ret_val);
20535: call_tests++;
20536: des_xmlNodePtr(n_parent, parent, 0);
20537: xmlResetLastError();
20538: if (mem_base != xmlMemBlocks()) {
20539: printf("Leak of %d blocks found in xmlGetLastChild",
20540: xmlMemBlocks() - mem_base);
20541: test_ret++;
20542: printf(" %d", n_parent);
20543: printf("\n");
20544: }
20545: }
20546: function_tests++;
20547:
20548: return(test_ret);
20549: }
20550:
20551:
20552: static int
20553: test_xmlGetLineNo(void) {
20554: int test_ret = 0;
20555:
20556: int mem_base;
20557: long ret_val;
20558: xmlNodePtr node; /* valid node */
20559: int n_node;
20560:
20561: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
20562: mem_base = xmlMemBlocks();
20563: node = gen_xmlNodePtr(n_node, 0);
20564:
20565: ret_val = xmlGetLineNo(node);
20566: desret_long(ret_val);
20567: call_tests++;
20568: des_xmlNodePtr(n_node, node, 0);
20569: xmlResetLastError();
20570: if (mem_base != xmlMemBlocks()) {
20571: printf("Leak of %d blocks found in xmlGetLineNo",
20572: xmlMemBlocks() - mem_base);
20573: test_ret++;
20574: printf(" %d", n_node);
20575: printf("\n");
20576: }
20577: }
20578: function_tests++;
20579:
20580: return(test_ret);
20581: }
20582:
20583:
20584: static int
20585: test_xmlGetNoNsProp(void) {
20586: int test_ret = 0;
20587:
20588: int mem_base;
20589: xmlChar * ret_val;
20590: xmlNodePtr node; /* the node */
20591: int n_node;
20592: xmlChar * name; /* the attribute name */
20593: int n_name;
20594:
20595: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
20596: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
20597: mem_base = xmlMemBlocks();
20598: node = gen_xmlNodePtr(n_node, 0);
20599: name = gen_const_xmlChar_ptr(n_name, 1);
20600:
20601: ret_val = xmlGetNoNsProp(node, (const xmlChar *)name);
20602: desret_xmlChar_ptr(ret_val);
20603: call_tests++;
20604: des_xmlNodePtr(n_node, node, 0);
20605: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
20606: xmlResetLastError();
20607: if (mem_base != xmlMemBlocks()) {
20608: printf("Leak of %d blocks found in xmlGetNoNsProp",
20609: xmlMemBlocks() - mem_base);
20610: test_ret++;
20611: printf(" %d", n_node);
20612: printf(" %d", n_name);
20613: printf("\n");
20614: }
20615: }
20616: }
20617: function_tests++;
20618:
20619: return(test_ret);
20620: }
20621:
20622:
20623: static int
20624: test_xmlGetNodePath(void) {
20625: int test_ret = 0;
20626:
20627: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED)
20628: int mem_base;
20629: xmlChar * ret_val;
20630: xmlNodePtr node; /* a node */
20631: int n_node;
20632:
20633: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
20634: mem_base = xmlMemBlocks();
20635: node = gen_xmlNodePtr(n_node, 0);
20636:
20637: ret_val = xmlGetNodePath(node);
20638: desret_xmlChar_ptr(ret_val);
20639: call_tests++;
20640: des_xmlNodePtr(n_node, node, 0);
20641: xmlResetLastError();
20642: if (mem_base != xmlMemBlocks()) {
20643: printf("Leak of %d blocks found in xmlGetNodePath",
20644: xmlMemBlocks() - mem_base);
20645: test_ret++;
20646: printf(" %d", n_node);
20647: printf("\n");
20648: }
20649: }
20650: function_tests++;
20651: #endif
20652:
20653: return(test_ret);
20654: }
20655:
20656:
20657: static int
20658: test_xmlGetNsList(void) {
20659: int test_ret = 0;
20660:
20661:
20662: /* missing type support */
20663: return(test_ret);
20664: }
20665:
20666:
20667: static int
20668: test_xmlGetNsProp(void) {
20669: int test_ret = 0;
20670:
20671: int mem_base;
20672: xmlChar * ret_val;
20673: xmlNodePtr node; /* the node */
20674: int n_node;
20675: xmlChar * name; /* the attribute name */
20676: int n_name;
20677: xmlChar * nameSpace; /* the URI of the namespace */
20678: int n_nameSpace;
20679:
20680: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
20681: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
20682: for (n_nameSpace = 0;n_nameSpace < gen_nb_const_xmlChar_ptr;n_nameSpace++) {
20683: mem_base = xmlMemBlocks();
20684: node = gen_xmlNodePtr(n_node, 0);
20685: name = gen_const_xmlChar_ptr(n_name, 1);
20686: nameSpace = gen_const_xmlChar_ptr(n_nameSpace, 2);
20687:
20688: ret_val = xmlGetNsProp(node, (const xmlChar *)name, (const xmlChar *)nameSpace);
20689: desret_xmlChar_ptr(ret_val);
20690: call_tests++;
20691: des_xmlNodePtr(n_node, node, 0);
20692: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
20693: des_const_xmlChar_ptr(n_nameSpace, (const xmlChar *)nameSpace, 2);
20694: xmlResetLastError();
20695: if (mem_base != xmlMemBlocks()) {
20696: printf("Leak of %d blocks found in xmlGetNsProp",
20697: xmlMemBlocks() - mem_base);
20698: test_ret++;
20699: printf(" %d", n_node);
20700: printf(" %d", n_name);
20701: printf(" %d", n_nameSpace);
20702: printf("\n");
20703: }
20704: }
20705: }
20706: }
20707: function_tests++;
20708:
20709: return(test_ret);
20710: }
20711:
20712:
20713: static int
20714: test_xmlGetProp(void) {
20715: int test_ret = 0;
20716:
20717: int mem_base;
20718: xmlChar * ret_val;
20719: xmlNodePtr node; /* the node */
20720: int n_node;
20721: xmlChar * name; /* the attribute name */
20722: int n_name;
20723:
20724: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
20725: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
20726: mem_base = xmlMemBlocks();
20727: node = gen_xmlNodePtr(n_node, 0);
20728: name = gen_const_xmlChar_ptr(n_name, 1);
20729:
20730: ret_val = xmlGetProp(node, (const xmlChar *)name);
20731: desret_xmlChar_ptr(ret_val);
20732: call_tests++;
20733: des_xmlNodePtr(n_node, node, 0);
20734: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
20735: xmlResetLastError();
20736: if (mem_base != xmlMemBlocks()) {
20737: printf("Leak of %d blocks found in xmlGetProp",
20738: xmlMemBlocks() - mem_base);
20739: test_ret++;
20740: printf(" %d", n_node);
20741: printf(" %d", n_name);
20742: printf("\n");
20743: }
20744: }
20745: }
20746: function_tests++;
20747:
20748: return(test_ret);
20749: }
20750:
20751:
20752: static int
20753: test_xmlHasNsProp(void) {
20754: int test_ret = 0;
20755:
20756: int mem_base;
20757: xmlAttrPtr ret_val;
20758: xmlNodePtr node; /* the node */
20759: int n_node;
20760: xmlChar * name; /* the attribute name */
20761: int n_name;
20762: xmlChar * nameSpace; /* the URI of the namespace */
20763: int n_nameSpace;
20764:
20765: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
20766: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
20767: for (n_nameSpace = 0;n_nameSpace < gen_nb_const_xmlChar_ptr;n_nameSpace++) {
20768: mem_base = xmlMemBlocks();
20769: node = gen_xmlNodePtr(n_node, 0);
20770: name = gen_const_xmlChar_ptr(n_name, 1);
20771: nameSpace = gen_const_xmlChar_ptr(n_nameSpace, 2);
20772:
20773: ret_val = xmlHasNsProp(node, (const xmlChar *)name, (const xmlChar *)nameSpace);
20774: desret_xmlAttrPtr(ret_val);
20775: call_tests++;
20776: des_xmlNodePtr(n_node, node, 0);
20777: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
20778: des_const_xmlChar_ptr(n_nameSpace, (const xmlChar *)nameSpace, 2);
20779: xmlResetLastError();
20780: if (mem_base != xmlMemBlocks()) {
20781: printf("Leak of %d blocks found in xmlHasNsProp",
20782: xmlMemBlocks() - mem_base);
20783: test_ret++;
20784: printf(" %d", n_node);
20785: printf(" %d", n_name);
20786: printf(" %d", n_nameSpace);
20787: printf("\n");
20788: }
20789: }
20790: }
20791: }
20792: function_tests++;
20793:
20794: return(test_ret);
20795: }
20796:
20797:
20798: static int
20799: test_xmlHasProp(void) {
20800: int test_ret = 0;
20801:
20802: int mem_base;
20803: xmlAttrPtr ret_val;
20804: xmlNodePtr node; /* the node */
20805: int n_node;
20806: xmlChar * name; /* the attribute name */
20807: int n_name;
20808:
20809: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
20810: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
20811: mem_base = xmlMemBlocks();
20812: node = gen_xmlNodePtr(n_node, 0);
20813: name = gen_const_xmlChar_ptr(n_name, 1);
20814:
20815: ret_val = xmlHasProp(node, (const xmlChar *)name);
20816: desret_xmlAttrPtr(ret_val);
20817: call_tests++;
20818: des_xmlNodePtr(n_node, node, 0);
20819: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
20820: xmlResetLastError();
20821: if (mem_base != xmlMemBlocks()) {
20822: printf("Leak of %d blocks found in xmlHasProp",
20823: xmlMemBlocks() - mem_base);
20824: test_ret++;
20825: printf(" %d", n_node);
20826: printf(" %d", n_name);
20827: printf("\n");
20828: }
20829: }
20830: }
20831: function_tests++;
20832:
20833: return(test_ret);
20834: }
20835:
20836:
20837: static int
20838: test_xmlIsBlankNode(void) {
20839: int test_ret = 0;
20840:
20841: int mem_base;
20842: int ret_val;
20843: xmlNodePtr node; /* the node */
20844: int n_node;
20845:
20846: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
20847: mem_base = xmlMemBlocks();
20848: node = gen_xmlNodePtr(n_node, 0);
20849:
20850: ret_val = xmlIsBlankNode(node);
20851: desret_int(ret_val);
20852: call_tests++;
20853: des_xmlNodePtr(n_node, node, 0);
20854: xmlResetLastError();
20855: if (mem_base != xmlMemBlocks()) {
20856: printf("Leak of %d blocks found in xmlIsBlankNode",
20857: xmlMemBlocks() - mem_base);
20858: test_ret++;
20859: printf(" %d", n_node);
20860: printf("\n");
20861: }
20862: }
20863: function_tests++;
20864:
20865: return(test_ret);
20866: }
20867:
20868:
20869: static int
20870: test_xmlIsXHTML(void) {
20871: int test_ret = 0;
20872:
20873: int mem_base;
20874: int ret_val;
20875: xmlChar * systemID; /* the system identifier */
20876: int n_systemID;
20877: xmlChar * publicID; /* the public identifier */
20878: int n_publicID;
20879:
20880: for (n_systemID = 0;n_systemID < gen_nb_const_xmlChar_ptr;n_systemID++) {
20881: for (n_publicID = 0;n_publicID < gen_nb_const_xmlChar_ptr;n_publicID++) {
20882: mem_base = xmlMemBlocks();
20883: systemID = gen_const_xmlChar_ptr(n_systemID, 0);
20884: publicID = gen_const_xmlChar_ptr(n_publicID, 1);
20885:
20886: ret_val = xmlIsXHTML((const xmlChar *)systemID, (const xmlChar *)publicID);
20887: desret_int(ret_val);
20888: call_tests++;
20889: des_const_xmlChar_ptr(n_systemID, (const xmlChar *)systemID, 0);
20890: des_const_xmlChar_ptr(n_publicID, (const xmlChar *)publicID, 1);
20891: xmlResetLastError();
20892: if (mem_base != xmlMemBlocks()) {
20893: printf("Leak of %d blocks found in xmlIsXHTML",
20894: xmlMemBlocks() - mem_base);
20895: test_ret++;
20896: printf(" %d", n_systemID);
20897: printf(" %d", n_publicID);
20898: printf("\n");
20899: }
20900: }
20901: }
20902: function_tests++;
20903:
20904: return(test_ret);
20905: }
20906:
20907:
20908: static int
20909: test_xmlLastElementChild(void) {
20910: int test_ret = 0;
20911:
20912: #if defined(LIBXML_TREE_ENABLED)
20913: int mem_base;
20914: xmlNodePtr ret_val;
20915: xmlNodePtr parent; /* the parent node */
20916: int n_parent;
20917:
20918: for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
20919: mem_base = xmlMemBlocks();
20920: parent = gen_xmlNodePtr(n_parent, 0);
20921:
20922: ret_val = xmlLastElementChild(parent);
20923: desret_xmlNodePtr(ret_val);
20924: call_tests++;
20925: des_xmlNodePtr(n_parent, parent, 0);
20926: xmlResetLastError();
20927: if (mem_base != xmlMemBlocks()) {
20928: printf("Leak of %d blocks found in xmlLastElementChild",
20929: xmlMemBlocks() - mem_base);
20930: test_ret++;
20931: printf(" %d", n_parent);
20932: printf("\n");
20933: }
20934: }
20935: function_tests++;
20936: #endif
20937:
20938: return(test_ret);
20939: }
20940:
20941:
20942: static int
20943: test_xmlNewCDataBlock(void) {
20944: int test_ret = 0;
20945:
20946: int mem_base;
20947: xmlNodePtr ret_val;
20948: xmlDocPtr doc; /* the document */
20949: int n_doc;
20950: xmlChar * content; /* the CDATA block content content */
20951: int n_content;
20952: int len; /* the length of the block */
20953: int n_len;
20954:
20955: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
20956: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
20957: for (n_len = 0;n_len < gen_nb_int;n_len++) {
20958: mem_base = xmlMemBlocks();
20959: doc = gen_xmlDocPtr(n_doc, 0);
20960: content = gen_const_xmlChar_ptr(n_content, 1);
20961: len = gen_int(n_len, 2);
20962:
20963: ret_val = xmlNewCDataBlock(doc, (const xmlChar *)content, len);
20964: desret_xmlNodePtr(ret_val);
20965: call_tests++;
20966: des_xmlDocPtr(n_doc, doc, 0);
20967: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
20968: des_int(n_len, len, 2);
20969: xmlResetLastError();
20970: if (mem_base != xmlMemBlocks()) {
20971: printf("Leak of %d blocks found in xmlNewCDataBlock",
20972: xmlMemBlocks() - mem_base);
20973: test_ret++;
20974: printf(" %d", n_doc);
20975: printf(" %d", n_content);
20976: printf(" %d", n_len);
20977: printf("\n");
20978: }
20979: }
20980: }
20981: }
20982: function_tests++;
20983:
20984: return(test_ret);
20985: }
20986:
20987:
20988: static int
20989: test_xmlNewCharRef(void) {
20990: int test_ret = 0;
20991:
20992: int mem_base;
20993: xmlNodePtr ret_val;
20994: xmlDocPtr doc; /* the document */
20995: int n_doc;
20996: xmlChar * name; /* the char ref string, starting with # or "&# ... ;" */
20997: int n_name;
20998:
20999: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21000: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21001: mem_base = xmlMemBlocks();
21002: doc = gen_xmlDocPtr(n_doc, 0);
21003: name = gen_const_xmlChar_ptr(n_name, 1);
21004:
21005: ret_val = xmlNewCharRef(doc, (const xmlChar *)name);
21006: desret_xmlNodePtr(ret_val);
21007: call_tests++;
21008: des_xmlDocPtr(n_doc, doc, 0);
21009: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
21010: xmlResetLastError();
21011: if (mem_base != xmlMemBlocks()) {
21012: printf("Leak of %d blocks found in xmlNewCharRef",
21013: xmlMemBlocks() - mem_base);
21014: test_ret++;
21015: printf(" %d", n_doc);
21016: printf(" %d", n_name);
21017: printf("\n");
21018: }
21019: }
21020: }
21021: function_tests++;
21022:
21023: return(test_ret);
21024: }
21025:
21026:
21027: static int
21028: test_xmlNewChild(void) {
21029: int test_ret = 0;
21030:
21031: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
21032: #ifdef LIBXML_TREE_ENABLED
21033: int mem_base;
21034: xmlNodePtr ret_val;
21035: xmlNodePtr parent; /* the parent node */
21036: int n_parent;
21037: xmlNsPtr ns; /* a namespace if any */
21038: int n_ns;
21039: xmlChar * name; /* the name of the child */
21040: int n_name;
21041: xmlChar * content; /* the XML content of the child if any. */
21042: int n_content;
21043:
21044: for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
21045: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
21046: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21047: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21048: mem_base = xmlMemBlocks();
21049: parent = gen_xmlNodePtr(n_parent, 0);
21050: ns = gen_xmlNsPtr(n_ns, 1);
21051: name = gen_const_xmlChar_ptr(n_name, 2);
21052: content = gen_const_xmlChar_ptr(n_content, 3);
21053:
21054: ret_val = xmlNewChild(parent, ns, (const xmlChar *)name, (const xmlChar *)content);
21055: desret_xmlNodePtr(ret_val);
21056: call_tests++;
21057: des_xmlNodePtr(n_parent, parent, 0);
21058: des_xmlNsPtr(n_ns, ns, 1);
21059: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
21060: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3);
21061: xmlResetLastError();
21062: if (mem_base != xmlMemBlocks()) {
21063: printf("Leak of %d blocks found in xmlNewChild",
21064: xmlMemBlocks() - mem_base);
21065: test_ret++;
21066: printf(" %d", n_parent);
21067: printf(" %d", n_ns);
21068: printf(" %d", n_name);
21069: printf(" %d", n_content);
21070: printf("\n");
21071: }
21072: }
21073: }
21074: }
21075: }
21076: function_tests++;
21077: #endif
21078: #endif
21079:
21080: return(test_ret);
21081: }
21082:
21083:
21084: static int
21085: test_xmlNewComment(void) {
21086: int test_ret = 0;
21087:
21088: int mem_base;
21089: xmlNodePtr ret_val;
21090: xmlChar * content; /* the comment content */
21091: int n_content;
21092:
21093: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21094: mem_base = xmlMemBlocks();
21095: content = gen_const_xmlChar_ptr(n_content, 0);
21096:
21097: ret_val = xmlNewComment((const xmlChar *)content);
21098: desret_xmlNodePtr(ret_val);
21099: call_tests++;
21100: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 0);
21101: xmlResetLastError();
21102: if (mem_base != xmlMemBlocks()) {
21103: printf("Leak of %d blocks found in xmlNewComment",
21104: xmlMemBlocks() - mem_base);
21105: test_ret++;
21106: printf(" %d", n_content);
21107: printf("\n");
21108: }
21109: }
21110: function_tests++;
21111:
21112: return(test_ret);
21113: }
21114:
21115:
21116: static int
21117: test_xmlNewDoc(void) {
21118: int test_ret = 0;
21119:
21120: int mem_base;
21121: xmlDocPtr ret_val;
21122: xmlChar * version; /* xmlChar string giving the version of XML "1.0" */
21123: int n_version;
21124:
21125: for (n_version = 0;n_version < gen_nb_const_xmlChar_ptr;n_version++) {
21126: mem_base = xmlMemBlocks();
21127: version = gen_const_xmlChar_ptr(n_version, 0);
21128:
21129: ret_val = xmlNewDoc((const xmlChar *)version);
21130: desret_xmlDocPtr(ret_val);
21131: call_tests++;
21132: des_const_xmlChar_ptr(n_version, (const xmlChar *)version, 0);
21133: xmlResetLastError();
21134: if (mem_base != xmlMemBlocks()) {
21135: printf("Leak of %d blocks found in xmlNewDoc",
21136: xmlMemBlocks() - mem_base);
21137: test_ret++;
21138: printf(" %d", n_version);
21139: printf("\n");
21140: }
21141: }
21142: function_tests++;
21143:
21144: return(test_ret);
21145: }
21146:
21147:
21148: static int
21149: test_xmlNewDocComment(void) {
21150: int test_ret = 0;
21151:
21152: int mem_base;
21153: xmlNodePtr ret_val;
21154: xmlDocPtr doc; /* the document */
21155: int n_doc;
21156: xmlChar * content; /* the comment content */
21157: int n_content;
21158:
21159: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21160: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21161: mem_base = xmlMemBlocks();
21162: doc = gen_xmlDocPtr(n_doc, 0);
21163: content = gen_const_xmlChar_ptr(n_content, 1);
21164:
21165: ret_val = xmlNewDocComment(doc, (const xmlChar *)content);
21166: desret_xmlNodePtr(ret_val);
21167: call_tests++;
21168: des_xmlDocPtr(n_doc, doc, 0);
21169: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
21170: xmlResetLastError();
21171: if (mem_base != xmlMemBlocks()) {
21172: printf("Leak of %d blocks found in xmlNewDocComment",
21173: xmlMemBlocks() - mem_base);
21174: test_ret++;
21175: printf(" %d", n_doc);
21176: printf(" %d", n_content);
21177: printf("\n");
21178: }
21179: }
21180: }
21181: function_tests++;
21182:
21183: return(test_ret);
21184: }
21185:
21186:
21187: static int
21188: test_xmlNewDocFragment(void) {
21189: int test_ret = 0;
21190:
21191: #if defined(LIBXML_TREE_ENABLED)
21192: int mem_base;
21193: xmlNodePtr ret_val;
21194: xmlDocPtr doc; /* the document owning the fragment */
21195: int n_doc;
21196:
21197: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21198: mem_base = xmlMemBlocks();
21199: doc = gen_xmlDocPtr(n_doc, 0);
21200:
21201: ret_val = xmlNewDocFragment(doc);
21202: desret_xmlNodePtr(ret_val);
21203: call_tests++;
21204: des_xmlDocPtr(n_doc, doc, 0);
21205: xmlResetLastError();
21206: if (mem_base != xmlMemBlocks()) {
21207: printf("Leak of %d blocks found in xmlNewDocFragment",
21208: xmlMemBlocks() - mem_base);
21209: test_ret++;
21210: printf(" %d", n_doc);
21211: printf("\n");
21212: }
21213: }
21214: function_tests++;
21215: #endif
21216:
21217: return(test_ret);
21218: }
21219:
21220:
21221: static int
21222: test_xmlNewDocNode(void) {
21223: int test_ret = 0;
21224:
21225: int mem_base;
21226: xmlNodePtr ret_val;
21227: xmlDocPtr doc; /* the document */
21228: int n_doc;
21229: xmlNsPtr ns; /* namespace if any */
21230: int n_ns;
21231: xmlChar * name; /* the node name */
21232: int n_name;
21233: xmlChar * content; /* the XML text content if any */
21234: int n_content;
21235:
21236: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21237: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
21238: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21239: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21240: mem_base = xmlMemBlocks();
21241: doc = gen_xmlDocPtr(n_doc, 0);
21242: ns = gen_xmlNsPtr(n_ns, 1);
21243: name = gen_const_xmlChar_ptr(n_name, 2);
21244: content = gen_const_xmlChar_ptr(n_content, 3);
21245:
21246: ret_val = xmlNewDocNode(doc, ns, (const xmlChar *)name, (const xmlChar *)content);
21247: desret_xmlNodePtr(ret_val);
21248: call_tests++;
21249: des_xmlDocPtr(n_doc, doc, 0);
21250: des_xmlNsPtr(n_ns, ns, 1);
21251: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
21252: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3);
21253: xmlResetLastError();
21254: if (mem_base != xmlMemBlocks()) {
21255: printf("Leak of %d blocks found in xmlNewDocNode",
21256: xmlMemBlocks() - mem_base);
21257: test_ret++;
21258: printf(" %d", n_doc);
21259: printf(" %d", n_ns);
21260: printf(" %d", n_name);
21261: printf(" %d", n_content);
21262: printf("\n");
21263: }
21264: }
21265: }
21266: }
21267: }
21268: function_tests++;
21269:
21270: return(test_ret);
21271: }
21272:
21273:
21274: static int
21275: test_xmlNewDocNodeEatName(void) {
21276: int test_ret = 0;
21277:
21278: int mem_base;
21279: xmlNodePtr ret_val;
21280: xmlDocPtr doc; /* the document */
21281: int n_doc;
21282: xmlNsPtr ns; /* namespace if any */
21283: int n_ns;
21284: xmlChar * name; /* the node name */
21285: int n_name;
21286: xmlChar * content; /* the XML text content if any */
21287: int n_content;
21288:
21289: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21290: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
21291: for (n_name = 0;n_name < gen_nb_eaten_name;n_name++) {
21292: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21293: mem_base = xmlMemBlocks();
21294: doc = gen_xmlDocPtr(n_doc, 0);
21295: ns = gen_xmlNsPtr(n_ns, 1);
21296: name = gen_eaten_name(n_name, 2);
21297: content = gen_const_xmlChar_ptr(n_content, 3);
21298:
21299: ret_val = xmlNewDocNodeEatName(doc, ns, name, (const xmlChar *)content);
21300: desret_xmlNodePtr(ret_val);
21301: call_tests++;
21302: des_xmlDocPtr(n_doc, doc, 0);
21303: des_xmlNsPtr(n_ns, ns, 1);
21304: des_eaten_name(n_name, name, 2);
21305: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3);
21306: xmlResetLastError();
21307: if (mem_base != xmlMemBlocks()) {
21308: printf("Leak of %d blocks found in xmlNewDocNodeEatName",
21309: xmlMemBlocks() - mem_base);
21310: test_ret++;
21311: printf(" %d", n_doc);
21312: printf(" %d", n_ns);
21313: printf(" %d", n_name);
21314: printf(" %d", n_content);
21315: printf("\n");
21316: }
21317: }
21318: }
21319: }
21320: }
21321: function_tests++;
21322:
21323: return(test_ret);
21324: }
21325:
21326:
21327: static int
21328: test_xmlNewDocPI(void) {
21329: int test_ret = 0;
21330:
21331: int mem_base;
21332: xmlNodePtr ret_val;
21333: xmlDocPtr doc; /* the target document */
21334: int n_doc;
21335: xmlChar * name; /* the processing instruction name */
21336: int n_name;
21337: xmlChar * content; /* the PI content */
21338: int n_content;
21339:
21340: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21341: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21342: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21343: mem_base = xmlMemBlocks();
21344: doc = gen_xmlDocPtr(n_doc, 0);
21345: name = gen_const_xmlChar_ptr(n_name, 1);
21346: content = gen_const_xmlChar_ptr(n_content, 2);
21347:
21348: ret_val = xmlNewDocPI(doc, (const xmlChar *)name, (const xmlChar *)content);
21349: desret_xmlNodePtr(ret_val);
21350: call_tests++;
21351: des_xmlDocPtr(n_doc, doc, 0);
21352: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
21353: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2);
21354: xmlResetLastError();
21355: if (mem_base != xmlMemBlocks()) {
21356: printf("Leak of %d blocks found in xmlNewDocPI",
21357: xmlMemBlocks() - mem_base);
21358: test_ret++;
21359: printf(" %d", n_doc);
21360: printf(" %d", n_name);
21361: printf(" %d", n_content);
21362: printf("\n");
21363: }
21364: }
21365: }
21366: }
21367: function_tests++;
21368:
21369: return(test_ret);
21370: }
21371:
21372:
21373: static int
21374: test_xmlNewDocProp(void) {
21375: int test_ret = 0;
21376:
21377: int mem_base;
21378: xmlAttrPtr ret_val;
21379: xmlDocPtr doc; /* the document */
21380: int n_doc;
21381: xmlChar * name; /* the name of the attribute */
21382: int n_name;
21383: xmlChar * value; /* the value of the attribute */
21384: int n_value;
21385:
21386: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21387: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21388: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
21389: mem_base = xmlMemBlocks();
21390: doc = gen_xmlDocPtr(n_doc, 0);
21391: name = gen_const_xmlChar_ptr(n_name, 1);
21392: value = gen_const_xmlChar_ptr(n_value, 2);
21393:
21394: ret_val = xmlNewDocProp(doc, (const xmlChar *)name, (const xmlChar *)value);
21395: desret_xmlAttrPtr(ret_val);
21396: call_tests++;
21397: des_xmlDocPtr(n_doc, doc, 0);
21398: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
21399: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2);
21400: xmlResetLastError();
21401: if (mem_base != xmlMemBlocks()) {
21402: printf("Leak of %d blocks found in xmlNewDocProp",
21403: xmlMemBlocks() - mem_base);
21404: test_ret++;
21405: printf(" %d", n_doc);
21406: printf(" %d", n_name);
21407: printf(" %d", n_value);
21408: printf("\n");
21409: }
21410: }
21411: }
21412: }
21413: function_tests++;
21414:
21415: return(test_ret);
21416: }
21417:
21418:
21419: static int
21420: test_xmlNewDocRawNode(void) {
21421: int test_ret = 0;
21422:
21423: #if defined(LIBXML_TREE_ENABLED)
21424: #ifdef LIBXML_TREE_ENABLED
21425: int mem_base;
21426: xmlNodePtr ret_val;
21427: xmlDocPtr doc; /* the document */
21428: int n_doc;
21429: xmlNsPtr ns; /* namespace if any */
21430: int n_ns;
21431: xmlChar * name; /* the node name */
21432: int n_name;
21433: xmlChar * content; /* the text content if any */
21434: int n_content;
21435:
21436: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21437: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
21438: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21439: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21440: mem_base = xmlMemBlocks();
21441: doc = gen_xmlDocPtr(n_doc, 0);
21442: ns = gen_xmlNsPtr(n_ns, 1);
21443: name = gen_const_xmlChar_ptr(n_name, 2);
21444: content = gen_const_xmlChar_ptr(n_content, 3);
21445:
21446: ret_val = xmlNewDocRawNode(doc, ns, (const xmlChar *)name, (const xmlChar *)content);
21447: desret_xmlNodePtr(ret_val);
21448: call_tests++;
21449: des_xmlDocPtr(n_doc, doc, 0);
21450: des_xmlNsPtr(n_ns, ns, 1);
21451: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
21452: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3);
21453: xmlResetLastError();
21454: if (mem_base != xmlMemBlocks()) {
21455: printf("Leak of %d blocks found in xmlNewDocRawNode",
21456: xmlMemBlocks() - mem_base);
21457: test_ret++;
21458: printf(" %d", n_doc);
21459: printf(" %d", n_ns);
21460: printf(" %d", n_name);
21461: printf(" %d", n_content);
21462: printf("\n");
21463: }
21464: }
21465: }
21466: }
21467: }
21468: function_tests++;
21469: #endif
21470: #endif
21471:
21472: return(test_ret);
21473: }
21474:
21475:
21476: static int
21477: test_xmlNewDocText(void) {
21478: int test_ret = 0;
21479:
21480: int mem_base;
21481: xmlNodePtr ret_val;
21482: xmlDocPtr doc; /* the document */
21483: int n_doc;
21484: xmlChar * content; /* the text content */
21485: int n_content;
21486:
21487: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21488: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21489: mem_base = xmlMemBlocks();
21490: doc = gen_xmlDocPtr(n_doc, 0);
21491: content = gen_const_xmlChar_ptr(n_content, 1);
21492:
21493: ret_val = xmlNewDocText(doc, (const xmlChar *)content);
21494: desret_xmlNodePtr(ret_val);
21495: call_tests++;
21496: des_xmlDocPtr(n_doc, doc, 0);
21497: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
21498: xmlResetLastError();
21499: if (mem_base != xmlMemBlocks()) {
21500: printf("Leak of %d blocks found in xmlNewDocText",
21501: xmlMemBlocks() - mem_base);
21502: test_ret++;
21503: printf(" %d", n_doc);
21504: printf(" %d", n_content);
21505: printf("\n");
21506: }
21507: }
21508: }
21509: function_tests++;
21510:
21511: return(test_ret);
21512: }
21513:
21514:
21515: static int
21516: test_xmlNewDocTextLen(void) {
21517: int test_ret = 0;
21518:
21519: int mem_base;
21520: xmlNodePtr ret_val;
21521: xmlDocPtr doc; /* the document */
21522: int n_doc;
21523: xmlChar * content; /* the text content */
21524: int n_content;
21525: int len; /* the text len. */
21526: int n_len;
21527:
21528: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21529: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21530: for (n_len = 0;n_len < gen_nb_int;n_len++) {
21531: mem_base = xmlMemBlocks();
21532: doc = gen_xmlDocPtr(n_doc, 0);
21533: content = gen_const_xmlChar_ptr(n_content, 1);
21534: len = gen_int(n_len, 2);
21535:
21536: ret_val = xmlNewDocTextLen(doc, (const xmlChar *)content, len);
21537: desret_xmlNodePtr(ret_val);
21538: call_tests++;
21539: des_xmlDocPtr(n_doc, doc, 0);
21540: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
21541: des_int(n_len, len, 2);
21542: xmlResetLastError();
21543: if (mem_base != xmlMemBlocks()) {
21544: printf("Leak of %d blocks found in xmlNewDocTextLen",
21545: xmlMemBlocks() - mem_base);
21546: test_ret++;
21547: printf(" %d", n_doc);
21548: printf(" %d", n_content);
21549: printf(" %d", n_len);
21550: printf("\n");
21551: }
21552: }
21553: }
21554: }
21555: function_tests++;
21556:
21557: return(test_ret);
21558: }
21559:
21560:
21561: static int
21562: test_xmlNewDtd(void) {
21563: int test_ret = 0;
21564:
21565: int mem_base;
21566: xmlDtdPtr ret_val;
21567: xmlDocPtr doc; /* the document pointer */
21568: int n_doc;
21569: xmlChar * name; /* the DTD name */
21570: int n_name;
21571: xmlChar * ExternalID; /* the external ID */
21572: int n_ExternalID;
21573: xmlChar * SystemID; /* the system ID */
21574: int n_SystemID;
21575:
21576: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21577: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21578: for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
21579: for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
21580: mem_base = xmlMemBlocks();
21581: doc = gen_xmlDocPtr(n_doc, 0);
21582: name = gen_const_xmlChar_ptr(n_name, 1);
21583: ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 2);
21584: SystemID = gen_const_xmlChar_ptr(n_SystemID, 3);
21585:
21586: ret_val = xmlNewDtd(doc, (const xmlChar *)name, (const xmlChar *)ExternalID, (const xmlChar *)SystemID);
21587: desret_xmlDtdPtr(ret_val);
21588: call_tests++;
21589: des_xmlDocPtr(n_doc, doc, 0);
21590: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
21591: des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 2);
21592: des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 3);
21593: xmlResetLastError();
21594: if (mem_base != xmlMemBlocks()) {
21595: printf("Leak of %d blocks found in xmlNewDtd",
21596: xmlMemBlocks() - mem_base);
21597: test_ret++;
21598: printf(" %d", n_doc);
21599: printf(" %d", n_name);
21600: printf(" %d", n_ExternalID);
21601: printf(" %d", n_SystemID);
21602: printf("\n");
21603: }
21604: }
21605: }
21606: }
21607: }
21608: function_tests++;
21609:
21610: return(test_ret);
21611: }
21612:
21613:
21614: static int
21615: test_xmlNewNode(void) {
21616: int test_ret = 0;
21617:
21618: int mem_base;
21619: xmlNodePtr ret_val;
21620: xmlNsPtr ns; /* namespace if any */
21621: int n_ns;
21622: xmlChar * name; /* the node name */
21623: int n_name;
21624:
21625: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
21626: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21627: mem_base = xmlMemBlocks();
21628: ns = gen_xmlNsPtr(n_ns, 0);
21629: name = gen_const_xmlChar_ptr(n_name, 1);
21630:
21631: ret_val = xmlNewNode(ns, (const xmlChar *)name);
21632: desret_xmlNodePtr(ret_val);
21633: call_tests++;
21634: des_xmlNsPtr(n_ns, ns, 0);
21635: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
21636: xmlResetLastError();
21637: if (mem_base != xmlMemBlocks()) {
21638: printf("Leak of %d blocks found in xmlNewNode",
21639: xmlMemBlocks() - mem_base);
21640: test_ret++;
21641: printf(" %d", n_ns);
21642: printf(" %d", n_name);
21643: printf("\n");
21644: }
21645: }
21646: }
21647: function_tests++;
21648:
21649: return(test_ret);
21650: }
21651:
21652:
21653: static int
21654: test_xmlNewNodeEatName(void) {
21655: int test_ret = 0;
21656:
21657: int mem_base;
21658: xmlNodePtr ret_val;
21659: xmlNsPtr ns; /* namespace if any */
21660: int n_ns;
21661: xmlChar * name; /* the node name */
21662: int n_name;
21663:
21664: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
21665: for (n_name = 0;n_name < gen_nb_eaten_name;n_name++) {
21666: mem_base = xmlMemBlocks();
21667: ns = gen_xmlNsPtr(n_ns, 0);
21668: name = gen_eaten_name(n_name, 1);
21669:
21670: ret_val = xmlNewNodeEatName(ns, name);
21671: desret_xmlNodePtr(ret_val);
21672: call_tests++;
21673: des_xmlNsPtr(n_ns, ns, 0);
21674: des_eaten_name(n_name, name, 1);
21675: xmlResetLastError();
21676: if (mem_base != xmlMemBlocks()) {
21677: printf("Leak of %d blocks found in xmlNewNodeEatName",
21678: xmlMemBlocks() - mem_base);
21679: test_ret++;
21680: printf(" %d", n_ns);
21681: printf(" %d", n_name);
21682: printf("\n");
21683: }
21684: }
21685: }
21686: function_tests++;
21687:
21688: return(test_ret);
21689: }
21690:
21691:
21692: static int
21693: test_xmlNewNs(void) {
21694: int test_ret = 0;
21695:
21696: int mem_base;
21697: xmlNsPtr ret_val;
21698: xmlNodePtr node; /* the element carrying the namespace */
21699: int n_node;
21700: xmlChar * href; /* the URI associated */
21701: int n_href;
21702: xmlChar * prefix; /* the prefix for the namespace */
21703: int n_prefix;
21704:
21705: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
21706: for (n_href = 0;n_href < gen_nb_const_xmlChar_ptr;n_href++) {
21707: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
21708: mem_base = xmlMemBlocks();
21709: node = gen_xmlNodePtr(n_node, 0);
21710: href = gen_const_xmlChar_ptr(n_href, 1);
21711: prefix = gen_const_xmlChar_ptr(n_prefix, 2);
21712:
21713: ret_val = xmlNewNs(node, (const xmlChar *)href, (const xmlChar *)prefix);
21714: if ((node == NULL) && (ret_val != NULL)) xmlFreeNs(ret_val);
21715: desret_xmlNsPtr(ret_val);
21716: call_tests++;
21717: des_xmlNodePtr(n_node, node, 0);
21718: des_const_xmlChar_ptr(n_href, (const xmlChar *)href, 1);
21719: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 2);
21720: xmlResetLastError();
21721: if (mem_base != xmlMemBlocks()) {
21722: printf("Leak of %d blocks found in xmlNewNs",
21723: xmlMemBlocks() - mem_base);
21724: test_ret++;
21725: printf(" %d", n_node);
21726: printf(" %d", n_href);
21727: printf(" %d", n_prefix);
21728: printf("\n");
21729: }
21730: }
21731: }
21732: }
21733: function_tests++;
21734:
21735: return(test_ret);
21736: }
21737:
21738:
21739: static int
21740: test_xmlNewNsProp(void) {
21741: int test_ret = 0;
21742:
21743: int mem_base;
21744: xmlAttrPtr ret_val;
21745: xmlNodePtr node; /* the holding node */
21746: int n_node;
21747: xmlNsPtr ns; /* the namespace */
21748: int n_ns;
21749: xmlChar * name; /* the name of the attribute */
21750: int n_name;
21751: xmlChar * value; /* the value of the attribute */
21752: int n_value;
21753:
21754: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
21755: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
21756: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21757: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
21758: mem_base = xmlMemBlocks();
21759: node = gen_xmlNodePtr(n_node, 0);
21760: ns = gen_xmlNsPtr(n_ns, 1);
21761: name = gen_const_xmlChar_ptr(n_name, 2);
21762: value = gen_const_xmlChar_ptr(n_value, 3);
21763:
21764: ret_val = xmlNewNsProp(node, ns, (const xmlChar *)name, (const xmlChar *)value);
21765: desret_xmlAttrPtr(ret_val);
21766: call_tests++;
21767: des_xmlNodePtr(n_node, node, 0);
21768: des_xmlNsPtr(n_ns, ns, 1);
21769: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
21770: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 3);
21771: xmlResetLastError();
21772: if (mem_base != xmlMemBlocks()) {
21773: printf("Leak of %d blocks found in xmlNewNsProp",
21774: xmlMemBlocks() - mem_base);
21775: test_ret++;
21776: printf(" %d", n_node);
21777: printf(" %d", n_ns);
21778: printf(" %d", n_name);
21779: printf(" %d", n_value);
21780: printf("\n");
21781: }
21782: }
21783: }
21784: }
21785: }
21786: function_tests++;
21787:
21788: return(test_ret);
21789: }
21790:
21791:
21792: static int
21793: test_xmlNewNsPropEatName(void) {
21794: int test_ret = 0;
21795:
21796: int mem_base;
21797: xmlAttrPtr ret_val;
21798: xmlNodePtr node; /* the holding node */
21799: int n_node;
21800: xmlNsPtr ns; /* the namespace */
21801: int n_ns;
21802: xmlChar * name; /* the name of the attribute */
21803: int n_name;
21804: xmlChar * value; /* the value of the attribute */
21805: int n_value;
21806:
21807: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
21808: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
21809: for (n_name = 0;n_name < gen_nb_eaten_name;n_name++) {
21810: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
21811: mem_base = xmlMemBlocks();
21812: node = gen_xmlNodePtr(n_node, 0);
21813: ns = gen_xmlNsPtr(n_ns, 1);
21814: name = gen_eaten_name(n_name, 2);
21815: value = gen_const_xmlChar_ptr(n_value, 3);
21816:
21817: ret_val = xmlNewNsPropEatName(node, ns, name, (const xmlChar *)value);
21818: desret_xmlAttrPtr(ret_val);
21819: call_tests++;
21820: des_xmlNodePtr(n_node, node, 0);
21821: des_xmlNsPtr(n_ns, ns, 1);
21822: des_eaten_name(n_name, name, 2);
21823: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 3);
21824: xmlResetLastError();
21825: if (mem_base != xmlMemBlocks()) {
21826: printf("Leak of %d blocks found in xmlNewNsPropEatName",
21827: xmlMemBlocks() - mem_base);
21828: test_ret++;
21829: printf(" %d", n_node);
21830: printf(" %d", n_ns);
21831: printf(" %d", n_name);
21832: printf(" %d", n_value);
21833: printf("\n");
21834: }
21835: }
21836: }
21837: }
21838: }
21839: function_tests++;
21840:
21841: return(test_ret);
21842: }
21843:
21844:
21845: static int
21846: test_xmlNewPI(void) {
21847: int test_ret = 0;
21848:
21849: int mem_base;
21850: xmlNodePtr ret_val;
21851: xmlChar * name; /* the processing instruction name */
21852: int n_name;
21853: xmlChar * content; /* the PI content */
21854: int n_content;
21855:
21856: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21857: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21858: mem_base = xmlMemBlocks();
21859: name = gen_const_xmlChar_ptr(n_name, 0);
21860: content = gen_const_xmlChar_ptr(n_content, 1);
21861:
21862: ret_val = xmlNewPI((const xmlChar *)name, (const xmlChar *)content);
21863: desret_xmlNodePtr(ret_val);
21864: call_tests++;
21865: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
21866: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
21867: xmlResetLastError();
21868: if (mem_base != xmlMemBlocks()) {
21869: printf("Leak of %d blocks found in xmlNewPI",
21870: xmlMemBlocks() - mem_base);
21871: test_ret++;
21872: printf(" %d", n_name);
21873: printf(" %d", n_content);
21874: printf("\n");
21875: }
21876: }
21877: }
21878: function_tests++;
21879:
21880: return(test_ret);
21881: }
21882:
21883:
21884: static int
21885: test_xmlNewProp(void) {
21886: int test_ret = 0;
21887:
21888: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
21889: #ifdef LIBXML_TREE_ENABLED
21890: int mem_base;
21891: xmlAttrPtr ret_val;
21892: xmlNodePtr node; /* the holding node */
21893: int n_node;
21894: xmlChar * name; /* the name of the attribute */
21895: int n_name;
21896: xmlChar * value; /* the value of the attribute */
21897: int n_value;
21898:
21899: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
21900: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21901: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
21902: mem_base = xmlMemBlocks();
21903: node = gen_xmlNodePtr(n_node, 0);
21904: name = gen_const_xmlChar_ptr(n_name, 1);
21905: value = gen_const_xmlChar_ptr(n_value, 2);
21906:
21907: ret_val = xmlNewProp(node, (const xmlChar *)name, (const xmlChar *)value);
21908: desret_xmlAttrPtr(ret_val);
21909: call_tests++;
21910: des_xmlNodePtr(n_node, node, 0);
21911: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
21912: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2);
21913: xmlResetLastError();
21914: if (mem_base != xmlMemBlocks()) {
21915: printf("Leak of %d blocks found in xmlNewProp",
21916: xmlMemBlocks() - mem_base);
21917: test_ret++;
21918: printf(" %d", n_node);
21919: printf(" %d", n_name);
21920: printf(" %d", n_value);
21921: printf("\n");
21922: }
21923: }
21924: }
21925: }
21926: function_tests++;
21927: #endif
21928: #endif
21929:
21930: return(test_ret);
21931: }
21932:
21933:
21934: static int
21935: test_xmlNewReference(void) {
21936: int test_ret = 0;
21937:
21938: int mem_base;
21939: xmlNodePtr ret_val;
21940: xmlDocPtr doc; /* the document */
21941: int n_doc;
21942: xmlChar * name; /* the reference name, or the reference string with & and ; */
21943: int n_name;
21944:
21945: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21946: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21947: mem_base = xmlMemBlocks();
21948: doc = gen_xmlDocPtr(n_doc, 0);
21949: name = gen_const_xmlChar_ptr(n_name, 1);
21950:
21951: ret_val = xmlNewReference(doc, (const xmlChar *)name);
21952: desret_xmlNodePtr(ret_val);
21953: call_tests++;
21954: des_xmlDocPtr(n_doc, doc, 0);
21955: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
21956: xmlResetLastError();
21957: if (mem_base != xmlMemBlocks()) {
21958: printf("Leak of %d blocks found in xmlNewReference",
21959: xmlMemBlocks() - mem_base);
21960: test_ret++;
21961: printf(" %d", n_doc);
21962: printf(" %d", n_name);
21963: printf("\n");
21964: }
21965: }
21966: }
21967: function_tests++;
21968:
21969: return(test_ret);
21970: }
21971:
21972:
21973: static int
21974: test_xmlNewText(void) {
21975: int test_ret = 0;
21976:
21977: int mem_base;
21978: xmlNodePtr ret_val;
21979: xmlChar * content; /* the text content */
21980: int n_content;
21981:
21982: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21983: mem_base = xmlMemBlocks();
21984: content = gen_const_xmlChar_ptr(n_content, 0);
21985:
21986: ret_val = xmlNewText((const xmlChar *)content);
21987: desret_xmlNodePtr(ret_val);
21988: call_tests++;
21989: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 0);
21990: xmlResetLastError();
21991: if (mem_base != xmlMemBlocks()) {
21992: printf("Leak of %d blocks found in xmlNewText",
21993: xmlMemBlocks() - mem_base);
21994: test_ret++;
21995: printf(" %d", n_content);
21996: printf("\n");
21997: }
21998: }
21999: function_tests++;
22000:
22001: return(test_ret);
22002: }
22003:
22004:
22005: static int
22006: test_xmlNewTextChild(void) {
22007: int test_ret = 0;
22008:
22009: #if defined(LIBXML_TREE_ENABLED)
22010: #ifdef LIBXML_TREE_ENABLED
22011: int mem_base;
22012: xmlNodePtr ret_val;
22013: xmlNodePtr parent; /* the parent node */
22014: int n_parent;
22015: xmlNsPtr ns; /* a namespace if any */
22016: int n_ns;
22017: xmlChar * name; /* the name of the child */
22018: int n_name;
22019: xmlChar * content; /* the text content of the child if any. */
22020: int n_content;
22021:
22022: for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
22023: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
22024: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
22025: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
22026: mem_base = xmlMemBlocks();
22027: parent = gen_xmlNodePtr(n_parent, 0);
22028: ns = gen_xmlNsPtr(n_ns, 1);
22029: name = gen_const_xmlChar_ptr(n_name, 2);
22030: content = gen_const_xmlChar_ptr(n_content, 3);
22031:
22032: ret_val = xmlNewTextChild(parent, ns, (const xmlChar *)name, (const xmlChar *)content);
22033: desret_xmlNodePtr(ret_val);
22034: call_tests++;
22035: des_xmlNodePtr(n_parent, parent, 0);
22036: des_xmlNsPtr(n_ns, ns, 1);
22037: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
22038: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3);
22039: xmlResetLastError();
22040: if (mem_base != xmlMemBlocks()) {
22041: printf("Leak of %d blocks found in xmlNewTextChild",
22042: xmlMemBlocks() - mem_base);
22043: test_ret++;
22044: printf(" %d", n_parent);
22045: printf(" %d", n_ns);
22046: printf(" %d", n_name);
22047: printf(" %d", n_content);
22048: printf("\n");
22049: }
22050: }
22051: }
22052: }
22053: }
22054: function_tests++;
22055: #endif
22056: #endif
22057:
22058: return(test_ret);
22059: }
22060:
22061:
22062: static int
22063: test_xmlNewTextLen(void) {
22064: int test_ret = 0;
22065:
22066: int mem_base;
22067: xmlNodePtr ret_val;
22068: xmlChar * content; /* the text content */
22069: int n_content;
22070: int len; /* the text len. */
22071: int n_len;
22072:
22073: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
22074: for (n_len = 0;n_len < gen_nb_int;n_len++) {
22075: mem_base = xmlMemBlocks();
22076: content = gen_const_xmlChar_ptr(n_content, 0);
22077: len = gen_int(n_len, 1);
22078:
22079: ret_val = xmlNewTextLen((const xmlChar *)content, len);
22080: desret_xmlNodePtr(ret_val);
22081: call_tests++;
22082: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 0);
22083: des_int(n_len, len, 1);
22084: xmlResetLastError();
22085: if (mem_base != xmlMemBlocks()) {
22086: printf("Leak of %d blocks found in xmlNewTextLen",
22087: xmlMemBlocks() - mem_base);
22088: test_ret++;
22089: printf(" %d", n_content);
22090: printf(" %d", n_len);
22091: printf("\n");
22092: }
22093: }
22094: }
22095: function_tests++;
22096:
22097: return(test_ret);
22098: }
22099:
22100:
22101: static int
22102: test_xmlNextElementSibling(void) {
22103: int test_ret = 0;
22104:
22105: #if defined(LIBXML_TREE_ENABLED)
22106: int mem_base;
22107: xmlNodePtr ret_val;
22108: xmlNodePtr node; /* the current node */
22109: int n_node;
22110:
22111: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
22112: mem_base = xmlMemBlocks();
22113: node = gen_xmlNodePtr(n_node, 0);
22114:
22115: ret_val = xmlNextElementSibling(node);
22116: desret_xmlNodePtr(ret_val);
22117: call_tests++;
22118: des_xmlNodePtr(n_node, node, 0);
22119: xmlResetLastError();
22120: if (mem_base != xmlMemBlocks()) {
22121: printf("Leak of %d blocks found in xmlNextElementSibling",
22122: xmlMemBlocks() - mem_base);
22123: test_ret++;
22124: printf(" %d", n_node);
22125: printf("\n");
22126: }
22127: }
22128: function_tests++;
22129: #endif
22130:
22131: return(test_ret);
22132: }
22133:
22134:
22135: static int
22136: test_xmlNodeAddContent(void) {
22137: int test_ret = 0;
22138:
22139: int mem_base;
22140: xmlNodePtr cur; /* the node being modified */
22141: int n_cur;
22142: xmlChar * content; /* extra content */
22143: int n_content;
22144:
22145: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22146: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
22147: mem_base = xmlMemBlocks();
22148: cur = gen_xmlNodePtr(n_cur, 0);
22149: content = gen_const_xmlChar_ptr(n_content, 1);
22150:
22151: xmlNodeAddContent(cur, (const xmlChar *)content);
22152: call_tests++;
22153: des_xmlNodePtr(n_cur, cur, 0);
22154: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
22155: xmlResetLastError();
22156: if (mem_base != xmlMemBlocks()) {
22157: printf("Leak of %d blocks found in xmlNodeAddContent",
22158: xmlMemBlocks() - mem_base);
22159: test_ret++;
22160: printf(" %d", n_cur);
22161: printf(" %d", n_content);
22162: printf("\n");
22163: }
22164: }
22165: }
22166: function_tests++;
22167:
22168: return(test_ret);
22169: }
22170:
22171:
22172: static int
22173: test_xmlNodeAddContentLen(void) {
22174: int test_ret = 0;
22175:
22176: int mem_base;
22177: xmlNodePtr cur; /* the node being modified */
22178: int n_cur;
22179: xmlChar * content; /* extra content */
22180: int n_content;
22181: int len; /* the size of @content */
22182: int n_len;
22183:
22184: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22185: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
22186: for (n_len = 0;n_len < gen_nb_int;n_len++) {
22187: mem_base = xmlMemBlocks();
22188: cur = gen_xmlNodePtr(n_cur, 0);
22189: content = gen_const_xmlChar_ptr(n_content, 1);
22190: len = gen_int(n_len, 2);
22191:
22192: xmlNodeAddContentLen(cur, (const xmlChar *)content, len);
22193: call_tests++;
22194: des_xmlNodePtr(n_cur, cur, 0);
22195: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
22196: des_int(n_len, len, 2);
22197: xmlResetLastError();
22198: if (mem_base != xmlMemBlocks()) {
22199: printf("Leak of %d blocks found in xmlNodeAddContentLen",
22200: xmlMemBlocks() - mem_base);
22201: test_ret++;
22202: printf(" %d", n_cur);
22203: printf(" %d", n_content);
22204: printf(" %d", n_len);
22205: printf("\n");
22206: }
22207: }
22208: }
22209: }
22210: function_tests++;
22211:
22212: return(test_ret);
22213: }
22214:
22215:
22216: static int
22217: test_xmlNodeBufGetContent(void) {
22218: int test_ret = 0;
22219:
22220: int mem_base;
22221: int ret_val;
22222: xmlBufferPtr buffer; /* a buffer */
22223: int n_buffer;
22224: xmlNodePtr cur; /* the node being read */
22225: int n_cur;
22226:
22227: for (n_buffer = 0;n_buffer < gen_nb_xmlBufferPtr;n_buffer++) {
22228: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22229: mem_base = xmlMemBlocks();
22230: buffer = gen_xmlBufferPtr(n_buffer, 0);
22231: cur = gen_xmlNodePtr(n_cur, 1);
22232:
22233: ret_val = xmlNodeBufGetContent(buffer, cur);
22234: desret_int(ret_val);
22235: call_tests++;
22236: des_xmlBufferPtr(n_buffer, buffer, 0);
22237: des_xmlNodePtr(n_cur, cur, 1);
22238: xmlResetLastError();
22239: if (mem_base != xmlMemBlocks()) {
22240: printf("Leak of %d blocks found in xmlNodeBufGetContent",
22241: xmlMemBlocks() - mem_base);
22242: test_ret++;
22243: printf(" %d", n_buffer);
22244: printf(" %d", n_cur);
22245: printf("\n");
22246: }
22247: }
22248: }
22249: function_tests++;
22250:
22251: return(test_ret);
22252: }
22253:
22254:
22255: static int
22256: test_xmlNodeDump(void) {
22257: int test_ret = 0;
22258:
22259: #if defined(LIBXML_OUTPUT_ENABLED)
22260: int mem_base;
22261: int ret_val;
22262: xmlBufferPtr buf; /* the XML buffer output */
22263: int n_buf;
22264: xmlDocPtr doc; /* the document */
22265: int n_doc;
22266: xmlNodePtr cur; /* the current node */
22267: int n_cur;
22268: int level; /* the imbrication level for indenting */
22269: int n_level;
22270: int format; /* is formatting allowed */
22271: int n_format;
22272:
22273: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
22274: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
22275: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22276: for (n_level = 0;n_level < gen_nb_int;n_level++) {
22277: for (n_format = 0;n_format < gen_nb_int;n_format++) {
22278: mem_base = xmlMemBlocks();
22279: buf = gen_xmlBufferPtr(n_buf, 0);
22280: doc = gen_xmlDocPtr(n_doc, 1);
22281: cur = gen_xmlNodePtr(n_cur, 2);
22282: level = gen_int(n_level, 3);
22283: format = gen_int(n_format, 4);
22284:
22285: ret_val = xmlNodeDump(buf, doc, cur, level, format);
22286: desret_int(ret_val);
22287: call_tests++;
22288: des_xmlBufferPtr(n_buf, buf, 0);
22289: des_xmlDocPtr(n_doc, doc, 1);
22290: des_xmlNodePtr(n_cur, cur, 2);
22291: des_int(n_level, level, 3);
22292: des_int(n_format, format, 4);
22293: xmlResetLastError();
22294: if (mem_base != xmlMemBlocks()) {
22295: printf("Leak of %d blocks found in xmlNodeDump",
22296: xmlMemBlocks() - mem_base);
22297: test_ret++;
22298: printf(" %d", n_buf);
22299: printf(" %d", n_doc);
22300: printf(" %d", n_cur);
22301: printf(" %d", n_level);
22302: printf(" %d", n_format);
22303: printf("\n");
22304: }
22305: }
22306: }
22307: }
22308: }
22309: }
22310: function_tests++;
22311: #endif
22312:
22313: return(test_ret);
22314: }
22315:
22316:
22317: static int
22318: test_xmlNodeDumpOutput(void) {
22319: int test_ret = 0;
22320:
22321: #if defined(LIBXML_OUTPUT_ENABLED)
22322: int mem_base;
22323: xmlOutputBufferPtr buf; /* the XML buffer output */
22324: int n_buf;
22325: xmlDocPtr doc; /* the document */
22326: int n_doc;
22327: xmlNodePtr cur; /* the current node */
22328: int n_cur;
22329: int level; /* the imbrication level for indenting */
22330: int n_level;
22331: int format; /* is formatting allowed */
22332: int n_format;
22333: char * encoding; /* an optional encoding string */
22334: int n_encoding;
22335:
22336: for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
22337: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
22338: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22339: for (n_level = 0;n_level < gen_nb_int;n_level++) {
22340: for (n_format = 0;n_format < gen_nb_int;n_format++) {
22341: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
22342: mem_base = xmlMemBlocks();
22343: buf = gen_xmlOutputBufferPtr(n_buf, 0);
22344: doc = gen_xmlDocPtr(n_doc, 1);
22345: cur = gen_xmlNodePtr(n_cur, 2);
22346: level = gen_int(n_level, 3);
22347: format = gen_int(n_format, 4);
22348: encoding = gen_const_char_ptr(n_encoding, 5);
22349:
22350: xmlNodeDumpOutput(buf, doc, cur, level, format, (const char *)encoding);
22351: call_tests++;
22352: des_xmlOutputBufferPtr(n_buf, buf, 0);
22353: des_xmlDocPtr(n_doc, doc, 1);
22354: des_xmlNodePtr(n_cur, cur, 2);
22355: des_int(n_level, level, 3);
22356: des_int(n_format, format, 4);
22357: des_const_char_ptr(n_encoding, (const char *)encoding, 5);
22358: xmlResetLastError();
22359: if (mem_base != xmlMemBlocks()) {
22360: printf("Leak of %d blocks found in xmlNodeDumpOutput",
22361: xmlMemBlocks() - mem_base);
22362: test_ret++;
22363: printf(" %d", n_buf);
22364: printf(" %d", n_doc);
22365: printf(" %d", n_cur);
22366: printf(" %d", n_level);
22367: printf(" %d", n_format);
22368: printf(" %d", n_encoding);
22369: printf("\n");
22370: }
22371: }
22372: }
22373: }
22374: }
22375: }
22376: }
22377: function_tests++;
22378: #endif
22379:
22380: return(test_ret);
22381: }
22382:
22383:
22384: static int
22385: test_xmlNodeGetBase(void) {
22386: int test_ret = 0;
22387:
22388: int mem_base;
22389: xmlChar * ret_val;
22390: xmlDocPtr doc; /* the document the node pertains to */
22391: int n_doc;
22392: xmlNodePtr cur; /* the node being checked */
22393: int n_cur;
22394:
22395: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
22396: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22397: mem_base = xmlMemBlocks();
22398: doc = gen_xmlDocPtr(n_doc, 0);
22399: cur = gen_xmlNodePtr(n_cur, 1);
22400:
22401: ret_val = xmlNodeGetBase(doc, cur);
22402: desret_xmlChar_ptr(ret_val);
22403: call_tests++;
22404: des_xmlDocPtr(n_doc, doc, 0);
22405: des_xmlNodePtr(n_cur, cur, 1);
22406: xmlResetLastError();
22407: if (mem_base != xmlMemBlocks()) {
22408: printf("Leak of %d blocks found in xmlNodeGetBase",
22409: xmlMemBlocks() - mem_base);
22410: test_ret++;
22411: printf(" %d", n_doc);
22412: printf(" %d", n_cur);
22413: printf("\n");
22414: }
22415: }
22416: }
22417: function_tests++;
22418:
22419: return(test_ret);
22420: }
22421:
22422:
22423: static int
22424: test_xmlNodeGetContent(void) {
22425: int test_ret = 0;
22426:
22427: int mem_base;
22428: xmlChar * ret_val;
22429: xmlNodePtr cur; /* the node being read */
22430: int n_cur;
22431:
22432: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22433: mem_base = xmlMemBlocks();
22434: cur = gen_xmlNodePtr(n_cur, 0);
22435:
22436: ret_val = xmlNodeGetContent(cur);
22437: desret_xmlChar_ptr(ret_val);
22438: call_tests++;
22439: des_xmlNodePtr(n_cur, cur, 0);
22440: xmlResetLastError();
22441: if (mem_base != xmlMemBlocks()) {
22442: printf("Leak of %d blocks found in xmlNodeGetContent",
22443: xmlMemBlocks() - mem_base);
22444: test_ret++;
22445: printf(" %d", n_cur);
22446: printf("\n");
22447: }
22448: }
22449: function_tests++;
22450:
22451: return(test_ret);
22452: }
22453:
22454:
22455: static int
22456: test_xmlNodeGetLang(void) {
22457: int test_ret = 0;
22458:
22459: int mem_base;
22460: xmlChar * ret_val;
22461: xmlNodePtr cur; /* the node being checked */
22462: int n_cur;
22463:
22464: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22465: mem_base = xmlMemBlocks();
22466: cur = gen_xmlNodePtr(n_cur, 0);
22467:
22468: ret_val = xmlNodeGetLang(cur);
22469: desret_xmlChar_ptr(ret_val);
22470: call_tests++;
22471: des_xmlNodePtr(n_cur, cur, 0);
22472: xmlResetLastError();
22473: if (mem_base != xmlMemBlocks()) {
22474: printf("Leak of %d blocks found in xmlNodeGetLang",
22475: xmlMemBlocks() - mem_base);
22476: test_ret++;
22477: printf(" %d", n_cur);
22478: printf("\n");
22479: }
22480: }
22481: function_tests++;
22482:
22483: return(test_ret);
22484: }
22485:
22486:
22487: static int
22488: test_xmlNodeGetSpacePreserve(void) {
22489: int test_ret = 0;
22490:
22491: int mem_base;
22492: int ret_val;
22493: xmlNodePtr cur; /* the node being checked */
22494: int n_cur;
22495:
22496: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22497: mem_base = xmlMemBlocks();
22498: cur = gen_xmlNodePtr(n_cur, 0);
22499:
22500: ret_val = xmlNodeGetSpacePreserve(cur);
22501: desret_int(ret_val);
22502: call_tests++;
22503: des_xmlNodePtr(n_cur, cur, 0);
22504: xmlResetLastError();
22505: if (mem_base != xmlMemBlocks()) {
22506: printf("Leak of %d blocks found in xmlNodeGetSpacePreserve",
22507: xmlMemBlocks() - mem_base);
22508: test_ret++;
22509: printf(" %d", n_cur);
22510: printf("\n");
22511: }
22512: }
22513: function_tests++;
22514:
22515: return(test_ret);
22516: }
22517:
22518:
22519: static int
22520: test_xmlNodeIsText(void) {
22521: int test_ret = 0;
22522:
22523: int mem_base;
22524: int ret_val;
22525: xmlNodePtr node; /* the node */
22526: int n_node;
22527:
22528: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
22529: mem_base = xmlMemBlocks();
22530: node = gen_xmlNodePtr(n_node, 0);
22531:
22532: ret_val = xmlNodeIsText(node);
22533: desret_int(ret_val);
22534: call_tests++;
22535: des_xmlNodePtr(n_node, node, 0);
22536: xmlResetLastError();
22537: if (mem_base != xmlMemBlocks()) {
22538: printf("Leak of %d blocks found in xmlNodeIsText",
22539: xmlMemBlocks() - mem_base);
22540: test_ret++;
22541: printf(" %d", n_node);
22542: printf("\n");
22543: }
22544: }
22545: function_tests++;
22546:
22547: return(test_ret);
22548: }
22549:
22550:
22551: static int
22552: test_xmlNodeListGetRawString(void) {
22553: int test_ret = 0;
22554:
22555: #if defined(LIBXML_TREE_ENABLED)
22556: int mem_base;
22557: xmlChar * ret_val;
22558: xmlDocPtr doc; /* the document */
22559: int n_doc;
22560: xmlNodePtr list; /* a Node list */
22561: int n_list;
22562: int inLine; /* should we replace entity contents or show their external form */
22563: int n_inLine;
22564:
22565: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
22566: for (n_list = 0;n_list < gen_nb_xmlNodePtr;n_list++) {
22567: for (n_inLine = 0;n_inLine < gen_nb_int;n_inLine++) {
22568: mem_base = xmlMemBlocks();
22569: doc = gen_xmlDocPtr(n_doc, 0);
22570: list = gen_xmlNodePtr(n_list, 1);
22571: inLine = gen_int(n_inLine, 2);
22572:
22573: ret_val = xmlNodeListGetRawString(doc, list, inLine);
22574: desret_xmlChar_ptr(ret_val);
22575: call_tests++;
22576: des_xmlDocPtr(n_doc, doc, 0);
22577: des_xmlNodePtr(n_list, list, 1);
22578: des_int(n_inLine, inLine, 2);
22579: xmlResetLastError();
22580: if (mem_base != xmlMemBlocks()) {
22581: printf("Leak of %d blocks found in xmlNodeListGetRawString",
22582: xmlMemBlocks() - mem_base);
22583: test_ret++;
22584: printf(" %d", n_doc);
22585: printf(" %d", n_list);
22586: printf(" %d", n_inLine);
22587: printf("\n");
22588: }
22589: }
22590: }
22591: }
22592: function_tests++;
22593: #endif
22594:
22595: return(test_ret);
22596: }
22597:
22598:
22599: static int
22600: test_xmlNodeListGetString(void) {
22601: int test_ret = 0;
22602:
22603: int mem_base;
22604: xmlChar * ret_val;
22605: xmlDocPtr doc; /* the document */
22606: int n_doc;
22607: xmlNodePtr list; /* a Node list */
22608: int n_list;
22609: int inLine; /* should we replace entity contents or show their external form */
22610: int n_inLine;
22611:
22612: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
22613: for (n_list = 0;n_list < gen_nb_xmlNodePtr;n_list++) {
22614: for (n_inLine = 0;n_inLine < gen_nb_int;n_inLine++) {
22615: mem_base = xmlMemBlocks();
22616: doc = gen_xmlDocPtr(n_doc, 0);
22617: list = gen_xmlNodePtr(n_list, 1);
22618: inLine = gen_int(n_inLine, 2);
22619:
22620: ret_val = xmlNodeListGetString(doc, list, inLine);
22621: desret_xmlChar_ptr(ret_val);
22622: call_tests++;
22623: des_xmlDocPtr(n_doc, doc, 0);
22624: des_xmlNodePtr(n_list, list, 1);
22625: des_int(n_inLine, inLine, 2);
22626: xmlResetLastError();
22627: if (mem_base != xmlMemBlocks()) {
22628: printf("Leak of %d blocks found in xmlNodeListGetString",
22629: xmlMemBlocks() - mem_base);
22630: test_ret++;
22631: printf(" %d", n_doc);
22632: printf(" %d", n_list);
22633: printf(" %d", n_inLine);
22634: printf("\n");
22635: }
22636: }
22637: }
22638: }
22639: function_tests++;
22640:
22641: return(test_ret);
22642: }
22643:
22644:
22645: static int
22646: test_xmlNodeSetBase(void) {
22647: int test_ret = 0;
22648:
22649: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED)
22650: int mem_base;
22651: xmlNodePtr cur; /* the node being changed */
22652: int n_cur;
22653: xmlChar * uri; /* the new base URI */
22654: int n_uri;
22655:
22656: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22657: for (n_uri = 0;n_uri < gen_nb_const_xmlChar_ptr;n_uri++) {
22658: mem_base = xmlMemBlocks();
22659: cur = gen_xmlNodePtr(n_cur, 0);
22660: uri = gen_const_xmlChar_ptr(n_uri, 1);
22661:
22662: xmlNodeSetBase(cur, (const xmlChar *)uri);
22663: call_tests++;
22664: des_xmlNodePtr(n_cur, cur, 0);
22665: des_const_xmlChar_ptr(n_uri, (const xmlChar *)uri, 1);
22666: xmlResetLastError();
22667: if (mem_base != xmlMemBlocks()) {
22668: printf("Leak of %d blocks found in xmlNodeSetBase",
22669: xmlMemBlocks() - mem_base);
22670: test_ret++;
22671: printf(" %d", n_cur);
22672: printf(" %d", n_uri);
22673: printf("\n");
22674: }
22675: }
22676: }
22677: function_tests++;
22678: #endif
22679:
22680: return(test_ret);
22681: }
22682:
22683:
22684: static int
22685: test_xmlNodeSetContent(void) {
22686: int test_ret = 0;
22687:
22688: int mem_base;
22689: xmlNodePtr cur; /* the node being modified */
22690: int n_cur;
22691: xmlChar * content; /* the new value of the content */
22692: int n_content;
22693:
22694: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22695: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
22696: mem_base = xmlMemBlocks();
22697: cur = gen_xmlNodePtr(n_cur, 0);
22698: content = gen_const_xmlChar_ptr(n_content, 1);
22699:
22700: xmlNodeSetContent(cur, (const xmlChar *)content);
22701: call_tests++;
22702: des_xmlNodePtr(n_cur, cur, 0);
22703: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
22704: xmlResetLastError();
22705: if (mem_base != xmlMemBlocks()) {
22706: printf("Leak of %d blocks found in xmlNodeSetContent",
22707: xmlMemBlocks() - mem_base);
22708: test_ret++;
22709: printf(" %d", n_cur);
22710: printf(" %d", n_content);
22711: printf("\n");
22712: }
22713: }
22714: }
22715: function_tests++;
22716:
22717: return(test_ret);
22718: }
22719:
22720:
22721: static int
22722: test_xmlNodeSetContentLen(void) {
22723: int test_ret = 0;
22724:
22725: #if defined(LIBXML_TREE_ENABLED)
22726: int mem_base;
22727: xmlNodePtr cur; /* the node being modified */
22728: int n_cur;
22729: xmlChar * content; /* the new value of the content */
22730: int n_content;
22731: int len; /* the size of @content */
22732: int n_len;
22733:
22734: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22735: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
22736: for (n_len = 0;n_len < gen_nb_int;n_len++) {
22737: mem_base = xmlMemBlocks();
22738: cur = gen_xmlNodePtr(n_cur, 0);
22739: content = gen_const_xmlChar_ptr(n_content, 1);
22740: len = gen_int(n_len, 2);
22741:
22742: xmlNodeSetContentLen(cur, (const xmlChar *)content, len);
22743: call_tests++;
22744: des_xmlNodePtr(n_cur, cur, 0);
22745: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
22746: des_int(n_len, len, 2);
22747: xmlResetLastError();
22748: if (mem_base != xmlMemBlocks()) {
22749: printf("Leak of %d blocks found in xmlNodeSetContentLen",
22750: xmlMemBlocks() - mem_base);
22751: test_ret++;
22752: printf(" %d", n_cur);
22753: printf(" %d", n_content);
22754: printf(" %d", n_len);
22755: printf("\n");
22756: }
22757: }
22758: }
22759: }
22760: function_tests++;
22761: #endif
22762:
22763: return(test_ret);
22764: }
22765:
22766:
22767: static int
22768: test_xmlNodeSetLang(void) {
22769: int test_ret = 0;
22770:
22771: #if defined(LIBXML_TREE_ENABLED)
22772: int mem_base;
22773: xmlNodePtr cur; /* the node being changed */
22774: int n_cur;
22775: xmlChar * lang; /* the language description */
22776: int n_lang;
22777:
22778: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22779: for (n_lang = 0;n_lang < gen_nb_const_xmlChar_ptr;n_lang++) {
22780: mem_base = xmlMemBlocks();
22781: cur = gen_xmlNodePtr(n_cur, 0);
22782: lang = gen_const_xmlChar_ptr(n_lang, 1);
22783:
22784: xmlNodeSetLang(cur, (const xmlChar *)lang);
22785: call_tests++;
22786: des_xmlNodePtr(n_cur, cur, 0);
22787: des_const_xmlChar_ptr(n_lang, (const xmlChar *)lang, 1);
22788: xmlResetLastError();
22789: if (mem_base != xmlMemBlocks()) {
22790: printf("Leak of %d blocks found in xmlNodeSetLang",
22791: xmlMemBlocks() - mem_base);
22792: test_ret++;
22793: printf(" %d", n_cur);
22794: printf(" %d", n_lang);
22795: printf("\n");
22796: }
22797: }
22798: }
22799: function_tests++;
22800: #endif
22801:
22802: return(test_ret);
22803: }
22804:
22805:
22806: static int
22807: test_xmlNodeSetName(void) {
22808: int test_ret = 0;
22809:
22810: #if defined(LIBXML_TREE_ENABLED)
22811: int mem_base;
22812: xmlNodePtr cur; /* the node being changed */
22813: int n_cur;
22814: xmlChar * name; /* the new tag name */
22815: int n_name;
22816:
22817: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22818: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
22819: mem_base = xmlMemBlocks();
22820: cur = gen_xmlNodePtr(n_cur, 0);
22821: name = gen_const_xmlChar_ptr(n_name, 1);
22822:
22823: xmlNodeSetName(cur, (const xmlChar *)name);
22824: call_tests++;
22825: des_xmlNodePtr(n_cur, cur, 0);
22826: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
22827: xmlResetLastError();
22828: if (mem_base != xmlMemBlocks()) {
22829: printf("Leak of %d blocks found in xmlNodeSetName",
22830: xmlMemBlocks() - mem_base);
22831: test_ret++;
22832: printf(" %d", n_cur);
22833: printf(" %d", n_name);
22834: printf("\n");
22835: }
22836: }
22837: }
22838: function_tests++;
22839: #endif
22840:
22841: return(test_ret);
22842: }
22843:
22844:
22845: static int
22846: test_xmlNodeSetSpacePreserve(void) {
22847: int test_ret = 0;
22848:
22849: #if defined(LIBXML_TREE_ENABLED)
22850: int mem_base;
22851: xmlNodePtr cur; /* the node being changed */
22852: int n_cur;
22853: int val; /* the xml:space value ("0": default, 1: "preserve") */
22854: int n_val;
22855:
22856: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22857: for (n_val = 0;n_val < gen_nb_int;n_val++) {
22858: mem_base = xmlMemBlocks();
22859: cur = gen_xmlNodePtr(n_cur, 0);
22860: val = gen_int(n_val, 1);
22861:
22862: xmlNodeSetSpacePreserve(cur, val);
22863: call_tests++;
22864: des_xmlNodePtr(n_cur, cur, 0);
22865: des_int(n_val, val, 1);
22866: xmlResetLastError();
22867: if (mem_base != xmlMemBlocks()) {
22868: printf("Leak of %d blocks found in xmlNodeSetSpacePreserve",
22869: xmlMemBlocks() - mem_base);
22870: test_ret++;
22871: printf(" %d", n_cur);
22872: printf(" %d", n_val);
22873: printf("\n");
22874: }
22875: }
22876: }
22877: function_tests++;
22878: #endif
22879:
22880: return(test_ret);
22881: }
22882:
22883:
22884: static int
22885: test_xmlPreviousElementSibling(void) {
22886: int test_ret = 0;
22887:
22888: #if defined(LIBXML_TREE_ENABLED)
22889: int mem_base;
22890: xmlNodePtr ret_val;
22891: xmlNodePtr node; /* the current node */
22892: int n_node;
22893:
22894: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
22895: mem_base = xmlMemBlocks();
22896: node = gen_xmlNodePtr(n_node, 0);
22897:
22898: ret_val = xmlPreviousElementSibling(node);
22899: desret_xmlNodePtr(ret_val);
22900: call_tests++;
22901: des_xmlNodePtr(n_node, node, 0);
22902: xmlResetLastError();
22903: if (mem_base != xmlMemBlocks()) {
22904: printf("Leak of %d blocks found in xmlPreviousElementSibling",
22905: xmlMemBlocks() - mem_base);
22906: test_ret++;
22907: printf(" %d", n_node);
22908: printf("\n");
22909: }
22910: }
22911: function_tests++;
22912: #endif
22913:
22914: return(test_ret);
22915: }
22916:
22917:
22918: static int
22919: test_xmlReconciliateNs(void) {
22920: int test_ret = 0;
22921:
22922: #if defined(LIBXML_TREE_ENABLED)
22923: #ifdef LIBXML_TREE_ENABLED
22924: int mem_base;
22925: int ret_val;
22926: xmlDocPtr doc; /* the document */
22927: int n_doc;
22928: xmlNodePtr tree; /* a node defining the subtree to reconciliate */
22929: int n_tree;
22930:
22931: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
22932: for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) {
22933: mem_base = xmlMemBlocks();
22934: doc = gen_xmlDocPtr(n_doc, 0);
22935: tree = gen_xmlNodePtr(n_tree, 1);
22936:
22937: ret_val = xmlReconciliateNs(doc, tree);
22938: desret_int(ret_val);
22939: call_tests++;
22940: des_xmlDocPtr(n_doc, doc, 0);
22941: des_xmlNodePtr(n_tree, tree, 1);
22942: xmlResetLastError();
22943: if (mem_base != xmlMemBlocks()) {
22944: printf("Leak of %d blocks found in xmlReconciliateNs",
22945: xmlMemBlocks() - mem_base);
22946: test_ret++;
22947: printf(" %d", n_doc);
22948: printf(" %d", n_tree);
22949: printf("\n");
22950: }
22951: }
22952: }
22953: function_tests++;
22954: #endif
22955: #endif
22956:
22957: return(test_ret);
22958: }
22959:
22960:
22961: static int
22962: test_xmlRemoveProp(void) {
22963: int test_ret = 0;
22964:
22965: int mem_base;
22966: int ret_val;
22967: xmlAttrPtr cur; /* an attribute */
22968: int n_cur;
22969:
22970: for (n_cur = 0;n_cur < gen_nb_xmlAttrPtr;n_cur++) {
22971: mem_base = xmlMemBlocks();
22972: cur = gen_xmlAttrPtr(n_cur, 0);
22973:
22974: ret_val = xmlRemoveProp(cur);
22975: cur = NULL;
22976: desret_int(ret_val);
22977: call_tests++;
22978: des_xmlAttrPtr(n_cur, cur, 0);
22979: xmlResetLastError();
22980: if (mem_base != xmlMemBlocks()) {
22981: printf("Leak of %d blocks found in xmlRemoveProp",
22982: xmlMemBlocks() - mem_base);
22983: test_ret++;
22984: printf(" %d", n_cur);
22985: printf("\n");
22986: }
22987: }
22988: function_tests++;
22989:
22990: return(test_ret);
22991: }
22992:
22993:
22994: static int
22995: test_xmlReplaceNode(void) {
22996: int test_ret = 0;
22997:
22998: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
22999: int mem_base;
23000: xmlNodePtr ret_val;
23001: xmlNodePtr old; /* the old node */
23002: int n_old;
23003: xmlNodePtr cur; /* the node */
23004: int n_cur;
23005:
23006: for (n_old = 0;n_old < gen_nb_xmlNodePtr;n_old++) {
23007: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr_in;n_cur++) {
23008: mem_base = xmlMemBlocks();
23009: old = gen_xmlNodePtr(n_old, 0);
23010: cur = gen_xmlNodePtr_in(n_cur, 1);
23011:
23012: ret_val = xmlReplaceNode(old, cur);
23013: if (cur != NULL) {
23014: xmlUnlinkNode(cur);
23015: xmlFreeNode(cur) ; cur = NULL ; }
23016: if (old != NULL) {
23017: xmlUnlinkNode(old);
23018: xmlFreeNode(old) ; old = NULL ; }
23019: ret_val = NULL;
23020: desret_xmlNodePtr(ret_val);
23021: call_tests++;
23022: des_xmlNodePtr(n_old, old, 0);
23023: des_xmlNodePtr_in(n_cur, cur, 1);
23024: xmlResetLastError();
23025: if (mem_base != xmlMemBlocks()) {
23026: printf("Leak of %d blocks found in xmlReplaceNode",
23027: xmlMemBlocks() - mem_base);
23028: test_ret++;
23029: printf(" %d", n_old);
23030: printf(" %d", n_cur);
23031: printf("\n");
23032: }
23033: }
23034: }
23035: function_tests++;
23036: #endif
23037:
23038: return(test_ret);
23039: }
23040:
23041:
23042: static int
23043: test_xmlSaveFile(void) {
23044: int test_ret = 0;
23045:
23046: #if defined(LIBXML_OUTPUT_ENABLED)
23047: int mem_base;
23048: int ret_val;
23049: const char * filename; /* the filename (or URL) */
23050: int n_filename;
23051: xmlDocPtr cur; /* the document */
23052: int n_cur;
23053:
23054: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
23055: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
23056: mem_base = xmlMemBlocks();
23057: filename = gen_fileoutput(n_filename, 0);
23058: cur = gen_xmlDocPtr(n_cur, 1);
23059:
23060: ret_val = xmlSaveFile(filename, cur);
23061: desret_int(ret_val);
23062: call_tests++;
23063: des_fileoutput(n_filename, filename, 0);
23064: des_xmlDocPtr(n_cur, cur, 1);
23065: xmlResetLastError();
23066: if (mem_base != xmlMemBlocks()) {
23067: printf("Leak of %d blocks found in xmlSaveFile",
23068: xmlMemBlocks() - mem_base);
23069: test_ret++;
23070: printf(" %d", n_filename);
23071: printf(" %d", n_cur);
23072: printf("\n");
23073: }
23074: }
23075: }
23076: function_tests++;
23077: #endif
23078:
23079: return(test_ret);
23080: }
23081:
23082:
23083: static int
23084: test_xmlSaveFileEnc(void) {
23085: int test_ret = 0;
23086:
23087: #if defined(LIBXML_OUTPUT_ENABLED)
23088: int mem_base;
23089: int ret_val;
23090: const char * filename; /* the filename (or URL) */
23091: int n_filename;
23092: xmlDocPtr cur; /* the document */
23093: int n_cur;
23094: char * encoding; /* the name of an encoding (or NULL) */
23095: int n_encoding;
23096:
23097: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
23098: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
23099: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
23100: mem_base = xmlMemBlocks();
23101: filename = gen_fileoutput(n_filename, 0);
23102: cur = gen_xmlDocPtr(n_cur, 1);
23103: encoding = gen_const_char_ptr(n_encoding, 2);
23104:
23105: ret_val = xmlSaveFileEnc(filename, cur, (const char *)encoding);
23106: desret_int(ret_val);
23107: call_tests++;
23108: des_fileoutput(n_filename, filename, 0);
23109: des_xmlDocPtr(n_cur, cur, 1);
23110: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
23111: xmlResetLastError();
23112: if (mem_base != xmlMemBlocks()) {
23113: printf("Leak of %d blocks found in xmlSaveFileEnc",
23114: xmlMemBlocks() - mem_base);
23115: test_ret++;
23116: printf(" %d", n_filename);
23117: printf(" %d", n_cur);
23118: printf(" %d", n_encoding);
23119: printf("\n");
23120: }
23121: }
23122: }
23123: }
23124: function_tests++;
23125: #endif
23126:
23127: return(test_ret);
23128: }
23129:
23130:
23131: static int
23132: test_xmlSaveFileTo(void) {
23133: int test_ret = 0;
23134:
23135: #if defined(LIBXML_OUTPUT_ENABLED)
23136: int mem_base;
23137: int ret_val;
23138: xmlOutputBufferPtr buf; /* an output I/O buffer */
23139: int n_buf;
23140: xmlDocPtr cur; /* the document */
23141: int n_cur;
23142: char * encoding; /* the encoding if any assuming the I/O layer handles the trancoding */
23143: int n_encoding;
23144:
23145: for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
23146: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
23147: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
23148: mem_base = xmlMemBlocks();
23149: buf = gen_xmlOutputBufferPtr(n_buf, 0);
23150: cur = gen_xmlDocPtr(n_cur, 1);
23151: encoding = gen_const_char_ptr(n_encoding, 2);
23152:
23153: ret_val = xmlSaveFileTo(buf, cur, (const char *)encoding);
23154: buf = NULL;
23155: desret_int(ret_val);
23156: call_tests++;
23157: des_xmlOutputBufferPtr(n_buf, buf, 0);
23158: des_xmlDocPtr(n_cur, cur, 1);
23159: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
23160: xmlResetLastError();
23161: if (mem_base != xmlMemBlocks()) {
23162: printf("Leak of %d blocks found in xmlSaveFileTo",
23163: xmlMemBlocks() - mem_base);
23164: test_ret++;
23165: printf(" %d", n_buf);
23166: printf(" %d", n_cur);
23167: printf(" %d", n_encoding);
23168: printf("\n");
23169: }
23170: }
23171: }
23172: }
23173: function_tests++;
23174: #endif
23175:
23176: return(test_ret);
23177: }
23178:
23179:
23180: static int
23181: test_xmlSaveFormatFile(void) {
23182: int test_ret = 0;
23183:
23184: #if defined(LIBXML_OUTPUT_ENABLED)
23185: int mem_base;
23186: int ret_val;
23187: const char * filename; /* the filename (or URL) */
23188: int n_filename;
23189: xmlDocPtr cur; /* the document */
23190: int n_cur;
23191: int format; /* should formatting spaces been added */
23192: int n_format;
23193:
23194: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
23195: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
23196: for (n_format = 0;n_format < gen_nb_int;n_format++) {
23197: mem_base = xmlMemBlocks();
23198: filename = gen_fileoutput(n_filename, 0);
23199: cur = gen_xmlDocPtr(n_cur, 1);
23200: format = gen_int(n_format, 2);
23201:
23202: ret_val = xmlSaveFormatFile(filename, cur, format);
23203: desret_int(ret_val);
23204: call_tests++;
23205: des_fileoutput(n_filename, filename, 0);
23206: des_xmlDocPtr(n_cur, cur, 1);
23207: des_int(n_format, format, 2);
23208: xmlResetLastError();
23209: if (mem_base != xmlMemBlocks()) {
23210: printf("Leak of %d blocks found in xmlSaveFormatFile",
23211: xmlMemBlocks() - mem_base);
23212: test_ret++;
23213: printf(" %d", n_filename);
23214: printf(" %d", n_cur);
23215: printf(" %d", n_format);
23216: printf("\n");
23217: }
23218: }
23219: }
23220: }
23221: function_tests++;
23222: #endif
23223:
23224: return(test_ret);
23225: }
23226:
23227:
23228: static int
23229: test_xmlSaveFormatFileEnc(void) {
23230: int test_ret = 0;
23231:
23232: #if defined(LIBXML_OUTPUT_ENABLED)
23233: int mem_base;
23234: int ret_val;
23235: const char * filename; /* the filename or URL to output */
23236: int n_filename;
23237: xmlDocPtr cur; /* the document being saved */
23238: int n_cur;
23239: char * encoding; /* the name of the encoding to use or NULL. */
23240: int n_encoding;
23241: int format; /* should formatting spaces be added. */
23242: int n_format;
23243:
23244: for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
23245: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
23246: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
23247: for (n_format = 0;n_format < gen_nb_int;n_format++) {
23248: mem_base = xmlMemBlocks();
23249: filename = gen_fileoutput(n_filename, 0);
23250: cur = gen_xmlDocPtr(n_cur, 1);
23251: encoding = gen_const_char_ptr(n_encoding, 2);
23252: format = gen_int(n_format, 3);
23253:
23254: ret_val = xmlSaveFormatFileEnc(filename, cur, (const char *)encoding, format);
23255: desret_int(ret_val);
23256: call_tests++;
23257: des_fileoutput(n_filename, filename, 0);
23258: des_xmlDocPtr(n_cur, cur, 1);
23259: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
23260: des_int(n_format, format, 3);
23261: xmlResetLastError();
23262: if (mem_base != xmlMemBlocks()) {
23263: printf("Leak of %d blocks found in xmlSaveFormatFileEnc",
23264: xmlMemBlocks() - mem_base);
23265: test_ret++;
23266: printf(" %d", n_filename);
23267: printf(" %d", n_cur);
23268: printf(" %d", n_encoding);
23269: printf(" %d", n_format);
23270: printf("\n");
23271: }
23272: }
23273: }
23274: }
23275: }
23276: function_tests++;
23277: #endif
23278:
23279: return(test_ret);
23280: }
23281:
23282:
23283: static int
23284: test_xmlSaveFormatFileTo(void) {
23285: int test_ret = 0;
23286:
23287: #if defined(LIBXML_OUTPUT_ENABLED)
23288: int mem_base;
23289: int ret_val;
23290: xmlOutputBufferPtr buf; /* an output I/O buffer */
23291: int n_buf;
23292: xmlDocPtr cur; /* the document */
23293: int n_cur;
23294: char * encoding; /* the encoding if any assuming the I/O layer handles the trancoding */
23295: int n_encoding;
23296: int format; /* should formatting spaces been added */
23297: int n_format;
23298:
23299: for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
23300: for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
23301: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
23302: for (n_format = 0;n_format < gen_nb_int;n_format++) {
23303: mem_base = xmlMemBlocks();
23304: buf = gen_xmlOutputBufferPtr(n_buf, 0);
23305: cur = gen_xmlDocPtr(n_cur, 1);
23306: encoding = gen_const_char_ptr(n_encoding, 2);
23307: format = gen_int(n_format, 3);
23308:
23309: ret_val = xmlSaveFormatFileTo(buf, cur, (const char *)encoding, format);
23310: buf = NULL;
23311: desret_int(ret_val);
23312: call_tests++;
23313: des_xmlOutputBufferPtr(n_buf, buf, 0);
23314: des_xmlDocPtr(n_cur, cur, 1);
23315: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
23316: des_int(n_format, format, 3);
23317: xmlResetLastError();
23318: if (mem_base != xmlMemBlocks()) {
23319: printf("Leak of %d blocks found in xmlSaveFormatFileTo",
23320: xmlMemBlocks() - mem_base);
23321: test_ret++;
23322: printf(" %d", n_buf);
23323: printf(" %d", n_cur);
23324: printf(" %d", n_encoding);
23325: printf(" %d", n_format);
23326: printf("\n");
23327: }
23328: }
23329: }
23330: }
23331: }
23332: function_tests++;
23333: #endif
23334:
23335: return(test_ret);
23336: }
23337:
23338:
23339: static int
23340: test_xmlSearchNs(void) {
23341: int test_ret = 0;
23342:
23343: int mem_base;
23344: xmlNsPtr ret_val;
23345: xmlDocPtr doc; /* the document */
23346: int n_doc;
23347: xmlNodePtr node; /* the current node */
23348: int n_node;
23349: xmlChar * nameSpace; /* the namespace prefix */
23350: int n_nameSpace;
23351:
23352: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
23353: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
23354: for (n_nameSpace = 0;n_nameSpace < gen_nb_const_xmlChar_ptr;n_nameSpace++) {
23355: mem_base = xmlMemBlocks();
23356: doc = gen_xmlDocPtr(n_doc, 0);
23357: node = gen_xmlNodePtr(n_node, 1);
23358: nameSpace = gen_const_xmlChar_ptr(n_nameSpace, 2);
23359:
23360: ret_val = xmlSearchNs(doc, node, (const xmlChar *)nameSpace);
23361: desret_xmlNsPtr(ret_val);
23362: call_tests++;
23363: des_xmlDocPtr(n_doc, doc, 0);
23364: des_xmlNodePtr(n_node, node, 1);
23365: des_const_xmlChar_ptr(n_nameSpace, (const xmlChar *)nameSpace, 2);
23366: xmlResetLastError();
23367: if (mem_base != xmlMemBlocks()) {
23368: printf("Leak of %d blocks found in xmlSearchNs",
23369: xmlMemBlocks() - mem_base);
23370: test_ret++;
23371: printf(" %d", n_doc);
23372: printf(" %d", n_node);
23373: printf(" %d", n_nameSpace);
23374: printf("\n");
23375: }
23376: }
23377: }
23378: }
23379: function_tests++;
23380:
23381: return(test_ret);
23382: }
23383:
23384:
23385: static int
23386: test_xmlSearchNsByHref(void) {
23387: int test_ret = 0;
23388:
23389: int mem_base;
23390: xmlNsPtr ret_val;
23391: xmlDocPtr doc; /* the document */
23392: int n_doc;
23393: xmlNodePtr node; /* the current node */
23394: int n_node;
23395: xmlChar * href; /* the namespace value */
23396: int n_href;
23397:
23398: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
23399: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
23400: for (n_href = 0;n_href < gen_nb_const_xmlChar_ptr;n_href++) {
23401: mem_base = xmlMemBlocks();
23402: doc = gen_xmlDocPtr(n_doc, 0);
23403: node = gen_xmlNodePtr(n_node, 1);
23404: href = gen_const_xmlChar_ptr(n_href, 2);
23405:
23406: ret_val = xmlSearchNsByHref(doc, node, (const xmlChar *)href);
23407: desret_xmlNsPtr(ret_val);
23408: call_tests++;
23409: des_xmlDocPtr(n_doc, doc, 0);
23410: des_xmlNodePtr(n_node, node, 1);
23411: des_const_xmlChar_ptr(n_href, (const xmlChar *)href, 2);
23412: xmlResetLastError();
23413: if (mem_base != xmlMemBlocks()) {
23414: printf("Leak of %d blocks found in xmlSearchNsByHref",
23415: xmlMemBlocks() - mem_base);
23416: test_ret++;
23417: printf(" %d", n_doc);
23418: printf(" %d", n_node);
23419: printf(" %d", n_href);
23420: printf("\n");
23421: }
23422: }
23423: }
23424: }
23425: function_tests++;
23426:
23427: return(test_ret);
23428: }
23429:
23430:
23431: static int
23432: test_xmlSetBufferAllocationScheme(void) {
23433: int test_ret = 0;
23434:
23435: int mem_base;
23436: xmlBufferAllocationScheme scheme; /* allocation method to use */
23437: int n_scheme;
23438:
23439: for (n_scheme = 0;n_scheme < gen_nb_xmlBufferAllocationScheme;n_scheme++) {
23440: mem_base = xmlMemBlocks();
23441: scheme = gen_xmlBufferAllocationScheme(n_scheme, 0);
23442:
23443: xmlSetBufferAllocationScheme(scheme);
23444: call_tests++;
23445: des_xmlBufferAllocationScheme(n_scheme, scheme, 0);
23446: xmlResetLastError();
23447: if (mem_base != xmlMemBlocks()) {
23448: printf("Leak of %d blocks found in xmlSetBufferAllocationScheme",
23449: xmlMemBlocks() - mem_base);
23450: test_ret++;
23451: printf(" %d", n_scheme);
23452: printf("\n");
23453: }
23454: }
23455: function_tests++;
23456:
23457: return(test_ret);
23458: }
23459:
23460:
23461: static int
23462: test_xmlSetCompressMode(void) {
23463: int test_ret = 0;
23464:
23465: int mem_base;
23466: int mode; /* the compression ratio */
23467: int n_mode;
23468:
23469: for (n_mode = 0;n_mode < gen_nb_int;n_mode++) {
23470: mem_base = xmlMemBlocks();
23471: mode = gen_int(n_mode, 0);
23472:
23473: xmlSetCompressMode(mode);
23474: call_tests++;
23475: des_int(n_mode, mode, 0);
23476: xmlResetLastError();
23477: if (mem_base != xmlMemBlocks()) {
23478: printf("Leak of %d blocks found in xmlSetCompressMode",
23479: xmlMemBlocks() - mem_base);
23480: test_ret++;
23481: printf(" %d", n_mode);
23482: printf("\n");
23483: }
23484: }
23485: function_tests++;
23486:
23487: return(test_ret);
23488: }
23489:
23490:
23491: static int
23492: test_xmlSetDocCompressMode(void) {
23493: int test_ret = 0;
23494:
23495: int mem_base;
23496: xmlDocPtr doc; /* the document */
23497: int n_doc;
23498: int mode; /* the compression ratio */
23499: int n_mode;
23500:
23501: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
23502: for (n_mode = 0;n_mode < gen_nb_int;n_mode++) {
23503: mem_base = xmlMemBlocks();
23504: doc = gen_xmlDocPtr(n_doc, 0);
23505: mode = gen_int(n_mode, 1);
23506:
23507: xmlSetDocCompressMode(doc, mode);
23508: call_tests++;
23509: des_xmlDocPtr(n_doc, doc, 0);
23510: des_int(n_mode, mode, 1);
23511: xmlResetLastError();
23512: if (mem_base != xmlMemBlocks()) {
23513: printf("Leak of %d blocks found in xmlSetDocCompressMode",
23514: xmlMemBlocks() - mem_base);
23515: test_ret++;
23516: printf(" %d", n_doc);
23517: printf(" %d", n_mode);
23518: printf("\n");
23519: }
23520: }
23521: }
23522: function_tests++;
23523:
23524: return(test_ret);
23525: }
23526:
23527:
23528: static int
23529: test_xmlSetNs(void) {
23530: int test_ret = 0;
23531:
23532: int mem_base;
23533: xmlNodePtr node; /* a node in the document */
23534: int n_node;
23535: xmlNsPtr ns; /* a namespace pointer */
23536: int n_ns;
23537:
23538: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
23539: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
23540: mem_base = xmlMemBlocks();
23541: node = gen_xmlNodePtr(n_node, 0);
23542: ns = gen_xmlNsPtr(n_ns, 1);
23543:
23544: xmlSetNs(node, ns);
23545: call_tests++;
23546: des_xmlNodePtr(n_node, node, 0);
23547: des_xmlNsPtr(n_ns, ns, 1);
23548: xmlResetLastError();
23549: if (mem_base != xmlMemBlocks()) {
23550: printf("Leak of %d blocks found in xmlSetNs",
23551: xmlMemBlocks() - mem_base);
23552: test_ret++;
23553: printf(" %d", n_node);
23554: printf(" %d", n_ns);
23555: printf("\n");
23556: }
23557: }
23558: }
23559: function_tests++;
23560:
23561: return(test_ret);
23562: }
23563:
23564:
23565: static int
23566: test_xmlSetNsProp(void) {
23567: int test_ret = 0;
23568:
23569: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
23570: int mem_base;
23571: xmlAttrPtr ret_val;
23572: xmlNodePtr node; /* the node */
23573: int n_node;
23574: xmlNsPtr ns; /* the namespace definition */
23575: int n_ns;
23576: xmlChar * name; /* the attribute name */
23577: int n_name;
23578: xmlChar * value; /* the attribute value */
23579: int n_value;
23580:
23581: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
23582: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
23583: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
23584: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
23585: mem_base = xmlMemBlocks();
23586: node = gen_xmlNodePtr(n_node, 0);
23587: ns = gen_xmlNsPtr(n_ns, 1);
23588: name = gen_const_xmlChar_ptr(n_name, 2);
23589: value = gen_const_xmlChar_ptr(n_value, 3);
23590:
23591: ret_val = xmlSetNsProp(node, ns, (const xmlChar *)name, (const xmlChar *)value);
23592: desret_xmlAttrPtr(ret_val);
23593: call_tests++;
23594: des_xmlNodePtr(n_node, node, 0);
23595: des_xmlNsPtr(n_ns, ns, 1);
23596: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
23597: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 3);
23598: xmlResetLastError();
23599: if (mem_base != xmlMemBlocks()) {
23600: printf("Leak of %d blocks found in xmlSetNsProp",
23601: xmlMemBlocks() - mem_base);
23602: test_ret++;
23603: printf(" %d", n_node);
23604: printf(" %d", n_ns);
23605: printf(" %d", n_name);
23606: printf(" %d", n_value);
23607: printf("\n");
23608: }
23609: }
23610: }
23611: }
23612: }
23613: function_tests++;
23614: #endif
23615:
23616: return(test_ret);
23617: }
23618:
23619:
23620: static int
23621: test_xmlSetProp(void) {
23622: int test_ret = 0;
23623:
23624: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
23625: int mem_base;
23626: xmlAttrPtr ret_val;
23627: xmlNodePtr node; /* the node */
23628: int n_node;
23629: xmlChar * name; /* the attribute name (a QName) */
23630: int n_name;
23631: xmlChar * value; /* the attribute value */
23632: int n_value;
23633:
23634: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
23635: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
23636: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
23637: mem_base = xmlMemBlocks();
23638: node = gen_xmlNodePtr(n_node, 0);
23639: name = gen_const_xmlChar_ptr(n_name, 1);
23640: value = gen_const_xmlChar_ptr(n_value, 2);
23641:
23642: ret_val = xmlSetProp(node, (const xmlChar *)name, (const xmlChar *)value);
23643: desret_xmlAttrPtr(ret_val);
23644: call_tests++;
23645: des_xmlNodePtr(n_node, node, 0);
23646: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
23647: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2);
23648: xmlResetLastError();
23649: if (mem_base != xmlMemBlocks()) {
23650: printf("Leak of %d blocks found in xmlSetProp",
23651: xmlMemBlocks() - mem_base);
23652: test_ret++;
23653: printf(" %d", n_node);
23654: printf(" %d", n_name);
23655: printf(" %d", n_value);
23656: printf("\n");
23657: }
23658: }
23659: }
23660: }
23661: function_tests++;
23662: #endif
23663:
23664: return(test_ret);
23665: }
23666:
23667:
23668: static int
23669: test_xmlSplitQName2(void) {
23670: int test_ret = 0;
23671:
23672: int mem_base;
23673: xmlChar * ret_val;
23674: xmlChar * name; /* the full QName */
23675: int n_name;
23676: xmlChar ** prefix; /* a xmlChar ** */
23677: int n_prefix;
23678:
23679: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
23680: for (n_prefix = 0;n_prefix < gen_nb_xmlChar_ptr_ptr;n_prefix++) {
23681: mem_base = xmlMemBlocks();
23682: name = gen_const_xmlChar_ptr(n_name, 0);
23683: prefix = gen_xmlChar_ptr_ptr(n_prefix, 1);
23684:
23685: ret_val = xmlSplitQName2((const xmlChar *)name, prefix);
23686: desret_xmlChar_ptr(ret_val);
23687: call_tests++;
23688: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
23689: des_xmlChar_ptr_ptr(n_prefix, prefix, 1);
23690: xmlResetLastError();
23691: if (mem_base != xmlMemBlocks()) {
23692: printf("Leak of %d blocks found in xmlSplitQName2",
23693: xmlMemBlocks() - mem_base);
23694: test_ret++;
23695: printf(" %d", n_name);
23696: printf(" %d", n_prefix);
23697: printf("\n");
23698: }
23699: }
23700: }
23701: function_tests++;
23702:
23703: return(test_ret);
23704: }
23705:
23706:
23707: static int
23708: test_xmlSplitQName3(void) {
23709: int test_ret = 0;
23710:
23711: int mem_base;
23712: const xmlChar * ret_val;
23713: xmlChar * name; /* the full QName */
23714: int n_name;
23715: int * len; /* an int * */
23716: int n_len;
23717:
23718: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
23719: for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
23720: mem_base = xmlMemBlocks();
23721: name = gen_const_xmlChar_ptr(n_name, 0);
23722: len = gen_int_ptr(n_len, 1);
23723:
23724: ret_val = xmlSplitQName3((const xmlChar *)name, len);
23725: desret_const_xmlChar_ptr(ret_val);
23726: call_tests++;
23727: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
23728: des_int_ptr(n_len, len, 1);
23729: xmlResetLastError();
23730: if (mem_base != xmlMemBlocks()) {
23731: printf("Leak of %d blocks found in xmlSplitQName3",
23732: xmlMemBlocks() - mem_base);
23733: test_ret++;
23734: printf(" %d", n_name);
23735: printf(" %d", n_len);
23736: printf("\n");
23737: }
23738: }
23739: }
23740: function_tests++;
23741:
23742: return(test_ret);
23743: }
23744:
23745:
23746: static int
23747: test_xmlStringGetNodeList(void) {
23748: int test_ret = 0;
23749:
23750: int mem_base;
23751: xmlNodePtr ret_val;
23752: xmlDocPtr doc; /* the document */
23753: int n_doc;
23754: xmlChar * value; /* the value of the attribute */
23755: int n_value;
23756:
23757: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
23758: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
23759: mem_base = xmlMemBlocks();
23760: doc = gen_xmlDocPtr(n_doc, 0);
23761: value = gen_const_xmlChar_ptr(n_value, 1);
23762:
23763: ret_val = xmlStringGetNodeList(doc, (const xmlChar *)value);
23764: desret_xmlNodePtr(ret_val);
23765: call_tests++;
23766: des_xmlDocPtr(n_doc, doc, 0);
23767: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
23768: xmlResetLastError();
23769: if (mem_base != xmlMemBlocks()) {
23770: printf("Leak of %d blocks found in xmlStringGetNodeList",
23771: xmlMemBlocks() - mem_base);
23772: test_ret++;
23773: printf(" %d", n_doc);
23774: printf(" %d", n_value);
23775: printf("\n");
23776: }
23777: }
23778: }
23779: function_tests++;
23780:
23781: return(test_ret);
23782: }
23783:
23784:
23785: static int
23786: test_xmlStringLenGetNodeList(void) {
23787: int test_ret = 0;
23788:
23789: int mem_base;
23790: xmlNodePtr ret_val;
23791: xmlDocPtr doc; /* the document */
23792: int n_doc;
23793: xmlChar * value; /* the value of the text */
23794: int n_value;
23795: int len; /* the length of the string value */
23796: int n_len;
23797:
23798: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
23799: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
23800: for (n_len = 0;n_len < gen_nb_int;n_len++) {
23801: mem_base = xmlMemBlocks();
23802: doc = gen_xmlDocPtr(n_doc, 0);
23803: value = gen_const_xmlChar_ptr(n_value, 1);
23804: len = gen_int(n_len, 2);
23805:
23806: ret_val = xmlStringLenGetNodeList(doc, (const xmlChar *)value, len);
23807: desret_xmlNodePtr(ret_val);
23808: call_tests++;
23809: des_xmlDocPtr(n_doc, doc, 0);
23810: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
23811: des_int(n_len, len, 2);
23812: xmlResetLastError();
23813: if (mem_base != xmlMemBlocks()) {
23814: printf("Leak of %d blocks found in xmlStringLenGetNodeList",
23815: xmlMemBlocks() - mem_base);
23816: test_ret++;
23817: printf(" %d", n_doc);
23818: printf(" %d", n_value);
23819: printf(" %d", n_len);
23820: printf("\n");
23821: }
23822: }
23823: }
23824: }
23825: function_tests++;
23826:
23827: return(test_ret);
23828: }
23829:
23830:
23831: static int
23832: test_xmlTextConcat(void) {
23833: int test_ret = 0;
23834:
23835: int mem_base;
23836: int ret_val;
23837: xmlNodePtr node; /* the node */
23838: int n_node;
23839: xmlChar * content; /* the content */
23840: int n_content;
23841: int len; /* @content length */
23842: int n_len;
23843:
23844: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
23845: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
23846: for (n_len = 0;n_len < gen_nb_int;n_len++) {
23847: mem_base = xmlMemBlocks();
23848: node = gen_xmlNodePtr(n_node, 0);
23849: content = gen_const_xmlChar_ptr(n_content, 1);
23850: len = gen_int(n_len, 2);
23851:
23852: ret_val = xmlTextConcat(node, (const xmlChar *)content, len);
23853: desret_int(ret_val);
23854: call_tests++;
23855: des_xmlNodePtr(n_node, node, 0);
23856: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
23857: des_int(n_len, len, 2);
23858: xmlResetLastError();
23859: if (mem_base != xmlMemBlocks()) {
23860: printf("Leak of %d blocks found in xmlTextConcat",
23861: xmlMemBlocks() - mem_base);
23862: test_ret++;
23863: printf(" %d", n_node);
23864: printf(" %d", n_content);
23865: printf(" %d", n_len);
23866: printf("\n");
23867: }
23868: }
23869: }
23870: }
23871: function_tests++;
23872:
23873: return(test_ret);
23874: }
23875:
23876:
23877: static int
23878: test_xmlTextMerge(void) {
23879: int test_ret = 0;
23880:
23881: int mem_base;
23882: xmlNodePtr ret_val;
23883: xmlNodePtr first; /* the first text node */
23884: int n_first;
23885: xmlNodePtr second; /* the second text node being merged */
23886: int n_second;
23887:
23888: for (n_first = 0;n_first < gen_nb_xmlNodePtr_in;n_first++) {
23889: for (n_second = 0;n_second < gen_nb_xmlNodePtr_in;n_second++) {
23890: mem_base = xmlMemBlocks();
23891: first = gen_xmlNodePtr_in(n_first, 0);
23892: second = gen_xmlNodePtr_in(n_second, 1);
23893:
23894: ret_val = xmlTextMerge(first, second);
23895: if ((first != NULL) && (first->type != XML_TEXT_NODE)) {
23896: xmlUnlinkNode(second);
23897: xmlFreeNode(second) ; second = NULL ; }
23898: desret_xmlNodePtr(ret_val);
23899: call_tests++;
23900: des_xmlNodePtr_in(n_first, first, 0);
23901: des_xmlNodePtr_in(n_second, second, 1);
23902: xmlResetLastError();
23903: if (mem_base != xmlMemBlocks()) {
23904: printf("Leak of %d blocks found in xmlTextMerge",
23905: xmlMemBlocks() - mem_base);
23906: test_ret++;
23907: printf(" %d", n_first);
23908: printf(" %d", n_second);
23909: printf("\n");
23910: }
23911: }
23912: }
23913: function_tests++;
23914:
23915: return(test_ret);
23916: }
23917:
23918:
23919: static int
23920: test_xmlUnsetNsProp(void) {
23921: int test_ret = 0;
23922:
23923: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
23924: int mem_base;
23925: int ret_val;
23926: xmlNodePtr node; /* the node */
23927: int n_node;
23928: xmlNsPtr ns; /* the namespace definition */
23929: int n_ns;
23930: xmlChar * name; /* the attribute name */
23931: int n_name;
23932:
23933: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
23934: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
23935: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
23936: mem_base = xmlMemBlocks();
23937: node = gen_xmlNodePtr(n_node, 0);
23938: ns = gen_xmlNsPtr(n_ns, 1);
23939: name = gen_const_xmlChar_ptr(n_name, 2);
23940:
23941: ret_val = xmlUnsetNsProp(node, ns, (const xmlChar *)name);
23942: desret_int(ret_val);
23943: call_tests++;
23944: des_xmlNodePtr(n_node, node, 0);
23945: des_xmlNsPtr(n_ns, ns, 1);
23946: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
23947: xmlResetLastError();
23948: if (mem_base != xmlMemBlocks()) {
23949: printf("Leak of %d blocks found in xmlUnsetNsProp",
23950: xmlMemBlocks() - mem_base);
23951: test_ret++;
23952: printf(" %d", n_node);
23953: printf(" %d", n_ns);
23954: printf(" %d", n_name);
23955: printf("\n");
23956: }
23957: }
23958: }
23959: }
23960: function_tests++;
23961: #endif
23962:
23963: return(test_ret);
23964: }
23965:
23966:
23967: static int
23968: test_xmlUnsetProp(void) {
23969: int test_ret = 0;
23970:
23971: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
23972: int mem_base;
23973: int ret_val;
23974: xmlNodePtr node; /* the node */
23975: int n_node;
23976: xmlChar * name; /* the attribute name */
23977: int n_name;
23978:
23979: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
23980: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
23981: mem_base = xmlMemBlocks();
23982: node = gen_xmlNodePtr(n_node, 0);
23983: name = gen_const_xmlChar_ptr(n_name, 1);
23984:
23985: ret_val = xmlUnsetProp(node, (const xmlChar *)name);
23986: desret_int(ret_val);
23987: call_tests++;
23988: des_xmlNodePtr(n_node, node, 0);
23989: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
23990: xmlResetLastError();
23991: if (mem_base != xmlMemBlocks()) {
23992: printf("Leak of %d blocks found in xmlUnsetProp",
23993: xmlMemBlocks() - mem_base);
23994: test_ret++;
23995: printf(" %d", n_node);
23996: printf(" %d", n_name);
23997: printf("\n");
23998: }
23999: }
24000: }
24001: function_tests++;
24002: #endif
24003:
24004: return(test_ret);
24005: }
24006:
24007:
24008: static int
24009: test_xmlValidateNCName(void) {
24010: int test_ret = 0;
24011:
24012: #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)
24013: #ifdef LIBXML_TREE_ENABLED
24014: int mem_base;
24015: int ret_val;
24016: xmlChar * value; /* the value to check */
24017: int n_value;
24018: int space; /* allow spaces in front and end of the string */
24019: int n_space;
24020:
24021: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
24022: for (n_space = 0;n_space < gen_nb_int;n_space++) {
24023: mem_base = xmlMemBlocks();
24024: value = gen_const_xmlChar_ptr(n_value, 0);
24025: space = gen_int(n_space, 1);
24026:
24027: ret_val = xmlValidateNCName((const xmlChar *)value, space);
24028: desret_int(ret_val);
24029: call_tests++;
24030: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
24031: des_int(n_space, space, 1);
24032: xmlResetLastError();
24033: if (mem_base != xmlMemBlocks()) {
24034: printf("Leak of %d blocks found in xmlValidateNCName",
24035: xmlMemBlocks() - mem_base);
24036: test_ret++;
24037: printf(" %d", n_value);
24038: printf(" %d", n_space);
24039: printf("\n");
24040: }
24041: }
24042: }
24043: function_tests++;
24044: #endif
24045: #endif
24046:
24047: return(test_ret);
24048: }
24049:
24050:
24051: static int
24052: test_xmlValidateNMToken(void) {
24053: int test_ret = 0;
24054:
24055: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
24056: #ifdef LIBXML_TREE_ENABLED
24057: int mem_base;
24058: int ret_val;
24059: xmlChar * value; /* the value to check */
24060: int n_value;
24061: int space; /* allow spaces in front and end of the string */
24062: int n_space;
24063:
24064: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
24065: for (n_space = 0;n_space < gen_nb_int;n_space++) {
24066: mem_base = xmlMemBlocks();
24067: value = gen_const_xmlChar_ptr(n_value, 0);
24068: space = gen_int(n_space, 1);
24069:
24070: ret_val = xmlValidateNMToken((const xmlChar *)value, space);
24071: desret_int(ret_val);
24072: call_tests++;
24073: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
24074: des_int(n_space, space, 1);
24075: xmlResetLastError();
24076: if (mem_base != xmlMemBlocks()) {
24077: printf("Leak of %d blocks found in xmlValidateNMToken",
24078: xmlMemBlocks() - mem_base);
24079: test_ret++;
24080: printf(" %d", n_value);
24081: printf(" %d", n_space);
24082: printf("\n");
24083: }
24084: }
24085: }
24086: function_tests++;
24087: #endif
24088: #endif
24089:
24090: return(test_ret);
24091: }
24092:
24093:
24094: static int
24095: test_xmlValidateName(void) {
24096: int test_ret = 0;
24097:
24098: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
24099: #ifdef LIBXML_TREE_ENABLED
24100: int mem_base;
24101: int ret_val;
24102: xmlChar * value; /* the value to check */
24103: int n_value;
24104: int space; /* allow spaces in front and end of the string */
24105: int n_space;
24106:
24107: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
24108: for (n_space = 0;n_space < gen_nb_int;n_space++) {
24109: mem_base = xmlMemBlocks();
24110: value = gen_const_xmlChar_ptr(n_value, 0);
24111: space = gen_int(n_space, 1);
24112:
24113: ret_val = xmlValidateName((const xmlChar *)value, space);
24114: desret_int(ret_val);
24115: call_tests++;
24116: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
24117: des_int(n_space, space, 1);
24118: xmlResetLastError();
24119: if (mem_base != xmlMemBlocks()) {
24120: printf("Leak of %d blocks found in xmlValidateName",
24121: xmlMemBlocks() - mem_base);
24122: test_ret++;
24123: printf(" %d", n_value);
24124: printf(" %d", n_space);
24125: printf("\n");
24126: }
24127: }
24128: }
24129: function_tests++;
24130: #endif
24131: #endif
24132:
24133: return(test_ret);
24134: }
24135:
24136:
24137: static int
24138: test_xmlValidateQName(void) {
24139: int test_ret = 0;
24140:
24141: #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
24142: #ifdef LIBXML_TREE_ENABLED
24143: int mem_base;
24144: int ret_val;
24145: xmlChar * value; /* the value to check */
24146: int n_value;
24147: int space; /* allow spaces in front and end of the string */
24148: int n_space;
24149:
24150: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
24151: for (n_space = 0;n_space < gen_nb_int;n_space++) {
24152: mem_base = xmlMemBlocks();
24153: value = gen_const_xmlChar_ptr(n_value, 0);
24154: space = gen_int(n_space, 1);
24155:
24156: ret_val = xmlValidateQName((const xmlChar *)value, space);
24157: desret_int(ret_val);
24158: call_tests++;
24159: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
24160: des_int(n_space, space, 1);
24161: xmlResetLastError();
24162: if (mem_base != xmlMemBlocks()) {
24163: printf("Leak of %d blocks found in xmlValidateQName",
24164: xmlMemBlocks() - mem_base);
24165: test_ret++;
24166: printf(" %d", n_value);
24167: printf(" %d", n_space);
24168: printf("\n");
24169: }
24170: }
24171: }
24172: function_tests++;
24173: #endif
24174: #endif
24175:
24176: return(test_ret);
24177: }
24178:
24179: static int
24180: test_tree(void) {
24181: int test_ret = 0;
24182:
1.1.1.3 ! misho 24183: if (quiet == 0) printf("Testing tree : 142 of 164 functions ...\n");
1.1 misho 24184: test_ret += test_xmlAddChild();
24185: test_ret += test_xmlAddChildList();
24186: test_ret += test_xmlAddNextSibling();
24187: test_ret += test_xmlAddPrevSibling();
24188: test_ret += test_xmlAddSibling();
24189: test_ret += test_xmlAttrSerializeTxtContent();
1.1.1.3 ! misho 24190: test_ret += test_xmlBufContent();
! 24191: test_ret += test_xmlBufEnd();
! 24192: test_ret += test_xmlBufGetNodeContent();
! 24193: test_ret += test_xmlBufNodeDump();
! 24194: test_ret += test_xmlBufShrink();
! 24195: test_ret += test_xmlBufUse();
1.1 misho 24196: test_ret += test_xmlBufferAdd();
24197: test_ret += test_xmlBufferAddHead();
24198: test_ret += test_xmlBufferCCat();
24199: test_ret += test_xmlBufferCat();
24200: test_ret += test_xmlBufferContent();
24201: test_ret += test_xmlBufferCreate();
24202: test_ret += test_xmlBufferCreateSize();
24203: test_ret += test_xmlBufferCreateStatic();
1.1.1.2 misho 24204: test_ret += test_xmlBufferDetach();
1.1 misho 24205: test_ret += test_xmlBufferEmpty();
24206: test_ret += test_xmlBufferGrow();
24207: test_ret += test_xmlBufferLength();
24208: test_ret += test_xmlBufferResize();
24209: test_ret += test_xmlBufferSetAllocationScheme();
24210: test_ret += test_xmlBufferShrink();
24211: test_ret += test_xmlBufferWriteCHAR();
24212: test_ret += test_xmlBufferWriteChar();
24213: test_ret += test_xmlBufferWriteQuotedString();
24214: test_ret += test_xmlBuildQName();
24215: test_ret += test_xmlChildElementCount();
24216: test_ret += test_xmlCopyDoc();
24217: test_ret += test_xmlCopyDtd();
24218: test_ret += test_xmlCopyNamespace();
24219: test_ret += test_xmlCopyNamespaceList();
24220: test_ret += test_xmlCopyNode();
24221: test_ret += test_xmlCopyNodeList();
24222: test_ret += test_xmlCopyProp();
24223: test_ret += test_xmlCopyPropList();
24224: test_ret += test_xmlCreateIntSubset();
24225: test_ret += test_xmlDOMWrapAdoptNode();
24226: test_ret += test_xmlDOMWrapCloneNode();
24227: test_ret += test_xmlDOMWrapNewCtxt();
24228: test_ret += test_xmlDOMWrapReconcileNamespaces();
24229: test_ret += test_xmlDOMWrapRemoveNode();
24230: test_ret += test_xmlDocCopyNode();
24231: test_ret += test_xmlDocCopyNodeList();
24232: test_ret += test_xmlDocDump();
24233: test_ret += test_xmlDocDumpFormatMemory();
24234: test_ret += test_xmlDocDumpFormatMemoryEnc();
24235: test_ret += test_xmlDocDumpMemory();
24236: test_ret += test_xmlDocDumpMemoryEnc();
24237: test_ret += test_xmlDocFormatDump();
24238: test_ret += test_xmlDocGetRootElement();
24239: test_ret += test_xmlDocSetRootElement();
24240: test_ret += test_xmlElemDump();
24241: test_ret += test_xmlFirstElementChild();
24242: test_ret += test_xmlGetBufferAllocationScheme();
24243: test_ret += test_xmlGetCompressMode();
24244: test_ret += test_xmlGetDocCompressMode();
24245: test_ret += test_xmlGetIntSubset();
24246: test_ret += test_xmlGetLastChild();
24247: test_ret += test_xmlGetLineNo();
24248: test_ret += test_xmlGetNoNsProp();
24249: test_ret += test_xmlGetNodePath();
24250: test_ret += test_xmlGetNsList();
24251: test_ret += test_xmlGetNsProp();
24252: test_ret += test_xmlGetProp();
24253: test_ret += test_xmlHasNsProp();
24254: test_ret += test_xmlHasProp();
24255: test_ret += test_xmlIsBlankNode();
24256: test_ret += test_xmlIsXHTML();
24257: test_ret += test_xmlLastElementChild();
24258: test_ret += test_xmlNewCDataBlock();
24259: test_ret += test_xmlNewCharRef();
24260: test_ret += test_xmlNewChild();
24261: test_ret += test_xmlNewComment();
24262: test_ret += test_xmlNewDoc();
24263: test_ret += test_xmlNewDocComment();
24264: test_ret += test_xmlNewDocFragment();
24265: test_ret += test_xmlNewDocNode();
24266: test_ret += test_xmlNewDocNodeEatName();
24267: test_ret += test_xmlNewDocPI();
24268: test_ret += test_xmlNewDocProp();
24269: test_ret += test_xmlNewDocRawNode();
24270: test_ret += test_xmlNewDocText();
24271: test_ret += test_xmlNewDocTextLen();
24272: test_ret += test_xmlNewDtd();
24273: test_ret += test_xmlNewNode();
24274: test_ret += test_xmlNewNodeEatName();
24275: test_ret += test_xmlNewNs();
24276: test_ret += test_xmlNewNsProp();
24277: test_ret += test_xmlNewNsPropEatName();
24278: test_ret += test_xmlNewPI();
24279: test_ret += test_xmlNewProp();
24280: test_ret += test_xmlNewReference();
24281: test_ret += test_xmlNewText();
24282: test_ret += test_xmlNewTextChild();
24283: test_ret += test_xmlNewTextLen();
24284: test_ret += test_xmlNextElementSibling();
24285: test_ret += test_xmlNodeAddContent();
24286: test_ret += test_xmlNodeAddContentLen();
24287: test_ret += test_xmlNodeBufGetContent();
24288: test_ret += test_xmlNodeDump();
24289: test_ret += test_xmlNodeDumpOutput();
24290: test_ret += test_xmlNodeGetBase();
24291: test_ret += test_xmlNodeGetContent();
24292: test_ret += test_xmlNodeGetLang();
24293: test_ret += test_xmlNodeGetSpacePreserve();
24294: test_ret += test_xmlNodeIsText();
24295: test_ret += test_xmlNodeListGetRawString();
24296: test_ret += test_xmlNodeListGetString();
24297: test_ret += test_xmlNodeSetBase();
24298: test_ret += test_xmlNodeSetContent();
24299: test_ret += test_xmlNodeSetContentLen();
24300: test_ret += test_xmlNodeSetLang();
24301: test_ret += test_xmlNodeSetName();
24302: test_ret += test_xmlNodeSetSpacePreserve();
24303: test_ret += test_xmlPreviousElementSibling();
24304: test_ret += test_xmlReconciliateNs();
24305: test_ret += test_xmlRemoveProp();
24306: test_ret += test_xmlReplaceNode();
24307: test_ret += test_xmlSaveFile();
24308: test_ret += test_xmlSaveFileEnc();
24309: test_ret += test_xmlSaveFileTo();
24310: test_ret += test_xmlSaveFormatFile();
24311: test_ret += test_xmlSaveFormatFileEnc();
24312: test_ret += test_xmlSaveFormatFileTo();
24313: test_ret += test_xmlSearchNs();
24314: test_ret += test_xmlSearchNsByHref();
24315: test_ret += test_xmlSetBufferAllocationScheme();
24316: test_ret += test_xmlSetCompressMode();
24317: test_ret += test_xmlSetDocCompressMode();
24318: test_ret += test_xmlSetNs();
24319: test_ret += test_xmlSetNsProp();
24320: test_ret += test_xmlSetProp();
24321: test_ret += test_xmlSplitQName2();
24322: test_ret += test_xmlSplitQName3();
24323: test_ret += test_xmlStringGetNodeList();
24324: test_ret += test_xmlStringLenGetNodeList();
24325: test_ret += test_xmlTextConcat();
24326: test_ret += test_xmlTextMerge();
24327: test_ret += test_xmlUnsetNsProp();
24328: test_ret += test_xmlUnsetProp();
24329: test_ret += test_xmlValidateNCName();
24330: test_ret += test_xmlValidateNMToken();
24331: test_ret += test_xmlValidateName();
24332: test_ret += test_xmlValidateQName();
24333:
24334: if (test_ret != 0)
24335: printf("Module tree: %d errors\n", test_ret);
24336: return(test_ret);
24337: }
24338:
24339: static int
24340: test_xmlBuildRelativeURI(void) {
24341: int test_ret = 0;
24342:
24343: int mem_base;
24344: xmlChar * ret_val;
24345: xmlChar * URI; /* the URI reference under consideration */
24346: int n_URI;
24347: xmlChar * base; /* the base value */
24348: int n_base;
24349:
24350: for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
24351: for (n_base = 0;n_base < gen_nb_const_xmlChar_ptr;n_base++) {
24352: mem_base = xmlMemBlocks();
24353: URI = gen_const_xmlChar_ptr(n_URI, 0);
24354: base = gen_const_xmlChar_ptr(n_base, 1);
24355:
24356: ret_val = xmlBuildRelativeURI((const xmlChar *)URI, (const xmlChar *)base);
24357: desret_xmlChar_ptr(ret_val);
24358: call_tests++;
24359: des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 0);
24360: des_const_xmlChar_ptr(n_base, (const xmlChar *)base, 1);
24361: xmlResetLastError();
24362: if (mem_base != xmlMemBlocks()) {
24363: printf("Leak of %d blocks found in xmlBuildRelativeURI",
24364: xmlMemBlocks() - mem_base);
24365: test_ret++;
24366: printf(" %d", n_URI);
24367: printf(" %d", n_base);
24368: printf("\n");
24369: }
24370: }
24371: }
24372: function_tests++;
24373:
24374: return(test_ret);
24375: }
24376:
24377:
24378: static int
24379: test_xmlBuildURI(void) {
24380: int test_ret = 0;
24381:
24382: int mem_base;
24383: xmlChar * ret_val;
24384: xmlChar * URI; /* the URI instance found in the document */
24385: int n_URI;
24386: xmlChar * base; /* the base value */
24387: int n_base;
24388:
24389: for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
24390: for (n_base = 0;n_base < gen_nb_const_xmlChar_ptr;n_base++) {
24391: mem_base = xmlMemBlocks();
24392: URI = gen_const_xmlChar_ptr(n_URI, 0);
24393: base = gen_const_xmlChar_ptr(n_base, 1);
24394:
24395: ret_val = xmlBuildURI((const xmlChar *)URI, (const xmlChar *)base);
24396: desret_xmlChar_ptr(ret_val);
24397: call_tests++;
24398: des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 0);
24399: des_const_xmlChar_ptr(n_base, (const xmlChar *)base, 1);
24400: xmlResetLastError();
24401: if (mem_base != xmlMemBlocks()) {
24402: printf("Leak of %d blocks found in xmlBuildURI",
24403: xmlMemBlocks() - mem_base);
24404: test_ret++;
24405: printf(" %d", n_URI);
24406: printf(" %d", n_base);
24407: printf("\n");
24408: }
24409: }
24410: }
24411: function_tests++;
24412:
24413: return(test_ret);
24414: }
24415:
24416:
24417: static int
24418: test_xmlCanonicPath(void) {
24419: int test_ret = 0;
24420:
24421: int mem_base;
24422: xmlChar * ret_val;
24423: xmlChar * path; /* the resource locator in a filesystem notation */
24424: int n_path;
24425:
24426: for (n_path = 0;n_path < gen_nb_const_xmlChar_ptr;n_path++) {
24427: mem_base = xmlMemBlocks();
24428: path = gen_const_xmlChar_ptr(n_path, 0);
24429:
24430: ret_val = xmlCanonicPath((const xmlChar *)path);
24431: desret_xmlChar_ptr(ret_val);
24432: call_tests++;
24433: des_const_xmlChar_ptr(n_path, (const xmlChar *)path, 0);
24434: xmlResetLastError();
24435: if (mem_base != xmlMemBlocks()) {
24436: printf("Leak of %d blocks found in xmlCanonicPath",
24437: xmlMemBlocks() - mem_base);
24438: test_ret++;
24439: printf(" %d", n_path);
24440: printf("\n");
24441: }
24442: }
24443: function_tests++;
24444:
24445: return(test_ret);
24446: }
24447:
24448:
24449: static int
24450: test_xmlCreateURI(void) {
24451: int test_ret = 0;
24452:
24453:
24454: /* missing type support */
24455: return(test_ret);
24456: }
24457:
24458:
24459: static int
24460: test_xmlNormalizeURIPath(void) {
24461: int test_ret = 0;
24462:
24463: int mem_base;
24464: int ret_val;
24465: char * path; /* pointer to the path string */
24466: int n_path;
24467:
24468: for (n_path = 0;n_path < gen_nb_char_ptr;n_path++) {
24469: mem_base = xmlMemBlocks();
24470: path = gen_char_ptr(n_path, 0);
24471:
24472: ret_val = xmlNormalizeURIPath(path);
24473: desret_int(ret_val);
24474: call_tests++;
24475: des_char_ptr(n_path, path, 0);
24476: xmlResetLastError();
24477: if (mem_base != xmlMemBlocks()) {
24478: printf("Leak of %d blocks found in xmlNormalizeURIPath",
24479: xmlMemBlocks() - mem_base);
24480: test_ret++;
24481: printf(" %d", n_path);
24482: printf("\n");
24483: }
24484: }
24485: function_tests++;
24486:
24487: return(test_ret);
24488: }
24489:
24490:
24491: static int
24492: test_xmlParseURI(void) {
24493: int test_ret = 0;
24494:
24495:
24496: /* missing type support */
24497: return(test_ret);
24498: }
24499:
24500:
24501: static int
24502: test_xmlParseURIRaw(void) {
24503: int test_ret = 0;
24504:
24505:
24506: /* missing type support */
24507: return(test_ret);
24508: }
24509:
24510:
24511: #define gen_nb_xmlURIPtr 1
24512: static xmlURIPtr gen_xmlURIPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24513: return(NULL);
24514: }
24515: static void des_xmlURIPtr(int no ATTRIBUTE_UNUSED, xmlURIPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24516: }
24517:
24518: static int
24519: test_xmlParseURIReference(void) {
24520: int test_ret = 0;
24521:
24522: int mem_base;
24523: int ret_val;
24524: xmlURIPtr uri; /* pointer to an URI structure */
24525: int n_uri;
24526: char * str; /* the string to analyze */
24527: int n_str;
24528:
24529: for (n_uri = 0;n_uri < gen_nb_xmlURIPtr;n_uri++) {
24530: for (n_str = 0;n_str < gen_nb_const_char_ptr;n_str++) {
24531: mem_base = xmlMemBlocks();
24532: uri = gen_xmlURIPtr(n_uri, 0);
24533: str = gen_const_char_ptr(n_str, 1);
24534:
24535: ret_val = xmlParseURIReference(uri, (const char *)str);
24536: desret_int(ret_val);
24537: call_tests++;
24538: des_xmlURIPtr(n_uri, uri, 0);
24539: des_const_char_ptr(n_str, (const char *)str, 1);
24540: xmlResetLastError();
24541: if (mem_base != xmlMemBlocks()) {
24542: printf("Leak of %d blocks found in xmlParseURIReference",
24543: xmlMemBlocks() - mem_base);
24544: test_ret++;
24545: printf(" %d", n_uri);
24546: printf(" %d", n_str);
24547: printf("\n");
24548: }
24549: }
24550: }
24551: function_tests++;
24552:
24553: return(test_ret);
24554: }
24555:
24556:
24557: static int
24558: test_xmlPathToURI(void) {
24559: int test_ret = 0;
24560:
24561: int mem_base;
24562: xmlChar * ret_val;
24563: xmlChar * path; /* the resource locator in a filesystem notation */
24564: int n_path;
24565:
24566: for (n_path = 0;n_path < gen_nb_const_xmlChar_ptr;n_path++) {
24567: mem_base = xmlMemBlocks();
24568: path = gen_const_xmlChar_ptr(n_path, 0);
24569:
24570: ret_val = xmlPathToURI((const xmlChar *)path);
24571: desret_xmlChar_ptr(ret_val);
24572: call_tests++;
24573: des_const_xmlChar_ptr(n_path, (const xmlChar *)path, 0);
24574: xmlResetLastError();
24575: if (mem_base != xmlMemBlocks()) {
24576: printf("Leak of %d blocks found in xmlPathToURI",
24577: xmlMemBlocks() - mem_base);
24578: test_ret++;
24579: printf(" %d", n_path);
24580: printf("\n");
24581: }
24582: }
24583: function_tests++;
24584:
24585: return(test_ret);
24586: }
24587:
24588:
24589: static int
24590: test_xmlPrintURI(void) {
24591: int test_ret = 0;
24592:
24593: int mem_base;
24594: FILE * stream; /* a FILE* for the output */
24595: int n_stream;
24596: xmlURIPtr uri; /* pointer to an xmlURI */
24597: int n_uri;
24598:
24599: for (n_stream = 0;n_stream < gen_nb_FILE_ptr;n_stream++) {
24600: for (n_uri = 0;n_uri < gen_nb_xmlURIPtr;n_uri++) {
24601: mem_base = xmlMemBlocks();
24602: stream = gen_FILE_ptr(n_stream, 0);
24603: uri = gen_xmlURIPtr(n_uri, 1);
24604:
24605: xmlPrintURI(stream, uri);
24606: call_tests++;
24607: des_FILE_ptr(n_stream, stream, 0);
24608: des_xmlURIPtr(n_uri, uri, 1);
24609: xmlResetLastError();
24610: if (mem_base != xmlMemBlocks()) {
24611: printf("Leak of %d blocks found in xmlPrintURI",
24612: xmlMemBlocks() - mem_base);
24613: test_ret++;
24614: printf(" %d", n_stream);
24615: printf(" %d", n_uri);
24616: printf("\n");
24617: }
24618: }
24619: }
24620: function_tests++;
24621:
24622: return(test_ret);
24623: }
24624:
24625:
24626: static int
24627: test_xmlSaveUri(void) {
24628: int test_ret = 0;
24629:
24630: int mem_base;
24631: xmlChar * ret_val;
24632: xmlURIPtr uri; /* pointer to an xmlURI */
24633: int n_uri;
24634:
24635: for (n_uri = 0;n_uri < gen_nb_xmlURIPtr;n_uri++) {
24636: mem_base = xmlMemBlocks();
24637: uri = gen_xmlURIPtr(n_uri, 0);
24638:
24639: ret_val = xmlSaveUri(uri);
24640: desret_xmlChar_ptr(ret_val);
24641: call_tests++;
24642: des_xmlURIPtr(n_uri, uri, 0);
24643: xmlResetLastError();
24644: if (mem_base != xmlMemBlocks()) {
24645: printf("Leak of %d blocks found in xmlSaveUri",
24646: xmlMemBlocks() - mem_base);
24647: test_ret++;
24648: printf(" %d", n_uri);
24649: printf("\n");
24650: }
24651: }
24652: function_tests++;
24653:
24654: return(test_ret);
24655: }
24656:
24657:
24658: static int
24659: test_xmlURIEscape(void) {
24660: int test_ret = 0;
24661:
24662: int mem_base;
24663: xmlChar * ret_val;
24664: xmlChar * str; /* the string of the URI to escape */
24665: int n_str;
24666:
24667: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
24668: mem_base = xmlMemBlocks();
24669: str = gen_const_xmlChar_ptr(n_str, 0);
24670:
24671: ret_val = xmlURIEscape((const xmlChar *)str);
24672: desret_xmlChar_ptr(ret_val);
24673: call_tests++;
24674: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
24675: xmlResetLastError();
24676: if (mem_base != xmlMemBlocks()) {
24677: printf("Leak of %d blocks found in xmlURIEscape",
24678: xmlMemBlocks() - mem_base);
24679: test_ret++;
24680: printf(" %d", n_str);
24681: printf("\n");
24682: }
24683: }
24684: function_tests++;
24685:
24686: return(test_ret);
24687: }
24688:
24689:
24690: static int
24691: test_xmlURIEscapeStr(void) {
24692: int test_ret = 0;
24693:
24694: int mem_base;
24695: xmlChar * ret_val;
24696: xmlChar * str; /* string to escape */
24697: int n_str;
24698: xmlChar * list; /* exception list string of chars not to escape */
24699: int n_list;
24700:
24701: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
24702: for (n_list = 0;n_list < gen_nb_const_xmlChar_ptr;n_list++) {
24703: mem_base = xmlMemBlocks();
24704: str = gen_const_xmlChar_ptr(n_str, 0);
24705: list = gen_const_xmlChar_ptr(n_list, 1);
24706:
24707: ret_val = xmlURIEscapeStr((const xmlChar *)str, (const xmlChar *)list);
24708: desret_xmlChar_ptr(ret_val);
24709: call_tests++;
24710: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
24711: des_const_xmlChar_ptr(n_list, (const xmlChar *)list, 1);
24712: xmlResetLastError();
24713: if (mem_base != xmlMemBlocks()) {
24714: printf("Leak of %d blocks found in xmlURIEscapeStr",
24715: xmlMemBlocks() - mem_base);
24716: test_ret++;
24717: printf(" %d", n_str);
24718: printf(" %d", n_list);
24719: printf("\n");
24720: }
24721: }
24722: }
24723: function_tests++;
24724:
24725: return(test_ret);
24726: }
24727:
24728:
24729: static int
24730: test_xmlURIUnescapeString(void) {
24731: int test_ret = 0;
24732:
24733:
24734: /* missing type support */
24735: return(test_ret);
24736: }
24737:
24738: static int
24739: test_uri(void) {
24740: int test_ret = 0;
24741:
24742: if (quiet == 0) printf("Testing uri : 10 of 15 functions ...\n");
24743: test_ret += test_xmlBuildRelativeURI();
24744: test_ret += test_xmlBuildURI();
24745: test_ret += test_xmlCanonicPath();
24746: test_ret += test_xmlCreateURI();
24747: test_ret += test_xmlNormalizeURIPath();
24748: test_ret += test_xmlParseURI();
24749: test_ret += test_xmlParseURIRaw();
24750: test_ret += test_xmlParseURIReference();
24751: test_ret += test_xmlPathToURI();
24752: test_ret += test_xmlPrintURI();
24753: test_ret += test_xmlSaveUri();
24754: test_ret += test_xmlURIEscape();
24755: test_ret += test_xmlURIEscapeStr();
24756: test_ret += test_xmlURIUnescapeString();
24757:
24758: if (test_ret != 0)
24759: printf("Module uri: %d errors\n", test_ret);
24760: return(test_ret);
24761: }
24762:
24763: static int
24764: test_xmlAddAttributeDecl(void) {
24765: int test_ret = 0;
24766:
24767: int mem_base;
24768: xmlAttributePtr ret_val;
24769: xmlValidCtxtPtr ctxt; /* the validation context */
24770: int n_ctxt;
24771: xmlDtdPtr dtd; /* pointer to the DTD */
24772: int n_dtd;
24773: xmlChar * elem; /* the element name */
24774: int n_elem;
24775: xmlChar * name; /* the attribute name */
24776: int n_name;
24777: xmlChar * ns; /* the attribute namespace prefix */
24778: int n_ns;
24779: xmlAttributeType type; /* the attribute type */
24780: int n_type;
24781: xmlAttributeDefault def; /* the attribute default type */
24782: int n_def;
24783: xmlChar * defaultValue; /* the attribute default value */
24784: int n_defaultValue;
24785: xmlEnumerationPtr tree; /* if it's an enumeration, the associated list */
24786: int n_tree;
24787:
24788: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
24789: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
24790: for (n_elem = 0;n_elem < gen_nb_const_xmlChar_ptr;n_elem++) {
24791: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
24792: for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) {
24793: for (n_type = 0;n_type < gen_nb_xmlAttributeType;n_type++) {
24794: for (n_def = 0;n_def < gen_nb_xmlAttributeDefault;n_def++) {
24795: for (n_defaultValue = 0;n_defaultValue < gen_nb_const_xmlChar_ptr;n_defaultValue++) {
24796: for (n_tree = 0;n_tree < gen_nb_xmlEnumerationPtr;n_tree++) {
24797: mem_base = xmlMemBlocks();
24798: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
24799: dtd = gen_xmlDtdPtr(n_dtd, 1);
24800: elem = gen_const_xmlChar_ptr(n_elem, 2);
24801: name = gen_const_xmlChar_ptr(n_name, 3);
24802: ns = gen_const_xmlChar_ptr(n_ns, 4);
24803: type = gen_xmlAttributeType(n_type, 5);
24804: def = gen_xmlAttributeDefault(n_def, 6);
24805: defaultValue = gen_const_xmlChar_ptr(n_defaultValue, 7);
24806: tree = gen_xmlEnumerationPtr(n_tree, 8);
24807:
24808: ret_val = xmlAddAttributeDecl(ctxt, dtd, (const xmlChar *)elem, (const xmlChar *)name, (const xmlChar *)ns, type, def, (const xmlChar *)defaultValue, tree);
24809: desret_xmlAttributePtr(ret_val);
24810: call_tests++;
24811: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
24812: des_xmlDtdPtr(n_dtd, dtd, 1);
24813: des_const_xmlChar_ptr(n_elem, (const xmlChar *)elem, 2);
24814: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 3);
24815: des_const_xmlChar_ptr(n_ns, (const xmlChar *)ns, 4);
24816: des_xmlAttributeType(n_type, type, 5);
24817: des_xmlAttributeDefault(n_def, def, 6);
24818: des_const_xmlChar_ptr(n_defaultValue, (const xmlChar *)defaultValue, 7);
24819: des_xmlEnumerationPtr(n_tree, tree, 8);
24820: xmlResetLastError();
24821: if (mem_base != xmlMemBlocks()) {
24822: printf("Leak of %d blocks found in xmlAddAttributeDecl",
24823: xmlMemBlocks() - mem_base);
24824: test_ret++;
24825: printf(" %d", n_ctxt);
24826: printf(" %d", n_dtd);
24827: printf(" %d", n_elem);
24828: printf(" %d", n_name);
24829: printf(" %d", n_ns);
24830: printf(" %d", n_type);
24831: printf(" %d", n_def);
24832: printf(" %d", n_defaultValue);
24833: printf(" %d", n_tree);
24834: printf("\n");
24835: }
24836: }
24837: }
24838: }
24839: }
24840: }
24841: }
24842: }
24843: }
24844: }
24845: function_tests++;
24846:
24847: return(test_ret);
24848: }
24849:
24850:
24851: static int
24852: test_xmlAddElementDecl(void) {
24853: int test_ret = 0;
24854:
24855: int mem_base;
24856: xmlElementPtr ret_val;
24857: xmlValidCtxtPtr ctxt; /* the validation context */
24858: int n_ctxt;
24859: xmlDtdPtr dtd; /* pointer to the DTD */
24860: int n_dtd;
24861: xmlChar * name; /* the entity name */
24862: int n_name;
24863: xmlElementTypeVal type; /* the element type */
24864: int n_type;
24865: xmlElementContentPtr content; /* the element content tree or NULL */
24866: int n_content;
24867:
24868: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
24869: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
24870: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
24871: for (n_type = 0;n_type < gen_nb_xmlElementTypeVal;n_type++) {
24872: for (n_content = 0;n_content < gen_nb_xmlElementContentPtr;n_content++) {
24873: mem_base = xmlMemBlocks();
24874: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
24875: dtd = gen_xmlDtdPtr(n_dtd, 1);
24876: name = gen_const_xmlChar_ptr(n_name, 2);
24877: type = gen_xmlElementTypeVal(n_type, 3);
24878: content = gen_xmlElementContentPtr(n_content, 4);
24879:
24880: ret_val = xmlAddElementDecl(ctxt, dtd, (const xmlChar *)name, type, content);
24881: desret_xmlElementPtr(ret_val);
24882: call_tests++;
24883: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
24884: des_xmlDtdPtr(n_dtd, dtd, 1);
24885: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
24886: des_xmlElementTypeVal(n_type, type, 3);
24887: des_xmlElementContentPtr(n_content, content, 4);
24888: xmlResetLastError();
24889: if (mem_base != xmlMemBlocks()) {
24890: printf("Leak of %d blocks found in xmlAddElementDecl",
24891: xmlMemBlocks() - mem_base);
24892: test_ret++;
24893: printf(" %d", n_ctxt);
24894: printf(" %d", n_dtd);
24895: printf(" %d", n_name);
24896: printf(" %d", n_type);
24897: printf(" %d", n_content);
24898: printf("\n");
24899: }
24900: }
24901: }
24902: }
24903: }
24904: }
24905: function_tests++;
24906:
24907: return(test_ret);
24908: }
24909:
24910:
24911: static int
24912: test_xmlAddID(void) {
24913: int test_ret = 0;
24914:
24915:
24916: /* missing type support */
24917: return(test_ret);
24918: }
24919:
24920:
24921: static int
24922: test_xmlAddNotationDecl(void) {
24923: int test_ret = 0;
24924:
24925:
24926: /* missing type support */
24927: return(test_ret);
24928: }
24929:
24930:
24931: static int
24932: test_xmlAddRef(void) {
24933: int test_ret = 0;
24934:
24935:
24936: /* missing type support */
24937: return(test_ret);
24938: }
24939:
24940:
24941: #define gen_nb_xmlAttributeTablePtr 1
24942: static xmlAttributeTablePtr gen_xmlAttributeTablePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24943: return(NULL);
24944: }
24945: static void des_xmlAttributeTablePtr(int no ATTRIBUTE_UNUSED, xmlAttributeTablePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24946: }
24947:
24948: static int
24949: test_xmlCopyAttributeTable(void) {
24950: int test_ret = 0;
24951:
24952:
24953: /* missing type support */
24954: return(test_ret);
24955: }
24956:
24957:
24958: static int
24959: test_xmlCopyDocElementContent(void) {
24960: int test_ret = 0;
24961:
24962: int mem_base;
24963: xmlElementContentPtr ret_val;
24964: xmlDocPtr doc; /* the document owning the element declaration */
24965: int n_doc;
24966: xmlElementContentPtr cur; /* An element content pointer. */
24967: int n_cur;
24968:
24969: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
24970: for (n_cur = 0;n_cur < gen_nb_xmlElementContentPtr;n_cur++) {
24971: mem_base = xmlMemBlocks();
24972: doc = gen_xmlDocPtr(n_doc, 0);
24973: cur = gen_xmlElementContentPtr(n_cur, 1);
24974:
24975: ret_val = xmlCopyDocElementContent(doc, cur);
24976: desret_xmlElementContentPtr(ret_val);
24977: call_tests++;
24978: des_xmlDocPtr(n_doc, doc, 0);
24979: des_xmlElementContentPtr(n_cur, cur, 1);
24980: xmlResetLastError();
24981: if (mem_base != xmlMemBlocks()) {
24982: printf("Leak of %d blocks found in xmlCopyDocElementContent",
24983: xmlMemBlocks() - mem_base);
24984: test_ret++;
24985: printf(" %d", n_doc);
24986: printf(" %d", n_cur);
24987: printf("\n");
24988: }
24989: }
24990: }
24991: function_tests++;
24992:
24993: return(test_ret);
24994: }
24995:
24996:
24997: static int
24998: test_xmlCopyElementContent(void) {
24999: int test_ret = 0;
25000:
25001: int mem_base;
25002: xmlElementContentPtr ret_val;
25003: xmlElementContentPtr cur; /* An element content pointer. */
25004: int n_cur;
25005:
25006: for (n_cur = 0;n_cur < gen_nb_xmlElementContentPtr;n_cur++) {
25007: mem_base = xmlMemBlocks();
25008: cur = gen_xmlElementContentPtr(n_cur, 0);
25009:
25010: ret_val = xmlCopyElementContent(cur);
25011: desret_xmlElementContentPtr(ret_val);
25012: call_tests++;
25013: des_xmlElementContentPtr(n_cur, cur, 0);
25014: xmlResetLastError();
25015: if (mem_base != xmlMemBlocks()) {
25016: printf("Leak of %d blocks found in xmlCopyElementContent",
25017: xmlMemBlocks() - mem_base);
25018: test_ret++;
25019: printf(" %d", n_cur);
25020: printf("\n");
25021: }
25022: }
25023: function_tests++;
25024:
25025: return(test_ret);
25026: }
25027:
25028:
25029: #define gen_nb_xmlElementTablePtr 1
25030: static xmlElementTablePtr gen_xmlElementTablePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
25031: return(NULL);
25032: }
25033: static void des_xmlElementTablePtr(int no ATTRIBUTE_UNUSED, xmlElementTablePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
25034: }
25035:
25036: static int
25037: test_xmlCopyElementTable(void) {
25038: int test_ret = 0;
25039:
25040:
25041: /* missing type support */
25042: return(test_ret);
25043: }
25044:
25045:
25046: static int
25047: test_xmlCopyEnumeration(void) {
25048: int test_ret = 0;
25049:
25050:
25051: /* missing type support */
25052: return(test_ret);
25053: }
25054:
25055:
25056: #define gen_nb_xmlNotationTablePtr 1
25057: static xmlNotationTablePtr gen_xmlNotationTablePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
25058: return(NULL);
25059: }
25060: static void des_xmlNotationTablePtr(int no ATTRIBUTE_UNUSED, xmlNotationTablePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
25061: }
25062:
25063: static int
25064: test_xmlCopyNotationTable(void) {
25065: int test_ret = 0;
25066:
25067:
25068: /* missing type support */
25069: return(test_ret);
25070: }
25071:
25072:
25073: static int
25074: test_xmlCreateEnumeration(void) {
25075: int test_ret = 0;
25076:
25077:
25078: /* missing type support */
25079: return(test_ret);
25080: }
25081:
25082:
25083: #define gen_nb_xmlAttributePtr 1
25084: static xmlAttributePtr gen_xmlAttributePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
25085: return(NULL);
25086: }
25087: static void des_xmlAttributePtr(int no ATTRIBUTE_UNUSED, xmlAttributePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
25088: }
25089:
25090: static int
25091: test_xmlDumpAttributeDecl(void) {
25092: int test_ret = 0;
25093:
25094: #if defined(LIBXML_OUTPUT_ENABLED)
25095: int mem_base;
25096: xmlBufferPtr buf; /* the XML buffer output */
25097: int n_buf;
25098: xmlAttributePtr attr; /* An attribute declaration */
25099: int n_attr;
25100:
25101: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
25102: for (n_attr = 0;n_attr < gen_nb_xmlAttributePtr;n_attr++) {
25103: mem_base = xmlMemBlocks();
25104: buf = gen_xmlBufferPtr(n_buf, 0);
25105: attr = gen_xmlAttributePtr(n_attr, 1);
25106:
25107: xmlDumpAttributeDecl(buf, attr);
25108: call_tests++;
25109: des_xmlBufferPtr(n_buf, buf, 0);
25110: des_xmlAttributePtr(n_attr, attr, 1);
25111: xmlResetLastError();
25112: if (mem_base != xmlMemBlocks()) {
25113: printf("Leak of %d blocks found in xmlDumpAttributeDecl",
25114: xmlMemBlocks() - mem_base);
25115: test_ret++;
25116: printf(" %d", n_buf);
25117: printf(" %d", n_attr);
25118: printf("\n");
25119: }
25120: }
25121: }
25122: function_tests++;
25123: #endif
25124:
25125: return(test_ret);
25126: }
25127:
25128:
25129: static int
25130: test_xmlDumpAttributeTable(void) {
25131: int test_ret = 0;
25132:
25133: #if defined(LIBXML_OUTPUT_ENABLED)
25134: int mem_base;
25135: xmlBufferPtr buf; /* the XML buffer output */
25136: int n_buf;
25137: xmlAttributeTablePtr table; /* An attribute table */
25138: int n_table;
25139:
25140: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
25141: for (n_table = 0;n_table < gen_nb_xmlAttributeTablePtr;n_table++) {
25142: mem_base = xmlMemBlocks();
25143: buf = gen_xmlBufferPtr(n_buf, 0);
25144: table = gen_xmlAttributeTablePtr(n_table, 1);
25145:
25146: xmlDumpAttributeTable(buf, table);
25147: call_tests++;
25148: des_xmlBufferPtr(n_buf, buf, 0);
25149: des_xmlAttributeTablePtr(n_table, table, 1);
25150: xmlResetLastError();
25151: if (mem_base != xmlMemBlocks()) {
25152: printf("Leak of %d blocks found in xmlDumpAttributeTable",
25153: xmlMemBlocks() - mem_base);
25154: test_ret++;
25155: printf(" %d", n_buf);
25156: printf(" %d", n_table);
25157: printf("\n");
25158: }
25159: }
25160: }
25161: function_tests++;
25162: #endif
25163:
25164: return(test_ret);
25165: }
25166:
25167:
25168: #define gen_nb_xmlElementPtr 1
25169: static xmlElementPtr gen_xmlElementPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
25170: return(NULL);
25171: }
25172: static void des_xmlElementPtr(int no ATTRIBUTE_UNUSED, xmlElementPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
25173: }
25174:
25175: static int
25176: test_xmlDumpElementDecl(void) {
25177: int test_ret = 0;
25178:
25179: #if defined(LIBXML_OUTPUT_ENABLED)
25180: int mem_base;
25181: xmlBufferPtr buf; /* the XML buffer output */
25182: int n_buf;
25183: xmlElementPtr elem; /* An element table */
25184: int n_elem;
25185:
25186: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
25187: for (n_elem = 0;n_elem < gen_nb_xmlElementPtr;n_elem++) {
25188: mem_base = xmlMemBlocks();
25189: buf = gen_xmlBufferPtr(n_buf, 0);
25190: elem = gen_xmlElementPtr(n_elem, 1);
25191:
25192: xmlDumpElementDecl(buf, elem);
25193: call_tests++;
25194: des_xmlBufferPtr(n_buf, buf, 0);
25195: des_xmlElementPtr(n_elem, elem, 1);
25196: xmlResetLastError();
25197: if (mem_base != xmlMemBlocks()) {
25198: printf("Leak of %d blocks found in xmlDumpElementDecl",
25199: xmlMemBlocks() - mem_base);
25200: test_ret++;
25201: printf(" %d", n_buf);
25202: printf(" %d", n_elem);
25203: printf("\n");
25204: }
25205: }
25206: }
25207: function_tests++;
25208: #endif
25209:
25210: return(test_ret);
25211: }
25212:
25213:
25214: static int
25215: test_xmlDumpElementTable(void) {
25216: int test_ret = 0;
25217:
25218: #if defined(LIBXML_OUTPUT_ENABLED)
25219: int mem_base;
25220: xmlBufferPtr buf; /* the XML buffer output */
25221: int n_buf;
25222: xmlElementTablePtr table; /* An element table */
25223: int n_table;
25224:
25225: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
25226: for (n_table = 0;n_table < gen_nb_xmlElementTablePtr;n_table++) {
25227: mem_base = xmlMemBlocks();
25228: buf = gen_xmlBufferPtr(n_buf, 0);
25229: table = gen_xmlElementTablePtr(n_table, 1);
25230:
25231: xmlDumpElementTable(buf, table);
25232: call_tests++;
25233: des_xmlBufferPtr(n_buf, buf, 0);
25234: des_xmlElementTablePtr(n_table, table, 1);
25235: xmlResetLastError();
25236: if (mem_base != xmlMemBlocks()) {
25237: printf("Leak of %d blocks found in xmlDumpElementTable",
25238: xmlMemBlocks() - mem_base);
25239: test_ret++;
25240: printf(" %d", n_buf);
25241: printf(" %d", n_table);
25242: printf("\n");
25243: }
25244: }
25245: }
25246: function_tests++;
25247: #endif
25248:
25249: return(test_ret);
25250: }
25251:
25252:
25253: #define gen_nb_xmlNotationPtr 1
25254: static xmlNotationPtr gen_xmlNotationPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
25255: return(NULL);
25256: }
25257: static void des_xmlNotationPtr(int no ATTRIBUTE_UNUSED, xmlNotationPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
25258: }
25259:
25260: static int
25261: test_xmlDumpNotationDecl(void) {
25262: int test_ret = 0;
25263:
25264: #if defined(LIBXML_OUTPUT_ENABLED)
25265: int mem_base;
25266: xmlBufferPtr buf; /* the XML buffer output */
25267: int n_buf;
25268: xmlNotationPtr nota; /* A notation declaration */
25269: int n_nota;
25270:
25271: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
25272: for (n_nota = 0;n_nota < gen_nb_xmlNotationPtr;n_nota++) {
25273: mem_base = xmlMemBlocks();
25274: buf = gen_xmlBufferPtr(n_buf, 0);
25275: nota = gen_xmlNotationPtr(n_nota, 1);
25276:
25277: xmlDumpNotationDecl(buf, nota);
25278: call_tests++;
25279: des_xmlBufferPtr(n_buf, buf, 0);
25280: des_xmlNotationPtr(n_nota, nota, 1);
25281: xmlResetLastError();
25282: if (mem_base != xmlMemBlocks()) {
25283: printf("Leak of %d blocks found in xmlDumpNotationDecl",
25284: xmlMemBlocks() - mem_base);
25285: test_ret++;
25286: printf(" %d", n_buf);
25287: printf(" %d", n_nota);
25288: printf("\n");
25289: }
25290: }
25291: }
25292: function_tests++;
25293: #endif
25294:
25295: return(test_ret);
25296: }
25297:
25298:
25299: static int
25300: test_xmlDumpNotationTable(void) {
25301: int test_ret = 0;
25302:
25303: #if defined(LIBXML_OUTPUT_ENABLED)
25304: int mem_base;
25305: xmlBufferPtr buf; /* the XML buffer output */
25306: int n_buf;
25307: xmlNotationTablePtr table; /* A notation table */
25308: int n_table;
25309:
25310: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
25311: for (n_table = 0;n_table < gen_nb_xmlNotationTablePtr;n_table++) {
25312: mem_base = xmlMemBlocks();
25313: buf = gen_xmlBufferPtr(n_buf, 0);
25314: table = gen_xmlNotationTablePtr(n_table, 1);
25315:
25316: xmlDumpNotationTable(buf, table);
25317: call_tests++;
25318: des_xmlBufferPtr(n_buf, buf, 0);
25319: des_xmlNotationTablePtr(n_table, table, 1);
25320: xmlResetLastError();
25321: if (mem_base != xmlMemBlocks()) {
25322: printf("Leak of %d blocks found in xmlDumpNotationTable",
25323: xmlMemBlocks() - mem_base);
25324: test_ret++;
25325: printf(" %d", n_buf);
25326: printf(" %d", n_table);
25327: printf("\n");
25328: }
25329: }
25330: }
25331: function_tests++;
25332: #endif
25333:
25334: return(test_ret);
25335: }
25336:
25337:
25338: static int
25339: test_xmlGetDtdAttrDesc(void) {
25340: int test_ret = 0;
25341:
25342: int mem_base;
25343: xmlAttributePtr ret_val;
25344: xmlDtdPtr dtd; /* a pointer to the DtD to search */
25345: int n_dtd;
25346: xmlChar * elem; /* the element name */
25347: int n_elem;
25348: xmlChar * name; /* the attribute name */
25349: int n_name;
25350:
25351: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
25352: for (n_elem = 0;n_elem < gen_nb_const_xmlChar_ptr;n_elem++) {
25353: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
25354: mem_base = xmlMemBlocks();
25355: dtd = gen_xmlDtdPtr(n_dtd, 0);
25356: elem = gen_const_xmlChar_ptr(n_elem, 1);
25357: name = gen_const_xmlChar_ptr(n_name, 2);
25358:
25359: ret_val = xmlGetDtdAttrDesc(dtd, (const xmlChar *)elem, (const xmlChar *)name);
25360: desret_xmlAttributePtr(ret_val);
25361: call_tests++;
25362: des_xmlDtdPtr(n_dtd, dtd, 0);
25363: des_const_xmlChar_ptr(n_elem, (const xmlChar *)elem, 1);
25364: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
25365: xmlResetLastError();
25366: if (mem_base != xmlMemBlocks()) {
25367: printf("Leak of %d blocks found in xmlGetDtdAttrDesc",
25368: xmlMemBlocks() - mem_base);
25369: test_ret++;
25370: printf(" %d", n_dtd);
25371: printf(" %d", n_elem);
25372: printf(" %d", n_name);
25373: printf("\n");
25374: }
25375: }
25376: }
25377: }
25378: function_tests++;
25379:
25380: return(test_ret);
25381: }
25382:
25383:
25384: static int
25385: test_xmlGetDtdElementDesc(void) {
25386: int test_ret = 0;
25387:
25388: int mem_base;
25389: xmlElementPtr ret_val;
25390: xmlDtdPtr dtd; /* a pointer to the DtD to search */
25391: int n_dtd;
25392: xmlChar * name; /* the element name */
25393: int n_name;
25394:
25395: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
25396: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
25397: mem_base = xmlMemBlocks();
25398: dtd = gen_xmlDtdPtr(n_dtd, 0);
25399: name = gen_const_xmlChar_ptr(n_name, 1);
25400:
25401: ret_val = xmlGetDtdElementDesc(dtd, (const xmlChar *)name);
25402: desret_xmlElementPtr(ret_val);
25403: call_tests++;
25404: des_xmlDtdPtr(n_dtd, dtd, 0);
25405: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
25406: xmlResetLastError();
25407: if (mem_base != xmlMemBlocks()) {
25408: printf("Leak of %d blocks found in xmlGetDtdElementDesc",
25409: xmlMemBlocks() - mem_base);
25410: test_ret++;
25411: printf(" %d", n_dtd);
25412: printf(" %d", n_name);
25413: printf("\n");
25414: }
25415: }
25416: }
25417: function_tests++;
25418:
25419: return(test_ret);
25420: }
25421:
25422:
25423: static int
25424: test_xmlGetDtdNotationDesc(void) {
25425: int test_ret = 0;
25426:
25427:
25428: /* missing type support */
25429: return(test_ret);
25430: }
25431:
25432:
25433: static int
25434: test_xmlGetDtdQAttrDesc(void) {
25435: int test_ret = 0;
25436:
25437: int mem_base;
25438: xmlAttributePtr ret_val;
25439: xmlDtdPtr dtd; /* a pointer to the DtD to search */
25440: int n_dtd;
25441: xmlChar * elem; /* the element name */
25442: int n_elem;
25443: xmlChar * name; /* the attribute name */
25444: int n_name;
25445: xmlChar * prefix; /* the attribute namespace prefix */
25446: int n_prefix;
25447:
25448: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
25449: for (n_elem = 0;n_elem < gen_nb_const_xmlChar_ptr;n_elem++) {
25450: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
25451: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
25452: mem_base = xmlMemBlocks();
25453: dtd = gen_xmlDtdPtr(n_dtd, 0);
25454: elem = gen_const_xmlChar_ptr(n_elem, 1);
25455: name = gen_const_xmlChar_ptr(n_name, 2);
25456: prefix = gen_const_xmlChar_ptr(n_prefix, 3);
25457:
25458: ret_val = xmlGetDtdQAttrDesc(dtd, (const xmlChar *)elem, (const xmlChar *)name, (const xmlChar *)prefix);
25459: desret_xmlAttributePtr(ret_val);
25460: call_tests++;
25461: des_xmlDtdPtr(n_dtd, dtd, 0);
25462: des_const_xmlChar_ptr(n_elem, (const xmlChar *)elem, 1);
25463: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
25464: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 3);
25465: xmlResetLastError();
25466: if (mem_base != xmlMemBlocks()) {
25467: printf("Leak of %d blocks found in xmlGetDtdQAttrDesc",
25468: xmlMemBlocks() - mem_base);
25469: test_ret++;
25470: printf(" %d", n_dtd);
25471: printf(" %d", n_elem);
25472: printf(" %d", n_name);
25473: printf(" %d", n_prefix);
25474: printf("\n");
25475: }
25476: }
25477: }
25478: }
25479: }
25480: function_tests++;
25481:
25482: return(test_ret);
25483: }
25484:
25485:
25486: static int
25487: test_xmlGetDtdQElementDesc(void) {
25488: int test_ret = 0;
25489:
25490: int mem_base;
25491: xmlElementPtr ret_val;
25492: xmlDtdPtr dtd; /* a pointer to the DtD to search */
25493: int n_dtd;
25494: xmlChar * name; /* the element name */
25495: int n_name;
25496: xmlChar * prefix; /* the element namespace prefix */
25497: int n_prefix;
25498:
25499: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
25500: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
25501: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
25502: mem_base = xmlMemBlocks();
25503: dtd = gen_xmlDtdPtr(n_dtd, 0);
25504: name = gen_const_xmlChar_ptr(n_name, 1);
25505: prefix = gen_const_xmlChar_ptr(n_prefix, 2);
25506:
25507: ret_val = xmlGetDtdQElementDesc(dtd, (const xmlChar *)name, (const xmlChar *)prefix);
25508: desret_xmlElementPtr(ret_val);
25509: call_tests++;
25510: des_xmlDtdPtr(n_dtd, dtd, 0);
25511: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
25512: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 2);
25513: xmlResetLastError();
25514: if (mem_base != xmlMemBlocks()) {
25515: printf("Leak of %d blocks found in xmlGetDtdQElementDesc",
25516: xmlMemBlocks() - mem_base);
25517: test_ret++;
25518: printf(" %d", n_dtd);
25519: printf(" %d", n_name);
25520: printf(" %d", n_prefix);
25521: printf("\n");
25522: }
25523: }
25524: }
25525: }
25526: function_tests++;
25527:
25528: return(test_ret);
25529: }
25530:
25531:
25532: static int
25533: test_xmlGetID(void) {
25534: int test_ret = 0;
25535:
25536: int mem_base;
25537: xmlAttrPtr ret_val;
25538: xmlDocPtr doc; /* pointer to the document */
25539: int n_doc;
25540: xmlChar * ID; /* the ID value */
25541: int n_ID;
25542:
25543: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
25544: for (n_ID = 0;n_ID < gen_nb_const_xmlChar_ptr;n_ID++) {
25545: mem_base = xmlMemBlocks();
25546: doc = gen_xmlDocPtr(n_doc, 0);
25547: ID = gen_const_xmlChar_ptr(n_ID, 1);
25548:
25549: ret_val = xmlGetID(doc, (const xmlChar *)ID);
25550: desret_xmlAttrPtr(ret_val);
25551: call_tests++;
25552: des_xmlDocPtr(n_doc, doc, 0);
25553: des_const_xmlChar_ptr(n_ID, (const xmlChar *)ID, 1);
25554: xmlResetLastError();
25555: if (mem_base != xmlMemBlocks()) {
25556: printf("Leak of %d blocks found in xmlGetID",
25557: xmlMemBlocks() - mem_base);
25558: test_ret++;
25559: printf(" %d", n_doc);
25560: printf(" %d", n_ID);
25561: printf("\n");
25562: }
25563: }
25564: }
25565: function_tests++;
25566:
25567: return(test_ret);
25568: }
25569:
25570:
25571: static int
25572: test_xmlGetRefs(void) {
25573: int test_ret = 0;
25574:
25575:
25576: /* missing type support */
25577: return(test_ret);
25578: }
25579:
25580:
25581: static int
25582: test_xmlIsID(void) {
25583: int test_ret = 0;
25584:
25585: int mem_base;
25586: int ret_val;
25587: xmlDocPtr doc; /* the document */
25588: int n_doc;
25589: xmlNodePtr elem; /* the element carrying the attribute */
25590: int n_elem;
25591: xmlAttrPtr attr; /* the attribute */
25592: int n_attr;
25593:
25594: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
25595: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
25596: for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
25597: mem_base = xmlMemBlocks();
25598: doc = gen_xmlDocPtr(n_doc, 0);
25599: elem = gen_xmlNodePtr(n_elem, 1);
25600: attr = gen_xmlAttrPtr(n_attr, 2);
25601:
25602: ret_val = xmlIsID(doc, elem, attr);
25603: desret_int(ret_val);
25604: call_tests++;
25605: des_xmlDocPtr(n_doc, doc, 0);
25606: des_xmlNodePtr(n_elem, elem, 1);
25607: des_xmlAttrPtr(n_attr, attr, 2);
25608: xmlResetLastError();
25609: if (mem_base != xmlMemBlocks()) {
25610: printf("Leak of %d blocks found in xmlIsID",
25611: xmlMemBlocks() - mem_base);
25612: test_ret++;
25613: printf(" %d", n_doc);
25614: printf(" %d", n_elem);
25615: printf(" %d", n_attr);
25616: printf("\n");
25617: }
25618: }
25619: }
25620: }
25621: function_tests++;
25622:
25623: return(test_ret);
25624: }
25625:
25626:
25627: static int
25628: test_xmlIsMixedElement(void) {
25629: int test_ret = 0;
25630:
25631: int mem_base;
25632: int ret_val;
25633: xmlDocPtr doc; /* the document */
25634: int n_doc;
25635: xmlChar * name; /* the element name */
25636: int n_name;
25637:
25638: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
25639: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
25640: mem_base = xmlMemBlocks();
25641: doc = gen_xmlDocPtr(n_doc, 0);
25642: name = gen_const_xmlChar_ptr(n_name, 1);
25643:
25644: ret_val = xmlIsMixedElement(doc, (const xmlChar *)name);
25645: desret_int(ret_val);
25646: call_tests++;
25647: des_xmlDocPtr(n_doc, doc, 0);
25648: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
25649: xmlResetLastError();
25650: if (mem_base != xmlMemBlocks()) {
25651: printf("Leak of %d blocks found in xmlIsMixedElement",
25652: xmlMemBlocks() - mem_base);
25653: test_ret++;
25654: printf(" %d", n_doc);
25655: printf(" %d", n_name);
25656: printf("\n");
25657: }
25658: }
25659: }
25660: function_tests++;
25661:
25662: return(test_ret);
25663: }
25664:
25665:
25666: static int
25667: test_xmlIsRef(void) {
25668: int test_ret = 0;
25669:
25670: int mem_base;
25671: int ret_val;
25672: xmlDocPtr doc; /* the document */
25673: int n_doc;
25674: xmlNodePtr elem; /* the element carrying the attribute */
25675: int n_elem;
25676: xmlAttrPtr attr; /* the attribute */
25677: int n_attr;
25678:
25679: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
25680: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
25681: for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
25682: mem_base = xmlMemBlocks();
25683: doc = gen_xmlDocPtr(n_doc, 0);
25684: elem = gen_xmlNodePtr(n_elem, 1);
25685: attr = gen_xmlAttrPtr(n_attr, 2);
25686:
25687: ret_val = xmlIsRef(doc, elem, attr);
25688: desret_int(ret_val);
25689: call_tests++;
25690: des_xmlDocPtr(n_doc, doc, 0);
25691: des_xmlNodePtr(n_elem, elem, 1);
25692: des_xmlAttrPtr(n_attr, attr, 2);
25693: xmlResetLastError();
25694: if (mem_base != xmlMemBlocks()) {
25695: printf("Leak of %d blocks found in xmlIsRef",
25696: xmlMemBlocks() - mem_base);
25697: test_ret++;
25698: printf(" %d", n_doc);
25699: printf(" %d", n_elem);
25700: printf(" %d", n_attr);
25701: printf("\n");
25702: }
25703: }
25704: }
25705: }
25706: function_tests++;
25707:
25708: return(test_ret);
25709: }
25710:
25711:
25712: static int
25713: test_xmlNewDocElementContent(void) {
25714: int test_ret = 0;
25715:
25716: int mem_base;
25717: xmlElementContentPtr ret_val;
25718: xmlDocPtr doc; /* the document */
25719: int n_doc;
25720: xmlChar * name; /* the subelement name or NULL */
25721: int n_name;
25722: xmlElementContentType type; /* the type of element content decl */
25723: int n_type;
25724:
25725: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
25726: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
25727: for (n_type = 0;n_type < gen_nb_xmlElementContentType;n_type++) {
25728: mem_base = xmlMemBlocks();
25729: doc = gen_xmlDocPtr(n_doc, 0);
25730: name = gen_const_xmlChar_ptr(n_name, 1);
25731: type = gen_xmlElementContentType(n_type, 2);
25732:
25733: ret_val = xmlNewDocElementContent(doc, (const xmlChar *)name, type);
25734: xmlFreeDocElementContent(doc, ret_val); ret_val = NULL;
25735: desret_xmlElementContentPtr(ret_val);
25736: call_tests++;
25737: des_xmlDocPtr(n_doc, doc, 0);
25738: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
25739: des_xmlElementContentType(n_type, type, 2);
25740: xmlResetLastError();
25741: if (mem_base != xmlMemBlocks()) {
25742: printf("Leak of %d blocks found in xmlNewDocElementContent",
25743: xmlMemBlocks() - mem_base);
25744: test_ret++;
25745: printf(" %d", n_doc);
25746: printf(" %d", n_name);
25747: printf(" %d", n_type);
25748: printf("\n");
25749: }
25750: }
25751: }
25752: }
25753: function_tests++;
25754:
25755: return(test_ret);
25756: }
25757:
25758:
25759: static int
25760: test_xmlNewElementContent(void) {
25761: int test_ret = 0;
25762:
25763: int mem_base;
25764: xmlElementContentPtr ret_val;
25765: xmlChar * name; /* the subelement name or NULL */
25766: int n_name;
25767: xmlElementContentType type; /* the type of element content decl */
25768: int n_type;
25769:
25770: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
25771: for (n_type = 0;n_type < gen_nb_xmlElementContentType;n_type++) {
25772: mem_base = xmlMemBlocks();
25773: name = gen_const_xmlChar_ptr(n_name, 0);
25774: type = gen_xmlElementContentType(n_type, 1);
25775:
25776: ret_val = xmlNewElementContent((const xmlChar *)name, type);
25777: desret_xmlElementContentPtr(ret_val);
25778: call_tests++;
25779: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
25780: des_xmlElementContentType(n_type, type, 1);
25781: xmlResetLastError();
25782: if (mem_base != xmlMemBlocks()) {
25783: printf("Leak of %d blocks found in xmlNewElementContent",
25784: xmlMemBlocks() - mem_base);
25785: test_ret++;
25786: printf(" %d", n_name);
25787: printf(" %d", n_type);
25788: printf("\n");
25789: }
25790: }
25791: }
25792: function_tests++;
25793:
25794: return(test_ret);
25795: }
25796:
25797:
25798: static int
25799: test_xmlNewValidCtxt(void) {
25800: int test_ret = 0;
25801:
25802:
25803: /* missing type support */
25804: return(test_ret);
25805: }
25806:
25807:
25808: static int
25809: test_xmlRemoveID(void) {
25810: int test_ret = 0;
25811:
25812: int mem_base;
25813: int ret_val;
25814: xmlDocPtr doc; /* the document */
25815: int n_doc;
25816: xmlAttrPtr attr; /* the attribute */
25817: int n_attr;
25818:
25819: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
25820: for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
25821: mem_base = xmlMemBlocks();
25822: doc = gen_xmlDocPtr(n_doc, 0);
25823: attr = gen_xmlAttrPtr(n_attr, 1);
25824:
25825: ret_val = xmlRemoveID(doc, attr);
25826: desret_int(ret_val);
25827: call_tests++;
25828: des_xmlDocPtr(n_doc, doc, 0);
25829: des_xmlAttrPtr(n_attr, attr, 1);
25830: xmlResetLastError();
25831: if (mem_base != xmlMemBlocks()) {
25832: printf("Leak of %d blocks found in xmlRemoveID",
25833: xmlMemBlocks() - mem_base);
25834: test_ret++;
25835: printf(" %d", n_doc);
25836: printf(" %d", n_attr);
25837: printf("\n");
25838: }
25839: }
25840: }
25841: function_tests++;
25842:
25843: return(test_ret);
25844: }
25845:
25846:
25847: static int
25848: test_xmlRemoveRef(void) {
25849: int test_ret = 0;
25850:
25851: int mem_base;
25852: int ret_val;
25853: xmlDocPtr doc; /* the document */
25854: int n_doc;
25855: xmlAttrPtr attr; /* the attribute */
25856: int n_attr;
25857:
25858: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
25859: for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
25860: mem_base = xmlMemBlocks();
25861: doc = gen_xmlDocPtr(n_doc, 0);
25862: attr = gen_xmlAttrPtr(n_attr, 1);
25863:
25864: ret_val = xmlRemoveRef(doc, attr);
25865: desret_int(ret_val);
25866: call_tests++;
25867: des_xmlDocPtr(n_doc, doc, 0);
25868: des_xmlAttrPtr(n_attr, attr, 1);
25869: xmlResetLastError();
25870: if (mem_base != xmlMemBlocks()) {
25871: printf("Leak of %d blocks found in xmlRemoveRef",
25872: xmlMemBlocks() - mem_base);
25873: test_ret++;
25874: printf(" %d", n_doc);
25875: printf(" %d", n_attr);
25876: printf("\n");
25877: }
25878: }
25879: }
25880: function_tests++;
25881:
25882: return(test_ret);
25883: }
25884:
25885:
25886: static int
25887: test_xmlSnprintfElementContent(void) {
25888: int test_ret = 0;
25889:
25890: int mem_base;
25891: char * buf; /* an output buffer */
25892: int n_buf;
25893: int size; /* the buffer size */
25894: int n_size;
25895: xmlElementContentPtr content; /* An element table */
25896: int n_content;
25897: int englob; /* 1 if one must print the englobing parenthesis, 0 otherwise */
25898: int n_englob;
25899:
25900: for (n_buf = 0;n_buf < gen_nb_char_ptr;n_buf++) {
25901: for (n_size = 0;n_size < gen_nb_int;n_size++) {
25902: for (n_content = 0;n_content < gen_nb_xmlElementContentPtr;n_content++) {
25903: for (n_englob = 0;n_englob < gen_nb_int;n_englob++) {
25904: mem_base = xmlMemBlocks();
25905: buf = gen_char_ptr(n_buf, 0);
25906: size = gen_int(n_size, 1);
25907: content = gen_xmlElementContentPtr(n_content, 2);
25908: englob = gen_int(n_englob, 3);
25909:
25910: xmlSnprintfElementContent(buf, size, content, englob);
25911: call_tests++;
25912: des_char_ptr(n_buf, buf, 0);
25913: des_int(n_size, size, 1);
25914: des_xmlElementContentPtr(n_content, content, 2);
25915: des_int(n_englob, englob, 3);
25916: xmlResetLastError();
25917: if (mem_base != xmlMemBlocks()) {
25918: printf("Leak of %d blocks found in xmlSnprintfElementContent",
25919: xmlMemBlocks() - mem_base);
25920: test_ret++;
25921: printf(" %d", n_buf);
25922: printf(" %d", n_size);
25923: printf(" %d", n_content);
25924: printf(" %d", n_englob);
25925: printf("\n");
25926: }
25927: }
25928: }
25929: }
25930: }
25931: function_tests++;
25932:
25933: return(test_ret);
25934: }
25935:
25936:
25937: static int
25938: test_xmlSprintfElementContent(void) {
25939: int test_ret = 0;
25940:
25941: #if defined(LIBXML_OUTPUT_ENABLED)
25942: #ifdef LIBXML_OUTPUT_ENABLED
25943: int mem_base;
25944: char * buf; /* an output buffer */
25945: int n_buf;
25946: xmlElementContentPtr content; /* An element table */
25947: int n_content;
25948: int englob; /* 1 if one must print the englobing parenthesis, 0 otherwise */
25949: int n_englob;
25950:
25951: for (n_buf = 0;n_buf < gen_nb_char_ptr;n_buf++) {
25952: for (n_content = 0;n_content < gen_nb_xmlElementContentPtr;n_content++) {
25953: for (n_englob = 0;n_englob < gen_nb_int;n_englob++) {
25954: mem_base = xmlMemBlocks();
25955: buf = gen_char_ptr(n_buf, 0);
25956: content = gen_xmlElementContentPtr(n_content, 1);
25957: englob = gen_int(n_englob, 2);
25958:
25959: xmlSprintfElementContent(buf, content, englob);
25960: call_tests++;
25961: des_char_ptr(n_buf, buf, 0);
25962: des_xmlElementContentPtr(n_content, content, 1);
25963: des_int(n_englob, englob, 2);
25964: xmlResetLastError();
25965: if (mem_base != xmlMemBlocks()) {
25966: printf("Leak of %d blocks found in xmlSprintfElementContent",
25967: xmlMemBlocks() - mem_base);
25968: test_ret++;
25969: printf(" %d", n_buf);
25970: printf(" %d", n_content);
25971: printf(" %d", n_englob);
25972: printf("\n");
25973: }
25974: }
25975: }
25976: }
25977: function_tests++;
25978: #endif
25979: #endif
25980:
25981: return(test_ret);
25982: }
25983:
25984:
25985: static int
25986: test_xmlValidBuildContentModel(void) {
25987: int test_ret = 0;
25988:
25989: #if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED)
25990: int mem_base;
25991: int ret_val;
25992: xmlValidCtxtPtr ctxt; /* a validation context */
25993: int n_ctxt;
25994: xmlElementPtr elem; /* an element declaration node */
25995: int n_elem;
25996:
25997: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
25998: for (n_elem = 0;n_elem < gen_nb_xmlElementPtr;n_elem++) {
25999: mem_base = xmlMemBlocks();
26000: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26001: elem = gen_xmlElementPtr(n_elem, 1);
26002:
26003: ret_val = xmlValidBuildContentModel(ctxt, elem);
26004: desret_int(ret_val);
26005: call_tests++;
26006: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26007: des_xmlElementPtr(n_elem, elem, 1);
26008: xmlResetLastError();
26009: if (mem_base != xmlMemBlocks()) {
26010: printf("Leak of %d blocks found in xmlValidBuildContentModel",
26011: xmlMemBlocks() - mem_base);
26012: test_ret++;
26013: printf(" %d", n_ctxt);
26014: printf(" %d", n_elem);
26015: printf("\n");
26016: }
26017: }
26018: }
26019: function_tests++;
26020: #endif
26021:
26022: return(test_ret);
26023: }
26024:
26025:
26026: static int
26027: test_xmlValidCtxtNormalizeAttributeValue(void) {
26028: int test_ret = 0;
26029:
26030: #if defined(LIBXML_VALID_ENABLED)
26031: int mem_base;
26032: xmlChar * ret_val;
26033: xmlValidCtxtPtr ctxt; /* the validation context or NULL */
26034: int n_ctxt;
26035: xmlDocPtr doc; /* the document */
26036: int n_doc;
26037: xmlNodePtr elem; /* the parent */
26038: int n_elem;
26039: xmlChar * name; /* the attribute name */
26040: int n_name;
26041: xmlChar * value; /* the attribute value */
26042: int n_value;
26043:
26044: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26045: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26046: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
26047: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
26048: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
26049: mem_base = xmlMemBlocks();
26050: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26051: doc = gen_xmlDocPtr(n_doc, 1);
26052: elem = gen_xmlNodePtr(n_elem, 2);
26053: name = gen_const_xmlChar_ptr(n_name, 3);
26054: value = gen_const_xmlChar_ptr(n_value, 4);
26055:
26056: ret_val = xmlValidCtxtNormalizeAttributeValue(ctxt, doc, elem, (const xmlChar *)name, (const xmlChar *)value);
26057: desret_xmlChar_ptr(ret_val);
26058: call_tests++;
26059: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26060: des_xmlDocPtr(n_doc, doc, 1);
26061: des_xmlNodePtr(n_elem, elem, 2);
26062: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 3);
26063: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 4);
26064: xmlResetLastError();
26065: if (mem_base != xmlMemBlocks()) {
26066: printf("Leak of %d blocks found in xmlValidCtxtNormalizeAttributeValue",
26067: xmlMemBlocks() - mem_base);
26068: test_ret++;
26069: printf(" %d", n_ctxt);
26070: printf(" %d", n_doc);
26071: printf(" %d", n_elem);
26072: printf(" %d", n_name);
26073: printf(" %d", n_value);
26074: printf("\n");
26075: }
26076: }
26077: }
26078: }
26079: }
26080: }
26081: function_tests++;
26082: #endif
26083:
26084: return(test_ret);
26085: }
26086:
26087:
26088: #define gen_nb_xmlElementContent_ptr 1
26089: static xmlElementContent * gen_xmlElementContent_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
26090: return(NULL);
26091: }
26092: static void des_xmlElementContent_ptr(int no ATTRIBUTE_UNUSED, xmlElementContent * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
26093: }
26094:
26095: static int
26096: test_xmlValidGetPotentialChildren(void) {
26097: int test_ret = 0;
26098:
26099: #if defined(LIBXML_VALID_ENABLED)
26100: #ifdef LIBXML_VALID_ENABLED
26101: int mem_base;
26102: int ret_val;
26103: xmlElementContent * ctree; /* an element content tree */
26104: int n_ctree;
26105: xmlChar ** names; /* an array to store the list of child names */
26106: int n_names;
26107: int * len; /* a pointer to the number of element in the list */
26108: int n_len;
26109: int max; /* the size of the array */
26110: int n_max;
26111:
26112: for (n_ctree = 0;n_ctree < gen_nb_xmlElementContent_ptr;n_ctree++) {
26113: for (n_names = 0;n_names < gen_nb_const_xmlChar_ptr_ptr;n_names++) {
26114: for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
26115: for (n_max = 0;n_max < gen_nb_int;n_max++) {
26116: mem_base = xmlMemBlocks();
26117: ctree = gen_xmlElementContent_ptr(n_ctree, 0);
26118: names = gen_const_xmlChar_ptr_ptr(n_names, 1);
26119: len = gen_int_ptr(n_len, 2);
26120: max = gen_int(n_max, 3);
26121:
26122: ret_val = xmlValidGetPotentialChildren(ctree, (const xmlChar **)names, len, max);
26123: desret_int(ret_val);
26124: call_tests++;
26125: des_xmlElementContent_ptr(n_ctree, ctree, 0);
26126: des_const_xmlChar_ptr_ptr(n_names, (const xmlChar **)names, 1);
26127: des_int_ptr(n_len, len, 2);
26128: des_int(n_max, max, 3);
26129: xmlResetLastError();
26130: if (mem_base != xmlMemBlocks()) {
26131: printf("Leak of %d blocks found in xmlValidGetPotentialChildren",
26132: xmlMemBlocks() - mem_base);
26133: test_ret++;
26134: printf(" %d", n_ctree);
26135: printf(" %d", n_names);
26136: printf(" %d", n_len);
26137: printf(" %d", n_max);
26138: printf("\n");
26139: }
26140: }
26141: }
26142: }
26143: }
26144: function_tests++;
26145: #endif
26146: #endif
26147:
26148: return(test_ret);
26149: }
26150:
26151:
26152: static int
26153: test_xmlValidGetValidElements(void) {
26154: int test_ret = 0;
26155:
26156: #if defined(LIBXML_VALID_ENABLED)
26157: #ifdef LIBXML_VALID_ENABLED
26158: int mem_base;
26159: int ret_val;
26160: xmlNode * prev; /* an element to insert after */
26161: int n_prev;
26162: xmlNode * next; /* an element to insert next */
26163: int n_next;
26164: xmlChar ** names; /* an array to store the list of child names */
26165: int n_names;
26166: int max; /* the size of the array */
26167: int n_max;
26168:
26169: for (n_prev = 0;n_prev < gen_nb_xmlNodePtr;n_prev++) {
26170: for (n_next = 0;n_next < gen_nb_xmlNodePtr;n_next++) {
26171: for (n_names = 0;n_names < gen_nb_const_xmlChar_ptr_ptr;n_names++) {
26172: for (n_max = 0;n_max < gen_nb_int;n_max++) {
26173: mem_base = xmlMemBlocks();
26174: prev = gen_xmlNodePtr(n_prev, 0);
26175: next = gen_xmlNodePtr(n_next, 1);
26176: names = gen_const_xmlChar_ptr_ptr(n_names, 2);
26177: max = gen_int(n_max, 3);
26178:
26179: ret_val = xmlValidGetValidElements(prev, next, (const xmlChar **)names, max);
26180: desret_int(ret_val);
26181: call_tests++;
26182: des_xmlNodePtr(n_prev, prev, 0);
26183: des_xmlNodePtr(n_next, next, 1);
26184: des_const_xmlChar_ptr_ptr(n_names, (const xmlChar **)names, 2);
26185: des_int(n_max, max, 3);
26186: xmlResetLastError();
26187: if (mem_base != xmlMemBlocks()) {
26188: printf("Leak of %d blocks found in xmlValidGetValidElements",
26189: xmlMemBlocks() - mem_base);
26190: test_ret++;
26191: printf(" %d", n_prev);
26192: printf(" %d", n_next);
26193: printf(" %d", n_names);
26194: printf(" %d", n_max);
26195: printf("\n");
26196: }
26197: }
26198: }
26199: }
26200: }
26201: function_tests++;
26202: #endif
26203: #endif
26204:
26205: return(test_ret);
26206: }
26207:
26208:
26209: static int
26210: test_xmlValidNormalizeAttributeValue(void) {
26211: int test_ret = 0;
26212:
26213: #if defined(LIBXML_VALID_ENABLED)
26214: int mem_base;
26215: xmlChar * ret_val;
26216: xmlDocPtr doc; /* the document */
26217: int n_doc;
26218: xmlNodePtr elem; /* the parent */
26219: int n_elem;
26220: xmlChar * name; /* the attribute name */
26221: int n_name;
26222: xmlChar * value; /* the attribute value */
26223: int n_value;
26224:
26225: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26226: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
26227: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
26228: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
26229: mem_base = xmlMemBlocks();
26230: doc = gen_xmlDocPtr(n_doc, 0);
26231: elem = gen_xmlNodePtr(n_elem, 1);
26232: name = gen_const_xmlChar_ptr(n_name, 2);
26233: value = gen_const_xmlChar_ptr(n_value, 3);
26234:
26235: ret_val = xmlValidNormalizeAttributeValue(doc, elem, (const xmlChar *)name, (const xmlChar *)value);
26236: desret_xmlChar_ptr(ret_val);
26237: call_tests++;
26238: des_xmlDocPtr(n_doc, doc, 0);
26239: des_xmlNodePtr(n_elem, elem, 1);
26240: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
26241: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 3);
26242: xmlResetLastError();
26243: if (mem_base != xmlMemBlocks()) {
26244: printf("Leak of %d blocks found in xmlValidNormalizeAttributeValue",
26245: xmlMemBlocks() - mem_base);
26246: test_ret++;
26247: printf(" %d", n_doc);
26248: printf(" %d", n_elem);
26249: printf(" %d", n_name);
26250: printf(" %d", n_value);
26251: printf("\n");
26252: }
26253: }
26254: }
26255: }
26256: }
26257: function_tests++;
26258: #endif
26259:
26260: return(test_ret);
26261: }
26262:
26263:
26264: static int
26265: test_xmlValidateAttributeDecl(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: xmlAttributePtr attr; /* an attribute definition */
26276: int n_attr;
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_attr = 0;n_attr < gen_nb_xmlAttributePtr;n_attr++) {
26281: mem_base = xmlMemBlocks();
26282: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26283: doc = gen_xmlDocPtr(n_doc, 1);
26284: attr = gen_xmlAttributePtr(n_attr, 2);
26285:
26286: ret_val = xmlValidateAttributeDecl(ctxt, doc, attr);
26287: desret_int(ret_val);
26288: call_tests++;
26289: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26290: des_xmlDocPtr(n_doc, doc, 1);
26291: des_xmlAttributePtr(n_attr, attr, 2);
26292: xmlResetLastError();
26293: if (mem_base != xmlMemBlocks()) {
26294: printf("Leak of %d blocks found in xmlValidateAttributeDecl",
26295: xmlMemBlocks() - mem_base);
26296: test_ret++;
26297: printf(" %d", n_ctxt);
26298: printf(" %d", n_doc);
26299: printf(" %d", n_attr);
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_xmlValidateAttributeValue(void) {
26314: int test_ret = 0;
26315:
26316: #if defined(LIBXML_VALID_ENABLED)
26317: int mem_base;
26318: int ret_val;
26319: xmlAttributeType type; /* an attribute type */
26320: int n_type;
26321: xmlChar * value; /* an attribute value */
26322: int n_value;
26323:
26324: for (n_type = 0;n_type < gen_nb_xmlAttributeType;n_type++) {
26325: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
26326: mem_base = xmlMemBlocks();
26327: type = gen_xmlAttributeType(n_type, 0);
26328: value = gen_const_xmlChar_ptr(n_value, 1);
26329:
26330: ret_val = xmlValidateAttributeValue(type, (const xmlChar *)value);
26331: desret_int(ret_val);
26332: call_tests++;
26333: des_xmlAttributeType(n_type, type, 0);
26334: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
26335: xmlResetLastError();
26336: if (mem_base != xmlMemBlocks()) {
26337: printf("Leak of %d blocks found in xmlValidateAttributeValue",
26338: xmlMemBlocks() - mem_base);
26339: test_ret++;
26340: printf(" %d", n_type);
26341: printf(" %d", n_value);
26342: printf("\n");
26343: }
26344: }
26345: }
26346: function_tests++;
26347: #endif
26348:
26349: return(test_ret);
26350: }
26351:
26352:
26353: static int
26354: test_xmlValidateDocument(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:
26365: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26366: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26367: mem_base = xmlMemBlocks();
26368: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26369: doc = gen_xmlDocPtr(n_doc, 1);
26370:
26371: ret_val = xmlValidateDocument(ctxt, doc);
26372: desret_int(ret_val);
26373: call_tests++;
26374: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26375: des_xmlDocPtr(n_doc, doc, 1);
26376: xmlResetLastError();
26377: if (mem_base != xmlMemBlocks()) {
26378: printf("Leak of %d blocks found in xmlValidateDocument",
26379: xmlMemBlocks() - mem_base);
26380: test_ret++;
26381: printf(" %d", n_ctxt);
26382: printf(" %d", n_doc);
26383: printf("\n");
26384: }
26385: }
26386: }
26387: function_tests++;
26388: #endif
26389:
26390: return(test_ret);
26391: }
26392:
26393:
26394: static int
26395: test_xmlValidateDocumentFinal(void) {
26396: int test_ret = 0;
26397:
26398: #if defined(LIBXML_VALID_ENABLED)
26399: int mem_base;
26400: int ret_val;
26401: xmlValidCtxtPtr ctxt; /* the validation context */
26402: int n_ctxt;
26403: xmlDocPtr doc; /* a document instance */
26404: int n_doc;
26405:
26406: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26407: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26408: mem_base = xmlMemBlocks();
26409: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26410: doc = gen_xmlDocPtr(n_doc, 1);
26411:
26412: ret_val = xmlValidateDocumentFinal(ctxt, doc);
26413: desret_int(ret_val);
26414: call_tests++;
26415: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26416: des_xmlDocPtr(n_doc, doc, 1);
26417: xmlResetLastError();
26418: if (mem_base != xmlMemBlocks()) {
26419: printf("Leak of %d blocks found in xmlValidateDocumentFinal",
26420: xmlMemBlocks() - mem_base);
26421: test_ret++;
26422: printf(" %d", n_ctxt);
26423: printf(" %d", n_doc);
26424: printf("\n");
26425: }
26426: }
26427: }
26428: function_tests++;
26429: #endif
26430:
26431: return(test_ret);
26432: }
26433:
26434:
26435: static int
26436: test_xmlValidateDtd(void) {
26437: int test_ret = 0;
26438:
26439: #if defined(LIBXML_VALID_ENABLED)
26440: int mem_base;
26441: int ret_val;
26442: xmlValidCtxtPtr ctxt; /* the validation context */
26443: int n_ctxt;
26444: xmlDocPtr doc; /* a document instance */
26445: int n_doc;
26446: xmlDtdPtr dtd; /* a dtd instance */
26447: int n_dtd;
26448:
26449: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26450: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26451: for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
26452: mem_base = xmlMemBlocks();
26453: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26454: doc = gen_xmlDocPtr(n_doc, 1);
26455: dtd = gen_xmlDtdPtr(n_dtd, 2);
26456:
26457: ret_val = xmlValidateDtd(ctxt, doc, dtd);
26458: desret_int(ret_val);
26459: call_tests++;
26460: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26461: des_xmlDocPtr(n_doc, doc, 1);
26462: des_xmlDtdPtr(n_dtd, dtd, 2);
26463: xmlResetLastError();
26464: if (mem_base != xmlMemBlocks()) {
26465: printf("Leak of %d blocks found in xmlValidateDtd",
26466: xmlMemBlocks() - mem_base);
26467: test_ret++;
26468: printf(" %d", n_ctxt);
26469: printf(" %d", n_doc);
26470: printf(" %d", n_dtd);
26471: printf("\n");
26472: }
26473: }
26474: }
26475: }
26476: function_tests++;
26477: #endif
26478:
26479: return(test_ret);
26480: }
26481:
26482:
26483: static int
26484: test_xmlValidateDtdFinal(void) {
26485: int test_ret = 0;
26486:
26487: #if defined(LIBXML_VALID_ENABLED)
26488: int mem_base;
26489: int ret_val;
26490: xmlValidCtxtPtr ctxt; /* the validation context */
26491: int n_ctxt;
26492: xmlDocPtr doc; /* a document instance */
26493: int n_doc;
26494:
26495: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26496: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26497: mem_base = xmlMemBlocks();
26498: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26499: doc = gen_xmlDocPtr(n_doc, 1);
26500:
26501: ret_val = xmlValidateDtdFinal(ctxt, doc);
26502: desret_int(ret_val);
26503: call_tests++;
26504: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26505: des_xmlDocPtr(n_doc, doc, 1);
26506: xmlResetLastError();
26507: if (mem_base != xmlMemBlocks()) {
26508: printf("Leak of %d blocks found in xmlValidateDtdFinal",
26509: xmlMemBlocks() - mem_base);
26510: test_ret++;
26511: printf(" %d", n_ctxt);
26512: printf(" %d", n_doc);
26513: printf("\n");
26514: }
26515: }
26516: }
26517: function_tests++;
26518: #endif
26519:
26520: return(test_ret);
26521: }
26522:
26523:
26524: static int
26525: test_xmlValidateElement(void) {
26526: int test_ret = 0;
26527:
26528: #if defined(LIBXML_VALID_ENABLED)
26529: int mem_base;
26530: int ret_val;
26531: xmlValidCtxtPtr ctxt; /* the validation context */
26532: int n_ctxt;
26533: xmlDocPtr doc; /* a document instance */
26534: int n_doc;
26535: xmlNodePtr elem; /* an element instance */
26536: int n_elem;
26537:
26538: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26539: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26540: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
26541: mem_base = xmlMemBlocks();
26542: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26543: doc = gen_xmlDocPtr(n_doc, 1);
26544: elem = gen_xmlNodePtr(n_elem, 2);
26545:
26546: ret_val = xmlValidateElement(ctxt, doc, elem);
26547: desret_int(ret_val);
26548: call_tests++;
26549: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26550: des_xmlDocPtr(n_doc, doc, 1);
26551: des_xmlNodePtr(n_elem, elem, 2);
26552: xmlResetLastError();
26553: if (mem_base != xmlMemBlocks()) {
26554: printf("Leak of %d blocks found in xmlValidateElement",
26555: xmlMemBlocks() - mem_base);
26556: test_ret++;
26557: printf(" %d", n_ctxt);
26558: printf(" %d", n_doc);
26559: printf(" %d", n_elem);
26560: printf("\n");
26561: }
26562: }
26563: }
26564: }
26565: function_tests++;
26566: #endif
26567:
26568: return(test_ret);
26569: }
26570:
26571:
26572: static int
26573: test_xmlValidateElementDecl(void) {
26574: int test_ret = 0;
26575:
26576: #if defined(LIBXML_VALID_ENABLED)
26577: int mem_base;
26578: int ret_val;
26579: xmlValidCtxtPtr ctxt; /* the validation context */
26580: int n_ctxt;
26581: xmlDocPtr doc; /* a document instance */
26582: int n_doc;
26583: xmlElementPtr elem; /* an element definition */
26584: int n_elem;
26585:
26586: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26587: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26588: for (n_elem = 0;n_elem < gen_nb_xmlElementPtr;n_elem++) {
26589: mem_base = xmlMemBlocks();
26590: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26591: doc = gen_xmlDocPtr(n_doc, 1);
26592: elem = gen_xmlElementPtr(n_elem, 2);
26593:
26594: ret_val = xmlValidateElementDecl(ctxt, doc, elem);
26595: desret_int(ret_val);
26596: call_tests++;
26597: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26598: des_xmlDocPtr(n_doc, doc, 1);
26599: des_xmlElementPtr(n_elem, elem, 2);
26600: xmlResetLastError();
26601: if (mem_base != xmlMemBlocks()) {
26602: printf("Leak of %d blocks found in xmlValidateElementDecl",
26603: xmlMemBlocks() - mem_base);
26604: test_ret++;
26605: printf(" %d", n_ctxt);
26606: printf(" %d", n_doc);
26607: printf(" %d", n_elem);
26608: printf("\n");
26609: }
26610: }
26611: }
26612: }
26613: function_tests++;
26614: #endif
26615:
26616: return(test_ret);
26617: }
26618:
26619:
26620: static int
26621: test_xmlValidateNameValue(void) {
26622: int test_ret = 0;
26623:
26624: #if defined(LIBXML_VALID_ENABLED)
26625: int mem_base;
26626: int ret_val;
26627: xmlChar * value; /* an Name value */
26628: int n_value;
26629:
26630: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
26631: mem_base = xmlMemBlocks();
26632: value = gen_const_xmlChar_ptr(n_value, 0);
26633:
26634: ret_val = xmlValidateNameValue((const xmlChar *)value);
26635: desret_int(ret_val);
26636: call_tests++;
26637: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
26638: xmlResetLastError();
26639: if (mem_base != xmlMemBlocks()) {
26640: printf("Leak of %d blocks found in xmlValidateNameValue",
26641: xmlMemBlocks() - mem_base);
26642: test_ret++;
26643: printf(" %d", n_value);
26644: printf("\n");
26645: }
26646: }
26647: function_tests++;
26648: #endif
26649:
26650: return(test_ret);
26651: }
26652:
26653:
26654: static int
26655: test_xmlValidateNamesValue(void) {
26656: int test_ret = 0;
26657:
26658: #if defined(LIBXML_VALID_ENABLED)
26659: int mem_base;
26660: int ret_val;
26661: xmlChar * value; /* an Names value */
26662: int n_value;
26663:
26664: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
26665: mem_base = xmlMemBlocks();
26666: value = gen_const_xmlChar_ptr(n_value, 0);
26667:
26668: ret_val = xmlValidateNamesValue((const xmlChar *)value);
26669: desret_int(ret_val);
26670: call_tests++;
26671: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
26672: xmlResetLastError();
26673: if (mem_base != xmlMemBlocks()) {
26674: printf("Leak of %d blocks found in xmlValidateNamesValue",
26675: xmlMemBlocks() - mem_base);
26676: test_ret++;
26677: printf(" %d", n_value);
26678: printf("\n");
26679: }
26680: }
26681: function_tests++;
26682: #endif
26683:
26684: return(test_ret);
26685: }
26686:
26687:
26688: static int
26689: test_xmlValidateNmtokenValue(void) {
26690: int test_ret = 0;
26691:
26692: #if defined(LIBXML_VALID_ENABLED)
26693: int mem_base;
26694: int ret_val;
26695: xmlChar * value; /* an Nmtoken value */
26696: int n_value;
26697:
26698: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
26699: mem_base = xmlMemBlocks();
26700: value = gen_const_xmlChar_ptr(n_value, 0);
26701:
26702: ret_val = xmlValidateNmtokenValue((const xmlChar *)value);
26703: desret_int(ret_val);
26704: call_tests++;
26705: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
26706: xmlResetLastError();
26707: if (mem_base != xmlMemBlocks()) {
26708: printf("Leak of %d blocks found in xmlValidateNmtokenValue",
26709: xmlMemBlocks() - mem_base);
26710: test_ret++;
26711: printf(" %d", n_value);
26712: printf("\n");
26713: }
26714: }
26715: function_tests++;
26716: #endif
26717:
26718: return(test_ret);
26719: }
26720:
26721:
26722: static int
26723: test_xmlValidateNmtokensValue(void) {
26724: int test_ret = 0;
26725:
26726: #if defined(LIBXML_VALID_ENABLED)
26727: int mem_base;
26728: int ret_val;
26729: xmlChar * value; /* an Nmtokens value */
26730: int n_value;
26731:
26732: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
26733: mem_base = xmlMemBlocks();
26734: value = gen_const_xmlChar_ptr(n_value, 0);
26735:
26736: ret_val = xmlValidateNmtokensValue((const xmlChar *)value);
26737: desret_int(ret_val);
26738: call_tests++;
26739: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
26740: xmlResetLastError();
26741: if (mem_base != xmlMemBlocks()) {
26742: printf("Leak of %d blocks found in xmlValidateNmtokensValue",
26743: xmlMemBlocks() - mem_base);
26744: test_ret++;
26745: printf(" %d", n_value);
26746: printf("\n");
26747: }
26748: }
26749: function_tests++;
26750: #endif
26751:
26752: return(test_ret);
26753: }
26754:
26755:
26756: static int
26757: test_xmlValidateNotationDecl(void) {
26758: int test_ret = 0;
26759:
26760: #if defined(LIBXML_VALID_ENABLED)
26761: int mem_base;
26762: int ret_val;
26763: xmlValidCtxtPtr ctxt; /* the validation context */
26764: int n_ctxt;
26765: xmlDocPtr doc; /* a document instance */
26766: int n_doc;
26767: xmlNotationPtr nota; /* a notation definition */
26768: int n_nota;
26769:
26770: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26771: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26772: for (n_nota = 0;n_nota < gen_nb_xmlNotationPtr;n_nota++) {
26773: mem_base = xmlMemBlocks();
26774: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26775: doc = gen_xmlDocPtr(n_doc, 1);
26776: nota = gen_xmlNotationPtr(n_nota, 2);
26777:
26778: ret_val = xmlValidateNotationDecl(ctxt, doc, nota);
26779: desret_int(ret_val);
26780: call_tests++;
26781: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26782: des_xmlDocPtr(n_doc, doc, 1);
26783: des_xmlNotationPtr(n_nota, nota, 2);
26784: xmlResetLastError();
26785: if (mem_base != xmlMemBlocks()) {
26786: printf("Leak of %d blocks found in xmlValidateNotationDecl",
26787: xmlMemBlocks() - mem_base);
26788: test_ret++;
26789: printf(" %d", n_ctxt);
26790: printf(" %d", n_doc);
26791: printf(" %d", n_nota);
26792: printf("\n");
26793: }
26794: }
26795: }
26796: }
26797: function_tests++;
26798: #endif
26799:
26800: return(test_ret);
26801: }
26802:
26803:
26804: static int
26805: test_xmlValidateNotationUse(void) {
26806: int test_ret = 0;
26807:
26808: #if defined(LIBXML_VALID_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
26809: int mem_base;
26810: int ret_val;
26811: xmlValidCtxtPtr ctxt; /* the validation context */
26812: int n_ctxt;
26813: xmlDocPtr doc; /* the document */
26814: int n_doc;
26815: xmlChar * notationName; /* the notation name to check */
26816: int n_notationName;
26817:
26818: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26819: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26820: for (n_notationName = 0;n_notationName < gen_nb_const_xmlChar_ptr;n_notationName++) {
26821: mem_base = xmlMemBlocks();
26822: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26823: doc = gen_xmlDocPtr(n_doc, 1);
26824: notationName = gen_const_xmlChar_ptr(n_notationName, 2);
26825:
26826: ret_val = xmlValidateNotationUse(ctxt, doc, (const xmlChar *)notationName);
26827: desret_int(ret_val);
26828: call_tests++;
26829: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26830: des_xmlDocPtr(n_doc, doc, 1);
26831: des_const_xmlChar_ptr(n_notationName, (const xmlChar *)notationName, 2);
26832: xmlResetLastError();
26833: if (mem_base != xmlMemBlocks()) {
26834: printf("Leak of %d blocks found in xmlValidateNotationUse",
26835: xmlMemBlocks() - mem_base);
26836: test_ret++;
26837: printf(" %d", n_ctxt);
26838: printf(" %d", n_doc);
26839: printf(" %d", n_notationName);
26840: printf("\n");
26841: }
26842: }
26843: }
26844: }
26845: function_tests++;
26846: #endif
26847:
26848: return(test_ret);
26849: }
26850:
26851:
26852: static int
26853: test_xmlValidateOneAttribute(void) {
26854: int test_ret = 0;
26855:
26856: #if defined(LIBXML_VALID_ENABLED)
26857: int mem_base;
26858: int ret_val;
26859: xmlValidCtxtPtr ctxt; /* the validation context */
26860: int n_ctxt;
26861: xmlDocPtr doc; /* a document instance */
26862: int n_doc;
26863: xmlNodePtr elem; /* an element instance */
26864: int n_elem;
26865: xmlAttrPtr attr; /* an attribute instance */
26866: int n_attr;
26867: xmlChar * value; /* the attribute value (without entities processing) */
26868: int n_value;
26869:
26870: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26871: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26872: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
26873: for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
26874: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
26875: mem_base = xmlMemBlocks();
26876: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26877: doc = gen_xmlDocPtr(n_doc, 1);
26878: elem = gen_xmlNodePtr(n_elem, 2);
26879: attr = gen_xmlAttrPtr(n_attr, 3);
26880: value = gen_const_xmlChar_ptr(n_value, 4);
26881:
26882: ret_val = xmlValidateOneAttribute(ctxt, doc, elem, attr, (const xmlChar *)value);
26883: desret_int(ret_val);
26884: call_tests++;
26885: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26886: des_xmlDocPtr(n_doc, doc, 1);
26887: des_xmlNodePtr(n_elem, elem, 2);
26888: des_xmlAttrPtr(n_attr, attr, 3);
26889: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 4);
26890: xmlResetLastError();
26891: if (mem_base != xmlMemBlocks()) {
26892: printf("Leak of %d blocks found in xmlValidateOneAttribute",
26893: xmlMemBlocks() - mem_base);
26894: test_ret++;
26895: printf(" %d", n_ctxt);
26896: printf(" %d", n_doc);
26897: printf(" %d", n_elem);
26898: printf(" %d", n_attr);
26899: printf(" %d", n_value);
26900: printf("\n");
26901: }
26902: }
26903: }
26904: }
26905: }
26906: }
26907: function_tests++;
26908: #endif
26909:
26910: return(test_ret);
26911: }
26912:
26913:
26914: static int
26915: test_xmlValidateOneElement(void) {
26916: int test_ret = 0;
26917:
26918: #if defined(LIBXML_VALID_ENABLED)
26919: int mem_base;
26920: int ret_val;
26921: xmlValidCtxtPtr ctxt; /* the validation context */
26922: int n_ctxt;
26923: xmlDocPtr doc; /* a document instance */
26924: int n_doc;
26925: xmlNodePtr elem; /* an element instance */
26926: int n_elem;
26927:
26928: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26929: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26930: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
26931: mem_base = xmlMemBlocks();
26932: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26933: doc = gen_xmlDocPtr(n_doc, 1);
26934: elem = gen_xmlNodePtr(n_elem, 2);
26935:
26936: ret_val = xmlValidateOneElement(ctxt, doc, elem);
26937: desret_int(ret_val);
26938: call_tests++;
26939: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26940: des_xmlDocPtr(n_doc, doc, 1);
26941: des_xmlNodePtr(n_elem, elem, 2);
26942: xmlResetLastError();
26943: if (mem_base != xmlMemBlocks()) {
26944: printf("Leak of %d blocks found in xmlValidateOneElement",
26945: xmlMemBlocks() - mem_base);
26946: test_ret++;
26947: printf(" %d", n_ctxt);
26948: printf(" %d", n_doc);
26949: printf(" %d", n_elem);
26950: printf("\n");
26951: }
26952: }
26953: }
26954: }
26955: function_tests++;
26956: #endif
26957:
26958: return(test_ret);
26959: }
26960:
26961:
26962: static int
26963: test_xmlValidateOneNamespace(void) {
26964: int test_ret = 0;
26965:
26966: #if defined(LIBXML_VALID_ENABLED)
26967: int mem_base;
26968: int ret_val;
26969: xmlValidCtxtPtr ctxt; /* the validation context */
26970: int n_ctxt;
26971: xmlDocPtr doc; /* a document instance */
26972: int n_doc;
26973: xmlNodePtr elem; /* an element instance */
26974: int n_elem;
26975: xmlChar * prefix; /* the namespace prefix */
26976: int n_prefix;
26977: xmlNsPtr ns; /* an namespace declaration instance */
26978: int n_ns;
26979: xmlChar * value; /* the attribute value (without entities processing) */
26980: int n_value;
26981:
26982: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26983: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26984: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
26985: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
26986: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
26987: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
26988: mem_base = xmlMemBlocks();
26989: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26990: doc = gen_xmlDocPtr(n_doc, 1);
26991: elem = gen_xmlNodePtr(n_elem, 2);
26992: prefix = gen_const_xmlChar_ptr(n_prefix, 3);
26993: ns = gen_xmlNsPtr(n_ns, 4);
26994: value = gen_const_xmlChar_ptr(n_value, 5);
26995:
26996: ret_val = xmlValidateOneNamespace(ctxt, doc, elem, (const xmlChar *)prefix, ns, (const xmlChar *)value);
26997: desret_int(ret_val);
26998: call_tests++;
26999: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
27000: des_xmlDocPtr(n_doc, doc, 1);
27001: des_xmlNodePtr(n_elem, elem, 2);
27002: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 3);
27003: des_xmlNsPtr(n_ns, ns, 4);
27004: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 5);
27005: xmlResetLastError();
27006: if (mem_base != xmlMemBlocks()) {
27007: printf("Leak of %d blocks found in xmlValidateOneNamespace",
27008: xmlMemBlocks() - mem_base);
27009: test_ret++;
27010: printf(" %d", n_ctxt);
27011: printf(" %d", n_doc);
27012: printf(" %d", n_elem);
27013: printf(" %d", n_prefix);
27014: printf(" %d", n_ns);
27015: printf(" %d", n_value);
27016: printf("\n");
27017: }
27018: }
27019: }
27020: }
27021: }
27022: }
27023: }
27024: function_tests++;
27025: #endif
27026:
27027: return(test_ret);
27028: }
27029:
27030:
27031: static int
27032: test_xmlValidatePopElement(void) {
27033: int test_ret = 0;
27034:
27035: #if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED)
27036: int mem_base;
27037: int ret_val;
27038: xmlValidCtxtPtr ctxt; /* the validation context */
27039: int n_ctxt;
27040: xmlDocPtr doc; /* a document instance */
27041: int n_doc;
27042: xmlNodePtr elem; /* an element instance */
27043: int n_elem;
27044: xmlChar * qname; /* the qualified name as appearing in the serialization */
27045: int n_qname;
27046:
27047: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
27048: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
27049: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
27050: for (n_qname = 0;n_qname < gen_nb_const_xmlChar_ptr;n_qname++) {
27051: mem_base = xmlMemBlocks();
27052: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
27053: doc = gen_xmlDocPtr(n_doc, 1);
27054: elem = gen_xmlNodePtr(n_elem, 2);
27055: qname = gen_const_xmlChar_ptr(n_qname, 3);
27056:
27057: ret_val = xmlValidatePopElement(ctxt, doc, elem, (const xmlChar *)qname);
27058: desret_int(ret_val);
27059: call_tests++;
27060: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
27061: des_xmlDocPtr(n_doc, doc, 1);
27062: des_xmlNodePtr(n_elem, elem, 2);
27063: des_const_xmlChar_ptr(n_qname, (const xmlChar *)qname, 3);
27064: xmlResetLastError();
27065: if (mem_base != xmlMemBlocks()) {
27066: printf("Leak of %d blocks found in xmlValidatePopElement",
27067: xmlMemBlocks() - mem_base);
27068: test_ret++;
27069: printf(" %d", n_ctxt);
27070: printf(" %d", n_doc);
27071: printf(" %d", n_elem);
27072: printf(" %d", n_qname);
27073: printf("\n");
27074: }
27075: }
27076: }
27077: }
27078: }
27079: function_tests++;
27080: #endif
27081:
27082: return(test_ret);
27083: }
27084:
27085:
27086: static int
27087: test_xmlValidatePushCData(void) {
27088: int test_ret = 0;
27089:
27090: #if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED)
27091: int mem_base;
27092: int ret_val;
27093: xmlValidCtxtPtr ctxt; /* the validation context */
27094: int n_ctxt;
27095: xmlChar * data; /* some character data read */
27096: int n_data;
1.1.1.3 ! misho 27097: int len; /* the length of the data */
1.1 misho 27098: int n_len;
27099:
27100: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
27101: for (n_data = 0;n_data < gen_nb_const_xmlChar_ptr;n_data++) {
27102: for (n_len = 0;n_len < gen_nb_int;n_len++) {
27103: mem_base = xmlMemBlocks();
27104: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
27105: data = gen_const_xmlChar_ptr(n_data, 1);
27106: len = gen_int(n_len, 2);
27107:
27108: ret_val = xmlValidatePushCData(ctxt, (const xmlChar *)data, len);
27109: desret_int(ret_val);
27110: call_tests++;
27111: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
27112: des_const_xmlChar_ptr(n_data, (const xmlChar *)data, 1);
27113: des_int(n_len, len, 2);
27114: xmlResetLastError();
27115: if (mem_base != xmlMemBlocks()) {
27116: printf("Leak of %d blocks found in xmlValidatePushCData",
27117: xmlMemBlocks() - mem_base);
27118: test_ret++;
27119: printf(" %d", n_ctxt);
27120: printf(" %d", n_data);
27121: printf(" %d", n_len);
27122: printf("\n");
27123: }
27124: }
27125: }
27126: }
27127: function_tests++;
27128: #endif
27129:
27130: return(test_ret);
27131: }
27132:
27133:
27134: static int
27135: test_xmlValidatePushElement(void) {
27136: int test_ret = 0;
27137:
27138: #if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED)
27139: int mem_base;
27140: int ret_val;
27141: xmlValidCtxtPtr ctxt; /* the validation context */
27142: int n_ctxt;
27143: xmlDocPtr doc; /* a document instance */
27144: int n_doc;
27145: xmlNodePtr elem; /* an element instance */
27146: int n_elem;
27147: xmlChar * qname; /* the qualified name as appearing in the serialization */
27148: int n_qname;
27149:
27150: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
27151: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
27152: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
27153: for (n_qname = 0;n_qname < gen_nb_const_xmlChar_ptr;n_qname++) {
27154: mem_base = xmlMemBlocks();
27155: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
27156: doc = gen_xmlDocPtr(n_doc, 1);
27157: elem = gen_xmlNodePtr(n_elem, 2);
27158: qname = gen_const_xmlChar_ptr(n_qname, 3);
27159:
27160: ret_val = xmlValidatePushElement(ctxt, doc, elem, (const xmlChar *)qname);
27161: desret_int(ret_val);
27162: call_tests++;
27163: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
27164: des_xmlDocPtr(n_doc, doc, 1);
27165: des_xmlNodePtr(n_elem, elem, 2);
27166: des_const_xmlChar_ptr(n_qname, (const xmlChar *)qname, 3);
27167: xmlResetLastError();
27168: if (mem_base != xmlMemBlocks()) {
27169: printf("Leak of %d blocks found in xmlValidatePushElement",
27170: xmlMemBlocks() - mem_base);
27171: test_ret++;
27172: printf(" %d", n_ctxt);
27173: printf(" %d", n_doc);
27174: printf(" %d", n_elem);
27175: printf(" %d", n_qname);
27176: printf("\n");
27177: }
27178: }
27179: }
27180: }
27181: }
27182: function_tests++;
27183: #endif
27184:
27185: return(test_ret);
27186: }
27187:
27188:
27189: static int
27190: test_xmlValidateRoot(void) {
27191: int test_ret = 0;
27192:
27193: #if defined(LIBXML_VALID_ENABLED)
27194: int mem_base;
27195: int ret_val;
27196: xmlValidCtxtPtr ctxt; /* the validation context */
27197: int n_ctxt;
27198: xmlDocPtr doc; /* a document instance */
27199: int n_doc;
27200:
27201: for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
27202: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
27203: mem_base = xmlMemBlocks();
27204: ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
27205: doc = gen_xmlDocPtr(n_doc, 1);
27206:
27207: ret_val = xmlValidateRoot(ctxt, doc);
27208: desret_int(ret_val);
27209: call_tests++;
27210: des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
27211: des_xmlDocPtr(n_doc, doc, 1);
27212: xmlResetLastError();
27213: if (mem_base != xmlMemBlocks()) {
27214: printf("Leak of %d blocks found in xmlValidateRoot",
27215: xmlMemBlocks() - mem_base);
27216: test_ret++;
27217: printf(" %d", n_ctxt);
27218: printf(" %d", n_doc);
27219: printf("\n");
27220: }
27221: }
27222: }
27223: function_tests++;
27224: #endif
27225:
27226: return(test_ret);
27227: }
27228:
27229: static int
27230: test_valid(void) {
27231: int test_ret = 0;
27232:
27233: if (quiet == 0) printf("Testing valid : 50 of 70 functions ...\n");
27234: test_ret += test_xmlAddAttributeDecl();
27235: test_ret += test_xmlAddElementDecl();
27236: test_ret += test_xmlAddID();
27237: test_ret += test_xmlAddNotationDecl();
27238: test_ret += test_xmlAddRef();
27239: test_ret += test_xmlCopyAttributeTable();
27240: test_ret += test_xmlCopyDocElementContent();
27241: test_ret += test_xmlCopyElementContent();
27242: test_ret += test_xmlCopyElementTable();
27243: test_ret += test_xmlCopyEnumeration();
27244: test_ret += test_xmlCopyNotationTable();
27245: test_ret += test_xmlCreateEnumeration();
27246: test_ret += test_xmlDumpAttributeDecl();
27247: test_ret += test_xmlDumpAttributeTable();
27248: test_ret += test_xmlDumpElementDecl();
27249: test_ret += test_xmlDumpElementTable();
27250: test_ret += test_xmlDumpNotationDecl();
27251: test_ret += test_xmlDumpNotationTable();
27252: test_ret += test_xmlGetDtdAttrDesc();
27253: test_ret += test_xmlGetDtdElementDesc();
27254: test_ret += test_xmlGetDtdNotationDesc();
27255: test_ret += test_xmlGetDtdQAttrDesc();
27256: test_ret += test_xmlGetDtdQElementDesc();
27257: test_ret += test_xmlGetID();
27258: test_ret += test_xmlGetRefs();
27259: test_ret += test_xmlIsID();
27260: test_ret += test_xmlIsMixedElement();
27261: test_ret += test_xmlIsRef();
27262: test_ret += test_xmlNewDocElementContent();
27263: test_ret += test_xmlNewElementContent();
27264: test_ret += test_xmlNewValidCtxt();
27265: test_ret += test_xmlRemoveID();
27266: test_ret += test_xmlRemoveRef();
27267: test_ret += test_xmlSnprintfElementContent();
27268: test_ret += test_xmlSprintfElementContent();
27269: test_ret += test_xmlValidBuildContentModel();
27270: test_ret += test_xmlValidCtxtNormalizeAttributeValue();
27271: test_ret += test_xmlValidGetPotentialChildren();
27272: test_ret += test_xmlValidGetValidElements();
27273: test_ret += test_xmlValidNormalizeAttributeValue();
27274: test_ret += test_xmlValidateAttributeDecl();
27275: test_ret += test_xmlValidateAttributeValue();
27276: test_ret += test_xmlValidateDocument();
27277: test_ret += test_xmlValidateDocumentFinal();
27278: test_ret += test_xmlValidateDtd();
27279: test_ret += test_xmlValidateDtdFinal();
27280: test_ret += test_xmlValidateElement();
27281: test_ret += test_xmlValidateElementDecl();
27282: test_ret += test_xmlValidateNameValue();
27283: test_ret += test_xmlValidateNamesValue();
27284: test_ret += test_xmlValidateNmtokenValue();
27285: test_ret += test_xmlValidateNmtokensValue();
27286: test_ret += test_xmlValidateNotationDecl();
27287: test_ret += test_xmlValidateNotationUse();
27288: test_ret += test_xmlValidateOneAttribute();
27289: test_ret += test_xmlValidateOneElement();
27290: test_ret += test_xmlValidateOneNamespace();
27291: test_ret += test_xmlValidatePopElement();
27292: test_ret += test_xmlValidatePushCData();
27293: test_ret += test_xmlValidatePushElement();
27294: test_ret += test_xmlValidateRoot();
27295:
27296: if (test_ret != 0)
27297: printf("Module valid: %d errors\n", test_ret);
27298: return(test_ret);
27299: }
27300:
27301: static int
27302: test_xmlXIncludeNewContext(void) {
27303: int test_ret = 0;
27304:
27305:
27306: /* missing type support */
27307: return(test_ret);
27308: }
27309:
27310:
27311: static int
27312: test_xmlXIncludeProcess(void) {
27313: int test_ret = 0;
27314:
27315: #if defined(LIBXML_XINCLUDE_ENABLED)
27316: int mem_base;
27317: int ret_val;
27318: xmlDocPtr doc; /* an XML document */
27319: int n_doc;
27320:
27321: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
27322: mem_base = xmlMemBlocks();
27323: doc = gen_xmlDocPtr(n_doc, 0);
27324:
27325: ret_val = xmlXIncludeProcess(doc);
27326: desret_int(ret_val);
27327: call_tests++;
27328: des_xmlDocPtr(n_doc, doc, 0);
27329: xmlResetLastError();
27330: if (mem_base != xmlMemBlocks()) {
27331: printf("Leak of %d blocks found in xmlXIncludeProcess",
27332: xmlMemBlocks() - mem_base);
27333: test_ret++;
27334: printf(" %d", n_doc);
27335: printf("\n");
27336: }
27337: }
27338: function_tests++;
27339: #endif
27340:
27341: return(test_ret);
27342: }
27343:
27344:
27345: static int
27346: test_xmlXIncludeProcessFlags(void) {
27347: int test_ret = 0;
27348:
27349: #if defined(LIBXML_XINCLUDE_ENABLED)
27350: int mem_base;
27351: int ret_val;
27352: xmlDocPtr doc; /* an XML document */
27353: int n_doc;
27354: int flags; /* a set of xmlParserOption used for parsing XML includes */
27355: int n_flags;
27356:
27357: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
27358: for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
27359: mem_base = xmlMemBlocks();
27360: doc = gen_xmlDocPtr(n_doc, 0);
27361: flags = gen_int(n_flags, 1);
27362:
27363: ret_val = xmlXIncludeProcessFlags(doc, flags);
27364: desret_int(ret_val);
27365: call_tests++;
27366: des_xmlDocPtr(n_doc, doc, 0);
27367: des_int(n_flags, flags, 1);
27368: xmlResetLastError();
27369: if (mem_base != xmlMemBlocks()) {
27370: printf("Leak of %d blocks found in xmlXIncludeProcessFlags",
27371: xmlMemBlocks() - mem_base);
27372: test_ret++;
27373: printf(" %d", n_doc);
27374: printf(" %d", n_flags);
27375: printf("\n");
27376: }
27377: }
27378: }
27379: function_tests++;
27380: #endif
27381:
27382: return(test_ret);
27383: }
27384:
27385:
27386: static int
27387: test_xmlXIncludeProcessFlagsData(void) {
27388: int test_ret = 0;
27389:
27390: #if defined(LIBXML_XINCLUDE_ENABLED)
27391: int mem_base;
27392: int ret_val;
27393: xmlDocPtr doc; /* an XML document */
27394: int n_doc;
27395: int flags; /* a set of xmlParserOption used for parsing XML includes */
27396: int n_flags;
27397: void * data; /* application data that will be passed to the parser context in the _private field of the parser context(s) */
27398: int n_data;
27399:
27400: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
27401: for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
27402: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
27403: mem_base = xmlMemBlocks();
27404: doc = gen_xmlDocPtr(n_doc, 0);
27405: flags = gen_int(n_flags, 1);
27406: data = gen_userdata(n_data, 2);
27407:
27408: ret_val = xmlXIncludeProcessFlagsData(doc, flags, data);
27409: desret_int(ret_val);
27410: call_tests++;
27411: des_xmlDocPtr(n_doc, doc, 0);
27412: des_int(n_flags, flags, 1);
27413: des_userdata(n_data, data, 2);
27414: xmlResetLastError();
27415: if (mem_base != xmlMemBlocks()) {
27416: printf("Leak of %d blocks found in xmlXIncludeProcessFlagsData",
27417: xmlMemBlocks() - mem_base);
27418: test_ret++;
27419: printf(" %d", n_doc);
27420: printf(" %d", n_flags);
27421: printf(" %d", n_data);
27422: printf("\n");
27423: }
27424: }
27425: }
27426: }
27427: function_tests++;
27428: #endif
27429:
27430: return(test_ret);
27431: }
27432:
27433: #ifdef LIBXML_XINCLUDE_ENABLED
27434:
27435: #define gen_nb_xmlXIncludeCtxtPtr 1
27436: static xmlXIncludeCtxtPtr gen_xmlXIncludeCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
27437: return(NULL);
27438: }
27439: static void des_xmlXIncludeCtxtPtr(int no ATTRIBUTE_UNUSED, xmlXIncludeCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
27440: }
27441: #endif
27442:
27443:
27444: static int
27445: test_xmlXIncludeProcessNode(void) {
27446: int test_ret = 0;
27447:
27448: #if defined(LIBXML_XINCLUDE_ENABLED)
27449: int mem_base;
27450: int ret_val;
27451: xmlXIncludeCtxtPtr ctxt; /* an existing XInclude context */
27452: int n_ctxt;
27453: xmlNodePtr node; /* a node in an XML document */
27454: int n_node;
27455:
27456: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXIncludeCtxtPtr;n_ctxt++) {
27457: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
27458: mem_base = xmlMemBlocks();
27459: ctxt = gen_xmlXIncludeCtxtPtr(n_ctxt, 0);
27460: node = gen_xmlNodePtr(n_node, 1);
27461:
27462: ret_val = xmlXIncludeProcessNode(ctxt, node);
27463: desret_int(ret_val);
27464: call_tests++;
27465: des_xmlXIncludeCtxtPtr(n_ctxt, ctxt, 0);
27466: des_xmlNodePtr(n_node, node, 1);
27467: xmlResetLastError();
27468: if (mem_base != xmlMemBlocks()) {
27469: printf("Leak of %d blocks found in xmlXIncludeProcessNode",
27470: xmlMemBlocks() - mem_base);
27471: test_ret++;
27472: printf(" %d", n_ctxt);
27473: printf(" %d", n_node);
27474: printf("\n");
27475: }
27476: }
27477: }
27478: function_tests++;
27479: #endif
27480:
27481: return(test_ret);
27482: }
27483:
27484:
27485: static int
27486: test_xmlXIncludeProcessTree(void) {
27487: int test_ret = 0;
27488:
27489: #if defined(LIBXML_XINCLUDE_ENABLED)
27490: int mem_base;
27491: int ret_val;
27492: xmlNodePtr tree; /* a node in an XML document */
27493: int n_tree;
27494:
27495: for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) {
27496: mem_base = xmlMemBlocks();
27497: tree = gen_xmlNodePtr(n_tree, 0);
27498:
27499: ret_val = xmlXIncludeProcessTree(tree);
27500: desret_int(ret_val);
27501: call_tests++;
27502: des_xmlNodePtr(n_tree, tree, 0);
27503: xmlResetLastError();
27504: if (mem_base != xmlMemBlocks()) {
27505: printf("Leak of %d blocks found in xmlXIncludeProcessTree",
27506: xmlMemBlocks() - mem_base);
27507: test_ret++;
27508: printf(" %d", n_tree);
27509: printf("\n");
27510: }
27511: }
27512: function_tests++;
27513: #endif
27514:
27515: return(test_ret);
27516: }
27517:
27518:
27519: static int
27520: test_xmlXIncludeProcessTreeFlags(void) {
27521: int test_ret = 0;
27522:
27523: #if defined(LIBXML_XINCLUDE_ENABLED)
27524: int mem_base;
27525: int ret_val;
27526: xmlNodePtr tree; /* a node in an XML document */
27527: int n_tree;
27528: int flags; /* a set of xmlParserOption used for parsing XML includes */
27529: int n_flags;
27530:
27531: for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) {
27532: for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
27533: mem_base = xmlMemBlocks();
27534: tree = gen_xmlNodePtr(n_tree, 0);
27535: flags = gen_int(n_flags, 1);
27536:
27537: ret_val = xmlXIncludeProcessTreeFlags(tree, flags);
27538: desret_int(ret_val);
27539: call_tests++;
27540: des_xmlNodePtr(n_tree, tree, 0);
27541: des_int(n_flags, flags, 1);
27542: xmlResetLastError();
27543: if (mem_base != xmlMemBlocks()) {
27544: printf("Leak of %d blocks found in xmlXIncludeProcessTreeFlags",
27545: xmlMemBlocks() - mem_base);
27546: test_ret++;
27547: printf(" %d", n_tree);
27548: printf(" %d", n_flags);
27549: printf("\n");
27550: }
27551: }
27552: }
27553: function_tests++;
27554: #endif
27555:
27556: return(test_ret);
27557: }
27558:
27559:
27560: static int
27561: test_xmlXIncludeProcessTreeFlagsData(void) {
27562: int test_ret = 0;
27563:
27564: #if defined(LIBXML_XINCLUDE_ENABLED)
27565: int mem_base;
27566: int ret_val;
27567: xmlNodePtr tree; /* an XML node */
27568: int n_tree;
27569: int flags; /* a set of xmlParserOption used for parsing XML includes */
27570: int n_flags;
27571: void * data; /* application data that will be passed to the parser context in the _private field of the parser context(s) */
27572: int n_data;
27573:
27574: for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) {
27575: for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
27576: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
27577: mem_base = xmlMemBlocks();
27578: tree = gen_xmlNodePtr(n_tree, 0);
27579: flags = gen_int(n_flags, 1);
27580: data = gen_userdata(n_data, 2);
27581:
27582: ret_val = xmlXIncludeProcessTreeFlagsData(tree, flags, data);
27583: desret_int(ret_val);
27584: call_tests++;
27585: des_xmlNodePtr(n_tree, tree, 0);
27586: des_int(n_flags, flags, 1);
27587: des_userdata(n_data, data, 2);
27588: xmlResetLastError();
27589: if (mem_base != xmlMemBlocks()) {
27590: printf("Leak of %d blocks found in xmlXIncludeProcessTreeFlagsData",
27591: xmlMemBlocks() - mem_base);
27592: test_ret++;
27593: printf(" %d", n_tree);
27594: printf(" %d", n_flags);
27595: printf(" %d", n_data);
27596: printf("\n");
27597: }
27598: }
27599: }
27600: }
27601: function_tests++;
27602: #endif
27603:
27604: return(test_ret);
27605: }
27606:
27607:
27608: static int
27609: test_xmlXIncludeSetFlags(void) {
27610: int test_ret = 0;
27611:
27612: #if defined(LIBXML_XINCLUDE_ENABLED)
27613: int mem_base;
27614: int ret_val;
27615: xmlXIncludeCtxtPtr ctxt; /* an XInclude processing context */
27616: int n_ctxt;
27617: int flags; /* a set of xmlParserOption used for parsing XML includes */
27618: int n_flags;
27619:
27620: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXIncludeCtxtPtr;n_ctxt++) {
27621: for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
27622: mem_base = xmlMemBlocks();
27623: ctxt = gen_xmlXIncludeCtxtPtr(n_ctxt, 0);
27624: flags = gen_int(n_flags, 1);
27625:
27626: ret_val = xmlXIncludeSetFlags(ctxt, flags);
27627: desret_int(ret_val);
27628: call_tests++;
27629: des_xmlXIncludeCtxtPtr(n_ctxt, ctxt, 0);
27630: des_int(n_flags, flags, 1);
27631: xmlResetLastError();
27632: if (mem_base != xmlMemBlocks()) {
27633: printf("Leak of %d blocks found in xmlXIncludeSetFlags",
27634: xmlMemBlocks() - mem_base);
27635: test_ret++;
27636: printf(" %d", n_ctxt);
27637: printf(" %d", n_flags);
27638: printf("\n");
27639: }
27640: }
27641: }
27642: function_tests++;
27643: #endif
27644:
27645: return(test_ret);
27646: }
27647:
27648: static int
27649: test_xinclude(void) {
27650: int test_ret = 0;
27651:
27652: if (quiet == 0) printf("Testing xinclude : 8 of 10 functions ...\n");
27653: test_ret += test_xmlXIncludeNewContext();
27654: test_ret += test_xmlXIncludeProcess();
27655: test_ret += test_xmlXIncludeProcessFlags();
27656: test_ret += test_xmlXIncludeProcessFlagsData();
27657: test_ret += test_xmlXIncludeProcessNode();
27658: test_ret += test_xmlXIncludeProcessTree();
27659: test_ret += test_xmlXIncludeProcessTreeFlags();
27660: test_ret += test_xmlXIncludeProcessTreeFlagsData();
27661: test_ret += test_xmlXIncludeSetFlags();
27662:
27663: if (test_ret != 0)
27664: printf("Module xinclude: %d errors\n", test_ret);
27665: return(test_ret);
27666: }
27667:
27668: static int
27669: test_xmlAllocOutputBuffer(void) {
27670: int test_ret = 0;
27671:
27672: #if defined(LIBXML_OUTPUT_ENABLED)
27673: int mem_base;
27674: xmlOutputBufferPtr ret_val;
27675: xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */
27676: int n_encoder;
27677:
27678: for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) {
27679: mem_base = xmlMemBlocks();
27680: encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 0);
27681:
27682: ret_val = xmlAllocOutputBuffer(encoder);
27683: desret_xmlOutputBufferPtr(ret_val);
27684: call_tests++;
27685: des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 0);
27686: xmlResetLastError();
27687: if (mem_base != xmlMemBlocks()) {
27688: printf("Leak of %d blocks found in xmlAllocOutputBuffer",
27689: xmlMemBlocks() - mem_base);
27690: test_ret++;
27691: printf(" %d", n_encoder);
27692: printf("\n");
27693: }
27694: }
27695: function_tests++;
27696: #endif
27697:
27698: return(test_ret);
27699: }
27700:
27701:
27702: static int
27703: test_xmlAllocParserInputBuffer(void) {
27704: int test_ret = 0;
27705:
27706: int mem_base;
27707: xmlParserInputBufferPtr ret_val;
27708: xmlCharEncoding enc; /* the charset encoding if known */
27709: int n_enc;
27710:
27711: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
27712: mem_base = xmlMemBlocks();
27713: enc = gen_xmlCharEncoding(n_enc, 0);
27714:
27715: ret_val = xmlAllocParserInputBuffer(enc);
27716: desret_xmlParserInputBufferPtr(ret_val);
27717: call_tests++;
27718: des_xmlCharEncoding(n_enc, enc, 0);
27719: xmlResetLastError();
27720: if (mem_base != xmlMemBlocks()) {
27721: printf("Leak of %d blocks found in xmlAllocParserInputBuffer",
27722: xmlMemBlocks() - mem_base);
27723: test_ret++;
27724: printf(" %d", n_enc);
27725: printf("\n");
27726: }
27727: }
27728: function_tests++;
27729:
27730: return(test_ret);
27731: }
27732:
27733:
27734: static int
27735: test_xmlCheckFilename(void) {
27736: int test_ret = 0;
27737:
27738: int mem_base;
27739: int ret_val;
27740: char * path; /* the path to check */
27741: int n_path;
27742:
27743: for (n_path = 0;n_path < gen_nb_const_char_ptr;n_path++) {
27744: mem_base = xmlMemBlocks();
27745: path = gen_const_char_ptr(n_path, 0);
27746:
27747: ret_val = xmlCheckFilename((const char *)path);
27748: desret_int(ret_val);
27749: call_tests++;
27750: des_const_char_ptr(n_path, (const char *)path, 0);
27751: xmlResetLastError();
27752: if (mem_base != xmlMemBlocks()) {
27753: printf("Leak of %d blocks found in xmlCheckFilename",
27754: xmlMemBlocks() - mem_base);
27755: test_ret++;
27756: printf(" %d", n_path);
27757: printf("\n");
27758: }
27759: }
27760: function_tests++;
27761:
27762: return(test_ret);
27763: }
27764:
27765:
27766: static int
27767: test_xmlCheckHTTPInput(void) {
27768: int test_ret = 0;
27769:
27770: int mem_base;
27771: xmlParserInputPtr ret_val;
27772: xmlParserCtxtPtr ctxt; /* an XML parser context */
27773: int n_ctxt;
27774: xmlParserInputPtr ret; /* an XML parser input */
27775: int n_ret;
27776:
27777: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
27778: for (n_ret = 0;n_ret < gen_nb_xmlParserInputPtr;n_ret++) {
27779: mem_base = xmlMemBlocks();
27780: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
27781: ret = gen_xmlParserInputPtr(n_ret, 1);
27782:
27783: ret_val = xmlCheckHTTPInput(ctxt, ret);
27784: desret_xmlParserInputPtr(ret_val);
27785: call_tests++;
27786: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
27787: des_xmlParserInputPtr(n_ret, ret, 1);
27788: xmlResetLastError();
27789: if (mem_base != xmlMemBlocks()) {
27790: printf("Leak of %d blocks found in xmlCheckHTTPInput",
27791: xmlMemBlocks() - mem_base);
27792: test_ret++;
27793: printf(" %d", n_ctxt);
27794: printf(" %d", n_ret);
27795: printf("\n");
27796: }
27797: }
27798: }
27799: function_tests++;
27800:
27801: return(test_ret);
27802: }
27803:
27804:
27805: static int
27806: test_xmlCleanupInputCallbacks(void) {
27807: int test_ret = 0;
27808:
27809: int mem_base;
27810:
27811: mem_base = xmlMemBlocks();
27812:
27813: xmlCleanupInputCallbacks();
27814: call_tests++;
27815: xmlResetLastError();
27816: if (mem_base != xmlMemBlocks()) {
27817: printf("Leak of %d blocks found in xmlCleanupInputCallbacks",
27818: xmlMemBlocks() - mem_base);
27819: test_ret++;
27820: printf("\n");
27821: }
27822: function_tests++;
27823:
27824: return(test_ret);
27825: }
27826:
27827:
27828: static int
27829: test_xmlCleanupOutputCallbacks(void) {
27830: int test_ret = 0;
27831:
27832: #if defined(LIBXML_OUTPUT_ENABLED)
27833: int mem_base;
27834:
27835: mem_base = xmlMemBlocks();
27836:
27837: xmlCleanupOutputCallbacks();
27838: call_tests++;
27839: xmlResetLastError();
27840: if (mem_base != xmlMemBlocks()) {
27841: printf("Leak of %d blocks found in xmlCleanupOutputCallbacks",
27842: xmlMemBlocks() - mem_base);
27843: test_ret++;
27844: printf("\n");
27845: }
27846: function_tests++;
27847: #endif
27848:
27849: return(test_ret);
27850: }
27851:
27852:
27853: static int
27854: test_xmlFileClose(void) {
27855: int test_ret = 0;
27856:
27857: int mem_base;
27858: int ret_val;
27859: void * context; /* the I/O context */
27860: int n_context;
27861:
27862: for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
27863: mem_base = xmlMemBlocks();
27864: context = gen_void_ptr(n_context, 0);
27865:
27866: ret_val = xmlFileClose(context);
27867: desret_int(ret_val);
27868: call_tests++;
27869: des_void_ptr(n_context, context, 0);
27870: xmlResetLastError();
27871: if (mem_base != xmlMemBlocks()) {
27872: printf("Leak of %d blocks found in xmlFileClose",
27873: xmlMemBlocks() - mem_base);
27874: test_ret++;
27875: printf(" %d", n_context);
27876: printf("\n");
27877: }
27878: }
27879: function_tests++;
27880:
27881: return(test_ret);
27882: }
27883:
27884:
27885: static int
27886: test_xmlFileMatch(void) {
27887: int test_ret = 0;
27888:
27889: int mem_base;
27890: int ret_val;
27891: const char * filename; /* the URI for matching */
27892: int n_filename;
27893:
27894: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
27895: mem_base = xmlMemBlocks();
27896: filename = gen_filepath(n_filename, 0);
27897:
27898: ret_val = xmlFileMatch(filename);
27899: desret_int(ret_val);
27900: call_tests++;
27901: des_filepath(n_filename, filename, 0);
27902: xmlResetLastError();
27903: if (mem_base != xmlMemBlocks()) {
27904: printf("Leak of %d blocks found in xmlFileMatch",
27905: xmlMemBlocks() - mem_base);
27906: test_ret++;
27907: printf(" %d", n_filename);
27908: printf("\n");
27909: }
27910: }
27911: function_tests++;
27912:
27913: return(test_ret);
27914: }
27915:
27916:
27917: static int
27918: test_xmlFileOpen(void) {
27919: int test_ret = 0;
27920:
27921: int mem_base;
27922: void * ret_val;
27923: const char * filename; /* the URI for matching */
27924: int n_filename;
27925:
27926: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
27927: mem_base = xmlMemBlocks();
27928: filename = gen_filepath(n_filename, 0);
27929:
27930: ret_val = xmlFileOpen(filename);
27931: desret_void_ptr(ret_val);
27932: call_tests++;
27933: des_filepath(n_filename, filename, 0);
27934: xmlResetLastError();
27935: if (mem_base != xmlMemBlocks()) {
27936: printf("Leak of %d blocks found in xmlFileOpen",
27937: xmlMemBlocks() - mem_base);
27938: test_ret++;
27939: printf(" %d", n_filename);
27940: printf("\n");
27941: }
27942: }
27943: function_tests++;
27944:
27945: return(test_ret);
27946: }
27947:
27948:
27949: static int
27950: test_xmlFileRead(void) {
27951: int test_ret = 0;
27952:
27953: int mem_base;
27954: int ret_val;
27955: void * context; /* the I/O context */
27956: int n_context;
27957: char * buffer; /* where to drop data */
27958: int n_buffer;
27959: int len; /* number of bytes to write */
27960: int n_len;
27961:
27962: for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
27963: for (n_buffer = 0;n_buffer < gen_nb_char_ptr;n_buffer++) {
27964: for (n_len = 0;n_len < gen_nb_int;n_len++) {
27965: mem_base = xmlMemBlocks();
27966: context = gen_void_ptr(n_context, 0);
27967: buffer = gen_char_ptr(n_buffer, 1);
27968: len = gen_int(n_len, 2);
27969:
27970: ret_val = xmlFileRead(context, buffer, len);
27971: desret_int(ret_val);
27972: call_tests++;
27973: des_void_ptr(n_context, context, 0);
27974: des_char_ptr(n_buffer, buffer, 1);
27975: des_int(n_len, len, 2);
27976: xmlResetLastError();
27977: if (mem_base != xmlMemBlocks()) {
27978: printf("Leak of %d blocks found in xmlFileRead",
27979: xmlMemBlocks() - mem_base);
27980: test_ret++;
27981: printf(" %d", n_context);
27982: printf(" %d", n_buffer);
27983: printf(" %d", n_len);
27984: printf("\n");
27985: }
27986: }
27987: }
27988: }
27989: function_tests++;
27990:
27991: return(test_ret);
27992: }
27993:
27994:
27995: static int
27996: test_xmlIOFTPClose(void) {
27997: int test_ret = 0;
27998:
27999: #if defined(LIBXML_FTP_ENABLED)
28000: int mem_base;
28001: int ret_val;
28002: void * context; /* the I/O context */
28003: int n_context;
28004:
28005: for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
28006: mem_base = xmlMemBlocks();
28007: context = gen_void_ptr(n_context, 0);
28008:
28009: ret_val = xmlIOFTPClose(context);
28010: desret_int(ret_val);
28011: call_tests++;
28012: des_void_ptr(n_context, context, 0);
28013: xmlResetLastError();
28014: if (mem_base != xmlMemBlocks()) {
28015: printf("Leak of %d blocks found in xmlIOFTPClose",
28016: xmlMemBlocks() - mem_base);
28017: test_ret++;
28018: printf(" %d", n_context);
28019: printf("\n");
28020: }
28021: }
28022: function_tests++;
28023: #endif
28024:
28025: return(test_ret);
28026: }
28027:
28028:
28029: static int
28030: test_xmlIOFTPMatch(void) {
28031: int test_ret = 0;
28032:
28033: #if defined(LIBXML_FTP_ENABLED)
28034: int mem_base;
28035: int ret_val;
28036: const char * filename; /* the URI for matching */
28037: int n_filename;
28038:
28039: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
28040: mem_base = xmlMemBlocks();
28041: filename = gen_filepath(n_filename, 0);
28042:
28043: ret_val = xmlIOFTPMatch(filename);
28044: desret_int(ret_val);
28045: call_tests++;
28046: des_filepath(n_filename, filename, 0);
28047: xmlResetLastError();
28048: if (mem_base != xmlMemBlocks()) {
28049: printf("Leak of %d blocks found in xmlIOFTPMatch",
28050: xmlMemBlocks() - mem_base);
28051: test_ret++;
28052: printf(" %d", n_filename);
28053: printf("\n");
28054: }
28055: }
28056: function_tests++;
28057: #endif
28058:
28059: return(test_ret);
28060: }
28061:
28062:
28063: static int
28064: test_xmlIOFTPOpen(void) {
28065: int test_ret = 0;
28066:
28067: #if defined(LIBXML_FTP_ENABLED)
28068: int mem_base;
28069: void * ret_val;
28070: const char * filename; /* the URI for matching */
28071: int n_filename;
28072:
28073: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
28074: mem_base = xmlMemBlocks();
28075: filename = gen_filepath(n_filename, 0);
28076:
28077: ret_val = xmlIOFTPOpen(filename);
28078: desret_void_ptr(ret_val);
28079: call_tests++;
28080: des_filepath(n_filename, filename, 0);
28081: xmlResetLastError();
28082: if (mem_base != xmlMemBlocks()) {
28083: printf("Leak of %d blocks found in xmlIOFTPOpen",
28084: xmlMemBlocks() - mem_base);
28085: test_ret++;
28086: printf(" %d", n_filename);
28087: printf("\n");
28088: }
28089: }
28090: function_tests++;
28091: #endif
28092:
28093: return(test_ret);
28094: }
28095:
28096:
28097: static int
28098: test_xmlIOFTPRead(void) {
28099: int test_ret = 0;
28100:
28101: #if defined(LIBXML_FTP_ENABLED)
28102: int mem_base;
28103: int ret_val;
28104: void * context; /* the I/O context */
28105: int n_context;
28106: char * buffer; /* where to drop data */
28107: int n_buffer;
28108: int len; /* number of bytes to write */
28109: int n_len;
28110:
28111: for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
28112: for (n_buffer = 0;n_buffer < gen_nb_char_ptr;n_buffer++) {
28113: for (n_len = 0;n_len < gen_nb_int;n_len++) {
28114: mem_base = xmlMemBlocks();
28115: context = gen_void_ptr(n_context, 0);
28116: buffer = gen_char_ptr(n_buffer, 1);
28117: len = gen_int(n_len, 2);
28118:
28119: ret_val = xmlIOFTPRead(context, buffer, len);
28120: desret_int(ret_val);
28121: call_tests++;
28122: des_void_ptr(n_context, context, 0);
28123: des_char_ptr(n_buffer, buffer, 1);
28124: des_int(n_len, len, 2);
28125: xmlResetLastError();
28126: if (mem_base != xmlMemBlocks()) {
28127: printf("Leak of %d blocks found in xmlIOFTPRead",
28128: xmlMemBlocks() - mem_base);
28129: test_ret++;
28130: printf(" %d", n_context);
28131: printf(" %d", n_buffer);
28132: printf(" %d", n_len);
28133: printf("\n");
28134: }
28135: }
28136: }
28137: }
28138: function_tests++;
28139: #endif
28140:
28141: return(test_ret);
28142: }
28143:
28144:
28145: static int
28146: test_xmlIOHTTPClose(void) {
28147: int test_ret = 0;
28148:
28149: #if defined(LIBXML_HTTP_ENABLED)
28150: int mem_base;
28151: int ret_val;
28152: void * context; /* the I/O context */
28153: int n_context;
28154:
28155: for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
28156: mem_base = xmlMemBlocks();
28157: context = gen_void_ptr(n_context, 0);
28158:
28159: ret_val = xmlIOHTTPClose(context);
28160: desret_int(ret_val);
28161: call_tests++;
28162: des_void_ptr(n_context, context, 0);
28163: xmlResetLastError();
28164: if (mem_base != xmlMemBlocks()) {
28165: printf("Leak of %d blocks found in xmlIOHTTPClose",
28166: xmlMemBlocks() - mem_base);
28167: test_ret++;
28168: printf(" %d", n_context);
28169: printf("\n");
28170: }
28171: }
28172: function_tests++;
28173: #endif
28174:
28175: return(test_ret);
28176: }
28177:
28178:
28179: static int
28180: test_xmlIOHTTPMatch(void) {
28181: int test_ret = 0;
28182:
28183: #if defined(LIBXML_HTTP_ENABLED)
28184: int mem_base;
28185: int ret_val;
28186: const char * filename; /* the URI for matching */
28187: int n_filename;
28188:
28189: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
28190: mem_base = xmlMemBlocks();
28191: filename = gen_filepath(n_filename, 0);
28192:
28193: ret_val = xmlIOHTTPMatch(filename);
28194: desret_int(ret_val);
28195: call_tests++;
28196: des_filepath(n_filename, filename, 0);
28197: xmlResetLastError();
28198: if (mem_base != xmlMemBlocks()) {
28199: printf("Leak of %d blocks found in xmlIOHTTPMatch",
28200: xmlMemBlocks() - mem_base);
28201: test_ret++;
28202: printf(" %d", n_filename);
28203: printf("\n");
28204: }
28205: }
28206: function_tests++;
28207: #endif
28208:
28209: return(test_ret);
28210: }
28211:
28212:
28213: static int
28214: test_xmlIOHTTPOpen(void) {
28215: int test_ret = 0;
28216:
28217: #if defined(LIBXML_HTTP_ENABLED)
28218: int mem_base;
28219: void * ret_val;
28220: const char * filename; /* the URI for matching */
28221: int n_filename;
28222:
28223: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
28224: mem_base = xmlMemBlocks();
28225: filename = gen_filepath(n_filename, 0);
28226:
28227: ret_val = xmlIOHTTPOpen(filename);
28228: desret_xmlNanoHTTPCtxtPtr(ret_val);
28229: call_tests++;
28230: des_filepath(n_filename, filename, 0);
28231: xmlResetLastError();
28232: if (mem_base != xmlMemBlocks()) {
28233: printf("Leak of %d blocks found in xmlIOHTTPOpen",
28234: xmlMemBlocks() - mem_base);
28235: test_ret++;
28236: printf(" %d", n_filename);
28237: printf("\n");
28238: }
28239: }
28240: function_tests++;
28241: #endif
28242:
28243: return(test_ret);
28244: }
28245:
28246:
28247: static int
28248: test_xmlIOHTTPRead(void) {
28249: int test_ret = 0;
28250:
28251: #if defined(LIBXML_HTTP_ENABLED)
28252: int mem_base;
28253: int ret_val;
28254: void * context; /* the I/O context */
28255: int n_context;
28256: char * buffer; /* where to drop data */
28257: int n_buffer;
28258: int len; /* number of bytes to write */
28259: int n_len;
28260:
28261: for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
28262: for (n_buffer = 0;n_buffer < gen_nb_char_ptr;n_buffer++) {
28263: for (n_len = 0;n_len < gen_nb_int;n_len++) {
28264: mem_base = xmlMemBlocks();
28265: context = gen_void_ptr(n_context, 0);
28266: buffer = gen_char_ptr(n_buffer, 1);
28267: len = gen_int(n_len, 2);
28268:
28269: ret_val = xmlIOHTTPRead(context, buffer, len);
28270: desret_int(ret_val);
28271: call_tests++;
28272: des_void_ptr(n_context, context, 0);
28273: des_char_ptr(n_buffer, buffer, 1);
28274: des_int(n_len, len, 2);
28275: xmlResetLastError();
28276: if (mem_base != xmlMemBlocks()) {
28277: printf("Leak of %d blocks found in xmlIOHTTPRead",
28278: xmlMemBlocks() - mem_base);
28279: test_ret++;
28280: printf(" %d", n_context);
28281: printf(" %d", n_buffer);
28282: printf(" %d", n_len);
28283: printf("\n");
28284: }
28285: }
28286: }
28287: }
28288: function_tests++;
28289: #endif
28290:
28291: return(test_ret);
28292: }
28293:
28294:
28295: static int
28296: test_xmlNoNetExternalEntityLoader(void) {
28297: int test_ret = 0;
28298:
28299: int mem_base;
28300: xmlParserInputPtr ret_val;
28301: const char * URL; /* the URL for the entity to load */
28302: int n_URL;
28303: char * ID; /* the System ID for the entity to load */
28304: int n_ID;
28305: xmlParserCtxtPtr ctxt; /* the context in which the entity is called or NULL */
28306: int n_ctxt;
28307:
28308: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
28309: for (n_ID = 0;n_ID < gen_nb_const_char_ptr;n_ID++) {
28310: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
28311: mem_base = xmlMemBlocks();
28312: URL = gen_filepath(n_URL, 0);
28313: ID = gen_const_char_ptr(n_ID, 1);
28314: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 2);
28315:
28316: ret_val = xmlNoNetExternalEntityLoader(URL, (const char *)ID, ctxt);
28317: desret_xmlParserInputPtr(ret_val);
28318: call_tests++;
28319: des_filepath(n_URL, URL, 0);
28320: des_const_char_ptr(n_ID, (const char *)ID, 1);
28321: des_xmlParserCtxtPtr(n_ctxt, ctxt, 2);
28322: xmlResetLastError();
28323: if (mem_base != xmlMemBlocks()) {
28324: printf("Leak of %d blocks found in xmlNoNetExternalEntityLoader",
28325: xmlMemBlocks() - mem_base);
28326: test_ret++;
28327: printf(" %d", n_URL);
28328: printf(" %d", n_ID);
28329: printf(" %d", n_ctxt);
28330: printf("\n");
28331: }
28332: }
28333: }
28334: }
28335: function_tests++;
28336:
28337: return(test_ret);
28338: }
28339:
28340:
28341: static int
28342: test_xmlNormalizeWindowsPath(void) {
28343: int test_ret = 0;
28344:
28345: int mem_base;
28346: xmlChar * ret_val;
28347: xmlChar * path; /* the input file path */
28348: int n_path;
28349:
28350: for (n_path = 0;n_path < gen_nb_const_xmlChar_ptr;n_path++) {
28351: mem_base = xmlMemBlocks();
28352: path = gen_const_xmlChar_ptr(n_path, 0);
28353:
28354: ret_val = xmlNormalizeWindowsPath((const xmlChar *)path);
28355: desret_xmlChar_ptr(ret_val);
28356: call_tests++;
28357: des_const_xmlChar_ptr(n_path, (const xmlChar *)path, 0);
28358: xmlResetLastError();
28359: if (mem_base != xmlMemBlocks()) {
28360: printf("Leak of %d blocks found in xmlNormalizeWindowsPath",
28361: xmlMemBlocks() - mem_base);
28362: test_ret++;
28363: printf(" %d", n_path);
28364: printf("\n");
28365: }
28366: }
28367: function_tests++;
28368:
28369: return(test_ret);
28370: }
28371:
28372:
28373: static int
28374: test_xmlOutputBufferCreateBuffer(void) {
28375: int test_ret = 0;
28376:
28377: #if defined(LIBXML_OUTPUT_ENABLED)
28378: int mem_base;
28379: xmlOutputBufferPtr ret_val;
28380: xmlBufferPtr buffer; /* a xmlBufferPtr */
28381: int n_buffer;
28382: xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */
28383: int n_encoder;
28384:
28385: for (n_buffer = 0;n_buffer < gen_nb_xmlBufferPtr;n_buffer++) {
28386: for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) {
28387: mem_base = xmlMemBlocks();
28388: buffer = gen_xmlBufferPtr(n_buffer, 0);
28389: encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 1);
28390:
28391: ret_val = xmlOutputBufferCreateBuffer(buffer, encoder);
28392: desret_xmlOutputBufferPtr(ret_val);
28393: call_tests++;
28394: des_xmlBufferPtr(n_buffer, buffer, 0);
28395: des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 1);
28396: xmlResetLastError();
28397: if (mem_base != xmlMemBlocks()) {
28398: printf("Leak of %d blocks found in xmlOutputBufferCreateBuffer",
28399: xmlMemBlocks() - mem_base);
28400: test_ret++;
28401: printf(" %d", n_buffer);
28402: printf(" %d", n_encoder);
28403: printf("\n");
28404: }
28405: }
28406: }
28407: function_tests++;
28408: #endif
28409:
28410: return(test_ret);
28411: }
28412:
28413:
28414: static int
28415: test_xmlOutputBufferCreateFd(void) {
28416: int test_ret = 0;
28417:
28418: #if defined(LIBXML_OUTPUT_ENABLED)
28419: int mem_base;
28420: xmlOutputBufferPtr ret_val;
28421: int fd; /* a file descriptor number */
28422: int n_fd;
28423: xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */
28424: int n_encoder;
28425:
28426: for (n_fd = 0;n_fd < gen_nb_int;n_fd++) {
28427: for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) {
28428: mem_base = xmlMemBlocks();
28429: fd = gen_int(n_fd, 0);
28430: encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 1);
28431:
28432: ret_val = xmlOutputBufferCreateFd(fd, encoder);
28433: desret_xmlOutputBufferPtr(ret_val);
28434: call_tests++;
28435: des_int(n_fd, fd, 0);
28436: des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 1);
28437: xmlResetLastError();
28438: if (mem_base != xmlMemBlocks()) {
28439: printf("Leak of %d blocks found in xmlOutputBufferCreateFd",
28440: xmlMemBlocks() - mem_base);
28441: test_ret++;
28442: printf(" %d", n_fd);
28443: printf(" %d", n_encoder);
28444: printf("\n");
28445: }
28446: }
28447: }
28448: function_tests++;
28449: #endif
28450:
28451: return(test_ret);
28452: }
28453:
28454:
28455: static int
28456: test_xmlOutputBufferCreateFile(void) {
28457: int test_ret = 0;
28458:
28459: #if defined(LIBXML_OUTPUT_ENABLED)
28460: int mem_base;
28461: xmlOutputBufferPtr ret_val;
28462: FILE * file; /* a FILE* */
28463: int n_file;
28464: xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */
28465: int n_encoder;
28466:
28467: for (n_file = 0;n_file < gen_nb_FILE_ptr;n_file++) {
28468: for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) {
28469: mem_base = xmlMemBlocks();
28470: file = gen_FILE_ptr(n_file, 0);
28471: encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 1);
28472:
28473: ret_val = xmlOutputBufferCreateFile(file, encoder);
28474: desret_xmlOutputBufferPtr(ret_val);
28475: call_tests++;
28476: des_FILE_ptr(n_file, file, 0);
28477: des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 1);
28478: xmlResetLastError();
28479: if (mem_base != xmlMemBlocks()) {
28480: printf("Leak of %d blocks found in xmlOutputBufferCreateFile",
28481: xmlMemBlocks() - mem_base);
28482: test_ret++;
28483: printf(" %d", n_file);
28484: printf(" %d", n_encoder);
28485: printf("\n");
28486: }
28487: }
28488: }
28489: function_tests++;
28490: #endif
28491:
28492: return(test_ret);
28493: }
28494:
28495:
28496: static int
28497: test_xmlOutputBufferCreateFilename(void) {
28498: int test_ret = 0;
28499:
28500: #if defined(LIBXML_OUTPUT_ENABLED)
28501: int mem_base;
28502: xmlOutputBufferPtr ret_val;
28503: const char * URI; /* a C string containing the URI or filename */
28504: int n_URI;
28505: xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */
28506: int n_encoder;
28507: int compression; /* the compression ration (0 none, 9 max). */
28508: int n_compression;
28509:
28510: for (n_URI = 0;n_URI < gen_nb_fileoutput;n_URI++) {
28511: for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) {
28512: for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
28513: mem_base = xmlMemBlocks();
28514: URI = gen_fileoutput(n_URI, 0);
28515: encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 1);
28516: compression = gen_int(n_compression, 2);
28517:
28518: ret_val = xmlOutputBufferCreateFilename(URI, encoder, compression);
28519: desret_xmlOutputBufferPtr(ret_val);
28520: call_tests++;
28521: des_fileoutput(n_URI, URI, 0);
28522: des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 1);
28523: des_int(n_compression, compression, 2);
28524: xmlResetLastError();
28525: if (mem_base != xmlMemBlocks()) {
28526: printf("Leak of %d blocks found in xmlOutputBufferCreateFilename",
28527: xmlMemBlocks() - mem_base);
28528: test_ret++;
28529: printf(" %d", n_URI);
28530: printf(" %d", n_encoder);
28531: printf(" %d", n_compression);
28532: printf("\n");
28533: }
28534: }
28535: }
28536: }
28537: function_tests++;
28538: #endif
28539:
28540: return(test_ret);
28541: }
28542:
28543:
28544: static int
28545: test_xmlOutputBufferFlush(void) {
28546: int test_ret = 0;
28547:
28548: #if defined(LIBXML_OUTPUT_ENABLED)
28549: int mem_base;
28550: int ret_val;
28551: xmlOutputBufferPtr out; /* a buffered output */
28552: int n_out;
28553:
28554: for (n_out = 0;n_out < gen_nb_xmlOutputBufferPtr;n_out++) {
28555: mem_base = xmlMemBlocks();
28556: out = gen_xmlOutputBufferPtr(n_out, 0);
28557:
28558: ret_val = xmlOutputBufferFlush(out);
28559: desret_int(ret_val);
28560: call_tests++;
28561: des_xmlOutputBufferPtr(n_out, out, 0);
28562: xmlResetLastError();
28563: if (mem_base != xmlMemBlocks()) {
28564: printf("Leak of %d blocks found in xmlOutputBufferFlush",
28565: xmlMemBlocks() - mem_base);
28566: test_ret++;
28567: printf(" %d", n_out);
28568: printf("\n");
28569: }
28570: }
28571: function_tests++;
28572: #endif
28573:
28574: return(test_ret);
28575: }
28576:
28577:
28578: static int
1.1.1.3 ! misho 28579: test_xmlOutputBufferGetContent(void) {
! 28580: int test_ret = 0;
! 28581:
! 28582: #if defined(LIBXML_OUTPUT_ENABLED)
! 28583: int mem_base;
! 28584: const xmlChar * ret_val;
! 28585: xmlOutputBufferPtr out; /* an xmlOutputBufferPtr */
! 28586: int n_out;
! 28587:
! 28588: for (n_out = 0;n_out < gen_nb_xmlOutputBufferPtr;n_out++) {
! 28589: mem_base = xmlMemBlocks();
! 28590: out = gen_xmlOutputBufferPtr(n_out, 0);
! 28591:
! 28592: ret_val = xmlOutputBufferGetContent(out);
! 28593: desret_const_xmlChar_ptr(ret_val);
! 28594: call_tests++;
! 28595: des_xmlOutputBufferPtr(n_out, out, 0);
! 28596: xmlResetLastError();
! 28597: if (mem_base != xmlMemBlocks()) {
! 28598: printf("Leak of %d blocks found in xmlOutputBufferGetContent",
! 28599: xmlMemBlocks() - mem_base);
! 28600: test_ret++;
! 28601: printf(" %d", n_out);
! 28602: printf("\n");
! 28603: }
! 28604: }
! 28605: function_tests++;
! 28606: #endif
! 28607:
! 28608: return(test_ret);
! 28609: }
! 28610:
! 28611:
! 28612: static int
! 28613: test_xmlOutputBufferGetSize(void) {
! 28614: int test_ret = 0;
! 28615:
! 28616:
! 28617: /* missing type support */
! 28618: return(test_ret);
! 28619: }
! 28620:
! 28621:
! 28622: static int
1.1 misho 28623: test_xmlOutputBufferWrite(void) {
28624: int test_ret = 0;
28625:
28626: #if defined(LIBXML_OUTPUT_ENABLED)
28627: int mem_base;
28628: int ret_val;
28629: xmlOutputBufferPtr out; /* a buffered parser output */
28630: int n_out;
28631: int len; /* the size in bytes of the array. */
28632: int n_len;
28633: char * buf; /* an char array */
28634: int n_buf;
28635:
28636: for (n_out = 0;n_out < gen_nb_xmlOutputBufferPtr;n_out++) {
28637: for (n_len = 0;n_len < gen_nb_int;n_len++) {
28638: for (n_buf = 0;n_buf < gen_nb_const_char_ptr;n_buf++) {
28639: mem_base = xmlMemBlocks();
28640: out = gen_xmlOutputBufferPtr(n_out, 0);
28641: len = gen_int(n_len, 1);
28642: buf = gen_const_char_ptr(n_buf, 2);
28643:
28644: ret_val = xmlOutputBufferWrite(out, len, (const char *)buf);
28645: desret_int(ret_val);
28646: call_tests++;
28647: des_xmlOutputBufferPtr(n_out, out, 0);
28648: des_int(n_len, len, 1);
28649: des_const_char_ptr(n_buf, (const char *)buf, 2);
28650: xmlResetLastError();
28651: if (mem_base != xmlMemBlocks()) {
28652: printf("Leak of %d blocks found in xmlOutputBufferWrite",
28653: xmlMemBlocks() - mem_base);
28654: test_ret++;
28655: printf(" %d", n_out);
28656: printf(" %d", n_len);
28657: printf(" %d", n_buf);
28658: printf("\n");
28659: }
28660: }
28661: }
28662: }
28663: function_tests++;
28664: #endif
28665:
28666: return(test_ret);
28667: }
28668:
28669:
28670: static int
28671: test_xmlOutputBufferWriteEscape(void) {
28672: int test_ret = 0;
28673:
28674:
28675: /* missing type support */
28676: return(test_ret);
28677: }
28678:
28679:
28680: static int
28681: test_xmlOutputBufferWriteString(void) {
28682: int test_ret = 0;
28683:
28684: #if defined(LIBXML_OUTPUT_ENABLED)
28685: int mem_base;
28686: int ret_val;
28687: xmlOutputBufferPtr out; /* a buffered parser output */
28688: int n_out;
28689: char * str; /* a zero terminated C string */
28690: int n_str;
28691:
28692: for (n_out = 0;n_out < gen_nb_xmlOutputBufferPtr;n_out++) {
28693: for (n_str = 0;n_str < gen_nb_const_char_ptr;n_str++) {
28694: mem_base = xmlMemBlocks();
28695: out = gen_xmlOutputBufferPtr(n_out, 0);
28696: str = gen_const_char_ptr(n_str, 1);
28697:
28698: ret_val = xmlOutputBufferWriteString(out, (const char *)str);
28699: desret_int(ret_val);
28700: call_tests++;
28701: des_xmlOutputBufferPtr(n_out, out, 0);
28702: des_const_char_ptr(n_str, (const char *)str, 1);
28703: xmlResetLastError();
28704: if (mem_base != xmlMemBlocks()) {
28705: printf("Leak of %d blocks found in xmlOutputBufferWriteString",
28706: xmlMemBlocks() - mem_base);
28707: test_ret++;
28708: printf(" %d", n_out);
28709: printf(" %d", n_str);
28710: printf("\n");
28711: }
28712: }
28713: }
28714: function_tests++;
28715: #endif
28716:
28717: return(test_ret);
28718: }
28719:
28720:
28721: static int
28722: test_xmlParserGetDirectory(void) {
28723: int test_ret = 0;
28724:
28725:
28726: /* missing type support */
28727: return(test_ret);
28728: }
28729:
28730:
28731: static int
28732: test_xmlParserInputBufferCreateFd(void) {
28733: int test_ret = 0;
28734:
28735: int mem_base;
28736: xmlParserInputBufferPtr ret_val;
28737: int fd; /* a file descriptor number */
28738: int n_fd;
28739: xmlCharEncoding enc; /* the charset encoding if known */
28740: int n_enc;
28741:
28742: for (n_fd = 0;n_fd < gen_nb_int;n_fd++) {
28743: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
28744: mem_base = xmlMemBlocks();
28745: fd = gen_int(n_fd, 0);
28746: enc = gen_xmlCharEncoding(n_enc, 1);
28747: if (fd >= 0) fd = -1;
28748:
28749: ret_val = xmlParserInputBufferCreateFd(fd, enc);
28750: desret_xmlParserInputBufferPtr(ret_val);
28751: call_tests++;
28752: des_int(n_fd, fd, 0);
28753: des_xmlCharEncoding(n_enc, enc, 1);
28754: xmlResetLastError();
28755: if (mem_base != xmlMemBlocks()) {
28756: printf("Leak of %d blocks found in xmlParserInputBufferCreateFd",
28757: xmlMemBlocks() - mem_base);
28758: test_ret++;
28759: printf(" %d", n_fd);
28760: printf(" %d", n_enc);
28761: printf("\n");
28762: }
28763: }
28764: }
28765: function_tests++;
28766:
28767: return(test_ret);
28768: }
28769:
28770:
28771: static int
28772: test_xmlParserInputBufferCreateFile(void) {
28773: int test_ret = 0;
28774:
28775: int mem_base;
28776: xmlParserInputBufferPtr ret_val;
28777: FILE * file; /* a FILE* */
28778: int n_file;
28779: xmlCharEncoding enc; /* the charset encoding if known */
28780: int n_enc;
28781:
28782: for (n_file = 0;n_file < gen_nb_FILE_ptr;n_file++) {
28783: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
28784: mem_base = xmlMemBlocks();
28785: file = gen_FILE_ptr(n_file, 0);
28786: enc = gen_xmlCharEncoding(n_enc, 1);
28787:
28788: ret_val = xmlParserInputBufferCreateFile(file, enc);
28789: desret_xmlParserInputBufferPtr(ret_val);
28790: call_tests++;
28791: des_FILE_ptr(n_file, file, 0);
28792: des_xmlCharEncoding(n_enc, enc, 1);
28793: xmlResetLastError();
28794: if (mem_base != xmlMemBlocks()) {
28795: printf("Leak of %d blocks found in xmlParserInputBufferCreateFile",
28796: xmlMemBlocks() - mem_base);
28797: test_ret++;
28798: printf(" %d", n_file);
28799: printf(" %d", n_enc);
28800: printf("\n");
28801: }
28802: }
28803: }
28804: function_tests++;
28805:
28806: return(test_ret);
28807: }
28808:
28809:
28810: static int
28811: test_xmlParserInputBufferCreateFilename(void) {
28812: int test_ret = 0;
28813:
28814: int mem_base;
28815: xmlParserInputBufferPtr ret_val;
28816: const char * URI; /* a C string containing the URI or filename */
28817: int n_URI;
28818: xmlCharEncoding enc; /* the charset encoding if known */
28819: int n_enc;
28820:
28821: for (n_URI = 0;n_URI < gen_nb_fileoutput;n_URI++) {
28822: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
28823: mem_base = xmlMemBlocks();
28824: URI = gen_fileoutput(n_URI, 0);
28825: enc = gen_xmlCharEncoding(n_enc, 1);
28826:
28827: ret_val = xmlParserInputBufferCreateFilename(URI, enc);
28828: desret_xmlParserInputBufferPtr(ret_val);
28829: call_tests++;
28830: des_fileoutput(n_URI, URI, 0);
28831: des_xmlCharEncoding(n_enc, enc, 1);
28832: xmlResetLastError();
28833: if (mem_base != xmlMemBlocks()) {
28834: printf("Leak of %d blocks found in xmlParserInputBufferCreateFilename",
28835: xmlMemBlocks() - mem_base);
28836: test_ret++;
28837: printf(" %d", n_URI);
28838: printf(" %d", n_enc);
28839: printf("\n");
28840: }
28841: }
28842: }
28843: function_tests++;
28844:
28845: return(test_ret);
28846: }
28847:
28848:
28849: static int
28850: test_xmlParserInputBufferCreateMem(void) {
28851: int test_ret = 0;
28852:
28853: int mem_base;
28854: xmlParserInputBufferPtr ret_val;
28855: char * mem; /* the memory input */
28856: int n_mem;
28857: int size; /* the length of the memory block */
28858: int n_size;
28859: xmlCharEncoding enc; /* the charset encoding if known */
28860: int n_enc;
28861:
28862: for (n_mem = 0;n_mem < gen_nb_const_char_ptr;n_mem++) {
28863: for (n_size = 0;n_size < gen_nb_int;n_size++) {
28864: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
28865: mem_base = xmlMemBlocks();
28866: mem = gen_const_char_ptr(n_mem, 0);
28867: size = gen_int(n_size, 1);
28868: enc = gen_xmlCharEncoding(n_enc, 2);
28869:
28870: ret_val = xmlParserInputBufferCreateMem((const char *)mem, size, enc);
28871: desret_xmlParserInputBufferPtr(ret_val);
28872: call_tests++;
28873: des_const_char_ptr(n_mem, (const char *)mem, 0);
28874: des_int(n_size, size, 1);
28875: des_xmlCharEncoding(n_enc, enc, 2);
28876: xmlResetLastError();
28877: if (mem_base != xmlMemBlocks()) {
28878: printf("Leak of %d blocks found in xmlParserInputBufferCreateMem",
28879: xmlMemBlocks() - mem_base);
28880: test_ret++;
28881: printf(" %d", n_mem);
28882: printf(" %d", n_size);
28883: printf(" %d", n_enc);
28884: printf("\n");
28885: }
28886: }
28887: }
28888: }
28889: function_tests++;
28890:
28891: return(test_ret);
28892: }
28893:
28894:
28895: static int
28896: test_xmlParserInputBufferCreateStatic(void) {
28897: int test_ret = 0;
28898:
28899: int mem_base;
28900: xmlParserInputBufferPtr ret_val;
28901: char * mem; /* the memory input */
28902: int n_mem;
28903: int size; /* the length of the memory block */
28904: int n_size;
28905: xmlCharEncoding enc; /* the charset encoding if known */
28906: int n_enc;
28907:
28908: for (n_mem = 0;n_mem < gen_nb_const_char_ptr;n_mem++) {
28909: for (n_size = 0;n_size < gen_nb_int;n_size++) {
28910: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
28911: mem_base = xmlMemBlocks();
28912: mem = gen_const_char_ptr(n_mem, 0);
28913: size = gen_int(n_size, 1);
28914: enc = gen_xmlCharEncoding(n_enc, 2);
28915:
28916: ret_val = xmlParserInputBufferCreateStatic((const char *)mem, size, enc);
28917: desret_xmlParserInputBufferPtr(ret_val);
28918: call_tests++;
28919: des_const_char_ptr(n_mem, (const char *)mem, 0);
28920: des_int(n_size, size, 1);
28921: des_xmlCharEncoding(n_enc, enc, 2);
28922: xmlResetLastError();
28923: if (mem_base != xmlMemBlocks()) {
28924: printf("Leak of %d blocks found in xmlParserInputBufferCreateStatic",
28925: xmlMemBlocks() - mem_base);
28926: test_ret++;
28927: printf(" %d", n_mem);
28928: printf(" %d", n_size);
28929: printf(" %d", n_enc);
28930: printf("\n");
28931: }
28932: }
28933: }
28934: }
28935: function_tests++;
28936:
28937: return(test_ret);
28938: }
28939:
28940:
28941: static int
28942: test_xmlParserInputBufferGrow(void) {
28943: int test_ret = 0;
28944:
28945: int mem_base;
28946: int ret_val;
28947: xmlParserInputBufferPtr in; /* a buffered parser input */
28948: int n_in;
28949: int len; /* indicative value of the amount of chars to read */
28950: int n_len;
28951:
28952: for (n_in = 0;n_in < gen_nb_xmlParserInputBufferPtr;n_in++) {
28953: for (n_len = 0;n_len < gen_nb_int;n_len++) {
28954: mem_base = xmlMemBlocks();
28955: in = gen_xmlParserInputBufferPtr(n_in, 0);
28956: len = gen_int(n_len, 1);
28957:
28958: ret_val = xmlParserInputBufferGrow(in, len);
28959: desret_int(ret_val);
28960: call_tests++;
28961: des_xmlParserInputBufferPtr(n_in, in, 0);
28962: des_int(n_len, len, 1);
28963: xmlResetLastError();
28964: if (mem_base != xmlMemBlocks()) {
28965: printf("Leak of %d blocks found in xmlParserInputBufferGrow",
28966: xmlMemBlocks() - mem_base);
28967: test_ret++;
28968: printf(" %d", n_in);
28969: printf(" %d", n_len);
28970: printf("\n");
28971: }
28972: }
28973: }
28974: function_tests++;
28975:
28976: return(test_ret);
28977: }
28978:
28979:
28980: static int
28981: test_xmlParserInputBufferPush(void) {
28982: int test_ret = 0;
28983:
28984: int mem_base;
28985: int ret_val;
28986: xmlParserInputBufferPtr in; /* a buffered parser input */
28987: int n_in;
28988: int len; /* the size in bytes of the array. */
28989: int n_len;
28990: char * buf; /* an char array */
28991: int n_buf;
28992:
28993: for (n_in = 0;n_in < gen_nb_xmlParserInputBufferPtr;n_in++) {
28994: for (n_len = 0;n_len < gen_nb_int;n_len++) {
28995: for (n_buf = 0;n_buf < gen_nb_const_char_ptr;n_buf++) {
28996: mem_base = xmlMemBlocks();
28997: in = gen_xmlParserInputBufferPtr(n_in, 0);
28998: len = gen_int(n_len, 1);
28999: buf = gen_const_char_ptr(n_buf, 2);
29000:
29001: ret_val = xmlParserInputBufferPush(in, len, (const char *)buf);
29002: desret_int(ret_val);
29003: call_tests++;
29004: des_xmlParserInputBufferPtr(n_in, in, 0);
29005: des_int(n_len, len, 1);
29006: des_const_char_ptr(n_buf, (const char *)buf, 2);
29007: xmlResetLastError();
29008: if (mem_base != xmlMemBlocks()) {
29009: printf("Leak of %d blocks found in xmlParserInputBufferPush",
29010: xmlMemBlocks() - mem_base);
29011: test_ret++;
29012: printf(" %d", n_in);
29013: printf(" %d", n_len);
29014: printf(" %d", n_buf);
29015: printf("\n");
29016: }
29017: }
29018: }
29019: }
29020: function_tests++;
29021:
29022: return(test_ret);
29023: }
29024:
29025:
29026: static int
29027: test_xmlParserInputBufferRead(void) {
29028: int test_ret = 0;
29029:
29030: int mem_base;
29031: int ret_val;
29032: xmlParserInputBufferPtr in; /* a buffered parser input */
29033: int n_in;
29034: int len; /* indicative value of the amount of chars to read */
29035: int n_len;
29036:
29037: for (n_in = 0;n_in < gen_nb_xmlParserInputBufferPtr;n_in++) {
29038: for (n_len = 0;n_len < gen_nb_int;n_len++) {
29039: mem_base = xmlMemBlocks();
29040: in = gen_xmlParserInputBufferPtr(n_in, 0);
29041: len = gen_int(n_len, 1);
29042:
29043: ret_val = xmlParserInputBufferRead(in, len);
29044: desret_int(ret_val);
29045: call_tests++;
29046: des_xmlParserInputBufferPtr(n_in, in, 0);
29047: des_int(n_len, len, 1);
29048: xmlResetLastError();
29049: if (mem_base != xmlMemBlocks()) {
29050: printf("Leak of %d blocks found in xmlParserInputBufferRead",
29051: xmlMemBlocks() - mem_base);
29052: test_ret++;
29053: printf(" %d", n_in);
29054: printf(" %d", n_len);
29055: printf("\n");
29056: }
29057: }
29058: }
29059: function_tests++;
29060:
29061: return(test_ret);
29062: }
29063:
29064:
29065: static int
29066: test_xmlPopInputCallbacks(void) {
29067: int test_ret = 0;
29068:
29069: int mem_base;
29070: int ret_val;
29071:
29072: mem_base = xmlMemBlocks();
29073:
29074: ret_val = xmlPopInputCallbacks();
29075: desret_int(ret_val);
29076: call_tests++;
29077: xmlResetLastError();
29078: if (mem_base != xmlMemBlocks()) {
29079: printf("Leak of %d blocks found in xmlPopInputCallbacks",
29080: xmlMemBlocks() - mem_base);
29081: test_ret++;
29082: printf("\n");
29083: }
29084: function_tests++;
29085:
29086: return(test_ret);
29087: }
29088:
29089:
29090: static int
29091: test_xmlRegisterDefaultInputCallbacks(void) {
29092: int test_ret = 0;
29093:
29094: int mem_base;
29095:
29096: mem_base = xmlMemBlocks();
29097:
29098: xmlRegisterDefaultInputCallbacks();
29099: call_tests++;
29100: xmlResetLastError();
29101: if (mem_base != xmlMemBlocks()) {
29102: printf("Leak of %d blocks found in xmlRegisterDefaultInputCallbacks",
29103: xmlMemBlocks() - mem_base);
29104: test_ret++;
29105: printf("\n");
29106: }
29107: function_tests++;
29108:
29109: return(test_ret);
29110: }
29111:
29112:
29113: static int
29114: test_xmlRegisterDefaultOutputCallbacks(void) {
29115: int test_ret = 0;
29116:
29117: #if defined(LIBXML_OUTPUT_ENABLED)
29118: int mem_base;
29119:
29120: mem_base = xmlMemBlocks();
29121:
29122: xmlRegisterDefaultOutputCallbacks();
29123: call_tests++;
29124: xmlResetLastError();
29125: if (mem_base != xmlMemBlocks()) {
29126: printf("Leak of %d blocks found in xmlRegisterDefaultOutputCallbacks",
29127: xmlMemBlocks() - mem_base);
29128: test_ret++;
29129: printf("\n");
29130: }
29131: function_tests++;
29132: #endif
29133:
29134: return(test_ret);
29135: }
29136:
29137:
29138: static int
29139: test_xmlRegisterHTTPPostCallbacks(void) {
29140: int test_ret = 0;
29141:
29142: #if defined(LIBXML_OUTPUT_ENABLED) && defined(LIBXML_HTTP_ENABLED)
29143: int mem_base;
29144:
29145: mem_base = xmlMemBlocks();
29146:
29147: xmlRegisterHTTPPostCallbacks();
29148: call_tests++;
29149: xmlResetLastError();
29150: if (mem_base != xmlMemBlocks()) {
29151: printf("Leak of %d blocks found in xmlRegisterHTTPPostCallbacks",
29152: xmlMemBlocks() - mem_base);
29153: test_ret++;
29154: printf("\n");
29155: }
29156: function_tests++;
29157: #endif
29158:
29159: return(test_ret);
29160: }
29161:
29162: static int
29163: test_xmlIO(void) {
29164: int test_ret = 0;
29165:
1.1.1.3 ! misho 29166: if (quiet == 0) printf("Testing xmlIO : 40 of 50 functions ...\n");
1.1 misho 29167: test_ret += test_xmlAllocOutputBuffer();
29168: test_ret += test_xmlAllocParserInputBuffer();
29169: test_ret += test_xmlCheckFilename();
29170: test_ret += test_xmlCheckHTTPInput();
29171: test_ret += test_xmlCleanupInputCallbacks();
29172: test_ret += test_xmlCleanupOutputCallbacks();
29173: test_ret += test_xmlFileClose();
29174: test_ret += test_xmlFileMatch();
29175: test_ret += test_xmlFileOpen();
29176: test_ret += test_xmlFileRead();
29177: test_ret += test_xmlIOFTPClose();
29178: test_ret += test_xmlIOFTPMatch();
29179: test_ret += test_xmlIOFTPOpen();
29180: test_ret += test_xmlIOFTPRead();
29181: test_ret += test_xmlIOHTTPClose();
29182: test_ret += test_xmlIOHTTPMatch();
29183: test_ret += test_xmlIOHTTPOpen();
29184: test_ret += test_xmlIOHTTPRead();
29185: test_ret += test_xmlNoNetExternalEntityLoader();
29186: test_ret += test_xmlNormalizeWindowsPath();
29187: test_ret += test_xmlOutputBufferCreateBuffer();
29188: test_ret += test_xmlOutputBufferCreateFd();
29189: test_ret += test_xmlOutputBufferCreateFile();
29190: test_ret += test_xmlOutputBufferCreateFilename();
29191: test_ret += test_xmlOutputBufferFlush();
1.1.1.3 ! misho 29192: test_ret += test_xmlOutputBufferGetContent();
! 29193: test_ret += test_xmlOutputBufferGetSize();
1.1 misho 29194: test_ret += test_xmlOutputBufferWrite();
29195: test_ret += test_xmlOutputBufferWriteEscape();
29196: test_ret += test_xmlOutputBufferWriteString();
29197: test_ret += test_xmlParserGetDirectory();
29198: test_ret += test_xmlParserInputBufferCreateFd();
29199: test_ret += test_xmlParserInputBufferCreateFile();
29200: test_ret += test_xmlParserInputBufferCreateFilename();
29201: test_ret += test_xmlParserInputBufferCreateMem();
29202: test_ret += test_xmlParserInputBufferCreateStatic();
29203: test_ret += test_xmlParserInputBufferGrow();
29204: test_ret += test_xmlParserInputBufferPush();
29205: test_ret += test_xmlParserInputBufferRead();
29206: test_ret += test_xmlPopInputCallbacks();
29207: test_ret += test_xmlRegisterDefaultInputCallbacks();
29208: test_ret += test_xmlRegisterDefaultOutputCallbacks();
29209: test_ret += test_xmlRegisterHTTPPostCallbacks();
29210:
29211: if (test_ret != 0)
29212: printf("Module xmlIO: %d errors\n", test_ret);
29213: return(test_ret);
29214: }
29215: #ifdef LIBXML_AUTOMATA_ENABLED
29216:
29217: #define gen_nb_xmlAutomataPtr 1
29218: static xmlAutomataPtr gen_xmlAutomataPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29219: return(NULL);
29220: }
29221: static void des_xmlAutomataPtr(int no ATTRIBUTE_UNUSED, xmlAutomataPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29222: }
29223: #endif
29224:
29225:
29226: static int
29227: test_xmlAutomataCompile(void) {
29228: int test_ret = 0;
29229:
29230:
29231: /* missing type support */
29232: return(test_ret);
29233: }
29234:
29235:
29236: static int
29237: test_xmlAutomataGetInitState(void) {
29238: int test_ret = 0;
29239:
29240:
29241: /* missing type support */
29242: return(test_ret);
29243: }
29244:
29245:
29246: static int
29247: test_xmlAutomataIsDeterminist(void) {
29248: int test_ret = 0;
29249:
29250: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_AUTOMATA_ENABLED)
29251: int mem_base;
29252: int ret_val;
29253: xmlAutomataPtr am; /* an automata */
29254: int n_am;
29255:
29256: for (n_am = 0;n_am < gen_nb_xmlAutomataPtr;n_am++) {
29257: mem_base = xmlMemBlocks();
29258: am = gen_xmlAutomataPtr(n_am, 0);
29259:
29260: ret_val = xmlAutomataIsDeterminist(am);
29261: desret_int(ret_val);
29262: call_tests++;
29263: des_xmlAutomataPtr(n_am, am, 0);
29264: xmlResetLastError();
29265: if (mem_base != xmlMemBlocks()) {
29266: printf("Leak of %d blocks found in xmlAutomataIsDeterminist",
29267: xmlMemBlocks() - mem_base);
29268: test_ret++;
29269: printf(" %d", n_am);
29270: printf("\n");
29271: }
29272: }
29273: function_tests++;
29274: #endif
29275:
29276: return(test_ret);
29277: }
29278:
29279: #ifdef LIBXML_AUTOMATA_ENABLED
29280:
29281: #define gen_nb_xmlAutomataStatePtr 1
29282: static xmlAutomataStatePtr gen_xmlAutomataStatePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29283: return(NULL);
29284: }
29285: static void des_xmlAutomataStatePtr(int no ATTRIBUTE_UNUSED, xmlAutomataStatePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29286: }
29287: #endif
29288:
29289:
29290: static int
29291: test_xmlAutomataNewAllTrans(void) {
29292: int test_ret = 0;
29293:
29294:
29295: /* missing type support */
29296: return(test_ret);
29297: }
29298:
29299:
29300: static int
29301: test_xmlAutomataNewCountTrans(void) {
29302: int test_ret = 0;
29303:
29304:
29305: /* missing type support */
29306: return(test_ret);
29307: }
29308:
29309:
29310: static int
29311: test_xmlAutomataNewCountTrans2(void) {
29312: int test_ret = 0;
29313:
29314:
29315: /* missing type support */
29316: return(test_ret);
29317: }
29318:
29319:
29320: static int
29321: test_xmlAutomataNewCountedTrans(void) {
29322: int test_ret = 0;
29323:
29324:
29325: /* missing type support */
29326: return(test_ret);
29327: }
29328:
29329:
29330: static int
29331: test_xmlAutomataNewCounter(void) {
29332: int test_ret = 0;
29333:
29334: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_AUTOMATA_ENABLED)
29335: int mem_base;
29336: int ret_val;
29337: xmlAutomataPtr am; /* an automata */
29338: int n_am;
29339: int min; /* the minimal value on the counter */
29340: int n_min;
29341: int max; /* the maximal value on the counter */
29342: int n_max;
29343:
29344: for (n_am = 0;n_am < gen_nb_xmlAutomataPtr;n_am++) {
29345: for (n_min = 0;n_min < gen_nb_int;n_min++) {
29346: for (n_max = 0;n_max < gen_nb_int;n_max++) {
29347: mem_base = xmlMemBlocks();
29348: am = gen_xmlAutomataPtr(n_am, 0);
29349: min = gen_int(n_min, 1);
29350: max = gen_int(n_max, 2);
29351:
29352: ret_val = xmlAutomataNewCounter(am, min, max);
29353: desret_int(ret_val);
29354: call_tests++;
29355: des_xmlAutomataPtr(n_am, am, 0);
29356: des_int(n_min, min, 1);
29357: des_int(n_max, max, 2);
29358: xmlResetLastError();
29359: if (mem_base != xmlMemBlocks()) {
29360: printf("Leak of %d blocks found in xmlAutomataNewCounter",
29361: xmlMemBlocks() - mem_base);
29362: test_ret++;
29363: printf(" %d", n_am);
29364: printf(" %d", n_min);
29365: printf(" %d", n_max);
29366: printf("\n");
29367: }
29368: }
29369: }
29370: }
29371: function_tests++;
29372: #endif
29373:
29374: return(test_ret);
29375: }
29376:
29377:
29378: static int
29379: test_xmlAutomataNewCounterTrans(void) {
29380: int test_ret = 0;
29381:
29382:
29383: /* missing type support */
29384: return(test_ret);
29385: }
29386:
29387:
29388: static int
29389: test_xmlAutomataNewEpsilon(void) {
29390: int test_ret = 0;
29391:
29392:
29393: /* missing type support */
29394: return(test_ret);
29395: }
29396:
29397:
29398: static int
29399: test_xmlAutomataNewNegTrans(void) {
29400: int test_ret = 0;
29401:
29402:
29403: /* missing type support */
29404: return(test_ret);
29405: }
29406:
29407:
29408: static int
29409: test_xmlAutomataNewOnceTrans(void) {
29410: int test_ret = 0;
29411:
29412:
29413: /* missing type support */
29414: return(test_ret);
29415: }
29416:
29417:
29418: static int
29419: test_xmlAutomataNewOnceTrans2(void) {
29420: int test_ret = 0;
29421:
29422:
29423: /* missing type support */
29424: return(test_ret);
29425: }
29426:
29427:
29428: static int
29429: test_xmlAutomataNewState(void) {
29430: int test_ret = 0;
29431:
29432:
29433: /* missing type support */
29434: return(test_ret);
29435: }
29436:
29437:
29438: static int
29439: test_xmlAutomataNewTransition(void) {
29440: int test_ret = 0;
29441:
29442:
29443: /* missing type support */
29444: return(test_ret);
29445: }
29446:
29447:
29448: static int
29449: test_xmlAutomataNewTransition2(void) {
29450: int test_ret = 0;
29451:
29452:
29453: /* missing type support */
29454: return(test_ret);
29455: }
29456:
29457:
29458: static int
29459: test_xmlAutomataSetFinalState(void) {
29460: int test_ret = 0;
29461:
29462: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_AUTOMATA_ENABLED)
29463: int mem_base;
29464: int ret_val;
29465: xmlAutomataPtr am; /* an automata */
29466: int n_am;
29467: xmlAutomataStatePtr state; /* a state in this automata */
29468: int n_state;
29469:
29470: for (n_am = 0;n_am < gen_nb_xmlAutomataPtr;n_am++) {
29471: for (n_state = 0;n_state < gen_nb_xmlAutomataStatePtr;n_state++) {
29472: mem_base = xmlMemBlocks();
29473: am = gen_xmlAutomataPtr(n_am, 0);
29474: state = gen_xmlAutomataStatePtr(n_state, 1);
29475:
29476: ret_val = xmlAutomataSetFinalState(am, state);
29477: desret_int(ret_val);
29478: call_tests++;
29479: des_xmlAutomataPtr(n_am, am, 0);
29480: des_xmlAutomataStatePtr(n_state, state, 1);
29481: xmlResetLastError();
29482: if (mem_base != xmlMemBlocks()) {
29483: printf("Leak of %d blocks found in xmlAutomataSetFinalState",
29484: xmlMemBlocks() - mem_base);
29485: test_ret++;
29486: printf(" %d", n_am);
29487: printf(" %d", n_state);
29488: printf("\n");
29489: }
29490: }
29491: }
29492: function_tests++;
29493: #endif
29494:
29495: return(test_ret);
29496: }
29497:
29498:
29499: static int
29500: test_xmlNewAutomata(void) {
29501: int test_ret = 0;
29502:
29503:
29504: /* missing type support */
29505: return(test_ret);
29506: }
29507:
29508: static int
29509: test_xmlautomata(void) {
29510: int test_ret = 0;
29511:
29512: if (quiet == 0) printf("Testing xmlautomata : 3 of 19 functions ...\n");
29513: test_ret += test_xmlAutomataCompile();
29514: test_ret += test_xmlAutomataGetInitState();
29515: test_ret += test_xmlAutomataIsDeterminist();
29516: test_ret += test_xmlAutomataNewAllTrans();
29517: test_ret += test_xmlAutomataNewCountTrans();
29518: test_ret += test_xmlAutomataNewCountTrans2();
29519: test_ret += test_xmlAutomataNewCountedTrans();
29520: test_ret += test_xmlAutomataNewCounter();
29521: test_ret += test_xmlAutomataNewCounterTrans();
29522: test_ret += test_xmlAutomataNewEpsilon();
29523: test_ret += test_xmlAutomataNewNegTrans();
29524: test_ret += test_xmlAutomataNewOnceTrans();
29525: test_ret += test_xmlAutomataNewOnceTrans2();
29526: test_ret += test_xmlAutomataNewState();
29527: test_ret += test_xmlAutomataNewTransition();
29528: test_ret += test_xmlAutomataNewTransition2();
29529: test_ret += test_xmlAutomataSetFinalState();
29530: test_ret += test_xmlNewAutomata();
29531:
29532: if (test_ret != 0)
29533: printf("Module xmlautomata: %d errors\n", test_ret);
29534: return(test_ret);
29535: }
29536:
29537: #define gen_nb_xmlGenericErrorFunc_ptr 1
29538: static xmlGenericErrorFunc * gen_xmlGenericErrorFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29539: return(NULL);
29540: }
29541: static void des_xmlGenericErrorFunc_ptr(int no ATTRIBUTE_UNUSED, xmlGenericErrorFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29542: }
29543:
29544: static int
29545: test_initGenericErrorDefaultFunc(void) {
29546: int test_ret = 0;
29547:
29548: int mem_base;
29549: xmlGenericErrorFunc * handler; /* the handler */
29550: int n_handler;
29551:
29552: for (n_handler = 0;n_handler < gen_nb_xmlGenericErrorFunc_ptr;n_handler++) {
29553: mem_base = xmlMemBlocks();
29554: handler = gen_xmlGenericErrorFunc_ptr(n_handler, 0);
29555:
29556: initGenericErrorDefaultFunc(handler);
29557: call_tests++;
29558: des_xmlGenericErrorFunc_ptr(n_handler, handler, 0);
29559: xmlResetLastError();
29560: if (mem_base != xmlMemBlocks()) {
29561: printf("Leak of %d blocks found in initGenericErrorDefaultFunc",
29562: xmlMemBlocks() - mem_base);
29563: test_ret++;
29564: printf(" %d", n_handler);
29565: printf("\n");
29566: }
29567: }
29568: function_tests++;
29569:
29570: return(test_ret);
29571: }
29572:
29573:
29574: #define gen_nb_xmlErrorPtr 1
29575: static xmlErrorPtr gen_xmlErrorPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29576: return(NULL);
29577: }
29578: static void des_xmlErrorPtr(int no ATTRIBUTE_UNUSED, xmlErrorPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29579: }
29580:
29581: static int
29582: test_xmlCopyError(void) {
29583: int test_ret = 0;
29584:
29585: int mem_base;
29586: int ret_val;
29587: xmlErrorPtr from; /* a source error */
29588: int n_from;
29589: xmlErrorPtr to; /* a target error */
29590: int n_to;
29591:
29592: for (n_from = 0;n_from < gen_nb_xmlErrorPtr;n_from++) {
29593: for (n_to = 0;n_to < gen_nb_xmlErrorPtr;n_to++) {
29594: mem_base = xmlMemBlocks();
29595: from = gen_xmlErrorPtr(n_from, 0);
29596: to = gen_xmlErrorPtr(n_to, 1);
29597:
29598: ret_val = xmlCopyError(from, to);
29599: desret_int(ret_val);
29600: call_tests++;
29601: des_xmlErrorPtr(n_from, from, 0);
29602: des_xmlErrorPtr(n_to, to, 1);
29603: xmlResetLastError();
29604: if (mem_base != xmlMemBlocks()) {
29605: printf("Leak of %d blocks found in xmlCopyError",
29606: xmlMemBlocks() - mem_base);
29607: test_ret++;
29608: printf(" %d", n_from);
29609: printf(" %d", n_to);
29610: printf("\n");
29611: }
29612: }
29613: }
29614: function_tests++;
29615:
29616: return(test_ret);
29617: }
29618:
29619:
29620: static int
29621: test_xmlCtxtGetLastError(void) {
29622: int test_ret = 0;
29623:
29624:
29625: /* missing type support */
29626: return(test_ret);
29627: }
29628:
29629:
29630: static int
29631: test_xmlCtxtResetLastError(void) {
29632: int test_ret = 0;
29633:
29634: int mem_base;
29635: void * ctx; /* an XML parser context */
29636: int n_ctx;
29637:
29638: for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
29639: mem_base = xmlMemBlocks();
29640: ctx = gen_void_ptr(n_ctx, 0);
29641:
29642: xmlCtxtResetLastError(ctx);
29643: call_tests++;
29644: des_void_ptr(n_ctx, ctx, 0);
29645: xmlResetLastError();
29646: if (mem_base != xmlMemBlocks()) {
29647: printf("Leak of %d blocks found in xmlCtxtResetLastError",
29648: xmlMemBlocks() - mem_base);
29649: test_ret++;
29650: printf(" %d", n_ctx);
29651: printf("\n");
29652: }
29653: }
29654: function_tests++;
29655:
29656: return(test_ret);
29657: }
29658:
29659:
29660: static int
29661: test_xmlGetLastError(void) {
29662: int test_ret = 0;
29663:
29664:
29665: /* missing type support */
29666: return(test_ret);
29667: }
29668:
29669:
29670: static int
29671: test_xmlParserError(void) {
29672: int test_ret = 0;
29673:
29674:
29675: /* missing type support */
29676: return(test_ret);
29677: }
29678:
29679:
29680: static int
29681: test_xmlParserPrintFileContext(void) {
29682: int test_ret = 0;
29683:
29684: int mem_base;
29685: xmlParserInputPtr input; /* an xmlParserInputPtr input */
29686: int n_input;
29687:
29688: for (n_input = 0;n_input < gen_nb_xmlParserInputPtr;n_input++) {
29689: mem_base = xmlMemBlocks();
29690: input = gen_xmlParserInputPtr(n_input, 0);
29691:
29692: xmlParserPrintFileContext(input);
29693: call_tests++;
29694: des_xmlParserInputPtr(n_input, input, 0);
29695: xmlResetLastError();
29696: if (mem_base != xmlMemBlocks()) {
29697: printf("Leak of %d blocks found in xmlParserPrintFileContext",
29698: xmlMemBlocks() - mem_base);
29699: test_ret++;
29700: printf(" %d", n_input);
29701: printf("\n");
29702: }
29703: }
29704: function_tests++;
29705:
29706: return(test_ret);
29707: }
29708:
29709:
29710: static int
29711: test_xmlParserPrintFileInfo(void) {
29712: int test_ret = 0;
29713:
29714: int mem_base;
29715: xmlParserInputPtr input; /* an xmlParserInputPtr input */
29716: int n_input;
29717:
29718: for (n_input = 0;n_input < gen_nb_xmlParserInputPtr;n_input++) {
29719: mem_base = xmlMemBlocks();
29720: input = gen_xmlParserInputPtr(n_input, 0);
29721:
29722: xmlParserPrintFileInfo(input);
29723: call_tests++;
29724: des_xmlParserInputPtr(n_input, input, 0);
29725: xmlResetLastError();
29726: if (mem_base != xmlMemBlocks()) {
29727: printf("Leak of %d blocks found in xmlParserPrintFileInfo",
29728: xmlMemBlocks() - mem_base);
29729: test_ret++;
29730: printf(" %d", n_input);
29731: printf("\n");
29732: }
29733: }
29734: function_tests++;
29735:
29736: return(test_ret);
29737: }
29738:
29739:
29740: static int
29741: test_xmlParserValidityError(void) {
29742: int test_ret = 0;
29743:
29744:
29745: /* missing type support */
29746: return(test_ret);
29747: }
29748:
29749:
29750: static int
29751: test_xmlParserValidityWarning(void) {
29752: int test_ret = 0;
29753:
29754:
29755: /* missing type support */
29756: return(test_ret);
29757: }
29758:
29759:
29760: static int
29761: test_xmlParserWarning(void) {
29762: int test_ret = 0;
29763:
29764:
29765: /* missing type support */
29766: return(test_ret);
29767: }
29768:
29769:
29770: static int
29771: test_xmlResetError(void) {
29772: int test_ret = 0;
29773:
29774: int mem_base;
29775: xmlErrorPtr err; /* pointer to the error. */
29776: int n_err;
29777:
29778: for (n_err = 0;n_err < gen_nb_xmlErrorPtr;n_err++) {
29779: mem_base = xmlMemBlocks();
29780: err = gen_xmlErrorPtr(n_err, 0);
29781:
29782: xmlResetError(err);
29783: call_tests++;
29784: des_xmlErrorPtr(n_err, err, 0);
29785: xmlResetLastError();
29786: if (mem_base != xmlMemBlocks()) {
29787: printf("Leak of %d blocks found in xmlResetError",
29788: xmlMemBlocks() - mem_base);
29789: test_ret++;
29790: printf(" %d", n_err);
29791: printf("\n");
29792: }
29793: }
29794: function_tests++;
29795:
29796: return(test_ret);
29797: }
29798:
29799:
29800: static int
29801: test_xmlResetLastError(void) {
29802: int test_ret = 0;
29803:
29804:
29805:
29806: xmlResetLastError();
29807: call_tests++;
29808: xmlResetLastError();
29809: function_tests++;
29810:
29811: return(test_ret);
29812: }
29813:
29814:
29815: static int
29816: test_xmlSetGenericErrorFunc(void) {
29817: int test_ret = 0;
29818:
29819:
29820: /* missing type support */
29821: return(test_ret);
29822: }
29823:
29824:
29825: static int
29826: test_xmlSetStructuredErrorFunc(void) {
29827: int test_ret = 0;
29828:
29829:
29830: /* missing type support */
29831: return(test_ret);
29832: }
29833:
29834: static int
29835: test_xmlerror(void) {
29836: int test_ret = 0;
29837:
29838: if (quiet == 0) printf("Testing xmlerror : 7 of 15 functions ...\n");
29839: test_ret += test_initGenericErrorDefaultFunc();
29840: test_ret += test_xmlCopyError();
29841: test_ret += test_xmlCtxtGetLastError();
29842: test_ret += test_xmlCtxtResetLastError();
29843: test_ret += test_xmlGetLastError();
29844: test_ret += test_xmlParserError();
29845: test_ret += test_xmlParserPrintFileContext();
29846: test_ret += test_xmlParserPrintFileInfo();
29847: test_ret += test_xmlParserValidityError();
29848: test_ret += test_xmlParserValidityWarning();
29849: test_ret += test_xmlParserWarning();
29850: test_ret += test_xmlResetError();
29851: test_ret += test_xmlResetLastError();
29852: test_ret += test_xmlSetGenericErrorFunc();
29853: test_ret += test_xmlSetStructuredErrorFunc();
29854:
29855: if (test_ret != 0)
29856: printf("Module xmlerror: %d errors\n", test_ret);
29857: return(test_ret);
29858: }
29859: #ifdef LIBXML_MODULES_ENABLED
29860:
29861: #define gen_nb_xmlModulePtr 1
29862: static xmlModulePtr gen_xmlModulePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29863: return(NULL);
29864: }
29865: static void des_xmlModulePtr(int no ATTRIBUTE_UNUSED, xmlModulePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29866: }
29867: #endif
29868:
29869:
29870: static int
29871: test_xmlModuleClose(void) {
29872: int test_ret = 0;
29873:
29874: #if defined(LIBXML_MODULES_ENABLED)
29875: int mem_base;
29876: int ret_val;
29877: xmlModulePtr module; /* the module handle */
29878: int n_module;
29879:
29880: for (n_module = 0;n_module < gen_nb_xmlModulePtr;n_module++) {
29881: mem_base = xmlMemBlocks();
29882: module = gen_xmlModulePtr(n_module, 0);
29883:
29884: ret_val = xmlModuleClose(module);
29885: desret_int(ret_val);
29886: call_tests++;
29887: des_xmlModulePtr(n_module, module, 0);
29888: xmlResetLastError();
29889: if (mem_base != xmlMemBlocks()) {
29890: printf("Leak of %d blocks found in xmlModuleClose",
29891: xmlMemBlocks() - mem_base);
29892: test_ret++;
29893: printf(" %d", n_module);
29894: printf("\n");
29895: }
29896: }
29897: function_tests++;
29898: #endif
29899:
29900: return(test_ret);
29901: }
29902:
29903:
29904: static int
29905: test_xmlModuleOpen(void) {
29906: int test_ret = 0;
29907:
29908:
29909: /* missing type support */
29910: return(test_ret);
29911: }
29912:
29913:
29914: static int
29915: test_xmlModuleSymbol(void) {
29916: int test_ret = 0;
29917:
29918: #if defined(LIBXML_MODULES_ENABLED)
29919: int mem_base;
29920: int ret_val;
29921: xmlModulePtr module; /* the module */
29922: int n_module;
29923: char * name; /* the name of the symbol */
29924: int n_name;
29925: void ** symbol; /* the resulting symbol address */
29926: int n_symbol;
29927:
29928: for (n_module = 0;n_module < gen_nb_xmlModulePtr;n_module++) {
29929: for (n_name = 0;n_name < gen_nb_const_char_ptr;n_name++) {
29930: for (n_symbol = 0;n_symbol < gen_nb_void_ptr_ptr;n_symbol++) {
29931: mem_base = xmlMemBlocks();
29932: module = gen_xmlModulePtr(n_module, 0);
29933: name = gen_const_char_ptr(n_name, 1);
29934: symbol = gen_void_ptr_ptr(n_symbol, 2);
29935:
29936: ret_val = xmlModuleSymbol(module, (const char *)name, symbol);
29937: desret_int(ret_val);
29938: call_tests++;
29939: des_xmlModulePtr(n_module, module, 0);
29940: des_const_char_ptr(n_name, (const char *)name, 1);
29941: des_void_ptr_ptr(n_symbol, symbol, 2);
29942: xmlResetLastError();
29943: if (mem_base != xmlMemBlocks()) {
29944: printf("Leak of %d blocks found in xmlModuleSymbol",
29945: xmlMemBlocks() - mem_base);
29946: test_ret++;
29947: printf(" %d", n_module);
29948: printf(" %d", n_name);
29949: printf(" %d", n_symbol);
29950: printf("\n");
29951: }
29952: }
29953: }
29954: }
29955: function_tests++;
29956: #endif
29957:
29958: return(test_ret);
29959: }
29960:
29961: static int
29962: test_xmlmodule(void) {
29963: int test_ret = 0;
29964:
29965: if (quiet == 0) printf("Testing xmlmodule : 2 of 4 functions ...\n");
29966: test_ret += test_xmlModuleClose();
29967: test_ret += test_xmlModuleOpen();
29968: test_ret += test_xmlModuleSymbol();
29969:
29970: if (test_ret != 0)
29971: printf("Module xmlmodule: %d errors\n", test_ret);
29972: return(test_ret);
29973: }
29974:
29975: static int
29976: test_xmlNewTextReader(void) {
29977: int test_ret = 0;
29978:
29979: #if defined(LIBXML_READER_ENABLED)
29980: int mem_base;
29981: xmlTextReaderPtr ret_val;
29982: xmlParserInputBufferPtr input; /* the xmlParserInputBufferPtr used to read data */
29983: int n_input;
29984: const char * URI; /* the URI information for the source if available */
29985: int n_URI;
29986:
29987: for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) {
29988: for (n_URI = 0;n_URI < gen_nb_filepath;n_URI++) {
29989: mem_base = xmlMemBlocks();
29990: input = gen_xmlParserInputBufferPtr(n_input, 0);
29991: URI = gen_filepath(n_URI, 1);
29992:
29993: ret_val = xmlNewTextReader(input, URI);
29994: desret_xmlTextReaderPtr(ret_val);
29995: call_tests++;
29996: des_xmlParserInputBufferPtr(n_input, input, 0);
29997: des_filepath(n_URI, URI, 1);
29998: xmlResetLastError();
29999: if (mem_base != xmlMemBlocks()) {
30000: printf("Leak of %d blocks found in xmlNewTextReader",
30001: xmlMemBlocks() - mem_base);
30002: test_ret++;
30003: printf(" %d", n_input);
30004: printf(" %d", n_URI);
30005: printf("\n");
30006: }
30007: }
30008: }
30009: function_tests++;
30010: #endif
30011:
30012: return(test_ret);
30013: }
30014:
30015:
30016: static int
30017: test_xmlNewTextReaderFilename(void) {
30018: int test_ret = 0;
30019:
30020: #if defined(LIBXML_READER_ENABLED)
30021: int mem_base;
30022: xmlTextReaderPtr ret_val;
30023: const char * URI; /* the URI of the resource to process */
30024: int n_URI;
30025:
30026: for (n_URI = 0;n_URI < gen_nb_filepath;n_URI++) {
30027: mem_base = xmlMemBlocks();
30028: URI = gen_filepath(n_URI, 0);
30029:
30030: ret_val = xmlNewTextReaderFilename(URI);
30031: desret_xmlTextReaderPtr(ret_val);
30032: call_tests++;
30033: des_filepath(n_URI, URI, 0);
30034: xmlResetLastError();
30035: if (mem_base != xmlMemBlocks()) {
30036: printf("Leak of %d blocks found in xmlNewTextReaderFilename",
30037: xmlMemBlocks() - mem_base);
30038: test_ret++;
30039: printf(" %d", n_URI);
30040: printf("\n");
30041: }
30042: }
30043: function_tests++;
30044: #endif
30045:
30046: return(test_ret);
30047: }
30048:
30049:
30050: static int
30051: test_xmlReaderForDoc(void) {
30052: int test_ret = 0;
30053:
30054: #if defined(LIBXML_READER_ENABLED)
30055: int mem_base;
30056: xmlTextReaderPtr ret_val;
30057: xmlChar * cur; /* a pointer to a zero terminated string */
30058: int n_cur;
30059: const char * URL; /* the base URL to use for the document */
30060: int n_URL;
30061: char * encoding; /* the document encoding, or NULL */
30062: int n_encoding;
30063: int options; /* a combination of xmlParserOption */
30064: int n_options;
30065:
30066: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
30067: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
30068: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
30069: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
30070: mem_base = xmlMemBlocks();
30071: cur = gen_const_xmlChar_ptr(n_cur, 0);
30072: URL = gen_filepath(n_URL, 1);
30073: encoding = gen_const_char_ptr(n_encoding, 2);
30074: options = gen_parseroptions(n_options, 3);
30075:
30076: ret_val = xmlReaderForDoc((const xmlChar *)cur, URL, (const char *)encoding, options);
30077: desret_xmlTextReaderPtr(ret_val);
30078: call_tests++;
30079: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
30080: des_filepath(n_URL, URL, 1);
30081: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
30082: des_parseroptions(n_options, options, 3);
30083: xmlResetLastError();
30084: if (mem_base != xmlMemBlocks()) {
30085: printf("Leak of %d blocks found in xmlReaderForDoc",
30086: xmlMemBlocks() - mem_base);
30087: test_ret++;
30088: printf(" %d", n_cur);
30089: printf(" %d", n_URL);
30090: printf(" %d", n_encoding);
30091: printf(" %d", n_options);
30092: printf("\n");
30093: }
30094: }
30095: }
30096: }
30097: }
30098: function_tests++;
30099: #endif
30100:
30101: return(test_ret);
30102: }
30103:
30104:
30105: static int
30106: test_xmlReaderForFile(void) {
30107: int test_ret = 0;
30108:
30109: #if defined(LIBXML_READER_ENABLED)
30110: int mem_base;
30111: xmlTextReaderPtr ret_val;
30112: const char * filename; /* a file or URL */
30113: int n_filename;
30114: char * encoding; /* the document encoding, or NULL */
30115: int n_encoding;
30116: int options; /* a combination of xmlParserOption */
30117: int n_options;
30118:
30119: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
30120: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
30121: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
30122: mem_base = xmlMemBlocks();
30123: filename = gen_filepath(n_filename, 0);
30124: encoding = gen_const_char_ptr(n_encoding, 1);
30125: options = gen_parseroptions(n_options, 2);
30126:
30127: ret_val = xmlReaderForFile(filename, (const char *)encoding, options);
30128: desret_xmlTextReaderPtr(ret_val);
30129: call_tests++;
30130: des_filepath(n_filename, filename, 0);
30131: des_const_char_ptr(n_encoding, (const char *)encoding, 1);
30132: des_parseroptions(n_options, options, 2);
30133: xmlResetLastError();
30134: if (mem_base != xmlMemBlocks()) {
30135: printf("Leak of %d blocks found in xmlReaderForFile",
30136: xmlMemBlocks() - mem_base);
30137: test_ret++;
30138: printf(" %d", n_filename);
30139: printf(" %d", n_encoding);
30140: printf(" %d", n_options);
30141: printf("\n");
30142: }
30143: }
30144: }
30145: }
30146: function_tests++;
30147: #endif
30148:
30149: return(test_ret);
30150: }
30151:
30152:
30153: static int
30154: test_xmlReaderForMemory(void) {
30155: int test_ret = 0;
30156:
30157: #if defined(LIBXML_READER_ENABLED)
30158: int mem_base;
30159: xmlTextReaderPtr ret_val;
30160: char * buffer; /* a pointer to a char array */
30161: int n_buffer;
30162: int size; /* the size of the array */
30163: int n_size;
30164: const char * URL; /* the base URL to use for the document */
30165: int n_URL;
30166: char * encoding; /* the document encoding, or NULL */
30167: int n_encoding;
30168: int options; /* a combination of xmlParserOption */
30169: int n_options;
30170:
30171: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
30172: for (n_size = 0;n_size < gen_nb_int;n_size++) {
30173: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
30174: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
30175: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
30176: mem_base = xmlMemBlocks();
30177: buffer = gen_const_char_ptr(n_buffer, 0);
30178: size = gen_int(n_size, 1);
30179: URL = gen_filepath(n_URL, 2);
30180: encoding = gen_const_char_ptr(n_encoding, 3);
30181: options = gen_parseroptions(n_options, 4);
30182:
30183: ret_val = xmlReaderForMemory((const char *)buffer, size, URL, (const char *)encoding, options);
30184: desret_xmlTextReaderPtr(ret_val);
30185: call_tests++;
30186: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
30187: des_int(n_size, size, 1);
30188: des_filepath(n_URL, URL, 2);
30189: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
30190: des_parseroptions(n_options, options, 4);
30191: xmlResetLastError();
30192: if (mem_base != xmlMemBlocks()) {
30193: printf("Leak of %d blocks found in xmlReaderForMemory",
30194: xmlMemBlocks() - mem_base);
30195: test_ret++;
30196: printf(" %d", n_buffer);
30197: printf(" %d", n_size);
30198: printf(" %d", n_URL);
30199: printf(" %d", n_encoding);
30200: printf(" %d", n_options);
30201: printf("\n");
30202: }
30203: }
30204: }
30205: }
30206: }
30207: }
30208: function_tests++;
30209: #endif
30210:
30211: return(test_ret);
30212: }
30213:
30214:
30215: static int
30216: test_xmlReaderNewDoc(void) {
30217: int test_ret = 0;
30218:
30219: #if defined(LIBXML_READER_ENABLED)
30220: int mem_base;
30221: int ret_val;
30222: xmlTextReaderPtr reader; /* an XML reader */
30223: int n_reader;
30224: xmlChar * cur; /* a pointer to a zero terminated string */
30225: int n_cur;
30226: const char * URL; /* the base URL to use for the document */
30227: int n_URL;
30228: char * encoding; /* the document encoding, or NULL */
30229: int n_encoding;
30230: int options; /* a combination of xmlParserOption */
30231: int n_options;
30232:
30233: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30234: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
30235: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
30236: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
30237: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
30238: mem_base = xmlMemBlocks();
30239: reader = gen_xmlTextReaderPtr(n_reader, 0);
30240: cur = gen_const_xmlChar_ptr(n_cur, 1);
30241: URL = gen_filepath(n_URL, 2);
30242: encoding = gen_const_char_ptr(n_encoding, 3);
30243: options = gen_parseroptions(n_options, 4);
30244:
30245: ret_val = xmlReaderNewDoc(reader, (const xmlChar *)cur, URL, (const char *)encoding, options);
30246: desret_int(ret_val);
30247: call_tests++;
30248: des_xmlTextReaderPtr(n_reader, reader, 0);
30249: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 1);
30250: des_filepath(n_URL, URL, 2);
30251: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
30252: des_parseroptions(n_options, options, 4);
30253: xmlResetLastError();
30254: if (mem_base != xmlMemBlocks()) {
30255: printf("Leak of %d blocks found in xmlReaderNewDoc",
30256: xmlMemBlocks() - mem_base);
30257: test_ret++;
30258: printf(" %d", n_reader);
30259: printf(" %d", n_cur);
30260: printf(" %d", n_URL);
30261: printf(" %d", n_encoding);
30262: printf(" %d", n_options);
30263: printf("\n");
30264: }
30265: }
30266: }
30267: }
30268: }
30269: }
30270: function_tests++;
30271: #endif
30272:
30273: return(test_ret);
30274: }
30275:
30276:
30277: static int
30278: test_xmlReaderNewFile(void) {
30279: int test_ret = 0;
30280:
30281: #if defined(LIBXML_READER_ENABLED)
30282: int mem_base;
30283: int ret_val;
30284: xmlTextReaderPtr reader; /* an XML reader */
30285: int n_reader;
30286: const char * filename; /* a file or URL */
30287: int n_filename;
30288: char * encoding; /* the document encoding, or NULL */
30289: int n_encoding;
30290: int options; /* a combination of xmlParserOption */
30291: int n_options;
30292:
30293: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30294: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
30295: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
30296: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
30297: mem_base = xmlMemBlocks();
30298: reader = gen_xmlTextReaderPtr(n_reader, 0);
30299: filename = gen_filepath(n_filename, 1);
30300: encoding = gen_const_char_ptr(n_encoding, 2);
30301: options = gen_parseroptions(n_options, 3);
30302:
30303: ret_val = xmlReaderNewFile(reader, filename, (const char *)encoding, options);
30304: desret_int(ret_val);
30305: call_tests++;
30306: des_xmlTextReaderPtr(n_reader, reader, 0);
30307: des_filepath(n_filename, filename, 1);
30308: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
30309: des_parseroptions(n_options, options, 3);
30310: xmlResetLastError();
30311: if (mem_base != xmlMemBlocks()) {
30312: printf("Leak of %d blocks found in xmlReaderNewFile",
30313: xmlMemBlocks() - mem_base);
30314: test_ret++;
30315: printf(" %d", n_reader);
30316: printf(" %d", n_filename);
30317: printf(" %d", n_encoding);
30318: printf(" %d", n_options);
30319: printf("\n");
30320: }
30321: }
30322: }
30323: }
30324: }
30325: function_tests++;
30326: #endif
30327:
30328: return(test_ret);
30329: }
30330:
30331:
30332: static int
30333: test_xmlReaderNewMemory(void) {
30334: int test_ret = 0;
30335:
30336: #if defined(LIBXML_READER_ENABLED)
30337: int mem_base;
30338: int ret_val;
30339: xmlTextReaderPtr reader; /* an XML reader */
30340: int n_reader;
30341: char * buffer; /* a pointer to a char array */
30342: int n_buffer;
30343: int size; /* the size of the array */
30344: int n_size;
30345: const char * URL; /* the base URL to use for the document */
30346: int n_URL;
30347: char * encoding; /* the document encoding, or NULL */
30348: int n_encoding;
30349: int options; /* a combination of xmlParserOption */
30350: int n_options;
30351:
30352: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30353: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
30354: for (n_size = 0;n_size < gen_nb_int;n_size++) {
30355: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
30356: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
30357: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
30358: mem_base = xmlMemBlocks();
30359: reader = gen_xmlTextReaderPtr(n_reader, 0);
30360: buffer = gen_const_char_ptr(n_buffer, 1);
30361: size = gen_int(n_size, 2);
30362: URL = gen_filepath(n_URL, 3);
30363: encoding = gen_const_char_ptr(n_encoding, 4);
30364: options = gen_parseroptions(n_options, 5);
30365:
30366: ret_val = xmlReaderNewMemory(reader, (const char *)buffer, size, URL, (const char *)encoding, options);
30367: desret_int(ret_val);
30368: call_tests++;
30369: des_xmlTextReaderPtr(n_reader, reader, 0);
30370: des_const_char_ptr(n_buffer, (const char *)buffer, 1);
30371: des_int(n_size, size, 2);
30372: des_filepath(n_URL, URL, 3);
30373: des_const_char_ptr(n_encoding, (const char *)encoding, 4);
30374: des_parseroptions(n_options, options, 5);
30375: xmlResetLastError();
30376: if (mem_base != xmlMemBlocks()) {
30377: printf("Leak of %d blocks found in xmlReaderNewMemory",
30378: xmlMemBlocks() - mem_base);
30379: test_ret++;
30380: printf(" %d", n_reader);
30381: printf(" %d", n_buffer);
30382: printf(" %d", n_size);
30383: printf(" %d", n_URL);
30384: printf(" %d", n_encoding);
30385: printf(" %d", n_options);
30386: printf("\n");
30387: }
30388: }
30389: }
30390: }
30391: }
30392: }
30393: }
30394: function_tests++;
30395: #endif
30396:
30397: return(test_ret);
30398: }
30399:
30400:
30401: static int
30402: test_xmlReaderNewWalker(void) {
30403: int test_ret = 0;
30404:
30405: #if defined(LIBXML_READER_ENABLED)
30406: int mem_base;
30407: int ret_val;
30408: xmlTextReaderPtr reader; /* an XML reader */
30409: int n_reader;
30410: xmlDocPtr doc; /* a preparsed document */
30411: int n_doc;
30412:
30413: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30414: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
30415: mem_base = xmlMemBlocks();
30416: reader = gen_xmlTextReaderPtr(n_reader, 0);
30417: doc = gen_xmlDocPtr(n_doc, 1);
30418:
30419: ret_val = xmlReaderNewWalker(reader, doc);
30420: desret_int(ret_val);
30421: call_tests++;
30422: des_xmlTextReaderPtr(n_reader, reader, 0);
30423: des_xmlDocPtr(n_doc, doc, 1);
30424: xmlResetLastError();
30425: if (mem_base != xmlMemBlocks()) {
30426: printf("Leak of %d blocks found in xmlReaderNewWalker",
30427: xmlMemBlocks() - mem_base);
30428: test_ret++;
30429: printf(" %d", n_reader);
30430: printf(" %d", n_doc);
30431: printf("\n");
30432: }
30433: }
30434: }
30435: function_tests++;
30436: #endif
30437:
30438: return(test_ret);
30439: }
30440:
30441:
30442: static int
30443: test_xmlReaderWalker(void) {
30444: int test_ret = 0;
30445:
30446: #if defined(LIBXML_READER_ENABLED)
30447: int mem_base;
30448: xmlTextReaderPtr ret_val;
30449: xmlDocPtr doc; /* a preparsed document */
30450: int n_doc;
30451:
30452: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
30453: mem_base = xmlMemBlocks();
30454: doc = gen_xmlDocPtr(n_doc, 0);
30455:
30456: ret_val = xmlReaderWalker(doc);
30457: desret_xmlTextReaderPtr(ret_val);
30458: call_tests++;
30459: des_xmlDocPtr(n_doc, doc, 0);
30460: xmlResetLastError();
30461: if (mem_base != xmlMemBlocks()) {
30462: printf("Leak of %d blocks found in xmlReaderWalker",
30463: xmlMemBlocks() - mem_base);
30464: test_ret++;
30465: printf(" %d", n_doc);
30466: printf("\n");
30467: }
30468: }
30469: function_tests++;
30470: #endif
30471:
30472: return(test_ret);
30473: }
30474:
30475:
30476: static int
30477: test_xmlTextReaderAttributeCount(void) {
30478: int test_ret = 0;
30479:
30480: #if defined(LIBXML_READER_ENABLED)
30481: int mem_base;
30482: int ret_val;
30483: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30484: int n_reader;
30485:
30486: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30487: mem_base = xmlMemBlocks();
30488: reader = gen_xmlTextReaderPtr(n_reader, 0);
30489:
30490: ret_val = xmlTextReaderAttributeCount(reader);
30491: desret_int(ret_val);
30492: call_tests++;
30493: des_xmlTextReaderPtr(n_reader, reader, 0);
30494: xmlResetLastError();
30495: if (mem_base != xmlMemBlocks()) {
30496: printf("Leak of %d blocks found in xmlTextReaderAttributeCount",
30497: xmlMemBlocks() - mem_base);
30498: test_ret++;
30499: printf(" %d", n_reader);
30500: printf("\n");
30501: }
30502: }
30503: function_tests++;
30504: #endif
30505:
30506: return(test_ret);
30507: }
30508:
30509:
30510: static int
30511: test_xmlTextReaderBaseUri(void) {
30512: int test_ret = 0;
30513:
30514: #if defined(LIBXML_READER_ENABLED)
30515: int mem_base;
30516: xmlChar * ret_val;
30517: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30518: int n_reader;
30519:
30520: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30521: mem_base = xmlMemBlocks();
30522: reader = gen_xmlTextReaderPtr(n_reader, 0);
30523:
30524: ret_val = xmlTextReaderBaseUri(reader);
30525: desret_xmlChar_ptr(ret_val);
30526: call_tests++;
30527: des_xmlTextReaderPtr(n_reader, reader, 0);
30528: xmlResetLastError();
30529: if (mem_base != xmlMemBlocks()) {
30530: printf("Leak of %d blocks found in xmlTextReaderBaseUri",
30531: xmlMemBlocks() - mem_base);
30532: test_ret++;
30533: printf(" %d", n_reader);
30534: printf("\n");
30535: }
30536: }
30537: function_tests++;
30538: #endif
30539:
30540: return(test_ret);
30541: }
30542:
30543:
30544: static int
30545: test_xmlTextReaderByteConsumed(void) {
30546: int test_ret = 0;
30547:
30548: #if defined(LIBXML_READER_ENABLED)
30549: int mem_base;
30550: long ret_val;
30551: xmlTextReaderPtr reader; /* an XML reader */
30552: int n_reader;
30553:
30554: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30555: mem_base = xmlMemBlocks();
30556: reader = gen_xmlTextReaderPtr(n_reader, 0);
30557:
30558: ret_val = xmlTextReaderByteConsumed(reader);
30559: desret_long(ret_val);
30560: call_tests++;
30561: des_xmlTextReaderPtr(n_reader, reader, 0);
30562: xmlResetLastError();
30563: if (mem_base != xmlMemBlocks()) {
30564: printf("Leak of %d blocks found in xmlTextReaderByteConsumed",
30565: xmlMemBlocks() - mem_base);
30566: test_ret++;
30567: printf(" %d", n_reader);
30568: printf("\n");
30569: }
30570: }
30571: function_tests++;
30572: #endif
30573:
30574: return(test_ret);
30575: }
30576:
30577:
30578: static int
30579: test_xmlTextReaderClose(void) {
30580: int test_ret = 0;
30581:
30582: #if defined(LIBXML_READER_ENABLED)
30583: int mem_base;
30584: int ret_val;
30585: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30586: int n_reader;
30587:
30588: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30589: mem_base = xmlMemBlocks();
30590: reader = gen_xmlTextReaderPtr(n_reader, 0);
30591:
30592: ret_val = xmlTextReaderClose(reader);
30593: desret_int(ret_val);
30594: call_tests++;
30595: des_xmlTextReaderPtr(n_reader, reader, 0);
30596: xmlResetLastError();
30597: if (mem_base != xmlMemBlocks()) {
30598: printf("Leak of %d blocks found in xmlTextReaderClose",
30599: xmlMemBlocks() - mem_base);
30600: test_ret++;
30601: printf(" %d", n_reader);
30602: printf("\n");
30603: }
30604: }
30605: function_tests++;
30606: #endif
30607:
30608: return(test_ret);
30609: }
30610:
30611:
30612: static int
30613: test_xmlTextReaderConstBaseUri(void) {
30614: int test_ret = 0;
30615:
30616: #if defined(LIBXML_READER_ENABLED)
30617: int mem_base;
30618: const xmlChar * ret_val;
30619: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30620: int n_reader;
30621:
30622: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30623: mem_base = xmlMemBlocks();
30624: reader = gen_xmlTextReaderPtr(n_reader, 0);
30625:
30626: ret_val = xmlTextReaderConstBaseUri(reader);
30627: desret_const_xmlChar_ptr(ret_val);
30628: call_tests++;
30629: des_xmlTextReaderPtr(n_reader, reader, 0);
30630: xmlResetLastError();
30631: if (mem_base != xmlMemBlocks()) {
30632: printf("Leak of %d blocks found in xmlTextReaderConstBaseUri",
30633: xmlMemBlocks() - mem_base);
30634: test_ret++;
30635: printf(" %d", n_reader);
30636: printf("\n");
30637: }
30638: }
30639: function_tests++;
30640: #endif
30641:
30642: return(test_ret);
30643: }
30644:
30645:
30646: static int
30647: test_xmlTextReaderConstEncoding(void) {
30648: int test_ret = 0;
30649:
30650: #if defined(LIBXML_READER_ENABLED)
30651: int mem_base;
30652: const xmlChar * ret_val;
30653: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30654: int n_reader;
30655:
30656: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30657: mem_base = xmlMemBlocks();
30658: reader = gen_xmlTextReaderPtr(n_reader, 0);
30659:
30660: ret_val = xmlTextReaderConstEncoding(reader);
30661: desret_const_xmlChar_ptr(ret_val);
30662: call_tests++;
30663: des_xmlTextReaderPtr(n_reader, reader, 0);
30664: xmlResetLastError();
30665: if (mem_base != xmlMemBlocks()) {
30666: printf("Leak of %d blocks found in xmlTextReaderConstEncoding",
30667: xmlMemBlocks() - mem_base);
30668: test_ret++;
30669: printf(" %d", n_reader);
30670: printf("\n");
30671: }
30672: }
30673: function_tests++;
30674: #endif
30675:
30676: return(test_ret);
30677: }
30678:
30679:
30680: static int
30681: test_xmlTextReaderConstLocalName(void) {
30682: int test_ret = 0;
30683:
30684: #if defined(LIBXML_READER_ENABLED)
30685: int mem_base;
30686: const xmlChar * ret_val;
30687: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30688: int n_reader;
30689:
30690: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30691: mem_base = xmlMemBlocks();
30692: reader = gen_xmlTextReaderPtr(n_reader, 0);
30693:
30694: ret_val = xmlTextReaderConstLocalName(reader);
30695: desret_const_xmlChar_ptr(ret_val);
30696: call_tests++;
30697: des_xmlTextReaderPtr(n_reader, reader, 0);
30698: xmlResetLastError();
30699: if (mem_base != xmlMemBlocks()) {
30700: printf("Leak of %d blocks found in xmlTextReaderConstLocalName",
30701: xmlMemBlocks() - mem_base);
30702: test_ret++;
30703: printf(" %d", n_reader);
30704: printf("\n");
30705: }
30706: }
30707: function_tests++;
30708: #endif
30709:
30710: return(test_ret);
30711: }
30712:
30713:
30714: static int
30715: test_xmlTextReaderConstName(void) {
30716: int test_ret = 0;
30717:
30718: #if defined(LIBXML_READER_ENABLED)
30719: int mem_base;
30720: const xmlChar * ret_val;
30721: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30722: int n_reader;
30723:
30724: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30725: mem_base = xmlMemBlocks();
30726: reader = gen_xmlTextReaderPtr(n_reader, 0);
30727:
30728: ret_val = xmlTextReaderConstName(reader);
30729: desret_const_xmlChar_ptr(ret_val);
30730: call_tests++;
30731: des_xmlTextReaderPtr(n_reader, reader, 0);
30732: xmlResetLastError();
30733: if (mem_base != xmlMemBlocks()) {
30734: printf("Leak of %d blocks found in xmlTextReaderConstName",
30735: xmlMemBlocks() - mem_base);
30736: test_ret++;
30737: printf(" %d", n_reader);
30738: printf("\n");
30739: }
30740: }
30741: function_tests++;
30742: #endif
30743:
30744: return(test_ret);
30745: }
30746:
30747:
30748: static int
30749: test_xmlTextReaderConstNamespaceUri(void) {
30750: int test_ret = 0;
30751:
30752: #if defined(LIBXML_READER_ENABLED)
30753: int mem_base;
30754: const xmlChar * ret_val;
30755: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30756: int n_reader;
30757:
30758: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30759: mem_base = xmlMemBlocks();
30760: reader = gen_xmlTextReaderPtr(n_reader, 0);
30761:
30762: ret_val = xmlTextReaderConstNamespaceUri(reader);
30763: desret_const_xmlChar_ptr(ret_val);
30764: call_tests++;
30765: des_xmlTextReaderPtr(n_reader, reader, 0);
30766: xmlResetLastError();
30767: if (mem_base != xmlMemBlocks()) {
30768: printf("Leak of %d blocks found in xmlTextReaderConstNamespaceUri",
30769: xmlMemBlocks() - mem_base);
30770: test_ret++;
30771: printf(" %d", n_reader);
30772: printf("\n");
30773: }
30774: }
30775: function_tests++;
30776: #endif
30777:
30778: return(test_ret);
30779: }
30780:
30781:
30782: static int
30783: test_xmlTextReaderConstPrefix(void) {
30784: int test_ret = 0;
30785:
30786: #if defined(LIBXML_READER_ENABLED)
30787: int mem_base;
30788: const xmlChar * ret_val;
30789: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30790: int n_reader;
30791:
30792: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30793: mem_base = xmlMemBlocks();
30794: reader = gen_xmlTextReaderPtr(n_reader, 0);
30795:
30796: ret_val = xmlTextReaderConstPrefix(reader);
30797: desret_const_xmlChar_ptr(ret_val);
30798: call_tests++;
30799: des_xmlTextReaderPtr(n_reader, reader, 0);
30800: xmlResetLastError();
30801: if (mem_base != xmlMemBlocks()) {
30802: printf("Leak of %d blocks found in xmlTextReaderConstPrefix",
30803: xmlMemBlocks() - mem_base);
30804: test_ret++;
30805: printf(" %d", n_reader);
30806: printf("\n");
30807: }
30808: }
30809: function_tests++;
30810: #endif
30811:
30812: return(test_ret);
30813: }
30814:
30815:
30816: static int
30817: test_xmlTextReaderConstString(void) {
30818: int test_ret = 0;
30819:
30820: #if defined(LIBXML_READER_ENABLED)
30821: int mem_base;
30822: const xmlChar * ret_val;
30823: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30824: int n_reader;
30825: xmlChar * str; /* the string to intern. */
30826: int n_str;
30827:
30828: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30829: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
30830: mem_base = xmlMemBlocks();
30831: reader = gen_xmlTextReaderPtr(n_reader, 0);
30832: str = gen_const_xmlChar_ptr(n_str, 1);
30833:
30834: ret_val = xmlTextReaderConstString(reader, (const xmlChar *)str);
30835: desret_const_xmlChar_ptr(ret_val);
30836: call_tests++;
30837: des_xmlTextReaderPtr(n_reader, reader, 0);
30838: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
30839: xmlResetLastError();
30840: if (mem_base != xmlMemBlocks()) {
30841: printf("Leak of %d blocks found in xmlTextReaderConstString",
30842: xmlMemBlocks() - mem_base);
30843: test_ret++;
30844: printf(" %d", n_reader);
30845: printf(" %d", n_str);
30846: printf("\n");
30847: }
30848: }
30849: }
30850: function_tests++;
30851: #endif
30852:
30853: return(test_ret);
30854: }
30855:
30856:
30857: static int
30858: test_xmlTextReaderConstValue(void) {
30859: int test_ret = 0;
30860:
30861: #if defined(LIBXML_READER_ENABLED)
30862: int mem_base;
30863: const xmlChar * ret_val;
30864: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30865: int n_reader;
30866:
30867: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30868: mem_base = xmlMemBlocks();
30869: reader = gen_xmlTextReaderPtr(n_reader, 0);
30870:
30871: ret_val = xmlTextReaderConstValue(reader);
30872: desret_const_xmlChar_ptr(ret_val);
30873: call_tests++;
30874: des_xmlTextReaderPtr(n_reader, reader, 0);
30875: xmlResetLastError();
30876: if (mem_base != xmlMemBlocks()) {
30877: printf("Leak of %d blocks found in xmlTextReaderConstValue",
30878: xmlMemBlocks() - mem_base);
30879: test_ret++;
30880: printf(" %d", n_reader);
30881: printf("\n");
30882: }
30883: }
30884: function_tests++;
30885: #endif
30886:
30887: return(test_ret);
30888: }
30889:
30890:
30891: static int
30892: test_xmlTextReaderConstXmlLang(void) {
30893: int test_ret = 0;
30894:
30895: #if defined(LIBXML_READER_ENABLED)
30896: int mem_base;
30897: const xmlChar * ret_val;
30898: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30899: int n_reader;
30900:
30901: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30902: mem_base = xmlMemBlocks();
30903: reader = gen_xmlTextReaderPtr(n_reader, 0);
30904:
30905: ret_val = xmlTextReaderConstXmlLang(reader);
30906: desret_const_xmlChar_ptr(ret_val);
30907: call_tests++;
30908: des_xmlTextReaderPtr(n_reader, reader, 0);
30909: xmlResetLastError();
30910: if (mem_base != xmlMemBlocks()) {
30911: printf("Leak of %d blocks found in xmlTextReaderConstXmlLang",
30912: xmlMemBlocks() - mem_base);
30913: test_ret++;
30914: printf(" %d", n_reader);
30915: printf("\n");
30916: }
30917: }
30918: function_tests++;
30919: #endif
30920:
30921: return(test_ret);
30922: }
30923:
30924:
30925: static int
30926: test_xmlTextReaderConstXmlVersion(void) {
30927: int test_ret = 0;
30928:
30929: #if defined(LIBXML_READER_ENABLED)
30930: int mem_base;
30931: const xmlChar * ret_val;
30932: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30933: int n_reader;
30934:
30935: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30936: mem_base = xmlMemBlocks();
30937: reader = gen_xmlTextReaderPtr(n_reader, 0);
30938:
30939: ret_val = xmlTextReaderConstXmlVersion(reader);
30940: desret_const_xmlChar_ptr(ret_val);
30941: call_tests++;
30942: des_xmlTextReaderPtr(n_reader, reader, 0);
30943: xmlResetLastError();
30944: if (mem_base != xmlMemBlocks()) {
30945: printf("Leak of %d blocks found in xmlTextReaderConstXmlVersion",
30946: xmlMemBlocks() - mem_base);
30947: test_ret++;
30948: printf(" %d", n_reader);
30949: printf("\n");
30950: }
30951: }
30952: function_tests++;
30953: #endif
30954:
30955: return(test_ret);
30956: }
30957:
30958:
30959: static int
30960: test_xmlTextReaderCurrentDoc(void) {
30961: int test_ret = 0;
30962:
30963: #if defined(LIBXML_READER_ENABLED)
30964: int mem_base;
30965: xmlDocPtr ret_val;
30966: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30967: int n_reader;
30968:
30969: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30970: mem_base = xmlMemBlocks();
30971: reader = gen_xmlTextReaderPtr(n_reader, 0);
30972:
30973: ret_val = xmlTextReaderCurrentDoc(reader);
30974: desret_xmlDocPtr(ret_val);
30975: call_tests++;
30976: des_xmlTextReaderPtr(n_reader, reader, 0);
30977: xmlResetLastError();
30978: if (mem_base != xmlMemBlocks()) {
30979: printf("Leak of %d blocks found in xmlTextReaderCurrentDoc",
30980: xmlMemBlocks() - mem_base);
30981: test_ret++;
30982: printf(" %d", n_reader);
30983: printf("\n");
30984: }
30985: }
30986: function_tests++;
30987: #endif
30988:
30989: return(test_ret);
30990: }
30991:
30992:
30993: static int
30994: test_xmlTextReaderCurrentNode(void) {
30995: int test_ret = 0;
30996:
30997: #if defined(LIBXML_READER_ENABLED)
30998: int mem_base;
30999: xmlNodePtr ret_val;
31000: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31001: int n_reader;
31002:
31003: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31004: mem_base = xmlMemBlocks();
31005: reader = gen_xmlTextReaderPtr(n_reader, 0);
31006:
31007: ret_val = xmlTextReaderCurrentNode(reader);
31008: desret_xmlNodePtr(ret_val);
31009: call_tests++;
31010: des_xmlTextReaderPtr(n_reader, reader, 0);
31011: xmlResetLastError();
31012: if (mem_base != xmlMemBlocks()) {
31013: printf("Leak of %d blocks found in xmlTextReaderCurrentNode",
31014: xmlMemBlocks() - mem_base);
31015: test_ret++;
31016: printf(" %d", n_reader);
31017: printf("\n");
31018: }
31019: }
31020: function_tests++;
31021: #endif
31022:
31023: return(test_ret);
31024: }
31025:
31026:
31027: static int
31028: test_xmlTextReaderDepth(void) {
31029: int test_ret = 0;
31030:
31031: #if defined(LIBXML_READER_ENABLED)
31032: int mem_base;
31033: int ret_val;
31034: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31035: int n_reader;
31036:
31037: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31038: mem_base = xmlMemBlocks();
31039: reader = gen_xmlTextReaderPtr(n_reader, 0);
31040:
31041: ret_val = xmlTextReaderDepth(reader);
31042: desret_int(ret_val);
31043: call_tests++;
31044: des_xmlTextReaderPtr(n_reader, reader, 0);
31045: xmlResetLastError();
31046: if (mem_base != xmlMemBlocks()) {
31047: printf("Leak of %d blocks found in xmlTextReaderDepth",
31048: xmlMemBlocks() - mem_base);
31049: test_ret++;
31050: printf(" %d", n_reader);
31051: printf("\n");
31052: }
31053: }
31054: function_tests++;
31055: #endif
31056:
31057: return(test_ret);
31058: }
31059:
31060:
31061: static int
31062: test_xmlTextReaderExpand(void) {
31063: int test_ret = 0;
31064:
31065: #if defined(LIBXML_READER_ENABLED)
31066: int mem_base;
31067: xmlNodePtr ret_val;
31068: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31069: int n_reader;
31070:
31071: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31072: mem_base = xmlMemBlocks();
31073: reader = gen_xmlTextReaderPtr(n_reader, 0);
31074:
31075: ret_val = xmlTextReaderExpand(reader);
31076: desret_xmlNodePtr(ret_val);
31077: call_tests++;
31078: des_xmlTextReaderPtr(n_reader, reader, 0);
31079: xmlResetLastError();
31080: if (mem_base != xmlMemBlocks()) {
31081: printf("Leak of %d blocks found in xmlTextReaderExpand",
31082: xmlMemBlocks() - mem_base);
31083: test_ret++;
31084: printf(" %d", n_reader);
31085: printf("\n");
31086: }
31087: }
31088: function_tests++;
31089: #endif
31090:
31091: return(test_ret);
31092: }
31093:
31094:
31095: static int
31096: test_xmlTextReaderGetAttribute(void) {
31097: int test_ret = 0;
31098:
31099: #if defined(LIBXML_READER_ENABLED)
31100: int mem_base;
31101: xmlChar * ret_val;
31102: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31103: int n_reader;
31104: xmlChar * name; /* the qualified name of the attribute. */
31105: int n_name;
31106:
31107: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31108: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
31109: mem_base = xmlMemBlocks();
31110: reader = gen_xmlTextReaderPtr(n_reader, 0);
31111: name = gen_const_xmlChar_ptr(n_name, 1);
31112:
31113: ret_val = xmlTextReaderGetAttribute(reader, (const xmlChar *)name);
31114: desret_xmlChar_ptr(ret_val);
31115: call_tests++;
31116: des_xmlTextReaderPtr(n_reader, reader, 0);
31117: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
31118: xmlResetLastError();
31119: if (mem_base != xmlMemBlocks()) {
31120: printf("Leak of %d blocks found in xmlTextReaderGetAttribute",
31121: xmlMemBlocks() - mem_base);
31122: test_ret++;
31123: printf(" %d", n_reader);
31124: printf(" %d", n_name);
31125: printf("\n");
31126: }
31127: }
31128: }
31129: function_tests++;
31130: #endif
31131:
31132: return(test_ret);
31133: }
31134:
31135:
31136: static int
31137: test_xmlTextReaderGetAttributeNo(void) {
31138: int test_ret = 0;
31139:
31140: #if defined(LIBXML_READER_ENABLED)
31141: int mem_base;
31142: xmlChar * ret_val;
31143: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31144: int n_reader;
31145: int no; /* the zero-based index of the attribute relative to the containing element */
31146: int n_no;
31147:
31148: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31149: for (n_no = 0;n_no < gen_nb_int;n_no++) {
31150: mem_base = xmlMemBlocks();
31151: reader = gen_xmlTextReaderPtr(n_reader, 0);
31152: no = gen_int(n_no, 1);
31153:
31154: ret_val = xmlTextReaderGetAttributeNo(reader, no);
31155: desret_xmlChar_ptr(ret_val);
31156: call_tests++;
31157: des_xmlTextReaderPtr(n_reader, reader, 0);
31158: des_int(n_no, no, 1);
31159: xmlResetLastError();
31160: if (mem_base != xmlMemBlocks()) {
31161: printf("Leak of %d blocks found in xmlTextReaderGetAttributeNo",
31162: xmlMemBlocks() - mem_base);
31163: test_ret++;
31164: printf(" %d", n_reader);
31165: printf(" %d", n_no);
31166: printf("\n");
31167: }
31168: }
31169: }
31170: function_tests++;
31171: #endif
31172:
31173: return(test_ret);
31174: }
31175:
31176:
31177: static int
31178: test_xmlTextReaderGetAttributeNs(void) {
31179: int test_ret = 0;
31180:
31181: #if defined(LIBXML_READER_ENABLED)
31182: int mem_base;
31183: xmlChar * ret_val;
31184: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31185: int n_reader;
31186: xmlChar * localName; /* the local name of the attribute. */
31187: int n_localName;
31188: xmlChar * namespaceURI; /* the namespace URI of the attribute. */
31189: int n_namespaceURI;
31190:
31191: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31192: for (n_localName = 0;n_localName < gen_nb_const_xmlChar_ptr;n_localName++) {
31193: for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
31194: mem_base = xmlMemBlocks();
31195: reader = gen_xmlTextReaderPtr(n_reader, 0);
31196: localName = gen_const_xmlChar_ptr(n_localName, 1);
31197: namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 2);
31198:
31199: ret_val = xmlTextReaderGetAttributeNs(reader, (const xmlChar *)localName, (const xmlChar *)namespaceURI);
31200: desret_xmlChar_ptr(ret_val);
31201: call_tests++;
31202: des_xmlTextReaderPtr(n_reader, reader, 0);
31203: des_const_xmlChar_ptr(n_localName, (const xmlChar *)localName, 1);
31204: des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 2);
31205: xmlResetLastError();
31206: if (mem_base != xmlMemBlocks()) {
31207: printf("Leak of %d blocks found in xmlTextReaderGetAttributeNs",
31208: xmlMemBlocks() - mem_base);
31209: test_ret++;
31210: printf(" %d", n_reader);
31211: printf(" %d", n_localName);
31212: printf(" %d", n_namespaceURI);
31213: printf("\n");
31214: }
31215: }
31216: }
31217: }
31218: function_tests++;
31219: #endif
31220:
31221: return(test_ret);
31222: }
31223:
31224: #ifdef LIBXML_READER_ENABLED
31225:
31226: #define gen_nb_xmlTextReaderErrorFunc_ptr 1
31227: static xmlTextReaderErrorFunc * gen_xmlTextReaderErrorFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
31228: return(NULL);
31229: }
31230: static void des_xmlTextReaderErrorFunc_ptr(int no ATTRIBUTE_UNUSED, xmlTextReaderErrorFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
31231: }
31232: #endif
31233:
31234:
31235: static int
31236: test_xmlTextReaderGetErrorHandler(void) {
31237: int test_ret = 0;
31238:
31239: #if defined(LIBXML_READER_ENABLED)
31240: int mem_base;
31241: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31242: int n_reader;
31243: xmlTextReaderErrorFunc * f; /* the callback function or NULL is no callback has been registered */
31244: int n_f;
31245: void ** arg; /* a user argument */
31246: int n_arg;
31247:
31248: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31249: for (n_f = 0;n_f < gen_nb_xmlTextReaderErrorFunc_ptr;n_f++) {
31250: for (n_arg = 0;n_arg < gen_nb_void_ptr_ptr;n_arg++) {
31251: mem_base = xmlMemBlocks();
31252: reader = gen_xmlTextReaderPtr(n_reader, 0);
31253: f = gen_xmlTextReaderErrorFunc_ptr(n_f, 1);
31254: arg = gen_void_ptr_ptr(n_arg, 2);
31255:
31256: xmlTextReaderGetErrorHandler(reader, f, arg);
31257: call_tests++;
31258: des_xmlTextReaderPtr(n_reader, reader, 0);
31259: des_xmlTextReaderErrorFunc_ptr(n_f, f, 1);
31260: des_void_ptr_ptr(n_arg, arg, 2);
31261: xmlResetLastError();
31262: if (mem_base != xmlMemBlocks()) {
31263: printf("Leak of %d blocks found in xmlTextReaderGetErrorHandler",
31264: xmlMemBlocks() - mem_base);
31265: test_ret++;
31266: printf(" %d", n_reader);
31267: printf(" %d", n_f);
31268: printf(" %d", n_arg);
31269: printf("\n");
31270: }
31271: }
31272: }
31273: }
31274: function_tests++;
31275: #endif
31276:
31277: return(test_ret);
31278: }
31279:
31280:
31281: static int
31282: test_xmlTextReaderGetParserColumnNumber(void) {
31283: int test_ret = 0;
31284:
31285: #if defined(LIBXML_READER_ENABLED)
31286: int mem_base;
31287: int ret_val;
31288: xmlTextReaderPtr reader; /* the user data (XML reader context) */
31289: int n_reader;
31290:
31291: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31292: mem_base = xmlMemBlocks();
31293: reader = gen_xmlTextReaderPtr(n_reader, 0);
31294:
31295: ret_val = xmlTextReaderGetParserColumnNumber(reader);
31296: desret_int(ret_val);
31297: call_tests++;
31298: des_xmlTextReaderPtr(n_reader, reader, 0);
31299: xmlResetLastError();
31300: if (mem_base != xmlMemBlocks()) {
31301: printf("Leak of %d blocks found in xmlTextReaderGetParserColumnNumber",
31302: xmlMemBlocks() - mem_base);
31303: test_ret++;
31304: printf(" %d", n_reader);
31305: printf("\n");
31306: }
31307: }
31308: function_tests++;
31309: #endif
31310:
31311: return(test_ret);
31312: }
31313:
31314:
31315: static int
31316: test_xmlTextReaderGetParserLineNumber(void) {
31317: int test_ret = 0;
31318:
31319: #if defined(LIBXML_READER_ENABLED)
31320: int mem_base;
31321: int ret_val;
31322: xmlTextReaderPtr reader; /* the user data (XML reader context) */
31323: int n_reader;
31324:
31325: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31326: mem_base = xmlMemBlocks();
31327: reader = gen_xmlTextReaderPtr(n_reader, 0);
31328:
31329: ret_val = xmlTextReaderGetParserLineNumber(reader);
31330: desret_int(ret_val);
31331: call_tests++;
31332: des_xmlTextReaderPtr(n_reader, reader, 0);
31333: xmlResetLastError();
31334: if (mem_base != xmlMemBlocks()) {
31335: printf("Leak of %d blocks found in xmlTextReaderGetParserLineNumber",
31336: xmlMemBlocks() - mem_base);
31337: test_ret++;
31338: printf(" %d", n_reader);
31339: printf("\n");
31340: }
31341: }
31342: function_tests++;
31343: #endif
31344:
31345: return(test_ret);
31346: }
31347:
31348:
31349: static int
31350: test_xmlTextReaderGetParserProp(void) {
31351: int test_ret = 0;
31352:
31353: #if defined(LIBXML_READER_ENABLED)
31354: int mem_base;
31355: int ret_val;
31356: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31357: int n_reader;
31358: int prop; /* the xmlParserProperties to get */
31359: int n_prop;
31360:
31361: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31362: for (n_prop = 0;n_prop < gen_nb_int;n_prop++) {
31363: mem_base = xmlMemBlocks();
31364: reader = gen_xmlTextReaderPtr(n_reader, 0);
31365: prop = gen_int(n_prop, 1);
31366:
31367: ret_val = xmlTextReaderGetParserProp(reader, prop);
31368: desret_int(ret_val);
31369: call_tests++;
31370: des_xmlTextReaderPtr(n_reader, reader, 0);
31371: des_int(n_prop, prop, 1);
31372: xmlResetLastError();
31373: if (mem_base != xmlMemBlocks()) {
31374: printf("Leak of %d blocks found in xmlTextReaderGetParserProp",
31375: xmlMemBlocks() - mem_base);
31376: test_ret++;
31377: printf(" %d", n_reader);
31378: printf(" %d", n_prop);
31379: printf("\n");
31380: }
31381: }
31382: }
31383: function_tests++;
31384: #endif
31385:
31386: return(test_ret);
31387: }
31388:
31389:
31390: static int
31391: test_xmlTextReaderGetRemainder(void) {
31392: int test_ret = 0;
31393:
31394: #if defined(LIBXML_READER_ENABLED)
31395: int mem_base;
31396: xmlParserInputBufferPtr ret_val;
31397: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31398: int n_reader;
31399:
31400: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31401: mem_base = xmlMemBlocks();
31402: reader = gen_xmlTextReaderPtr(n_reader, 0);
31403:
31404: ret_val = xmlTextReaderGetRemainder(reader);
31405: desret_xmlParserInputBufferPtr(ret_val);
31406: call_tests++;
31407: des_xmlTextReaderPtr(n_reader, reader, 0);
31408: xmlResetLastError();
31409: if (mem_base != xmlMemBlocks()) {
31410: printf("Leak of %d blocks found in xmlTextReaderGetRemainder",
31411: xmlMemBlocks() - mem_base);
31412: test_ret++;
31413: printf(" %d", n_reader);
31414: printf("\n");
31415: }
31416: }
31417: function_tests++;
31418: #endif
31419:
31420: return(test_ret);
31421: }
31422:
31423:
31424: static int
31425: test_xmlTextReaderHasAttributes(void) {
31426: int test_ret = 0;
31427:
31428: #if defined(LIBXML_READER_ENABLED)
31429: int mem_base;
31430: int ret_val;
31431: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31432: int n_reader;
31433:
31434: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31435: mem_base = xmlMemBlocks();
31436: reader = gen_xmlTextReaderPtr(n_reader, 0);
31437:
31438: ret_val = xmlTextReaderHasAttributes(reader);
31439: desret_int(ret_val);
31440: call_tests++;
31441: des_xmlTextReaderPtr(n_reader, reader, 0);
31442: xmlResetLastError();
31443: if (mem_base != xmlMemBlocks()) {
31444: printf("Leak of %d blocks found in xmlTextReaderHasAttributes",
31445: xmlMemBlocks() - mem_base);
31446: test_ret++;
31447: printf(" %d", n_reader);
31448: printf("\n");
31449: }
31450: }
31451: function_tests++;
31452: #endif
31453:
31454: return(test_ret);
31455: }
31456:
31457:
31458: static int
31459: test_xmlTextReaderHasValue(void) {
31460: int test_ret = 0;
31461:
31462: #if defined(LIBXML_READER_ENABLED)
31463: int mem_base;
31464: int ret_val;
31465: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31466: int n_reader;
31467:
31468: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31469: mem_base = xmlMemBlocks();
31470: reader = gen_xmlTextReaderPtr(n_reader, 0);
31471:
31472: ret_val = xmlTextReaderHasValue(reader);
31473: desret_int(ret_val);
31474: call_tests++;
31475: des_xmlTextReaderPtr(n_reader, reader, 0);
31476: xmlResetLastError();
31477: if (mem_base != xmlMemBlocks()) {
31478: printf("Leak of %d blocks found in xmlTextReaderHasValue",
31479: xmlMemBlocks() - mem_base);
31480: test_ret++;
31481: printf(" %d", n_reader);
31482: printf("\n");
31483: }
31484: }
31485: function_tests++;
31486: #endif
31487:
31488: return(test_ret);
31489: }
31490:
31491:
31492: static int
31493: test_xmlTextReaderIsDefault(void) {
31494: int test_ret = 0;
31495:
31496: #if defined(LIBXML_READER_ENABLED)
31497: int mem_base;
31498: int ret_val;
31499: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31500: int n_reader;
31501:
31502: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31503: mem_base = xmlMemBlocks();
31504: reader = gen_xmlTextReaderPtr(n_reader, 0);
31505:
31506: ret_val = xmlTextReaderIsDefault(reader);
31507: desret_int(ret_val);
31508: call_tests++;
31509: des_xmlTextReaderPtr(n_reader, reader, 0);
31510: xmlResetLastError();
31511: if (mem_base != xmlMemBlocks()) {
31512: printf("Leak of %d blocks found in xmlTextReaderIsDefault",
31513: xmlMemBlocks() - mem_base);
31514: test_ret++;
31515: printf(" %d", n_reader);
31516: printf("\n");
31517: }
31518: }
31519: function_tests++;
31520: #endif
31521:
31522: return(test_ret);
31523: }
31524:
31525:
31526: static int
31527: test_xmlTextReaderIsEmptyElement(void) {
31528: int test_ret = 0;
31529:
31530: #if defined(LIBXML_READER_ENABLED)
31531: int mem_base;
31532: int ret_val;
31533: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31534: int n_reader;
31535:
31536: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31537: mem_base = xmlMemBlocks();
31538: reader = gen_xmlTextReaderPtr(n_reader, 0);
31539:
31540: ret_val = xmlTextReaderIsEmptyElement(reader);
31541: desret_int(ret_val);
31542: call_tests++;
31543: des_xmlTextReaderPtr(n_reader, reader, 0);
31544: xmlResetLastError();
31545: if (mem_base != xmlMemBlocks()) {
31546: printf("Leak of %d blocks found in xmlTextReaderIsEmptyElement",
31547: xmlMemBlocks() - mem_base);
31548: test_ret++;
31549: printf(" %d", n_reader);
31550: printf("\n");
31551: }
31552: }
31553: function_tests++;
31554: #endif
31555:
31556: return(test_ret);
31557: }
31558:
31559:
31560: static int
31561: test_xmlTextReaderIsNamespaceDecl(void) {
31562: int test_ret = 0;
31563:
31564: #if defined(LIBXML_READER_ENABLED)
31565: int mem_base;
31566: int ret_val;
31567: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31568: int n_reader;
31569:
31570: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31571: mem_base = xmlMemBlocks();
31572: reader = gen_xmlTextReaderPtr(n_reader, 0);
31573:
31574: ret_val = xmlTextReaderIsNamespaceDecl(reader);
31575: desret_int(ret_val);
31576: call_tests++;
31577: des_xmlTextReaderPtr(n_reader, reader, 0);
31578: xmlResetLastError();
31579: if (mem_base != xmlMemBlocks()) {
31580: printf("Leak of %d blocks found in xmlTextReaderIsNamespaceDecl",
31581: xmlMemBlocks() - mem_base);
31582: test_ret++;
31583: printf(" %d", n_reader);
31584: printf("\n");
31585: }
31586: }
31587: function_tests++;
31588: #endif
31589:
31590: return(test_ret);
31591: }
31592:
31593:
31594: static int
31595: test_xmlTextReaderIsValid(void) {
31596: int test_ret = 0;
31597:
31598: #if defined(LIBXML_READER_ENABLED)
31599: int mem_base;
31600: int ret_val;
31601: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31602: int n_reader;
31603:
31604: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31605: mem_base = xmlMemBlocks();
31606: reader = gen_xmlTextReaderPtr(n_reader, 0);
31607:
31608: ret_val = xmlTextReaderIsValid(reader);
31609: desret_int(ret_val);
31610: call_tests++;
31611: des_xmlTextReaderPtr(n_reader, reader, 0);
31612: xmlResetLastError();
31613: if (mem_base != xmlMemBlocks()) {
31614: printf("Leak of %d blocks found in xmlTextReaderIsValid",
31615: xmlMemBlocks() - mem_base);
31616: test_ret++;
31617: printf(" %d", n_reader);
31618: printf("\n");
31619: }
31620: }
31621: function_tests++;
31622: #endif
31623:
31624: return(test_ret);
31625: }
31626:
31627:
31628: static int
31629: test_xmlTextReaderLocalName(void) {
31630: int test_ret = 0;
31631:
31632: #if defined(LIBXML_READER_ENABLED)
31633: int mem_base;
31634: xmlChar * ret_val;
31635: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31636: int n_reader;
31637:
31638: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31639: mem_base = xmlMemBlocks();
31640: reader = gen_xmlTextReaderPtr(n_reader, 0);
31641:
31642: ret_val = xmlTextReaderLocalName(reader);
31643: desret_xmlChar_ptr(ret_val);
31644: call_tests++;
31645: des_xmlTextReaderPtr(n_reader, reader, 0);
31646: xmlResetLastError();
31647: if (mem_base != xmlMemBlocks()) {
31648: printf("Leak of %d blocks found in xmlTextReaderLocalName",
31649: xmlMemBlocks() - mem_base);
31650: test_ret++;
31651: printf(" %d", n_reader);
31652: printf("\n");
31653: }
31654: }
31655: function_tests++;
31656: #endif
31657:
31658: return(test_ret);
31659: }
31660:
31661: #ifdef LIBXML_READER_ENABLED
31662:
31663: #define gen_nb_xmlTextReaderLocatorPtr 1
31664: static xmlTextReaderLocatorPtr gen_xmlTextReaderLocatorPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
31665: return(NULL);
31666: }
31667: static void des_xmlTextReaderLocatorPtr(int no ATTRIBUTE_UNUSED, xmlTextReaderLocatorPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
31668: }
31669: #endif
31670:
31671:
31672: static int
31673: test_xmlTextReaderLocatorBaseURI(void) {
31674: int test_ret = 0;
31675:
31676: #if defined(LIBXML_READER_ENABLED)
31677: int mem_base;
31678: xmlChar * ret_val;
31679: xmlTextReaderLocatorPtr locator; /* the xmlTextReaderLocatorPtr used */
31680: int n_locator;
31681:
31682: for (n_locator = 0;n_locator < gen_nb_xmlTextReaderLocatorPtr;n_locator++) {
31683: mem_base = xmlMemBlocks();
31684: locator = gen_xmlTextReaderLocatorPtr(n_locator, 0);
31685:
31686: ret_val = xmlTextReaderLocatorBaseURI(locator);
31687: desret_xmlChar_ptr(ret_val);
31688: call_tests++;
31689: des_xmlTextReaderLocatorPtr(n_locator, locator, 0);
31690: xmlResetLastError();
31691: if (mem_base != xmlMemBlocks()) {
31692: printf("Leak of %d blocks found in xmlTextReaderLocatorBaseURI",
31693: xmlMemBlocks() - mem_base);
31694: test_ret++;
31695: printf(" %d", n_locator);
31696: printf("\n");
31697: }
31698: }
31699: function_tests++;
31700: #endif
31701:
31702: return(test_ret);
31703: }
31704:
31705:
31706: static int
31707: test_xmlTextReaderLocatorLineNumber(void) {
31708: int test_ret = 0;
31709:
31710: #if defined(LIBXML_READER_ENABLED)
31711: int mem_base;
31712: int ret_val;
31713: xmlTextReaderLocatorPtr locator; /* the xmlTextReaderLocatorPtr used */
31714: int n_locator;
31715:
31716: for (n_locator = 0;n_locator < gen_nb_xmlTextReaderLocatorPtr;n_locator++) {
31717: mem_base = xmlMemBlocks();
31718: locator = gen_xmlTextReaderLocatorPtr(n_locator, 0);
31719:
31720: ret_val = xmlTextReaderLocatorLineNumber(locator);
31721: desret_int(ret_val);
31722: call_tests++;
31723: des_xmlTextReaderLocatorPtr(n_locator, locator, 0);
31724: xmlResetLastError();
31725: if (mem_base != xmlMemBlocks()) {
31726: printf("Leak of %d blocks found in xmlTextReaderLocatorLineNumber",
31727: xmlMemBlocks() - mem_base);
31728: test_ret++;
31729: printf(" %d", n_locator);
31730: printf("\n");
31731: }
31732: }
31733: function_tests++;
31734: #endif
31735:
31736: return(test_ret);
31737: }
31738:
31739:
31740: static int
31741: test_xmlTextReaderLookupNamespace(void) {
31742: int test_ret = 0;
31743:
31744: #if defined(LIBXML_READER_ENABLED)
31745: int mem_base;
31746: xmlChar * ret_val;
31747: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31748: int n_reader;
31749: xmlChar * prefix; /* the prefix whose namespace URI is to be resolved. To return the default namespace, specify NULL */
31750: int n_prefix;
31751:
31752: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31753: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
31754: mem_base = xmlMemBlocks();
31755: reader = gen_xmlTextReaderPtr(n_reader, 0);
31756: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
31757:
31758: ret_val = xmlTextReaderLookupNamespace(reader, (const xmlChar *)prefix);
31759: desret_xmlChar_ptr(ret_val);
31760: call_tests++;
31761: des_xmlTextReaderPtr(n_reader, reader, 0);
31762: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
31763: xmlResetLastError();
31764: if (mem_base != xmlMemBlocks()) {
31765: printf("Leak of %d blocks found in xmlTextReaderLookupNamespace",
31766: xmlMemBlocks() - mem_base);
31767: test_ret++;
31768: printf(" %d", n_reader);
31769: printf(" %d", n_prefix);
31770: printf("\n");
31771: }
31772: }
31773: }
31774: function_tests++;
31775: #endif
31776:
31777: return(test_ret);
31778: }
31779:
31780:
31781: static int
31782: test_xmlTextReaderMoveToAttribute(void) {
31783: int test_ret = 0;
31784:
31785: #if defined(LIBXML_READER_ENABLED)
31786: int mem_base;
31787: int ret_val;
31788: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31789: int n_reader;
31790: xmlChar * name; /* the qualified name of the attribute. */
31791: int n_name;
31792:
31793: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31794: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
31795: mem_base = xmlMemBlocks();
31796: reader = gen_xmlTextReaderPtr(n_reader, 0);
31797: name = gen_const_xmlChar_ptr(n_name, 1);
31798:
31799: ret_val = xmlTextReaderMoveToAttribute(reader, (const xmlChar *)name);
31800: desret_int(ret_val);
31801: call_tests++;
31802: des_xmlTextReaderPtr(n_reader, reader, 0);
31803: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
31804: xmlResetLastError();
31805: if (mem_base != xmlMemBlocks()) {
31806: printf("Leak of %d blocks found in xmlTextReaderMoveToAttribute",
31807: xmlMemBlocks() - mem_base);
31808: test_ret++;
31809: printf(" %d", n_reader);
31810: printf(" %d", n_name);
31811: printf("\n");
31812: }
31813: }
31814: }
31815: function_tests++;
31816: #endif
31817:
31818: return(test_ret);
31819: }
31820:
31821:
31822: static int
31823: test_xmlTextReaderMoveToAttributeNo(void) {
31824: int test_ret = 0;
31825:
31826: #if defined(LIBXML_READER_ENABLED)
31827: int mem_base;
31828: int ret_val;
31829: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31830: int n_reader;
31831: int no; /* the zero-based index of the attribute relative to the containing element. */
31832: int n_no;
31833:
31834: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31835: for (n_no = 0;n_no < gen_nb_int;n_no++) {
31836: mem_base = xmlMemBlocks();
31837: reader = gen_xmlTextReaderPtr(n_reader, 0);
31838: no = gen_int(n_no, 1);
31839:
31840: ret_val = xmlTextReaderMoveToAttributeNo(reader, no);
31841: desret_int(ret_val);
31842: call_tests++;
31843: des_xmlTextReaderPtr(n_reader, reader, 0);
31844: des_int(n_no, no, 1);
31845: xmlResetLastError();
31846: if (mem_base != xmlMemBlocks()) {
31847: printf("Leak of %d blocks found in xmlTextReaderMoveToAttributeNo",
31848: xmlMemBlocks() - mem_base);
31849: test_ret++;
31850: printf(" %d", n_reader);
31851: printf(" %d", n_no);
31852: printf("\n");
31853: }
31854: }
31855: }
31856: function_tests++;
31857: #endif
31858:
31859: return(test_ret);
31860: }
31861:
31862:
31863: static int
31864: test_xmlTextReaderMoveToAttributeNs(void) {
31865: int test_ret = 0;
31866:
31867: #if defined(LIBXML_READER_ENABLED)
31868: int mem_base;
31869: int ret_val;
31870: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31871: int n_reader;
31872: xmlChar * localName; /* the local name of the attribute. */
31873: int n_localName;
31874: xmlChar * namespaceURI; /* the namespace URI of the attribute. */
31875: int n_namespaceURI;
31876:
31877: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31878: for (n_localName = 0;n_localName < gen_nb_const_xmlChar_ptr;n_localName++) {
31879: for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
31880: mem_base = xmlMemBlocks();
31881: reader = gen_xmlTextReaderPtr(n_reader, 0);
31882: localName = gen_const_xmlChar_ptr(n_localName, 1);
31883: namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 2);
31884:
31885: ret_val = xmlTextReaderMoveToAttributeNs(reader, (const xmlChar *)localName, (const xmlChar *)namespaceURI);
31886: desret_int(ret_val);
31887: call_tests++;
31888: des_xmlTextReaderPtr(n_reader, reader, 0);
31889: des_const_xmlChar_ptr(n_localName, (const xmlChar *)localName, 1);
31890: des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 2);
31891: xmlResetLastError();
31892: if (mem_base != xmlMemBlocks()) {
31893: printf("Leak of %d blocks found in xmlTextReaderMoveToAttributeNs",
31894: xmlMemBlocks() - mem_base);
31895: test_ret++;
31896: printf(" %d", n_reader);
31897: printf(" %d", n_localName);
31898: printf(" %d", n_namespaceURI);
31899: printf("\n");
31900: }
31901: }
31902: }
31903: }
31904: function_tests++;
31905: #endif
31906:
31907: return(test_ret);
31908: }
31909:
31910:
31911: static int
31912: test_xmlTextReaderMoveToElement(void) {
31913: int test_ret = 0;
31914:
31915: #if defined(LIBXML_READER_ENABLED)
31916: int mem_base;
31917: int ret_val;
31918: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31919: int n_reader;
31920:
31921: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31922: mem_base = xmlMemBlocks();
31923: reader = gen_xmlTextReaderPtr(n_reader, 0);
31924:
31925: ret_val = xmlTextReaderMoveToElement(reader);
31926: desret_int(ret_val);
31927: call_tests++;
31928: des_xmlTextReaderPtr(n_reader, reader, 0);
31929: xmlResetLastError();
31930: if (mem_base != xmlMemBlocks()) {
31931: printf("Leak of %d blocks found in xmlTextReaderMoveToElement",
31932: xmlMemBlocks() - mem_base);
31933: test_ret++;
31934: printf(" %d", n_reader);
31935: printf("\n");
31936: }
31937: }
31938: function_tests++;
31939: #endif
31940:
31941: return(test_ret);
31942: }
31943:
31944:
31945: static int
31946: test_xmlTextReaderMoveToFirstAttribute(void) {
31947: int test_ret = 0;
31948:
31949: #if defined(LIBXML_READER_ENABLED)
31950: int mem_base;
31951: int ret_val;
31952: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31953: int n_reader;
31954:
31955: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31956: mem_base = xmlMemBlocks();
31957: reader = gen_xmlTextReaderPtr(n_reader, 0);
31958:
31959: ret_val = xmlTextReaderMoveToFirstAttribute(reader);
31960: desret_int(ret_val);
31961: call_tests++;
31962: des_xmlTextReaderPtr(n_reader, reader, 0);
31963: xmlResetLastError();
31964: if (mem_base != xmlMemBlocks()) {
31965: printf("Leak of %d blocks found in xmlTextReaderMoveToFirstAttribute",
31966: xmlMemBlocks() - mem_base);
31967: test_ret++;
31968: printf(" %d", n_reader);
31969: printf("\n");
31970: }
31971: }
31972: function_tests++;
31973: #endif
31974:
31975: return(test_ret);
31976: }
31977:
31978:
31979: static int
31980: test_xmlTextReaderMoveToNextAttribute(void) {
31981: int test_ret = 0;
31982:
31983: #if defined(LIBXML_READER_ENABLED)
31984: int mem_base;
31985: int ret_val;
31986: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31987: int n_reader;
31988:
31989: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31990: mem_base = xmlMemBlocks();
31991: reader = gen_xmlTextReaderPtr(n_reader, 0);
31992:
31993: ret_val = xmlTextReaderMoveToNextAttribute(reader);
31994: desret_int(ret_val);
31995: call_tests++;
31996: des_xmlTextReaderPtr(n_reader, reader, 0);
31997: xmlResetLastError();
31998: if (mem_base != xmlMemBlocks()) {
31999: printf("Leak of %d blocks found in xmlTextReaderMoveToNextAttribute",
32000: xmlMemBlocks() - mem_base);
32001: test_ret++;
32002: printf(" %d", n_reader);
32003: printf("\n");
32004: }
32005: }
32006: function_tests++;
32007: #endif
32008:
32009: return(test_ret);
32010: }
32011:
32012:
32013: static int
32014: test_xmlTextReaderName(void) {
32015: int test_ret = 0;
32016:
32017: #if defined(LIBXML_READER_ENABLED)
32018: int mem_base;
32019: xmlChar * ret_val;
32020: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32021: int n_reader;
32022:
32023: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32024: mem_base = xmlMemBlocks();
32025: reader = gen_xmlTextReaderPtr(n_reader, 0);
32026:
32027: ret_val = xmlTextReaderName(reader);
32028: desret_xmlChar_ptr(ret_val);
32029: call_tests++;
32030: des_xmlTextReaderPtr(n_reader, reader, 0);
32031: xmlResetLastError();
32032: if (mem_base != xmlMemBlocks()) {
32033: printf("Leak of %d blocks found in xmlTextReaderName",
32034: xmlMemBlocks() - mem_base);
32035: test_ret++;
32036: printf(" %d", n_reader);
32037: printf("\n");
32038: }
32039: }
32040: function_tests++;
32041: #endif
32042:
32043: return(test_ret);
32044: }
32045:
32046:
32047: static int
32048: test_xmlTextReaderNamespaceUri(void) {
32049: int test_ret = 0;
32050:
32051: #if defined(LIBXML_READER_ENABLED)
32052: int mem_base;
32053: xmlChar * ret_val;
32054: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32055: int n_reader;
32056:
32057: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32058: mem_base = xmlMemBlocks();
32059: reader = gen_xmlTextReaderPtr(n_reader, 0);
32060:
32061: ret_val = xmlTextReaderNamespaceUri(reader);
32062: desret_xmlChar_ptr(ret_val);
32063: call_tests++;
32064: des_xmlTextReaderPtr(n_reader, reader, 0);
32065: xmlResetLastError();
32066: if (mem_base != xmlMemBlocks()) {
32067: printf("Leak of %d blocks found in xmlTextReaderNamespaceUri",
32068: xmlMemBlocks() - mem_base);
32069: test_ret++;
32070: printf(" %d", n_reader);
32071: printf("\n");
32072: }
32073: }
32074: function_tests++;
32075: #endif
32076:
32077: return(test_ret);
32078: }
32079:
32080:
32081: static int
32082: test_xmlTextReaderNext(void) {
32083: int test_ret = 0;
32084:
32085: #if defined(LIBXML_READER_ENABLED)
32086: int mem_base;
32087: int ret_val;
32088: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32089: int n_reader;
32090:
32091: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32092: mem_base = xmlMemBlocks();
32093: reader = gen_xmlTextReaderPtr(n_reader, 0);
32094:
32095: ret_val = xmlTextReaderNext(reader);
32096: desret_int(ret_val);
32097: call_tests++;
32098: des_xmlTextReaderPtr(n_reader, reader, 0);
32099: xmlResetLastError();
32100: if (mem_base != xmlMemBlocks()) {
32101: printf("Leak of %d blocks found in xmlTextReaderNext",
32102: xmlMemBlocks() - mem_base);
32103: test_ret++;
32104: printf(" %d", n_reader);
32105: printf("\n");
32106: }
32107: }
32108: function_tests++;
32109: #endif
32110:
32111: return(test_ret);
32112: }
32113:
32114:
32115: static int
32116: test_xmlTextReaderNextSibling(void) {
32117: int test_ret = 0;
32118:
32119: #if defined(LIBXML_READER_ENABLED)
32120: int mem_base;
32121: int ret_val;
32122: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32123: int n_reader;
32124:
32125: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32126: mem_base = xmlMemBlocks();
32127: reader = gen_xmlTextReaderPtr(n_reader, 0);
32128:
32129: ret_val = xmlTextReaderNextSibling(reader);
32130: desret_int(ret_val);
32131: call_tests++;
32132: des_xmlTextReaderPtr(n_reader, reader, 0);
32133: xmlResetLastError();
32134: if (mem_base != xmlMemBlocks()) {
32135: printf("Leak of %d blocks found in xmlTextReaderNextSibling",
32136: xmlMemBlocks() - mem_base);
32137: test_ret++;
32138: printf(" %d", n_reader);
32139: printf("\n");
32140: }
32141: }
32142: function_tests++;
32143: #endif
32144:
32145: return(test_ret);
32146: }
32147:
32148:
32149: static int
32150: test_xmlTextReaderNodeType(void) {
32151: int test_ret = 0;
32152:
32153: #if defined(LIBXML_READER_ENABLED)
32154: int mem_base;
32155: int ret_val;
32156: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32157: int n_reader;
32158:
32159: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32160: mem_base = xmlMemBlocks();
32161: reader = gen_xmlTextReaderPtr(n_reader, 0);
32162:
32163: ret_val = xmlTextReaderNodeType(reader);
32164: desret_int(ret_val);
32165: call_tests++;
32166: des_xmlTextReaderPtr(n_reader, reader, 0);
32167: xmlResetLastError();
32168: if (mem_base != xmlMemBlocks()) {
32169: printf("Leak of %d blocks found in xmlTextReaderNodeType",
32170: xmlMemBlocks() - mem_base);
32171: test_ret++;
32172: printf(" %d", n_reader);
32173: printf("\n");
32174: }
32175: }
32176: function_tests++;
32177: #endif
32178:
32179: return(test_ret);
32180: }
32181:
32182:
32183: static int
32184: test_xmlTextReaderNormalization(void) {
32185: int test_ret = 0;
32186:
32187: #if defined(LIBXML_READER_ENABLED)
32188: int mem_base;
32189: int ret_val;
32190: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32191: int n_reader;
32192:
32193: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32194: mem_base = xmlMemBlocks();
32195: reader = gen_xmlTextReaderPtr(n_reader, 0);
32196:
32197: ret_val = xmlTextReaderNormalization(reader);
32198: desret_int(ret_val);
32199: call_tests++;
32200: des_xmlTextReaderPtr(n_reader, reader, 0);
32201: xmlResetLastError();
32202: if (mem_base != xmlMemBlocks()) {
32203: printf("Leak of %d blocks found in xmlTextReaderNormalization",
32204: xmlMemBlocks() - mem_base);
32205: test_ret++;
32206: printf(" %d", n_reader);
32207: printf("\n");
32208: }
32209: }
32210: function_tests++;
32211: #endif
32212:
32213: return(test_ret);
32214: }
32215:
32216:
32217: static int
32218: test_xmlTextReaderPrefix(void) {
32219: int test_ret = 0;
32220:
32221: #if defined(LIBXML_READER_ENABLED)
32222: int mem_base;
32223: xmlChar * ret_val;
32224: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32225: int n_reader;
32226:
32227: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32228: mem_base = xmlMemBlocks();
32229: reader = gen_xmlTextReaderPtr(n_reader, 0);
32230:
32231: ret_val = xmlTextReaderPrefix(reader);
32232: desret_xmlChar_ptr(ret_val);
32233: call_tests++;
32234: des_xmlTextReaderPtr(n_reader, reader, 0);
32235: xmlResetLastError();
32236: if (mem_base != xmlMemBlocks()) {
32237: printf("Leak of %d blocks found in xmlTextReaderPrefix",
32238: xmlMemBlocks() - mem_base);
32239: test_ret++;
32240: printf(" %d", n_reader);
32241: printf("\n");
32242: }
32243: }
32244: function_tests++;
32245: #endif
32246:
32247: return(test_ret);
32248: }
32249:
32250:
32251: static int
32252: test_xmlTextReaderPreserve(void) {
32253: int test_ret = 0;
32254:
32255: #if defined(LIBXML_READER_ENABLED)
32256: int mem_base;
32257: xmlNodePtr ret_val;
32258: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32259: int n_reader;
32260:
32261: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32262: mem_base = xmlMemBlocks();
32263: reader = gen_xmlTextReaderPtr(n_reader, 0);
32264:
32265: ret_val = xmlTextReaderPreserve(reader);
32266: desret_xmlNodePtr(ret_val);
32267: call_tests++;
32268: des_xmlTextReaderPtr(n_reader, reader, 0);
32269: xmlResetLastError();
32270: if (mem_base != xmlMemBlocks()) {
32271: printf("Leak of %d blocks found in xmlTextReaderPreserve",
32272: xmlMemBlocks() - mem_base);
32273: test_ret++;
32274: printf(" %d", n_reader);
32275: printf("\n");
32276: }
32277: }
32278: function_tests++;
32279: #endif
32280:
32281: return(test_ret);
32282: }
32283:
32284:
32285: static int
32286: test_xmlTextReaderPreservePattern(void) {
32287: int test_ret = 0;
32288:
32289: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_PATTERN_ENABLED)
32290: #ifdef LIBXML_PATTERN_ENABLED
32291: int mem_base;
32292: int ret_val;
32293: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32294: int n_reader;
32295: xmlChar * pattern; /* an XPath subset pattern */
32296: int n_pattern;
32297: xmlChar ** namespaces; /* the prefix definitions, array of [URI, prefix] or NULL */
32298: int n_namespaces;
32299:
32300: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32301: for (n_pattern = 0;n_pattern < gen_nb_const_xmlChar_ptr;n_pattern++) {
32302: for (n_namespaces = 0;n_namespaces < gen_nb_const_xmlChar_ptr_ptr;n_namespaces++) {
32303: mem_base = xmlMemBlocks();
32304: reader = gen_xmlTextReaderPtr(n_reader, 0);
32305: pattern = gen_const_xmlChar_ptr(n_pattern, 1);
32306: namespaces = gen_const_xmlChar_ptr_ptr(n_namespaces, 2);
32307:
32308: ret_val = xmlTextReaderPreservePattern(reader, (const xmlChar *)pattern, (const xmlChar **)namespaces);
32309: desret_int(ret_val);
32310: call_tests++;
32311: des_xmlTextReaderPtr(n_reader, reader, 0);
32312: des_const_xmlChar_ptr(n_pattern, (const xmlChar *)pattern, 1);
32313: des_const_xmlChar_ptr_ptr(n_namespaces, (const xmlChar **)namespaces, 2);
32314: xmlResetLastError();
32315: if (mem_base != xmlMemBlocks()) {
32316: printf("Leak of %d blocks found in xmlTextReaderPreservePattern",
32317: xmlMemBlocks() - mem_base);
32318: test_ret++;
32319: printf(" %d", n_reader);
32320: printf(" %d", n_pattern);
32321: printf(" %d", n_namespaces);
32322: printf("\n");
32323: }
32324: }
32325: }
32326: }
32327: function_tests++;
32328: #endif
32329: #endif
32330:
32331: return(test_ret);
32332: }
32333:
32334:
32335: static int
32336: test_xmlTextReaderQuoteChar(void) {
32337: int test_ret = 0;
32338:
32339: #if defined(LIBXML_READER_ENABLED)
32340: int mem_base;
32341: int ret_val;
32342: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32343: int n_reader;
32344:
32345: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32346: mem_base = xmlMemBlocks();
32347: reader = gen_xmlTextReaderPtr(n_reader, 0);
32348:
32349: ret_val = xmlTextReaderQuoteChar(reader);
32350: desret_int(ret_val);
32351: call_tests++;
32352: des_xmlTextReaderPtr(n_reader, reader, 0);
32353: xmlResetLastError();
32354: if (mem_base != xmlMemBlocks()) {
32355: printf("Leak of %d blocks found in xmlTextReaderQuoteChar",
32356: xmlMemBlocks() - mem_base);
32357: test_ret++;
32358: printf(" %d", n_reader);
32359: printf("\n");
32360: }
32361: }
32362: function_tests++;
32363: #endif
32364:
32365: return(test_ret);
32366: }
32367:
32368:
32369: static int
32370: test_xmlTextReaderRead(void) {
32371: int test_ret = 0;
32372:
32373: #if defined(LIBXML_READER_ENABLED)
32374: int mem_base;
32375: int ret_val;
32376: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32377: int n_reader;
32378:
32379: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32380: mem_base = xmlMemBlocks();
32381: reader = gen_xmlTextReaderPtr(n_reader, 0);
32382:
32383: ret_val = xmlTextReaderRead(reader);
32384: desret_int(ret_val);
32385: call_tests++;
32386: des_xmlTextReaderPtr(n_reader, reader, 0);
32387: xmlResetLastError();
32388: if (mem_base != xmlMemBlocks()) {
32389: printf("Leak of %d blocks found in xmlTextReaderRead",
32390: xmlMemBlocks() - mem_base);
32391: test_ret++;
32392: printf(" %d", n_reader);
32393: printf("\n");
32394: }
32395: }
32396: function_tests++;
32397: #endif
32398:
32399: return(test_ret);
32400: }
32401:
32402:
32403: static int
32404: test_xmlTextReaderReadAttributeValue(void) {
32405: int test_ret = 0;
32406:
32407: #if defined(LIBXML_READER_ENABLED)
32408: int mem_base;
32409: int ret_val;
32410: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32411: int n_reader;
32412:
32413: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32414: mem_base = xmlMemBlocks();
32415: reader = gen_xmlTextReaderPtr(n_reader, 0);
32416:
32417: ret_val = xmlTextReaderReadAttributeValue(reader);
32418: desret_int(ret_val);
32419: call_tests++;
32420: des_xmlTextReaderPtr(n_reader, reader, 0);
32421: xmlResetLastError();
32422: if (mem_base != xmlMemBlocks()) {
32423: printf("Leak of %d blocks found in xmlTextReaderReadAttributeValue",
32424: xmlMemBlocks() - mem_base);
32425: test_ret++;
32426: printf(" %d", n_reader);
32427: printf("\n");
32428: }
32429: }
32430: function_tests++;
32431: #endif
32432:
32433: return(test_ret);
32434: }
32435:
32436:
32437: static int
32438: test_xmlTextReaderReadState(void) {
32439: int test_ret = 0;
32440:
32441: #if defined(LIBXML_READER_ENABLED)
32442: int mem_base;
32443: int ret_val;
32444: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32445: int n_reader;
32446:
32447: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32448: mem_base = xmlMemBlocks();
32449: reader = gen_xmlTextReaderPtr(n_reader, 0);
32450:
32451: ret_val = xmlTextReaderReadState(reader);
32452: desret_int(ret_val);
32453: call_tests++;
32454: des_xmlTextReaderPtr(n_reader, reader, 0);
32455: xmlResetLastError();
32456: if (mem_base != xmlMemBlocks()) {
32457: printf("Leak of %d blocks found in xmlTextReaderReadState",
32458: xmlMemBlocks() - mem_base);
32459: test_ret++;
32460: printf(" %d", n_reader);
32461: printf("\n");
32462: }
32463: }
32464: function_tests++;
32465: #endif
32466:
32467: return(test_ret);
32468: }
32469:
32470:
32471: static int
32472: test_xmlTextReaderRelaxNGSetSchema(void) {
32473: int test_ret = 0;
32474:
32475: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
32476: int mem_base;
32477: int ret_val;
32478: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32479: int n_reader;
32480: xmlRelaxNGPtr schema; /* a precompiled RelaxNG schema */
32481: int n_schema;
32482:
32483: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32484: for (n_schema = 0;n_schema < gen_nb_xmlRelaxNGPtr;n_schema++) {
32485: mem_base = xmlMemBlocks();
32486: reader = gen_xmlTextReaderPtr(n_reader, 0);
32487: schema = gen_xmlRelaxNGPtr(n_schema, 1);
32488:
32489: ret_val = xmlTextReaderRelaxNGSetSchema(reader, schema);
32490: desret_int(ret_val);
32491: call_tests++;
32492: des_xmlTextReaderPtr(n_reader, reader, 0);
32493: des_xmlRelaxNGPtr(n_schema, schema, 1);
32494: xmlResetLastError();
32495: if (mem_base != xmlMemBlocks()) {
32496: printf("Leak of %d blocks found in xmlTextReaderRelaxNGSetSchema",
32497: xmlMemBlocks() - mem_base);
32498: test_ret++;
32499: printf(" %d", n_reader);
32500: printf(" %d", n_schema);
32501: printf("\n");
32502: }
32503: }
32504: }
32505: function_tests++;
32506: #endif
32507:
32508: return(test_ret);
32509: }
32510:
32511:
32512: static int
32513: test_xmlTextReaderRelaxNGValidate(void) {
32514: int test_ret = 0;
32515:
32516: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
32517: int mem_base;
32518: int ret_val;
32519: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32520: int n_reader;
32521: char * rng; /* the path to a RelaxNG schema or NULL */
32522: int n_rng;
32523:
32524: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32525: for (n_rng = 0;n_rng < gen_nb_const_char_ptr;n_rng++) {
32526: mem_base = xmlMemBlocks();
32527: reader = gen_xmlTextReaderPtr(n_reader, 0);
32528: rng = gen_const_char_ptr(n_rng, 1);
32529:
32530: ret_val = xmlTextReaderRelaxNGValidate(reader, (const char *)rng);
32531: desret_int(ret_val);
32532: call_tests++;
32533: des_xmlTextReaderPtr(n_reader, reader, 0);
32534: des_const_char_ptr(n_rng, (const char *)rng, 1);
32535: xmlResetLastError();
32536: if (mem_base != xmlMemBlocks()) {
32537: printf("Leak of %d blocks found in xmlTextReaderRelaxNGValidate",
32538: xmlMemBlocks() - mem_base);
32539: test_ret++;
32540: printf(" %d", n_reader);
32541: printf(" %d", n_rng);
32542: printf("\n");
32543: }
32544: }
32545: }
32546: function_tests++;
32547: #endif
32548:
32549: return(test_ret);
32550: }
32551:
32552:
32553: static int
1.1.1.2 misho 32554: test_xmlTextReaderRelaxNGValidateCtxt(void) {
32555: int test_ret = 0;
32556:
32557: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
32558: int mem_base;
32559: int ret_val;
32560: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32561: int n_reader;
32562: xmlRelaxNGValidCtxtPtr ctxt; /* the RelaxNG schema validation context or NULL */
32563: int n_ctxt;
32564: int options; /* options (not used yet) */
32565: int n_options;
32566:
32567: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32568: for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
32569: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
32570: mem_base = xmlMemBlocks();
32571: reader = gen_xmlTextReaderPtr(n_reader, 0);
32572: ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 1);
32573: options = gen_parseroptions(n_options, 2);
32574:
32575: ret_val = xmlTextReaderRelaxNGValidateCtxt(reader, ctxt, options);
32576: desret_int(ret_val);
32577: call_tests++;
32578: des_xmlTextReaderPtr(n_reader, reader, 0);
32579: des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 1);
32580: des_parseroptions(n_options, options, 2);
32581: xmlResetLastError();
32582: if (mem_base != xmlMemBlocks()) {
32583: printf("Leak of %d blocks found in xmlTextReaderRelaxNGValidateCtxt",
32584: xmlMemBlocks() - mem_base);
32585: test_ret++;
32586: printf(" %d", n_reader);
32587: printf(" %d", n_ctxt);
32588: printf(" %d", n_options);
32589: printf("\n");
32590: }
32591: }
32592: }
32593: }
32594: function_tests++;
32595: #endif
32596:
32597: return(test_ret);
32598: }
32599:
32600:
32601: static int
1.1 misho 32602: test_xmlTextReaderSchemaValidate(void) {
32603: int test_ret = 0;
32604:
32605: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
32606: int ret_val;
32607: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32608: int n_reader;
32609: char * xsd; /* the path to a W3C XSD schema or NULL */
32610: int n_xsd;
32611:
32612: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32613: for (n_xsd = 0;n_xsd < gen_nb_const_char_ptr;n_xsd++) {
32614: reader = gen_xmlTextReaderPtr(n_reader, 0);
32615: xsd = gen_const_char_ptr(n_xsd, 1);
32616:
32617: ret_val = xmlTextReaderSchemaValidate(reader, (const char *)xsd);
32618: desret_int(ret_val);
32619: call_tests++;
32620: des_xmlTextReaderPtr(n_reader, reader, 0);
32621: des_const_char_ptr(n_xsd, (const char *)xsd, 1);
32622: xmlResetLastError();
32623: }
32624: }
32625: function_tests++;
32626: #endif
32627:
32628: return(test_ret);
32629: }
32630:
32631:
32632: static int
32633: test_xmlTextReaderSchemaValidateCtxt(void) {
32634: int test_ret = 0;
32635:
32636: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
32637: int mem_base;
32638: int ret_val;
32639: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32640: int n_reader;
32641: xmlSchemaValidCtxtPtr ctxt; /* the XML Schema validation context or NULL */
32642: int n_ctxt;
32643: int options; /* options (not used yet) */
32644: int n_options;
32645:
32646: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32647: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
32648: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
32649: mem_base = xmlMemBlocks();
32650: reader = gen_xmlTextReaderPtr(n_reader, 0);
32651: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 1);
32652: options = gen_parseroptions(n_options, 2);
32653:
32654: ret_val = xmlTextReaderSchemaValidateCtxt(reader, ctxt, options);
32655: desret_int(ret_val);
32656: call_tests++;
32657: des_xmlTextReaderPtr(n_reader, reader, 0);
32658: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 1);
32659: des_parseroptions(n_options, options, 2);
32660: xmlResetLastError();
32661: if (mem_base != xmlMemBlocks()) {
32662: printf("Leak of %d blocks found in xmlTextReaderSchemaValidateCtxt",
32663: xmlMemBlocks() - mem_base);
32664: test_ret++;
32665: printf(" %d", n_reader);
32666: printf(" %d", n_ctxt);
32667: printf(" %d", n_options);
32668: printf("\n");
32669: }
32670: }
32671: }
32672: }
32673: function_tests++;
32674: #endif
32675:
32676: return(test_ret);
32677: }
32678:
32679:
32680: static int
32681: test_xmlTextReaderSetErrorHandler(void) {
32682: int test_ret = 0;
32683:
32684:
32685: /* missing type support */
32686: return(test_ret);
32687: }
32688:
32689:
32690: static int
32691: test_xmlTextReaderSetParserProp(void) {
32692: int test_ret = 0;
32693:
32694: #if defined(LIBXML_READER_ENABLED)
32695: int mem_base;
32696: int ret_val;
32697: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32698: int n_reader;
32699: int prop; /* the xmlParserProperties to set */
32700: int n_prop;
32701: int value; /* usually 0 or 1 to (de)activate it */
32702: int n_value;
32703:
32704: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32705: for (n_prop = 0;n_prop < gen_nb_int;n_prop++) {
32706: for (n_value = 0;n_value < gen_nb_int;n_value++) {
32707: mem_base = xmlMemBlocks();
32708: reader = gen_xmlTextReaderPtr(n_reader, 0);
32709: prop = gen_int(n_prop, 1);
32710: value = gen_int(n_value, 2);
32711:
32712: ret_val = xmlTextReaderSetParserProp(reader, prop, value);
32713: desret_int(ret_val);
32714: call_tests++;
32715: des_xmlTextReaderPtr(n_reader, reader, 0);
32716: des_int(n_prop, prop, 1);
32717: des_int(n_value, value, 2);
32718: xmlResetLastError();
32719: if (mem_base != xmlMemBlocks()) {
32720: printf("Leak of %d blocks found in xmlTextReaderSetParserProp",
32721: xmlMemBlocks() - mem_base);
32722: test_ret++;
32723: printf(" %d", n_reader);
32724: printf(" %d", n_prop);
32725: printf(" %d", n_value);
32726: printf("\n");
32727: }
32728: }
32729: }
32730: }
32731: function_tests++;
32732: #endif
32733:
32734: return(test_ret);
32735: }
32736:
32737:
32738: static int
32739: test_xmlTextReaderSetSchema(void) {
32740: int test_ret = 0;
32741:
32742: #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
32743: int mem_base;
32744: int ret_val;
32745: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32746: int n_reader;
32747: xmlSchemaPtr schema; /* a precompiled Schema schema */
32748: int n_schema;
32749:
32750: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32751: for (n_schema = 0;n_schema < gen_nb_xmlSchemaPtr;n_schema++) {
32752: mem_base = xmlMemBlocks();
32753: reader = gen_xmlTextReaderPtr(n_reader, 0);
32754: schema = gen_xmlSchemaPtr(n_schema, 1);
32755:
32756: ret_val = xmlTextReaderSetSchema(reader, schema);
32757: desret_int(ret_val);
32758: call_tests++;
32759: des_xmlTextReaderPtr(n_reader, reader, 0);
32760: des_xmlSchemaPtr(n_schema, schema, 1);
32761: xmlResetLastError();
32762: if (mem_base != xmlMemBlocks()) {
32763: printf("Leak of %d blocks found in xmlTextReaderSetSchema",
32764: xmlMemBlocks() - mem_base);
32765: test_ret++;
32766: printf(" %d", n_reader);
32767: printf(" %d", n_schema);
32768: printf("\n");
32769: }
32770: }
32771: }
32772: function_tests++;
32773: #endif
32774:
32775: return(test_ret);
32776: }
32777:
32778:
32779: static int
32780: test_xmlTextReaderSetStructuredErrorHandler(void) {
32781: int test_ret = 0;
32782:
32783:
32784: /* missing type support */
32785: return(test_ret);
32786: }
32787:
32788:
32789: static int
32790: test_xmlTextReaderSetup(void) {
32791: int test_ret = 0;
32792:
32793: #if defined(LIBXML_READER_ENABLED)
32794: int mem_base;
32795: int ret_val;
32796: xmlTextReaderPtr reader; /* an XML reader */
32797: int n_reader;
32798: xmlParserInputBufferPtr input; /* xmlParserInputBufferPtr used to feed the reader, will be destroyed with it. */
32799: int n_input;
32800: const char * URL; /* the base URL to use for the document */
32801: int n_URL;
32802: char * encoding; /* the document encoding, or NULL */
32803: int n_encoding;
32804: int options; /* a combination of xmlParserOption */
32805: int n_options;
32806:
32807: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32808: for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) {
32809: for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
32810: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
32811: for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
32812: mem_base = xmlMemBlocks();
32813: reader = gen_xmlTextReaderPtr(n_reader, 0);
32814: input = gen_xmlParserInputBufferPtr(n_input, 1);
32815: URL = gen_filepath(n_URL, 2);
32816: encoding = gen_const_char_ptr(n_encoding, 3);
32817: options = gen_parseroptions(n_options, 4);
32818:
32819: ret_val = xmlTextReaderSetup(reader, input, URL, (const char *)encoding, options);
32820: desret_int(ret_val);
32821: call_tests++;
32822: des_xmlTextReaderPtr(n_reader, reader, 0);
32823: des_filepath(n_URL, URL, 2);
32824: des_const_char_ptr(n_encoding, (const char *)encoding, 3);
32825: des_parseroptions(n_options, options, 4);
32826: xmlResetLastError();
32827: if (mem_base != xmlMemBlocks()) {
32828: printf("Leak of %d blocks found in xmlTextReaderSetup",
32829: xmlMemBlocks() - mem_base);
32830: test_ret++;
32831: printf(" %d", n_reader);
32832: printf(" %d", n_input);
32833: printf(" %d", n_URL);
32834: printf(" %d", n_encoding);
32835: printf(" %d", n_options);
32836: printf("\n");
32837: }
32838: }
32839: }
32840: }
32841: }
32842: }
32843: function_tests++;
32844: #endif
32845:
32846: return(test_ret);
32847: }
32848:
32849:
32850: static int
32851: test_xmlTextReaderStandalone(void) {
32852: int test_ret = 0;
32853:
32854: #if defined(LIBXML_READER_ENABLED)
32855: int mem_base;
32856: int ret_val;
32857: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32858: int n_reader;
32859:
32860: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32861: mem_base = xmlMemBlocks();
32862: reader = gen_xmlTextReaderPtr(n_reader, 0);
32863:
32864: ret_val = xmlTextReaderStandalone(reader);
32865: desret_int(ret_val);
32866: call_tests++;
32867: des_xmlTextReaderPtr(n_reader, reader, 0);
32868: xmlResetLastError();
32869: if (mem_base != xmlMemBlocks()) {
32870: printf("Leak of %d blocks found in xmlTextReaderStandalone",
32871: xmlMemBlocks() - mem_base);
32872: test_ret++;
32873: printf(" %d", n_reader);
32874: printf("\n");
32875: }
32876: }
32877: function_tests++;
32878: #endif
32879:
32880: return(test_ret);
32881: }
32882:
32883:
32884: static int
32885: test_xmlTextReaderValue(void) {
32886: int test_ret = 0;
32887:
32888: #if defined(LIBXML_READER_ENABLED)
32889: int mem_base;
32890: xmlChar * ret_val;
32891: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32892: int n_reader;
32893:
32894: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32895: mem_base = xmlMemBlocks();
32896: reader = gen_xmlTextReaderPtr(n_reader, 0);
32897:
32898: ret_val = xmlTextReaderValue(reader);
32899: desret_xmlChar_ptr(ret_val);
32900: call_tests++;
32901: des_xmlTextReaderPtr(n_reader, reader, 0);
32902: xmlResetLastError();
32903: if (mem_base != xmlMemBlocks()) {
32904: printf("Leak of %d blocks found in xmlTextReaderValue",
32905: xmlMemBlocks() - mem_base);
32906: test_ret++;
32907: printf(" %d", n_reader);
32908: printf("\n");
32909: }
32910: }
32911: function_tests++;
32912: #endif
32913:
32914: return(test_ret);
32915: }
32916:
32917:
32918: static int
32919: test_xmlTextReaderXmlLang(void) {
32920: int test_ret = 0;
32921:
32922: #if defined(LIBXML_READER_ENABLED)
32923: int mem_base;
32924: xmlChar * ret_val;
32925: xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32926: int n_reader;
32927:
32928: for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32929: mem_base = xmlMemBlocks();
32930: reader = gen_xmlTextReaderPtr(n_reader, 0);
32931:
32932: ret_val = xmlTextReaderXmlLang(reader);
32933: desret_xmlChar_ptr(ret_val);
32934: call_tests++;
32935: des_xmlTextReaderPtr(n_reader, reader, 0);
32936: xmlResetLastError();
32937: if (mem_base != xmlMemBlocks()) {
32938: printf("Leak of %d blocks found in xmlTextReaderXmlLang",
32939: xmlMemBlocks() - mem_base);
32940: test_ret++;
32941: printf(" %d", n_reader);
32942: printf("\n");
32943: }
32944: }
32945: function_tests++;
32946: #endif
32947:
32948: return(test_ret);
32949: }
32950:
32951: static int
32952: test_xmlreader(void) {
32953: int test_ret = 0;
32954:
1.1.1.2 misho 32955: if (quiet == 0) printf("Testing xmlreader : 76 of 86 functions ...\n");
1.1 misho 32956: test_ret += test_xmlNewTextReader();
32957: test_ret += test_xmlNewTextReaderFilename();
32958: test_ret += test_xmlReaderForDoc();
32959: test_ret += test_xmlReaderForFile();
32960: test_ret += test_xmlReaderForMemory();
32961: test_ret += test_xmlReaderNewDoc();
32962: test_ret += test_xmlReaderNewFile();
32963: test_ret += test_xmlReaderNewMemory();
32964: test_ret += test_xmlReaderNewWalker();
32965: test_ret += test_xmlReaderWalker();
32966: test_ret += test_xmlTextReaderAttributeCount();
32967: test_ret += test_xmlTextReaderBaseUri();
32968: test_ret += test_xmlTextReaderByteConsumed();
32969: test_ret += test_xmlTextReaderClose();
32970: test_ret += test_xmlTextReaderConstBaseUri();
32971: test_ret += test_xmlTextReaderConstEncoding();
32972: test_ret += test_xmlTextReaderConstLocalName();
32973: test_ret += test_xmlTextReaderConstName();
32974: test_ret += test_xmlTextReaderConstNamespaceUri();
32975: test_ret += test_xmlTextReaderConstPrefix();
32976: test_ret += test_xmlTextReaderConstString();
32977: test_ret += test_xmlTextReaderConstValue();
32978: test_ret += test_xmlTextReaderConstXmlLang();
32979: test_ret += test_xmlTextReaderConstXmlVersion();
32980: test_ret += test_xmlTextReaderCurrentDoc();
32981: test_ret += test_xmlTextReaderCurrentNode();
32982: test_ret += test_xmlTextReaderDepth();
32983: test_ret += test_xmlTextReaderExpand();
32984: test_ret += test_xmlTextReaderGetAttribute();
32985: test_ret += test_xmlTextReaderGetAttributeNo();
32986: test_ret += test_xmlTextReaderGetAttributeNs();
32987: test_ret += test_xmlTextReaderGetErrorHandler();
32988: test_ret += test_xmlTextReaderGetParserColumnNumber();
32989: test_ret += test_xmlTextReaderGetParserLineNumber();
32990: test_ret += test_xmlTextReaderGetParserProp();
32991: test_ret += test_xmlTextReaderGetRemainder();
32992: test_ret += test_xmlTextReaderHasAttributes();
32993: test_ret += test_xmlTextReaderHasValue();
32994: test_ret += test_xmlTextReaderIsDefault();
32995: test_ret += test_xmlTextReaderIsEmptyElement();
32996: test_ret += test_xmlTextReaderIsNamespaceDecl();
32997: test_ret += test_xmlTextReaderIsValid();
32998: test_ret += test_xmlTextReaderLocalName();
32999: test_ret += test_xmlTextReaderLocatorBaseURI();
33000: test_ret += test_xmlTextReaderLocatorLineNumber();
33001: test_ret += test_xmlTextReaderLookupNamespace();
33002: test_ret += test_xmlTextReaderMoveToAttribute();
33003: test_ret += test_xmlTextReaderMoveToAttributeNo();
33004: test_ret += test_xmlTextReaderMoveToAttributeNs();
33005: test_ret += test_xmlTextReaderMoveToElement();
33006: test_ret += test_xmlTextReaderMoveToFirstAttribute();
33007: test_ret += test_xmlTextReaderMoveToNextAttribute();
33008: test_ret += test_xmlTextReaderName();
33009: test_ret += test_xmlTextReaderNamespaceUri();
33010: test_ret += test_xmlTextReaderNext();
33011: test_ret += test_xmlTextReaderNextSibling();
33012: test_ret += test_xmlTextReaderNodeType();
33013: test_ret += test_xmlTextReaderNormalization();
33014: test_ret += test_xmlTextReaderPrefix();
33015: test_ret += test_xmlTextReaderPreserve();
33016: test_ret += test_xmlTextReaderPreservePattern();
33017: test_ret += test_xmlTextReaderQuoteChar();
33018: test_ret += test_xmlTextReaderRead();
33019: test_ret += test_xmlTextReaderReadAttributeValue();
33020: test_ret += test_xmlTextReaderReadState();
33021: test_ret += test_xmlTextReaderRelaxNGSetSchema();
33022: test_ret += test_xmlTextReaderRelaxNGValidate();
1.1.1.2 misho 33023: test_ret += test_xmlTextReaderRelaxNGValidateCtxt();
1.1 misho 33024: test_ret += test_xmlTextReaderSchemaValidate();
33025: test_ret += test_xmlTextReaderSchemaValidateCtxt();
33026: test_ret += test_xmlTextReaderSetErrorHandler();
33027: test_ret += test_xmlTextReaderSetParserProp();
33028: test_ret += test_xmlTextReaderSetSchema();
33029: test_ret += test_xmlTextReaderSetStructuredErrorHandler();
33030: test_ret += test_xmlTextReaderSetup();
33031: test_ret += test_xmlTextReaderStandalone();
33032: test_ret += test_xmlTextReaderValue();
33033: test_ret += test_xmlTextReaderXmlLang();
33034:
33035: if (test_ret != 0)
33036: printf("Module xmlreader: %d errors\n", test_ret);
33037: return(test_ret);
33038: }
33039:
33040: static int
33041: test_xmlExpCtxtNbCons(void) {
33042: int test_ret = 0;
33043:
33044: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
33045: int mem_base;
33046: int ret_val;
33047: xmlExpCtxtPtr ctxt; /* an expression context */
33048: int n_ctxt;
33049:
33050: for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) {
33051: mem_base = xmlMemBlocks();
33052: ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0);
33053:
33054: ret_val = xmlExpCtxtNbCons(ctxt);
33055: desret_int(ret_val);
33056: call_tests++;
33057: des_xmlExpCtxtPtr(n_ctxt, ctxt, 0);
33058: xmlResetLastError();
33059: if (mem_base != xmlMemBlocks()) {
33060: printf("Leak of %d blocks found in xmlExpCtxtNbCons",
33061: xmlMemBlocks() - mem_base);
33062: test_ret++;
33063: printf(" %d", n_ctxt);
33064: printf("\n");
33065: }
33066: }
33067: function_tests++;
33068: #endif
33069:
33070: return(test_ret);
33071: }
33072:
33073:
33074: static int
33075: test_xmlExpCtxtNbNodes(void) {
33076: int test_ret = 0;
33077:
33078: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
33079: int mem_base;
33080: int ret_val;
33081: xmlExpCtxtPtr ctxt; /* an expression context */
33082: int n_ctxt;
33083:
33084: for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) {
33085: mem_base = xmlMemBlocks();
33086: ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0);
33087:
33088: ret_val = xmlExpCtxtNbNodes(ctxt);
33089: desret_int(ret_val);
33090: call_tests++;
33091: des_xmlExpCtxtPtr(n_ctxt, ctxt, 0);
33092: xmlResetLastError();
33093: if (mem_base != xmlMemBlocks()) {
33094: printf("Leak of %d blocks found in xmlExpCtxtNbNodes",
33095: xmlMemBlocks() - mem_base);
33096: test_ret++;
33097: printf(" %d", n_ctxt);
33098: printf("\n");
33099: }
33100: }
33101: function_tests++;
33102: #endif
33103:
33104: return(test_ret);
33105: }
33106:
33107:
33108: static int
33109: test_xmlExpDump(void) {
33110: int test_ret = 0;
33111:
33112: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
33113: int mem_base;
33114: xmlBufferPtr buf; /* a buffer to receive the output */
33115: int n_buf;
33116: xmlExpNodePtr expr; /* the compiled expression */
33117: int n_expr;
33118:
33119: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
33120: for (n_expr = 0;n_expr < gen_nb_xmlExpNodePtr;n_expr++) {
33121: mem_base = xmlMemBlocks();
33122: buf = gen_xmlBufferPtr(n_buf, 0);
33123: expr = gen_xmlExpNodePtr(n_expr, 1);
33124:
33125: xmlExpDump(buf, expr);
33126: call_tests++;
33127: des_xmlBufferPtr(n_buf, buf, 0);
33128: des_xmlExpNodePtr(n_expr, expr, 1);
33129: xmlResetLastError();
33130: if (mem_base != xmlMemBlocks()) {
33131: printf("Leak of %d blocks found in xmlExpDump",
33132: xmlMemBlocks() - mem_base);
33133: test_ret++;
33134: printf(" %d", n_buf);
33135: printf(" %d", n_expr);
33136: printf("\n");
33137: }
33138: }
33139: }
33140: function_tests++;
33141: #endif
33142:
33143: return(test_ret);
33144: }
33145:
33146:
33147: static int
33148: test_xmlExpExpDerive(void) {
33149: int test_ret = 0;
33150:
33151:
33152: /* missing type support */
33153: return(test_ret);
33154: }
33155:
33156:
33157: static int
33158: test_xmlExpGetLanguage(void) {
33159: int test_ret = 0;
33160:
33161: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
33162: int mem_base;
33163: int ret_val;
33164: xmlExpCtxtPtr ctxt; /* the expression context */
33165: int n_ctxt;
33166: xmlExpNodePtr exp; /* the expression */
33167: int n_exp;
33168: xmlChar ** langList; /* where to store the tokens */
33169: int n_langList;
1.1.1.3 ! misho 33170: int len; /* the allocated length of @list */
1.1 misho 33171: int n_len;
33172:
33173: for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) {
33174: for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) {
33175: for (n_langList = 0;n_langList < gen_nb_const_xmlChar_ptr_ptr;n_langList++) {
33176: for (n_len = 0;n_len < gen_nb_int;n_len++) {
33177: mem_base = xmlMemBlocks();
33178: ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0);
33179: exp = gen_xmlExpNodePtr(n_exp, 1);
33180: langList = gen_const_xmlChar_ptr_ptr(n_langList, 2);
33181: len = gen_int(n_len, 3);
33182:
33183: ret_val = xmlExpGetLanguage(ctxt, exp, (const xmlChar **)langList, len);
33184: desret_int(ret_val);
33185: call_tests++;
33186: des_xmlExpCtxtPtr(n_ctxt, ctxt, 0);
33187: des_xmlExpNodePtr(n_exp, exp, 1);
33188: des_const_xmlChar_ptr_ptr(n_langList, (const xmlChar **)langList, 2);
33189: des_int(n_len, len, 3);
33190: xmlResetLastError();
33191: if (mem_base != xmlMemBlocks()) {
33192: printf("Leak of %d blocks found in xmlExpGetLanguage",
33193: xmlMemBlocks() - mem_base);
33194: test_ret++;
33195: printf(" %d", n_ctxt);
33196: printf(" %d", n_exp);
33197: printf(" %d", n_langList);
33198: printf(" %d", n_len);
33199: printf("\n");
33200: }
33201: }
33202: }
33203: }
33204: }
33205: function_tests++;
33206: #endif
33207:
33208: return(test_ret);
33209: }
33210:
33211:
33212: static int
33213: test_xmlExpGetStart(void) {
33214: int test_ret = 0;
33215:
33216: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
33217: int mem_base;
33218: int ret_val;
33219: xmlExpCtxtPtr ctxt; /* the expression context */
33220: int n_ctxt;
33221: xmlExpNodePtr exp; /* the expression */
33222: int n_exp;
33223: xmlChar ** tokList; /* where to store the tokens */
33224: int n_tokList;
1.1.1.3 ! misho 33225: int len; /* the allocated length of @list */
1.1 misho 33226: int n_len;
33227:
33228: for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) {
33229: for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) {
33230: for (n_tokList = 0;n_tokList < gen_nb_const_xmlChar_ptr_ptr;n_tokList++) {
33231: for (n_len = 0;n_len < gen_nb_int;n_len++) {
33232: mem_base = xmlMemBlocks();
33233: ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0);
33234: exp = gen_xmlExpNodePtr(n_exp, 1);
33235: tokList = gen_const_xmlChar_ptr_ptr(n_tokList, 2);
33236: len = gen_int(n_len, 3);
33237:
33238: ret_val = xmlExpGetStart(ctxt, exp, (const xmlChar **)tokList, len);
33239: desret_int(ret_val);
33240: call_tests++;
33241: des_xmlExpCtxtPtr(n_ctxt, ctxt, 0);
33242: des_xmlExpNodePtr(n_exp, exp, 1);
33243: des_const_xmlChar_ptr_ptr(n_tokList, (const xmlChar **)tokList, 2);
33244: des_int(n_len, len, 3);
33245: xmlResetLastError();
33246: if (mem_base != xmlMemBlocks()) {
33247: printf("Leak of %d blocks found in xmlExpGetStart",
33248: xmlMemBlocks() - mem_base);
33249: test_ret++;
33250: printf(" %d", n_ctxt);
33251: printf(" %d", n_exp);
33252: printf(" %d", n_tokList);
33253: printf(" %d", n_len);
33254: printf("\n");
33255: }
33256: }
33257: }
33258: }
33259: }
33260: function_tests++;
33261: #endif
33262:
33263: return(test_ret);
33264: }
33265:
33266:
33267: static int
33268: test_xmlExpIsNillable(void) {
33269: int test_ret = 0;
33270:
33271: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
33272: int mem_base;
33273: int ret_val;
33274: xmlExpNodePtr exp; /* the expression */
33275: int n_exp;
33276:
33277: for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) {
33278: mem_base = xmlMemBlocks();
33279: exp = gen_xmlExpNodePtr(n_exp, 0);
33280:
33281: ret_val = xmlExpIsNillable(exp);
33282: desret_int(ret_val);
33283: call_tests++;
33284: des_xmlExpNodePtr(n_exp, exp, 0);
33285: xmlResetLastError();
33286: if (mem_base != xmlMemBlocks()) {
33287: printf("Leak of %d blocks found in xmlExpIsNillable",
33288: xmlMemBlocks() - mem_base);
33289: test_ret++;
33290: printf(" %d", n_exp);
33291: printf("\n");
33292: }
33293: }
33294: function_tests++;
33295: #endif
33296:
33297: return(test_ret);
33298: }
33299:
33300:
33301: static int
33302: test_xmlExpMaxToken(void) {
33303: int test_ret = 0;
33304:
33305: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
33306: int mem_base;
33307: int ret_val;
33308: xmlExpNodePtr expr; /* a compiled expression */
33309: int n_expr;
33310:
33311: for (n_expr = 0;n_expr < gen_nb_xmlExpNodePtr;n_expr++) {
33312: mem_base = xmlMemBlocks();
33313: expr = gen_xmlExpNodePtr(n_expr, 0);
33314:
33315: ret_val = xmlExpMaxToken(expr);
33316: desret_int(ret_val);
33317: call_tests++;
33318: des_xmlExpNodePtr(n_expr, expr, 0);
33319: xmlResetLastError();
33320: if (mem_base != xmlMemBlocks()) {
33321: printf("Leak of %d blocks found in xmlExpMaxToken",
33322: xmlMemBlocks() - mem_base);
33323: test_ret++;
33324: printf(" %d", n_expr);
33325: printf("\n");
33326: }
33327: }
33328: function_tests++;
33329: #endif
33330:
33331: return(test_ret);
33332: }
33333:
33334:
33335: static int
33336: test_xmlExpNewAtom(void) {
33337: int test_ret = 0;
33338:
33339:
33340: /* missing type support */
33341: return(test_ret);
33342: }
33343:
33344:
33345: static int
33346: test_xmlExpNewCtxt(void) {
33347: int test_ret = 0;
33348:
33349:
33350: /* missing type support */
33351: return(test_ret);
33352: }
33353:
33354:
33355: static int
33356: test_xmlExpNewOr(void) {
33357: int test_ret = 0;
33358:
33359:
33360: /* missing type support */
33361: return(test_ret);
33362: }
33363:
33364:
33365: static int
33366: test_xmlExpNewRange(void) {
33367: int test_ret = 0;
33368:
33369:
33370: /* missing type support */
33371: return(test_ret);
33372: }
33373:
33374:
33375: static int
33376: test_xmlExpNewSeq(void) {
33377: int test_ret = 0;
33378:
33379:
33380: /* missing type support */
33381: return(test_ret);
33382: }
33383:
33384:
33385: static int
33386: test_xmlExpParse(void) {
33387: int test_ret = 0;
33388:
33389:
33390: /* missing type support */
33391: return(test_ret);
33392: }
33393:
33394:
33395: static int
33396: test_xmlExpRef(void) {
33397: int test_ret = 0;
33398:
33399: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
33400: int mem_base;
33401: xmlExpNodePtr exp; /* the expression */
33402: int n_exp;
33403:
33404: for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) {
33405: mem_base = xmlMemBlocks();
33406: exp = gen_xmlExpNodePtr(n_exp, 0);
33407:
33408: xmlExpRef(exp);
33409: call_tests++;
33410: des_xmlExpNodePtr(n_exp, exp, 0);
33411: xmlResetLastError();
33412: if (mem_base != xmlMemBlocks()) {
33413: printf("Leak of %d blocks found in xmlExpRef",
33414: xmlMemBlocks() - mem_base);
33415: test_ret++;
33416: printf(" %d", n_exp);
33417: printf("\n");
33418: }
33419: }
33420: function_tests++;
33421: #endif
33422:
33423: return(test_ret);
33424: }
33425:
33426:
33427: static int
33428: test_xmlExpStringDerive(void) {
33429: int test_ret = 0;
33430:
33431:
33432: /* missing type support */
33433: return(test_ret);
33434: }
33435:
33436:
33437: static int
33438: test_xmlExpSubsume(void) {
33439: int test_ret = 0;
33440:
33441: #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
33442: int mem_base;
33443: int ret_val;
33444: xmlExpCtxtPtr ctxt; /* the expressions context */
33445: int n_ctxt;
33446: xmlExpNodePtr exp; /* the englobing expression */
33447: int n_exp;
33448: xmlExpNodePtr sub; /* the subexpression */
33449: int n_sub;
33450:
33451: for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) {
33452: for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) {
33453: for (n_sub = 0;n_sub < gen_nb_xmlExpNodePtr;n_sub++) {
33454: mem_base = xmlMemBlocks();
33455: ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0);
33456: exp = gen_xmlExpNodePtr(n_exp, 1);
33457: sub = gen_xmlExpNodePtr(n_sub, 2);
33458:
33459: ret_val = xmlExpSubsume(ctxt, exp, sub);
33460: desret_int(ret_val);
33461: call_tests++;
33462: des_xmlExpCtxtPtr(n_ctxt, ctxt, 0);
33463: des_xmlExpNodePtr(n_exp, exp, 1);
33464: des_xmlExpNodePtr(n_sub, sub, 2);
33465: xmlResetLastError();
33466: if (mem_base != xmlMemBlocks()) {
33467: printf("Leak of %d blocks found in xmlExpSubsume",
33468: xmlMemBlocks() - mem_base);
33469: test_ret++;
33470: printf(" %d", n_ctxt);
33471: printf(" %d", n_exp);
33472: printf(" %d", n_sub);
33473: printf("\n");
33474: }
33475: }
33476: }
33477: }
33478: function_tests++;
33479: #endif
33480:
33481: return(test_ret);
33482: }
33483:
33484: #ifdef LIBXML_REGEXP_ENABLED
33485:
33486: #define gen_nb_xmlRegExecCtxtPtr 1
33487: static xmlRegExecCtxtPtr gen_xmlRegExecCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33488: return(NULL);
33489: }
33490: static void des_xmlRegExecCtxtPtr(int no ATTRIBUTE_UNUSED, xmlRegExecCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33491: }
33492: #endif
33493:
33494:
33495: static int
33496: test_xmlRegExecErrInfo(void) {
33497: int test_ret = 0;
33498:
33499: #if defined(LIBXML_REGEXP_ENABLED)
33500: int mem_base;
33501: int ret_val;
33502: xmlRegExecCtxtPtr exec; /* a regexp execution context generating an error */
33503: int n_exec;
33504: xmlChar ** string; /* return value for the error string */
33505: int n_string;
33506: int * nbval; /* pointer to the number of accepted values IN/OUT */
33507: int n_nbval;
33508: int * nbneg; /* return number of negative transitions */
33509: int n_nbneg;
33510: xmlChar ** values; /* pointer to the array of acceptable values */
33511: int n_values;
33512: int * terminal; /* return value if this was a terminal state */
33513: int n_terminal;
33514:
33515: for (n_exec = 0;n_exec < gen_nb_xmlRegExecCtxtPtr;n_exec++) {
33516: for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr_ptr;n_string++) {
33517: for (n_nbval = 0;n_nbval < gen_nb_int_ptr;n_nbval++) {
33518: for (n_nbneg = 0;n_nbneg < gen_nb_int_ptr;n_nbneg++) {
33519: for (n_values = 0;n_values < gen_nb_xmlChar_ptr_ptr;n_values++) {
33520: for (n_terminal = 0;n_terminal < gen_nb_int_ptr;n_terminal++) {
33521: mem_base = xmlMemBlocks();
33522: exec = gen_xmlRegExecCtxtPtr(n_exec, 0);
33523: string = gen_const_xmlChar_ptr_ptr(n_string, 1);
33524: nbval = gen_int_ptr(n_nbval, 2);
33525: nbneg = gen_int_ptr(n_nbneg, 3);
33526: values = gen_xmlChar_ptr_ptr(n_values, 4);
33527: terminal = gen_int_ptr(n_terminal, 5);
33528:
33529: ret_val = xmlRegExecErrInfo(exec, (const xmlChar **)string, nbval, nbneg, values, terminal);
33530: desret_int(ret_val);
33531: call_tests++;
33532: des_xmlRegExecCtxtPtr(n_exec, exec, 0);
33533: des_const_xmlChar_ptr_ptr(n_string, (const xmlChar **)string, 1);
33534: des_int_ptr(n_nbval, nbval, 2);
33535: des_int_ptr(n_nbneg, nbneg, 3);
33536: des_xmlChar_ptr_ptr(n_values, values, 4);
33537: des_int_ptr(n_terminal, terminal, 5);
33538: xmlResetLastError();
33539: if (mem_base != xmlMemBlocks()) {
33540: printf("Leak of %d blocks found in xmlRegExecErrInfo",
33541: xmlMemBlocks() - mem_base);
33542: test_ret++;
33543: printf(" %d", n_exec);
33544: printf(" %d", n_string);
33545: printf(" %d", n_nbval);
33546: printf(" %d", n_nbneg);
33547: printf(" %d", n_values);
33548: printf(" %d", n_terminal);
33549: printf("\n");
33550: }
33551: }
33552: }
33553: }
33554: }
33555: }
33556: }
33557: function_tests++;
33558: #endif
33559:
33560: return(test_ret);
33561: }
33562:
33563:
33564: static int
33565: test_xmlRegExecNextValues(void) {
33566: int test_ret = 0;
33567:
33568: #if defined(LIBXML_REGEXP_ENABLED)
33569: int mem_base;
33570: int ret_val;
33571: xmlRegExecCtxtPtr exec; /* a regexp execution context */
33572: int n_exec;
33573: int * nbval; /* pointer to the number of accepted values IN/OUT */
33574: int n_nbval;
33575: int * nbneg; /* return number of negative transitions */
33576: int n_nbneg;
33577: xmlChar ** values; /* pointer to the array of acceptable values */
33578: int n_values;
33579: int * terminal; /* return value if this was a terminal state */
33580: int n_terminal;
33581:
33582: for (n_exec = 0;n_exec < gen_nb_xmlRegExecCtxtPtr;n_exec++) {
33583: for (n_nbval = 0;n_nbval < gen_nb_int_ptr;n_nbval++) {
33584: for (n_nbneg = 0;n_nbneg < gen_nb_int_ptr;n_nbneg++) {
33585: for (n_values = 0;n_values < gen_nb_xmlChar_ptr_ptr;n_values++) {
33586: for (n_terminal = 0;n_terminal < gen_nb_int_ptr;n_terminal++) {
33587: mem_base = xmlMemBlocks();
33588: exec = gen_xmlRegExecCtxtPtr(n_exec, 0);
33589: nbval = gen_int_ptr(n_nbval, 1);
33590: nbneg = gen_int_ptr(n_nbneg, 2);
33591: values = gen_xmlChar_ptr_ptr(n_values, 3);
33592: terminal = gen_int_ptr(n_terminal, 4);
33593:
33594: ret_val = xmlRegExecNextValues(exec, nbval, nbneg, values, terminal);
33595: desret_int(ret_val);
33596: call_tests++;
33597: des_xmlRegExecCtxtPtr(n_exec, exec, 0);
33598: des_int_ptr(n_nbval, nbval, 1);
33599: des_int_ptr(n_nbneg, nbneg, 2);
33600: des_xmlChar_ptr_ptr(n_values, values, 3);
33601: des_int_ptr(n_terminal, terminal, 4);
33602: xmlResetLastError();
33603: if (mem_base != xmlMemBlocks()) {
33604: printf("Leak of %d blocks found in xmlRegExecNextValues",
33605: xmlMemBlocks() - mem_base);
33606: test_ret++;
33607: printf(" %d", n_exec);
33608: printf(" %d", n_nbval);
33609: printf(" %d", n_nbneg);
33610: printf(" %d", n_values);
33611: printf(" %d", n_terminal);
33612: printf("\n");
33613: }
33614: }
33615: }
33616: }
33617: }
33618: }
33619: function_tests++;
33620: #endif
33621:
33622: return(test_ret);
33623: }
33624:
33625:
33626: static int
33627: test_xmlRegExecPushString(void) {
33628: int test_ret = 0;
33629:
33630: #if defined(LIBXML_REGEXP_ENABLED)
33631: int mem_base;
33632: int ret_val;
33633: xmlRegExecCtxtPtr exec; /* a regexp execution context or NULL to indicate the end */
33634: int n_exec;
33635: xmlChar * value; /* a string token input */
33636: int n_value;
33637: void * data; /* data associated to the token to reuse in callbacks */
33638: int n_data;
33639:
33640: for (n_exec = 0;n_exec < gen_nb_xmlRegExecCtxtPtr;n_exec++) {
33641: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
33642: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
33643: mem_base = xmlMemBlocks();
33644: exec = gen_xmlRegExecCtxtPtr(n_exec, 0);
33645: value = gen_const_xmlChar_ptr(n_value, 1);
33646: data = gen_userdata(n_data, 2);
33647:
33648: ret_val = xmlRegExecPushString(exec, (const xmlChar *)value, data);
33649: desret_int(ret_val);
33650: call_tests++;
33651: des_xmlRegExecCtxtPtr(n_exec, exec, 0);
33652: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
33653: des_userdata(n_data, data, 2);
33654: xmlResetLastError();
33655: if (mem_base != xmlMemBlocks()) {
33656: printf("Leak of %d blocks found in xmlRegExecPushString",
33657: xmlMemBlocks() - mem_base);
33658: test_ret++;
33659: printf(" %d", n_exec);
33660: printf(" %d", n_value);
33661: printf(" %d", n_data);
33662: printf("\n");
33663: }
33664: }
33665: }
33666: }
33667: function_tests++;
33668: #endif
33669:
33670: return(test_ret);
33671: }
33672:
33673:
33674: static int
33675: test_xmlRegExecPushString2(void) {
33676: int test_ret = 0;
33677:
33678: #if defined(LIBXML_REGEXP_ENABLED)
33679: int mem_base;
33680: int ret_val;
33681: xmlRegExecCtxtPtr exec; /* a regexp execution context or NULL to indicate the end */
33682: int n_exec;
33683: xmlChar * value; /* the first string token input */
33684: int n_value;
33685: xmlChar * value2; /* the second string token input */
33686: int n_value2;
33687: void * data; /* data associated to the token to reuse in callbacks */
33688: int n_data;
33689:
33690: for (n_exec = 0;n_exec < gen_nb_xmlRegExecCtxtPtr;n_exec++) {
33691: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
33692: for (n_value2 = 0;n_value2 < gen_nb_const_xmlChar_ptr;n_value2++) {
33693: for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
33694: mem_base = xmlMemBlocks();
33695: exec = gen_xmlRegExecCtxtPtr(n_exec, 0);
33696: value = gen_const_xmlChar_ptr(n_value, 1);
33697: value2 = gen_const_xmlChar_ptr(n_value2, 2);
33698: data = gen_userdata(n_data, 3);
33699:
33700: ret_val = xmlRegExecPushString2(exec, (const xmlChar *)value, (const xmlChar *)value2, data);
33701: desret_int(ret_val);
33702: call_tests++;
33703: des_xmlRegExecCtxtPtr(n_exec, exec, 0);
33704: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
33705: des_const_xmlChar_ptr(n_value2, (const xmlChar *)value2, 2);
33706: des_userdata(n_data, data, 3);
33707: xmlResetLastError();
33708: if (mem_base != xmlMemBlocks()) {
33709: printf("Leak of %d blocks found in xmlRegExecPushString2",
33710: xmlMemBlocks() - mem_base);
33711: test_ret++;
33712: printf(" %d", n_exec);
33713: printf(" %d", n_value);
33714: printf(" %d", n_value2);
33715: printf(" %d", n_data);
33716: printf("\n");
33717: }
33718: }
33719: }
33720: }
33721: }
33722: function_tests++;
33723: #endif
33724:
33725: return(test_ret);
33726: }
33727:
33728: #ifdef LIBXML_REGEXP_ENABLED
33729:
33730: #define gen_nb_xmlRegexpPtr 1
33731: static xmlRegexpPtr gen_xmlRegexpPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33732: return(NULL);
33733: }
33734: static void des_xmlRegexpPtr(int no ATTRIBUTE_UNUSED, xmlRegexpPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33735: }
33736: #endif
33737:
33738:
33739: static int
33740: test_xmlRegNewExecCtxt(void) {
33741: int test_ret = 0;
33742:
33743:
33744: /* missing type support */
33745: return(test_ret);
33746: }
33747:
33748:
33749: static int
33750: test_xmlRegexpCompile(void) {
33751: int test_ret = 0;
33752:
33753:
33754: /* missing type support */
33755: return(test_ret);
33756: }
33757:
33758:
33759: static int
33760: test_xmlRegexpExec(void) {
33761: int test_ret = 0;
33762:
33763: #if defined(LIBXML_REGEXP_ENABLED)
33764: int mem_base;
33765: int ret_val;
33766: xmlRegexpPtr comp; /* the compiled regular expression */
33767: int n_comp;
33768: xmlChar * content; /* the value to check against the regular expression */
33769: int n_content;
33770:
33771: for (n_comp = 0;n_comp < gen_nb_xmlRegexpPtr;n_comp++) {
33772: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
33773: mem_base = xmlMemBlocks();
33774: comp = gen_xmlRegexpPtr(n_comp, 0);
33775: content = gen_const_xmlChar_ptr(n_content, 1);
33776:
33777: ret_val = xmlRegexpExec(comp, (const xmlChar *)content);
33778: desret_int(ret_val);
33779: call_tests++;
33780: des_xmlRegexpPtr(n_comp, comp, 0);
33781: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
33782: xmlResetLastError();
33783: if (mem_base != xmlMemBlocks()) {
33784: printf("Leak of %d blocks found in xmlRegexpExec",
33785: xmlMemBlocks() - mem_base);
33786: test_ret++;
33787: printf(" %d", n_comp);
33788: printf(" %d", n_content);
33789: printf("\n");
33790: }
33791: }
33792: }
33793: function_tests++;
33794: #endif
33795:
33796: return(test_ret);
33797: }
33798:
33799:
33800: static int
33801: test_xmlRegexpIsDeterminist(void) {
33802: int test_ret = 0;
33803:
33804: #if defined(LIBXML_REGEXP_ENABLED)
33805: int mem_base;
33806: int ret_val;
33807: xmlRegexpPtr comp; /* the compiled regular expression */
33808: int n_comp;
33809:
33810: for (n_comp = 0;n_comp < gen_nb_xmlRegexpPtr;n_comp++) {
33811: mem_base = xmlMemBlocks();
33812: comp = gen_xmlRegexpPtr(n_comp, 0);
33813:
33814: ret_val = xmlRegexpIsDeterminist(comp);
33815: desret_int(ret_val);
33816: call_tests++;
33817: des_xmlRegexpPtr(n_comp, comp, 0);
33818: xmlResetLastError();
33819: if (mem_base != xmlMemBlocks()) {
33820: printf("Leak of %d blocks found in xmlRegexpIsDeterminist",
33821: xmlMemBlocks() - mem_base);
33822: test_ret++;
33823: printf(" %d", n_comp);
33824: printf("\n");
33825: }
33826: }
33827: function_tests++;
33828: #endif
33829:
33830: return(test_ret);
33831: }
33832:
33833:
33834: static int
33835: test_xmlRegexpPrint(void) {
33836: int test_ret = 0;
33837:
33838: #if defined(LIBXML_REGEXP_ENABLED)
33839: int mem_base;
33840: FILE * output; /* the file for the output debug */
33841: int n_output;
33842: xmlRegexpPtr regexp; /* the compiled regexp */
33843: int n_regexp;
33844:
33845: for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
33846: for (n_regexp = 0;n_regexp < gen_nb_xmlRegexpPtr;n_regexp++) {
33847: mem_base = xmlMemBlocks();
33848: output = gen_FILE_ptr(n_output, 0);
33849: regexp = gen_xmlRegexpPtr(n_regexp, 1);
33850:
33851: xmlRegexpPrint(output, regexp);
33852: call_tests++;
33853: des_FILE_ptr(n_output, output, 0);
33854: des_xmlRegexpPtr(n_regexp, regexp, 1);
33855: xmlResetLastError();
33856: if (mem_base != xmlMemBlocks()) {
33857: printf("Leak of %d blocks found in xmlRegexpPrint",
33858: xmlMemBlocks() - mem_base);
33859: test_ret++;
33860: printf(" %d", n_output);
33861: printf(" %d", n_regexp);
33862: printf("\n");
33863: }
33864: }
33865: }
33866: function_tests++;
33867: #endif
33868:
33869: return(test_ret);
33870: }
33871:
33872: static int
33873: test_xmlregexp(void) {
33874: int test_ret = 0;
33875:
33876: if (quiet == 0) printf("Testing xmlregexp : 16 of 30 functions ...\n");
33877: test_ret += test_xmlExpCtxtNbCons();
33878: test_ret += test_xmlExpCtxtNbNodes();
33879: test_ret += test_xmlExpDump();
33880: test_ret += test_xmlExpExpDerive();
33881: test_ret += test_xmlExpGetLanguage();
33882: test_ret += test_xmlExpGetStart();
33883: test_ret += test_xmlExpIsNillable();
33884: test_ret += test_xmlExpMaxToken();
33885: test_ret += test_xmlExpNewAtom();
33886: test_ret += test_xmlExpNewCtxt();
33887: test_ret += test_xmlExpNewOr();
33888: test_ret += test_xmlExpNewRange();
33889: test_ret += test_xmlExpNewSeq();
33890: test_ret += test_xmlExpParse();
33891: test_ret += test_xmlExpRef();
33892: test_ret += test_xmlExpStringDerive();
33893: test_ret += test_xmlExpSubsume();
33894: test_ret += test_xmlRegExecErrInfo();
33895: test_ret += test_xmlRegExecNextValues();
33896: test_ret += test_xmlRegExecPushString();
33897: test_ret += test_xmlRegExecPushString2();
33898: test_ret += test_xmlRegNewExecCtxt();
33899: test_ret += test_xmlRegexpCompile();
33900: test_ret += test_xmlRegexpExec();
33901: test_ret += test_xmlRegexpIsDeterminist();
33902: test_ret += test_xmlRegexpPrint();
33903:
33904: if (test_ret != 0)
33905: printf("Module xmlregexp: %d errors\n", test_ret);
33906: return(test_ret);
33907: }
33908: #ifdef LIBXML_OUTPUT_ENABLED
33909:
33910: #define gen_nb_xmlSaveCtxtPtr 1
33911: static xmlSaveCtxtPtr gen_xmlSaveCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33912: return(NULL);
33913: }
33914: static void des_xmlSaveCtxtPtr(int no ATTRIBUTE_UNUSED, xmlSaveCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33915: }
33916: #endif
33917:
33918:
33919: static int
33920: test_xmlSaveClose(void) {
33921: int test_ret = 0;
33922:
33923: #if defined(LIBXML_OUTPUT_ENABLED)
33924: int mem_base;
33925: int ret_val;
33926: xmlSaveCtxtPtr ctxt; /* a document saving context */
33927: int n_ctxt;
33928:
33929: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSaveCtxtPtr;n_ctxt++) {
33930: mem_base = xmlMemBlocks();
33931: ctxt = gen_xmlSaveCtxtPtr(n_ctxt, 0);
33932:
33933: ret_val = xmlSaveClose(ctxt);
33934: desret_int(ret_val);
33935: call_tests++;
33936: des_xmlSaveCtxtPtr(n_ctxt, ctxt, 0);
33937: xmlResetLastError();
33938: if (mem_base != xmlMemBlocks()) {
33939: printf("Leak of %d blocks found in xmlSaveClose",
33940: xmlMemBlocks() - mem_base);
33941: test_ret++;
33942: printf(" %d", n_ctxt);
33943: printf("\n");
33944: }
33945: }
33946: function_tests++;
33947: #endif
33948:
33949: return(test_ret);
33950: }
33951:
33952:
33953: static int
33954: test_xmlSaveDoc(void) {
33955: int test_ret = 0;
33956:
33957: #if defined(LIBXML_OUTPUT_ENABLED)
33958: int mem_base;
33959: long ret_val;
33960: xmlSaveCtxtPtr ctxt; /* a document saving context */
33961: int n_ctxt;
33962: xmlDocPtr doc; /* a document */
33963: int n_doc;
33964:
33965: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSaveCtxtPtr;n_ctxt++) {
33966: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
33967: mem_base = xmlMemBlocks();
33968: ctxt = gen_xmlSaveCtxtPtr(n_ctxt, 0);
33969: doc = gen_xmlDocPtr(n_doc, 1);
33970:
33971: ret_val = xmlSaveDoc(ctxt, doc);
33972: desret_long(ret_val);
33973: call_tests++;
33974: des_xmlSaveCtxtPtr(n_ctxt, ctxt, 0);
33975: des_xmlDocPtr(n_doc, doc, 1);
33976: xmlResetLastError();
33977: if (mem_base != xmlMemBlocks()) {
33978: printf("Leak of %d blocks found in xmlSaveDoc",
33979: xmlMemBlocks() - mem_base);
33980: test_ret++;
33981: printf(" %d", n_ctxt);
33982: printf(" %d", n_doc);
33983: printf("\n");
33984: }
33985: }
33986: }
33987: function_tests++;
33988: #endif
33989:
33990: return(test_ret);
33991: }
33992:
33993:
33994: static int
33995: test_xmlSaveFlush(void) {
33996: int test_ret = 0;
33997:
33998: #if defined(LIBXML_OUTPUT_ENABLED)
33999: int mem_base;
34000: int ret_val;
34001: xmlSaveCtxtPtr ctxt; /* a document saving context */
34002: int n_ctxt;
34003:
34004: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSaveCtxtPtr;n_ctxt++) {
34005: mem_base = xmlMemBlocks();
34006: ctxt = gen_xmlSaveCtxtPtr(n_ctxt, 0);
34007:
34008: ret_val = xmlSaveFlush(ctxt);
34009: desret_int(ret_val);
34010: call_tests++;
34011: des_xmlSaveCtxtPtr(n_ctxt, ctxt, 0);
34012: xmlResetLastError();
34013: if (mem_base != xmlMemBlocks()) {
34014: printf("Leak of %d blocks found in xmlSaveFlush",
34015: xmlMemBlocks() - mem_base);
34016: test_ret++;
34017: printf(" %d", n_ctxt);
34018: printf("\n");
34019: }
34020: }
34021: function_tests++;
34022: #endif
34023:
34024: return(test_ret);
34025: }
34026:
34027:
34028: static int
34029: test_xmlSaveSetAttrEscape(void) {
34030: int test_ret = 0;
34031:
34032:
34033: /* missing type support */
34034: return(test_ret);
34035: }
34036:
34037:
34038: static int
34039: test_xmlSaveSetEscape(void) {
34040: int test_ret = 0;
34041:
34042:
34043: /* missing type support */
34044: return(test_ret);
34045: }
34046:
34047:
34048: static int
34049: test_xmlSaveToBuffer(void) {
34050: int test_ret = 0;
34051:
34052:
34053: /* missing type support */
34054: return(test_ret);
34055: }
34056:
34057:
34058: static int
34059: test_xmlSaveToFd(void) {
34060: int test_ret = 0;
34061:
34062:
34063: /* missing type support */
34064: return(test_ret);
34065: }
34066:
34067:
34068: static int
34069: test_xmlSaveToFilename(void) {
34070: int test_ret = 0;
34071:
34072:
34073: /* missing type support */
34074: return(test_ret);
34075: }
34076:
34077:
34078: static int
34079: test_xmlSaveTree(void) {
34080: int test_ret = 0;
34081:
34082: #if defined(LIBXML_OUTPUT_ENABLED)
34083: int mem_base;
34084: long ret_val;
34085: xmlSaveCtxtPtr ctxt; /* a document saving context */
34086: int n_ctxt;
34087: xmlNodePtr node; /* the top node of the subtree to save */
34088: int n_node;
34089:
34090: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSaveCtxtPtr;n_ctxt++) {
34091: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
34092: mem_base = xmlMemBlocks();
34093: ctxt = gen_xmlSaveCtxtPtr(n_ctxt, 0);
34094: node = gen_xmlNodePtr(n_node, 1);
34095:
34096: ret_val = xmlSaveTree(ctxt, node);
34097: desret_long(ret_val);
34098: call_tests++;
34099: des_xmlSaveCtxtPtr(n_ctxt, ctxt, 0);
34100: des_xmlNodePtr(n_node, node, 1);
34101: xmlResetLastError();
34102: if (mem_base != xmlMemBlocks()) {
34103: printf("Leak of %d blocks found in xmlSaveTree",
34104: xmlMemBlocks() - mem_base);
34105: test_ret++;
34106: printf(" %d", n_ctxt);
34107: printf(" %d", n_node);
34108: printf("\n");
34109: }
34110: }
34111: }
34112: function_tests++;
34113: #endif
34114:
34115: return(test_ret);
34116: }
34117:
34118: static int
34119: test_xmlsave(void) {
34120: int test_ret = 0;
34121:
34122: if (quiet == 0) printf("Testing xmlsave : 4 of 10 functions ...\n");
34123: test_ret += test_xmlSaveClose();
34124: test_ret += test_xmlSaveDoc();
34125: test_ret += test_xmlSaveFlush();
34126: test_ret += test_xmlSaveSetAttrEscape();
34127: test_ret += test_xmlSaveSetEscape();
34128: test_ret += test_xmlSaveToBuffer();
34129: test_ret += test_xmlSaveToFd();
34130: test_ret += test_xmlSaveToFilename();
34131: test_ret += test_xmlSaveTree();
34132:
34133: if (test_ret != 0)
34134: printf("Module xmlsave: %d errors\n", test_ret);
34135: return(test_ret);
34136: }
34137:
34138: static int
34139: test_xmlSchemaDump(void) {
34140: int test_ret = 0;
34141:
34142: #if defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
34143: int mem_base;
34144: FILE * output; /* the file output */
34145: int n_output;
34146: xmlSchemaPtr schema; /* a schema structure */
34147: int n_schema;
34148:
34149: for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
34150: for (n_schema = 0;n_schema < gen_nb_xmlSchemaPtr;n_schema++) {
34151: mem_base = xmlMemBlocks();
34152: output = gen_FILE_ptr(n_output, 0);
34153: schema = gen_xmlSchemaPtr(n_schema, 1);
34154:
34155: xmlSchemaDump(output, schema);
34156: call_tests++;
34157: des_FILE_ptr(n_output, output, 0);
34158: des_xmlSchemaPtr(n_schema, schema, 1);
34159: xmlResetLastError();
34160: if (mem_base != xmlMemBlocks()) {
34161: printf("Leak of %d blocks found in xmlSchemaDump",
34162: xmlMemBlocks() - mem_base);
34163: test_ret++;
34164: printf(" %d", n_output);
34165: printf(" %d", n_schema);
34166: printf("\n");
34167: }
34168: }
34169: }
34170: function_tests++;
34171: #endif
34172:
34173: return(test_ret);
34174: }
34175:
34176: #ifdef LIBXML_SCHEMAS_ENABLED
34177:
34178: #define gen_nb_xmlSchemaParserCtxtPtr 1
34179: static xmlSchemaParserCtxtPtr gen_xmlSchemaParserCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34180: return(NULL);
34181: }
34182: static void des_xmlSchemaParserCtxtPtr(int no ATTRIBUTE_UNUSED, xmlSchemaParserCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34183: }
34184: #endif
34185:
34186: #ifdef LIBXML_SCHEMAS_ENABLED
34187:
34188: #define gen_nb_xmlSchemaValidityErrorFunc_ptr 1
34189: static xmlSchemaValidityErrorFunc * gen_xmlSchemaValidityErrorFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34190: return(NULL);
34191: }
34192: static void des_xmlSchemaValidityErrorFunc_ptr(int no ATTRIBUTE_UNUSED, xmlSchemaValidityErrorFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34193: }
34194: #endif
34195:
34196: #ifdef LIBXML_SCHEMAS_ENABLED
34197:
34198: #define gen_nb_xmlSchemaValidityWarningFunc_ptr 1
34199: static xmlSchemaValidityWarningFunc * gen_xmlSchemaValidityWarningFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34200: return(NULL);
34201: }
34202: static void des_xmlSchemaValidityWarningFunc_ptr(int no ATTRIBUTE_UNUSED, xmlSchemaValidityWarningFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34203: }
34204: #endif
34205:
34206:
34207: static int
34208: test_xmlSchemaGetParserErrors(void) {
34209: int test_ret = 0;
34210:
34211: #if defined(LIBXML_SCHEMAS_ENABLED)
34212: int mem_base;
34213: int ret_val;
34214: xmlSchemaParserCtxtPtr ctxt; /* a XMl-Schema parser context */
34215: int n_ctxt;
34216: xmlSchemaValidityErrorFunc * err; /* the error callback result */
34217: int n_err;
34218: xmlSchemaValidityWarningFunc * warn; /* the warning callback result */
34219: int n_warn;
34220: void ** ctx; /* contextual data for the callbacks result */
34221: int n_ctx;
34222:
34223: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaParserCtxtPtr;n_ctxt++) {
34224: for (n_err = 0;n_err < gen_nb_xmlSchemaValidityErrorFunc_ptr;n_err++) {
34225: for (n_warn = 0;n_warn < gen_nb_xmlSchemaValidityWarningFunc_ptr;n_warn++) {
34226: for (n_ctx = 0;n_ctx < gen_nb_void_ptr_ptr;n_ctx++) {
34227: mem_base = xmlMemBlocks();
34228: ctxt = gen_xmlSchemaParserCtxtPtr(n_ctxt, 0);
34229: err = gen_xmlSchemaValidityErrorFunc_ptr(n_err, 1);
34230: warn = gen_xmlSchemaValidityWarningFunc_ptr(n_warn, 2);
34231: ctx = gen_void_ptr_ptr(n_ctx, 3);
34232:
34233: ret_val = xmlSchemaGetParserErrors(ctxt, err, warn, ctx);
34234: desret_int(ret_val);
34235: call_tests++;
34236: des_xmlSchemaParserCtxtPtr(n_ctxt, ctxt, 0);
34237: des_xmlSchemaValidityErrorFunc_ptr(n_err, err, 1);
34238: des_xmlSchemaValidityWarningFunc_ptr(n_warn, warn, 2);
34239: des_void_ptr_ptr(n_ctx, ctx, 3);
34240: xmlResetLastError();
34241: if (mem_base != xmlMemBlocks()) {
34242: printf("Leak of %d blocks found in xmlSchemaGetParserErrors",
34243: xmlMemBlocks() - mem_base);
34244: test_ret++;
34245: printf(" %d", n_ctxt);
34246: printf(" %d", n_err);
34247: printf(" %d", n_warn);
34248: printf(" %d", n_ctx);
34249: printf("\n");
34250: }
34251: }
34252: }
34253: }
34254: }
34255: function_tests++;
34256: #endif
34257:
34258: return(test_ret);
34259: }
34260:
34261:
34262: static int
34263: test_xmlSchemaGetValidErrors(void) {
34264: int test_ret = 0;
34265:
34266: #if defined(LIBXML_SCHEMAS_ENABLED)
34267: int mem_base;
34268: int ret_val;
34269: xmlSchemaValidCtxtPtr ctxt; /* a XML-Schema validation context */
34270: int n_ctxt;
34271: xmlSchemaValidityErrorFunc * err; /* the error function result */
34272: int n_err;
34273: xmlSchemaValidityWarningFunc * warn; /* the warning function result */
34274: int n_warn;
34275: void ** ctx; /* the functions context result */
34276: int n_ctx;
34277:
34278: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34279: for (n_err = 0;n_err < gen_nb_xmlSchemaValidityErrorFunc_ptr;n_err++) {
34280: for (n_warn = 0;n_warn < gen_nb_xmlSchemaValidityWarningFunc_ptr;n_warn++) {
34281: for (n_ctx = 0;n_ctx < gen_nb_void_ptr_ptr;n_ctx++) {
34282: mem_base = xmlMemBlocks();
34283: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34284: err = gen_xmlSchemaValidityErrorFunc_ptr(n_err, 1);
34285: warn = gen_xmlSchemaValidityWarningFunc_ptr(n_warn, 2);
34286: ctx = gen_void_ptr_ptr(n_ctx, 3);
34287:
34288: ret_val = xmlSchemaGetValidErrors(ctxt, err, warn, ctx);
34289: desret_int(ret_val);
34290: call_tests++;
34291: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34292: des_xmlSchemaValidityErrorFunc_ptr(n_err, err, 1);
34293: des_xmlSchemaValidityWarningFunc_ptr(n_warn, warn, 2);
34294: des_void_ptr_ptr(n_ctx, ctx, 3);
34295: xmlResetLastError();
34296: if (mem_base != xmlMemBlocks()) {
34297: printf("Leak of %d blocks found in xmlSchemaGetValidErrors",
34298: xmlMemBlocks() - mem_base);
34299: test_ret++;
34300: printf(" %d", n_ctxt);
34301: printf(" %d", n_err);
34302: printf(" %d", n_warn);
34303: printf(" %d", n_ctx);
34304: printf("\n");
34305: }
34306: }
34307: }
34308: }
34309: }
34310: function_tests++;
34311: #endif
34312:
34313: return(test_ret);
34314: }
34315:
34316:
34317: static int
34318: test_xmlSchemaIsValid(void) {
34319: int test_ret = 0;
34320:
34321: #if defined(LIBXML_SCHEMAS_ENABLED)
34322: int mem_base;
34323: int ret_val;
34324: xmlSchemaValidCtxtPtr ctxt; /* the schema validation context */
34325: int n_ctxt;
34326:
34327: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34328: mem_base = xmlMemBlocks();
34329: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34330:
34331: ret_val = xmlSchemaIsValid(ctxt);
34332: desret_int(ret_val);
34333: call_tests++;
34334: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34335: xmlResetLastError();
34336: if (mem_base != xmlMemBlocks()) {
34337: printf("Leak of %d blocks found in xmlSchemaIsValid",
34338: xmlMemBlocks() - mem_base);
34339: test_ret++;
34340: printf(" %d", n_ctxt);
34341: printf("\n");
34342: }
34343: }
34344: function_tests++;
34345: #endif
34346:
34347: return(test_ret);
34348: }
34349:
34350:
34351: static int
34352: test_xmlSchemaNewDocParserCtxt(void) {
34353: int test_ret = 0;
34354:
34355: #if defined(LIBXML_SCHEMAS_ENABLED)
34356: int mem_base;
34357: xmlSchemaParserCtxtPtr ret_val;
34358: xmlDocPtr doc; /* a preparsed document tree */
34359: int n_doc;
34360:
34361: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
34362: mem_base = xmlMemBlocks();
34363: doc = gen_xmlDocPtr(n_doc, 0);
34364:
34365: ret_val = xmlSchemaNewDocParserCtxt(doc);
34366: desret_xmlSchemaParserCtxtPtr(ret_val);
34367: call_tests++;
34368: des_xmlDocPtr(n_doc, doc, 0);
34369: xmlResetLastError();
34370: if (mem_base != xmlMemBlocks()) {
34371: printf("Leak of %d blocks found in xmlSchemaNewDocParserCtxt",
34372: xmlMemBlocks() - mem_base);
34373: test_ret++;
34374: printf(" %d", n_doc);
34375: printf("\n");
34376: }
34377: }
34378: function_tests++;
34379: #endif
34380:
34381: return(test_ret);
34382: }
34383:
34384:
34385: static int
34386: test_xmlSchemaNewMemParserCtxt(void) {
34387: int test_ret = 0;
34388:
34389: #if defined(LIBXML_SCHEMAS_ENABLED)
34390: int mem_base;
34391: xmlSchemaParserCtxtPtr ret_val;
34392: char * buffer; /* a pointer to a char array containing the schemas */
34393: int n_buffer;
34394: int size; /* the size of the array */
34395: int n_size;
34396:
34397: for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
34398: for (n_size = 0;n_size < gen_nb_int;n_size++) {
34399: mem_base = xmlMemBlocks();
34400: buffer = gen_const_char_ptr(n_buffer, 0);
34401: size = gen_int(n_size, 1);
34402:
34403: ret_val = xmlSchemaNewMemParserCtxt((const char *)buffer, size);
34404: desret_xmlSchemaParserCtxtPtr(ret_val);
34405: call_tests++;
34406: des_const_char_ptr(n_buffer, (const char *)buffer, 0);
34407: des_int(n_size, size, 1);
34408: xmlResetLastError();
34409: if (mem_base != xmlMemBlocks()) {
34410: printf("Leak of %d blocks found in xmlSchemaNewMemParserCtxt",
34411: xmlMemBlocks() - mem_base);
34412: test_ret++;
34413: printf(" %d", n_buffer);
34414: printf(" %d", n_size);
34415: printf("\n");
34416: }
34417: }
34418: }
34419: function_tests++;
34420: #endif
34421:
34422: return(test_ret);
34423: }
34424:
34425:
34426: static int
34427: test_xmlSchemaNewParserCtxt(void) {
34428: int test_ret = 0;
34429:
34430: #if defined(LIBXML_SCHEMAS_ENABLED)
34431: int mem_base;
34432: xmlSchemaParserCtxtPtr ret_val;
34433: char * URL; /* the location of the schema */
34434: int n_URL;
34435:
34436: for (n_URL = 0;n_URL < gen_nb_const_char_ptr;n_URL++) {
34437: mem_base = xmlMemBlocks();
34438: URL = gen_const_char_ptr(n_URL, 0);
34439:
34440: ret_val = xmlSchemaNewParserCtxt((const char *)URL);
34441: desret_xmlSchemaParserCtxtPtr(ret_val);
34442: call_tests++;
34443: des_const_char_ptr(n_URL, (const char *)URL, 0);
34444: xmlResetLastError();
34445: if (mem_base != xmlMemBlocks()) {
34446: printf("Leak of %d blocks found in xmlSchemaNewParserCtxt",
34447: xmlMemBlocks() - mem_base);
34448: test_ret++;
34449: printf(" %d", n_URL);
34450: printf("\n");
34451: }
34452: }
34453: function_tests++;
34454: #endif
34455:
34456: return(test_ret);
34457: }
34458:
34459:
34460: static int
34461: test_xmlSchemaNewValidCtxt(void) {
34462: int test_ret = 0;
34463:
34464:
34465: /* missing type support */
34466: return(test_ret);
34467: }
34468:
34469:
34470: static int
34471: test_xmlSchemaParse(void) {
34472: int test_ret = 0;
34473:
34474:
34475: /* missing type support */
34476: return(test_ret);
34477: }
34478:
34479: #ifdef LIBXML_SCHEMAS_ENABLED
34480:
34481: #define gen_nb_xmlSAXHandlerPtr_ptr 1
34482: static xmlSAXHandlerPtr * gen_xmlSAXHandlerPtr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34483: return(NULL);
34484: }
34485: static void des_xmlSAXHandlerPtr_ptr(int no ATTRIBUTE_UNUSED, xmlSAXHandlerPtr * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34486: }
34487: #endif
34488:
34489:
34490: static int
34491: test_xmlSchemaSAXPlug(void) {
34492: int test_ret = 0;
34493:
34494:
34495: /* missing type support */
34496: return(test_ret);
34497: }
34498:
34499: #ifdef LIBXML_SCHEMAS_ENABLED
34500:
34501: #define gen_nb_xmlSchemaSAXPlugPtr 1
34502: static xmlSchemaSAXPlugPtr gen_xmlSchemaSAXPlugPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34503: return(NULL);
34504: }
34505: static void des_xmlSchemaSAXPlugPtr(int no ATTRIBUTE_UNUSED, xmlSchemaSAXPlugPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34506: }
34507: #endif
34508:
34509:
34510: static int
34511: test_xmlSchemaSAXUnplug(void) {
34512: int test_ret = 0;
34513:
34514: #if defined(LIBXML_SCHEMAS_ENABLED)
34515: int mem_base;
34516: int ret_val;
34517: xmlSchemaSAXPlugPtr plug; /* a data structure returned by xmlSchemaSAXPlug */
34518: int n_plug;
34519:
34520: for (n_plug = 0;n_plug < gen_nb_xmlSchemaSAXPlugPtr;n_plug++) {
34521: mem_base = xmlMemBlocks();
34522: plug = gen_xmlSchemaSAXPlugPtr(n_plug, 0);
34523:
34524: ret_val = xmlSchemaSAXUnplug(plug);
34525: desret_int(ret_val);
34526: call_tests++;
34527: des_xmlSchemaSAXPlugPtr(n_plug, plug, 0);
34528: xmlResetLastError();
34529: if (mem_base != xmlMemBlocks()) {
34530: printf("Leak of %d blocks found in xmlSchemaSAXUnplug",
34531: xmlMemBlocks() - mem_base);
34532: test_ret++;
34533: printf(" %d", n_plug);
34534: printf("\n");
34535: }
34536: }
34537: function_tests++;
34538: #endif
34539:
34540: return(test_ret);
34541: }
34542:
34543:
34544: static int
34545: test_xmlSchemaSetParserErrors(void) {
34546: int test_ret = 0;
34547:
34548:
34549: /* missing type support */
34550: return(test_ret);
34551: }
34552:
34553:
34554: static int
34555: test_xmlSchemaSetParserStructuredErrors(void) {
34556: int test_ret = 0;
34557:
34558:
34559: /* missing type support */
34560: return(test_ret);
34561: }
34562:
34563:
34564: static int
34565: test_xmlSchemaSetValidErrors(void) {
34566: int test_ret = 0;
34567:
34568:
34569: /* missing type support */
34570: return(test_ret);
34571: }
34572:
34573:
34574: static int
34575: test_xmlSchemaSetValidOptions(void) {
34576: int test_ret = 0;
34577:
34578: #if defined(LIBXML_SCHEMAS_ENABLED)
34579: int mem_base;
34580: int ret_val;
34581: xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
34582: int n_ctxt;
34583: int options; /* a combination of xmlSchemaValidOption */
34584: int n_options;
34585:
34586: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34587: for (n_options = 0;n_options < gen_nb_int;n_options++) {
34588: mem_base = xmlMemBlocks();
34589: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34590: options = gen_int(n_options, 1);
34591:
34592: ret_val = xmlSchemaSetValidOptions(ctxt, options);
34593: desret_int(ret_val);
34594: call_tests++;
34595: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34596: des_int(n_options, options, 1);
34597: xmlResetLastError();
34598: if (mem_base != xmlMemBlocks()) {
34599: printf("Leak of %d blocks found in xmlSchemaSetValidOptions",
34600: xmlMemBlocks() - mem_base);
34601: test_ret++;
34602: printf(" %d", n_ctxt);
34603: printf(" %d", n_options);
34604: printf("\n");
34605: }
34606: }
34607: }
34608: function_tests++;
34609: #endif
34610:
34611: return(test_ret);
34612: }
34613:
34614:
34615: static int
34616: test_xmlSchemaSetValidStructuredErrors(void) {
34617: int test_ret = 0;
34618:
34619:
34620: /* missing type support */
34621: return(test_ret);
34622: }
34623:
34624:
34625: static int
34626: test_xmlSchemaValidCtxtGetOptions(void) {
34627: int test_ret = 0;
34628:
34629: #if defined(LIBXML_SCHEMAS_ENABLED)
34630: int mem_base;
34631: int ret_val;
34632: xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
34633: int n_ctxt;
34634:
34635: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34636: mem_base = xmlMemBlocks();
34637: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34638:
34639: ret_val = xmlSchemaValidCtxtGetOptions(ctxt);
34640: desret_int(ret_val);
34641: call_tests++;
34642: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34643: xmlResetLastError();
34644: if (mem_base != xmlMemBlocks()) {
34645: printf("Leak of %d blocks found in xmlSchemaValidCtxtGetOptions",
34646: xmlMemBlocks() - mem_base);
34647: test_ret++;
34648: printf(" %d", n_ctxt);
34649: printf("\n");
34650: }
34651: }
34652: function_tests++;
34653: #endif
34654:
34655: return(test_ret);
34656: }
34657:
34658:
34659: static int
34660: test_xmlSchemaValidCtxtGetParserCtxt(void) {
34661: int test_ret = 0;
34662:
34663: #if defined(LIBXML_SCHEMAS_ENABLED)
34664: int mem_base;
34665: xmlParserCtxtPtr ret_val;
34666: xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
34667: int n_ctxt;
34668:
34669: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34670: mem_base = xmlMemBlocks();
34671: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34672:
34673: ret_val = xmlSchemaValidCtxtGetParserCtxt(ctxt);
34674: desret_xmlParserCtxtPtr(ret_val);
34675: call_tests++;
34676: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34677: xmlResetLastError();
34678: if (mem_base != xmlMemBlocks()) {
34679: printf("Leak of %d blocks found in xmlSchemaValidCtxtGetParserCtxt",
34680: xmlMemBlocks() - mem_base);
34681: test_ret++;
34682: printf(" %d", n_ctxt);
34683: printf("\n");
34684: }
34685: }
34686: function_tests++;
34687: #endif
34688:
34689: return(test_ret);
34690: }
34691:
34692:
34693: static int
34694: test_xmlSchemaValidateDoc(void) {
34695: int test_ret = 0;
34696:
34697: #if defined(LIBXML_SCHEMAS_ENABLED)
34698: int mem_base;
34699: int ret_val;
34700: xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
34701: int n_ctxt;
34702: xmlDocPtr doc; /* a parsed document tree */
34703: int n_doc;
34704:
34705: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34706: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
34707: mem_base = xmlMemBlocks();
34708: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34709: doc = gen_xmlDocPtr(n_doc, 1);
34710:
34711: ret_val = xmlSchemaValidateDoc(ctxt, doc);
34712: desret_int(ret_val);
34713: call_tests++;
34714: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34715: des_xmlDocPtr(n_doc, doc, 1);
34716: xmlResetLastError();
34717: if (mem_base != xmlMemBlocks()) {
34718: printf("Leak of %d blocks found in xmlSchemaValidateDoc",
34719: xmlMemBlocks() - mem_base);
34720: test_ret++;
34721: printf(" %d", n_ctxt);
34722: printf(" %d", n_doc);
34723: printf("\n");
34724: }
34725: }
34726: }
34727: function_tests++;
34728: #endif
34729:
34730: return(test_ret);
34731: }
34732:
34733:
34734: static int
34735: test_xmlSchemaValidateFile(void) {
34736: int test_ret = 0;
34737:
34738: #if defined(LIBXML_SCHEMAS_ENABLED)
34739: int mem_base;
34740: int ret_val;
34741: xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
34742: int n_ctxt;
34743: const char * filename; /* the URI of the instance */
34744: int n_filename;
34745: int options; /* a future set of options, currently unused */
34746: int n_options;
34747:
34748: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34749: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
34750: for (n_options = 0;n_options < gen_nb_int;n_options++) {
34751: mem_base = xmlMemBlocks();
34752: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34753: filename = gen_filepath(n_filename, 1);
34754: options = gen_int(n_options, 2);
34755:
34756: ret_val = xmlSchemaValidateFile(ctxt, filename, options);
34757: desret_int(ret_val);
34758: call_tests++;
34759: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34760: des_filepath(n_filename, filename, 1);
34761: des_int(n_options, options, 2);
34762: xmlResetLastError();
34763: if (mem_base != xmlMemBlocks()) {
34764: printf("Leak of %d blocks found in xmlSchemaValidateFile",
34765: xmlMemBlocks() - mem_base);
34766: test_ret++;
34767: printf(" %d", n_ctxt);
34768: printf(" %d", n_filename);
34769: printf(" %d", n_options);
34770: printf("\n");
34771: }
34772: }
34773: }
34774: }
34775: function_tests++;
34776: #endif
34777:
34778: return(test_ret);
34779: }
34780:
34781:
34782: static int
34783: test_xmlSchemaValidateOneElement(void) {
34784: int test_ret = 0;
34785:
34786: #if defined(LIBXML_SCHEMAS_ENABLED)
34787: int mem_base;
34788: int ret_val;
34789: xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
34790: int n_ctxt;
34791: xmlNodePtr elem; /* an element node */
34792: int n_elem;
34793:
34794: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34795: for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
34796: mem_base = xmlMemBlocks();
34797: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34798: elem = gen_xmlNodePtr(n_elem, 1);
34799:
34800: ret_val = xmlSchemaValidateOneElement(ctxt, elem);
34801: desret_int(ret_val);
34802: call_tests++;
34803: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34804: des_xmlNodePtr(n_elem, elem, 1);
34805: xmlResetLastError();
34806: if (mem_base != xmlMemBlocks()) {
34807: printf("Leak of %d blocks found in xmlSchemaValidateOneElement",
34808: xmlMemBlocks() - mem_base);
34809: test_ret++;
34810: printf(" %d", n_ctxt);
34811: printf(" %d", n_elem);
34812: printf("\n");
34813: }
34814: }
34815: }
34816: function_tests++;
34817: #endif
34818:
34819: return(test_ret);
34820: }
34821:
34822:
34823: static int
1.1.1.3 ! misho 34824: test_xmlSchemaValidateSetFilename(void) {
! 34825: int test_ret = 0;
! 34826:
! 34827: #if defined(LIBXML_SCHEMAS_ENABLED)
! 34828: int mem_base;
! 34829: xmlSchemaValidCtxtPtr vctxt; /* the schema validation context */
! 34830: int n_vctxt;
! 34831: const char * filename; /* the file name */
! 34832: int n_filename;
! 34833:
! 34834: for (n_vctxt = 0;n_vctxt < gen_nb_xmlSchemaValidCtxtPtr;n_vctxt++) {
! 34835: for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
! 34836: mem_base = xmlMemBlocks();
! 34837: vctxt = gen_xmlSchemaValidCtxtPtr(n_vctxt, 0);
! 34838: filename = gen_filepath(n_filename, 1);
! 34839:
! 34840: xmlSchemaValidateSetFilename(vctxt, filename);
! 34841: call_tests++;
! 34842: des_xmlSchemaValidCtxtPtr(n_vctxt, vctxt, 0);
! 34843: des_filepath(n_filename, filename, 1);
! 34844: xmlResetLastError();
! 34845: if (mem_base != xmlMemBlocks()) {
! 34846: printf("Leak of %d blocks found in xmlSchemaValidateSetFilename",
! 34847: xmlMemBlocks() - mem_base);
! 34848: test_ret++;
! 34849: printf(" %d", n_vctxt);
! 34850: printf(" %d", n_filename);
! 34851: printf("\n");
! 34852: }
! 34853: }
! 34854: }
! 34855: function_tests++;
! 34856: #endif
! 34857:
! 34858: return(test_ret);
! 34859: }
! 34860:
! 34861:
! 34862: static int
! 34863: test_xmlSchemaValidateSetLocator(void) {
! 34864: int test_ret = 0;
! 34865:
! 34866:
! 34867: /* missing type support */
! 34868: return(test_ret);
! 34869: }
! 34870:
! 34871:
! 34872: static int
1.1 misho 34873: test_xmlSchemaValidateStream(void) {
34874: int test_ret = 0;
34875:
34876: #if defined(LIBXML_SCHEMAS_ENABLED)
34877: int mem_base;
34878: int ret_val;
34879: xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
34880: int n_ctxt;
34881: xmlParserInputBufferPtr input; /* the input to use for reading the data */
34882: int n_input;
34883: xmlCharEncoding enc; /* an optional encoding information */
34884: int n_enc;
34885: xmlSAXHandlerPtr sax; /* a SAX handler for the resulting events */
34886: int n_sax;
34887: void * user_data; /* the context to provide to the SAX handler. */
34888: int n_user_data;
34889:
34890: for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34891: for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) {
34892: for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
34893: for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
34894: for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
34895: mem_base = xmlMemBlocks();
34896: ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34897: input = gen_xmlParserInputBufferPtr(n_input, 1);
34898: enc = gen_xmlCharEncoding(n_enc, 2);
34899: sax = gen_xmlSAXHandlerPtr(n_sax, 3);
34900: user_data = gen_userdata(n_user_data, 4);
34901:
34902: ret_val = xmlSchemaValidateStream(ctxt, input, enc, sax, user_data);
34903: desret_int(ret_val);
34904: call_tests++;
34905: des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34906: des_xmlParserInputBufferPtr(n_input, input, 1);
34907: des_xmlCharEncoding(n_enc, enc, 2);
34908: des_xmlSAXHandlerPtr(n_sax, sax, 3);
34909: des_userdata(n_user_data, user_data, 4);
34910: xmlResetLastError();
34911: if (mem_base != xmlMemBlocks()) {
34912: printf("Leak of %d blocks found in xmlSchemaValidateStream",
34913: xmlMemBlocks() - mem_base);
34914: test_ret++;
34915: printf(" %d", n_ctxt);
34916: printf(" %d", n_input);
34917: printf(" %d", n_enc);
34918: printf(" %d", n_sax);
34919: printf(" %d", n_user_data);
34920: printf("\n");
34921: }
34922: }
34923: }
34924: }
34925: }
34926: }
34927: function_tests++;
34928: #endif
34929:
34930: return(test_ret);
34931: }
34932:
34933: static int
34934: test_xmlschemas(void) {
34935: int test_ret = 0;
34936:
1.1.1.3 ! misho 34937: if (quiet == 0) printf("Testing xmlschemas : 16 of 27 functions ...\n");
1.1 misho 34938: test_ret += test_xmlSchemaDump();
34939: test_ret += test_xmlSchemaGetParserErrors();
34940: test_ret += test_xmlSchemaGetValidErrors();
34941: test_ret += test_xmlSchemaIsValid();
34942: test_ret += test_xmlSchemaNewDocParserCtxt();
34943: test_ret += test_xmlSchemaNewMemParserCtxt();
34944: test_ret += test_xmlSchemaNewParserCtxt();
34945: test_ret += test_xmlSchemaNewValidCtxt();
34946: test_ret += test_xmlSchemaParse();
34947: test_ret += test_xmlSchemaSAXPlug();
34948: test_ret += test_xmlSchemaSAXUnplug();
34949: test_ret += test_xmlSchemaSetParserErrors();
34950: test_ret += test_xmlSchemaSetParserStructuredErrors();
34951: test_ret += test_xmlSchemaSetValidErrors();
34952: test_ret += test_xmlSchemaSetValidOptions();
34953: test_ret += test_xmlSchemaSetValidStructuredErrors();
34954: test_ret += test_xmlSchemaValidCtxtGetOptions();
34955: test_ret += test_xmlSchemaValidCtxtGetParserCtxt();
34956: test_ret += test_xmlSchemaValidateDoc();
34957: test_ret += test_xmlSchemaValidateFile();
34958: test_ret += test_xmlSchemaValidateOneElement();
1.1.1.3 ! misho 34959: test_ret += test_xmlSchemaValidateSetFilename();
! 34960: test_ret += test_xmlSchemaValidateSetLocator();
1.1 misho 34961: test_ret += test_xmlSchemaValidateStream();
34962:
34963: if (test_ret != 0)
34964: printf("Module xmlschemas: %d errors\n", test_ret);
34965: return(test_ret);
34966: }
34967: #ifdef LIBXML_SCHEMAS_ENABLED
34968:
34969: #define gen_nb_xmlSchemaFacetPtr 1
34970: static xmlSchemaFacetPtr gen_xmlSchemaFacetPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34971: return(NULL);
34972: }
34973: static void des_xmlSchemaFacetPtr(int no ATTRIBUTE_UNUSED, xmlSchemaFacetPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34974: }
34975: #endif
34976:
34977: #ifdef LIBXML_SCHEMAS_ENABLED
34978:
34979: #define gen_nb_xmlSchemaTypePtr 1
34980: static xmlSchemaTypePtr gen_xmlSchemaTypePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34981: return(NULL);
34982: }
34983: static void des_xmlSchemaTypePtr(int no ATTRIBUTE_UNUSED, xmlSchemaTypePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34984: }
34985: #endif
34986:
34987:
34988: static int
34989: test_xmlSchemaCheckFacet(void) {
34990: int test_ret = 0;
34991:
34992: #if defined(LIBXML_SCHEMAS_ENABLED)
34993: int mem_base;
34994: int ret_val;
34995: xmlSchemaFacetPtr facet; /* the facet */
34996: int n_facet;
34997: xmlSchemaTypePtr typeDecl; /* the schema type definition */
34998: int n_typeDecl;
34999: xmlSchemaParserCtxtPtr pctxt; /* the schema parser context or NULL */
35000: int n_pctxt;
35001: xmlChar * name; /* the optional name of the type */
35002: int n_name;
35003:
35004: for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
35005: for (n_typeDecl = 0;n_typeDecl < gen_nb_xmlSchemaTypePtr;n_typeDecl++) {
35006: for (n_pctxt = 0;n_pctxt < gen_nb_xmlSchemaParserCtxtPtr;n_pctxt++) {
35007: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
35008: mem_base = xmlMemBlocks();
35009: facet = gen_xmlSchemaFacetPtr(n_facet, 0);
35010: typeDecl = gen_xmlSchemaTypePtr(n_typeDecl, 1);
35011: pctxt = gen_xmlSchemaParserCtxtPtr(n_pctxt, 2);
35012: name = gen_const_xmlChar_ptr(n_name, 3);
35013:
35014: ret_val = xmlSchemaCheckFacet(facet, typeDecl, pctxt, (const xmlChar *)name);
35015: desret_int(ret_val);
35016: call_tests++;
35017: des_xmlSchemaFacetPtr(n_facet, facet, 0);
35018: des_xmlSchemaTypePtr(n_typeDecl, typeDecl, 1);
35019: des_xmlSchemaParserCtxtPtr(n_pctxt, pctxt, 2);
35020: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 3);
35021: xmlResetLastError();
35022: if (mem_base != xmlMemBlocks()) {
35023: printf("Leak of %d blocks found in xmlSchemaCheckFacet",
35024: xmlMemBlocks() - mem_base);
35025: test_ret++;
35026: printf(" %d", n_facet);
35027: printf(" %d", n_typeDecl);
35028: printf(" %d", n_pctxt);
35029: printf(" %d", n_name);
35030: printf("\n");
35031: }
35032: }
35033: }
35034: }
35035: }
35036: function_tests++;
35037: #endif
35038:
35039: return(test_ret);
35040: }
35041:
35042:
35043: static int
35044: test_xmlSchemaCleanupTypes(void) {
35045: int test_ret = 0;
35046:
35047: #if defined(LIBXML_SCHEMAS_ENABLED)
35048:
35049:
35050: xmlSchemaCleanupTypes();
35051: call_tests++;
35052: xmlResetLastError();
35053: function_tests++;
35054: #endif
35055:
35056: return(test_ret);
35057: }
35058:
35059:
35060: static int
35061: test_xmlSchemaCollapseString(void) {
35062: int test_ret = 0;
35063:
35064: #if defined(LIBXML_SCHEMAS_ENABLED)
35065: int mem_base;
35066: xmlChar * ret_val;
35067: xmlChar * value; /* a value */
35068: int n_value;
35069:
35070: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35071: mem_base = xmlMemBlocks();
35072: value = gen_const_xmlChar_ptr(n_value, 0);
35073:
35074: ret_val = xmlSchemaCollapseString((const xmlChar *)value);
35075: desret_xmlChar_ptr(ret_val);
35076: call_tests++;
35077: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
35078: xmlResetLastError();
35079: if (mem_base != xmlMemBlocks()) {
35080: printf("Leak of %d blocks found in xmlSchemaCollapseString",
35081: xmlMemBlocks() - mem_base);
35082: test_ret++;
35083: printf(" %d", n_value);
35084: printf("\n");
35085: }
35086: }
35087: function_tests++;
35088: #endif
35089:
35090: return(test_ret);
35091: }
35092:
35093: #ifdef LIBXML_SCHEMAS_ENABLED
35094:
35095: #define gen_nb_xmlSchemaValPtr 1
35096: static xmlSchemaValPtr gen_xmlSchemaValPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
35097: return(NULL);
35098: }
35099: static void des_xmlSchemaValPtr(int no ATTRIBUTE_UNUSED, xmlSchemaValPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
35100: }
35101: #endif
35102:
35103:
35104: static int
35105: test_xmlSchemaCompareValues(void) {
35106: int test_ret = 0;
35107:
35108: #if defined(LIBXML_SCHEMAS_ENABLED)
35109: int mem_base;
35110: int ret_val;
35111: xmlSchemaValPtr x; /* a first value */
35112: int n_x;
35113: xmlSchemaValPtr y; /* a second value */
35114: int n_y;
35115:
35116: for (n_x = 0;n_x < gen_nb_xmlSchemaValPtr;n_x++) {
35117: for (n_y = 0;n_y < gen_nb_xmlSchemaValPtr;n_y++) {
35118: mem_base = xmlMemBlocks();
35119: x = gen_xmlSchemaValPtr(n_x, 0);
35120: y = gen_xmlSchemaValPtr(n_y, 1);
35121:
35122: ret_val = xmlSchemaCompareValues(x, y);
35123: desret_int(ret_val);
35124: call_tests++;
35125: des_xmlSchemaValPtr(n_x, x, 0);
35126: des_xmlSchemaValPtr(n_y, y, 1);
35127: xmlResetLastError();
35128: if (mem_base != xmlMemBlocks()) {
35129: printf("Leak of %d blocks found in xmlSchemaCompareValues",
35130: xmlMemBlocks() - mem_base);
35131: test_ret++;
35132: printf(" %d", n_x);
35133: printf(" %d", n_y);
35134: printf("\n");
35135: }
35136: }
35137: }
35138: function_tests++;
35139: #endif
35140:
35141: return(test_ret);
35142: }
35143:
35144:
35145: static int
35146: test_xmlSchemaCompareValuesWhtsp(void) {
35147: int test_ret = 0;
35148:
35149: #if defined(LIBXML_SCHEMAS_ENABLED)
35150: int mem_base;
35151: int ret_val;
35152: xmlSchemaValPtr x; /* a first value */
35153: int n_x;
35154: xmlSchemaWhitespaceValueType xws; /* the whitespace value of x */
35155: int n_xws;
35156: xmlSchemaValPtr y; /* a second value */
35157: int n_y;
35158: xmlSchemaWhitespaceValueType yws; /* the whitespace value of y */
35159: int n_yws;
35160:
35161: for (n_x = 0;n_x < gen_nb_xmlSchemaValPtr;n_x++) {
35162: for (n_xws = 0;n_xws < gen_nb_xmlSchemaWhitespaceValueType;n_xws++) {
35163: for (n_y = 0;n_y < gen_nb_xmlSchemaValPtr;n_y++) {
35164: for (n_yws = 0;n_yws < gen_nb_xmlSchemaWhitespaceValueType;n_yws++) {
35165: mem_base = xmlMemBlocks();
35166: x = gen_xmlSchemaValPtr(n_x, 0);
35167: xws = gen_xmlSchemaWhitespaceValueType(n_xws, 1);
35168: y = gen_xmlSchemaValPtr(n_y, 2);
35169: yws = gen_xmlSchemaWhitespaceValueType(n_yws, 3);
35170:
35171: ret_val = xmlSchemaCompareValuesWhtsp(x, xws, y, yws);
35172: desret_int(ret_val);
35173: call_tests++;
35174: des_xmlSchemaValPtr(n_x, x, 0);
35175: des_xmlSchemaWhitespaceValueType(n_xws, xws, 1);
35176: des_xmlSchemaValPtr(n_y, y, 2);
35177: des_xmlSchemaWhitespaceValueType(n_yws, yws, 3);
35178: xmlResetLastError();
35179: if (mem_base != xmlMemBlocks()) {
35180: printf("Leak of %d blocks found in xmlSchemaCompareValuesWhtsp",
35181: xmlMemBlocks() - mem_base);
35182: test_ret++;
35183: printf(" %d", n_x);
35184: printf(" %d", n_xws);
35185: printf(" %d", n_y);
35186: printf(" %d", n_yws);
35187: printf("\n");
35188: }
35189: }
35190: }
35191: }
35192: }
35193: function_tests++;
35194: #endif
35195:
35196: return(test_ret);
35197: }
35198:
35199:
35200: static int
35201: test_xmlSchemaCopyValue(void) {
35202: int test_ret = 0;
35203:
35204:
35205: /* missing type support */
35206: return(test_ret);
35207: }
35208:
35209:
35210: static int
35211: test_xmlSchemaGetBuiltInListSimpleTypeItemType(void) {
35212: int test_ret = 0;
35213:
35214: #if defined(LIBXML_SCHEMAS_ENABLED)
35215: int mem_base;
35216: xmlSchemaTypePtr ret_val;
35217: xmlSchemaTypePtr type; /* the built-in simple type. */
35218: int n_type;
35219:
35220: for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
35221: mem_base = xmlMemBlocks();
35222: type = gen_xmlSchemaTypePtr(n_type, 0);
35223:
35224: ret_val = xmlSchemaGetBuiltInListSimpleTypeItemType(type);
35225: desret_xmlSchemaTypePtr(ret_val);
35226: call_tests++;
35227: des_xmlSchemaTypePtr(n_type, type, 0);
35228: xmlResetLastError();
35229: if (mem_base != xmlMemBlocks()) {
35230: printf("Leak of %d blocks found in xmlSchemaGetBuiltInListSimpleTypeItemType",
35231: xmlMemBlocks() - mem_base);
35232: test_ret++;
35233: printf(" %d", n_type);
35234: printf("\n");
35235: }
35236: }
35237: function_tests++;
35238: #endif
35239:
35240: return(test_ret);
35241: }
35242:
35243:
35244: static int
35245: test_xmlSchemaGetBuiltInType(void) {
35246: int test_ret = 0;
35247:
35248: #if defined(LIBXML_SCHEMAS_ENABLED)
35249: xmlSchemaTypePtr ret_val;
35250: xmlSchemaValType type; /* the type of the built in type */
35251: int n_type;
35252:
35253: for (n_type = 0;n_type < gen_nb_xmlSchemaValType;n_type++) {
35254: type = gen_xmlSchemaValType(n_type, 0);
35255:
35256: ret_val = xmlSchemaGetBuiltInType(type);
35257: desret_xmlSchemaTypePtr(ret_val);
35258: call_tests++;
35259: des_xmlSchemaValType(n_type, type, 0);
35260: xmlResetLastError();
35261: }
35262: function_tests++;
35263: #endif
35264:
35265: return(test_ret);
35266: }
35267:
35268:
35269: static int
35270: test_xmlSchemaGetCanonValue(void) {
35271: int test_ret = 0;
35272:
35273: #if defined(LIBXML_SCHEMAS_ENABLED)
35274: int mem_base;
35275: int ret_val;
35276: xmlSchemaValPtr val; /* the precomputed value */
35277: int n_val;
35278: xmlChar ** retValue; /* the returned value */
35279: int n_retValue;
35280:
35281: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
35282: for (n_retValue = 0;n_retValue < gen_nb_const_xmlChar_ptr_ptr;n_retValue++) {
35283: mem_base = xmlMemBlocks();
35284: val = gen_xmlSchemaValPtr(n_val, 0);
35285: retValue = gen_const_xmlChar_ptr_ptr(n_retValue, 1);
35286:
35287: ret_val = xmlSchemaGetCanonValue(val, (const xmlChar **)retValue);
35288: desret_int(ret_val);
35289: call_tests++;
35290: des_xmlSchemaValPtr(n_val, val, 0);
35291: des_const_xmlChar_ptr_ptr(n_retValue, (const xmlChar **)retValue, 1);
35292: xmlResetLastError();
35293: if (mem_base != xmlMemBlocks()) {
35294: printf("Leak of %d blocks found in xmlSchemaGetCanonValue",
35295: xmlMemBlocks() - mem_base);
35296: test_ret++;
35297: printf(" %d", n_val);
35298: printf(" %d", n_retValue);
35299: printf("\n");
35300: }
35301: }
35302: }
35303: function_tests++;
35304: #endif
35305:
35306: return(test_ret);
35307: }
35308:
35309:
35310: static int
35311: test_xmlSchemaGetCanonValueWhtsp(void) {
35312: int test_ret = 0;
35313:
35314: #if defined(LIBXML_SCHEMAS_ENABLED)
35315: int mem_base;
35316: int ret_val;
35317: xmlSchemaValPtr val; /* the precomputed value */
35318: int n_val;
35319: xmlChar ** retValue; /* the returned value */
35320: int n_retValue;
35321: xmlSchemaWhitespaceValueType ws; /* the whitespace type of the value */
35322: int n_ws;
35323:
35324: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
35325: for (n_retValue = 0;n_retValue < gen_nb_const_xmlChar_ptr_ptr;n_retValue++) {
35326: for (n_ws = 0;n_ws < gen_nb_xmlSchemaWhitespaceValueType;n_ws++) {
35327: mem_base = xmlMemBlocks();
35328: val = gen_xmlSchemaValPtr(n_val, 0);
35329: retValue = gen_const_xmlChar_ptr_ptr(n_retValue, 1);
35330: ws = gen_xmlSchemaWhitespaceValueType(n_ws, 2);
35331:
35332: ret_val = xmlSchemaGetCanonValueWhtsp(val, (const xmlChar **)retValue, ws);
35333: desret_int(ret_val);
35334: call_tests++;
35335: des_xmlSchemaValPtr(n_val, val, 0);
35336: des_const_xmlChar_ptr_ptr(n_retValue, (const xmlChar **)retValue, 1);
35337: des_xmlSchemaWhitespaceValueType(n_ws, ws, 2);
35338: xmlResetLastError();
35339: if (mem_base != xmlMemBlocks()) {
35340: printf("Leak of %d blocks found in xmlSchemaGetCanonValueWhtsp",
35341: xmlMemBlocks() - mem_base);
35342: test_ret++;
35343: printf(" %d", n_val);
35344: printf(" %d", n_retValue);
35345: printf(" %d", n_ws);
35346: printf("\n");
35347: }
35348: }
35349: }
35350: }
35351: function_tests++;
35352: #endif
35353:
35354: return(test_ret);
35355: }
35356:
35357:
35358: static int
35359: test_xmlSchemaGetFacetValueAsULong(void) {
35360: int test_ret = 0;
35361:
35362: #if defined(LIBXML_SCHEMAS_ENABLED)
35363: int mem_base;
35364: unsigned long ret_val;
35365: xmlSchemaFacetPtr facet; /* an schemas type facet */
35366: int n_facet;
35367:
35368: for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
35369: mem_base = xmlMemBlocks();
35370: facet = gen_xmlSchemaFacetPtr(n_facet, 0);
35371:
35372: ret_val = xmlSchemaGetFacetValueAsULong(facet);
35373: desret_unsigned_long(ret_val);
35374: call_tests++;
35375: des_xmlSchemaFacetPtr(n_facet, facet, 0);
35376: xmlResetLastError();
35377: if (mem_base != xmlMemBlocks()) {
35378: printf("Leak of %d blocks found in xmlSchemaGetFacetValueAsULong",
35379: xmlMemBlocks() - mem_base);
35380: test_ret++;
35381: printf(" %d", n_facet);
35382: printf("\n");
35383: }
35384: }
35385: function_tests++;
35386: #endif
35387:
35388: return(test_ret);
35389: }
35390:
35391:
35392: static int
35393: test_xmlSchemaGetPredefinedType(void) {
35394: int test_ret = 0;
35395:
35396: #if defined(LIBXML_SCHEMAS_ENABLED)
35397: int mem_base;
35398: xmlSchemaTypePtr ret_val;
35399: xmlChar * name; /* the type name */
35400: int n_name;
35401: xmlChar * ns; /* the URI of the namespace usually "http://www.w3.org/2001/XMLSchema" */
35402: int n_ns;
35403:
35404: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
35405: for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) {
35406: mem_base = xmlMemBlocks();
35407: name = gen_const_xmlChar_ptr(n_name, 0);
35408: ns = gen_const_xmlChar_ptr(n_ns, 1);
35409:
35410: ret_val = xmlSchemaGetPredefinedType((const xmlChar *)name, (const xmlChar *)ns);
35411: desret_xmlSchemaTypePtr(ret_val);
35412: call_tests++;
35413: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
35414: des_const_xmlChar_ptr(n_ns, (const xmlChar *)ns, 1);
35415: xmlResetLastError();
35416: if (mem_base != xmlMemBlocks()) {
35417: printf("Leak of %d blocks found in xmlSchemaGetPredefinedType",
35418: xmlMemBlocks() - mem_base);
35419: test_ret++;
35420: printf(" %d", n_name);
35421: printf(" %d", n_ns);
35422: printf("\n");
35423: }
35424: }
35425: }
35426: function_tests++;
35427: #endif
35428:
35429: return(test_ret);
35430: }
35431:
35432:
35433: static int
35434: test_xmlSchemaGetValType(void) {
35435: int test_ret = 0;
35436:
35437: #if defined(LIBXML_SCHEMAS_ENABLED)
35438: int mem_base;
35439: xmlSchemaValType ret_val;
35440: xmlSchemaValPtr val; /* a schemas value */
35441: int n_val;
35442:
35443: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
35444: mem_base = xmlMemBlocks();
35445: val = gen_xmlSchemaValPtr(n_val, 0);
35446:
35447: ret_val = xmlSchemaGetValType(val);
35448: desret_xmlSchemaValType(ret_val);
35449: call_tests++;
35450: des_xmlSchemaValPtr(n_val, val, 0);
35451: xmlResetLastError();
35452: if (mem_base != xmlMemBlocks()) {
35453: printf("Leak of %d blocks found in xmlSchemaGetValType",
35454: xmlMemBlocks() - mem_base);
35455: test_ret++;
35456: printf(" %d", n_val);
35457: printf("\n");
35458: }
35459: }
35460: function_tests++;
35461: #endif
35462:
35463: return(test_ret);
35464: }
35465:
35466:
35467: static int
35468: test_xmlSchemaInitTypes(void) {
35469: int test_ret = 0;
35470:
35471: #if defined(LIBXML_SCHEMAS_ENABLED)
35472:
35473:
35474: xmlSchemaInitTypes();
35475: call_tests++;
35476: xmlResetLastError();
35477: function_tests++;
35478: #endif
35479:
35480: return(test_ret);
35481: }
35482:
35483:
35484: static int
35485: test_xmlSchemaIsBuiltInTypeFacet(void) {
35486: int test_ret = 0;
35487:
35488: #if defined(LIBXML_SCHEMAS_ENABLED)
35489: int mem_base;
35490: int ret_val;
35491: xmlSchemaTypePtr type; /* the built-in type */
35492: int n_type;
35493: int facetType; /* the facet type */
35494: int n_facetType;
35495:
35496: for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
35497: for (n_facetType = 0;n_facetType < gen_nb_int;n_facetType++) {
35498: mem_base = xmlMemBlocks();
35499: type = gen_xmlSchemaTypePtr(n_type, 0);
35500: facetType = gen_int(n_facetType, 1);
35501:
35502: ret_val = xmlSchemaIsBuiltInTypeFacet(type, facetType);
35503: desret_int(ret_val);
35504: call_tests++;
35505: des_xmlSchemaTypePtr(n_type, type, 0);
35506: des_int(n_facetType, facetType, 1);
35507: xmlResetLastError();
35508: if (mem_base != xmlMemBlocks()) {
35509: printf("Leak of %d blocks found in xmlSchemaIsBuiltInTypeFacet",
35510: xmlMemBlocks() - mem_base);
35511: test_ret++;
35512: printf(" %d", n_type);
35513: printf(" %d", n_facetType);
35514: printf("\n");
35515: }
35516: }
35517: }
35518: function_tests++;
35519: #endif
35520:
35521: return(test_ret);
35522: }
35523:
35524:
35525: static int
35526: test_xmlSchemaNewFacet(void) {
35527: int test_ret = 0;
35528:
35529:
35530: /* missing type support */
35531: return(test_ret);
35532: }
35533:
35534:
35535: static int
35536: test_xmlSchemaNewNOTATIONValue(void) {
35537: int test_ret = 0;
35538:
35539:
35540: /* missing type support */
35541: return(test_ret);
35542: }
35543:
35544:
35545: static int
35546: test_xmlSchemaNewQNameValue(void) {
35547: int test_ret = 0;
35548:
35549:
35550: /* missing type support */
35551: return(test_ret);
35552: }
35553:
35554:
35555: static int
35556: test_xmlSchemaNewStringValue(void) {
35557: int test_ret = 0;
35558:
35559:
35560: /* missing type support */
35561: return(test_ret);
35562: }
35563:
35564: #ifdef LIBXML_SCHEMAS_ENABLED
35565:
35566: #define gen_nb_xmlSchemaValPtr_ptr 1
35567: static xmlSchemaValPtr * gen_xmlSchemaValPtr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
35568: return(NULL);
35569: }
35570: static void des_xmlSchemaValPtr_ptr(int no ATTRIBUTE_UNUSED, xmlSchemaValPtr * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
35571: }
35572: #endif
35573:
35574:
35575: static int
35576: test_xmlSchemaValPredefTypeNode(void) {
35577: int test_ret = 0;
35578:
35579: #if defined(LIBXML_SCHEMAS_ENABLED)
35580: int mem_base;
35581: int ret_val;
35582: xmlSchemaTypePtr type; /* the predefined type */
35583: int n_type;
35584: xmlChar * value; /* the value to check */
35585: int n_value;
35586: xmlSchemaValPtr * val; /* the return computed value */
35587: int n_val;
35588: xmlNodePtr node; /* the node containing the value */
35589: int n_node;
35590:
35591: for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
35592: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35593: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr_ptr;n_val++) {
35594: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
35595: mem_base = xmlMemBlocks();
35596: type = gen_xmlSchemaTypePtr(n_type, 0);
35597: value = gen_const_xmlChar_ptr(n_value, 1);
35598: val = gen_xmlSchemaValPtr_ptr(n_val, 2);
35599: node = gen_xmlNodePtr(n_node, 3);
35600:
35601: ret_val = xmlSchemaValPredefTypeNode(type, (const xmlChar *)value, val, node);
35602: desret_int(ret_val);
35603: call_tests++;
35604: des_xmlSchemaTypePtr(n_type, type, 0);
35605: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
35606: des_xmlSchemaValPtr_ptr(n_val, val, 2);
35607: des_xmlNodePtr(n_node, node, 3);
35608: xmlResetLastError();
35609: if (mem_base != xmlMemBlocks()) {
35610: printf("Leak of %d blocks found in xmlSchemaValPredefTypeNode",
35611: xmlMemBlocks() - mem_base);
35612: test_ret++;
35613: printf(" %d", n_type);
35614: printf(" %d", n_value);
35615: printf(" %d", n_val);
35616: printf(" %d", n_node);
35617: printf("\n");
35618: }
35619: }
35620: }
35621: }
35622: }
35623: function_tests++;
35624: #endif
35625:
35626: return(test_ret);
35627: }
35628:
35629:
35630: static int
35631: test_xmlSchemaValPredefTypeNodeNoNorm(void) {
35632: int test_ret = 0;
35633:
35634: #if defined(LIBXML_SCHEMAS_ENABLED)
35635: int mem_base;
35636: int ret_val;
35637: xmlSchemaTypePtr type; /* the predefined type */
35638: int n_type;
35639: xmlChar * value; /* the value to check */
35640: int n_value;
35641: xmlSchemaValPtr * val; /* the return computed value */
35642: int n_val;
35643: xmlNodePtr node; /* the node containing the value */
35644: int n_node;
35645:
35646: for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
35647: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35648: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr_ptr;n_val++) {
35649: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
35650: mem_base = xmlMemBlocks();
35651: type = gen_xmlSchemaTypePtr(n_type, 0);
35652: value = gen_const_xmlChar_ptr(n_value, 1);
35653: val = gen_xmlSchemaValPtr_ptr(n_val, 2);
35654: node = gen_xmlNodePtr(n_node, 3);
35655:
35656: ret_val = xmlSchemaValPredefTypeNodeNoNorm(type, (const xmlChar *)value, val, node);
35657: desret_int(ret_val);
35658: call_tests++;
35659: des_xmlSchemaTypePtr(n_type, type, 0);
35660: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
35661: des_xmlSchemaValPtr_ptr(n_val, val, 2);
35662: des_xmlNodePtr(n_node, node, 3);
35663: xmlResetLastError();
35664: if (mem_base != xmlMemBlocks()) {
35665: printf("Leak of %d blocks found in xmlSchemaValPredefTypeNodeNoNorm",
35666: xmlMemBlocks() - mem_base);
35667: test_ret++;
35668: printf(" %d", n_type);
35669: printf(" %d", n_value);
35670: printf(" %d", n_val);
35671: printf(" %d", n_node);
35672: printf("\n");
35673: }
35674: }
35675: }
35676: }
35677: }
35678: function_tests++;
35679: #endif
35680:
35681: return(test_ret);
35682: }
35683:
35684:
35685: static int
35686: test_xmlSchemaValidateFacet(void) {
35687: int test_ret = 0;
35688:
35689: #if defined(LIBXML_SCHEMAS_ENABLED)
35690: int mem_base;
35691: int ret_val;
35692: xmlSchemaTypePtr base; /* the base type */
35693: int n_base;
35694: xmlSchemaFacetPtr facet; /* the facet to check */
35695: int n_facet;
35696: xmlChar * value; /* the lexical repr of the value to validate */
35697: int n_value;
35698: xmlSchemaValPtr val; /* the precomputed value */
35699: int n_val;
35700:
35701: for (n_base = 0;n_base < gen_nb_xmlSchemaTypePtr;n_base++) {
35702: for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
35703: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35704: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
35705: mem_base = xmlMemBlocks();
35706: base = gen_xmlSchemaTypePtr(n_base, 0);
35707: facet = gen_xmlSchemaFacetPtr(n_facet, 1);
35708: value = gen_const_xmlChar_ptr(n_value, 2);
35709: val = gen_xmlSchemaValPtr(n_val, 3);
35710:
35711: ret_val = xmlSchemaValidateFacet(base, facet, (const xmlChar *)value, val);
35712: desret_int(ret_val);
35713: call_tests++;
35714: des_xmlSchemaTypePtr(n_base, base, 0);
35715: des_xmlSchemaFacetPtr(n_facet, facet, 1);
35716: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2);
35717: des_xmlSchemaValPtr(n_val, val, 3);
35718: xmlResetLastError();
35719: if (mem_base != xmlMemBlocks()) {
35720: printf("Leak of %d blocks found in xmlSchemaValidateFacet",
35721: xmlMemBlocks() - mem_base);
35722: test_ret++;
35723: printf(" %d", n_base);
35724: printf(" %d", n_facet);
35725: printf(" %d", n_value);
35726: printf(" %d", n_val);
35727: printf("\n");
35728: }
35729: }
35730: }
35731: }
35732: }
35733: function_tests++;
35734: #endif
35735:
35736: return(test_ret);
35737: }
35738:
35739:
35740: static int
35741: test_xmlSchemaValidateFacetWhtsp(void) {
35742: int test_ret = 0;
35743:
35744: #if defined(LIBXML_SCHEMAS_ENABLED)
35745: int mem_base;
35746: int ret_val;
35747: xmlSchemaFacetPtr facet; /* the facet to check */
35748: int n_facet;
35749: xmlSchemaWhitespaceValueType fws; /* the whitespace type of the facet's value */
35750: int n_fws;
35751: xmlSchemaValType valType; /* the built-in type of the value */
35752: int n_valType;
35753: xmlChar * value; /* the lexical (or normalized for pattern) repr of the value to validate */
35754: int n_value;
35755: xmlSchemaValPtr val; /* the precomputed value */
35756: int n_val;
35757: xmlSchemaWhitespaceValueType ws; /* the whitespace type of the value */
35758: int n_ws;
35759:
35760: for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
35761: for (n_fws = 0;n_fws < gen_nb_xmlSchemaWhitespaceValueType;n_fws++) {
35762: for (n_valType = 0;n_valType < gen_nb_xmlSchemaValType;n_valType++) {
35763: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35764: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
35765: for (n_ws = 0;n_ws < gen_nb_xmlSchemaWhitespaceValueType;n_ws++) {
35766: mem_base = xmlMemBlocks();
35767: facet = gen_xmlSchemaFacetPtr(n_facet, 0);
35768: fws = gen_xmlSchemaWhitespaceValueType(n_fws, 1);
35769: valType = gen_xmlSchemaValType(n_valType, 2);
35770: value = gen_const_xmlChar_ptr(n_value, 3);
35771: val = gen_xmlSchemaValPtr(n_val, 4);
35772: ws = gen_xmlSchemaWhitespaceValueType(n_ws, 5);
35773:
35774: ret_val = xmlSchemaValidateFacetWhtsp(facet, fws, valType, (const xmlChar *)value, val, ws);
35775: desret_int(ret_val);
35776: call_tests++;
35777: des_xmlSchemaFacetPtr(n_facet, facet, 0);
35778: des_xmlSchemaWhitespaceValueType(n_fws, fws, 1);
35779: des_xmlSchemaValType(n_valType, valType, 2);
35780: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 3);
35781: des_xmlSchemaValPtr(n_val, val, 4);
35782: des_xmlSchemaWhitespaceValueType(n_ws, ws, 5);
35783: xmlResetLastError();
35784: if (mem_base != xmlMemBlocks()) {
35785: printf("Leak of %d blocks found in xmlSchemaValidateFacetWhtsp",
35786: xmlMemBlocks() - mem_base);
35787: test_ret++;
35788: printf(" %d", n_facet);
35789: printf(" %d", n_fws);
35790: printf(" %d", n_valType);
35791: printf(" %d", n_value);
35792: printf(" %d", n_val);
35793: printf(" %d", n_ws);
35794: printf("\n");
35795: }
35796: }
35797: }
35798: }
35799: }
35800: }
35801: }
35802: function_tests++;
35803: #endif
35804:
35805: return(test_ret);
35806: }
35807:
35808:
35809: static int
35810: test_xmlSchemaValidateLengthFacet(void) {
35811: int test_ret = 0;
35812:
35813: #if defined(LIBXML_SCHEMAS_ENABLED)
35814: int mem_base;
35815: int ret_val;
35816: xmlSchemaTypePtr type; /* the built-in type */
35817: int n_type;
35818: xmlSchemaFacetPtr facet; /* the facet to check */
35819: int n_facet;
35820: xmlChar * value; /* the lexical repr. of the value to be validated */
35821: int n_value;
35822: xmlSchemaValPtr val; /* the precomputed value */
35823: int n_val;
35824: unsigned long * length; /* the actual length of the value */
35825: int n_length;
35826:
35827: for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
35828: for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
35829: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35830: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
35831: for (n_length = 0;n_length < gen_nb_unsigned_long_ptr;n_length++) {
35832: mem_base = xmlMemBlocks();
35833: type = gen_xmlSchemaTypePtr(n_type, 0);
35834: facet = gen_xmlSchemaFacetPtr(n_facet, 1);
35835: value = gen_const_xmlChar_ptr(n_value, 2);
35836: val = gen_xmlSchemaValPtr(n_val, 3);
35837: length = gen_unsigned_long_ptr(n_length, 4);
35838:
35839: ret_val = xmlSchemaValidateLengthFacet(type, facet, (const xmlChar *)value, val, length);
35840: desret_int(ret_val);
35841: call_tests++;
35842: des_xmlSchemaTypePtr(n_type, type, 0);
35843: des_xmlSchemaFacetPtr(n_facet, facet, 1);
35844: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2);
35845: des_xmlSchemaValPtr(n_val, val, 3);
35846: des_unsigned_long_ptr(n_length, length, 4);
35847: xmlResetLastError();
35848: if (mem_base != xmlMemBlocks()) {
35849: printf("Leak of %d blocks found in xmlSchemaValidateLengthFacet",
35850: xmlMemBlocks() - mem_base);
35851: test_ret++;
35852: printf(" %d", n_type);
35853: printf(" %d", n_facet);
35854: printf(" %d", n_value);
35855: printf(" %d", n_val);
35856: printf(" %d", n_length);
35857: printf("\n");
35858: }
35859: }
35860: }
35861: }
35862: }
35863: }
35864: function_tests++;
35865: #endif
35866:
35867: return(test_ret);
35868: }
35869:
35870:
35871: static int
35872: test_xmlSchemaValidateLengthFacetWhtsp(void) {
35873: int test_ret = 0;
35874:
35875: #if defined(LIBXML_SCHEMAS_ENABLED)
35876: int mem_base;
35877: int ret_val;
35878: xmlSchemaFacetPtr facet; /* the facet to check */
35879: int n_facet;
35880: xmlSchemaValType valType; /* the built-in type */
35881: int n_valType;
35882: xmlChar * value; /* the lexical repr. of the value to be validated */
35883: int n_value;
35884: xmlSchemaValPtr val; /* the precomputed value */
35885: int n_val;
35886: unsigned long * length; /* the actual length of the value */
35887: int n_length;
35888: xmlSchemaWhitespaceValueType ws; /* the whitespace type of the value */
35889: int n_ws;
35890:
35891: for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
35892: for (n_valType = 0;n_valType < gen_nb_xmlSchemaValType;n_valType++) {
35893: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35894: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
35895: for (n_length = 0;n_length < gen_nb_unsigned_long_ptr;n_length++) {
35896: for (n_ws = 0;n_ws < gen_nb_xmlSchemaWhitespaceValueType;n_ws++) {
35897: mem_base = xmlMemBlocks();
35898: facet = gen_xmlSchemaFacetPtr(n_facet, 0);
35899: valType = gen_xmlSchemaValType(n_valType, 1);
35900: value = gen_const_xmlChar_ptr(n_value, 2);
35901: val = gen_xmlSchemaValPtr(n_val, 3);
35902: length = gen_unsigned_long_ptr(n_length, 4);
35903: ws = gen_xmlSchemaWhitespaceValueType(n_ws, 5);
35904:
35905: ret_val = xmlSchemaValidateLengthFacetWhtsp(facet, valType, (const xmlChar *)value, val, length, ws);
35906: desret_int(ret_val);
35907: call_tests++;
35908: des_xmlSchemaFacetPtr(n_facet, facet, 0);
35909: des_xmlSchemaValType(n_valType, valType, 1);
35910: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2);
35911: des_xmlSchemaValPtr(n_val, val, 3);
35912: des_unsigned_long_ptr(n_length, length, 4);
35913: des_xmlSchemaWhitespaceValueType(n_ws, ws, 5);
35914: xmlResetLastError();
35915: if (mem_base != xmlMemBlocks()) {
35916: printf("Leak of %d blocks found in xmlSchemaValidateLengthFacetWhtsp",
35917: xmlMemBlocks() - mem_base);
35918: test_ret++;
35919: printf(" %d", n_facet);
35920: printf(" %d", n_valType);
35921: printf(" %d", n_value);
35922: printf(" %d", n_val);
35923: printf(" %d", n_length);
35924: printf(" %d", n_ws);
35925: printf("\n");
35926: }
35927: }
35928: }
35929: }
35930: }
35931: }
35932: }
35933: function_tests++;
35934: #endif
35935:
35936: return(test_ret);
35937: }
35938:
35939:
35940: static int
35941: test_xmlSchemaValidateListSimpleTypeFacet(void) {
35942: int test_ret = 0;
35943:
35944: #if defined(LIBXML_SCHEMAS_ENABLED)
35945: int mem_base;
35946: int ret_val;
35947: xmlSchemaFacetPtr facet; /* the facet to check */
35948: int n_facet;
35949: xmlChar * value; /* the lexical repr of the value to validate */
35950: int n_value;
35951: unsigned long actualLen; /* the number of list items */
35952: int n_actualLen;
35953: unsigned long * expectedLen; /* the resulting expected number of list items */
35954: int n_expectedLen;
35955:
35956: for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
35957: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35958: for (n_actualLen = 0;n_actualLen < gen_nb_unsigned_long;n_actualLen++) {
35959: for (n_expectedLen = 0;n_expectedLen < gen_nb_unsigned_long_ptr;n_expectedLen++) {
35960: mem_base = xmlMemBlocks();
35961: facet = gen_xmlSchemaFacetPtr(n_facet, 0);
35962: value = gen_const_xmlChar_ptr(n_value, 1);
35963: actualLen = gen_unsigned_long(n_actualLen, 2);
35964: expectedLen = gen_unsigned_long_ptr(n_expectedLen, 3);
35965:
35966: ret_val = xmlSchemaValidateListSimpleTypeFacet(facet, (const xmlChar *)value, actualLen, expectedLen);
35967: desret_int(ret_val);
35968: call_tests++;
35969: des_xmlSchemaFacetPtr(n_facet, facet, 0);
35970: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
35971: des_unsigned_long(n_actualLen, actualLen, 2);
35972: des_unsigned_long_ptr(n_expectedLen, expectedLen, 3);
35973: xmlResetLastError();
35974: if (mem_base != xmlMemBlocks()) {
35975: printf("Leak of %d blocks found in xmlSchemaValidateListSimpleTypeFacet",
35976: xmlMemBlocks() - mem_base);
35977: test_ret++;
35978: printf(" %d", n_facet);
35979: printf(" %d", n_value);
35980: printf(" %d", n_actualLen);
35981: printf(" %d", n_expectedLen);
35982: printf("\n");
35983: }
35984: }
35985: }
35986: }
35987: }
35988: function_tests++;
35989: #endif
35990:
35991: return(test_ret);
35992: }
35993:
35994:
35995: static int
35996: test_xmlSchemaValidatePredefinedType(void) {
35997: int test_ret = 0;
35998:
35999: #if defined(LIBXML_SCHEMAS_ENABLED)
36000: int mem_base;
36001: int ret_val;
36002: xmlSchemaTypePtr type; /* the predefined type */
36003: int n_type;
36004: xmlChar * value; /* the value to check */
36005: int n_value;
36006: xmlSchemaValPtr * val; /* the return computed value */
36007: int n_val;
36008:
36009: for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
36010: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
36011: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr_ptr;n_val++) {
36012: mem_base = xmlMemBlocks();
36013: type = gen_xmlSchemaTypePtr(n_type, 0);
36014: value = gen_const_xmlChar_ptr(n_value, 1);
36015: val = gen_xmlSchemaValPtr_ptr(n_val, 2);
36016:
36017: ret_val = xmlSchemaValidatePredefinedType(type, (const xmlChar *)value, val);
36018: desret_int(ret_val);
36019: call_tests++;
36020: des_xmlSchemaTypePtr(n_type, type, 0);
36021: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
36022: des_xmlSchemaValPtr_ptr(n_val, val, 2);
36023: xmlResetLastError();
36024: if (mem_base != xmlMemBlocks()) {
36025: printf("Leak of %d blocks found in xmlSchemaValidatePredefinedType",
36026: xmlMemBlocks() - mem_base);
36027: test_ret++;
36028: printf(" %d", n_type);
36029: printf(" %d", n_value);
36030: printf(" %d", n_val);
36031: printf("\n");
36032: }
36033: }
36034: }
36035: }
36036: function_tests++;
36037: #endif
36038:
36039: return(test_ret);
36040: }
36041:
36042:
36043: static int
36044: test_xmlSchemaValueAppend(void) {
36045: int test_ret = 0;
36046:
36047: #if defined(LIBXML_SCHEMAS_ENABLED)
36048: int mem_base;
36049: int ret_val;
36050: xmlSchemaValPtr prev; /* the value */
36051: int n_prev;
36052: xmlSchemaValPtr cur; /* the value to be appended */
36053: int n_cur;
36054:
36055: for (n_prev = 0;n_prev < gen_nb_xmlSchemaValPtr;n_prev++) {
36056: for (n_cur = 0;n_cur < gen_nb_xmlSchemaValPtr;n_cur++) {
36057: mem_base = xmlMemBlocks();
36058: prev = gen_xmlSchemaValPtr(n_prev, 0);
36059: cur = gen_xmlSchemaValPtr(n_cur, 1);
36060:
36061: ret_val = xmlSchemaValueAppend(prev, cur);
36062: desret_int(ret_val);
36063: call_tests++;
36064: des_xmlSchemaValPtr(n_prev, prev, 0);
36065: des_xmlSchemaValPtr(n_cur, cur, 1);
36066: xmlResetLastError();
36067: if (mem_base != xmlMemBlocks()) {
36068: printf("Leak of %d blocks found in xmlSchemaValueAppend",
36069: xmlMemBlocks() - mem_base);
36070: test_ret++;
36071: printf(" %d", n_prev);
36072: printf(" %d", n_cur);
36073: printf("\n");
36074: }
36075: }
36076: }
36077: function_tests++;
36078: #endif
36079:
36080: return(test_ret);
36081: }
36082:
36083:
36084: static int
36085: test_xmlSchemaValueGetAsBoolean(void) {
36086: int test_ret = 0;
36087:
36088: #if defined(LIBXML_SCHEMAS_ENABLED)
36089: int mem_base;
36090: int ret_val;
36091: xmlSchemaValPtr val; /* the value */
36092: int n_val;
36093:
36094: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
36095: mem_base = xmlMemBlocks();
36096: val = gen_xmlSchemaValPtr(n_val, 0);
36097:
36098: ret_val = xmlSchemaValueGetAsBoolean(val);
36099: desret_int(ret_val);
36100: call_tests++;
36101: des_xmlSchemaValPtr(n_val, val, 0);
36102: xmlResetLastError();
36103: if (mem_base != xmlMemBlocks()) {
36104: printf("Leak of %d blocks found in xmlSchemaValueGetAsBoolean",
36105: xmlMemBlocks() - mem_base);
36106: test_ret++;
36107: printf(" %d", n_val);
36108: printf("\n");
36109: }
36110: }
36111: function_tests++;
36112: #endif
36113:
36114: return(test_ret);
36115: }
36116:
36117:
36118: static int
36119: test_xmlSchemaValueGetAsString(void) {
36120: int test_ret = 0;
36121:
36122: #if defined(LIBXML_SCHEMAS_ENABLED)
36123: int mem_base;
36124: const xmlChar * ret_val;
36125: xmlSchemaValPtr val; /* the value */
36126: int n_val;
36127:
36128: for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
36129: mem_base = xmlMemBlocks();
36130: val = gen_xmlSchemaValPtr(n_val, 0);
36131:
36132: ret_val = xmlSchemaValueGetAsString(val);
36133: desret_const_xmlChar_ptr(ret_val);
36134: call_tests++;
36135: des_xmlSchemaValPtr(n_val, val, 0);
36136: xmlResetLastError();
36137: if (mem_base != xmlMemBlocks()) {
36138: printf("Leak of %d blocks found in xmlSchemaValueGetAsString",
36139: xmlMemBlocks() - mem_base);
36140: test_ret++;
36141: printf(" %d", n_val);
36142: printf("\n");
36143: }
36144: }
36145: function_tests++;
36146: #endif
36147:
36148: return(test_ret);
36149: }
36150:
36151:
36152: static int
36153: test_xmlSchemaValueGetNext(void) {
36154: int test_ret = 0;
36155:
36156:
36157: /* missing type support */
36158: return(test_ret);
36159: }
36160:
36161:
36162: static int
36163: test_xmlSchemaWhiteSpaceReplace(void) {
36164: int test_ret = 0;
36165:
36166: #if defined(LIBXML_SCHEMAS_ENABLED)
36167: int mem_base;
36168: xmlChar * ret_val;
36169: xmlChar * value; /* a value */
36170: int n_value;
36171:
36172: for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
36173: mem_base = xmlMemBlocks();
36174: value = gen_const_xmlChar_ptr(n_value, 0);
36175:
36176: ret_val = xmlSchemaWhiteSpaceReplace((const xmlChar *)value);
36177: desret_xmlChar_ptr(ret_val);
36178: call_tests++;
36179: des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
36180: xmlResetLastError();
36181: if (mem_base != xmlMemBlocks()) {
36182: printf("Leak of %d blocks found in xmlSchemaWhiteSpaceReplace",
36183: xmlMemBlocks() - mem_base);
36184: test_ret++;
36185: printf(" %d", n_value);
36186: printf("\n");
36187: }
36188: }
36189: function_tests++;
36190: #endif
36191:
36192: return(test_ret);
36193: }
36194:
36195: static int
36196: test_xmlschemastypes(void) {
36197: int test_ret = 0;
36198:
36199: if (quiet == 0) printf("Testing xmlschemastypes : 26 of 34 functions ...\n");
36200: test_ret += test_xmlSchemaCheckFacet();
36201: test_ret += test_xmlSchemaCleanupTypes();
36202: test_ret += test_xmlSchemaCollapseString();
36203: test_ret += test_xmlSchemaCompareValues();
36204: test_ret += test_xmlSchemaCompareValuesWhtsp();
36205: test_ret += test_xmlSchemaCopyValue();
36206: test_ret += test_xmlSchemaGetBuiltInListSimpleTypeItemType();
36207: test_ret += test_xmlSchemaGetBuiltInType();
36208: test_ret += test_xmlSchemaGetCanonValue();
36209: test_ret += test_xmlSchemaGetCanonValueWhtsp();
36210: test_ret += test_xmlSchemaGetFacetValueAsULong();
36211: test_ret += test_xmlSchemaGetPredefinedType();
36212: test_ret += test_xmlSchemaGetValType();
36213: test_ret += test_xmlSchemaInitTypes();
36214: test_ret += test_xmlSchemaIsBuiltInTypeFacet();
36215: test_ret += test_xmlSchemaNewFacet();
36216: test_ret += test_xmlSchemaNewNOTATIONValue();
36217: test_ret += test_xmlSchemaNewQNameValue();
36218: test_ret += test_xmlSchemaNewStringValue();
36219: test_ret += test_xmlSchemaValPredefTypeNode();
36220: test_ret += test_xmlSchemaValPredefTypeNodeNoNorm();
36221: test_ret += test_xmlSchemaValidateFacet();
36222: test_ret += test_xmlSchemaValidateFacetWhtsp();
36223: test_ret += test_xmlSchemaValidateLengthFacet();
36224: test_ret += test_xmlSchemaValidateLengthFacetWhtsp();
36225: test_ret += test_xmlSchemaValidateListSimpleTypeFacet();
36226: test_ret += test_xmlSchemaValidatePredefinedType();
36227: test_ret += test_xmlSchemaValueAppend();
36228: test_ret += test_xmlSchemaValueGetAsBoolean();
36229: test_ret += test_xmlSchemaValueGetAsString();
36230: test_ret += test_xmlSchemaValueGetNext();
36231: test_ret += test_xmlSchemaWhiteSpaceReplace();
36232:
36233: if (test_ret != 0)
36234: printf("Module xmlschemastypes: %d errors\n", test_ret);
36235: return(test_ret);
36236: }
36237:
36238: static int
36239: test_xmlCharStrdup(void) {
36240: int test_ret = 0;
36241:
36242: int mem_base;
36243: xmlChar * ret_val;
36244: char * cur; /* the input char * */
36245: int n_cur;
36246:
36247: for (n_cur = 0;n_cur < gen_nb_const_char_ptr;n_cur++) {
36248: mem_base = xmlMemBlocks();
36249: cur = gen_const_char_ptr(n_cur, 0);
36250:
36251: ret_val = xmlCharStrdup((const char *)cur);
36252: desret_xmlChar_ptr(ret_val);
36253: call_tests++;
36254: des_const_char_ptr(n_cur, (const char *)cur, 0);
36255: xmlResetLastError();
36256: if (mem_base != xmlMemBlocks()) {
36257: printf("Leak of %d blocks found in xmlCharStrdup",
36258: xmlMemBlocks() - mem_base);
36259: test_ret++;
36260: printf(" %d", n_cur);
36261: printf("\n");
36262: }
36263: }
36264: function_tests++;
36265:
36266: return(test_ret);
36267: }
36268:
36269:
36270: static int
36271: test_xmlCharStrndup(void) {
36272: int test_ret = 0;
36273:
36274: int mem_base;
36275: xmlChar * ret_val;
36276: char * cur; /* the input char * */
36277: int n_cur;
36278: int len; /* the len of @cur */
36279: int n_len;
36280:
36281: for (n_cur = 0;n_cur < gen_nb_const_char_ptr;n_cur++) {
36282: for (n_len = 0;n_len < gen_nb_int;n_len++) {
36283: mem_base = xmlMemBlocks();
36284: cur = gen_const_char_ptr(n_cur, 0);
36285: len = gen_int(n_len, 1);
36286:
36287: ret_val = xmlCharStrndup((const char *)cur, len);
36288: desret_xmlChar_ptr(ret_val);
36289: call_tests++;
36290: des_const_char_ptr(n_cur, (const char *)cur, 0);
36291: des_int(n_len, len, 1);
36292: xmlResetLastError();
36293: if (mem_base != xmlMemBlocks()) {
36294: printf("Leak of %d blocks found in xmlCharStrndup",
36295: xmlMemBlocks() - mem_base);
36296: test_ret++;
36297: printf(" %d", n_cur);
36298: printf(" %d", n_len);
36299: printf("\n");
36300: }
36301: }
36302: }
36303: function_tests++;
36304:
36305: return(test_ret);
36306: }
36307:
36308:
36309: static int
36310: test_xmlCheckUTF8(void) {
36311: int test_ret = 0;
36312:
36313: int mem_base;
36314: int ret_val;
36315: unsigned char * utf; /* Pointer to putative UTF-8 encoded string. */
36316: int n_utf;
36317:
36318: for (n_utf = 0;n_utf < gen_nb_const_unsigned_char_ptr;n_utf++) {
36319: mem_base = xmlMemBlocks();
36320: utf = gen_const_unsigned_char_ptr(n_utf, 0);
36321:
36322: ret_val = xmlCheckUTF8((const unsigned char *)utf);
36323: desret_int(ret_val);
36324: call_tests++;
36325: des_const_unsigned_char_ptr(n_utf, (const unsigned char *)utf, 0);
36326: xmlResetLastError();
36327: if (mem_base != xmlMemBlocks()) {
36328: printf("Leak of %d blocks found in xmlCheckUTF8",
36329: xmlMemBlocks() - mem_base);
36330: test_ret++;
36331: printf(" %d", n_utf);
36332: printf("\n");
36333: }
36334: }
36335: function_tests++;
36336:
36337: return(test_ret);
36338: }
36339:
36340:
36341: static int
36342: test_xmlGetUTF8Char(void) {
36343: int test_ret = 0;
36344:
36345: int mem_base;
36346: int ret_val;
36347: unsigned char * utf; /* a sequence of UTF-8 encoded bytes */
36348: int n_utf;
36349: 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. */
36350: int n_len;
36351:
36352: for (n_utf = 0;n_utf < gen_nb_const_unsigned_char_ptr;n_utf++) {
36353: for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
36354: mem_base = xmlMemBlocks();
36355: utf = gen_const_unsigned_char_ptr(n_utf, 0);
36356: len = gen_int_ptr(n_len, 1);
36357:
36358: ret_val = xmlGetUTF8Char((const unsigned char *)utf, len);
36359: desret_int(ret_val);
36360: call_tests++;
36361: des_const_unsigned_char_ptr(n_utf, (const unsigned char *)utf, 0);
36362: des_int_ptr(n_len, len, 1);
36363: xmlResetLastError();
36364: if (mem_base != xmlMemBlocks()) {
36365: printf("Leak of %d blocks found in xmlGetUTF8Char",
36366: xmlMemBlocks() - mem_base);
36367: test_ret++;
36368: printf(" %d", n_utf);
36369: printf(" %d", n_len);
36370: printf("\n");
36371: }
36372: }
36373: }
36374: function_tests++;
36375:
36376: return(test_ret);
36377: }
36378:
36379:
36380: static int
36381: test_xmlStrEqual(void) {
36382: int test_ret = 0;
36383:
36384: int mem_base;
36385: int ret_val;
36386: xmlChar * str1; /* the first xmlChar * */
36387: int n_str1;
36388: xmlChar * str2; /* the second xmlChar * */
36389: int n_str2;
36390:
36391: for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
36392: for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
36393: mem_base = xmlMemBlocks();
36394: str1 = gen_const_xmlChar_ptr(n_str1, 0);
36395: str2 = gen_const_xmlChar_ptr(n_str2, 1);
36396:
36397: ret_val = xmlStrEqual((const xmlChar *)str1, (const xmlChar *)str2);
36398: desret_int(ret_val);
36399: call_tests++;
36400: des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0);
36401: des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1);
36402: xmlResetLastError();
36403: if (mem_base != xmlMemBlocks()) {
36404: printf("Leak of %d blocks found in xmlStrEqual",
36405: xmlMemBlocks() - mem_base);
36406: test_ret++;
36407: printf(" %d", n_str1);
36408: printf(" %d", n_str2);
36409: printf("\n");
36410: }
36411: }
36412: }
36413: function_tests++;
36414:
36415: return(test_ret);
36416: }
36417:
36418:
36419: static int
36420: test_xmlStrPrintf(void) {
36421: int test_ret = 0;
36422:
36423:
36424: /* missing type support */
36425: return(test_ret);
36426: }
36427:
36428:
36429: static int
36430: test_xmlStrQEqual(void) {
36431: int test_ret = 0;
36432:
36433: int mem_base;
36434: int ret_val;
36435: xmlChar * pref; /* the prefix of the QName */
36436: int n_pref;
36437: xmlChar * name; /* the localname of the QName */
36438: int n_name;
36439: xmlChar * str; /* the second xmlChar * */
36440: int n_str;
36441:
36442: for (n_pref = 0;n_pref < gen_nb_const_xmlChar_ptr;n_pref++) {
36443: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
36444: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
36445: mem_base = xmlMemBlocks();
36446: pref = gen_const_xmlChar_ptr(n_pref, 0);
36447: name = gen_const_xmlChar_ptr(n_name, 1);
36448: str = gen_const_xmlChar_ptr(n_str, 2);
36449:
36450: ret_val = xmlStrQEqual((const xmlChar *)pref, (const xmlChar *)name, (const xmlChar *)str);
36451: desret_int(ret_val);
36452: call_tests++;
36453: des_const_xmlChar_ptr(n_pref, (const xmlChar *)pref, 0);
36454: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
36455: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 2);
36456: xmlResetLastError();
36457: if (mem_base != xmlMemBlocks()) {
36458: printf("Leak of %d blocks found in xmlStrQEqual",
36459: xmlMemBlocks() - mem_base);
36460: test_ret++;
36461: printf(" %d", n_pref);
36462: printf(" %d", n_name);
36463: printf(" %d", n_str);
36464: printf("\n");
36465: }
36466: }
36467: }
36468: }
36469: function_tests++;
36470:
36471: return(test_ret);
36472: }
36473:
36474:
36475: static int
36476: test_xmlStrVPrintf(void) {
36477: int test_ret = 0;
36478:
36479:
36480: /* missing type support */
36481: return(test_ret);
36482: }
36483:
36484:
36485: static int
36486: test_xmlStrcasecmp(void) {
36487: int test_ret = 0;
36488:
36489: int mem_base;
36490: int ret_val;
36491: xmlChar * str1; /* the first xmlChar * */
36492: int n_str1;
36493: xmlChar * str2; /* the second xmlChar * */
36494: int n_str2;
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: mem_base = xmlMemBlocks();
36499: str1 = gen_const_xmlChar_ptr(n_str1, 0);
36500: str2 = gen_const_xmlChar_ptr(n_str2, 1);
36501:
36502: ret_val = xmlStrcasecmp((const xmlChar *)str1, (const xmlChar *)str2);
36503: desret_int(ret_val);
36504: call_tests++;
36505: des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0);
36506: des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1);
36507: xmlResetLastError();
36508: if (mem_base != xmlMemBlocks()) {
36509: printf("Leak of %d blocks found in xmlStrcasecmp",
36510: xmlMemBlocks() - mem_base);
36511: test_ret++;
36512: printf(" %d", n_str1);
36513: printf(" %d", n_str2);
36514: printf("\n");
36515: }
36516: }
36517: }
36518: function_tests++;
36519:
36520: return(test_ret);
36521: }
36522:
36523:
36524: static int
36525: test_xmlStrcasestr(void) {
36526: int test_ret = 0;
36527:
36528: int mem_base;
36529: const xmlChar * ret_val;
36530: xmlChar * str; /* the xmlChar * array (haystack) */
36531: int n_str;
36532: xmlChar * val; /* the xmlChar to search (needle) */
36533: int n_val;
36534:
36535: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
36536: for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) {
36537: mem_base = xmlMemBlocks();
36538: str = gen_const_xmlChar_ptr(n_str, 0);
36539: val = gen_const_xmlChar_ptr(n_val, 1);
36540:
36541: ret_val = xmlStrcasestr((const xmlChar *)str, (const xmlChar *)val);
36542: desret_const_xmlChar_ptr(ret_val);
36543: call_tests++;
36544: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
36545: des_const_xmlChar_ptr(n_val, (const xmlChar *)val, 1);
36546: xmlResetLastError();
36547: if (mem_base != xmlMemBlocks()) {
36548: printf("Leak of %d blocks found in xmlStrcasestr",
36549: xmlMemBlocks() - mem_base);
36550: test_ret++;
36551: printf(" %d", n_str);
36552: printf(" %d", n_val);
36553: printf("\n");
36554: }
36555: }
36556: }
36557: function_tests++;
36558:
36559: return(test_ret);
36560: }
36561:
36562:
36563: static int
36564: test_xmlStrchr(void) {
36565: int test_ret = 0;
36566:
36567: int mem_base;
36568: const xmlChar * ret_val;
36569: xmlChar * str; /* the xmlChar * array */
36570: int n_str;
36571: xmlChar val; /* the xmlChar to search */
36572: int n_val;
36573:
36574: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
36575: for (n_val = 0;n_val < gen_nb_xmlChar;n_val++) {
36576: mem_base = xmlMemBlocks();
36577: str = gen_const_xmlChar_ptr(n_str, 0);
36578: val = gen_xmlChar(n_val, 1);
36579:
36580: ret_val = xmlStrchr((const xmlChar *)str, val);
36581: desret_const_xmlChar_ptr(ret_val);
36582: call_tests++;
36583: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
36584: des_xmlChar(n_val, val, 1);
36585: xmlResetLastError();
36586: if (mem_base != xmlMemBlocks()) {
36587: printf("Leak of %d blocks found in xmlStrchr",
36588: xmlMemBlocks() - mem_base);
36589: test_ret++;
36590: printf(" %d", n_str);
36591: printf(" %d", n_val);
36592: printf("\n");
36593: }
36594: }
36595: }
36596: function_tests++;
36597:
36598: return(test_ret);
36599: }
36600:
36601:
36602: static int
36603: test_xmlStrcmp(void) {
36604: int test_ret = 0;
36605:
36606: int mem_base;
36607: int ret_val;
36608: xmlChar * str1; /* the first xmlChar * */
36609: int n_str1;
36610: xmlChar * str2; /* the second xmlChar * */
36611: int n_str2;
36612:
36613: for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
36614: for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
36615: mem_base = xmlMemBlocks();
36616: str1 = gen_const_xmlChar_ptr(n_str1, 0);
36617: str2 = gen_const_xmlChar_ptr(n_str2, 1);
36618:
36619: ret_val = xmlStrcmp((const xmlChar *)str1, (const xmlChar *)str2);
36620: desret_int(ret_val);
36621: call_tests++;
36622: des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0);
36623: des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1);
36624: xmlResetLastError();
36625: if (mem_base != xmlMemBlocks()) {
36626: printf("Leak of %d blocks found in xmlStrcmp",
36627: xmlMemBlocks() - mem_base);
36628: test_ret++;
36629: printf(" %d", n_str1);
36630: printf(" %d", n_str2);
36631: printf("\n");
36632: }
36633: }
36634: }
36635: function_tests++;
36636:
36637: return(test_ret);
36638: }
36639:
36640:
36641: static int
36642: test_xmlStrdup(void) {
36643: int test_ret = 0;
36644:
36645: int mem_base;
36646: xmlChar * ret_val;
36647: xmlChar * cur; /* the input xmlChar * */
36648: int n_cur;
36649:
36650: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
36651: mem_base = xmlMemBlocks();
36652: cur = gen_const_xmlChar_ptr(n_cur, 0);
36653:
36654: ret_val = xmlStrdup((const xmlChar *)cur);
36655: desret_xmlChar_ptr(ret_val);
36656: call_tests++;
36657: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
36658: xmlResetLastError();
36659: if (mem_base != xmlMemBlocks()) {
36660: printf("Leak of %d blocks found in xmlStrdup",
36661: xmlMemBlocks() - mem_base);
36662: test_ret++;
36663: printf(" %d", n_cur);
36664: printf("\n");
36665: }
36666: }
36667: function_tests++;
36668:
36669: return(test_ret);
36670: }
36671:
36672:
36673: static int
36674: test_xmlStrlen(void) {
36675: int test_ret = 0;
36676:
36677: int mem_base;
36678: int ret_val;
36679: xmlChar * str; /* the xmlChar * array */
36680: int n_str;
36681:
36682: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
36683: mem_base = xmlMemBlocks();
36684: str = gen_const_xmlChar_ptr(n_str, 0);
36685:
36686: ret_val = xmlStrlen((const xmlChar *)str);
36687: desret_int(ret_val);
36688: call_tests++;
36689: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
36690: xmlResetLastError();
36691: if (mem_base != xmlMemBlocks()) {
36692: printf("Leak of %d blocks found in xmlStrlen",
36693: xmlMemBlocks() - mem_base);
36694: test_ret++;
36695: printf(" %d", n_str);
36696: printf("\n");
36697: }
36698: }
36699: function_tests++;
36700:
36701: return(test_ret);
36702: }
36703:
36704:
36705: static int
36706: test_xmlStrncasecmp(void) {
36707: int test_ret = 0;
36708:
36709: int mem_base;
36710: int ret_val;
36711: xmlChar * str1; /* the first xmlChar * */
36712: int n_str1;
36713: xmlChar * str2; /* the second xmlChar * */
36714: int n_str2;
36715: int len; /* the max comparison length */
36716: int n_len;
36717:
36718: for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
36719: for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
36720: for (n_len = 0;n_len < gen_nb_int;n_len++) {
36721: mem_base = xmlMemBlocks();
36722: str1 = gen_const_xmlChar_ptr(n_str1, 0);
36723: str2 = gen_const_xmlChar_ptr(n_str2, 1);
36724: len = gen_int(n_len, 2);
36725:
36726: ret_val = xmlStrncasecmp((const xmlChar *)str1, (const xmlChar *)str2, len);
36727: desret_int(ret_val);
36728: call_tests++;
36729: des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0);
36730: des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1);
36731: des_int(n_len, len, 2);
36732: xmlResetLastError();
36733: if (mem_base != xmlMemBlocks()) {
36734: printf("Leak of %d blocks found in xmlStrncasecmp",
36735: xmlMemBlocks() - mem_base);
36736: test_ret++;
36737: printf(" %d", n_str1);
36738: printf(" %d", n_str2);
36739: printf(" %d", n_len);
36740: printf("\n");
36741: }
36742: }
36743: }
36744: }
36745: function_tests++;
36746:
36747: return(test_ret);
36748: }
36749:
36750:
36751: static int
36752: test_xmlStrncatNew(void) {
36753: int test_ret = 0;
36754:
36755: int mem_base;
36756: xmlChar * ret_val;
36757: xmlChar * str1; /* first xmlChar string */
36758: int n_str1;
36759: xmlChar * str2; /* second xmlChar string */
36760: int n_str2;
36761: int len; /* the len of @str2 or < 0 */
36762: int n_len;
36763:
36764: for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
36765: for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
36766: for (n_len = 0;n_len < gen_nb_int;n_len++) {
36767: mem_base = xmlMemBlocks();
36768: str1 = gen_const_xmlChar_ptr(n_str1, 0);
36769: str2 = gen_const_xmlChar_ptr(n_str2, 1);
36770: len = gen_int(n_len, 2);
36771:
36772: ret_val = xmlStrncatNew((const xmlChar *)str1, (const xmlChar *)str2, len);
36773: desret_xmlChar_ptr(ret_val);
36774: call_tests++;
36775: des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0);
36776: des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1);
36777: des_int(n_len, len, 2);
36778: xmlResetLastError();
36779: if (mem_base != xmlMemBlocks()) {
36780: printf("Leak of %d blocks found in xmlStrncatNew",
36781: xmlMemBlocks() - mem_base);
36782: test_ret++;
36783: printf(" %d", n_str1);
36784: printf(" %d", n_str2);
36785: printf(" %d", n_len);
36786: printf("\n");
36787: }
36788: }
36789: }
36790: }
36791: function_tests++;
36792:
36793: return(test_ret);
36794: }
36795:
36796:
36797: static int
36798: test_xmlStrncmp(void) {
36799: int test_ret = 0;
36800:
36801: int mem_base;
36802: int ret_val;
36803: xmlChar * str1; /* the first xmlChar * */
36804: int n_str1;
36805: xmlChar * str2; /* the second xmlChar * */
36806: int n_str2;
36807: int len; /* the max comparison length */
36808: int n_len;
36809:
36810: for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
36811: for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
36812: for (n_len = 0;n_len < gen_nb_int;n_len++) {
36813: mem_base = xmlMemBlocks();
36814: str1 = gen_const_xmlChar_ptr(n_str1, 0);
36815: str2 = gen_const_xmlChar_ptr(n_str2, 1);
36816: len = gen_int(n_len, 2);
36817:
36818: ret_val = xmlStrncmp((const xmlChar *)str1, (const xmlChar *)str2, len);
36819: desret_int(ret_val);
36820: call_tests++;
36821: des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0);
36822: des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1);
36823: des_int(n_len, len, 2);
36824: xmlResetLastError();
36825: if (mem_base != xmlMemBlocks()) {
36826: printf("Leak of %d blocks found in xmlStrncmp",
36827: xmlMemBlocks() - mem_base);
36828: test_ret++;
36829: printf(" %d", n_str1);
36830: printf(" %d", n_str2);
36831: printf(" %d", n_len);
36832: printf("\n");
36833: }
36834: }
36835: }
36836: }
36837: function_tests++;
36838:
36839: return(test_ret);
36840: }
36841:
36842:
36843: static int
36844: test_xmlStrndup(void) {
36845: int test_ret = 0;
36846:
36847: int mem_base;
36848: xmlChar * ret_val;
36849: xmlChar * cur; /* the input xmlChar * */
36850: int n_cur;
36851: int len; /* the len of @cur */
36852: int n_len;
36853:
36854: for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
36855: for (n_len = 0;n_len < gen_nb_int;n_len++) {
36856: mem_base = xmlMemBlocks();
36857: cur = gen_const_xmlChar_ptr(n_cur, 0);
36858: len = gen_int(n_len, 1);
36859:
36860: ret_val = xmlStrndup((const xmlChar *)cur, len);
36861: desret_xmlChar_ptr(ret_val);
36862: call_tests++;
36863: des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
36864: des_int(n_len, len, 1);
36865: xmlResetLastError();
36866: if (mem_base != xmlMemBlocks()) {
36867: printf("Leak of %d blocks found in xmlStrndup",
36868: xmlMemBlocks() - mem_base);
36869: test_ret++;
36870: printf(" %d", n_cur);
36871: printf(" %d", n_len);
36872: printf("\n");
36873: }
36874: }
36875: }
36876: function_tests++;
36877:
36878: return(test_ret);
36879: }
36880:
36881:
36882: static int
36883: test_xmlStrstr(void) {
36884: int test_ret = 0;
36885:
36886: int mem_base;
36887: const xmlChar * ret_val;
36888: xmlChar * str; /* the xmlChar * array (haystack) */
36889: int n_str;
36890: xmlChar * val; /* the xmlChar to search (needle) */
36891: int n_val;
36892:
36893: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
36894: for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) {
36895: mem_base = xmlMemBlocks();
36896: str = gen_const_xmlChar_ptr(n_str, 0);
36897: val = gen_const_xmlChar_ptr(n_val, 1);
36898:
36899: ret_val = xmlStrstr((const xmlChar *)str, (const xmlChar *)val);
36900: desret_const_xmlChar_ptr(ret_val);
36901: call_tests++;
36902: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
36903: des_const_xmlChar_ptr(n_val, (const xmlChar *)val, 1);
36904: xmlResetLastError();
36905: if (mem_base != xmlMemBlocks()) {
36906: printf("Leak of %d blocks found in xmlStrstr",
36907: xmlMemBlocks() - mem_base);
36908: test_ret++;
36909: printf(" %d", n_str);
36910: printf(" %d", n_val);
36911: printf("\n");
36912: }
36913: }
36914: }
36915: function_tests++;
36916:
36917: return(test_ret);
36918: }
36919:
36920:
36921: static int
36922: test_xmlStrsub(void) {
36923: int test_ret = 0;
36924:
36925: int mem_base;
36926: xmlChar * ret_val;
36927: xmlChar * str; /* the xmlChar * array (haystack) */
36928: int n_str;
36929: int start; /* the index of the first char (zero based) */
36930: int n_start;
36931: int len; /* the length of the substring */
36932: int n_len;
36933:
36934: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
36935: for (n_start = 0;n_start < gen_nb_int;n_start++) {
36936: for (n_len = 0;n_len < gen_nb_int;n_len++) {
36937: mem_base = xmlMemBlocks();
36938: str = gen_const_xmlChar_ptr(n_str, 0);
36939: start = gen_int(n_start, 1);
36940: len = gen_int(n_len, 2);
36941:
36942: ret_val = xmlStrsub((const xmlChar *)str, start, len);
36943: desret_xmlChar_ptr(ret_val);
36944: call_tests++;
36945: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
36946: des_int(n_start, start, 1);
36947: des_int(n_len, len, 2);
36948: xmlResetLastError();
36949: if (mem_base != xmlMemBlocks()) {
36950: printf("Leak of %d blocks found in xmlStrsub",
36951: xmlMemBlocks() - mem_base);
36952: test_ret++;
36953: printf(" %d", n_str);
36954: printf(" %d", n_start);
36955: printf(" %d", n_len);
36956: printf("\n");
36957: }
36958: }
36959: }
36960: }
36961: function_tests++;
36962:
36963: return(test_ret);
36964: }
36965:
36966:
36967: static int
36968: test_xmlUTF8Charcmp(void) {
36969: int test_ret = 0;
36970:
36971: int mem_base;
36972: int ret_val;
36973: xmlChar * utf1; /* pointer to first UTF8 char */
36974: int n_utf1;
36975: xmlChar * utf2; /* pointer to second UTF8 char */
36976: int n_utf2;
36977:
36978: for (n_utf1 = 0;n_utf1 < gen_nb_const_xmlChar_ptr;n_utf1++) {
36979: for (n_utf2 = 0;n_utf2 < gen_nb_const_xmlChar_ptr;n_utf2++) {
36980: mem_base = xmlMemBlocks();
36981: utf1 = gen_const_xmlChar_ptr(n_utf1, 0);
36982: utf2 = gen_const_xmlChar_ptr(n_utf2, 1);
36983:
36984: ret_val = xmlUTF8Charcmp((const xmlChar *)utf1, (const xmlChar *)utf2);
36985: desret_int(ret_val);
36986: call_tests++;
36987: des_const_xmlChar_ptr(n_utf1, (const xmlChar *)utf1, 0);
36988: des_const_xmlChar_ptr(n_utf2, (const xmlChar *)utf2, 1);
36989: xmlResetLastError();
36990: if (mem_base != xmlMemBlocks()) {
36991: printf("Leak of %d blocks found in xmlUTF8Charcmp",
36992: xmlMemBlocks() - mem_base);
36993: test_ret++;
36994: printf(" %d", n_utf1);
36995: printf(" %d", n_utf2);
36996: printf("\n");
36997: }
36998: }
36999: }
37000: function_tests++;
37001:
37002: return(test_ret);
37003: }
37004:
37005:
37006: static int
37007: test_xmlUTF8Size(void) {
37008: int test_ret = 0;
37009:
37010: int mem_base;
37011: int ret_val;
37012: xmlChar * utf; /* pointer to the UTF8 character */
37013: int n_utf;
37014:
37015: for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
37016: mem_base = xmlMemBlocks();
37017: utf = gen_const_xmlChar_ptr(n_utf, 0);
37018:
37019: ret_val = xmlUTF8Size((const xmlChar *)utf);
37020: desret_int(ret_val);
37021: call_tests++;
37022: des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
37023: xmlResetLastError();
37024: if (mem_base != xmlMemBlocks()) {
37025: printf("Leak of %d blocks found in xmlUTF8Size",
37026: xmlMemBlocks() - mem_base);
37027: test_ret++;
37028: printf(" %d", n_utf);
37029: printf("\n");
37030: }
37031: }
37032: function_tests++;
37033:
37034: return(test_ret);
37035: }
37036:
37037:
37038: static int
37039: test_xmlUTF8Strlen(void) {
37040: int test_ret = 0;
37041:
37042: int mem_base;
37043: int ret_val;
37044: xmlChar * utf; /* a sequence of UTF-8 encoded bytes */
37045: int n_utf;
37046:
37047: for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
37048: mem_base = xmlMemBlocks();
37049: utf = gen_const_xmlChar_ptr(n_utf, 0);
37050:
37051: ret_val = xmlUTF8Strlen((const xmlChar *)utf);
37052: desret_int(ret_val);
37053: call_tests++;
37054: des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
37055: xmlResetLastError();
37056: if (mem_base != xmlMemBlocks()) {
37057: printf("Leak of %d blocks found in xmlUTF8Strlen",
37058: xmlMemBlocks() - mem_base);
37059: test_ret++;
37060: printf(" %d", n_utf);
37061: printf("\n");
37062: }
37063: }
37064: function_tests++;
37065:
37066: return(test_ret);
37067: }
37068:
37069:
37070: static int
37071: test_xmlUTF8Strloc(void) {
37072: int test_ret = 0;
37073:
37074: int mem_base;
37075: int ret_val;
37076: xmlChar * utf; /* the input UTF8 * */
37077: int n_utf;
37078: xmlChar * utfchar; /* the UTF8 character to be found */
37079: int n_utfchar;
37080:
37081: for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
37082: for (n_utfchar = 0;n_utfchar < gen_nb_const_xmlChar_ptr;n_utfchar++) {
37083: mem_base = xmlMemBlocks();
37084: utf = gen_const_xmlChar_ptr(n_utf, 0);
37085: utfchar = gen_const_xmlChar_ptr(n_utfchar, 1);
37086:
37087: ret_val = xmlUTF8Strloc((const xmlChar *)utf, (const xmlChar *)utfchar);
37088: desret_int(ret_val);
37089: call_tests++;
37090: des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
37091: des_const_xmlChar_ptr(n_utfchar, (const xmlChar *)utfchar, 1);
37092: xmlResetLastError();
37093: if (mem_base != xmlMemBlocks()) {
37094: printf("Leak of %d blocks found in xmlUTF8Strloc",
37095: xmlMemBlocks() - mem_base);
37096: test_ret++;
37097: printf(" %d", n_utf);
37098: printf(" %d", n_utfchar);
37099: printf("\n");
37100: }
37101: }
37102: }
37103: function_tests++;
37104:
37105: return(test_ret);
37106: }
37107:
37108:
37109: static int
37110: test_xmlUTF8Strndup(void) {
37111: int test_ret = 0;
37112:
37113: int mem_base;
37114: xmlChar * ret_val;
37115: xmlChar * utf; /* the input UTF8 * */
37116: int n_utf;
37117: int len; /* the len of @utf (in chars) */
37118: int n_len;
37119:
37120: for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
37121: for (n_len = 0;n_len < gen_nb_int;n_len++) {
37122: mem_base = xmlMemBlocks();
37123: utf = gen_const_xmlChar_ptr(n_utf, 0);
37124: len = gen_int(n_len, 1);
37125:
37126: ret_val = xmlUTF8Strndup((const xmlChar *)utf, len);
37127: desret_xmlChar_ptr(ret_val);
37128: call_tests++;
37129: des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
37130: des_int(n_len, len, 1);
37131: xmlResetLastError();
37132: if (mem_base != xmlMemBlocks()) {
37133: printf("Leak of %d blocks found in xmlUTF8Strndup",
37134: xmlMemBlocks() - mem_base);
37135: test_ret++;
37136: printf(" %d", n_utf);
37137: printf(" %d", n_len);
37138: printf("\n");
37139: }
37140: }
37141: }
37142: function_tests++;
37143:
37144: return(test_ret);
37145: }
37146:
37147:
37148: static int
37149: test_xmlUTF8Strpos(void) {
37150: int test_ret = 0;
37151:
37152: int mem_base;
37153: const xmlChar * ret_val;
37154: xmlChar * utf; /* the input UTF8 * */
37155: int n_utf;
37156: int pos; /* the position of the desired UTF8 char (in chars) */
37157: int n_pos;
37158:
37159: for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
37160: for (n_pos = 0;n_pos < gen_nb_int;n_pos++) {
37161: mem_base = xmlMemBlocks();
37162: utf = gen_const_xmlChar_ptr(n_utf, 0);
37163: pos = gen_int(n_pos, 1);
37164:
37165: ret_val = xmlUTF8Strpos((const xmlChar *)utf, pos);
37166: desret_const_xmlChar_ptr(ret_val);
37167: call_tests++;
37168: des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
37169: des_int(n_pos, pos, 1);
37170: xmlResetLastError();
37171: if (mem_base != xmlMemBlocks()) {
37172: printf("Leak of %d blocks found in xmlUTF8Strpos",
37173: xmlMemBlocks() - mem_base);
37174: test_ret++;
37175: printf(" %d", n_utf);
37176: printf(" %d", n_pos);
37177: printf("\n");
37178: }
37179: }
37180: }
37181: function_tests++;
37182:
37183: return(test_ret);
37184: }
37185:
37186:
37187: static int
37188: test_xmlUTF8Strsize(void) {
37189: int test_ret = 0;
37190:
37191: int mem_base;
37192: int ret_val;
37193: xmlChar * utf; /* a sequence of UTF-8 encoded bytes */
37194: int n_utf;
37195: int len; /* the number of characters in the array */
37196: int n_len;
37197:
37198: for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
37199: for (n_len = 0;n_len < gen_nb_int;n_len++) {
37200: mem_base = xmlMemBlocks();
37201: utf = gen_const_xmlChar_ptr(n_utf, 0);
37202: len = gen_int(n_len, 1);
37203:
37204: ret_val = xmlUTF8Strsize((const xmlChar *)utf, len);
37205: desret_int(ret_val);
37206: call_tests++;
37207: des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
37208: des_int(n_len, len, 1);
37209: xmlResetLastError();
37210: if (mem_base != xmlMemBlocks()) {
37211: printf("Leak of %d blocks found in xmlUTF8Strsize",
37212: xmlMemBlocks() - mem_base);
37213: test_ret++;
37214: printf(" %d", n_utf);
37215: printf(" %d", n_len);
37216: printf("\n");
37217: }
37218: }
37219: }
37220: function_tests++;
37221:
37222: return(test_ret);
37223: }
37224:
37225:
37226: static int
37227: test_xmlUTF8Strsub(void) {
37228: int test_ret = 0;
37229:
37230: int mem_base;
37231: xmlChar * ret_val;
37232: xmlChar * utf; /* a sequence of UTF-8 encoded bytes */
37233: int n_utf;
37234: int start; /* relative pos of first char */
37235: int n_start;
37236: int len; /* total number to copy */
37237: int n_len;
37238:
37239: for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
37240: for (n_start = 0;n_start < gen_nb_int;n_start++) {
37241: for (n_len = 0;n_len < gen_nb_int;n_len++) {
37242: mem_base = xmlMemBlocks();
37243: utf = gen_const_xmlChar_ptr(n_utf, 0);
37244: start = gen_int(n_start, 1);
37245: len = gen_int(n_len, 2);
37246:
37247: ret_val = xmlUTF8Strsub((const xmlChar *)utf, start, len);
37248: desret_xmlChar_ptr(ret_val);
37249: call_tests++;
37250: des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
37251: des_int(n_start, start, 1);
37252: des_int(n_len, len, 2);
37253: xmlResetLastError();
37254: if (mem_base != xmlMemBlocks()) {
37255: printf("Leak of %d blocks found in xmlUTF8Strsub",
37256: xmlMemBlocks() - mem_base);
37257: test_ret++;
37258: printf(" %d", n_utf);
37259: printf(" %d", n_start);
37260: printf(" %d", n_len);
37261: printf("\n");
37262: }
37263: }
37264: }
37265: }
37266: function_tests++;
37267:
37268: return(test_ret);
37269: }
37270:
37271: static int
37272: test_xmlstring(void) {
37273: int test_ret = 0;
37274:
37275: if (quiet == 0) printf("Testing xmlstring : 26 of 30 functions ...\n");
37276: test_ret += test_xmlCharStrdup();
37277: test_ret += test_xmlCharStrndup();
37278: test_ret += test_xmlCheckUTF8();
37279: test_ret += test_xmlGetUTF8Char();
37280: test_ret += test_xmlStrEqual();
37281: test_ret += test_xmlStrPrintf();
37282: test_ret += test_xmlStrQEqual();
37283: test_ret += test_xmlStrVPrintf();
37284: test_ret += test_xmlStrcasecmp();
37285: test_ret += test_xmlStrcasestr();
37286: test_ret += test_xmlStrchr();
37287: test_ret += test_xmlStrcmp();
37288: test_ret += test_xmlStrdup();
37289: test_ret += test_xmlStrlen();
37290: test_ret += test_xmlStrncasecmp();
37291: test_ret += test_xmlStrncatNew();
37292: test_ret += test_xmlStrncmp();
37293: test_ret += test_xmlStrndup();
37294: test_ret += test_xmlStrstr();
37295: test_ret += test_xmlStrsub();
37296: test_ret += test_xmlUTF8Charcmp();
37297: test_ret += test_xmlUTF8Size();
37298: test_ret += test_xmlUTF8Strlen();
37299: test_ret += test_xmlUTF8Strloc();
37300: test_ret += test_xmlUTF8Strndup();
37301: test_ret += test_xmlUTF8Strpos();
37302: test_ret += test_xmlUTF8Strsize();
37303: test_ret += test_xmlUTF8Strsub();
37304:
37305: if (test_ret != 0)
37306: printf("Module xmlstring: %d errors\n", test_ret);
37307: return(test_ret);
37308: }
37309:
37310: static int
37311: test_xmlUCSIsAegeanNumbers(void) {
37312: int test_ret = 0;
37313:
37314: #if defined(LIBXML_UNICODE_ENABLED)
37315: int mem_base;
37316: int ret_val;
37317: int code; /* UCS code point */
37318: int n_code;
37319:
37320: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37321: mem_base = xmlMemBlocks();
37322: code = gen_int(n_code, 0);
37323:
37324: ret_val = xmlUCSIsAegeanNumbers(code);
37325: desret_int(ret_val);
37326: call_tests++;
37327: des_int(n_code, code, 0);
37328: xmlResetLastError();
37329: if (mem_base != xmlMemBlocks()) {
37330: printf("Leak of %d blocks found in xmlUCSIsAegeanNumbers",
37331: xmlMemBlocks() - mem_base);
37332: test_ret++;
37333: printf(" %d", n_code);
37334: printf("\n");
37335: }
37336: }
37337: function_tests++;
37338: #endif
37339:
37340: return(test_ret);
37341: }
37342:
37343:
37344: static int
37345: test_xmlUCSIsAlphabeticPresentationForms(void) {
37346: int test_ret = 0;
37347:
37348: #if defined(LIBXML_UNICODE_ENABLED)
37349: int mem_base;
37350: int ret_val;
37351: int code; /* UCS code point */
37352: int n_code;
37353:
37354: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37355: mem_base = xmlMemBlocks();
37356: code = gen_int(n_code, 0);
37357:
37358: ret_val = xmlUCSIsAlphabeticPresentationForms(code);
37359: desret_int(ret_val);
37360: call_tests++;
37361: des_int(n_code, code, 0);
37362: xmlResetLastError();
37363: if (mem_base != xmlMemBlocks()) {
37364: printf("Leak of %d blocks found in xmlUCSIsAlphabeticPresentationForms",
37365: xmlMemBlocks() - mem_base);
37366: test_ret++;
37367: printf(" %d", n_code);
37368: printf("\n");
37369: }
37370: }
37371: function_tests++;
37372: #endif
37373:
37374: return(test_ret);
37375: }
37376:
37377:
37378: static int
37379: test_xmlUCSIsArabic(void) {
37380: int test_ret = 0;
37381:
37382: #if defined(LIBXML_UNICODE_ENABLED)
37383: int mem_base;
37384: int ret_val;
37385: int code; /* UCS code point */
37386: int n_code;
37387:
37388: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37389: mem_base = xmlMemBlocks();
37390: code = gen_int(n_code, 0);
37391:
37392: ret_val = xmlUCSIsArabic(code);
37393: desret_int(ret_val);
37394: call_tests++;
37395: des_int(n_code, code, 0);
37396: xmlResetLastError();
37397: if (mem_base != xmlMemBlocks()) {
37398: printf("Leak of %d blocks found in xmlUCSIsArabic",
37399: xmlMemBlocks() - mem_base);
37400: test_ret++;
37401: printf(" %d", n_code);
37402: printf("\n");
37403: }
37404: }
37405: function_tests++;
37406: #endif
37407:
37408: return(test_ret);
37409: }
37410:
37411:
37412: static int
37413: test_xmlUCSIsArabicPresentationFormsA(void) {
37414: int test_ret = 0;
37415:
37416: #if defined(LIBXML_UNICODE_ENABLED)
37417: int mem_base;
37418: int ret_val;
37419: int code; /* UCS code point */
37420: int n_code;
37421:
37422: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37423: mem_base = xmlMemBlocks();
37424: code = gen_int(n_code, 0);
37425:
37426: ret_val = xmlUCSIsArabicPresentationFormsA(code);
37427: desret_int(ret_val);
37428: call_tests++;
37429: des_int(n_code, code, 0);
37430: xmlResetLastError();
37431: if (mem_base != xmlMemBlocks()) {
37432: printf("Leak of %d blocks found in xmlUCSIsArabicPresentationFormsA",
37433: xmlMemBlocks() - mem_base);
37434: test_ret++;
37435: printf(" %d", n_code);
37436: printf("\n");
37437: }
37438: }
37439: function_tests++;
37440: #endif
37441:
37442: return(test_ret);
37443: }
37444:
37445:
37446: static int
37447: test_xmlUCSIsArabicPresentationFormsB(void) {
37448: int test_ret = 0;
37449:
37450: #if defined(LIBXML_UNICODE_ENABLED)
37451: int mem_base;
37452: int ret_val;
37453: int code; /* UCS code point */
37454: int n_code;
37455:
37456: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37457: mem_base = xmlMemBlocks();
37458: code = gen_int(n_code, 0);
37459:
37460: ret_val = xmlUCSIsArabicPresentationFormsB(code);
37461: desret_int(ret_val);
37462: call_tests++;
37463: des_int(n_code, code, 0);
37464: xmlResetLastError();
37465: if (mem_base != xmlMemBlocks()) {
37466: printf("Leak of %d blocks found in xmlUCSIsArabicPresentationFormsB",
37467: xmlMemBlocks() - mem_base);
37468: test_ret++;
37469: printf(" %d", n_code);
37470: printf("\n");
37471: }
37472: }
37473: function_tests++;
37474: #endif
37475:
37476: return(test_ret);
37477: }
37478:
37479:
37480: static int
37481: test_xmlUCSIsArmenian(void) {
37482: int test_ret = 0;
37483:
37484: #if defined(LIBXML_UNICODE_ENABLED)
37485: int mem_base;
37486: int ret_val;
37487: int code; /* UCS code point */
37488: int n_code;
37489:
37490: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37491: mem_base = xmlMemBlocks();
37492: code = gen_int(n_code, 0);
37493:
37494: ret_val = xmlUCSIsArmenian(code);
37495: desret_int(ret_val);
37496: call_tests++;
37497: des_int(n_code, code, 0);
37498: xmlResetLastError();
37499: if (mem_base != xmlMemBlocks()) {
37500: printf("Leak of %d blocks found in xmlUCSIsArmenian",
37501: xmlMemBlocks() - mem_base);
37502: test_ret++;
37503: printf(" %d", n_code);
37504: printf("\n");
37505: }
37506: }
37507: function_tests++;
37508: #endif
37509:
37510: return(test_ret);
37511: }
37512:
37513:
37514: static int
37515: test_xmlUCSIsArrows(void) {
37516: int test_ret = 0;
37517:
37518: #if defined(LIBXML_UNICODE_ENABLED)
37519: int mem_base;
37520: int ret_val;
37521: int code; /* UCS code point */
37522: int n_code;
37523:
37524: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37525: mem_base = xmlMemBlocks();
37526: code = gen_int(n_code, 0);
37527:
37528: ret_val = xmlUCSIsArrows(code);
37529: desret_int(ret_val);
37530: call_tests++;
37531: des_int(n_code, code, 0);
37532: xmlResetLastError();
37533: if (mem_base != xmlMemBlocks()) {
37534: printf("Leak of %d blocks found in xmlUCSIsArrows",
37535: xmlMemBlocks() - mem_base);
37536: test_ret++;
37537: printf(" %d", n_code);
37538: printf("\n");
37539: }
37540: }
37541: function_tests++;
37542: #endif
37543:
37544: return(test_ret);
37545: }
37546:
37547:
37548: static int
37549: test_xmlUCSIsBasicLatin(void) {
37550: int test_ret = 0;
37551:
37552: #if defined(LIBXML_UNICODE_ENABLED)
37553: int mem_base;
37554: int ret_val;
37555: int code; /* UCS code point */
37556: int n_code;
37557:
37558: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37559: mem_base = xmlMemBlocks();
37560: code = gen_int(n_code, 0);
37561:
37562: ret_val = xmlUCSIsBasicLatin(code);
37563: desret_int(ret_val);
37564: call_tests++;
37565: des_int(n_code, code, 0);
37566: xmlResetLastError();
37567: if (mem_base != xmlMemBlocks()) {
37568: printf("Leak of %d blocks found in xmlUCSIsBasicLatin",
37569: xmlMemBlocks() - mem_base);
37570: test_ret++;
37571: printf(" %d", n_code);
37572: printf("\n");
37573: }
37574: }
37575: function_tests++;
37576: #endif
37577:
37578: return(test_ret);
37579: }
37580:
37581:
37582: static int
37583: test_xmlUCSIsBengali(void) {
37584: int test_ret = 0;
37585:
37586: #if defined(LIBXML_UNICODE_ENABLED)
37587: int mem_base;
37588: int ret_val;
37589: int code; /* UCS code point */
37590: int n_code;
37591:
37592: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37593: mem_base = xmlMemBlocks();
37594: code = gen_int(n_code, 0);
37595:
37596: ret_val = xmlUCSIsBengali(code);
37597: desret_int(ret_val);
37598: call_tests++;
37599: des_int(n_code, code, 0);
37600: xmlResetLastError();
37601: if (mem_base != xmlMemBlocks()) {
37602: printf("Leak of %d blocks found in xmlUCSIsBengali",
37603: xmlMemBlocks() - mem_base);
37604: test_ret++;
37605: printf(" %d", n_code);
37606: printf("\n");
37607: }
37608: }
37609: function_tests++;
37610: #endif
37611:
37612: return(test_ret);
37613: }
37614:
37615:
37616: static int
37617: test_xmlUCSIsBlock(void) {
37618: int test_ret = 0;
37619:
37620: #if defined(LIBXML_UNICODE_ENABLED)
37621: int mem_base;
37622: int ret_val;
37623: int code; /* UCS code point */
37624: int n_code;
37625: char * block; /* UCS block name */
37626: int n_block;
37627:
37628: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37629: for (n_block = 0;n_block < gen_nb_const_char_ptr;n_block++) {
37630: mem_base = xmlMemBlocks();
37631: code = gen_int(n_code, 0);
37632: block = gen_const_char_ptr(n_block, 1);
37633:
37634: ret_val = xmlUCSIsBlock(code, (const char *)block);
37635: desret_int(ret_val);
37636: call_tests++;
37637: des_int(n_code, code, 0);
37638: des_const_char_ptr(n_block, (const char *)block, 1);
37639: xmlResetLastError();
37640: if (mem_base != xmlMemBlocks()) {
37641: printf("Leak of %d blocks found in xmlUCSIsBlock",
37642: xmlMemBlocks() - mem_base);
37643: test_ret++;
37644: printf(" %d", n_code);
37645: printf(" %d", n_block);
37646: printf("\n");
37647: }
37648: }
37649: }
37650: function_tests++;
37651: #endif
37652:
37653: return(test_ret);
37654: }
37655:
37656:
37657: static int
37658: test_xmlUCSIsBlockElements(void) {
37659: int test_ret = 0;
37660:
37661: #if defined(LIBXML_UNICODE_ENABLED)
37662: int mem_base;
37663: int ret_val;
37664: int code; /* UCS code point */
37665: int n_code;
37666:
37667: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37668: mem_base = xmlMemBlocks();
37669: code = gen_int(n_code, 0);
37670:
37671: ret_val = xmlUCSIsBlockElements(code);
37672: desret_int(ret_val);
37673: call_tests++;
37674: des_int(n_code, code, 0);
37675: xmlResetLastError();
37676: if (mem_base != xmlMemBlocks()) {
37677: printf("Leak of %d blocks found in xmlUCSIsBlockElements",
37678: xmlMemBlocks() - mem_base);
37679: test_ret++;
37680: printf(" %d", n_code);
37681: printf("\n");
37682: }
37683: }
37684: function_tests++;
37685: #endif
37686:
37687: return(test_ret);
37688: }
37689:
37690:
37691: static int
37692: test_xmlUCSIsBopomofo(void) {
37693: int test_ret = 0;
37694:
37695: #if defined(LIBXML_UNICODE_ENABLED)
37696: int mem_base;
37697: int ret_val;
37698: int code; /* UCS code point */
37699: int n_code;
37700:
37701: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37702: mem_base = xmlMemBlocks();
37703: code = gen_int(n_code, 0);
37704:
37705: ret_val = xmlUCSIsBopomofo(code);
37706: desret_int(ret_val);
37707: call_tests++;
37708: des_int(n_code, code, 0);
37709: xmlResetLastError();
37710: if (mem_base != xmlMemBlocks()) {
37711: printf("Leak of %d blocks found in xmlUCSIsBopomofo",
37712: xmlMemBlocks() - mem_base);
37713: test_ret++;
37714: printf(" %d", n_code);
37715: printf("\n");
37716: }
37717: }
37718: function_tests++;
37719: #endif
37720:
37721: return(test_ret);
37722: }
37723:
37724:
37725: static int
37726: test_xmlUCSIsBopomofoExtended(void) {
37727: int test_ret = 0;
37728:
37729: #if defined(LIBXML_UNICODE_ENABLED)
37730: int mem_base;
37731: int ret_val;
37732: int code; /* UCS code point */
37733: int n_code;
37734:
37735: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37736: mem_base = xmlMemBlocks();
37737: code = gen_int(n_code, 0);
37738:
37739: ret_val = xmlUCSIsBopomofoExtended(code);
37740: desret_int(ret_val);
37741: call_tests++;
37742: des_int(n_code, code, 0);
37743: xmlResetLastError();
37744: if (mem_base != xmlMemBlocks()) {
37745: printf("Leak of %d blocks found in xmlUCSIsBopomofoExtended",
37746: xmlMemBlocks() - mem_base);
37747: test_ret++;
37748: printf(" %d", n_code);
37749: printf("\n");
37750: }
37751: }
37752: function_tests++;
37753: #endif
37754:
37755: return(test_ret);
37756: }
37757:
37758:
37759: static int
37760: test_xmlUCSIsBoxDrawing(void) {
37761: int test_ret = 0;
37762:
37763: #if defined(LIBXML_UNICODE_ENABLED)
37764: int mem_base;
37765: int ret_val;
37766: int code; /* UCS code point */
37767: int n_code;
37768:
37769: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37770: mem_base = xmlMemBlocks();
37771: code = gen_int(n_code, 0);
37772:
37773: ret_val = xmlUCSIsBoxDrawing(code);
37774: desret_int(ret_val);
37775: call_tests++;
37776: des_int(n_code, code, 0);
37777: xmlResetLastError();
37778: if (mem_base != xmlMemBlocks()) {
37779: printf("Leak of %d blocks found in xmlUCSIsBoxDrawing",
37780: xmlMemBlocks() - mem_base);
37781: test_ret++;
37782: printf(" %d", n_code);
37783: printf("\n");
37784: }
37785: }
37786: function_tests++;
37787: #endif
37788:
37789: return(test_ret);
37790: }
37791:
37792:
37793: static int
37794: test_xmlUCSIsBraillePatterns(void) {
37795: int test_ret = 0;
37796:
37797: #if defined(LIBXML_UNICODE_ENABLED)
37798: int mem_base;
37799: int ret_val;
37800: int code; /* UCS code point */
37801: int n_code;
37802:
37803: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37804: mem_base = xmlMemBlocks();
37805: code = gen_int(n_code, 0);
37806:
37807: ret_val = xmlUCSIsBraillePatterns(code);
37808: desret_int(ret_val);
37809: call_tests++;
37810: des_int(n_code, code, 0);
37811: xmlResetLastError();
37812: if (mem_base != xmlMemBlocks()) {
37813: printf("Leak of %d blocks found in xmlUCSIsBraillePatterns",
37814: xmlMemBlocks() - mem_base);
37815: test_ret++;
37816: printf(" %d", n_code);
37817: printf("\n");
37818: }
37819: }
37820: function_tests++;
37821: #endif
37822:
37823: return(test_ret);
37824: }
37825:
37826:
37827: static int
37828: test_xmlUCSIsBuhid(void) {
37829: int test_ret = 0;
37830:
37831: #if defined(LIBXML_UNICODE_ENABLED)
37832: int mem_base;
37833: int ret_val;
37834: int code; /* UCS code point */
37835: int n_code;
37836:
37837: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37838: mem_base = xmlMemBlocks();
37839: code = gen_int(n_code, 0);
37840:
37841: ret_val = xmlUCSIsBuhid(code);
37842: desret_int(ret_val);
37843: call_tests++;
37844: des_int(n_code, code, 0);
37845: xmlResetLastError();
37846: if (mem_base != xmlMemBlocks()) {
37847: printf("Leak of %d blocks found in xmlUCSIsBuhid",
37848: xmlMemBlocks() - mem_base);
37849: test_ret++;
37850: printf(" %d", n_code);
37851: printf("\n");
37852: }
37853: }
37854: function_tests++;
37855: #endif
37856:
37857: return(test_ret);
37858: }
37859:
37860:
37861: static int
37862: test_xmlUCSIsByzantineMusicalSymbols(void) {
37863: int test_ret = 0;
37864:
37865: #if defined(LIBXML_UNICODE_ENABLED)
37866: int mem_base;
37867: int ret_val;
37868: int code; /* UCS code point */
37869: int n_code;
37870:
37871: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37872: mem_base = xmlMemBlocks();
37873: code = gen_int(n_code, 0);
37874:
37875: ret_val = xmlUCSIsByzantineMusicalSymbols(code);
37876: desret_int(ret_val);
37877: call_tests++;
37878: des_int(n_code, code, 0);
37879: xmlResetLastError();
37880: if (mem_base != xmlMemBlocks()) {
37881: printf("Leak of %d blocks found in xmlUCSIsByzantineMusicalSymbols",
37882: xmlMemBlocks() - mem_base);
37883: test_ret++;
37884: printf(" %d", n_code);
37885: printf("\n");
37886: }
37887: }
37888: function_tests++;
37889: #endif
37890:
37891: return(test_ret);
37892: }
37893:
37894:
37895: static int
37896: test_xmlUCSIsCJKCompatibility(void) {
37897: int test_ret = 0;
37898:
37899: #if defined(LIBXML_UNICODE_ENABLED)
37900: int mem_base;
37901: int ret_val;
37902: int code; /* UCS code point */
37903: int n_code;
37904:
37905: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37906: mem_base = xmlMemBlocks();
37907: code = gen_int(n_code, 0);
37908:
37909: ret_val = xmlUCSIsCJKCompatibility(code);
37910: desret_int(ret_val);
37911: call_tests++;
37912: des_int(n_code, code, 0);
37913: xmlResetLastError();
37914: if (mem_base != xmlMemBlocks()) {
37915: printf("Leak of %d blocks found in xmlUCSIsCJKCompatibility",
37916: xmlMemBlocks() - mem_base);
37917: test_ret++;
37918: printf(" %d", n_code);
37919: printf("\n");
37920: }
37921: }
37922: function_tests++;
37923: #endif
37924:
37925: return(test_ret);
37926: }
37927:
37928:
37929: static int
37930: test_xmlUCSIsCJKCompatibilityForms(void) {
37931: int test_ret = 0;
37932:
37933: #if defined(LIBXML_UNICODE_ENABLED)
37934: int mem_base;
37935: int ret_val;
37936: int code; /* UCS code point */
37937: int n_code;
37938:
37939: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37940: mem_base = xmlMemBlocks();
37941: code = gen_int(n_code, 0);
37942:
37943: ret_val = xmlUCSIsCJKCompatibilityForms(code);
37944: desret_int(ret_val);
37945: call_tests++;
37946: des_int(n_code, code, 0);
37947: xmlResetLastError();
37948: if (mem_base != xmlMemBlocks()) {
37949: printf("Leak of %d blocks found in xmlUCSIsCJKCompatibilityForms",
37950: xmlMemBlocks() - mem_base);
37951: test_ret++;
37952: printf(" %d", n_code);
37953: printf("\n");
37954: }
37955: }
37956: function_tests++;
37957: #endif
37958:
37959: return(test_ret);
37960: }
37961:
37962:
37963: static int
37964: test_xmlUCSIsCJKCompatibilityIdeographs(void) {
37965: int test_ret = 0;
37966:
37967: #if defined(LIBXML_UNICODE_ENABLED)
37968: int mem_base;
37969: int ret_val;
37970: int code; /* UCS code point */
37971: int n_code;
37972:
37973: for (n_code = 0;n_code < gen_nb_int;n_code++) {
37974: mem_base = xmlMemBlocks();
37975: code = gen_int(n_code, 0);
37976:
37977: ret_val = xmlUCSIsCJKCompatibilityIdeographs(code);
37978: desret_int(ret_val);
37979: call_tests++;
37980: des_int(n_code, code, 0);
37981: xmlResetLastError();
37982: if (mem_base != xmlMemBlocks()) {
37983: printf("Leak of %d blocks found in xmlUCSIsCJKCompatibilityIdeographs",
37984: xmlMemBlocks() - mem_base);
37985: test_ret++;
37986: printf(" %d", n_code);
37987: printf("\n");
37988: }
37989: }
37990: function_tests++;
37991: #endif
37992:
37993: return(test_ret);
37994: }
37995:
37996:
37997: static int
37998: test_xmlUCSIsCJKCompatibilityIdeographsSupplement(void) {
37999: int test_ret = 0;
38000:
38001: #if defined(LIBXML_UNICODE_ENABLED)
38002: int mem_base;
38003: int ret_val;
38004: int code; /* UCS code point */
38005: int n_code;
38006:
38007: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38008: mem_base = xmlMemBlocks();
38009: code = gen_int(n_code, 0);
38010:
38011: ret_val = xmlUCSIsCJKCompatibilityIdeographsSupplement(code);
38012: desret_int(ret_val);
38013: call_tests++;
38014: des_int(n_code, code, 0);
38015: xmlResetLastError();
38016: if (mem_base != xmlMemBlocks()) {
38017: printf("Leak of %d blocks found in xmlUCSIsCJKCompatibilityIdeographsSupplement",
38018: xmlMemBlocks() - mem_base);
38019: test_ret++;
38020: printf(" %d", n_code);
38021: printf("\n");
38022: }
38023: }
38024: function_tests++;
38025: #endif
38026:
38027: return(test_ret);
38028: }
38029:
38030:
38031: static int
38032: test_xmlUCSIsCJKRadicalsSupplement(void) {
38033: int test_ret = 0;
38034:
38035: #if defined(LIBXML_UNICODE_ENABLED)
38036: int mem_base;
38037: int ret_val;
38038: int code; /* UCS code point */
38039: int n_code;
38040:
38041: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38042: mem_base = xmlMemBlocks();
38043: code = gen_int(n_code, 0);
38044:
38045: ret_val = xmlUCSIsCJKRadicalsSupplement(code);
38046: desret_int(ret_val);
38047: call_tests++;
38048: des_int(n_code, code, 0);
38049: xmlResetLastError();
38050: if (mem_base != xmlMemBlocks()) {
38051: printf("Leak of %d blocks found in xmlUCSIsCJKRadicalsSupplement",
38052: xmlMemBlocks() - mem_base);
38053: test_ret++;
38054: printf(" %d", n_code);
38055: printf("\n");
38056: }
38057: }
38058: function_tests++;
38059: #endif
38060:
38061: return(test_ret);
38062: }
38063:
38064:
38065: static int
38066: test_xmlUCSIsCJKSymbolsandPunctuation(void) {
38067: int test_ret = 0;
38068:
38069: #if defined(LIBXML_UNICODE_ENABLED)
38070: int mem_base;
38071: int ret_val;
38072: int code; /* UCS code point */
38073: int n_code;
38074:
38075: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38076: mem_base = xmlMemBlocks();
38077: code = gen_int(n_code, 0);
38078:
38079: ret_val = xmlUCSIsCJKSymbolsandPunctuation(code);
38080: desret_int(ret_val);
38081: call_tests++;
38082: des_int(n_code, code, 0);
38083: xmlResetLastError();
38084: if (mem_base != xmlMemBlocks()) {
38085: printf("Leak of %d blocks found in xmlUCSIsCJKSymbolsandPunctuation",
38086: xmlMemBlocks() - mem_base);
38087: test_ret++;
38088: printf(" %d", n_code);
38089: printf("\n");
38090: }
38091: }
38092: function_tests++;
38093: #endif
38094:
38095: return(test_ret);
38096: }
38097:
38098:
38099: static int
38100: test_xmlUCSIsCJKUnifiedIdeographs(void) {
38101: int test_ret = 0;
38102:
38103: #if defined(LIBXML_UNICODE_ENABLED)
38104: int mem_base;
38105: int ret_val;
38106: int code; /* UCS code point */
38107: int n_code;
38108:
38109: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38110: mem_base = xmlMemBlocks();
38111: code = gen_int(n_code, 0);
38112:
38113: ret_val = xmlUCSIsCJKUnifiedIdeographs(code);
38114: desret_int(ret_val);
38115: call_tests++;
38116: des_int(n_code, code, 0);
38117: xmlResetLastError();
38118: if (mem_base != xmlMemBlocks()) {
38119: printf("Leak of %d blocks found in xmlUCSIsCJKUnifiedIdeographs",
38120: xmlMemBlocks() - mem_base);
38121: test_ret++;
38122: printf(" %d", n_code);
38123: printf("\n");
38124: }
38125: }
38126: function_tests++;
38127: #endif
38128:
38129: return(test_ret);
38130: }
38131:
38132:
38133: static int
38134: test_xmlUCSIsCJKUnifiedIdeographsExtensionA(void) {
38135: int test_ret = 0;
38136:
38137: #if defined(LIBXML_UNICODE_ENABLED)
38138: int mem_base;
38139: int ret_val;
38140: int code; /* UCS code point */
38141: int n_code;
38142:
38143: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38144: mem_base = xmlMemBlocks();
38145: code = gen_int(n_code, 0);
38146:
38147: ret_val = xmlUCSIsCJKUnifiedIdeographsExtensionA(code);
38148: desret_int(ret_val);
38149: call_tests++;
38150: des_int(n_code, code, 0);
38151: xmlResetLastError();
38152: if (mem_base != xmlMemBlocks()) {
38153: printf("Leak of %d blocks found in xmlUCSIsCJKUnifiedIdeographsExtensionA",
38154: xmlMemBlocks() - mem_base);
38155: test_ret++;
38156: printf(" %d", n_code);
38157: printf("\n");
38158: }
38159: }
38160: function_tests++;
38161: #endif
38162:
38163: return(test_ret);
38164: }
38165:
38166:
38167: static int
38168: test_xmlUCSIsCJKUnifiedIdeographsExtensionB(void) {
38169: int test_ret = 0;
38170:
38171: #if defined(LIBXML_UNICODE_ENABLED)
38172: int mem_base;
38173: int ret_val;
38174: int code; /* UCS code point */
38175: int n_code;
38176:
38177: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38178: mem_base = xmlMemBlocks();
38179: code = gen_int(n_code, 0);
38180:
38181: ret_val = xmlUCSIsCJKUnifiedIdeographsExtensionB(code);
38182: desret_int(ret_val);
38183: call_tests++;
38184: des_int(n_code, code, 0);
38185: xmlResetLastError();
38186: if (mem_base != xmlMemBlocks()) {
38187: printf("Leak of %d blocks found in xmlUCSIsCJKUnifiedIdeographsExtensionB",
38188: xmlMemBlocks() - mem_base);
38189: test_ret++;
38190: printf(" %d", n_code);
38191: printf("\n");
38192: }
38193: }
38194: function_tests++;
38195: #endif
38196:
38197: return(test_ret);
38198: }
38199:
38200:
38201: static int
38202: test_xmlUCSIsCat(void) {
38203: int test_ret = 0;
38204:
38205: #if defined(LIBXML_UNICODE_ENABLED)
38206: int mem_base;
38207: int ret_val;
38208: int code; /* UCS code point */
38209: int n_code;
38210: char * cat; /* UCS Category name */
38211: int n_cat;
38212:
38213: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38214: for (n_cat = 0;n_cat < gen_nb_const_char_ptr;n_cat++) {
38215: mem_base = xmlMemBlocks();
38216: code = gen_int(n_code, 0);
38217: cat = gen_const_char_ptr(n_cat, 1);
38218:
38219: ret_val = xmlUCSIsCat(code, (const char *)cat);
38220: desret_int(ret_val);
38221: call_tests++;
38222: des_int(n_code, code, 0);
38223: des_const_char_ptr(n_cat, (const char *)cat, 1);
38224: xmlResetLastError();
38225: if (mem_base != xmlMemBlocks()) {
38226: printf("Leak of %d blocks found in xmlUCSIsCat",
38227: xmlMemBlocks() - mem_base);
38228: test_ret++;
38229: printf(" %d", n_code);
38230: printf(" %d", n_cat);
38231: printf("\n");
38232: }
38233: }
38234: }
38235: function_tests++;
38236: #endif
38237:
38238: return(test_ret);
38239: }
38240:
38241:
38242: static int
38243: test_xmlUCSIsCatC(void) {
38244: int test_ret = 0;
38245:
38246: #if defined(LIBXML_UNICODE_ENABLED)
38247: int mem_base;
38248: int ret_val;
38249: int code; /* UCS code point */
38250: int n_code;
38251:
38252: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38253: mem_base = xmlMemBlocks();
38254: code = gen_int(n_code, 0);
38255:
38256: ret_val = xmlUCSIsCatC(code);
38257: desret_int(ret_val);
38258: call_tests++;
38259: des_int(n_code, code, 0);
38260: xmlResetLastError();
38261: if (mem_base != xmlMemBlocks()) {
38262: printf("Leak of %d blocks found in xmlUCSIsCatC",
38263: xmlMemBlocks() - mem_base);
38264: test_ret++;
38265: printf(" %d", n_code);
38266: printf("\n");
38267: }
38268: }
38269: function_tests++;
38270: #endif
38271:
38272: return(test_ret);
38273: }
38274:
38275:
38276: static int
38277: test_xmlUCSIsCatCc(void) {
38278: int test_ret = 0;
38279:
38280: #if defined(LIBXML_UNICODE_ENABLED)
38281: int mem_base;
38282: int ret_val;
38283: int code; /* UCS code point */
38284: int n_code;
38285:
38286: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38287: mem_base = xmlMemBlocks();
38288: code = gen_int(n_code, 0);
38289:
38290: ret_val = xmlUCSIsCatCc(code);
38291: desret_int(ret_val);
38292: call_tests++;
38293: des_int(n_code, code, 0);
38294: xmlResetLastError();
38295: if (mem_base != xmlMemBlocks()) {
38296: printf("Leak of %d blocks found in xmlUCSIsCatCc",
38297: xmlMemBlocks() - mem_base);
38298: test_ret++;
38299: printf(" %d", n_code);
38300: printf("\n");
38301: }
38302: }
38303: function_tests++;
38304: #endif
38305:
38306: return(test_ret);
38307: }
38308:
38309:
38310: static int
38311: test_xmlUCSIsCatCf(void) {
38312: int test_ret = 0;
38313:
38314: #if defined(LIBXML_UNICODE_ENABLED)
38315: int mem_base;
38316: int ret_val;
38317: int code; /* UCS code point */
38318: int n_code;
38319:
38320: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38321: mem_base = xmlMemBlocks();
38322: code = gen_int(n_code, 0);
38323:
38324: ret_val = xmlUCSIsCatCf(code);
38325: desret_int(ret_val);
38326: call_tests++;
38327: des_int(n_code, code, 0);
38328: xmlResetLastError();
38329: if (mem_base != xmlMemBlocks()) {
38330: printf("Leak of %d blocks found in xmlUCSIsCatCf",
38331: xmlMemBlocks() - mem_base);
38332: test_ret++;
38333: printf(" %d", n_code);
38334: printf("\n");
38335: }
38336: }
38337: function_tests++;
38338: #endif
38339:
38340: return(test_ret);
38341: }
38342:
38343:
38344: static int
38345: test_xmlUCSIsCatCo(void) {
38346: int test_ret = 0;
38347:
38348: #if defined(LIBXML_UNICODE_ENABLED)
38349: int mem_base;
38350: int ret_val;
38351: int code; /* UCS code point */
38352: int n_code;
38353:
38354: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38355: mem_base = xmlMemBlocks();
38356: code = gen_int(n_code, 0);
38357:
38358: ret_val = xmlUCSIsCatCo(code);
38359: desret_int(ret_val);
38360: call_tests++;
38361: des_int(n_code, code, 0);
38362: xmlResetLastError();
38363: if (mem_base != xmlMemBlocks()) {
38364: printf("Leak of %d blocks found in xmlUCSIsCatCo",
38365: xmlMemBlocks() - mem_base);
38366: test_ret++;
38367: printf(" %d", n_code);
38368: printf("\n");
38369: }
38370: }
38371: function_tests++;
38372: #endif
38373:
38374: return(test_ret);
38375: }
38376:
38377:
38378: static int
38379: test_xmlUCSIsCatCs(void) {
38380: int test_ret = 0;
38381:
38382: #if defined(LIBXML_UNICODE_ENABLED)
38383: int mem_base;
38384: int ret_val;
38385: int code; /* UCS code point */
38386: int n_code;
38387:
38388: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38389: mem_base = xmlMemBlocks();
38390: code = gen_int(n_code, 0);
38391:
38392: ret_val = xmlUCSIsCatCs(code);
38393: desret_int(ret_val);
38394: call_tests++;
38395: des_int(n_code, code, 0);
38396: xmlResetLastError();
38397: if (mem_base != xmlMemBlocks()) {
38398: printf("Leak of %d blocks found in xmlUCSIsCatCs",
38399: xmlMemBlocks() - mem_base);
38400: test_ret++;
38401: printf(" %d", n_code);
38402: printf("\n");
38403: }
38404: }
38405: function_tests++;
38406: #endif
38407:
38408: return(test_ret);
38409: }
38410:
38411:
38412: static int
38413: test_xmlUCSIsCatL(void) {
38414: int test_ret = 0;
38415:
38416: #if defined(LIBXML_UNICODE_ENABLED)
38417: int mem_base;
38418: int ret_val;
38419: int code; /* UCS code point */
38420: int n_code;
38421:
38422: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38423: mem_base = xmlMemBlocks();
38424: code = gen_int(n_code, 0);
38425:
38426: ret_val = xmlUCSIsCatL(code);
38427: desret_int(ret_val);
38428: call_tests++;
38429: des_int(n_code, code, 0);
38430: xmlResetLastError();
38431: if (mem_base != xmlMemBlocks()) {
38432: printf("Leak of %d blocks found in xmlUCSIsCatL",
38433: xmlMemBlocks() - mem_base);
38434: test_ret++;
38435: printf(" %d", n_code);
38436: printf("\n");
38437: }
38438: }
38439: function_tests++;
38440: #endif
38441:
38442: return(test_ret);
38443: }
38444:
38445:
38446: static int
38447: test_xmlUCSIsCatLl(void) {
38448: int test_ret = 0;
38449:
38450: #if defined(LIBXML_UNICODE_ENABLED)
38451: int mem_base;
38452: int ret_val;
38453: int code; /* UCS code point */
38454: int n_code;
38455:
38456: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38457: mem_base = xmlMemBlocks();
38458: code = gen_int(n_code, 0);
38459:
38460: ret_val = xmlUCSIsCatLl(code);
38461: desret_int(ret_val);
38462: call_tests++;
38463: des_int(n_code, code, 0);
38464: xmlResetLastError();
38465: if (mem_base != xmlMemBlocks()) {
38466: printf("Leak of %d blocks found in xmlUCSIsCatLl",
38467: xmlMemBlocks() - mem_base);
38468: test_ret++;
38469: printf(" %d", n_code);
38470: printf("\n");
38471: }
38472: }
38473: function_tests++;
38474: #endif
38475:
38476: return(test_ret);
38477: }
38478:
38479:
38480: static int
38481: test_xmlUCSIsCatLm(void) {
38482: int test_ret = 0;
38483:
38484: #if defined(LIBXML_UNICODE_ENABLED)
38485: int mem_base;
38486: int ret_val;
38487: int code; /* UCS code point */
38488: int n_code;
38489:
38490: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38491: mem_base = xmlMemBlocks();
38492: code = gen_int(n_code, 0);
38493:
38494: ret_val = xmlUCSIsCatLm(code);
38495: desret_int(ret_val);
38496: call_tests++;
38497: des_int(n_code, code, 0);
38498: xmlResetLastError();
38499: if (mem_base != xmlMemBlocks()) {
38500: printf("Leak of %d blocks found in xmlUCSIsCatLm",
38501: xmlMemBlocks() - mem_base);
38502: test_ret++;
38503: printf(" %d", n_code);
38504: printf("\n");
38505: }
38506: }
38507: function_tests++;
38508: #endif
38509:
38510: return(test_ret);
38511: }
38512:
38513:
38514: static int
38515: test_xmlUCSIsCatLo(void) {
38516: int test_ret = 0;
38517:
38518: #if defined(LIBXML_UNICODE_ENABLED)
38519: int mem_base;
38520: int ret_val;
38521: int code; /* UCS code point */
38522: int n_code;
38523:
38524: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38525: mem_base = xmlMemBlocks();
38526: code = gen_int(n_code, 0);
38527:
38528: ret_val = xmlUCSIsCatLo(code);
38529: desret_int(ret_val);
38530: call_tests++;
38531: des_int(n_code, code, 0);
38532: xmlResetLastError();
38533: if (mem_base != xmlMemBlocks()) {
38534: printf("Leak of %d blocks found in xmlUCSIsCatLo",
38535: xmlMemBlocks() - mem_base);
38536: test_ret++;
38537: printf(" %d", n_code);
38538: printf("\n");
38539: }
38540: }
38541: function_tests++;
38542: #endif
38543:
38544: return(test_ret);
38545: }
38546:
38547:
38548: static int
38549: test_xmlUCSIsCatLt(void) {
38550: int test_ret = 0;
38551:
38552: #if defined(LIBXML_UNICODE_ENABLED)
38553: int mem_base;
38554: int ret_val;
38555: int code; /* UCS code point */
38556: int n_code;
38557:
38558: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38559: mem_base = xmlMemBlocks();
38560: code = gen_int(n_code, 0);
38561:
38562: ret_val = xmlUCSIsCatLt(code);
38563: desret_int(ret_val);
38564: call_tests++;
38565: des_int(n_code, code, 0);
38566: xmlResetLastError();
38567: if (mem_base != xmlMemBlocks()) {
38568: printf("Leak of %d blocks found in xmlUCSIsCatLt",
38569: xmlMemBlocks() - mem_base);
38570: test_ret++;
38571: printf(" %d", n_code);
38572: printf("\n");
38573: }
38574: }
38575: function_tests++;
38576: #endif
38577:
38578: return(test_ret);
38579: }
38580:
38581:
38582: static int
38583: test_xmlUCSIsCatLu(void) {
38584: int test_ret = 0;
38585:
38586: #if defined(LIBXML_UNICODE_ENABLED)
38587: int mem_base;
38588: int ret_val;
38589: int code; /* UCS code point */
38590: int n_code;
38591:
38592: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38593: mem_base = xmlMemBlocks();
38594: code = gen_int(n_code, 0);
38595:
38596: ret_val = xmlUCSIsCatLu(code);
38597: desret_int(ret_val);
38598: call_tests++;
38599: des_int(n_code, code, 0);
38600: xmlResetLastError();
38601: if (mem_base != xmlMemBlocks()) {
38602: printf("Leak of %d blocks found in xmlUCSIsCatLu",
38603: xmlMemBlocks() - mem_base);
38604: test_ret++;
38605: printf(" %d", n_code);
38606: printf("\n");
38607: }
38608: }
38609: function_tests++;
38610: #endif
38611:
38612: return(test_ret);
38613: }
38614:
38615:
38616: static int
38617: test_xmlUCSIsCatM(void) {
38618: int test_ret = 0;
38619:
38620: #if defined(LIBXML_UNICODE_ENABLED)
38621: int mem_base;
38622: int ret_val;
38623: int code; /* UCS code point */
38624: int n_code;
38625:
38626: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38627: mem_base = xmlMemBlocks();
38628: code = gen_int(n_code, 0);
38629:
38630: ret_val = xmlUCSIsCatM(code);
38631: desret_int(ret_val);
38632: call_tests++;
38633: des_int(n_code, code, 0);
38634: xmlResetLastError();
38635: if (mem_base != xmlMemBlocks()) {
38636: printf("Leak of %d blocks found in xmlUCSIsCatM",
38637: xmlMemBlocks() - mem_base);
38638: test_ret++;
38639: printf(" %d", n_code);
38640: printf("\n");
38641: }
38642: }
38643: function_tests++;
38644: #endif
38645:
38646: return(test_ret);
38647: }
38648:
38649:
38650: static int
38651: test_xmlUCSIsCatMc(void) {
38652: int test_ret = 0;
38653:
38654: #if defined(LIBXML_UNICODE_ENABLED)
38655: int mem_base;
38656: int ret_val;
38657: int code; /* UCS code point */
38658: int n_code;
38659:
38660: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38661: mem_base = xmlMemBlocks();
38662: code = gen_int(n_code, 0);
38663:
38664: ret_val = xmlUCSIsCatMc(code);
38665: desret_int(ret_val);
38666: call_tests++;
38667: des_int(n_code, code, 0);
38668: xmlResetLastError();
38669: if (mem_base != xmlMemBlocks()) {
38670: printf("Leak of %d blocks found in xmlUCSIsCatMc",
38671: xmlMemBlocks() - mem_base);
38672: test_ret++;
38673: printf(" %d", n_code);
38674: printf("\n");
38675: }
38676: }
38677: function_tests++;
38678: #endif
38679:
38680: return(test_ret);
38681: }
38682:
38683:
38684: static int
38685: test_xmlUCSIsCatMe(void) {
38686: int test_ret = 0;
38687:
38688: #if defined(LIBXML_UNICODE_ENABLED)
38689: int mem_base;
38690: int ret_val;
38691: int code; /* UCS code point */
38692: int n_code;
38693:
38694: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38695: mem_base = xmlMemBlocks();
38696: code = gen_int(n_code, 0);
38697:
38698: ret_val = xmlUCSIsCatMe(code);
38699: desret_int(ret_val);
38700: call_tests++;
38701: des_int(n_code, code, 0);
38702: xmlResetLastError();
38703: if (mem_base != xmlMemBlocks()) {
38704: printf("Leak of %d blocks found in xmlUCSIsCatMe",
38705: xmlMemBlocks() - mem_base);
38706: test_ret++;
38707: printf(" %d", n_code);
38708: printf("\n");
38709: }
38710: }
38711: function_tests++;
38712: #endif
38713:
38714: return(test_ret);
38715: }
38716:
38717:
38718: static int
38719: test_xmlUCSIsCatMn(void) {
38720: int test_ret = 0;
38721:
38722: #if defined(LIBXML_UNICODE_ENABLED)
38723: int mem_base;
38724: int ret_val;
38725: int code; /* UCS code point */
38726: int n_code;
38727:
38728: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38729: mem_base = xmlMemBlocks();
38730: code = gen_int(n_code, 0);
38731:
38732: ret_val = xmlUCSIsCatMn(code);
38733: desret_int(ret_val);
38734: call_tests++;
38735: des_int(n_code, code, 0);
38736: xmlResetLastError();
38737: if (mem_base != xmlMemBlocks()) {
38738: printf("Leak of %d blocks found in xmlUCSIsCatMn",
38739: xmlMemBlocks() - mem_base);
38740: test_ret++;
38741: printf(" %d", n_code);
38742: printf("\n");
38743: }
38744: }
38745: function_tests++;
38746: #endif
38747:
38748: return(test_ret);
38749: }
38750:
38751:
38752: static int
38753: test_xmlUCSIsCatN(void) {
38754: int test_ret = 0;
38755:
38756: #if defined(LIBXML_UNICODE_ENABLED)
38757: int mem_base;
38758: int ret_val;
38759: int code; /* UCS code point */
38760: int n_code;
38761:
38762: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38763: mem_base = xmlMemBlocks();
38764: code = gen_int(n_code, 0);
38765:
38766: ret_val = xmlUCSIsCatN(code);
38767: desret_int(ret_val);
38768: call_tests++;
38769: des_int(n_code, code, 0);
38770: xmlResetLastError();
38771: if (mem_base != xmlMemBlocks()) {
38772: printf("Leak of %d blocks found in xmlUCSIsCatN",
38773: xmlMemBlocks() - mem_base);
38774: test_ret++;
38775: printf(" %d", n_code);
38776: printf("\n");
38777: }
38778: }
38779: function_tests++;
38780: #endif
38781:
38782: return(test_ret);
38783: }
38784:
38785:
38786: static int
38787: test_xmlUCSIsCatNd(void) {
38788: int test_ret = 0;
38789:
38790: #if defined(LIBXML_UNICODE_ENABLED)
38791: int mem_base;
38792: int ret_val;
38793: int code; /* UCS code point */
38794: int n_code;
38795:
38796: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38797: mem_base = xmlMemBlocks();
38798: code = gen_int(n_code, 0);
38799:
38800: ret_val = xmlUCSIsCatNd(code);
38801: desret_int(ret_val);
38802: call_tests++;
38803: des_int(n_code, code, 0);
38804: xmlResetLastError();
38805: if (mem_base != xmlMemBlocks()) {
38806: printf("Leak of %d blocks found in xmlUCSIsCatNd",
38807: xmlMemBlocks() - mem_base);
38808: test_ret++;
38809: printf(" %d", n_code);
38810: printf("\n");
38811: }
38812: }
38813: function_tests++;
38814: #endif
38815:
38816: return(test_ret);
38817: }
38818:
38819:
38820: static int
38821: test_xmlUCSIsCatNl(void) {
38822: int test_ret = 0;
38823:
38824: #if defined(LIBXML_UNICODE_ENABLED)
38825: int mem_base;
38826: int ret_val;
38827: int code; /* UCS code point */
38828: int n_code;
38829:
38830: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38831: mem_base = xmlMemBlocks();
38832: code = gen_int(n_code, 0);
38833:
38834: ret_val = xmlUCSIsCatNl(code);
38835: desret_int(ret_val);
38836: call_tests++;
38837: des_int(n_code, code, 0);
38838: xmlResetLastError();
38839: if (mem_base != xmlMemBlocks()) {
38840: printf("Leak of %d blocks found in xmlUCSIsCatNl",
38841: xmlMemBlocks() - mem_base);
38842: test_ret++;
38843: printf(" %d", n_code);
38844: printf("\n");
38845: }
38846: }
38847: function_tests++;
38848: #endif
38849:
38850: return(test_ret);
38851: }
38852:
38853:
38854: static int
38855: test_xmlUCSIsCatNo(void) {
38856: int test_ret = 0;
38857:
38858: #if defined(LIBXML_UNICODE_ENABLED)
38859: int mem_base;
38860: int ret_val;
38861: int code; /* UCS code point */
38862: int n_code;
38863:
38864: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38865: mem_base = xmlMemBlocks();
38866: code = gen_int(n_code, 0);
38867:
38868: ret_val = xmlUCSIsCatNo(code);
38869: desret_int(ret_val);
38870: call_tests++;
38871: des_int(n_code, code, 0);
38872: xmlResetLastError();
38873: if (mem_base != xmlMemBlocks()) {
38874: printf("Leak of %d blocks found in xmlUCSIsCatNo",
38875: xmlMemBlocks() - mem_base);
38876: test_ret++;
38877: printf(" %d", n_code);
38878: printf("\n");
38879: }
38880: }
38881: function_tests++;
38882: #endif
38883:
38884: return(test_ret);
38885: }
38886:
38887:
38888: static int
38889: test_xmlUCSIsCatP(void) {
38890: int test_ret = 0;
38891:
38892: #if defined(LIBXML_UNICODE_ENABLED)
38893: int mem_base;
38894: int ret_val;
38895: int code; /* UCS code point */
38896: int n_code;
38897:
38898: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38899: mem_base = xmlMemBlocks();
38900: code = gen_int(n_code, 0);
38901:
38902: ret_val = xmlUCSIsCatP(code);
38903: desret_int(ret_val);
38904: call_tests++;
38905: des_int(n_code, code, 0);
38906: xmlResetLastError();
38907: if (mem_base != xmlMemBlocks()) {
38908: printf("Leak of %d blocks found in xmlUCSIsCatP",
38909: xmlMemBlocks() - mem_base);
38910: test_ret++;
38911: printf(" %d", n_code);
38912: printf("\n");
38913: }
38914: }
38915: function_tests++;
38916: #endif
38917:
38918: return(test_ret);
38919: }
38920:
38921:
38922: static int
38923: test_xmlUCSIsCatPc(void) {
38924: int test_ret = 0;
38925:
38926: #if defined(LIBXML_UNICODE_ENABLED)
38927: int mem_base;
38928: int ret_val;
38929: int code; /* UCS code point */
38930: int n_code;
38931:
38932: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38933: mem_base = xmlMemBlocks();
38934: code = gen_int(n_code, 0);
38935:
38936: ret_val = xmlUCSIsCatPc(code);
38937: desret_int(ret_val);
38938: call_tests++;
38939: des_int(n_code, code, 0);
38940: xmlResetLastError();
38941: if (mem_base != xmlMemBlocks()) {
38942: printf("Leak of %d blocks found in xmlUCSIsCatPc",
38943: xmlMemBlocks() - mem_base);
38944: test_ret++;
38945: printf(" %d", n_code);
38946: printf("\n");
38947: }
38948: }
38949: function_tests++;
38950: #endif
38951:
38952: return(test_ret);
38953: }
38954:
38955:
38956: static int
38957: test_xmlUCSIsCatPd(void) {
38958: int test_ret = 0;
38959:
38960: #if defined(LIBXML_UNICODE_ENABLED)
38961: int mem_base;
38962: int ret_val;
38963: int code; /* UCS code point */
38964: int n_code;
38965:
38966: for (n_code = 0;n_code < gen_nb_int;n_code++) {
38967: mem_base = xmlMemBlocks();
38968: code = gen_int(n_code, 0);
38969:
38970: ret_val = xmlUCSIsCatPd(code);
38971: desret_int(ret_val);
38972: call_tests++;
38973: des_int(n_code, code, 0);
38974: xmlResetLastError();
38975: if (mem_base != xmlMemBlocks()) {
38976: printf("Leak of %d blocks found in xmlUCSIsCatPd",
38977: xmlMemBlocks() - mem_base);
38978: test_ret++;
38979: printf(" %d", n_code);
38980: printf("\n");
38981: }
38982: }
38983: function_tests++;
38984: #endif
38985:
38986: return(test_ret);
38987: }
38988:
38989:
38990: static int
38991: test_xmlUCSIsCatPe(void) {
38992: int test_ret = 0;
38993:
38994: #if defined(LIBXML_UNICODE_ENABLED)
38995: int mem_base;
38996: int ret_val;
38997: int code; /* UCS code point */
38998: int n_code;
38999:
39000: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39001: mem_base = xmlMemBlocks();
39002: code = gen_int(n_code, 0);
39003:
39004: ret_val = xmlUCSIsCatPe(code);
39005: desret_int(ret_val);
39006: call_tests++;
39007: des_int(n_code, code, 0);
39008: xmlResetLastError();
39009: if (mem_base != xmlMemBlocks()) {
39010: printf("Leak of %d blocks found in xmlUCSIsCatPe",
39011: xmlMemBlocks() - mem_base);
39012: test_ret++;
39013: printf(" %d", n_code);
39014: printf("\n");
39015: }
39016: }
39017: function_tests++;
39018: #endif
39019:
39020: return(test_ret);
39021: }
39022:
39023:
39024: static int
39025: test_xmlUCSIsCatPf(void) {
39026: int test_ret = 0;
39027:
39028: #if defined(LIBXML_UNICODE_ENABLED)
39029: int mem_base;
39030: int ret_val;
39031: int code; /* UCS code point */
39032: int n_code;
39033:
39034: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39035: mem_base = xmlMemBlocks();
39036: code = gen_int(n_code, 0);
39037:
39038: ret_val = xmlUCSIsCatPf(code);
39039: desret_int(ret_val);
39040: call_tests++;
39041: des_int(n_code, code, 0);
39042: xmlResetLastError();
39043: if (mem_base != xmlMemBlocks()) {
39044: printf("Leak of %d blocks found in xmlUCSIsCatPf",
39045: xmlMemBlocks() - mem_base);
39046: test_ret++;
39047: printf(" %d", n_code);
39048: printf("\n");
39049: }
39050: }
39051: function_tests++;
39052: #endif
39053:
39054: return(test_ret);
39055: }
39056:
39057:
39058: static int
39059: test_xmlUCSIsCatPi(void) {
39060: int test_ret = 0;
39061:
39062: #if defined(LIBXML_UNICODE_ENABLED)
39063: int mem_base;
39064: int ret_val;
39065: int code; /* UCS code point */
39066: int n_code;
39067:
39068: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39069: mem_base = xmlMemBlocks();
39070: code = gen_int(n_code, 0);
39071:
39072: ret_val = xmlUCSIsCatPi(code);
39073: desret_int(ret_val);
39074: call_tests++;
39075: des_int(n_code, code, 0);
39076: xmlResetLastError();
39077: if (mem_base != xmlMemBlocks()) {
39078: printf("Leak of %d blocks found in xmlUCSIsCatPi",
39079: xmlMemBlocks() - mem_base);
39080: test_ret++;
39081: printf(" %d", n_code);
39082: printf("\n");
39083: }
39084: }
39085: function_tests++;
39086: #endif
39087:
39088: return(test_ret);
39089: }
39090:
39091:
39092: static int
39093: test_xmlUCSIsCatPo(void) {
39094: int test_ret = 0;
39095:
39096: #if defined(LIBXML_UNICODE_ENABLED)
39097: int mem_base;
39098: int ret_val;
39099: int code; /* UCS code point */
39100: int n_code;
39101:
39102: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39103: mem_base = xmlMemBlocks();
39104: code = gen_int(n_code, 0);
39105:
39106: ret_val = xmlUCSIsCatPo(code);
39107: desret_int(ret_val);
39108: call_tests++;
39109: des_int(n_code, code, 0);
39110: xmlResetLastError();
39111: if (mem_base != xmlMemBlocks()) {
39112: printf("Leak of %d blocks found in xmlUCSIsCatPo",
39113: xmlMemBlocks() - mem_base);
39114: test_ret++;
39115: printf(" %d", n_code);
39116: printf("\n");
39117: }
39118: }
39119: function_tests++;
39120: #endif
39121:
39122: return(test_ret);
39123: }
39124:
39125:
39126: static int
39127: test_xmlUCSIsCatPs(void) {
39128: int test_ret = 0;
39129:
39130: #if defined(LIBXML_UNICODE_ENABLED)
39131: int mem_base;
39132: int ret_val;
39133: int code; /* UCS code point */
39134: int n_code;
39135:
39136: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39137: mem_base = xmlMemBlocks();
39138: code = gen_int(n_code, 0);
39139:
39140: ret_val = xmlUCSIsCatPs(code);
39141: desret_int(ret_val);
39142: call_tests++;
39143: des_int(n_code, code, 0);
39144: xmlResetLastError();
39145: if (mem_base != xmlMemBlocks()) {
39146: printf("Leak of %d blocks found in xmlUCSIsCatPs",
39147: xmlMemBlocks() - mem_base);
39148: test_ret++;
39149: printf(" %d", n_code);
39150: printf("\n");
39151: }
39152: }
39153: function_tests++;
39154: #endif
39155:
39156: return(test_ret);
39157: }
39158:
39159:
39160: static int
39161: test_xmlUCSIsCatS(void) {
39162: int test_ret = 0;
39163:
39164: #if defined(LIBXML_UNICODE_ENABLED)
39165: int mem_base;
39166: int ret_val;
39167: int code; /* UCS code point */
39168: int n_code;
39169:
39170: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39171: mem_base = xmlMemBlocks();
39172: code = gen_int(n_code, 0);
39173:
39174: ret_val = xmlUCSIsCatS(code);
39175: desret_int(ret_val);
39176: call_tests++;
39177: des_int(n_code, code, 0);
39178: xmlResetLastError();
39179: if (mem_base != xmlMemBlocks()) {
39180: printf("Leak of %d blocks found in xmlUCSIsCatS",
39181: xmlMemBlocks() - mem_base);
39182: test_ret++;
39183: printf(" %d", n_code);
39184: printf("\n");
39185: }
39186: }
39187: function_tests++;
39188: #endif
39189:
39190: return(test_ret);
39191: }
39192:
39193:
39194: static int
39195: test_xmlUCSIsCatSc(void) {
39196: int test_ret = 0;
39197:
39198: #if defined(LIBXML_UNICODE_ENABLED)
39199: int mem_base;
39200: int ret_val;
39201: int code; /* UCS code point */
39202: int n_code;
39203:
39204: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39205: mem_base = xmlMemBlocks();
39206: code = gen_int(n_code, 0);
39207:
39208: ret_val = xmlUCSIsCatSc(code);
39209: desret_int(ret_val);
39210: call_tests++;
39211: des_int(n_code, code, 0);
39212: xmlResetLastError();
39213: if (mem_base != xmlMemBlocks()) {
39214: printf("Leak of %d blocks found in xmlUCSIsCatSc",
39215: xmlMemBlocks() - mem_base);
39216: test_ret++;
39217: printf(" %d", n_code);
39218: printf("\n");
39219: }
39220: }
39221: function_tests++;
39222: #endif
39223:
39224: return(test_ret);
39225: }
39226:
39227:
39228: static int
39229: test_xmlUCSIsCatSk(void) {
39230: int test_ret = 0;
39231:
39232: #if defined(LIBXML_UNICODE_ENABLED)
39233: int mem_base;
39234: int ret_val;
39235: int code; /* UCS code point */
39236: int n_code;
39237:
39238: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39239: mem_base = xmlMemBlocks();
39240: code = gen_int(n_code, 0);
39241:
39242: ret_val = xmlUCSIsCatSk(code);
39243: desret_int(ret_val);
39244: call_tests++;
39245: des_int(n_code, code, 0);
39246: xmlResetLastError();
39247: if (mem_base != xmlMemBlocks()) {
39248: printf("Leak of %d blocks found in xmlUCSIsCatSk",
39249: xmlMemBlocks() - mem_base);
39250: test_ret++;
39251: printf(" %d", n_code);
39252: printf("\n");
39253: }
39254: }
39255: function_tests++;
39256: #endif
39257:
39258: return(test_ret);
39259: }
39260:
39261:
39262: static int
39263: test_xmlUCSIsCatSm(void) {
39264: int test_ret = 0;
39265:
39266: #if defined(LIBXML_UNICODE_ENABLED)
39267: int mem_base;
39268: int ret_val;
39269: int code; /* UCS code point */
39270: int n_code;
39271:
39272: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39273: mem_base = xmlMemBlocks();
39274: code = gen_int(n_code, 0);
39275:
39276: ret_val = xmlUCSIsCatSm(code);
39277: desret_int(ret_val);
39278: call_tests++;
39279: des_int(n_code, code, 0);
39280: xmlResetLastError();
39281: if (mem_base != xmlMemBlocks()) {
39282: printf("Leak of %d blocks found in xmlUCSIsCatSm",
39283: xmlMemBlocks() - mem_base);
39284: test_ret++;
39285: printf(" %d", n_code);
39286: printf("\n");
39287: }
39288: }
39289: function_tests++;
39290: #endif
39291:
39292: return(test_ret);
39293: }
39294:
39295:
39296: static int
39297: test_xmlUCSIsCatSo(void) {
39298: int test_ret = 0;
39299:
39300: #if defined(LIBXML_UNICODE_ENABLED)
39301: int mem_base;
39302: int ret_val;
39303: int code; /* UCS code point */
39304: int n_code;
39305:
39306: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39307: mem_base = xmlMemBlocks();
39308: code = gen_int(n_code, 0);
39309:
39310: ret_val = xmlUCSIsCatSo(code);
39311: desret_int(ret_val);
39312: call_tests++;
39313: des_int(n_code, code, 0);
39314: xmlResetLastError();
39315: if (mem_base != xmlMemBlocks()) {
39316: printf("Leak of %d blocks found in xmlUCSIsCatSo",
39317: xmlMemBlocks() - mem_base);
39318: test_ret++;
39319: printf(" %d", n_code);
39320: printf("\n");
39321: }
39322: }
39323: function_tests++;
39324: #endif
39325:
39326: return(test_ret);
39327: }
39328:
39329:
39330: static int
39331: test_xmlUCSIsCatZ(void) {
39332: int test_ret = 0;
39333:
39334: #if defined(LIBXML_UNICODE_ENABLED)
39335: int mem_base;
39336: int ret_val;
39337: int code; /* UCS code point */
39338: int n_code;
39339:
39340: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39341: mem_base = xmlMemBlocks();
39342: code = gen_int(n_code, 0);
39343:
39344: ret_val = xmlUCSIsCatZ(code);
39345: desret_int(ret_val);
39346: call_tests++;
39347: des_int(n_code, code, 0);
39348: xmlResetLastError();
39349: if (mem_base != xmlMemBlocks()) {
39350: printf("Leak of %d blocks found in xmlUCSIsCatZ",
39351: xmlMemBlocks() - mem_base);
39352: test_ret++;
39353: printf(" %d", n_code);
39354: printf("\n");
39355: }
39356: }
39357: function_tests++;
39358: #endif
39359:
39360: return(test_ret);
39361: }
39362:
39363:
39364: static int
39365: test_xmlUCSIsCatZl(void) {
39366: int test_ret = 0;
39367:
39368: #if defined(LIBXML_UNICODE_ENABLED)
39369: int mem_base;
39370: int ret_val;
39371: int code; /* UCS code point */
39372: int n_code;
39373:
39374: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39375: mem_base = xmlMemBlocks();
39376: code = gen_int(n_code, 0);
39377:
39378: ret_val = xmlUCSIsCatZl(code);
39379: desret_int(ret_val);
39380: call_tests++;
39381: des_int(n_code, code, 0);
39382: xmlResetLastError();
39383: if (mem_base != xmlMemBlocks()) {
39384: printf("Leak of %d blocks found in xmlUCSIsCatZl",
39385: xmlMemBlocks() - mem_base);
39386: test_ret++;
39387: printf(" %d", n_code);
39388: printf("\n");
39389: }
39390: }
39391: function_tests++;
39392: #endif
39393:
39394: return(test_ret);
39395: }
39396:
39397:
39398: static int
39399: test_xmlUCSIsCatZp(void) {
39400: int test_ret = 0;
39401:
39402: #if defined(LIBXML_UNICODE_ENABLED)
39403: int mem_base;
39404: int ret_val;
39405: int code; /* UCS code point */
39406: int n_code;
39407:
39408: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39409: mem_base = xmlMemBlocks();
39410: code = gen_int(n_code, 0);
39411:
39412: ret_val = xmlUCSIsCatZp(code);
39413: desret_int(ret_val);
39414: call_tests++;
39415: des_int(n_code, code, 0);
39416: xmlResetLastError();
39417: if (mem_base != xmlMemBlocks()) {
39418: printf("Leak of %d blocks found in xmlUCSIsCatZp",
39419: xmlMemBlocks() - mem_base);
39420: test_ret++;
39421: printf(" %d", n_code);
39422: printf("\n");
39423: }
39424: }
39425: function_tests++;
39426: #endif
39427:
39428: return(test_ret);
39429: }
39430:
39431:
39432: static int
39433: test_xmlUCSIsCatZs(void) {
39434: int test_ret = 0;
39435:
39436: #if defined(LIBXML_UNICODE_ENABLED)
39437: int mem_base;
39438: int ret_val;
39439: int code; /* UCS code point */
39440: int n_code;
39441:
39442: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39443: mem_base = xmlMemBlocks();
39444: code = gen_int(n_code, 0);
39445:
39446: ret_val = xmlUCSIsCatZs(code);
39447: desret_int(ret_val);
39448: call_tests++;
39449: des_int(n_code, code, 0);
39450: xmlResetLastError();
39451: if (mem_base != xmlMemBlocks()) {
39452: printf("Leak of %d blocks found in xmlUCSIsCatZs",
39453: xmlMemBlocks() - mem_base);
39454: test_ret++;
39455: printf(" %d", n_code);
39456: printf("\n");
39457: }
39458: }
39459: function_tests++;
39460: #endif
39461:
39462: return(test_ret);
39463: }
39464:
39465:
39466: static int
39467: test_xmlUCSIsCherokee(void) {
39468: int test_ret = 0;
39469:
39470: #if defined(LIBXML_UNICODE_ENABLED)
39471: int mem_base;
39472: int ret_val;
39473: int code; /* UCS code point */
39474: int n_code;
39475:
39476: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39477: mem_base = xmlMemBlocks();
39478: code = gen_int(n_code, 0);
39479:
39480: ret_val = xmlUCSIsCherokee(code);
39481: desret_int(ret_val);
39482: call_tests++;
39483: des_int(n_code, code, 0);
39484: xmlResetLastError();
39485: if (mem_base != xmlMemBlocks()) {
39486: printf("Leak of %d blocks found in xmlUCSIsCherokee",
39487: xmlMemBlocks() - mem_base);
39488: test_ret++;
39489: printf(" %d", n_code);
39490: printf("\n");
39491: }
39492: }
39493: function_tests++;
39494: #endif
39495:
39496: return(test_ret);
39497: }
39498:
39499:
39500: static int
39501: test_xmlUCSIsCombiningDiacriticalMarks(void) {
39502: int test_ret = 0;
39503:
39504: #if defined(LIBXML_UNICODE_ENABLED)
39505: int mem_base;
39506: int ret_val;
39507: int code; /* UCS code point */
39508: int n_code;
39509:
39510: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39511: mem_base = xmlMemBlocks();
39512: code = gen_int(n_code, 0);
39513:
39514: ret_val = xmlUCSIsCombiningDiacriticalMarks(code);
39515: desret_int(ret_val);
39516: call_tests++;
39517: des_int(n_code, code, 0);
39518: xmlResetLastError();
39519: if (mem_base != xmlMemBlocks()) {
39520: printf("Leak of %d blocks found in xmlUCSIsCombiningDiacriticalMarks",
39521: xmlMemBlocks() - mem_base);
39522: test_ret++;
39523: printf(" %d", n_code);
39524: printf("\n");
39525: }
39526: }
39527: function_tests++;
39528: #endif
39529:
39530: return(test_ret);
39531: }
39532:
39533:
39534: static int
39535: test_xmlUCSIsCombiningDiacriticalMarksforSymbols(void) {
39536: int test_ret = 0;
39537:
39538: #if defined(LIBXML_UNICODE_ENABLED)
39539: int mem_base;
39540: int ret_val;
39541: int code; /* UCS code point */
39542: int n_code;
39543:
39544: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39545: mem_base = xmlMemBlocks();
39546: code = gen_int(n_code, 0);
39547:
39548: ret_val = xmlUCSIsCombiningDiacriticalMarksforSymbols(code);
39549: desret_int(ret_val);
39550: call_tests++;
39551: des_int(n_code, code, 0);
39552: xmlResetLastError();
39553: if (mem_base != xmlMemBlocks()) {
39554: printf("Leak of %d blocks found in xmlUCSIsCombiningDiacriticalMarksforSymbols",
39555: xmlMemBlocks() - mem_base);
39556: test_ret++;
39557: printf(" %d", n_code);
39558: printf("\n");
39559: }
39560: }
39561: function_tests++;
39562: #endif
39563:
39564: return(test_ret);
39565: }
39566:
39567:
39568: static int
39569: test_xmlUCSIsCombiningHalfMarks(void) {
39570: int test_ret = 0;
39571:
39572: #if defined(LIBXML_UNICODE_ENABLED)
39573: int mem_base;
39574: int ret_val;
39575: int code; /* UCS code point */
39576: int n_code;
39577:
39578: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39579: mem_base = xmlMemBlocks();
39580: code = gen_int(n_code, 0);
39581:
39582: ret_val = xmlUCSIsCombiningHalfMarks(code);
39583: desret_int(ret_val);
39584: call_tests++;
39585: des_int(n_code, code, 0);
39586: xmlResetLastError();
39587: if (mem_base != xmlMemBlocks()) {
39588: printf("Leak of %d blocks found in xmlUCSIsCombiningHalfMarks",
39589: xmlMemBlocks() - mem_base);
39590: test_ret++;
39591: printf(" %d", n_code);
39592: printf("\n");
39593: }
39594: }
39595: function_tests++;
39596: #endif
39597:
39598: return(test_ret);
39599: }
39600:
39601:
39602: static int
39603: test_xmlUCSIsCombiningMarksforSymbols(void) {
39604: int test_ret = 0;
39605:
39606: #if defined(LIBXML_UNICODE_ENABLED)
39607: int mem_base;
39608: int ret_val;
39609: int code; /* UCS code point */
39610: int n_code;
39611:
39612: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39613: mem_base = xmlMemBlocks();
39614: code = gen_int(n_code, 0);
39615:
39616: ret_val = xmlUCSIsCombiningMarksforSymbols(code);
39617: desret_int(ret_val);
39618: call_tests++;
39619: des_int(n_code, code, 0);
39620: xmlResetLastError();
39621: if (mem_base != xmlMemBlocks()) {
39622: printf("Leak of %d blocks found in xmlUCSIsCombiningMarksforSymbols",
39623: xmlMemBlocks() - mem_base);
39624: test_ret++;
39625: printf(" %d", n_code);
39626: printf("\n");
39627: }
39628: }
39629: function_tests++;
39630: #endif
39631:
39632: return(test_ret);
39633: }
39634:
39635:
39636: static int
39637: test_xmlUCSIsControlPictures(void) {
39638: int test_ret = 0;
39639:
39640: #if defined(LIBXML_UNICODE_ENABLED)
39641: int mem_base;
39642: int ret_val;
39643: int code; /* UCS code point */
39644: int n_code;
39645:
39646: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39647: mem_base = xmlMemBlocks();
39648: code = gen_int(n_code, 0);
39649:
39650: ret_val = xmlUCSIsControlPictures(code);
39651: desret_int(ret_val);
39652: call_tests++;
39653: des_int(n_code, code, 0);
39654: xmlResetLastError();
39655: if (mem_base != xmlMemBlocks()) {
39656: printf("Leak of %d blocks found in xmlUCSIsControlPictures",
39657: xmlMemBlocks() - mem_base);
39658: test_ret++;
39659: printf(" %d", n_code);
39660: printf("\n");
39661: }
39662: }
39663: function_tests++;
39664: #endif
39665:
39666: return(test_ret);
39667: }
39668:
39669:
39670: static int
39671: test_xmlUCSIsCurrencySymbols(void) {
39672: int test_ret = 0;
39673:
39674: #if defined(LIBXML_UNICODE_ENABLED)
39675: int mem_base;
39676: int ret_val;
39677: int code; /* UCS code point */
39678: int n_code;
39679:
39680: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39681: mem_base = xmlMemBlocks();
39682: code = gen_int(n_code, 0);
39683:
39684: ret_val = xmlUCSIsCurrencySymbols(code);
39685: desret_int(ret_val);
39686: call_tests++;
39687: des_int(n_code, code, 0);
39688: xmlResetLastError();
39689: if (mem_base != xmlMemBlocks()) {
39690: printf("Leak of %d blocks found in xmlUCSIsCurrencySymbols",
39691: xmlMemBlocks() - mem_base);
39692: test_ret++;
39693: printf(" %d", n_code);
39694: printf("\n");
39695: }
39696: }
39697: function_tests++;
39698: #endif
39699:
39700: return(test_ret);
39701: }
39702:
39703:
39704: static int
39705: test_xmlUCSIsCypriotSyllabary(void) {
39706: int test_ret = 0;
39707:
39708: #if defined(LIBXML_UNICODE_ENABLED)
39709: int mem_base;
39710: int ret_val;
39711: int code; /* UCS code point */
39712: int n_code;
39713:
39714: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39715: mem_base = xmlMemBlocks();
39716: code = gen_int(n_code, 0);
39717:
39718: ret_val = xmlUCSIsCypriotSyllabary(code);
39719: desret_int(ret_val);
39720: call_tests++;
39721: des_int(n_code, code, 0);
39722: xmlResetLastError();
39723: if (mem_base != xmlMemBlocks()) {
39724: printf("Leak of %d blocks found in xmlUCSIsCypriotSyllabary",
39725: xmlMemBlocks() - mem_base);
39726: test_ret++;
39727: printf(" %d", n_code);
39728: printf("\n");
39729: }
39730: }
39731: function_tests++;
39732: #endif
39733:
39734: return(test_ret);
39735: }
39736:
39737:
39738: static int
39739: test_xmlUCSIsCyrillic(void) {
39740: int test_ret = 0;
39741:
39742: #if defined(LIBXML_UNICODE_ENABLED)
39743: int mem_base;
39744: int ret_val;
39745: int code; /* UCS code point */
39746: int n_code;
39747:
39748: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39749: mem_base = xmlMemBlocks();
39750: code = gen_int(n_code, 0);
39751:
39752: ret_val = xmlUCSIsCyrillic(code);
39753: desret_int(ret_val);
39754: call_tests++;
39755: des_int(n_code, code, 0);
39756: xmlResetLastError();
39757: if (mem_base != xmlMemBlocks()) {
39758: printf("Leak of %d blocks found in xmlUCSIsCyrillic",
39759: xmlMemBlocks() - mem_base);
39760: test_ret++;
39761: printf(" %d", n_code);
39762: printf("\n");
39763: }
39764: }
39765: function_tests++;
39766: #endif
39767:
39768: return(test_ret);
39769: }
39770:
39771:
39772: static int
39773: test_xmlUCSIsCyrillicSupplement(void) {
39774: int test_ret = 0;
39775:
39776: #if defined(LIBXML_UNICODE_ENABLED)
39777: int mem_base;
39778: int ret_val;
39779: int code; /* UCS code point */
39780: int n_code;
39781:
39782: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39783: mem_base = xmlMemBlocks();
39784: code = gen_int(n_code, 0);
39785:
39786: ret_val = xmlUCSIsCyrillicSupplement(code);
39787: desret_int(ret_val);
39788: call_tests++;
39789: des_int(n_code, code, 0);
39790: xmlResetLastError();
39791: if (mem_base != xmlMemBlocks()) {
39792: printf("Leak of %d blocks found in xmlUCSIsCyrillicSupplement",
39793: xmlMemBlocks() - mem_base);
39794: test_ret++;
39795: printf(" %d", n_code);
39796: printf("\n");
39797: }
39798: }
39799: function_tests++;
39800: #endif
39801:
39802: return(test_ret);
39803: }
39804:
39805:
39806: static int
39807: test_xmlUCSIsDeseret(void) {
39808: int test_ret = 0;
39809:
39810: #if defined(LIBXML_UNICODE_ENABLED)
39811: int mem_base;
39812: int ret_val;
39813: int code; /* UCS code point */
39814: int n_code;
39815:
39816: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39817: mem_base = xmlMemBlocks();
39818: code = gen_int(n_code, 0);
39819:
39820: ret_val = xmlUCSIsDeseret(code);
39821: desret_int(ret_val);
39822: call_tests++;
39823: des_int(n_code, code, 0);
39824: xmlResetLastError();
39825: if (mem_base != xmlMemBlocks()) {
39826: printf("Leak of %d blocks found in xmlUCSIsDeseret",
39827: xmlMemBlocks() - mem_base);
39828: test_ret++;
39829: printf(" %d", n_code);
39830: printf("\n");
39831: }
39832: }
39833: function_tests++;
39834: #endif
39835:
39836: return(test_ret);
39837: }
39838:
39839:
39840: static int
39841: test_xmlUCSIsDevanagari(void) {
39842: int test_ret = 0;
39843:
39844: #if defined(LIBXML_UNICODE_ENABLED)
39845: int mem_base;
39846: int ret_val;
39847: int code; /* UCS code point */
39848: int n_code;
39849:
39850: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39851: mem_base = xmlMemBlocks();
39852: code = gen_int(n_code, 0);
39853:
39854: ret_val = xmlUCSIsDevanagari(code);
39855: desret_int(ret_val);
39856: call_tests++;
39857: des_int(n_code, code, 0);
39858: xmlResetLastError();
39859: if (mem_base != xmlMemBlocks()) {
39860: printf("Leak of %d blocks found in xmlUCSIsDevanagari",
39861: xmlMemBlocks() - mem_base);
39862: test_ret++;
39863: printf(" %d", n_code);
39864: printf("\n");
39865: }
39866: }
39867: function_tests++;
39868: #endif
39869:
39870: return(test_ret);
39871: }
39872:
39873:
39874: static int
39875: test_xmlUCSIsDingbats(void) {
39876: int test_ret = 0;
39877:
39878: #if defined(LIBXML_UNICODE_ENABLED)
39879: int mem_base;
39880: int ret_val;
39881: int code; /* UCS code point */
39882: int n_code;
39883:
39884: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39885: mem_base = xmlMemBlocks();
39886: code = gen_int(n_code, 0);
39887:
39888: ret_val = xmlUCSIsDingbats(code);
39889: desret_int(ret_val);
39890: call_tests++;
39891: des_int(n_code, code, 0);
39892: xmlResetLastError();
39893: if (mem_base != xmlMemBlocks()) {
39894: printf("Leak of %d blocks found in xmlUCSIsDingbats",
39895: xmlMemBlocks() - mem_base);
39896: test_ret++;
39897: printf(" %d", n_code);
39898: printf("\n");
39899: }
39900: }
39901: function_tests++;
39902: #endif
39903:
39904: return(test_ret);
39905: }
39906:
39907:
39908: static int
39909: test_xmlUCSIsEnclosedAlphanumerics(void) {
39910: int test_ret = 0;
39911:
39912: #if defined(LIBXML_UNICODE_ENABLED)
39913: int mem_base;
39914: int ret_val;
39915: int code; /* UCS code point */
39916: int n_code;
39917:
39918: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39919: mem_base = xmlMemBlocks();
39920: code = gen_int(n_code, 0);
39921:
39922: ret_val = xmlUCSIsEnclosedAlphanumerics(code);
39923: desret_int(ret_val);
39924: call_tests++;
39925: des_int(n_code, code, 0);
39926: xmlResetLastError();
39927: if (mem_base != xmlMemBlocks()) {
39928: printf("Leak of %d blocks found in xmlUCSIsEnclosedAlphanumerics",
39929: xmlMemBlocks() - mem_base);
39930: test_ret++;
39931: printf(" %d", n_code);
39932: printf("\n");
39933: }
39934: }
39935: function_tests++;
39936: #endif
39937:
39938: return(test_ret);
39939: }
39940:
39941:
39942: static int
39943: test_xmlUCSIsEnclosedCJKLettersandMonths(void) {
39944: int test_ret = 0;
39945:
39946: #if defined(LIBXML_UNICODE_ENABLED)
39947: int mem_base;
39948: int ret_val;
39949: int code; /* UCS code point */
39950: int n_code;
39951:
39952: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39953: mem_base = xmlMemBlocks();
39954: code = gen_int(n_code, 0);
39955:
39956: ret_val = xmlUCSIsEnclosedCJKLettersandMonths(code);
39957: desret_int(ret_val);
39958: call_tests++;
39959: des_int(n_code, code, 0);
39960: xmlResetLastError();
39961: if (mem_base != xmlMemBlocks()) {
39962: printf("Leak of %d blocks found in xmlUCSIsEnclosedCJKLettersandMonths",
39963: xmlMemBlocks() - mem_base);
39964: test_ret++;
39965: printf(" %d", n_code);
39966: printf("\n");
39967: }
39968: }
39969: function_tests++;
39970: #endif
39971:
39972: return(test_ret);
39973: }
39974:
39975:
39976: static int
39977: test_xmlUCSIsEthiopic(void) {
39978: int test_ret = 0;
39979:
39980: #if defined(LIBXML_UNICODE_ENABLED)
39981: int mem_base;
39982: int ret_val;
39983: int code; /* UCS code point */
39984: int n_code;
39985:
39986: for (n_code = 0;n_code < gen_nb_int;n_code++) {
39987: mem_base = xmlMemBlocks();
39988: code = gen_int(n_code, 0);
39989:
39990: ret_val = xmlUCSIsEthiopic(code);
39991: desret_int(ret_val);
39992: call_tests++;
39993: des_int(n_code, code, 0);
39994: xmlResetLastError();
39995: if (mem_base != xmlMemBlocks()) {
39996: printf("Leak of %d blocks found in xmlUCSIsEthiopic",
39997: xmlMemBlocks() - mem_base);
39998: test_ret++;
39999: printf(" %d", n_code);
40000: printf("\n");
40001: }
40002: }
40003: function_tests++;
40004: #endif
40005:
40006: return(test_ret);
40007: }
40008:
40009:
40010: static int
40011: test_xmlUCSIsGeneralPunctuation(void) {
40012: int test_ret = 0;
40013:
40014: #if defined(LIBXML_UNICODE_ENABLED)
40015: int mem_base;
40016: int ret_val;
40017: int code; /* UCS code point */
40018: int n_code;
40019:
40020: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40021: mem_base = xmlMemBlocks();
40022: code = gen_int(n_code, 0);
40023:
40024: ret_val = xmlUCSIsGeneralPunctuation(code);
40025: desret_int(ret_val);
40026: call_tests++;
40027: des_int(n_code, code, 0);
40028: xmlResetLastError();
40029: if (mem_base != xmlMemBlocks()) {
40030: printf("Leak of %d blocks found in xmlUCSIsGeneralPunctuation",
40031: xmlMemBlocks() - mem_base);
40032: test_ret++;
40033: printf(" %d", n_code);
40034: printf("\n");
40035: }
40036: }
40037: function_tests++;
40038: #endif
40039:
40040: return(test_ret);
40041: }
40042:
40043:
40044: static int
40045: test_xmlUCSIsGeometricShapes(void) {
40046: int test_ret = 0;
40047:
40048: #if defined(LIBXML_UNICODE_ENABLED)
40049: int mem_base;
40050: int ret_val;
40051: int code; /* UCS code point */
40052: int n_code;
40053:
40054: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40055: mem_base = xmlMemBlocks();
40056: code = gen_int(n_code, 0);
40057:
40058: ret_val = xmlUCSIsGeometricShapes(code);
40059: desret_int(ret_val);
40060: call_tests++;
40061: des_int(n_code, code, 0);
40062: xmlResetLastError();
40063: if (mem_base != xmlMemBlocks()) {
40064: printf("Leak of %d blocks found in xmlUCSIsGeometricShapes",
40065: xmlMemBlocks() - mem_base);
40066: test_ret++;
40067: printf(" %d", n_code);
40068: printf("\n");
40069: }
40070: }
40071: function_tests++;
40072: #endif
40073:
40074: return(test_ret);
40075: }
40076:
40077:
40078: static int
40079: test_xmlUCSIsGeorgian(void) {
40080: int test_ret = 0;
40081:
40082: #if defined(LIBXML_UNICODE_ENABLED)
40083: int mem_base;
40084: int ret_val;
40085: int code; /* UCS code point */
40086: int n_code;
40087:
40088: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40089: mem_base = xmlMemBlocks();
40090: code = gen_int(n_code, 0);
40091:
40092: ret_val = xmlUCSIsGeorgian(code);
40093: desret_int(ret_val);
40094: call_tests++;
40095: des_int(n_code, code, 0);
40096: xmlResetLastError();
40097: if (mem_base != xmlMemBlocks()) {
40098: printf("Leak of %d blocks found in xmlUCSIsGeorgian",
40099: xmlMemBlocks() - mem_base);
40100: test_ret++;
40101: printf(" %d", n_code);
40102: printf("\n");
40103: }
40104: }
40105: function_tests++;
40106: #endif
40107:
40108: return(test_ret);
40109: }
40110:
40111:
40112: static int
40113: test_xmlUCSIsGothic(void) {
40114: int test_ret = 0;
40115:
40116: #if defined(LIBXML_UNICODE_ENABLED)
40117: int mem_base;
40118: int ret_val;
40119: int code; /* UCS code point */
40120: int n_code;
40121:
40122: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40123: mem_base = xmlMemBlocks();
40124: code = gen_int(n_code, 0);
40125:
40126: ret_val = xmlUCSIsGothic(code);
40127: desret_int(ret_val);
40128: call_tests++;
40129: des_int(n_code, code, 0);
40130: xmlResetLastError();
40131: if (mem_base != xmlMemBlocks()) {
40132: printf("Leak of %d blocks found in xmlUCSIsGothic",
40133: xmlMemBlocks() - mem_base);
40134: test_ret++;
40135: printf(" %d", n_code);
40136: printf("\n");
40137: }
40138: }
40139: function_tests++;
40140: #endif
40141:
40142: return(test_ret);
40143: }
40144:
40145:
40146: static int
40147: test_xmlUCSIsGreek(void) {
40148: int test_ret = 0;
40149:
40150: #if defined(LIBXML_UNICODE_ENABLED)
40151: int mem_base;
40152: int ret_val;
40153: int code; /* UCS code point */
40154: int n_code;
40155:
40156: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40157: mem_base = xmlMemBlocks();
40158: code = gen_int(n_code, 0);
40159:
40160: ret_val = xmlUCSIsGreek(code);
40161: desret_int(ret_val);
40162: call_tests++;
40163: des_int(n_code, code, 0);
40164: xmlResetLastError();
40165: if (mem_base != xmlMemBlocks()) {
40166: printf("Leak of %d blocks found in xmlUCSIsGreek",
40167: xmlMemBlocks() - mem_base);
40168: test_ret++;
40169: printf(" %d", n_code);
40170: printf("\n");
40171: }
40172: }
40173: function_tests++;
40174: #endif
40175:
40176: return(test_ret);
40177: }
40178:
40179:
40180: static int
40181: test_xmlUCSIsGreekExtended(void) {
40182: int test_ret = 0;
40183:
40184: #if defined(LIBXML_UNICODE_ENABLED)
40185: int mem_base;
40186: int ret_val;
40187: int code; /* UCS code point */
40188: int n_code;
40189:
40190: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40191: mem_base = xmlMemBlocks();
40192: code = gen_int(n_code, 0);
40193:
40194: ret_val = xmlUCSIsGreekExtended(code);
40195: desret_int(ret_val);
40196: call_tests++;
40197: des_int(n_code, code, 0);
40198: xmlResetLastError();
40199: if (mem_base != xmlMemBlocks()) {
40200: printf("Leak of %d blocks found in xmlUCSIsGreekExtended",
40201: xmlMemBlocks() - mem_base);
40202: test_ret++;
40203: printf(" %d", n_code);
40204: printf("\n");
40205: }
40206: }
40207: function_tests++;
40208: #endif
40209:
40210: return(test_ret);
40211: }
40212:
40213:
40214: static int
40215: test_xmlUCSIsGreekandCoptic(void) {
40216: int test_ret = 0;
40217:
40218: #if defined(LIBXML_UNICODE_ENABLED)
40219: int mem_base;
40220: int ret_val;
40221: int code; /* UCS code point */
40222: int n_code;
40223:
40224: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40225: mem_base = xmlMemBlocks();
40226: code = gen_int(n_code, 0);
40227:
40228: ret_val = xmlUCSIsGreekandCoptic(code);
40229: desret_int(ret_val);
40230: call_tests++;
40231: des_int(n_code, code, 0);
40232: xmlResetLastError();
40233: if (mem_base != xmlMemBlocks()) {
40234: printf("Leak of %d blocks found in xmlUCSIsGreekandCoptic",
40235: xmlMemBlocks() - mem_base);
40236: test_ret++;
40237: printf(" %d", n_code);
40238: printf("\n");
40239: }
40240: }
40241: function_tests++;
40242: #endif
40243:
40244: return(test_ret);
40245: }
40246:
40247:
40248: static int
40249: test_xmlUCSIsGujarati(void) {
40250: int test_ret = 0;
40251:
40252: #if defined(LIBXML_UNICODE_ENABLED)
40253: int mem_base;
40254: int ret_val;
40255: int code; /* UCS code point */
40256: int n_code;
40257:
40258: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40259: mem_base = xmlMemBlocks();
40260: code = gen_int(n_code, 0);
40261:
40262: ret_val = xmlUCSIsGujarati(code);
40263: desret_int(ret_val);
40264: call_tests++;
40265: des_int(n_code, code, 0);
40266: xmlResetLastError();
40267: if (mem_base != xmlMemBlocks()) {
40268: printf("Leak of %d blocks found in xmlUCSIsGujarati",
40269: xmlMemBlocks() - mem_base);
40270: test_ret++;
40271: printf(" %d", n_code);
40272: printf("\n");
40273: }
40274: }
40275: function_tests++;
40276: #endif
40277:
40278: return(test_ret);
40279: }
40280:
40281:
40282: static int
40283: test_xmlUCSIsGurmukhi(void) {
40284: int test_ret = 0;
40285:
40286: #if defined(LIBXML_UNICODE_ENABLED)
40287: int mem_base;
40288: int ret_val;
40289: int code; /* UCS code point */
40290: int n_code;
40291:
40292: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40293: mem_base = xmlMemBlocks();
40294: code = gen_int(n_code, 0);
40295:
40296: ret_val = xmlUCSIsGurmukhi(code);
40297: desret_int(ret_val);
40298: call_tests++;
40299: des_int(n_code, code, 0);
40300: xmlResetLastError();
40301: if (mem_base != xmlMemBlocks()) {
40302: printf("Leak of %d blocks found in xmlUCSIsGurmukhi",
40303: xmlMemBlocks() - mem_base);
40304: test_ret++;
40305: printf(" %d", n_code);
40306: printf("\n");
40307: }
40308: }
40309: function_tests++;
40310: #endif
40311:
40312: return(test_ret);
40313: }
40314:
40315:
40316: static int
40317: test_xmlUCSIsHalfwidthandFullwidthForms(void) {
40318: int test_ret = 0;
40319:
40320: #if defined(LIBXML_UNICODE_ENABLED)
40321: int mem_base;
40322: int ret_val;
40323: int code; /* UCS code point */
40324: int n_code;
40325:
40326: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40327: mem_base = xmlMemBlocks();
40328: code = gen_int(n_code, 0);
40329:
40330: ret_val = xmlUCSIsHalfwidthandFullwidthForms(code);
40331: desret_int(ret_val);
40332: call_tests++;
40333: des_int(n_code, code, 0);
40334: xmlResetLastError();
40335: if (mem_base != xmlMemBlocks()) {
40336: printf("Leak of %d blocks found in xmlUCSIsHalfwidthandFullwidthForms",
40337: xmlMemBlocks() - mem_base);
40338: test_ret++;
40339: printf(" %d", n_code);
40340: printf("\n");
40341: }
40342: }
40343: function_tests++;
40344: #endif
40345:
40346: return(test_ret);
40347: }
40348:
40349:
40350: static int
40351: test_xmlUCSIsHangulCompatibilityJamo(void) {
40352: int test_ret = 0;
40353:
40354: #if defined(LIBXML_UNICODE_ENABLED)
40355: int mem_base;
40356: int ret_val;
40357: int code; /* UCS code point */
40358: int n_code;
40359:
40360: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40361: mem_base = xmlMemBlocks();
40362: code = gen_int(n_code, 0);
40363:
40364: ret_val = xmlUCSIsHangulCompatibilityJamo(code);
40365: desret_int(ret_val);
40366: call_tests++;
40367: des_int(n_code, code, 0);
40368: xmlResetLastError();
40369: if (mem_base != xmlMemBlocks()) {
40370: printf("Leak of %d blocks found in xmlUCSIsHangulCompatibilityJamo",
40371: xmlMemBlocks() - mem_base);
40372: test_ret++;
40373: printf(" %d", n_code);
40374: printf("\n");
40375: }
40376: }
40377: function_tests++;
40378: #endif
40379:
40380: return(test_ret);
40381: }
40382:
40383:
40384: static int
40385: test_xmlUCSIsHangulJamo(void) {
40386: int test_ret = 0;
40387:
40388: #if defined(LIBXML_UNICODE_ENABLED)
40389: int mem_base;
40390: int ret_val;
40391: int code; /* UCS code point */
40392: int n_code;
40393:
40394: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40395: mem_base = xmlMemBlocks();
40396: code = gen_int(n_code, 0);
40397:
40398: ret_val = xmlUCSIsHangulJamo(code);
40399: desret_int(ret_val);
40400: call_tests++;
40401: des_int(n_code, code, 0);
40402: xmlResetLastError();
40403: if (mem_base != xmlMemBlocks()) {
40404: printf("Leak of %d blocks found in xmlUCSIsHangulJamo",
40405: xmlMemBlocks() - mem_base);
40406: test_ret++;
40407: printf(" %d", n_code);
40408: printf("\n");
40409: }
40410: }
40411: function_tests++;
40412: #endif
40413:
40414: return(test_ret);
40415: }
40416:
40417:
40418: static int
40419: test_xmlUCSIsHangulSyllables(void) {
40420: int test_ret = 0;
40421:
40422: #if defined(LIBXML_UNICODE_ENABLED)
40423: int mem_base;
40424: int ret_val;
40425: int code; /* UCS code point */
40426: int n_code;
40427:
40428: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40429: mem_base = xmlMemBlocks();
40430: code = gen_int(n_code, 0);
40431:
40432: ret_val = xmlUCSIsHangulSyllables(code);
40433: desret_int(ret_val);
40434: call_tests++;
40435: des_int(n_code, code, 0);
40436: xmlResetLastError();
40437: if (mem_base != xmlMemBlocks()) {
40438: printf("Leak of %d blocks found in xmlUCSIsHangulSyllables",
40439: xmlMemBlocks() - mem_base);
40440: test_ret++;
40441: printf(" %d", n_code);
40442: printf("\n");
40443: }
40444: }
40445: function_tests++;
40446: #endif
40447:
40448: return(test_ret);
40449: }
40450:
40451:
40452: static int
40453: test_xmlUCSIsHanunoo(void) {
40454: int test_ret = 0;
40455:
40456: #if defined(LIBXML_UNICODE_ENABLED)
40457: int mem_base;
40458: int ret_val;
40459: int code; /* UCS code point */
40460: int n_code;
40461:
40462: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40463: mem_base = xmlMemBlocks();
40464: code = gen_int(n_code, 0);
40465:
40466: ret_val = xmlUCSIsHanunoo(code);
40467: desret_int(ret_val);
40468: call_tests++;
40469: des_int(n_code, code, 0);
40470: xmlResetLastError();
40471: if (mem_base != xmlMemBlocks()) {
40472: printf("Leak of %d blocks found in xmlUCSIsHanunoo",
40473: xmlMemBlocks() - mem_base);
40474: test_ret++;
40475: printf(" %d", n_code);
40476: printf("\n");
40477: }
40478: }
40479: function_tests++;
40480: #endif
40481:
40482: return(test_ret);
40483: }
40484:
40485:
40486: static int
40487: test_xmlUCSIsHebrew(void) {
40488: int test_ret = 0;
40489:
40490: #if defined(LIBXML_UNICODE_ENABLED)
40491: int mem_base;
40492: int ret_val;
40493: int code; /* UCS code point */
40494: int n_code;
40495:
40496: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40497: mem_base = xmlMemBlocks();
40498: code = gen_int(n_code, 0);
40499:
40500: ret_val = xmlUCSIsHebrew(code);
40501: desret_int(ret_val);
40502: call_tests++;
40503: des_int(n_code, code, 0);
40504: xmlResetLastError();
40505: if (mem_base != xmlMemBlocks()) {
40506: printf("Leak of %d blocks found in xmlUCSIsHebrew",
40507: xmlMemBlocks() - mem_base);
40508: test_ret++;
40509: printf(" %d", n_code);
40510: printf("\n");
40511: }
40512: }
40513: function_tests++;
40514: #endif
40515:
40516: return(test_ret);
40517: }
40518:
40519:
40520: static int
40521: test_xmlUCSIsHighPrivateUseSurrogates(void) {
40522: int test_ret = 0;
40523:
40524: #if defined(LIBXML_UNICODE_ENABLED)
40525: int mem_base;
40526: int ret_val;
40527: int code; /* UCS code point */
40528: int n_code;
40529:
40530: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40531: mem_base = xmlMemBlocks();
40532: code = gen_int(n_code, 0);
40533:
40534: ret_val = xmlUCSIsHighPrivateUseSurrogates(code);
40535: desret_int(ret_val);
40536: call_tests++;
40537: des_int(n_code, code, 0);
40538: xmlResetLastError();
40539: if (mem_base != xmlMemBlocks()) {
40540: printf("Leak of %d blocks found in xmlUCSIsHighPrivateUseSurrogates",
40541: xmlMemBlocks() - mem_base);
40542: test_ret++;
40543: printf(" %d", n_code);
40544: printf("\n");
40545: }
40546: }
40547: function_tests++;
40548: #endif
40549:
40550: return(test_ret);
40551: }
40552:
40553:
40554: static int
40555: test_xmlUCSIsHighSurrogates(void) {
40556: int test_ret = 0;
40557:
40558: #if defined(LIBXML_UNICODE_ENABLED)
40559: int mem_base;
40560: int ret_val;
40561: int code; /* UCS code point */
40562: int n_code;
40563:
40564: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40565: mem_base = xmlMemBlocks();
40566: code = gen_int(n_code, 0);
40567:
40568: ret_val = xmlUCSIsHighSurrogates(code);
40569: desret_int(ret_val);
40570: call_tests++;
40571: des_int(n_code, code, 0);
40572: xmlResetLastError();
40573: if (mem_base != xmlMemBlocks()) {
40574: printf("Leak of %d blocks found in xmlUCSIsHighSurrogates",
40575: xmlMemBlocks() - mem_base);
40576: test_ret++;
40577: printf(" %d", n_code);
40578: printf("\n");
40579: }
40580: }
40581: function_tests++;
40582: #endif
40583:
40584: return(test_ret);
40585: }
40586:
40587:
40588: static int
40589: test_xmlUCSIsHiragana(void) {
40590: int test_ret = 0;
40591:
40592: #if defined(LIBXML_UNICODE_ENABLED)
40593: int mem_base;
40594: int ret_val;
40595: int code; /* UCS code point */
40596: int n_code;
40597:
40598: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40599: mem_base = xmlMemBlocks();
40600: code = gen_int(n_code, 0);
40601:
40602: ret_val = xmlUCSIsHiragana(code);
40603: desret_int(ret_val);
40604: call_tests++;
40605: des_int(n_code, code, 0);
40606: xmlResetLastError();
40607: if (mem_base != xmlMemBlocks()) {
40608: printf("Leak of %d blocks found in xmlUCSIsHiragana",
40609: xmlMemBlocks() - mem_base);
40610: test_ret++;
40611: printf(" %d", n_code);
40612: printf("\n");
40613: }
40614: }
40615: function_tests++;
40616: #endif
40617:
40618: return(test_ret);
40619: }
40620:
40621:
40622: static int
40623: test_xmlUCSIsIPAExtensions(void) {
40624: int test_ret = 0;
40625:
40626: #if defined(LIBXML_UNICODE_ENABLED)
40627: int mem_base;
40628: int ret_val;
40629: int code; /* UCS code point */
40630: int n_code;
40631:
40632: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40633: mem_base = xmlMemBlocks();
40634: code = gen_int(n_code, 0);
40635:
40636: ret_val = xmlUCSIsIPAExtensions(code);
40637: desret_int(ret_val);
40638: call_tests++;
40639: des_int(n_code, code, 0);
40640: xmlResetLastError();
40641: if (mem_base != xmlMemBlocks()) {
40642: printf("Leak of %d blocks found in xmlUCSIsIPAExtensions",
40643: xmlMemBlocks() - mem_base);
40644: test_ret++;
40645: printf(" %d", n_code);
40646: printf("\n");
40647: }
40648: }
40649: function_tests++;
40650: #endif
40651:
40652: return(test_ret);
40653: }
40654:
40655:
40656: static int
40657: test_xmlUCSIsIdeographicDescriptionCharacters(void) {
40658: int test_ret = 0;
40659:
40660: #if defined(LIBXML_UNICODE_ENABLED)
40661: int mem_base;
40662: int ret_val;
40663: int code; /* UCS code point */
40664: int n_code;
40665:
40666: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40667: mem_base = xmlMemBlocks();
40668: code = gen_int(n_code, 0);
40669:
40670: ret_val = xmlUCSIsIdeographicDescriptionCharacters(code);
40671: desret_int(ret_val);
40672: call_tests++;
40673: des_int(n_code, code, 0);
40674: xmlResetLastError();
40675: if (mem_base != xmlMemBlocks()) {
40676: printf("Leak of %d blocks found in xmlUCSIsIdeographicDescriptionCharacters",
40677: xmlMemBlocks() - mem_base);
40678: test_ret++;
40679: printf(" %d", n_code);
40680: printf("\n");
40681: }
40682: }
40683: function_tests++;
40684: #endif
40685:
40686: return(test_ret);
40687: }
40688:
40689:
40690: static int
40691: test_xmlUCSIsKanbun(void) {
40692: int test_ret = 0;
40693:
40694: #if defined(LIBXML_UNICODE_ENABLED)
40695: int mem_base;
40696: int ret_val;
40697: int code; /* UCS code point */
40698: int n_code;
40699:
40700: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40701: mem_base = xmlMemBlocks();
40702: code = gen_int(n_code, 0);
40703:
40704: ret_val = xmlUCSIsKanbun(code);
40705: desret_int(ret_val);
40706: call_tests++;
40707: des_int(n_code, code, 0);
40708: xmlResetLastError();
40709: if (mem_base != xmlMemBlocks()) {
40710: printf("Leak of %d blocks found in xmlUCSIsKanbun",
40711: xmlMemBlocks() - mem_base);
40712: test_ret++;
40713: printf(" %d", n_code);
40714: printf("\n");
40715: }
40716: }
40717: function_tests++;
40718: #endif
40719:
40720: return(test_ret);
40721: }
40722:
40723:
40724: static int
40725: test_xmlUCSIsKangxiRadicals(void) {
40726: int test_ret = 0;
40727:
40728: #if defined(LIBXML_UNICODE_ENABLED)
40729: int mem_base;
40730: int ret_val;
40731: int code; /* UCS code point */
40732: int n_code;
40733:
40734: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40735: mem_base = xmlMemBlocks();
40736: code = gen_int(n_code, 0);
40737:
40738: ret_val = xmlUCSIsKangxiRadicals(code);
40739: desret_int(ret_val);
40740: call_tests++;
40741: des_int(n_code, code, 0);
40742: xmlResetLastError();
40743: if (mem_base != xmlMemBlocks()) {
40744: printf("Leak of %d blocks found in xmlUCSIsKangxiRadicals",
40745: xmlMemBlocks() - mem_base);
40746: test_ret++;
40747: printf(" %d", n_code);
40748: printf("\n");
40749: }
40750: }
40751: function_tests++;
40752: #endif
40753:
40754: return(test_ret);
40755: }
40756:
40757:
40758: static int
40759: test_xmlUCSIsKannada(void) {
40760: int test_ret = 0;
40761:
40762: #if defined(LIBXML_UNICODE_ENABLED)
40763: int mem_base;
40764: int ret_val;
40765: int code; /* UCS code point */
40766: int n_code;
40767:
40768: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40769: mem_base = xmlMemBlocks();
40770: code = gen_int(n_code, 0);
40771:
40772: ret_val = xmlUCSIsKannada(code);
40773: desret_int(ret_val);
40774: call_tests++;
40775: des_int(n_code, code, 0);
40776: xmlResetLastError();
40777: if (mem_base != xmlMemBlocks()) {
40778: printf("Leak of %d blocks found in xmlUCSIsKannada",
40779: xmlMemBlocks() - mem_base);
40780: test_ret++;
40781: printf(" %d", n_code);
40782: printf("\n");
40783: }
40784: }
40785: function_tests++;
40786: #endif
40787:
40788: return(test_ret);
40789: }
40790:
40791:
40792: static int
40793: test_xmlUCSIsKatakana(void) {
40794: int test_ret = 0;
40795:
40796: #if defined(LIBXML_UNICODE_ENABLED)
40797: int mem_base;
40798: int ret_val;
40799: int code; /* UCS code point */
40800: int n_code;
40801:
40802: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40803: mem_base = xmlMemBlocks();
40804: code = gen_int(n_code, 0);
40805:
40806: ret_val = xmlUCSIsKatakana(code);
40807: desret_int(ret_val);
40808: call_tests++;
40809: des_int(n_code, code, 0);
40810: xmlResetLastError();
40811: if (mem_base != xmlMemBlocks()) {
40812: printf("Leak of %d blocks found in xmlUCSIsKatakana",
40813: xmlMemBlocks() - mem_base);
40814: test_ret++;
40815: printf(" %d", n_code);
40816: printf("\n");
40817: }
40818: }
40819: function_tests++;
40820: #endif
40821:
40822: return(test_ret);
40823: }
40824:
40825:
40826: static int
40827: test_xmlUCSIsKatakanaPhoneticExtensions(void) {
40828: int test_ret = 0;
40829:
40830: #if defined(LIBXML_UNICODE_ENABLED)
40831: int mem_base;
40832: int ret_val;
40833: int code; /* UCS code point */
40834: int n_code;
40835:
40836: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40837: mem_base = xmlMemBlocks();
40838: code = gen_int(n_code, 0);
40839:
40840: ret_val = xmlUCSIsKatakanaPhoneticExtensions(code);
40841: desret_int(ret_val);
40842: call_tests++;
40843: des_int(n_code, code, 0);
40844: xmlResetLastError();
40845: if (mem_base != xmlMemBlocks()) {
40846: printf("Leak of %d blocks found in xmlUCSIsKatakanaPhoneticExtensions",
40847: xmlMemBlocks() - mem_base);
40848: test_ret++;
40849: printf(" %d", n_code);
40850: printf("\n");
40851: }
40852: }
40853: function_tests++;
40854: #endif
40855:
40856: return(test_ret);
40857: }
40858:
40859:
40860: static int
40861: test_xmlUCSIsKhmer(void) {
40862: int test_ret = 0;
40863:
40864: #if defined(LIBXML_UNICODE_ENABLED)
40865: int mem_base;
40866: int ret_val;
40867: int code; /* UCS code point */
40868: int n_code;
40869:
40870: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40871: mem_base = xmlMemBlocks();
40872: code = gen_int(n_code, 0);
40873:
40874: ret_val = xmlUCSIsKhmer(code);
40875: desret_int(ret_val);
40876: call_tests++;
40877: des_int(n_code, code, 0);
40878: xmlResetLastError();
40879: if (mem_base != xmlMemBlocks()) {
40880: printf("Leak of %d blocks found in xmlUCSIsKhmer",
40881: xmlMemBlocks() - mem_base);
40882: test_ret++;
40883: printf(" %d", n_code);
40884: printf("\n");
40885: }
40886: }
40887: function_tests++;
40888: #endif
40889:
40890: return(test_ret);
40891: }
40892:
40893:
40894: static int
40895: test_xmlUCSIsKhmerSymbols(void) {
40896: int test_ret = 0;
40897:
40898: #if defined(LIBXML_UNICODE_ENABLED)
40899: int mem_base;
40900: int ret_val;
40901: int code; /* UCS code point */
40902: int n_code;
40903:
40904: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40905: mem_base = xmlMemBlocks();
40906: code = gen_int(n_code, 0);
40907:
40908: ret_val = xmlUCSIsKhmerSymbols(code);
40909: desret_int(ret_val);
40910: call_tests++;
40911: des_int(n_code, code, 0);
40912: xmlResetLastError();
40913: if (mem_base != xmlMemBlocks()) {
40914: printf("Leak of %d blocks found in xmlUCSIsKhmerSymbols",
40915: xmlMemBlocks() - mem_base);
40916: test_ret++;
40917: printf(" %d", n_code);
40918: printf("\n");
40919: }
40920: }
40921: function_tests++;
40922: #endif
40923:
40924: return(test_ret);
40925: }
40926:
40927:
40928: static int
40929: test_xmlUCSIsLao(void) {
40930: int test_ret = 0;
40931:
40932: #if defined(LIBXML_UNICODE_ENABLED)
40933: int mem_base;
40934: int ret_val;
40935: int code; /* UCS code point */
40936: int n_code;
40937:
40938: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40939: mem_base = xmlMemBlocks();
40940: code = gen_int(n_code, 0);
40941:
40942: ret_val = xmlUCSIsLao(code);
40943: desret_int(ret_val);
40944: call_tests++;
40945: des_int(n_code, code, 0);
40946: xmlResetLastError();
40947: if (mem_base != xmlMemBlocks()) {
40948: printf("Leak of %d blocks found in xmlUCSIsLao",
40949: xmlMemBlocks() - mem_base);
40950: test_ret++;
40951: printf(" %d", n_code);
40952: printf("\n");
40953: }
40954: }
40955: function_tests++;
40956: #endif
40957:
40958: return(test_ret);
40959: }
40960:
40961:
40962: static int
40963: test_xmlUCSIsLatin1Supplement(void) {
40964: int test_ret = 0;
40965:
40966: #if defined(LIBXML_UNICODE_ENABLED)
40967: int mem_base;
40968: int ret_val;
40969: int code; /* UCS code point */
40970: int n_code;
40971:
40972: for (n_code = 0;n_code < gen_nb_int;n_code++) {
40973: mem_base = xmlMemBlocks();
40974: code = gen_int(n_code, 0);
40975:
40976: ret_val = xmlUCSIsLatin1Supplement(code);
40977: desret_int(ret_val);
40978: call_tests++;
40979: des_int(n_code, code, 0);
40980: xmlResetLastError();
40981: if (mem_base != xmlMemBlocks()) {
40982: printf("Leak of %d blocks found in xmlUCSIsLatin1Supplement",
40983: xmlMemBlocks() - mem_base);
40984: test_ret++;
40985: printf(" %d", n_code);
40986: printf("\n");
40987: }
40988: }
40989: function_tests++;
40990: #endif
40991:
40992: return(test_ret);
40993: }
40994:
40995:
40996: static int
40997: test_xmlUCSIsLatinExtendedA(void) {
40998: int test_ret = 0;
40999:
41000: #if defined(LIBXML_UNICODE_ENABLED)
41001: int mem_base;
41002: int ret_val;
41003: int code; /* UCS code point */
41004: int n_code;
41005:
41006: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41007: mem_base = xmlMemBlocks();
41008: code = gen_int(n_code, 0);
41009:
41010: ret_val = xmlUCSIsLatinExtendedA(code);
41011: desret_int(ret_val);
41012: call_tests++;
41013: des_int(n_code, code, 0);
41014: xmlResetLastError();
41015: if (mem_base != xmlMemBlocks()) {
41016: printf("Leak of %d blocks found in xmlUCSIsLatinExtendedA",
41017: xmlMemBlocks() - mem_base);
41018: test_ret++;
41019: printf(" %d", n_code);
41020: printf("\n");
41021: }
41022: }
41023: function_tests++;
41024: #endif
41025:
41026: return(test_ret);
41027: }
41028:
41029:
41030: static int
41031: test_xmlUCSIsLatinExtendedAdditional(void) {
41032: int test_ret = 0;
41033:
41034: #if defined(LIBXML_UNICODE_ENABLED)
41035: int mem_base;
41036: int ret_val;
41037: int code; /* UCS code point */
41038: int n_code;
41039:
41040: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41041: mem_base = xmlMemBlocks();
41042: code = gen_int(n_code, 0);
41043:
41044: ret_val = xmlUCSIsLatinExtendedAdditional(code);
41045: desret_int(ret_val);
41046: call_tests++;
41047: des_int(n_code, code, 0);
41048: xmlResetLastError();
41049: if (mem_base != xmlMemBlocks()) {
41050: printf("Leak of %d blocks found in xmlUCSIsLatinExtendedAdditional",
41051: xmlMemBlocks() - mem_base);
41052: test_ret++;
41053: printf(" %d", n_code);
41054: printf("\n");
41055: }
41056: }
41057: function_tests++;
41058: #endif
41059:
41060: return(test_ret);
41061: }
41062:
41063:
41064: static int
41065: test_xmlUCSIsLatinExtendedB(void) {
41066: int test_ret = 0;
41067:
41068: #if defined(LIBXML_UNICODE_ENABLED)
41069: int mem_base;
41070: int ret_val;
41071: int code; /* UCS code point */
41072: int n_code;
41073:
41074: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41075: mem_base = xmlMemBlocks();
41076: code = gen_int(n_code, 0);
41077:
41078: ret_val = xmlUCSIsLatinExtendedB(code);
41079: desret_int(ret_val);
41080: call_tests++;
41081: des_int(n_code, code, 0);
41082: xmlResetLastError();
41083: if (mem_base != xmlMemBlocks()) {
41084: printf("Leak of %d blocks found in xmlUCSIsLatinExtendedB",
41085: xmlMemBlocks() - mem_base);
41086: test_ret++;
41087: printf(" %d", n_code);
41088: printf("\n");
41089: }
41090: }
41091: function_tests++;
41092: #endif
41093:
41094: return(test_ret);
41095: }
41096:
41097:
41098: static int
41099: test_xmlUCSIsLetterlikeSymbols(void) {
41100: int test_ret = 0;
41101:
41102: #if defined(LIBXML_UNICODE_ENABLED)
41103: int mem_base;
41104: int ret_val;
41105: int code; /* UCS code point */
41106: int n_code;
41107:
41108: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41109: mem_base = xmlMemBlocks();
41110: code = gen_int(n_code, 0);
41111:
41112: ret_val = xmlUCSIsLetterlikeSymbols(code);
41113: desret_int(ret_val);
41114: call_tests++;
41115: des_int(n_code, code, 0);
41116: xmlResetLastError();
41117: if (mem_base != xmlMemBlocks()) {
41118: printf("Leak of %d blocks found in xmlUCSIsLetterlikeSymbols",
41119: xmlMemBlocks() - mem_base);
41120: test_ret++;
41121: printf(" %d", n_code);
41122: printf("\n");
41123: }
41124: }
41125: function_tests++;
41126: #endif
41127:
41128: return(test_ret);
41129: }
41130:
41131:
41132: static int
41133: test_xmlUCSIsLimbu(void) {
41134: int test_ret = 0;
41135:
41136: #if defined(LIBXML_UNICODE_ENABLED)
41137: int mem_base;
41138: int ret_val;
41139: int code; /* UCS code point */
41140: int n_code;
41141:
41142: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41143: mem_base = xmlMemBlocks();
41144: code = gen_int(n_code, 0);
41145:
41146: ret_val = xmlUCSIsLimbu(code);
41147: desret_int(ret_val);
41148: call_tests++;
41149: des_int(n_code, code, 0);
41150: xmlResetLastError();
41151: if (mem_base != xmlMemBlocks()) {
41152: printf("Leak of %d blocks found in xmlUCSIsLimbu",
41153: xmlMemBlocks() - mem_base);
41154: test_ret++;
41155: printf(" %d", n_code);
41156: printf("\n");
41157: }
41158: }
41159: function_tests++;
41160: #endif
41161:
41162: return(test_ret);
41163: }
41164:
41165:
41166: static int
41167: test_xmlUCSIsLinearBIdeograms(void) {
41168: int test_ret = 0;
41169:
41170: #if defined(LIBXML_UNICODE_ENABLED)
41171: int mem_base;
41172: int ret_val;
41173: int code; /* UCS code point */
41174: int n_code;
41175:
41176: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41177: mem_base = xmlMemBlocks();
41178: code = gen_int(n_code, 0);
41179:
41180: ret_val = xmlUCSIsLinearBIdeograms(code);
41181: desret_int(ret_val);
41182: call_tests++;
41183: des_int(n_code, code, 0);
41184: xmlResetLastError();
41185: if (mem_base != xmlMemBlocks()) {
41186: printf("Leak of %d blocks found in xmlUCSIsLinearBIdeograms",
41187: xmlMemBlocks() - mem_base);
41188: test_ret++;
41189: printf(" %d", n_code);
41190: printf("\n");
41191: }
41192: }
41193: function_tests++;
41194: #endif
41195:
41196: return(test_ret);
41197: }
41198:
41199:
41200: static int
41201: test_xmlUCSIsLinearBSyllabary(void) {
41202: int test_ret = 0;
41203:
41204: #if defined(LIBXML_UNICODE_ENABLED)
41205: int mem_base;
41206: int ret_val;
41207: int code; /* UCS code point */
41208: int n_code;
41209:
41210: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41211: mem_base = xmlMemBlocks();
41212: code = gen_int(n_code, 0);
41213:
41214: ret_val = xmlUCSIsLinearBSyllabary(code);
41215: desret_int(ret_val);
41216: call_tests++;
41217: des_int(n_code, code, 0);
41218: xmlResetLastError();
41219: if (mem_base != xmlMemBlocks()) {
41220: printf("Leak of %d blocks found in xmlUCSIsLinearBSyllabary",
41221: xmlMemBlocks() - mem_base);
41222: test_ret++;
41223: printf(" %d", n_code);
41224: printf("\n");
41225: }
41226: }
41227: function_tests++;
41228: #endif
41229:
41230: return(test_ret);
41231: }
41232:
41233:
41234: static int
41235: test_xmlUCSIsLowSurrogates(void) {
41236: int test_ret = 0;
41237:
41238: #if defined(LIBXML_UNICODE_ENABLED)
41239: int mem_base;
41240: int ret_val;
41241: int code; /* UCS code point */
41242: int n_code;
41243:
41244: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41245: mem_base = xmlMemBlocks();
41246: code = gen_int(n_code, 0);
41247:
41248: ret_val = xmlUCSIsLowSurrogates(code);
41249: desret_int(ret_val);
41250: call_tests++;
41251: des_int(n_code, code, 0);
41252: xmlResetLastError();
41253: if (mem_base != xmlMemBlocks()) {
41254: printf("Leak of %d blocks found in xmlUCSIsLowSurrogates",
41255: xmlMemBlocks() - mem_base);
41256: test_ret++;
41257: printf(" %d", n_code);
41258: printf("\n");
41259: }
41260: }
41261: function_tests++;
41262: #endif
41263:
41264: return(test_ret);
41265: }
41266:
41267:
41268: static int
41269: test_xmlUCSIsMalayalam(void) {
41270: int test_ret = 0;
41271:
41272: #if defined(LIBXML_UNICODE_ENABLED)
41273: int mem_base;
41274: int ret_val;
41275: int code; /* UCS code point */
41276: int n_code;
41277:
41278: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41279: mem_base = xmlMemBlocks();
41280: code = gen_int(n_code, 0);
41281:
41282: ret_val = xmlUCSIsMalayalam(code);
41283: desret_int(ret_val);
41284: call_tests++;
41285: des_int(n_code, code, 0);
41286: xmlResetLastError();
41287: if (mem_base != xmlMemBlocks()) {
41288: printf("Leak of %d blocks found in xmlUCSIsMalayalam",
41289: xmlMemBlocks() - mem_base);
41290: test_ret++;
41291: printf(" %d", n_code);
41292: printf("\n");
41293: }
41294: }
41295: function_tests++;
41296: #endif
41297:
41298: return(test_ret);
41299: }
41300:
41301:
41302: static int
41303: test_xmlUCSIsMathematicalAlphanumericSymbols(void) {
41304: int test_ret = 0;
41305:
41306: #if defined(LIBXML_UNICODE_ENABLED)
41307: int mem_base;
41308: int ret_val;
41309: int code; /* UCS code point */
41310: int n_code;
41311:
41312: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41313: mem_base = xmlMemBlocks();
41314: code = gen_int(n_code, 0);
41315:
41316: ret_val = xmlUCSIsMathematicalAlphanumericSymbols(code);
41317: desret_int(ret_val);
41318: call_tests++;
41319: des_int(n_code, code, 0);
41320: xmlResetLastError();
41321: if (mem_base != xmlMemBlocks()) {
41322: printf("Leak of %d blocks found in xmlUCSIsMathematicalAlphanumericSymbols",
41323: xmlMemBlocks() - mem_base);
41324: test_ret++;
41325: printf(" %d", n_code);
41326: printf("\n");
41327: }
41328: }
41329: function_tests++;
41330: #endif
41331:
41332: return(test_ret);
41333: }
41334:
41335:
41336: static int
41337: test_xmlUCSIsMathematicalOperators(void) {
41338: int test_ret = 0;
41339:
41340: #if defined(LIBXML_UNICODE_ENABLED)
41341: int mem_base;
41342: int ret_val;
41343: int code; /* UCS code point */
41344: int n_code;
41345:
41346: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41347: mem_base = xmlMemBlocks();
41348: code = gen_int(n_code, 0);
41349:
41350: ret_val = xmlUCSIsMathematicalOperators(code);
41351: desret_int(ret_val);
41352: call_tests++;
41353: des_int(n_code, code, 0);
41354: xmlResetLastError();
41355: if (mem_base != xmlMemBlocks()) {
41356: printf("Leak of %d blocks found in xmlUCSIsMathematicalOperators",
41357: xmlMemBlocks() - mem_base);
41358: test_ret++;
41359: printf(" %d", n_code);
41360: printf("\n");
41361: }
41362: }
41363: function_tests++;
41364: #endif
41365:
41366: return(test_ret);
41367: }
41368:
41369:
41370: static int
41371: test_xmlUCSIsMiscellaneousMathematicalSymbolsA(void) {
41372: int test_ret = 0;
41373:
41374: #if defined(LIBXML_UNICODE_ENABLED)
41375: int mem_base;
41376: int ret_val;
41377: int code; /* UCS code point */
41378: int n_code;
41379:
41380: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41381: mem_base = xmlMemBlocks();
41382: code = gen_int(n_code, 0);
41383:
41384: ret_val = xmlUCSIsMiscellaneousMathematicalSymbolsA(code);
41385: desret_int(ret_val);
41386: call_tests++;
41387: des_int(n_code, code, 0);
41388: xmlResetLastError();
41389: if (mem_base != xmlMemBlocks()) {
41390: printf("Leak of %d blocks found in xmlUCSIsMiscellaneousMathematicalSymbolsA",
41391: xmlMemBlocks() - mem_base);
41392: test_ret++;
41393: printf(" %d", n_code);
41394: printf("\n");
41395: }
41396: }
41397: function_tests++;
41398: #endif
41399:
41400: return(test_ret);
41401: }
41402:
41403:
41404: static int
41405: test_xmlUCSIsMiscellaneousMathematicalSymbolsB(void) {
41406: int test_ret = 0;
41407:
41408: #if defined(LIBXML_UNICODE_ENABLED)
41409: int mem_base;
41410: int ret_val;
41411: int code; /* UCS code point */
41412: int n_code;
41413:
41414: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41415: mem_base = xmlMemBlocks();
41416: code = gen_int(n_code, 0);
41417:
41418: ret_val = xmlUCSIsMiscellaneousMathematicalSymbolsB(code);
41419: desret_int(ret_val);
41420: call_tests++;
41421: des_int(n_code, code, 0);
41422: xmlResetLastError();
41423: if (mem_base != xmlMemBlocks()) {
41424: printf("Leak of %d blocks found in xmlUCSIsMiscellaneousMathematicalSymbolsB",
41425: xmlMemBlocks() - mem_base);
41426: test_ret++;
41427: printf(" %d", n_code);
41428: printf("\n");
41429: }
41430: }
41431: function_tests++;
41432: #endif
41433:
41434: return(test_ret);
41435: }
41436:
41437:
41438: static int
41439: test_xmlUCSIsMiscellaneousSymbols(void) {
41440: int test_ret = 0;
41441:
41442: #if defined(LIBXML_UNICODE_ENABLED)
41443: int mem_base;
41444: int ret_val;
41445: int code; /* UCS code point */
41446: int n_code;
41447:
41448: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41449: mem_base = xmlMemBlocks();
41450: code = gen_int(n_code, 0);
41451:
41452: ret_val = xmlUCSIsMiscellaneousSymbols(code);
41453: desret_int(ret_val);
41454: call_tests++;
41455: des_int(n_code, code, 0);
41456: xmlResetLastError();
41457: if (mem_base != xmlMemBlocks()) {
41458: printf("Leak of %d blocks found in xmlUCSIsMiscellaneousSymbols",
41459: xmlMemBlocks() - mem_base);
41460: test_ret++;
41461: printf(" %d", n_code);
41462: printf("\n");
41463: }
41464: }
41465: function_tests++;
41466: #endif
41467:
41468: return(test_ret);
41469: }
41470:
41471:
41472: static int
41473: test_xmlUCSIsMiscellaneousSymbolsandArrows(void) {
41474: int test_ret = 0;
41475:
41476: #if defined(LIBXML_UNICODE_ENABLED)
41477: int mem_base;
41478: int ret_val;
41479: int code; /* UCS code point */
41480: int n_code;
41481:
41482: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41483: mem_base = xmlMemBlocks();
41484: code = gen_int(n_code, 0);
41485:
41486: ret_val = xmlUCSIsMiscellaneousSymbolsandArrows(code);
41487: desret_int(ret_val);
41488: call_tests++;
41489: des_int(n_code, code, 0);
41490: xmlResetLastError();
41491: if (mem_base != xmlMemBlocks()) {
41492: printf("Leak of %d blocks found in xmlUCSIsMiscellaneousSymbolsandArrows",
41493: xmlMemBlocks() - mem_base);
41494: test_ret++;
41495: printf(" %d", n_code);
41496: printf("\n");
41497: }
41498: }
41499: function_tests++;
41500: #endif
41501:
41502: return(test_ret);
41503: }
41504:
41505:
41506: static int
41507: test_xmlUCSIsMiscellaneousTechnical(void) {
41508: int test_ret = 0;
41509:
41510: #if defined(LIBXML_UNICODE_ENABLED)
41511: int mem_base;
41512: int ret_val;
41513: int code; /* UCS code point */
41514: int n_code;
41515:
41516: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41517: mem_base = xmlMemBlocks();
41518: code = gen_int(n_code, 0);
41519:
41520: ret_val = xmlUCSIsMiscellaneousTechnical(code);
41521: desret_int(ret_val);
41522: call_tests++;
41523: des_int(n_code, code, 0);
41524: xmlResetLastError();
41525: if (mem_base != xmlMemBlocks()) {
41526: printf("Leak of %d blocks found in xmlUCSIsMiscellaneousTechnical",
41527: xmlMemBlocks() - mem_base);
41528: test_ret++;
41529: printf(" %d", n_code);
41530: printf("\n");
41531: }
41532: }
41533: function_tests++;
41534: #endif
41535:
41536: return(test_ret);
41537: }
41538:
41539:
41540: static int
41541: test_xmlUCSIsMongolian(void) {
41542: int test_ret = 0;
41543:
41544: #if defined(LIBXML_UNICODE_ENABLED)
41545: int mem_base;
41546: int ret_val;
41547: int code; /* UCS code point */
41548: int n_code;
41549:
41550: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41551: mem_base = xmlMemBlocks();
41552: code = gen_int(n_code, 0);
41553:
41554: ret_val = xmlUCSIsMongolian(code);
41555: desret_int(ret_val);
41556: call_tests++;
41557: des_int(n_code, code, 0);
41558: xmlResetLastError();
41559: if (mem_base != xmlMemBlocks()) {
41560: printf("Leak of %d blocks found in xmlUCSIsMongolian",
41561: xmlMemBlocks() - mem_base);
41562: test_ret++;
41563: printf(" %d", n_code);
41564: printf("\n");
41565: }
41566: }
41567: function_tests++;
41568: #endif
41569:
41570: return(test_ret);
41571: }
41572:
41573:
41574: static int
41575: test_xmlUCSIsMusicalSymbols(void) {
41576: int test_ret = 0;
41577:
41578: #if defined(LIBXML_UNICODE_ENABLED)
41579: int mem_base;
41580: int ret_val;
41581: int code; /* UCS code point */
41582: int n_code;
41583:
41584: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41585: mem_base = xmlMemBlocks();
41586: code = gen_int(n_code, 0);
41587:
41588: ret_val = xmlUCSIsMusicalSymbols(code);
41589: desret_int(ret_val);
41590: call_tests++;
41591: des_int(n_code, code, 0);
41592: xmlResetLastError();
41593: if (mem_base != xmlMemBlocks()) {
41594: printf("Leak of %d blocks found in xmlUCSIsMusicalSymbols",
41595: xmlMemBlocks() - mem_base);
41596: test_ret++;
41597: printf(" %d", n_code);
41598: printf("\n");
41599: }
41600: }
41601: function_tests++;
41602: #endif
41603:
41604: return(test_ret);
41605: }
41606:
41607:
41608: static int
41609: test_xmlUCSIsMyanmar(void) {
41610: int test_ret = 0;
41611:
41612: #if defined(LIBXML_UNICODE_ENABLED)
41613: int mem_base;
41614: int ret_val;
41615: int code; /* UCS code point */
41616: int n_code;
41617:
41618: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41619: mem_base = xmlMemBlocks();
41620: code = gen_int(n_code, 0);
41621:
41622: ret_val = xmlUCSIsMyanmar(code);
41623: desret_int(ret_val);
41624: call_tests++;
41625: des_int(n_code, code, 0);
41626: xmlResetLastError();
41627: if (mem_base != xmlMemBlocks()) {
41628: printf("Leak of %d blocks found in xmlUCSIsMyanmar",
41629: xmlMemBlocks() - mem_base);
41630: test_ret++;
41631: printf(" %d", n_code);
41632: printf("\n");
41633: }
41634: }
41635: function_tests++;
41636: #endif
41637:
41638: return(test_ret);
41639: }
41640:
41641:
41642: static int
41643: test_xmlUCSIsNumberForms(void) {
41644: int test_ret = 0;
41645:
41646: #if defined(LIBXML_UNICODE_ENABLED)
41647: int mem_base;
41648: int ret_val;
41649: int code; /* UCS code point */
41650: int n_code;
41651:
41652: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41653: mem_base = xmlMemBlocks();
41654: code = gen_int(n_code, 0);
41655:
41656: ret_val = xmlUCSIsNumberForms(code);
41657: desret_int(ret_val);
41658: call_tests++;
41659: des_int(n_code, code, 0);
41660: xmlResetLastError();
41661: if (mem_base != xmlMemBlocks()) {
41662: printf("Leak of %d blocks found in xmlUCSIsNumberForms",
41663: xmlMemBlocks() - mem_base);
41664: test_ret++;
41665: printf(" %d", n_code);
41666: printf("\n");
41667: }
41668: }
41669: function_tests++;
41670: #endif
41671:
41672: return(test_ret);
41673: }
41674:
41675:
41676: static int
41677: test_xmlUCSIsOgham(void) {
41678: int test_ret = 0;
41679:
41680: #if defined(LIBXML_UNICODE_ENABLED)
41681: int mem_base;
41682: int ret_val;
41683: int code; /* UCS code point */
41684: int n_code;
41685:
41686: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41687: mem_base = xmlMemBlocks();
41688: code = gen_int(n_code, 0);
41689:
41690: ret_val = xmlUCSIsOgham(code);
41691: desret_int(ret_val);
41692: call_tests++;
41693: des_int(n_code, code, 0);
41694: xmlResetLastError();
41695: if (mem_base != xmlMemBlocks()) {
41696: printf("Leak of %d blocks found in xmlUCSIsOgham",
41697: xmlMemBlocks() - mem_base);
41698: test_ret++;
41699: printf(" %d", n_code);
41700: printf("\n");
41701: }
41702: }
41703: function_tests++;
41704: #endif
41705:
41706: return(test_ret);
41707: }
41708:
41709:
41710: static int
41711: test_xmlUCSIsOldItalic(void) {
41712: int test_ret = 0;
41713:
41714: #if defined(LIBXML_UNICODE_ENABLED)
41715: int mem_base;
41716: int ret_val;
41717: int code; /* UCS code point */
41718: int n_code;
41719:
41720: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41721: mem_base = xmlMemBlocks();
41722: code = gen_int(n_code, 0);
41723:
41724: ret_val = xmlUCSIsOldItalic(code);
41725: desret_int(ret_val);
41726: call_tests++;
41727: des_int(n_code, code, 0);
41728: xmlResetLastError();
41729: if (mem_base != xmlMemBlocks()) {
41730: printf("Leak of %d blocks found in xmlUCSIsOldItalic",
41731: xmlMemBlocks() - mem_base);
41732: test_ret++;
41733: printf(" %d", n_code);
41734: printf("\n");
41735: }
41736: }
41737: function_tests++;
41738: #endif
41739:
41740: return(test_ret);
41741: }
41742:
41743:
41744: static int
41745: test_xmlUCSIsOpticalCharacterRecognition(void) {
41746: int test_ret = 0;
41747:
41748: #if defined(LIBXML_UNICODE_ENABLED)
41749: int mem_base;
41750: int ret_val;
41751: int code; /* UCS code point */
41752: int n_code;
41753:
41754: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41755: mem_base = xmlMemBlocks();
41756: code = gen_int(n_code, 0);
41757:
41758: ret_val = xmlUCSIsOpticalCharacterRecognition(code);
41759: desret_int(ret_val);
41760: call_tests++;
41761: des_int(n_code, code, 0);
41762: xmlResetLastError();
41763: if (mem_base != xmlMemBlocks()) {
41764: printf("Leak of %d blocks found in xmlUCSIsOpticalCharacterRecognition",
41765: xmlMemBlocks() - mem_base);
41766: test_ret++;
41767: printf(" %d", n_code);
41768: printf("\n");
41769: }
41770: }
41771: function_tests++;
41772: #endif
41773:
41774: return(test_ret);
41775: }
41776:
41777:
41778: static int
41779: test_xmlUCSIsOriya(void) {
41780: int test_ret = 0;
41781:
41782: #if defined(LIBXML_UNICODE_ENABLED)
41783: int mem_base;
41784: int ret_val;
41785: int code; /* UCS code point */
41786: int n_code;
41787:
41788: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41789: mem_base = xmlMemBlocks();
41790: code = gen_int(n_code, 0);
41791:
41792: ret_val = xmlUCSIsOriya(code);
41793: desret_int(ret_val);
41794: call_tests++;
41795: des_int(n_code, code, 0);
41796: xmlResetLastError();
41797: if (mem_base != xmlMemBlocks()) {
41798: printf("Leak of %d blocks found in xmlUCSIsOriya",
41799: xmlMemBlocks() - mem_base);
41800: test_ret++;
41801: printf(" %d", n_code);
41802: printf("\n");
41803: }
41804: }
41805: function_tests++;
41806: #endif
41807:
41808: return(test_ret);
41809: }
41810:
41811:
41812: static int
41813: test_xmlUCSIsOsmanya(void) {
41814: int test_ret = 0;
41815:
41816: #if defined(LIBXML_UNICODE_ENABLED)
41817: int mem_base;
41818: int ret_val;
41819: int code; /* UCS code point */
41820: int n_code;
41821:
41822: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41823: mem_base = xmlMemBlocks();
41824: code = gen_int(n_code, 0);
41825:
41826: ret_val = xmlUCSIsOsmanya(code);
41827: desret_int(ret_val);
41828: call_tests++;
41829: des_int(n_code, code, 0);
41830: xmlResetLastError();
41831: if (mem_base != xmlMemBlocks()) {
41832: printf("Leak of %d blocks found in xmlUCSIsOsmanya",
41833: xmlMemBlocks() - mem_base);
41834: test_ret++;
41835: printf(" %d", n_code);
41836: printf("\n");
41837: }
41838: }
41839: function_tests++;
41840: #endif
41841:
41842: return(test_ret);
41843: }
41844:
41845:
41846: static int
41847: test_xmlUCSIsPhoneticExtensions(void) {
41848: int test_ret = 0;
41849:
41850: #if defined(LIBXML_UNICODE_ENABLED)
41851: int mem_base;
41852: int ret_val;
41853: int code; /* UCS code point */
41854: int n_code;
41855:
41856: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41857: mem_base = xmlMemBlocks();
41858: code = gen_int(n_code, 0);
41859:
41860: ret_val = xmlUCSIsPhoneticExtensions(code);
41861: desret_int(ret_val);
41862: call_tests++;
41863: des_int(n_code, code, 0);
41864: xmlResetLastError();
41865: if (mem_base != xmlMemBlocks()) {
41866: printf("Leak of %d blocks found in xmlUCSIsPhoneticExtensions",
41867: xmlMemBlocks() - mem_base);
41868: test_ret++;
41869: printf(" %d", n_code);
41870: printf("\n");
41871: }
41872: }
41873: function_tests++;
41874: #endif
41875:
41876: return(test_ret);
41877: }
41878:
41879:
41880: static int
41881: test_xmlUCSIsPrivateUse(void) {
41882: int test_ret = 0;
41883:
41884: #if defined(LIBXML_UNICODE_ENABLED)
41885: int mem_base;
41886: int ret_val;
41887: int code; /* UCS code point */
41888: int n_code;
41889:
41890: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41891: mem_base = xmlMemBlocks();
41892: code = gen_int(n_code, 0);
41893:
41894: ret_val = xmlUCSIsPrivateUse(code);
41895: desret_int(ret_val);
41896: call_tests++;
41897: des_int(n_code, code, 0);
41898: xmlResetLastError();
41899: if (mem_base != xmlMemBlocks()) {
41900: printf("Leak of %d blocks found in xmlUCSIsPrivateUse",
41901: xmlMemBlocks() - mem_base);
41902: test_ret++;
41903: printf(" %d", n_code);
41904: printf("\n");
41905: }
41906: }
41907: function_tests++;
41908: #endif
41909:
41910: return(test_ret);
41911: }
41912:
41913:
41914: static int
41915: test_xmlUCSIsPrivateUseArea(void) {
41916: int test_ret = 0;
41917:
41918: #if defined(LIBXML_UNICODE_ENABLED)
41919: int mem_base;
41920: int ret_val;
41921: int code; /* UCS code point */
41922: int n_code;
41923:
41924: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41925: mem_base = xmlMemBlocks();
41926: code = gen_int(n_code, 0);
41927:
41928: ret_val = xmlUCSIsPrivateUseArea(code);
41929: desret_int(ret_val);
41930: call_tests++;
41931: des_int(n_code, code, 0);
41932: xmlResetLastError();
41933: if (mem_base != xmlMemBlocks()) {
41934: printf("Leak of %d blocks found in xmlUCSIsPrivateUseArea",
41935: xmlMemBlocks() - mem_base);
41936: test_ret++;
41937: printf(" %d", n_code);
41938: printf("\n");
41939: }
41940: }
41941: function_tests++;
41942: #endif
41943:
41944: return(test_ret);
41945: }
41946:
41947:
41948: static int
41949: test_xmlUCSIsRunic(void) {
41950: int test_ret = 0;
41951:
41952: #if defined(LIBXML_UNICODE_ENABLED)
41953: int mem_base;
41954: int ret_val;
41955: int code; /* UCS code point */
41956: int n_code;
41957:
41958: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41959: mem_base = xmlMemBlocks();
41960: code = gen_int(n_code, 0);
41961:
41962: ret_val = xmlUCSIsRunic(code);
41963: desret_int(ret_val);
41964: call_tests++;
41965: des_int(n_code, code, 0);
41966: xmlResetLastError();
41967: if (mem_base != xmlMemBlocks()) {
41968: printf("Leak of %d blocks found in xmlUCSIsRunic",
41969: xmlMemBlocks() - mem_base);
41970: test_ret++;
41971: printf(" %d", n_code);
41972: printf("\n");
41973: }
41974: }
41975: function_tests++;
41976: #endif
41977:
41978: return(test_ret);
41979: }
41980:
41981:
41982: static int
41983: test_xmlUCSIsShavian(void) {
41984: int test_ret = 0;
41985:
41986: #if defined(LIBXML_UNICODE_ENABLED)
41987: int mem_base;
41988: int ret_val;
41989: int code; /* UCS code point */
41990: int n_code;
41991:
41992: for (n_code = 0;n_code < gen_nb_int;n_code++) {
41993: mem_base = xmlMemBlocks();
41994: code = gen_int(n_code, 0);
41995:
41996: ret_val = xmlUCSIsShavian(code);
41997: desret_int(ret_val);
41998: call_tests++;
41999: des_int(n_code, code, 0);
42000: xmlResetLastError();
42001: if (mem_base != xmlMemBlocks()) {
42002: printf("Leak of %d blocks found in xmlUCSIsShavian",
42003: xmlMemBlocks() - mem_base);
42004: test_ret++;
42005: printf(" %d", n_code);
42006: printf("\n");
42007: }
42008: }
42009: function_tests++;
42010: #endif
42011:
42012: return(test_ret);
42013: }
42014:
42015:
42016: static int
42017: test_xmlUCSIsSinhala(void) {
42018: int test_ret = 0;
42019:
42020: #if defined(LIBXML_UNICODE_ENABLED)
42021: int mem_base;
42022: int ret_val;
42023: int code; /* UCS code point */
42024: int n_code;
42025:
42026: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42027: mem_base = xmlMemBlocks();
42028: code = gen_int(n_code, 0);
42029:
42030: ret_val = xmlUCSIsSinhala(code);
42031: desret_int(ret_val);
42032: call_tests++;
42033: des_int(n_code, code, 0);
42034: xmlResetLastError();
42035: if (mem_base != xmlMemBlocks()) {
42036: printf("Leak of %d blocks found in xmlUCSIsSinhala",
42037: xmlMemBlocks() - mem_base);
42038: test_ret++;
42039: printf(" %d", n_code);
42040: printf("\n");
42041: }
42042: }
42043: function_tests++;
42044: #endif
42045:
42046: return(test_ret);
42047: }
42048:
42049:
42050: static int
42051: test_xmlUCSIsSmallFormVariants(void) {
42052: int test_ret = 0;
42053:
42054: #if defined(LIBXML_UNICODE_ENABLED)
42055: int mem_base;
42056: int ret_val;
42057: int code; /* UCS code point */
42058: int n_code;
42059:
42060: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42061: mem_base = xmlMemBlocks();
42062: code = gen_int(n_code, 0);
42063:
42064: ret_val = xmlUCSIsSmallFormVariants(code);
42065: desret_int(ret_val);
42066: call_tests++;
42067: des_int(n_code, code, 0);
42068: xmlResetLastError();
42069: if (mem_base != xmlMemBlocks()) {
42070: printf("Leak of %d blocks found in xmlUCSIsSmallFormVariants",
42071: xmlMemBlocks() - mem_base);
42072: test_ret++;
42073: printf(" %d", n_code);
42074: printf("\n");
42075: }
42076: }
42077: function_tests++;
42078: #endif
42079:
42080: return(test_ret);
42081: }
42082:
42083:
42084: static int
42085: test_xmlUCSIsSpacingModifierLetters(void) {
42086: int test_ret = 0;
42087:
42088: #if defined(LIBXML_UNICODE_ENABLED)
42089: int mem_base;
42090: int ret_val;
42091: int code; /* UCS code point */
42092: int n_code;
42093:
42094: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42095: mem_base = xmlMemBlocks();
42096: code = gen_int(n_code, 0);
42097:
42098: ret_val = xmlUCSIsSpacingModifierLetters(code);
42099: desret_int(ret_val);
42100: call_tests++;
42101: des_int(n_code, code, 0);
42102: xmlResetLastError();
42103: if (mem_base != xmlMemBlocks()) {
42104: printf("Leak of %d blocks found in xmlUCSIsSpacingModifierLetters",
42105: xmlMemBlocks() - mem_base);
42106: test_ret++;
42107: printf(" %d", n_code);
42108: printf("\n");
42109: }
42110: }
42111: function_tests++;
42112: #endif
42113:
42114: return(test_ret);
42115: }
42116:
42117:
42118: static int
42119: test_xmlUCSIsSpecials(void) {
42120: int test_ret = 0;
42121:
42122: #if defined(LIBXML_UNICODE_ENABLED)
42123: int mem_base;
42124: int ret_val;
42125: int code; /* UCS code point */
42126: int n_code;
42127:
42128: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42129: mem_base = xmlMemBlocks();
42130: code = gen_int(n_code, 0);
42131:
42132: ret_val = xmlUCSIsSpecials(code);
42133: desret_int(ret_val);
42134: call_tests++;
42135: des_int(n_code, code, 0);
42136: xmlResetLastError();
42137: if (mem_base != xmlMemBlocks()) {
42138: printf("Leak of %d blocks found in xmlUCSIsSpecials",
42139: xmlMemBlocks() - mem_base);
42140: test_ret++;
42141: printf(" %d", n_code);
42142: printf("\n");
42143: }
42144: }
42145: function_tests++;
42146: #endif
42147:
42148: return(test_ret);
42149: }
42150:
42151:
42152: static int
42153: test_xmlUCSIsSuperscriptsandSubscripts(void) {
42154: int test_ret = 0;
42155:
42156: #if defined(LIBXML_UNICODE_ENABLED)
42157: int mem_base;
42158: int ret_val;
42159: int code; /* UCS code point */
42160: int n_code;
42161:
42162: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42163: mem_base = xmlMemBlocks();
42164: code = gen_int(n_code, 0);
42165:
42166: ret_val = xmlUCSIsSuperscriptsandSubscripts(code);
42167: desret_int(ret_val);
42168: call_tests++;
42169: des_int(n_code, code, 0);
42170: xmlResetLastError();
42171: if (mem_base != xmlMemBlocks()) {
42172: printf("Leak of %d blocks found in xmlUCSIsSuperscriptsandSubscripts",
42173: xmlMemBlocks() - mem_base);
42174: test_ret++;
42175: printf(" %d", n_code);
42176: printf("\n");
42177: }
42178: }
42179: function_tests++;
42180: #endif
42181:
42182: return(test_ret);
42183: }
42184:
42185:
42186: static int
42187: test_xmlUCSIsSupplementalArrowsA(void) {
42188: int test_ret = 0;
42189:
42190: #if defined(LIBXML_UNICODE_ENABLED)
42191: int mem_base;
42192: int ret_val;
42193: int code; /* UCS code point */
42194: int n_code;
42195:
42196: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42197: mem_base = xmlMemBlocks();
42198: code = gen_int(n_code, 0);
42199:
42200: ret_val = xmlUCSIsSupplementalArrowsA(code);
42201: desret_int(ret_val);
42202: call_tests++;
42203: des_int(n_code, code, 0);
42204: xmlResetLastError();
42205: if (mem_base != xmlMemBlocks()) {
42206: printf("Leak of %d blocks found in xmlUCSIsSupplementalArrowsA",
42207: xmlMemBlocks() - mem_base);
42208: test_ret++;
42209: printf(" %d", n_code);
42210: printf("\n");
42211: }
42212: }
42213: function_tests++;
42214: #endif
42215:
42216: return(test_ret);
42217: }
42218:
42219:
42220: static int
42221: test_xmlUCSIsSupplementalArrowsB(void) {
42222: int test_ret = 0;
42223:
42224: #if defined(LIBXML_UNICODE_ENABLED)
42225: int mem_base;
42226: int ret_val;
42227: int code; /* UCS code point */
42228: int n_code;
42229:
42230: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42231: mem_base = xmlMemBlocks();
42232: code = gen_int(n_code, 0);
42233:
42234: ret_val = xmlUCSIsSupplementalArrowsB(code);
42235: desret_int(ret_val);
42236: call_tests++;
42237: des_int(n_code, code, 0);
42238: xmlResetLastError();
42239: if (mem_base != xmlMemBlocks()) {
42240: printf("Leak of %d blocks found in xmlUCSIsSupplementalArrowsB",
42241: xmlMemBlocks() - mem_base);
42242: test_ret++;
42243: printf(" %d", n_code);
42244: printf("\n");
42245: }
42246: }
42247: function_tests++;
42248: #endif
42249:
42250: return(test_ret);
42251: }
42252:
42253:
42254: static int
42255: test_xmlUCSIsSupplementalMathematicalOperators(void) {
42256: int test_ret = 0;
42257:
42258: #if defined(LIBXML_UNICODE_ENABLED)
42259: int mem_base;
42260: int ret_val;
42261: int code; /* UCS code point */
42262: int n_code;
42263:
42264: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42265: mem_base = xmlMemBlocks();
42266: code = gen_int(n_code, 0);
42267:
42268: ret_val = xmlUCSIsSupplementalMathematicalOperators(code);
42269: desret_int(ret_val);
42270: call_tests++;
42271: des_int(n_code, code, 0);
42272: xmlResetLastError();
42273: if (mem_base != xmlMemBlocks()) {
42274: printf("Leak of %d blocks found in xmlUCSIsSupplementalMathematicalOperators",
42275: xmlMemBlocks() - mem_base);
42276: test_ret++;
42277: printf(" %d", n_code);
42278: printf("\n");
42279: }
42280: }
42281: function_tests++;
42282: #endif
42283:
42284: return(test_ret);
42285: }
42286:
42287:
42288: static int
42289: test_xmlUCSIsSupplementaryPrivateUseAreaA(void) {
42290: int test_ret = 0;
42291:
42292: #if defined(LIBXML_UNICODE_ENABLED)
42293: int mem_base;
42294: int ret_val;
42295: int code; /* UCS code point */
42296: int n_code;
42297:
42298: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42299: mem_base = xmlMemBlocks();
42300: code = gen_int(n_code, 0);
42301:
42302: ret_val = xmlUCSIsSupplementaryPrivateUseAreaA(code);
42303: desret_int(ret_val);
42304: call_tests++;
42305: des_int(n_code, code, 0);
42306: xmlResetLastError();
42307: if (mem_base != xmlMemBlocks()) {
42308: printf("Leak of %d blocks found in xmlUCSIsSupplementaryPrivateUseAreaA",
42309: xmlMemBlocks() - mem_base);
42310: test_ret++;
42311: printf(" %d", n_code);
42312: printf("\n");
42313: }
42314: }
42315: function_tests++;
42316: #endif
42317:
42318: return(test_ret);
42319: }
42320:
42321:
42322: static int
42323: test_xmlUCSIsSupplementaryPrivateUseAreaB(void) {
42324: int test_ret = 0;
42325:
42326: #if defined(LIBXML_UNICODE_ENABLED)
42327: int mem_base;
42328: int ret_val;
42329: int code; /* UCS code point */
42330: int n_code;
42331:
42332: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42333: mem_base = xmlMemBlocks();
42334: code = gen_int(n_code, 0);
42335:
42336: ret_val = xmlUCSIsSupplementaryPrivateUseAreaB(code);
42337: desret_int(ret_val);
42338: call_tests++;
42339: des_int(n_code, code, 0);
42340: xmlResetLastError();
42341: if (mem_base != xmlMemBlocks()) {
42342: printf("Leak of %d blocks found in xmlUCSIsSupplementaryPrivateUseAreaB",
42343: xmlMemBlocks() - mem_base);
42344: test_ret++;
42345: printf(" %d", n_code);
42346: printf("\n");
42347: }
42348: }
42349: function_tests++;
42350: #endif
42351:
42352: return(test_ret);
42353: }
42354:
42355:
42356: static int
42357: test_xmlUCSIsSyriac(void) {
42358: int test_ret = 0;
42359:
42360: #if defined(LIBXML_UNICODE_ENABLED)
42361: int mem_base;
42362: int ret_val;
42363: int code; /* UCS code point */
42364: int n_code;
42365:
42366: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42367: mem_base = xmlMemBlocks();
42368: code = gen_int(n_code, 0);
42369:
42370: ret_val = xmlUCSIsSyriac(code);
42371: desret_int(ret_val);
42372: call_tests++;
42373: des_int(n_code, code, 0);
42374: xmlResetLastError();
42375: if (mem_base != xmlMemBlocks()) {
42376: printf("Leak of %d blocks found in xmlUCSIsSyriac",
42377: xmlMemBlocks() - mem_base);
42378: test_ret++;
42379: printf(" %d", n_code);
42380: printf("\n");
42381: }
42382: }
42383: function_tests++;
42384: #endif
42385:
42386: return(test_ret);
42387: }
42388:
42389:
42390: static int
42391: test_xmlUCSIsTagalog(void) {
42392: int test_ret = 0;
42393:
42394: #if defined(LIBXML_UNICODE_ENABLED)
42395: int mem_base;
42396: int ret_val;
42397: int code; /* UCS code point */
42398: int n_code;
42399:
42400: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42401: mem_base = xmlMemBlocks();
42402: code = gen_int(n_code, 0);
42403:
42404: ret_val = xmlUCSIsTagalog(code);
42405: desret_int(ret_val);
42406: call_tests++;
42407: des_int(n_code, code, 0);
42408: xmlResetLastError();
42409: if (mem_base != xmlMemBlocks()) {
42410: printf("Leak of %d blocks found in xmlUCSIsTagalog",
42411: xmlMemBlocks() - mem_base);
42412: test_ret++;
42413: printf(" %d", n_code);
42414: printf("\n");
42415: }
42416: }
42417: function_tests++;
42418: #endif
42419:
42420: return(test_ret);
42421: }
42422:
42423:
42424: static int
42425: test_xmlUCSIsTagbanwa(void) {
42426: int test_ret = 0;
42427:
42428: #if defined(LIBXML_UNICODE_ENABLED)
42429: int mem_base;
42430: int ret_val;
42431: int code; /* UCS code point */
42432: int n_code;
42433:
42434: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42435: mem_base = xmlMemBlocks();
42436: code = gen_int(n_code, 0);
42437:
42438: ret_val = xmlUCSIsTagbanwa(code);
42439: desret_int(ret_val);
42440: call_tests++;
42441: des_int(n_code, code, 0);
42442: xmlResetLastError();
42443: if (mem_base != xmlMemBlocks()) {
42444: printf("Leak of %d blocks found in xmlUCSIsTagbanwa",
42445: xmlMemBlocks() - mem_base);
42446: test_ret++;
42447: printf(" %d", n_code);
42448: printf("\n");
42449: }
42450: }
42451: function_tests++;
42452: #endif
42453:
42454: return(test_ret);
42455: }
42456:
42457:
42458: static int
42459: test_xmlUCSIsTags(void) {
42460: int test_ret = 0;
42461:
42462: #if defined(LIBXML_UNICODE_ENABLED)
42463: int mem_base;
42464: int ret_val;
42465: int code; /* UCS code point */
42466: int n_code;
42467:
42468: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42469: mem_base = xmlMemBlocks();
42470: code = gen_int(n_code, 0);
42471:
42472: ret_val = xmlUCSIsTags(code);
42473: desret_int(ret_val);
42474: call_tests++;
42475: des_int(n_code, code, 0);
42476: xmlResetLastError();
42477: if (mem_base != xmlMemBlocks()) {
42478: printf("Leak of %d blocks found in xmlUCSIsTags",
42479: xmlMemBlocks() - mem_base);
42480: test_ret++;
42481: printf(" %d", n_code);
42482: printf("\n");
42483: }
42484: }
42485: function_tests++;
42486: #endif
42487:
42488: return(test_ret);
42489: }
42490:
42491:
42492: static int
42493: test_xmlUCSIsTaiLe(void) {
42494: int test_ret = 0;
42495:
42496: #if defined(LIBXML_UNICODE_ENABLED)
42497: int mem_base;
42498: int ret_val;
42499: int code; /* UCS code point */
42500: int n_code;
42501:
42502: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42503: mem_base = xmlMemBlocks();
42504: code = gen_int(n_code, 0);
42505:
42506: ret_val = xmlUCSIsTaiLe(code);
42507: desret_int(ret_val);
42508: call_tests++;
42509: des_int(n_code, code, 0);
42510: xmlResetLastError();
42511: if (mem_base != xmlMemBlocks()) {
42512: printf("Leak of %d blocks found in xmlUCSIsTaiLe",
42513: xmlMemBlocks() - mem_base);
42514: test_ret++;
42515: printf(" %d", n_code);
42516: printf("\n");
42517: }
42518: }
42519: function_tests++;
42520: #endif
42521:
42522: return(test_ret);
42523: }
42524:
42525:
42526: static int
42527: test_xmlUCSIsTaiXuanJingSymbols(void) {
42528: int test_ret = 0;
42529:
42530: #if defined(LIBXML_UNICODE_ENABLED)
42531: int mem_base;
42532: int ret_val;
42533: int code; /* UCS code point */
42534: int n_code;
42535:
42536: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42537: mem_base = xmlMemBlocks();
42538: code = gen_int(n_code, 0);
42539:
42540: ret_val = xmlUCSIsTaiXuanJingSymbols(code);
42541: desret_int(ret_val);
42542: call_tests++;
42543: des_int(n_code, code, 0);
42544: xmlResetLastError();
42545: if (mem_base != xmlMemBlocks()) {
42546: printf("Leak of %d blocks found in xmlUCSIsTaiXuanJingSymbols",
42547: xmlMemBlocks() - mem_base);
42548: test_ret++;
42549: printf(" %d", n_code);
42550: printf("\n");
42551: }
42552: }
42553: function_tests++;
42554: #endif
42555:
42556: return(test_ret);
42557: }
42558:
42559:
42560: static int
42561: test_xmlUCSIsTamil(void) {
42562: int test_ret = 0;
42563:
42564: #if defined(LIBXML_UNICODE_ENABLED)
42565: int mem_base;
42566: int ret_val;
42567: int code; /* UCS code point */
42568: int n_code;
42569:
42570: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42571: mem_base = xmlMemBlocks();
42572: code = gen_int(n_code, 0);
42573:
42574: ret_val = xmlUCSIsTamil(code);
42575: desret_int(ret_val);
42576: call_tests++;
42577: des_int(n_code, code, 0);
42578: xmlResetLastError();
42579: if (mem_base != xmlMemBlocks()) {
42580: printf("Leak of %d blocks found in xmlUCSIsTamil",
42581: xmlMemBlocks() - mem_base);
42582: test_ret++;
42583: printf(" %d", n_code);
42584: printf("\n");
42585: }
42586: }
42587: function_tests++;
42588: #endif
42589:
42590: return(test_ret);
42591: }
42592:
42593:
42594: static int
42595: test_xmlUCSIsTelugu(void) {
42596: int test_ret = 0;
42597:
42598: #if defined(LIBXML_UNICODE_ENABLED)
42599: int mem_base;
42600: int ret_val;
42601: int code; /* UCS code point */
42602: int n_code;
42603:
42604: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42605: mem_base = xmlMemBlocks();
42606: code = gen_int(n_code, 0);
42607:
42608: ret_val = xmlUCSIsTelugu(code);
42609: desret_int(ret_val);
42610: call_tests++;
42611: des_int(n_code, code, 0);
42612: xmlResetLastError();
42613: if (mem_base != xmlMemBlocks()) {
42614: printf("Leak of %d blocks found in xmlUCSIsTelugu",
42615: xmlMemBlocks() - mem_base);
42616: test_ret++;
42617: printf(" %d", n_code);
42618: printf("\n");
42619: }
42620: }
42621: function_tests++;
42622: #endif
42623:
42624: return(test_ret);
42625: }
42626:
42627:
42628: static int
42629: test_xmlUCSIsThaana(void) {
42630: int test_ret = 0;
42631:
42632: #if defined(LIBXML_UNICODE_ENABLED)
42633: int mem_base;
42634: int ret_val;
42635: int code; /* UCS code point */
42636: int n_code;
42637:
42638: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42639: mem_base = xmlMemBlocks();
42640: code = gen_int(n_code, 0);
42641:
42642: ret_val = xmlUCSIsThaana(code);
42643: desret_int(ret_val);
42644: call_tests++;
42645: des_int(n_code, code, 0);
42646: xmlResetLastError();
42647: if (mem_base != xmlMemBlocks()) {
42648: printf("Leak of %d blocks found in xmlUCSIsThaana",
42649: xmlMemBlocks() - mem_base);
42650: test_ret++;
42651: printf(" %d", n_code);
42652: printf("\n");
42653: }
42654: }
42655: function_tests++;
42656: #endif
42657:
42658: return(test_ret);
42659: }
42660:
42661:
42662: static int
42663: test_xmlUCSIsThai(void) {
42664: int test_ret = 0;
42665:
42666: #if defined(LIBXML_UNICODE_ENABLED)
42667: int mem_base;
42668: int ret_val;
42669: int code; /* UCS code point */
42670: int n_code;
42671:
42672: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42673: mem_base = xmlMemBlocks();
42674: code = gen_int(n_code, 0);
42675:
42676: ret_val = xmlUCSIsThai(code);
42677: desret_int(ret_val);
42678: call_tests++;
42679: des_int(n_code, code, 0);
42680: xmlResetLastError();
42681: if (mem_base != xmlMemBlocks()) {
42682: printf("Leak of %d blocks found in xmlUCSIsThai",
42683: xmlMemBlocks() - mem_base);
42684: test_ret++;
42685: printf(" %d", n_code);
42686: printf("\n");
42687: }
42688: }
42689: function_tests++;
42690: #endif
42691:
42692: return(test_ret);
42693: }
42694:
42695:
42696: static int
42697: test_xmlUCSIsTibetan(void) {
42698: int test_ret = 0;
42699:
42700: #if defined(LIBXML_UNICODE_ENABLED)
42701: int mem_base;
42702: int ret_val;
42703: int code; /* UCS code point */
42704: int n_code;
42705:
42706: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42707: mem_base = xmlMemBlocks();
42708: code = gen_int(n_code, 0);
42709:
42710: ret_val = xmlUCSIsTibetan(code);
42711: desret_int(ret_val);
42712: call_tests++;
42713: des_int(n_code, code, 0);
42714: xmlResetLastError();
42715: if (mem_base != xmlMemBlocks()) {
42716: printf("Leak of %d blocks found in xmlUCSIsTibetan",
42717: xmlMemBlocks() - mem_base);
42718: test_ret++;
42719: printf(" %d", n_code);
42720: printf("\n");
42721: }
42722: }
42723: function_tests++;
42724: #endif
42725:
42726: return(test_ret);
42727: }
42728:
42729:
42730: static int
42731: test_xmlUCSIsUgaritic(void) {
42732: int test_ret = 0;
42733:
42734: #if defined(LIBXML_UNICODE_ENABLED)
42735: int mem_base;
42736: int ret_val;
42737: int code; /* UCS code point */
42738: int n_code;
42739:
42740: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42741: mem_base = xmlMemBlocks();
42742: code = gen_int(n_code, 0);
42743:
42744: ret_val = xmlUCSIsUgaritic(code);
42745: desret_int(ret_val);
42746: call_tests++;
42747: des_int(n_code, code, 0);
42748: xmlResetLastError();
42749: if (mem_base != xmlMemBlocks()) {
42750: printf("Leak of %d blocks found in xmlUCSIsUgaritic",
42751: xmlMemBlocks() - mem_base);
42752: test_ret++;
42753: printf(" %d", n_code);
42754: printf("\n");
42755: }
42756: }
42757: function_tests++;
42758: #endif
42759:
42760: return(test_ret);
42761: }
42762:
42763:
42764: static int
42765: test_xmlUCSIsUnifiedCanadianAboriginalSyllabics(void) {
42766: int test_ret = 0;
42767:
42768: #if defined(LIBXML_UNICODE_ENABLED)
42769: int mem_base;
42770: int ret_val;
42771: int code; /* UCS code point */
42772: int n_code;
42773:
42774: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42775: mem_base = xmlMemBlocks();
42776: code = gen_int(n_code, 0);
42777:
42778: ret_val = xmlUCSIsUnifiedCanadianAboriginalSyllabics(code);
42779: desret_int(ret_val);
42780: call_tests++;
42781: des_int(n_code, code, 0);
42782: xmlResetLastError();
42783: if (mem_base != xmlMemBlocks()) {
42784: printf("Leak of %d blocks found in xmlUCSIsUnifiedCanadianAboriginalSyllabics",
42785: xmlMemBlocks() - mem_base);
42786: test_ret++;
42787: printf(" %d", n_code);
42788: printf("\n");
42789: }
42790: }
42791: function_tests++;
42792: #endif
42793:
42794: return(test_ret);
42795: }
42796:
42797:
42798: static int
42799: test_xmlUCSIsVariationSelectors(void) {
42800: int test_ret = 0;
42801:
42802: #if defined(LIBXML_UNICODE_ENABLED)
42803: int mem_base;
42804: int ret_val;
42805: int code; /* UCS code point */
42806: int n_code;
42807:
42808: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42809: mem_base = xmlMemBlocks();
42810: code = gen_int(n_code, 0);
42811:
42812: ret_val = xmlUCSIsVariationSelectors(code);
42813: desret_int(ret_val);
42814: call_tests++;
42815: des_int(n_code, code, 0);
42816: xmlResetLastError();
42817: if (mem_base != xmlMemBlocks()) {
42818: printf("Leak of %d blocks found in xmlUCSIsVariationSelectors",
42819: xmlMemBlocks() - mem_base);
42820: test_ret++;
42821: printf(" %d", n_code);
42822: printf("\n");
42823: }
42824: }
42825: function_tests++;
42826: #endif
42827:
42828: return(test_ret);
42829: }
42830:
42831:
42832: static int
42833: test_xmlUCSIsVariationSelectorsSupplement(void) {
42834: int test_ret = 0;
42835:
42836: #if defined(LIBXML_UNICODE_ENABLED)
42837: int mem_base;
42838: int ret_val;
42839: int code; /* UCS code point */
42840: int n_code;
42841:
42842: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42843: mem_base = xmlMemBlocks();
42844: code = gen_int(n_code, 0);
42845:
42846: ret_val = xmlUCSIsVariationSelectorsSupplement(code);
42847: desret_int(ret_val);
42848: call_tests++;
42849: des_int(n_code, code, 0);
42850: xmlResetLastError();
42851: if (mem_base != xmlMemBlocks()) {
42852: printf("Leak of %d blocks found in xmlUCSIsVariationSelectorsSupplement",
42853: xmlMemBlocks() - mem_base);
42854: test_ret++;
42855: printf(" %d", n_code);
42856: printf("\n");
42857: }
42858: }
42859: function_tests++;
42860: #endif
42861:
42862: return(test_ret);
42863: }
42864:
42865:
42866: static int
42867: test_xmlUCSIsYiRadicals(void) {
42868: int test_ret = 0;
42869:
42870: #if defined(LIBXML_UNICODE_ENABLED)
42871: int mem_base;
42872: int ret_val;
42873: int code; /* UCS code point */
42874: int n_code;
42875:
42876: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42877: mem_base = xmlMemBlocks();
42878: code = gen_int(n_code, 0);
42879:
42880: ret_val = xmlUCSIsYiRadicals(code);
42881: desret_int(ret_val);
42882: call_tests++;
42883: des_int(n_code, code, 0);
42884: xmlResetLastError();
42885: if (mem_base != xmlMemBlocks()) {
42886: printf("Leak of %d blocks found in xmlUCSIsYiRadicals",
42887: xmlMemBlocks() - mem_base);
42888: test_ret++;
42889: printf(" %d", n_code);
42890: printf("\n");
42891: }
42892: }
42893: function_tests++;
42894: #endif
42895:
42896: return(test_ret);
42897: }
42898:
42899:
42900: static int
42901: test_xmlUCSIsYiSyllables(void) {
42902: int test_ret = 0;
42903:
42904: #if defined(LIBXML_UNICODE_ENABLED)
42905: int mem_base;
42906: int ret_val;
42907: int code; /* UCS code point */
42908: int n_code;
42909:
42910: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42911: mem_base = xmlMemBlocks();
42912: code = gen_int(n_code, 0);
42913:
42914: ret_val = xmlUCSIsYiSyllables(code);
42915: desret_int(ret_val);
42916: call_tests++;
42917: des_int(n_code, code, 0);
42918: xmlResetLastError();
42919: if (mem_base != xmlMemBlocks()) {
42920: printf("Leak of %d blocks found in xmlUCSIsYiSyllables",
42921: xmlMemBlocks() - mem_base);
42922: test_ret++;
42923: printf(" %d", n_code);
42924: printf("\n");
42925: }
42926: }
42927: function_tests++;
42928: #endif
42929:
42930: return(test_ret);
42931: }
42932:
42933:
42934: static int
42935: test_xmlUCSIsYijingHexagramSymbols(void) {
42936: int test_ret = 0;
42937:
42938: #if defined(LIBXML_UNICODE_ENABLED)
42939: int mem_base;
42940: int ret_val;
42941: int code; /* UCS code point */
42942: int n_code;
42943:
42944: for (n_code = 0;n_code < gen_nb_int;n_code++) {
42945: mem_base = xmlMemBlocks();
42946: code = gen_int(n_code, 0);
42947:
42948: ret_val = xmlUCSIsYijingHexagramSymbols(code);
42949: desret_int(ret_val);
42950: call_tests++;
42951: des_int(n_code, code, 0);
42952: xmlResetLastError();
42953: if (mem_base != xmlMemBlocks()) {
42954: printf("Leak of %d blocks found in xmlUCSIsYijingHexagramSymbols",
42955: xmlMemBlocks() - mem_base);
42956: test_ret++;
42957: printf(" %d", n_code);
42958: printf("\n");
42959: }
42960: }
42961: function_tests++;
42962: #endif
42963:
42964: return(test_ret);
42965: }
42966:
42967: static int
42968: test_xmlunicode(void) {
42969: int test_ret = 0;
42970:
42971: if (quiet == 0) printf("Testing xmlunicode : 166 of 166 functions ...\n");
42972: test_ret += test_xmlUCSIsAegeanNumbers();
42973: test_ret += test_xmlUCSIsAlphabeticPresentationForms();
42974: test_ret += test_xmlUCSIsArabic();
42975: test_ret += test_xmlUCSIsArabicPresentationFormsA();
42976: test_ret += test_xmlUCSIsArabicPresentationFormsB();
42977: test_ret += test_xmlUCSIsArmenian();
42978: test_ret += test_xmlUCSIsArrows();
42979: test_ret += test_xmlUCSIsBasicLatin();
42980: test_ret += test_xmlUCSIsBengali();
42981: test_ret += test_xmlUCSIsBlock();
42982: test_ret += test_xmlUCSIsBlockElements();
42983: test_ret += test_xmlUCSIsBopomofo();
42984: test_ret += test_xmlUCSIsBopomofoExtended();
42985: test_ret += test_xmlUCSIsBoxDrawing();
42986: test_ret += test_xmlUCSIsBraillePatterns();
42987: test_ret += test_xmlUCSIsBuhid();
42988: test_ret += test_xmlUCSIsByzantineMusicalSymbols();
42989: test_ret += test_xmlUCSIsCJKCompatibility();
42990: test_ret += test_xmlUCSIsCJKCompatibilityForms();
42991: test_ret += test_xmlUCSIsCJKCompatibilityIdeographs();
42992: test_ret += test_xmlUCSIsCJKCompatibilityIdeographsSupplement();
42993: test_ret += test_xmlUCSIsCJKRadicalsSupplement();
42994: test_ret += test_xmlUCSIsCJKSymbolsandPunctuation();
42995: test_ret += test_xmlUCSIsCJKUnifiedIdeographs();
42996: test_ret += test_xmlUCSIsCJKUnifiedIdeographsExtensionA();
42997: test_ret += test_xmlUCSIsCJKUnifiedIdeographsExtensionB();
42998: test_ret += test_xmlUCSIsCat();
42999: test_ret += test_xmlUCSIsCatC();
43000: test_ret += test_xmlUCSIsCatCc();
43001: test_ret += test_xmlUCSIsCatCf();
43002: test_ret += test_xmlUCSIsCatCo();
43003: test_ret += test_xmlUCSIsCatCs();
43004: test_ret += test_xmlUCSIsCatL();
43005: test_ret += test_xmlUCSIsCatLl();
43006: test_ret += test_xmlUCSIsCatLm();
43007: test_ret += test_xmlUCSIsCatLo();
43008: test_ret += test_xmlUCSIsCatLt();
43009: test_ret += test_xmlUCSIsCatLu();
43010: test_ret += test_xmlUCSIsCatM();
43011: test_ret += test_xmlUCSIsCatMc();
43012: test_ret += test_xmlUCSIsCatMe();
43013: test_ret += test_xmlUCSIsCatMn();
43014: test_ret += test_xmlUCSIsCatN();
43015: test_ret += test_xmlUCSIsCatNd();
43016: test_ret += test_xmlUCSIsCatNl();
43017: test_ret += test_xmlUCSIsCatNo();
43018: test_ret += test_xmlUCSIsCatP();
43019: test_ret += test_xmlUCSIsCatPc();
43020: test_ret += test_xmlUCSIsCatPd();
43021: test_ret += test_xmlUCSIsCatPe();
43022: test_ret += test_xmlUCSIsCatPf();
43023: test_ret += test_xmlUCSIsCatPi();
43024: test_ret += test_xmlUCSIsCatPo();
43025: test_ret += test_xmlUCSIsCatPs();
43026: test_ret += test_xmlUCSIsCatS();
43027: test_ret += test_xmlUCSIsCatSc();
43028: test_ret += test_xmlUCSIsCatSk();
43029: test_ret += test_xmlUCSIsCatSm();
43030: test_ret += test_xmlUCSIsCatSo();
43031: test_ret += test_xmlUCSIsCatZ();
43032: test_ret += test_xmlUCSIsCatZl();
43033: test_ret += test_xmlUCSIsCatZp();
43034: test_ret += test_xmlUCSIsCatZs();
43035: test_ret += test_xmlUCSIsCherokee();
43036: test_ret += test_xmlUCSIsCombiningDiacriticalMarks();
43037: test_ret += test_xmlUCSIsCombiningDiacriticalMarksforSymbols();
43038: test_ret += test_xmlUCSIsCombiningHalfMarks();
43039: test_ret += test_xmlUCSIsCombiningMarksforSymbols();
43040: test_ret += test_xmlUCSIsControlPictures();
43041: test_ret += test_xmlUCSIsCurrencySymbols();
43042: test_ret += test_xmlUCSIsCypriotSyllabary();
43043: test_ret += test_xmlUCSIsCyrillic();
43044: test_ret += test_xmlUCSIsCyrillicSupplement();
43045: test_ret += test_xmlUCSIsDeseret();
43046: test_ret += test_xmlUCSIsDevanagari();
43047: test_ret += test_xmlUCSIsDingbats();
43048: test_ret += test_xmlUCSIsEnclosedAlphanumerics();
43049: test_ret += test_xmlUCSIsEnclosedCJKLettersandMonths();
43050: test_ret += test_xmlUCSIsEthiopic();
43051: test_ret += test_xmlUCSIsGeneralPunctuation();
43052: test_ret += test_xmlUCSIsGeometricShapes();
43053: test_ret += test_xmlUCSIsGeorgian();
43054: test_ret += test_xmlUCSIsGothic();
43055: test_ret += test_xmlUCSIsGreek();
43056: test_ret += test_xmlUCSIsGreekExtended();
43057: test_ret += test_xmlUCSIsGreekandCoptic();
43058: test_ret += test_xmlUCSIsGujarati();
43059: test_ret += test_xmlUCSIsGurmukhi();
43060: test_ret += test_xmlUCSIsHalfwidthandFullwidthForms();
43061: test_ret += test_xmlUCSIsHangulCompatibilityJamo();
43062: test_ret += test_xmlUCSIsHangulJamo();
43063: test_ret += test_xmlUCSIsHangulSyllables();
43064: test_ret += test_xmlUCSIsHanunoo();
43065: test_ret += test_xmlUCSIsHebrew();
43066: test_ret += test_xmlUCSIsHighPrivateUseSurrogates();
43067: test_ret += test_xmlUCSIsHighSurrogates();
43068: test_ret += test_xmlUCSIsHiragana();
43069: test_ret += test_xmlUCSIsIPAExtensions();
43070: test_ret += test_xmlUCSIsIdeographicDescriptionCharacters();
43071: test_ret += test_xmlUCSIsKanbun();
43072: test_ret += test_xmlUCSIsKangxiRadicals();
43073: test_ret += test_xmlUCSIsKannada();
43074: test_ret += test_xmlUCSIsKatakana();
43075: test_ret += test_xmlUCSIsKatakanaPhoneticExtensions();
43076: test_ret += test_xmlUCSIsKhmer();
43077: test_ret += test_xmlUCSIsKhmerSymbols();
43078: test_ret += test_xmlUCSIsLao();
43079: test_ret += test_xmlUCSIsLatin1Supplement();
43080: test_ret += test_xmlUCSIsLatinExtendedA();
43081: test_ret += test_xmlUCSIsLatinExtendedAdditional();
43082: test_ret += test_xmlUCSIsLatinExtendedB();
43083: test_ret += test_xmlUCSIsLetterlikeSymbols();
43084: test_ret += test_xmlUCSIsLimbu();
43085: test_ret += test_xmlUCSIsLinearBIdeograms();
43086: test_ret += test_xmlUCSIsLinearBSyllabary();
43087: test_ret += test_xmlUCSIsLowSurrogates();
43088: test_ret += test_xmlUCSIsMalayalam();
43089: test_ret += test_xmlUCSIsMathematicalAlphanumericSymbols();
43090: test_ret += test_xmlUCSIsMathematicalOperators();
43091: test_ret += test_xmlUCSIsMiscellaneousMathematicalSymbolsA();
43092: test_ret += test_xmlUCSIsMiscellaneousMathematicalSymbolsB();
43093: test_ret += test_xmlUCSIsMiscellaneousSymbols();
43094: test_ret += test_xmlUCSIsMiscellaneousSymbolsandArrows();
43095: test_ret += test_xmlUCSIsMiscellaneousTechnical();
43096: test_ret += test_xmlUCSIsMongolian();
43097: test_ret += test_xmlUCSIsMusicalSymbols();
43098: test_ret += test_xmlUCSIsMyanmar();
43099: test_ret += test_xmlUCSIsNumberForms();
43100: test_ret += test_xmlUCSIsOgham();
43101: test_ret += test_xmlUCSIsOldItalic();
43102: test_ret += test_xmlUCSIsOpticalCharacterRecognition();
43103: test_ret += test_xmlUCSIsOriya();
43104: test_ret += test_xmlUCSIsOsmanya();
43105: test_ret += test_xmlUCSIsPhoneticExtensions();
43106: test_ret += test_xmlUCSIsPrivateUse();
43107: test_ret += test_xmlUCSIsPrivateUseArea();
43108: test_ret += test_xmlUCSIsRunic();
43109: test_ret += test_xmlUCSIsShavian();
43110: test_ret += test_xmlUCSIsSinhala();
43111: test_ret += test_xmlUCSIsSmallFormVariants();
43112: test_ret += test_xmlUCSIsSpacingModifierLetters();
43113: test_ret += test_xmlUCSIsSpecials();
43114: test_ret += test_xmlUCSIsSuperscriptsandSubscripts();
43115: test_ret += test_xmlUCSIsSupplementalArrowsA();
43116: test_ret += test_xmlUCSIsSupplementalArrowsB();
43117: test_ret += test_xmlUCSIsSupplementalMathematicalOperators();
43118: test_ret += test_xmlUCSIsSupplementaryPrivateUseAreaA();
43119: test_ret += test_xmlUCSIsSupplementaryPrivateUseAreaB();
43120: test_ret += test_xmlUCSIsSyriac();
43121: test_ret += test_xmlUCSIsTagalog();
43122: test_ret += test_xmlUCSIsTagbanwa();
43123: test_ret += test_xmlUCSIsTags();
43124: test_ret += test_xmlUCSIsTaiLe();
43125: test_ret += test_xmlUCSIsTaiXuanJingSymbols();
43126: test_ret += test_xmlUCSIsTamil();
43127: test_ret += test_xmlUCSIsTelugu();
43128: test_ret += test_xmlUCSIsThaana();
43129: test_ret += test_xmlUCSIsThai();
43130: test_ret += test_xmlUCSIsTibetan();
43131: test_ret += test_xmlUCSIsUgaritic();
43132: test_ret += test_xmlUCSIsUnifiedCanadianAboriginalSyllabics();
43133: test_ret += test_xmlUCSIsVariationSelectors();
43134: test_ret += test_xmlUCSIsVariationSelectorsSupplement();
43135: test_ret += test_xmlUCSIsYiRadicals();
43136: test_ret += test_xmlUCSIsYiSyllables();
43137: test_ret += test_xmlUCSIsYijingHexagramSymbols();
43138:
43139: if (test_ret != 0)
43140: printf("Module xmlunicode: %d errors\n", test_ret);
43141: return(test_ret);
43142: }
43143:
43144: static int
43145: test_xmlNewTextWriter(void) {
43146: int test_ret = 0;
43147:
43148: #if defined(LIBXML_WRITER_ENABLED)
43149: int mem_base;
43150: xmlTextWriterPtr ret_val;
43151: xmlOutputBufferPtr out; /* an xmlOutputBufferPtr */
43152: int n_out;
43153:
43154: for (n_out = 0;n_out < gen_nb_xmlOutputBufferPtr;n_out++) {
43155: mem_base = xmlMemBlocks();
43156: out = gen_xmlOutputBufferPtr(n_out, 0);
43157:
43158: ret_val = xmlNewTextWriter(out);
43159: if (ret_val != NULL) out = NULL;
43160: desret_xmlTextWriterPtr(ret_val);
43161: call_tests++;
43162: des_xmlOutputBufferPtr(n_out, out, 0);
43163: xmlResetLastError();
43164: if (mem_base != xmlMemBlocks()) {
43165: printf("Leak of %d blocks found in xmlNewTextWriter",
43166: xmlMemBlocks() - mem_base);
43167: test_ret++;
43168: printf(" %d", n_out);
43169: printf("\n");
43170: }
43171: }
43172: function_tests++;
43173: #endif
43174:
43175: return(test_ret);
43176: }
43177:
43178:
43179: static int
43180: test_xmlNewTextWriterFilename(void) {
43181: int test_ret = 0;
43182:
43183: #if defined(LIBXML_WRITER_ENABLED)
43184: int mem_base;
43185: xmlTextWriterPtr ret_val;
43186: const char * uri; /* the URI of the resource for the output */
43187: int n_uri;
43188: int compression; /* compress the output? */
43189: int n_compression;
43190:
43191: for (n_uri = 0;n_uri < gen_nb_fileoutput;n_uri++) {
43192: for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
43193: mem_base = xmlMemBlocks();
43194: uri = gen_fileoutput(n_uri, 0);
43195: compression = gen_int(n_compression, 1);
43196:
43197: ret_val = xmlNewTextWriterFilename(uri, compression);
43198: desret_xmlTextWriterPtr(ret_val);
43199: call_tests++;
43200: des_fileoutput(n_uri, uri, 0);
43201: des_int(n_compression, compression, 1);
43202: xmlResetLastError();
43203: if (mem_base != xmlMemBlocks()) {
43204: printf("Leak of %d blocks found in xmlNewTextWriterFilename",
43205: xmlMemBlocks() - mem_base);
43206: test_ret++;
43207: printf(" %d", n_uri);
43208: printf(" %d", n_compression);
43209: printf("\n");
43210: }
43211: }
43212: }
43213: function_tests++;
43214: #endif
43215:
43216: return(test_ret);
43217: }
43218:
43219:
43220: static int
43221: test_xmlNewTextWriterMemory(void) {
43222: int test_ret = 0;
43223:
43224: #if defined(LIBXML_WRITER_ENABLED)
43225: int mem_base;
43226: xmlTextWriterPtr ret_val;
43227: xmlBufferPtr buf; /* xmlBufferPtr */
43228: int n_buf;
43229: int compression; /* compress the output? */
43230: int n_compression;
43231:
43232: for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
43233: for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
43234: mem_base = xmlMemBlocks();
43235: buf = gen_xmlBufferPtr(n_buf, 0);
43236: compression = gen_int(n_compression, 1);
43237:
43238: ret_val = xmlNewTextWriterMemory(buf, compression);
43239: desret_xmlTextWriterPtr(ret_val);
43240: call_tests++;
43241: des_xmlBufferPtr(n_buf, buf, 0);
43242: des_int(n_compression, compression, 1);
43243: xmlResetLastError();
43244: if (mem_base != xmlMemBlocks()) {
43245: printf("Leak of %d blocks found in xmlNewTextWriterMemory",
43246: xmlMemBlocks() - mem_base);
43247: test_ret++;
43248: printf(" %d", n_buf);
43249: printf(" %d", n_compression);
43250: printf("\n");
43251: }
43252: }
43253: }
43254: function_tests++;
43255: #endif
43256:
43257: return(test_ret);
43258: }
43259:
43260:
43261: static int
43262: test_xmlNewTextWriterPushParser(void) {
43263: int test_ret = 0;
43264:
43265: #if defined(LIBXML_WRITER_ENABLED)
43266: int mem_base;
43267: xmlTextWriterPtr ret_val;
43268: xmlParserCtxtPtr ctxt; /* xmlParserCtxtPtr to hold the new XML document tree */
43269: int n_ctxt;
43270: int compression; /* compress the output? */
43271: int n_compression;
43272:
43273: for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
43274: for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
43275: mem_base = xmlMemBlocks();
43276: ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
43277: compression = gen_int(n_compression, 1);
43278:
43279: ret_val = xmlNewTextWriterPushParser(ctxt, compression);
43280: if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;} if (ret_val != NULL) ctxt = NULL;
43281: desret_xmlTextWriterPtr(ret_val);
43282: call_tests++;
43283: des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
43284: des_int(n_compression, compression, 1);
43285: xmlResetLastError();
43286: if (mem_base != xmlMemBlocks()) {
43287: printf("Leak of %d blocks found in xmlNewTextWriterPushParser",
43288: xmlMemBlocks() - mem_base);
43289: test_ret++;
43290: printf(" %d", n_ctxt);
43291: printf(" %d", n_compression);
43292: printf("\n");
43293: }
43294: }
43295: }
43296: function_tests++;
43297: #endif
43298:
43299: return(test_ret);
43300: }
43301:
43302:
43303: static int
43304: test_xmlNewTextWriterTree(void) {
43305: int test_ret = 0;
43306:
43307: #if defined(LIBXML_WRITER_ENABLED)
43308: int mem_base;
43309: xmlTextWriterPtr ret_val;
43310: xmlDocPtr doc; /* xmlDocPtr */
43311: int n_doc;
43312: xmlNodePtr node; /* xmlNodePtr or NULL for doc->children */
43313: int n_node;
43314: int compression; /* compress the output? */
43315: int n_compression;
43316:
43317: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
43318: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
43319: for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
43320: mem_base = xmlMemBlocks();
43321: doc = gen_xmlDocPtr(n_doc, 0);
43322: node = gen_xmlNodePtr(n_node, 1);
43323: compression = gen_int(n_compression, 2);
43324:
43325: ret_val = xmlNewTextWriterTree(doc, node, compression);
43326: desret_xmlTextWriterPtr(ret_val);
43327: call_tests++;
43328: des_xmlDocPtr(n_doc, doc, 0);
43329: des_xmlNodePtr(n_node, node, 1);
43330: des_int(n_compression, compression, 2);
43331: xmlResetLastError();
43332: if (mem_base != xmlMemBlocks()) {
43333: printf("Leak of %d blocks found in xmlNewTextWriterTree",
43334: xmlMemBlocks() - mem_base);
43335: test_ret++;
43336: printf(" %d", n_doc);
43337: printf(" %d", n_node);
43338: printf(" %d", n_compression);
43339: printf("\n");
43340: }
43341: }
43342: }
43343: }
43344: function_tests++;
43345: #endif
43346:
43347: return(test_ret);
43348: }
43349:
43350:
43351: static int
43352: test_xmlTextWriterEndAttribute(void) {
43353: int test_ret = 0;
43354:
43355: #if defined(LIBXML_WRITER_ENABLED)
43356: int mem_base;
43357: int ret_val;
43358: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43359: int n_writer;
43360:
43361: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43362: mem_base = xmlMemBlocks();
43363: writer = gen_xmlTextWriterPtr(n_writer, 0);
43364:
43365: ret_val = xmlTextWriterEndAttribute(writer);
43366: desret_int(ret_val);
43367: call_tests++;
43368: des_xmlTextWriterPtr(n_writer, writer, 0);
43369: xmlResetLastError();
43370: if (mem_base != xmlMemBlocks()) {
43371: printf("Leak of %d blocks found in xmlTextWriterEndAttribute",
43372: xmlMemBlocks() - mem_base);
43373: test_ret++;
43374: printf(" %d", n_writer);
43375: printf("\n");
43376: }
43377: }
43378: function_tests++;
43379: #endif
43380:
43381: return(test_ret);
43382: }
43383:
43384:
43385: static int
43386: test_xmlTextWriterEndCDATA(void) {
43387: int test_ret = 0;
43388:
43389: #if defined(LIBXML_WRITER_ENABLED)
43390: int mem_base;
43391: int ret_val;
43392: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43393: int n_writer;
43394:
43395: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43396: mem_base = xmlMemBlocks();
43397: writer = gen_xmlTextWriterPtr(n_writer, 0);
43398:
43399: ret_val = xmlTextWriterEndCDATA(writer);
43400: desret_int(ret_val);
43401: call_tests++;
43402: des_xmlTextWriterPtr(n_writer, writer, 0);
43403: xmlResetLastError();
43404: if (mem_base != xmlMemBlocks()) {
43405: printf("Leak of %d blocks found in xmlTextWriterEndCDATA",
43406: xmlMemBlocks() - mem_base);
43407: test_ret++;
43408: printf(" %d", n_writer);
43409: printf("\n");
43410: }
43411: }
43412: function_tests++;
43413: #endif
43414:
43415: return(test_ret);
43416: }
43417:
43418:
43419: static int
43420: test_xmlTextWriterEndComment(void) {
43421: int test_ret = 0;
43422:
43423: #if defined(LIBXML_WRITER_ENABLED)
43424: int mem_base;
43425: int ret_val;
43426: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43427: int n_writer;
43428:
43429: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43430: mem_base = xmlMemBlocks();
43431: writer = gen_xmlTextWriterPtr(n_writer, 0);
43432:
43433: ret_val = xmlTextWriterEndComment(writer);
43434: desret_int(ret_val);
43435: call_tests++;
43436: des_xmlTextWriterPtr(n_writer, writer, 0);
43437: xmlResetLastError();
43438: if (mem_base != xmlMemBlocks()) {
43439: printf("Leak of %d blocks found in xmlTextWriterEndComment",
43440: xmlMemBlocks() - mem_base);
43441: test_ret++;
43442: printf(" %d", n_writer);
43443: printf("\n");
43444: }
43445: }
43446: function_tests++;
43447: #endif
43448:
43449: return(test_ret);
43450: }
43451:
43452:
43453: static int
43454: test_xmlTextWriterEndDTD(void) {
43455: int test_ret = 0;
43456:
43457: #if defined(LIBXML_WRITER_ENABLED)
43458: int mem_base;
43459: int ret_val;
43460: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43461: int n_writer;
43462:
43463: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43464: mem_base = xmlMemBlocks();
43465: writer = gen_xmlTextWriterPtr(n_writer, 0);
43466:
43467: ret_val = xmlTextWriterEndDTD(writer);
43468: desret_int(ret_val);
43469: call_tests++;
43470: des_xmlTextWriterPtr(n_writer, writer, 0);
43471: xmlResetLastError();
43472: if (mem_base != xmlMemBlocks()) {
43473: printf("Leak of %d blocks found in xmlTextWriterEndDTD",
43474: xmlMemBlocks() - mem_base);
43475: test_ret++;
43476: printf(" %d", n_writer);
43477: printf("\n");
43478: }
43479: }
43480: function_tests++;
43481: #endif
43482:
43483: return(test_ret);
43484: }
43485:
43486:
43487: static int
43488: test_xmlTextWriterEndDTDAttlist(void) {
43489: int test_ret = 0;
43490:
43491: #if defined(LIBXML_WRITER_ENABLED)
43492: int mem_base;
43493: int ret_val;
43494: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43495: int n_writer;
43496:
43497: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43498: mem_base = xmlMemBlocks();
43499: writer = gen_xmlTextWriterPtr(n_writer, 0);
43500:
43501: ret_val = xmlTextWriterEndDTDAttlist(writer);
43502: desret_int(ret_val);
43503: call_tests++;
43504: des_xmlTextWriterPtr(n_writer, writer, 0);
43505: xmlResetLastError();
43506: if (mem_base != xmlMemBlocks()) {
43507: printf("Leak of %d blocks found in xmlTextWriterEndDTDAttlist",
43508: xmlMemBlocks() - mem_base);
43509: test_ret++;
43510: printf(" %d", n_writer);
43511: printf("\n");
43512: }
43513: }
43514: function_tests++;
43515: #endif
43516:
43517: return(test_ret);
43518: }
43519:
43520:
43521: static int
43522: test_xmlTextWriterEndDTDElement(void) {
43523: int test_ret = 0;
43524:
43525: #if defined(LIBXML_WRITER_ENABLED)
43526: int mem_base;
43527: int ret_val;
43528: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43529: int n_writer;
43530:
43531: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43532: mem_base = xmlMemBlocks();
43533: writer = gen_xmlTextWriterPtr(n_writer, 0);
43534:
43535: ret_val = xmlTextWriterEndDTDElement(writer);
43536: desret_int(ret_val);
43537: call_tests++;
43538: des_xmlTextWriterPtr(n_writer, writer, 0);
43539: xmlResetLastError();
43540: if (mem_base != xmlMemBlocks()) {
43541: printf("Leak of %d blocks found in xmlTextWriterEndDTDElement",
43542: xmlMemBlocks() - mem_base);
43543: test_ret++;
43544: printf(" %d", n_writer);
43545: printf("\n");
43546: }
43547: }
43548: function_tests++;
43549: #endif
43550:
43551: return(test_ret);
43552: }
43553:
43554:
43555: static int
43556: test_xmlTextWriterEndDTDEntity(void) {
43557: int test_ret = 0;
43558:
43559: #if defined(LIBXML_WRITER_ENABLED)
43560: int mem_base;
43561: int ret_val;
43562: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43563: int n_writer;
43564:
43565: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43566: mem_base = xmlMemBlocks();
43567: writer = gen_xmlTextWriterPtr(n_writer, 0);
43568:
43569: ret_val = xmlTextWriterEndDTDEntity(writer);
43570: desret_int(ret_val);
43571: call_tests++;
43572: des_xmlTextWriterPtr(n_writer, writer, 0);
43573: xmlResetLastError();
43574: if (mem_base != xmlMemBlocks()) {
43575: printf("Leak of %d blocks found in xmlTextWriterEndDTDEntity",
43576: xmlMemBlocks() - mem_base);
43577: test_ret++;
43578: printf(" %d", n_writer);
43579: printf("\n");
43580: }
43581: }
43582: function_tests++;
43583: #endif
43584:
43585: return(test_ret);
43586: }
43587:
43588:
43589: static int
43590: test_xmlTextWriterEndDocument(void) {
43591: int test_ret = 0;
43592:
43593: #if defined(LIBXML_WRITER_ENABLED)
43594: int mem_base;
43595: int ret_val;
43596: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43597: int n_writer;
43598:
43599: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43600: mem_base = xmlMemBlocks();
43601: writer = gen_xmlTextWriterPtr(n_writer, 0);
43602:
43603: ret_val = xmlTextWriterEndDocument(writer);
43604: desret_int(ret_val);
43605: call_tests++;
43606: des_xmlTextWriterPtr(n_writer, writer, 0);
43607: xmlResetLastError();
43608: if (mem_base != xmlMemBlocks()) {
43609: printf("Leak of %d blocks found in xmlTextWriterEndDocument",
43610: xmlMemBlocks() - mem_base);
43611: test_ret++;
43612: printf(" %d", n_writer);
43613: printf("\n");
43614: }
43615: }
43616: function_tests++;
43617: #endif
43618:
43619: return(test_ret);
43620: }
43621:
43622:
43623: static int
43624: test_xmlTextWriterEndElement(void) {
43625: int test_ret = 0;
43626:
43627: #if defined(LIBXML_WRITER_ENABLED)
43628: int mem_base;
43629: int ret_val;
43630: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43631: int n_writer;
43632:
43633: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43634: mem_base = xmlMemBlocks();
43635: writer = gen_xmlTextWriterPtr(n_writer, 0);
43636:
43637: ret_val = xmlTextWriterEndElement(writer);
43638: desret_int(ret_val);
43639: call_tests++;
43640: des_xmlTextWriterPtr(n_writer, writer, 0);
43641: xmlResetLastError();
43642: if (mem_base != xmlMemBlocks()) {
43643: printf("Leak of %d blocks found in xmlTextWriterEndElement",
43644: xmlMemBlocks() - mem_base);
43645: test_ret++;
43646: printf(" %d", n_writer);
43647: printf("\n");
43648: }
43649: }
43650: function_tests++;
43651: #endif
43652:
43653: return(test_ret);
43654: }
43655:
43656:
43657: static int
43658: test_xmlTextWriterEndPI(void) {
43659: int test_ret = 0;
43660:
43661: #if defined(LIBXML_WRITER_ENABLED)
43662: int mem_base;
43663: int ret_val;
43664: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43665: int n_writer;
43666:
43667: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43668: mem_base = xmlMemBlocks();
43669: writer = gen_xmlTextWriterPtr(n_writer, 0);
43670:
43671: ret_val = xmlTextWriterEndPI(writer);
43672: desret_int(ret_val);
43673: call_tests++;
43674: des_xmlTextWriterPtr(n_writer, writer, 0);
43675: xmlResetLastError();
43676: if (mem_base != xmlMemBlocks()) {
43677: printf("Leak of %d blocks found in xmlTextWriterEndPI",
43678: xmlMemBlocks() - mem_base);
43679: test_ret++;
43680: printf(" %d", n_writer);
43681: printf("\n");
43682: }
43683: }
43684: function_tests++;
43685: #endif
43686:
43687: return(test_ret);
43688: }
43689:
43690:
43691: static int
43692: test_xmlTextWriterFlush(void) {
43693: int test_ret = 0;
43694:
43695: #if defined(LIBXML_WRITER_ENABLED)
43696: int mem_base;
43697: int ret_val;
43698: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43699: int n_writer;
43700:
43701: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43702: mem_base = xmlMemBlocks();
43703: writer = gen_xmlTextWriterPtr(n_writer, 0);
43704:
43705: ret_val = xmlTextWriterFlush(writer);
43706: desret_int(ret_val);
43707: call_tests++;
43708: des_xmlTextWriterPtr(n_writer, writer, 0);
43709: xmlResetLastError();
43710: if (mem_base != xmlMemBlocks()) {
43711: printf("Leak of %d blocks found in xmlTextWriterFlush",
43712: xmlMemBlocks() - mem_base);
43713: test_ret++;
43714: printf(" %d", n_writer);
43715: printf("\n");
43716: }
43717: }
43718: function_tests++;
43719: #endif
43720:
43721: return(test_ret);
43722: }
43723:
43724:
43725: static int
43726: test_xmlTextWriterFullEndElement(void) {
43727: int test_ret = 0;
43728:
43729: #if defined(LIBXML_WRITER_ENABLED)
43730: int mem_base;
43731: int ret_val;
43732: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43733: int n_writer;
43734:
43735: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43736: mem_base = xmlMemBlocks();
43737: writer = gen_xmlTextWriterPtr(n_writer, 0);
43738:
43739: ret_val = xmlTextWriterFullEndElement(writer);
43740: desret_int(ret_val);
43741: call_tests++;
43742: des_xmlTextWriterPtr(n_writer, writer, 0);
43743: xmlResetLastError();
43744: if (mem_base != xmlMemBlocks()) {
43745: printf("Leak of %d blocks found in xmlTextWriterFullEndElement",
43746: xmlMemBlocks() - mem_base);
43747: test_ret++;
43748: printf(" %d", n_writer);
43749: printf("\n");
43750: }
43751: }
43752: function_tests++;
43753: #endif
43754:
43755: return(test_ret);
43756: }
43757:
43758:
43759: static int
43760: test_xmlTextWriterSetIndent(void) {
43761: int test_ret = 0;
43762:
43763: #if defined(LIBXML_WRITER_ENABLED)
43764: int mem_base;
43765: int ret_val;
43766: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43767: int n_writer;
43768: int indent; /* do indentation? */
43769: int n_indent;
43770:
43771: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43772: for (n_indent = 0;n_indent < gen_nb_int;n_indent++) {
43773: mem_base = xmlMemBlocks();
43774: writer = gen_xmlTextWriterPtr(n_writer, 0);
43775: indent = gen_int(n_indent, 1);
43776:
43777: ret_val = xmlTextWriterSetIndent(writer, indent);
43778: desret_int(ret_val);
43779: call_tests++;
43780: des_xmlTextWriterPtr(n_writer, writer, 0);
43781: des_int(n_indent, indent, 1);
43782: xmlResetLastError();
43783: if (mem_base != xmlMemBlocks()) {
43784: printf("Leak of %d blocks found in xmlTextWriterSetIndent",
43785: xmlMemBlocks() - mem_base);
43786: test_ret++;
43787: printf(" %d", n_writer);
43788: printf(" %d", n_indent);
43789: printf("\n");
43790: }
43791: }
43792: }
43793: function_tests++;
43794: #endif
43795:
43796: return(test_ret);
43797: }
43798:
43799:
43800: static int
43801: test_xmlTextWriterSetIndentString(void) {
43802: int test_ret = 0;
43803:
43804: #if defined(LIBXML_WRITER_ENABLED)
43805: int mem_base;
43806: int ret_val;
43807: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43808: int n_writer;
43809: xmlChar * str; /* the xmlChar string */
43810: int n_str;
43811:
43812: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43813: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
43814: mem_base = xmlMemBlocks();
43815: writer = gen_xmlTextWriterPtr(n_writer, 0);
43816: str = gen_const_xmlChar_ptr(n_str, 1);
43817:
43818: ret_val = xmlTextWriterSetIndentString(writer, (const xmlChar *)str);
43819: desret_int(ret_val);
43820: call_tests++;
43821: des_xmlTextWriterPtr(n_writer, writer, 0);
43822: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
43823: xmlResetLastError();
43824: if (mem_base != xmlMemBlocks()) {
43825: printf("Leak of %d blocks found in xmlTextWriterSetIndentString",
43826: xmlMemBlocks() - mem_base);
43827: test_ret++;
43828: printf(" %d", n_writer);
43829: printf(" %d", n_str);
43830: printf("\n");
43831: }
43832: }
43833: }
43834: function_tests++;
43835: #endif
43836:
43837: return(test_ret);
43838: }
43839:
43840:
43841: static int
1.1.1.3 ! misho 43842: test_xmlTextWriterSetQuoteChar(void) {
! 43843: int test_ret = 0;
! 43844:
! 43845: #if defined(LIBXML_WRITER_ENABLED)
! 43846: int mem_base;
! 43847: int ret_val;
! 43848: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
! 43849: int n_writer;
! 43850: xmlChar quotechar; /* the quote character */
! 43851: int n_quotechar;
! 43852:
! 43853: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
! 43854: for (n_quotechar = 0;n_quotechar < gen_nb_xmlChar;n_quotechar++) {
! 43855: mem_base = xmlMemBlocks();
! 43856: writer = gen_xmlTextWriterPtr(n_writer, 0);
! 43857: quotechar = gen_xmlChar(n_quotechar, 1);
! 43858:
! 43859: ret_val = xmlTextWriterSetQuoteChar(writer, quotechar);
! 43860: desret_int(ret_val);
! 43861: call_tests++;
! 43862: des_xmlTextWriterPtr(n_writer, writer, 0);
! 43863: des_xmlChar(n_quotechar, quotechar, 1);
! 43864: xmlResetLastError();
! 43865: if (mem_base != xmlMemBlocks()) {
! 43866: printf("Leak of %d blocks found in xmlTextWriterSetQuoteChar",
! 43867: xmlMemBlocks() - mem_base);
! 43868: test_ret++;
! 43869: printf(" %d", n_writer);
! 43870: printf(" %d", n_quotechar);
! 43871: printf("\n");
! 43872: }
! 43873: }
! 43874: }
! 43875: function_tests++;
! 43876: #endif
! 43877:
! 43878: return(test_ret);
! 43879: }
! 43880:
! 43881:
! 43882: static int
1.1 misho 43883: test_xmlTextWriterStartAttribute(void) {
43884: int test_ret = 0;
43885:
43886: #if defined(LIBXML_WRITER_ENABLED)
43887: int mem_base;
43888: int ret_val;
43889: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43890: int n_writer;
43891: xmlChar * name; /* element name */
43892: int n_name;
43893:
43894: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43895: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
43896: mem_base = xmlMemBlocks();
43897: writer = gen_xmlTextWriterPtr(n_writer, 0);
43898: name = gen_const_xmlChar_ptr(n_name, 1);
43899:
43900: ret_val = xmlTextWriterStartAttribute(writer, (const xmlChar *)name);
43901: desret_int(ret_val);
43902: call_tests++;
43903: des_xmlTextWriterPtr(n_writer, writer, 0);
43904: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
43905: xmlResetLastError();
43906: if (mem_base != xmlMemBlocks()) {
43907: printf("Leak of %d blocks found in xmlTextWriterStartAttribute",
43908: xmlMemBlocks() - mem_base);
43909: test_ret++;
43910: printf(" %d", n_writer);
43911: printf(" %d", n_name);
43912: printf("\n");
43913: }
43914: }
43915: }
43916: function_tests++;
43917: #endif
43918:
43919: return(test_ret);
43920: }
43921:
43922:
43923: static int
43924: test_xmlTextWriterStartAttributeNS(void) {
43925: int test_ret = 0;
43926:
43927: #if defined(LIBXML_WRITER_ENABLED)
43928: int mem_base;
43929: int ret_val;
43930: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43931: int n_writer;
43932: xmlChar * prefix; /* namespace prefix or NULL */
43933: int n_prefix;
43934: xmlChar * name; /* element local name */
43935: int n_name;
43936: xmlChar * namespaceURI; /* namespace URI or NULL */
43937: int n_namespaceURI;
43938:
43939: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43940: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
43941: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
43942: for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
43943: mem_base = xmlMemBlocks();
43944: writer = gen_xmlTextWriterPtr(n_writer, 0);
43945: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
43946: name = gen_const_xmlChar_ptr(n_name, 2);
43947: namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 3);
43948:
43949: ret_val = xmlTextWriterStartAttributeNS(writer, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)namespaceURI);
43950: desret_int(ret_val);
43951: call_tests++;
43952: des_xmlTextWriterPtr(n_writer, writer, 0);
43953: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
43954: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
43955: des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 3);
43956: xmlResetLastError();
43957: if (mem_base != xmlMemBlocks()) {
43958: printf("Leak of %d blocks found in xmlTextWriterStartAttributeNS",
43959: xmlMemBlocks() - mem_base);
43960: test_ret++;
43961: printf(" %d", n_writer);
43962: printf(" %d", n_prefix);
43963: printf(" %d", n_name);
43964: printf(" %d", n_namespaceURI);
43965: printf("\n");
43966: }
43967: }
43968: }
43969: }
43970: }
43971: function_tests++;
43972: #endif
43973:
43974: return(test_ret);
43975: }
43976:
43977:
43978: static int
43979: test_xmlTextWriterStartCDATA(void) {
43980: int test_ret = 0;
43981:
43982: #if defined(LIBXML_WRITER_ENABLED)
43983: int mem_base;
43984: int ret_val;
43985: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43986: int n_writer;
43987:
43988: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43989: mem_base = xmlMemBlocks();
43990: writer = gen_xmlTextWriterPtr(n_writer, 0);
43991:
43992: ret_val = xmlTextWriterStartCDATA(writer);
43993: desret_int(ret_val);
43994: call_tests++;
43995: des_xmlTextWriterPtr(n_writer, writer, 0);
43996: xmlResetLastError();
43997: if (mem_base != xmlMemBlocks()) {
43998: printf("Leak of %d blocks found in xmlTextWriterStartCDATA",
43999: xmlMemBlocks() - mem_base);
44000: test_ret++;
44001: printf(" %d", n_writer);
44002: printf("\n");
44003: }
44004: }
44005: function_tests++;
44006: #endif
44007:
44008: return(test_ret);
44009: }
44010:
44011:
44012: static int
44013: test_xmlTextWriterStartComment(void) {
44014: int test_ret = 0;
44015:
44016: #if defined(LIBXML_WRITER_ENABLED)
44017: int mem_base;
44018: int ret_val;
44019: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44020: int n_writer;
44021:
44022: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44023: mem_base = xmlMemBlocks();
44024: writer = gen_xmlTextWriterPtr(n_writer, 0);
44025:
44026: ret_val = xmlTextWriterStartComment(writer);
44027: desret_int(ret_val);
44028: call_tests++;
44029: des_xmlTextWriterPtr(n_writer, writer, 0);
44030: xmlResetLastError();
44031: if (mem_base != xmlMemBlocks()) {
44032: printf("Leak of %d blocks found in xmlTextWriterStartComment",
44033: xmlMemBlocks() - mem_base);
44034: test_ret++;
44035: printf(" %d", n_writer);
44036: printf("\n");
44037: }
44038: }
44039: function_tests++;
44040: #endif
44041:
44042: return(test_ret);
44043: }
44044:
44045:
44046: static int
44047: test_xmlTextWriterStartDTD(void) {
44048: int test_ret = 0;
44049:
44050: #if defined(LIBXML_WRITER_ENABLED)
44051: int mem_base;
44052: int ret_val;
44053: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44054: int n_writer;
44055: xmlChar * name; /* the name of the DTD */
44056: int n_name;
44057: xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
44058: int n_pubid;
44059: xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
44060: int n_sysid;
44061:
44062: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44063: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44064: for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
44065: for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
44066: mem_base = xmlMemBlocks();
44067: writer = gen_xmlTextWriterPtr(n_writer, 0);
44068: name = gen_const_xmlChar_ptr(n_name, 1);
44069: pubid = gen_const_xmlChar_ptr(n_pubid, 2);
44070: sysid = gen_const_xmlChar_ptr(n_sysid, 3);
44071:
44072: ret_val = xmlTextWriterStartDTD(writer, (const xmlChar *)name, (const xmlChar *)pubid, (const xmlChar *)sysid);
44073: desret_int(ret_val);
44074: call_tests++;
44075: des_xmlTextWriterPtr(n_writer, writer, 0);
44076: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
44077: des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 2);
44078: des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 3);
44079: xmlResetLastError();
44080: if (mem_base != xmlMemBlocks()) {
44081: printf("Leak of %d blocks found in xmlTextWriterStartDTD",
44082: xmlMemBlocks() - mem_base);
44083: test_ret++;
44084: printf(" %d", n_writer);
44085: printf(" %d", n_name);
44086: printf(" %d", n_pubid);
44087: printf(" %d", n_sysid);
44088: printf("\n");
44089: }
44090: }
44091: }
44092: }
44093: }
44094: function_tests++;
44095: #endif
44096:
44097: return(test_ret);
44098: }
44099:
44100:
44101: static int
44102: test_xmlTextWriterStartDTDAttlist(void) {
44103: int test_ret = 0;
44104:
44105: #if defined(LIBXML_WRITER_ENABLED)
44106: int mem_base;
44107: int ret_val;
44108: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44109: int n_writer;
44110: xmlChar * name; /* the name of the DTD ATTLIST */
44111: int n_name;
44112:
44113: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44114: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44115: mem_base = xmlMemBlocks();
44116: writer = gen_xmlTextWriterPtr(n_writer, 0);
44117: name = gen_const_xmlChar_ptr(n_name, 1);
44118:
44119: ret_val = xmlTextWriterStartDTDAttlist(writer, (const xmlChar *)name);
44120: desret_int(ret_val);
44121: call_tests++;
44122: des_xmlTextWriterPtr(n_writer, writer, 0);
44123: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
44124: xmlResetLastError();
44125: if (mem_base != xmlMemBlocks()) {
44126: printf("Leak of %d blocks found in xmlTextWriterStartDTDAttlist",
44127: xmlMemBlocks() - mem_base);
44128: test_ret++;
44129: printf(" %d", n_writer);
44130: printf(" %d", n_name);
44131: printf("\n");
44132: }
44133: }
44134: }
44135: function_tests++;
44136: #endif
44137:
44138: return(test_ret);
44139: }
44140:
44141:
44142: static int
44143: test_xmlTextWriterStartDTDElement(void) {
44144: int test_ret = 0;
44145:
44146: #if defined(LIBXML_WRITER_ENABLED)
44147: int mem_base;
44148: int ret_val;
44149: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44150: int n_writer;
44151: xmlChar * name; /* the name of the DTD element */
44152: int n_name;
44153:
44154: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44155: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44156: mem_base = xmlMemBlocks();
44157: writer = gen_xmlTextWriterPtr(n_writer, 0);
44158: name = gen_const_xmlChar_ptr(n_name, 1);
44159:
44160: ret_val = xmlTextWriterStartDTDElement(writer, (const xmlChar *)name);
44161: desret_int(ret_val);
44162: call_tests++;
44163: des_xmlTextWriterPtr(n_writer, writer, 0);
44164: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
44165: xmlResetLastError();
44166: if (mem_base != xmlMemBlocks()) {
44167: printf("Leak of %d blocks found in xmlTextWriterStartDTDElement",
44168: xmlMemBlocks() - mem_base);
44169: test_ret++;
44170: printf(" %d", n_writer);
44171: printf(" %d", n_name);
44172: printf("\n");
44173: }
44174: }
44175: }
44176: function_tests++;
44177: #endif
44178:
44179: return(test_ret);
44180: }
44181:
44182:
44183: static int
44184: test_xmlTextWriterStartDTDEntity(void) {
44185: int test_ret = 0;
44186:
44187: #if defined(LIBXML_WRITER_ENABLED)
44188: int mem_base;
44189: int ret_val;
44190: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44191: int n_writer;
44192: int pe; /* TRUE if this is a parameter entity, FALSE if not */
44193: int n_pe;
44194: xmlChar * name; /* the name of the DTD ATTLIST */
44195: int n_name;
44196:
44197: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44198: for (n_pe = 0;n_pe < gen_nb_int;n_pe++) {
44199: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44200: mem_base = xmlMemBlocks();
44201: writer = gen_xmlTextWriterPtr(n_writer, 0);
44202: pe = gen_int(n_pe, 1);
44203: name = gen_const_xmlChar_ptr(n_name, 2);
44204:
44205: ret_val = xmlTextWriterStartDTDEntity(writer, pe, (const xmlChar *)name);
44206: desret_int(ret_val);
44207: call_tests++;
44208: des_xmlTextWriterPtr(n_writer, writer, 0);
44209: des_int(n_pe, pe, 1);
44210: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
44211: xmlResetLastError();
44212: if (mem_base != xmlMemBlocks()) {
44213: printf("Leak of %d blocks found in xmlTextWriterStartDTDEntity",
44214: xmlMemBlocks() - mem_base);
44215: test_ret++;
44216: printf(" %d", n_writer);
44217: printf(" %d", n_pe);
44218: printf(" %d", n_name);
44219: printf("\n");
44220: }
44221: }
44222: }
44223: }
44224: function_tests++;
44225: #endif
44226:
44227: return(test_ret);
44228: }
44229:
44230:
44231: static int
44232: test_xmlTextWriterStartDocument(void) {
44233: int test_ret = 0;
44234:
44235: #if defined(LIBXML_WRITER_ENABLED)
44236: int mem_base;
44237: int ret_val;
44238: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44239: int n_writer;
44240: char * version; /* the xml version ("1.0") or NULL for default ("1.0") */
44241: int n_version;
44242: char * encoding; /* the encoding or NULL for default */
44243: int n_encoding;
44244: char * standalone; /* "yes" or "no" or NULL for default */
44245: int n_standalone;
44246:
44247: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44248: for (n_version = 0;n_version < gen_nb_const_char_ptr;n_version++) {
44249: for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
44250: for (n_standalone = 0;n_standalone < gen_nb_const_char_ptr;n_standalone++) {
44251: mem_base = xmlMemBlocks();
44252: writer = gen_xmlTextWriterPtr(n_writer, 0);
44253: version = gen_const_char_ptr(n_version, 1);
44254: encoding = gen_const_char_ptr(n_encoding, 2);
44255: standalone = gen_const_char_ptr(n_standalone, 3);
44256:
44257: ret_val = xmlTextWriterStartDocument(writer, (const char *)version, (const char *)encoding, (const char *)standalone);
44258: desret_int(ret_val);
44259: call_tests++;
44260: des_xmlTextWriterPtr(n_writer, writer, 0);
44261: des_const_char_ptr(n_version, (const char *)version, 1);
44262: des_const_char_ptr(n_encoding, (const char *)encoding, 2);
44263: des_const_char_ptr(n_standalone, (const char *)standalone, 3);
44264: xmlResetLastError();
44265: if (mem_base != xmlMemBlocks()) {
44266: printf("Leak of %d blocks found in xmlTextWriterStartDocument",
44267: xmlMemBlocks() - mem_base);
44268: test_ret++;
44269: printf(" %d", n_writer);
44270: printf(" %d", n_version);
44271: printf(" %d", n_encoding);
44272: printf(" %d", n_standalone);
44273: printf("\n");
44274: }
44275: }
44276: }
44277: }
44278: }
44279: function_tests++;
44280: #endif
44281:
44282: return(test_ret);
44283: }
44284:
44285:
44286: static int
44287: test_xmlTextWriterStartElement(void) {
44288: int test_ret = 0;
44289:
44290: #if defined(LIBXML_WRITER_ENABLED)
44291: int mem_base;
44292: int ret_val;
44293: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44294: int n_writer;
44295: xmlChar * name; /* element name */
44296: int n_name;
44297:
44298: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44299: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44300: mem_base = xmlMemBlocks();
44301: writer = gen_xmlTextWriterPtr(n_writer, 0);
44302: name = gen_const_xmlChar_ptr(n_name, 1);
44303:
44304: ret_val = xmlTextWriterStartElement(writer, (const xmlChar *)name);
44305: desret_int(ret_val);
44306: call_tests++;
44307: des_xmlTextWriterPtr(n_writer, writer, 0);
44308: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
44309: xmlResetLastError();
44310: if (mem_base != xmlMemBlocks()) {
44311: printf("Leak of %d blocks found in xmlTextWriterStartElement",
44312: xmlMemBlocks() - mem_base);
44313: test_ret++;
44314: printf(" %d", n_writer);
44315: printf(" %d", n_name);
44316: printf("\n");
44317: }
44318: }
44319: }
44320: function_tests++;
44321: #endif
44322:
44323: return(test_ret);
44324: }
44325:
44326:
44327: static int
44328: test_xmlTextWriterStartElementNS(void) {
44329: int test_ret = 0;
44330:
44331: #if defined(LIBXML_WRITER_ENABLED)
44332: int mem_base;
44333: int ret_val;
44334: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44335: int n_writer;
44336: xmlChar * prefix; /* namespace prefix or NULL */
44337: int n_prefix;
44338: xmlChar * name; /* element local name */
44339: int n_name;
44340: xmlChar * namespaceURI; /* namespace URI or NULL */
44341: int n_namespaceURI;
44342:
44343: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44344: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
44345: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44346: for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
44347: mem_base = xmlMemBlocks();
44348: writer = gen_xmlTextWriterPtr(n_writer, 0);
44349: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
44350: name = gen_const_xmlChar_ptr(n_name, 2);
44351: namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 3);
44352:
44353: ret_val = xmlTextWriterStartElementNS(writer, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)namespaceURI);
44354: desret_int(ret_val);
44355: call_tests++;
44356: des_xmlTextWriterPtr(n_writer, writer, 0);
44357: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
44358: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
44359: des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 3);
44360: xmlResetLastError();
44361: if (mem_base != xmlMemBlocks()) {
44362: printf("Leak of %d blocks found in xmlTextWriterStartElementNS",
44363: xmlMemBlocks() - mem_base);
44364: test_ret++;
44365: printf(" %d", n_writer);
44366: printf(" %d", n_prefix);
44367: printf(" %d", n_name);
44368: printf(" %d", n_namespaceURI);
44369: printf("\n");
44370: }
44371: }
44372: }
44373: }
44374: }
44375: function_tests++;
44376: #endif
44377:
44378: return(test_ret);
44379: }
44380:
44381:
44382: static int
44383: test_xmlTextWriterStartPI(void) {
44384: int test_ret = 0;
44385:
44386: #if defined(LIBXML_WRITER_ENABLED)
44387: int mem_base;
44388: int ret_val;
44389: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44390: int n_writer;
44391: xmlChar * target; /* PI target */
44392: int n_target;
44393:
44394: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44395: for (n_target = 0;n_target < gen_nb_const_xmlChar_ptr;n_target++) {
44396: mem_base = xmlMemBlocks();
44397: writer = gen_xmlTextWriterPtr(n_writer, 0);
44398: target = gen_const_xmlChar_ptr(n_target, 1);
44399:
44400: ret_val = xmlTextWriterStartPI(writer, (const xmlChar *)target);
44401: desret_int(ret_val);
44402: call_tests++;
44403: des_xmlTextWriterPtr(n_writer, writer, 0);
44404: des_const_xmlChar_ptr(n_target, (const xmlChar *)target, 1);
44405: xmlResetLastError();
44406: if (mem_base != xmlMemBlocks()) {
44407: printf("Leak of %d blocks found in xmlTextWriterStartPI",
44408: xmlMemBlocks() - mem_base);
44409: test_ret++;
44410: printf(" %d", n_writer);
44411: printf(" %d", n_target);
44412: printf("\n");
44413: }
44414: }
44415: }
44416: function_tests++;
44417: #endif
44418:
44419: return(test_ret);
44420: }
44421:
44422:
44423: static int
44424: test_xmlTextWriterWriteAttribute(void) {
44425: int test_ret = 0;
44426:
44427: #if defined(LIBXML_WRITER_ENABLED)
44428: int mem_base;
44429: int ret_val;
44430: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44431: int n_writer;
44432: xmlChar * name; /* attribute name */
44433: int n_name;
44434: xmlChar * content; /* attribute content */
44435: int n_content;
44436:
44437: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44438: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44439: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44440: mem_base = xmlMemBlocks();
44441: writer = gen_xmlTextWriterPtr(n_writer, 0);
44442: name = gen_const_xmlChar_ptr(n_name, 1);
44443: content = gen_const_xmlChar_ptr(n_content, 2);
44444:
44445: ret_val = xmlTextWriterWriteAttribute(writer, (const xmlChar *)name, (const xmlChar *)content);
44446: desret_int(ret_val);
44447: call_tests++;
44448: des_xmlTextWriterPtr(n_writer, writer, 0);
44449: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
44450: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2);
44451: xmlResetLastError();
44452: if (mem_base != xmlMemBlocks()) {
44453: printf("Leak of %d blocks found in xmlTextWriterWriteAttribute",
44454: xmlMemBlocks() - mem_base);
44455: test_ret++;
44456: printf(" %d", n_writer);
44457: printf(" %d", n_name);
44458: printf(" %d", n_content);
44459: printf("\n");
44460: }
44461: }
44462: }
44463: }
44464: function_tests++;
44465: #endif
44466:
44467: return(test_ret);
44468: }
44469:
44470:
44471: static int
44472: test_xmlTextWriterWriteAttributeNS(void) {
44473: int test_ret = 0;
44474:
44475: #if defined(LIBXML_WRITER_ENABLED)
44476: int mem_base;
44477: int ret_val;
44478: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44479: int n_writer;
44480: xmlChar * prefix; /* namespace prefix */
44481: int n_prefix;
44482: xmlChar * name; /* attribute local name */
44483: int n_name;
44484: xmlChar * namespaceURI; /* namespace URI */
44485: int n_namespaceURI;
44486: xmlChar * content; /* attribute content */
44487: int n_content;
44488:
44489: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44490: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
44491: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44492: for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
44493: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44494: mem_base = xmlMemBlocks();
44495: writer = gen_xmlTextWriterPtr(n_writer, 0);
44496: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
44497: name = gen_const_xmlChar_ptr(n_name, 2);
44498: namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 3);
44499: content = gen_const_xmlChar_ptr(n_content, 4);
44500:
44501: ret_val = xmlTextWriterWriteAttributeNS(writer, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)namespaceURI, (const xmlChar *)content);
44502: desret_int(ret_val);
44503: call_tests++;
44504: des_xmlTextWriterPtr(n_writer, writer, 0);
44505: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
44506: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
44507: des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 3);
44508: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 4);
44509: xmlResetLastError();
44510: if (mem_base != xmlMemBlocks()) {
44511: printf("Leak of %d blocks found in xmlTextWriterWriteAttributeNS",
44512: xmlMemBlocks() - mem_base);
44513: test_ret++;
44514: printf(" %d", n_writer);
44515: printf(" %d", n_prefix);
44516: printf(" %d", n_name);
44517: printf(" %d", n_namespaceURI);
44518: printf(" %d", n_content);
44519: printf("\n");
44520: }
44521: }
44522: }
44523: }
44524: }
44525: }
44526: function_tests++;
44527: #endif
44528:
44529: return(test_ret);
44530: }
44531:
44532:
44533: static int
44534: test_xmlTextWriterWriteBase64(void) {
44535: int test_ret = 0;
44536:
44537: #if defined(LIBXML_WRITER_ENABLED)
44538: int mem_base;
44539: int ret_val;
44540: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44541: int n_writer;
44542: char * data; /* binary data */
44543: int n_data;
44544: int start; /* the position within the data of the first byte to encode */
44545: int n_start;
44546: int len; /* the number of bytes to encode */
44547: int n_len;
44548:
44549: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44550: for (n_data = 0;n_data < gen_nb_const_char_ptr;n_data++) {
44551: for (n_start = 0;n_start < gen_nb_int;n_start++) {
44552: for (n_len = 0;n_len < gen_nb_int;n_len++) {
44553: mem_base = xmlMemBlocks();
44554: writer = gen_xmlTextWriterPtr(n_writer, 0);
44555: data = gen_const_char_ptr(n_data, 1);
44556: start = gen_int(n_start, 2);
44557: len = gen_int(n_len, 3);
44558:
44559: ret_val = xmlTextWriterWriteBase64(writer, (const char *)data, start, len);
44560: desret_int(ret_val);
44561: call_tests++;
44562: des_xmlTextWriterPtr(n_writer, writer, 0);
44563: des_const_char_ptr(n_data, (const char *)data, 1);
44564: des_int(n_start, start, 2);
44565: des_int(n_len, len, 3);
44566: xmlResetLastError();
44567: if (mem_base != xmlMemBlocks()) {
44568: printf("Leak of %d blocks found in xmlTextWriterWriteBase64",
44569: xmlMemBlocks() - mem_base);
44570: test_ret++;
44571: printf(" %d", n_writer);
44572: printf(" %d", n_data);
44573: printf(" %d", n_start);
44574: printf(" %d", n_len);
44575: printf("\n");
44576: }
44577: }
44578: }
44579: }
44580: }
44581: function_tests++;
44582: #endif
44583:
44584: return(test_ret);
44585: }
44586:
44587:
44588: static int
44589: test_xmlTextWriterWriteBinHex(void) {
44590: int test_ret = 0;
44591:
44592: #if defined(LIBXML_WRITER_ENABLED)
44593: int mem_base;
44594: int ret_val;
44595: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44596: int n_writer;
44597: char * data; /* binary data */
44598: int n_data;
44599: int start; /* the position within the data of the first byte to encode */
44600: int n_start;
44601: int len; /* the number of bytes to encode */
44602: int n_len;
44603:
44604: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44605: for (n_data = 0;n_data < gen_nb_const_char_ptr;n_data++) {
44606: for (n_start = 0;n_start < gen_nb_int;n_start++) {
44607: for (n_len = 0;n_len < gen_nb_int;n_len++) {
44608: mem_base = xmlMemBlocks();
44609: writer = gen_xmlTextWriterPtr(n_writer, 0);
44610: data = gen_const_char_ptr(n_data, 1);
44611: start = gen_int(n_start, 2);
44612: len = gen_int(n_len, 3);
44613:
44614: ret_val = xmlTextWriterWriteBinHex(writer, (const char *)data, start, len);
44615: desret_int(ret_val);
44616: call_tests++;
44617: des_xmlTextWriterPtr(n_writer, writer, 0);
44618: des_const_char_ptr(n_data, (const char *)data, 1);
44619: des_int(n_start, start, 2);
44620: des_int(n_len, len, 3);
44621: xmlResetLastError();
44622: if (mem_base != xmlMemBlocks()) {
44623: printf("Leak of %d blocks found in xmlTextWriterWriteBinHex",
44624: xmlMemBlocks() - mem_base);
44625: test_ret++;
44626: printf(" %d", n_writer);
44627: printf(" %d", n_data);
44628: printf(" %d", n_start);
44629: printf(" %d", n_len);
44630: printf("\n");
44631: }
44632: }
44633: }
44634: }
44635: }
44636: function_tests++;
44637: #endif
44638:
44639: return(test_ret);
44640: }
44641:
44642:
44643: static int
44644: test_xmlTextWriterWriteCDATA(void) {
44645: int test_ret = 0;
44646:
44647: #if defined(LIBXML_WRITER_ENABLED)
44648: int mem_base;
44649: int ret_val;
44650: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44651: int n_writer;
44652: xmlChar * content; /* CDATA content */
44653: int n_content;
44654:
44655: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44656: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44657: mem_base = xmlMemBlocks();
44658: writer = gen_xmlTextWriterPtr(n_writer, 0);
44659: content = gen_const_xmlChar_ptr(n_content, 1);
44660:
44661: ret_val = xmlTextWriterWriteCDATA(writer, (const xmlChar *)content);
44662: desret_int(ret_val);
44663: call_tests++;
44664: des_xmlTextWriterPtr(n_writer, writer, 0);
44665: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
44666: xmlResetLastError();
44667: if (mem_base != xmlMemBlocks()) {
44668: printf("Leak of %d blocks found in xmlTextWriterWriteCDATA",
44669: xmlMemBlocks() - mem_base);
44670: test_ret++;
44671: printf(" %d", n_writer);
44672: printf(" %d", n_content);
44673: printf("\n");
44674: }
44675: }
44676: }
44677: function_tests++;
44678: #endif
44679:
44680: return(test_ret);
44681: }
44682:
44683:
44684: static int
44685: test_xmlTextWriterWriteComment(void) {
44686: int test_ret = 0;
44687:
44688: #if defined(LIBXML_WRITER_ENABLED)
44689: int mem_base;
44690: int ret_val;
44691: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44692: int n_writer;
44693: xmlChar * content; /* comment string */
44694: int n_content;
44695:
44696: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44697: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44698: mem_base = xmlMemBlocks();
44699: writer = gen_xmlTextWriterPtr(n_writer, 0);
44700: content = gen_const_xmlChar_ptr(n_content, 1);
44701:
44702: ret_val = xmlTextWriterWriteComment(writer, (const xmlChar *)content);
44703: desret_int(ret_val);
44704: call_tests++;
44705: des_xmlTextWriterPtr(n_writer, writer, 0);
44706: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
44707: xmlResetLastError();
44708: if (mem_base != xmlMemBlocks()) {
44709: printf("Leak of %d blocks found in xmlTextWriterWriteComment",
44710: xmlMemBlocks() - mem_base);
44711: test_ret++;
44712: printf(" %d", n_writer);
44713: printf(" %d", n_content);
44714: printf("\n");
44715: }
44716: }
44717: }
44718: function_tests++;
44719: #endif
44720:
44721: return(test_ret);
44722: }
44723:
44724:
44725: static int
44726: test_xmlTextWriterWriteDTD(void) {
44727: int test_ret = 0;
44728:
44729: #if defined(LIBXML_WRITER_ENABLED)
44730: int mem_base;
44731: int ret_val;
44732: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44733: int n_writer;
44734: xmlChar * name; /* the name of the DTD */
44735: int n_name;
44736: xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
44737: int n_pubid;
44738: xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
44739: int n_sysid;
44740: xmlChar * subset; /* string content of the DTD */
44741: int n_subset;
44742:
44743: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44744: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44745: for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
44746: for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
44747: for (n_subset = 0;n_subset < gen_nb_const_xmlChar_ptr;n_subset++) {
44748: mem_base = xmlMemBlocks();
44749: writer = gen_xmlTextWriterPtr(n_writer, 0);
44750: name = gen_const_xmlChar_ptr(n_name, 1);
44751: pubid = gen_const_xmlChar_ptr(n_pubid, 2);
44752: sysid = gen_const_xmlChar_ptr(n_sysid, 3);
44753: subset = gen_const_xmlChar_ptr(n_subset, 4);
44754:
44755: ret_val = xmlTextWriterWriteDTD(writer, (const xmlChar *)name, (const xmlChar *)pubid, (const xmlChar *)sysid, (const xmlChar *)subset);
44756: desret_int(ret_val);
44757: call_tests++;
44758: des_xmlTextWriterPtr(n_writer, writer, 0);
44759: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
44760: des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 2);
44761: des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 3);
44762: des_const_xmlChar_ptr(n_subset, (const xmlChar *)subset, 4);
44763: xmlResetLastError();
44764: if (mem_base != xmlMemBlocks()) {
44765: printf("Leak of %d blocks found in xmlTextWriterWriteDTD",
44766: xmlMemBlocks() - mem_base);
44767: test_ret++;
44768: printf(" %d", n_writer);
44769: printf(" %d", n_name);
44770: printf(" %d", n_pubid);
44771: printf(" %d", n_sysid);
44772: printf(" %d", n_subset);
44773: printf("\n");
44774: }
44775: }
44776: }
44777: }
44778: }
44779: }
44780: function_tests++;
44781: #endif
44782:
44783: return(test_ret);
44784: }
44785:
44786:
44787: static int
44788: test_xmlTextWriterWriteDTDAttlist(void) {
44789: int test_ret = 0;
44790:
44791: #if defined(LIBXML_WRITER_ENABLED)
44792: int mem_base;
44793: int ret_val;
44794: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44795: int n_writer;
44796: xmlChar * name; /* the name of the DTD ATTLIST */
44797: int n_name;
44798: xmlChar * content; /* content of the ATTLIST */
44799: int n_content;
44800:
44801: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44802: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44803: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44804: mem_base = xmlMemBlocks();
44805: writer = gen_xmlTextWriterPtr(n_writer, 0);
44806: name = gen_const_xmlChar_ptr(n_name, 1);
44807: content = gen_const_xmlChar_ptr(n_content, 2);
44808:
44809: ret_val = xmlTextWriterWriteDTDAttlist(writer, (const xmlChar *)name, (const xmlChar *)content);
44810: desret_int(ret_val);
44811: call_tests++;
44812: des_xmlTextWriterPtr(n_writer, writer, 0);
44813: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
44814: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2);
44815: xmlResetLastError();
44816: if (mem_base != xmlMemBlocks()) {
44817: printf("Leak of %d blocks found in xmlTextWriterWriteDTDAttlist",
44818: xmlMemBlocks() - mem_base);
44819: test_ret++;
44820: printf(" %d", n_writer);
44821: printf(" %d", n_name);
44822: printf(" %d", n_content);
44823: printf("\n");
44824: }
44825: }
44826: }
44827: }
44828: function_tests++;
44829: #endif
44830:
44831: return(test_ret);
44832: }
44833:
44834:
44835: static int
44836: test_xmlTextWriterWriteDTDElement(void) {
44837: int test_ret = 0;
44838:
44839: #if defined(LIBXML_WRITER_ENABLED)
44840: int mem_base;
44841: int ret_val;
44842: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44843: int n_writer;
44844: xmlChar * name; /* the name of the DTD element */
44845: int n_name;
44846: xmlChar * content; /* content of the element */
44847: int n_content;
44848:
44849: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44850: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44851: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44852: mem_base = xmlMemBlocks();
44853: writer = gen_xmlTextWriterPtr(n_writer, 0);
44854: name = gen_const_xmlChar_ptr(n_name, 1);
44855: content = gen_const_xmlChar_ptr(n_content, 2);
44856:
44857: ret_val = xmlTextWriterWriteDTDElement(writer, (const xmlChar *)name, (const xmlChar *)content);
44858: desret_int(ret_val);
44859: call_tests++;
44860: des_xmlTextWriterPtr(n_writer, writer, 0);
44861: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
44862: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2);
44863: xmlResetLastError();
44864: if (mem_base != xmlMemBlocks()) {
44865: printf("Leak of %d blocks found in xmlTextWriterWriteDTDElement",
44866: xmlMemBlocks() - mem_base);
44867: test_ret++;
44868: printf(" %d", n_writer);
44869: printf(" %d", n_name);
44870: printf(" %d", n_content);
44871: printf("\n");
44872: }
44873: }
44874: }
44875: }
44876: function_tests++;
44877: #endif
44878:
44879: return(test_ret);
44880: }
44881:
44882:
44883: static int
44884: test_xmlTextWriterWriteDTDEntity(void) {
44885: int test_ret = 0;
44886:
44887: #if defined(LIBXML_WRITER_ENABLED)
44888: int mem_base;
44889: int ret_val;
44890: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44891: int n_writer;
44892: int pe; /* TRUE if this is a parameter entity, FALSE if not */
44893: int n_pe;
44894: xmlChar * name; /* the name of the DTD entity */
44895: int n_name;
44896: xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
44897: int n_pubid;
44898: xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
44899: int n_sysid;
44900: xmlChar * ndataid; /* the xml notation name. */
44901: int n_ndataid;
44902: xmlChar * content; /* content of the entity */
44903: int n_content;
44904:
44905: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44906: for (n_pe = 0;n_pe < gen_nb_int;n_pe++) {
44907: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44908: for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
44909: for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
44910: for (n_ndataid = 0;n_ndataid < gen_nb_const_xmlChar_ptr;n_ndataid++) {
44911: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44912: mem_base = xmlMemBlocks();
44913: writer = gen_xmlTextWriterPtr(n_writer, 0);
44914: pe = gen_int(n_pe, 1);
44915: name = gen_const_xmlChar_ptr(n_name, 2);
44916: pubid = gen_const_xmlChar_ptr(n_pubid, 3);
44917: sysid = gen_const_xmlChar_ptr(n_sysid, 4);
44918: ndataid = gen_const_xmlChar_ptr(n_ndataid, 5);
44919: content = gen_const_xmlChar_ptr(n_content, 6);
44920:
44921: ret_val = xmlTextWriterWriteDTDEntity(writer, pe, (const xmlChar *)name, (const xmlChar *)pubid, (const xmlChar *)sysid, (const xmlChar *)ndataid, (const xmlChar *)content);
44922: desret_int(ret_val);
44923: call_tests++;
44924: des_xmlTextWriterPtr(n_writer, writer, 0);
44925: des_int(n_pe, pe, 1);
44926: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
44927: des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 3);
44928: des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 4);
44929: des_const_xmlChar_ptr(n_ndataid, (const xmlChar *)ndataid, 5);
44930: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 6);
44931: xmlResetLastError();
44932: if (mem_base != xmlMemBlocks()) {
44933: printf("Leak of %d blocks found in xmlTextWriterWriteDTDEntity",
44934: xmlMemBlocks() - mem_base);
44935: test_ret++;
44936: printf(" %d", n_writer);
44937: printf(" %d", n_pe);
44938: printf(" %d", n_name);
44939: printf(" %d", n_pubid);
44940: printf(" %d", n_sysid);
44941: printf(" %d", n_ndataid);
44942: printf(" %d", n_content);
44943: printf("\n");
44944: }
44945: }
44946: }
44947: }
44948: }
44949: }
44950: }
44951: }
44952: function_tests++;
44953: #endif
44954:
44955: return(test_ret);
44956: }
44957:
44958:
44959: static int
44960: test_xmlTextWriterWriteDTDExternalEntity(void) {
44961: int test_ret = 0;
44962:
44963: #if defined(LIBXML_WRITER_ENABLED)
44964: int mem_base;
44965: int ret_val;
44966: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44967: int n_writer;
44968: int pe; /* TRUE if this is a parameter entity, FALSE if not */
44969: int n_pe;
44970: xmlChar * name; /* the name of the DTD entity */
44971: int n_name;
44972: xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
44973: int n_pubid;
44974: xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
44975: int n_sysid;
44976: xmlChar * ndataid; /* the xml notation name. */
44977: int n_ndataid;
44978:
44979: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44980: for (n_pe = 0;n_pe < gen_nb_int;n_pe++) {
44981: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44982: for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
44983: for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
44984: for (n_ndataid = 0;n_ndataid < gen_nb_const_xmlChar_ptr;n_ndataid++) {
44985: mem_base = xmlMemBlocks();
44986: writer = gen_xmlTextWriterPtr(n_writer, 0);
44987: pe = gen_int(n_pe, 1);
44988: name = gen_const_xmlChar_ptr(n_name, 2);
44989: pubid = gen_const_xmlChar_ptr(n_pubid, 3);
44990: sysid = gen_const_xmlChar_ptr(n_sysid, 4);
44991: ndataid = gen_const_xmlChar_ptr(n_ndataid, 5);
44992:
44993: ret_val = xmlTextWriterWriteDTDExternalEntity(writer, pe, (const xmlChar *)name, (const xmlChar *)pubid, (const xmlChar *)sysid, (const xmlChar *)ndataid);
44994: desret_int(ret_val);
44995: call_tests++;
44996: des_xmlTextWriterPtr(n_writer, writer, 0);
44997: des_int(n_pe, pe, 1);
44998: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
44999: des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 3);
45000: des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 4);
45001: des_const_xmlChar_ptr(n_ndataid, (const xmlChar *)ndataid, 5);
45002: xmlResetLastError();
45003: if (mem_base != xmlMemBlocks()) {
45004: printf("Leak of %d blocks found in xmlTextWriterWriteDTDExternalEntity",
45005: xmlMemBlocks() - mem_base);
45006: test_ret++;
45007: printf(" %d", n_writer);
45008: printf(" %d", n_pe);
45009: printf(" %d", n_name);
45010: printf(" %d", n_pubid);
45011: printf(" %d", n_sysid);
45012: printf(" %d", n_ndataid);
45013: printf("\n");
45014: }
45015: }
45016: }
45017: }
45018: }
45019: }
45020: }
45021: function_tests++;
45022: #endif
45023:
45024: return(test_ret);
45025: }
45026:
45027:
45028: static int
45029: test_xmlTextWriterWriteDTDExternalEntityContents(void) {
45030: int test_ret = 0;
45031:
45032: #if defined(LIBXML_WRITER_ENABLED)
45033: int mem_base;
45034: int ret_val;
45035: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
45036: int n_writer;
45037: xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
45038: int n_pubid;
45039: xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
45040: int n_sysid;
45041: xmlChar * ndataid; /* the xml notation name. */
45042: int n_ndataid;
45043:
45044: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
45045: for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
45046: for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
45047: for (n_ndataid = 0;n_ndataid < gen_nb_const_xmlChar_ptr;n_ndataid++) {
45048: mem_base = xmlMemBlocks();
45049: writer = gen_xmlTextWriterPtr(n_writer, 0);
45050: pubid = gen_const_xmlChar_ptr(n_pubid, 1);
45051: sysid = gen_const_xmlChar_ptr(n_sysid, 2);
45052: ndataid = gen_const_xmlChar_ptr(n_ndataid, 3);
45053:
45054: ret_val = xmlTextWriterWriteDTDExternalEntityContents(writer, (const xmlChar *)pubid, (const xmlChar *)sysid, (const xmlChar *)ndataid);
45055: desret_int(ret_val);
45056: call_tests++;
45057: des_xmlTextWriterPtr(n_writer, writer, 0);
45058: des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 1);
45059: des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 2);
45060: des_const_xmlChar_ptr(n_ndataid, (const xmlChar *)ndataid, 3);
45061: xmlResetLastError();
45062: if (mem_base != xmlMemBlocks()) {
45063: printf("Leak of %d blocks found in xmlTextWriterWriteDTDExternalEntityContents",
45064: xmlMemBlocks() - mem_base);
45065: test_ret++;
45066: printf(" %d", n_writer);
45067: printf(" %d", n_pubid);
45068: printf(" %d", n_sysid);
45069: printf(" %d", n_ndataid);
45070: printf("\n");
45071: }
45072: }
45073: }
45074: }
45075: }
45076: function_tests++;
45077: #endif
45078:
45079: return(test_ret);
45080: }
45081:
45082:
45083: static int
45084: test_xmlTextWriterWriteDTDInternalEntity(void) {
45085: int test_ret = 0;
45086:
45087: #if defined(LIBXML_WRITER_ENABLED)
45088: int mem_base;
45089: int ret_val;
45090: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
45091: int n_writer;
45092: int pe; /* TRUE if this is a parameter entity, FALSE if not */
45093: int n_pe;
45094: xmlChar * name; /* the name of the DTD entity */
45095: int n_name;
45096: xmlChar * content; /* content of the entity */
45097: int n_content;
45098:
45099: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
45100: for (n_pe = 0;n_pe < gen_nb_int;n_pe++) {
45101: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
45102: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
45103: mem_base = xmlMemBlocks();
45104: writer = gen_xmlTextWriterPtr(n_writer, 0);
45105: pe = gen_int(n_pe, 1);
45106: name = gen_const_xmlChar_ptr(n_name, 2);
45107: content = gen_const_xmlChar_ptr(n_content, 3);
45108:
45109: ret_val = xmlTextWriterWriteDTDInternalEntity(writer, pe, (const xmlChar *)name, (const xmlChar *)content);
45110: desret_int(ret_val);
45111: call_tests++;
45112: des_xmlTextWriterPtr(n_writer, writer, 0);
45113: des_int(n_pe, pe, 1);
45114: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
45115: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3);
45116: xmlResetLastError();
45117: if (mem_base != xmlMemBlocks()) {
45118: printf("Leak of %d blocks found in xmlTextWriterWriteDTDInternalEntity",
45119: xmlMemBlocks() - mem_base);
45120: test_ret++;
45121: printf(" %d", n_writer);
45122: printf(" %d", n_pe);
45123: printf(" %d", n_name);
45124: printf(" %d", n_content);
45125: printf("\n");
45126: }
45127: }
45128: }
45129: }
45130: }
45131: function_tests++;
45132: #endif
45133:
45134: return(test_ret);
45135: }
45136:
45137:
45138: static int
45139: test_xmlTextWriterWriteDTDNotation(void) {
45140: int test_ret = 0;
45141:
45142: #if defined(LIBXML_WRITER_ENABLED)
45143: int mem_base;
45144: int ret_val;
45145: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
45146: int n_writer;
45147: xmlChar * name; /* the name of the xml notation */
45148: int n_name;
45149: xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
45150: int n_pubid;
45151: xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
45152: int n_sysid;
45153:
45154: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
45155: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
45156: for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
45157: for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
45158: mem_base = xmlMemBlocks();
45159: writer = gen_xmlTextWriterPtr(n_writer, 0);
45160: name = gen_const_xmlChar_ptr(n_name, 1);
45161: pubid = gen_const_xmlChar_ptr(n_pubid, 2);
45162: sysid = gen_const_xmlChar_ptr(n_sysid, 3);
45163:
45164: ret_val = xmlTextWriterWriteDTDNotation(writer, (const xmlChar *)name, (const xmlChar *)pubid, (const xmlChar *)sysid);
45165: desret_int(ret_val);
45166: call_tests++;
45167: des_xmlTextWriterPtr(n_writer, writer, 0);
45168: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
45169: des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 2);
45170: des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 3);
45171: xmlResetLastError();
45172: if (mem_base != xmlMemBlocks()) {
45173: printf("Leak of %d blocks found in xmlTextWriterWriteDTDNotation",
45174: xmlMemBlocks() - mem_base);
45175: test_ret++;
45176: printf(" %d", n_writer);
45177: printf(" %d", n_name);
45178: printf(" %d", n_pubid);
45179: printf(" %d", n_sysid);
45180: printf("\n");
45181: }
45182: }
45183: }
45184: }
45185: }
45186: function_tests++;
45187: #endif
45188:
45189: return(test_ret);
45190: }
45191:
45192:
45193: static int
45194: test_xmlTextWriterWriteElement(void) {
45195: int test_ret = 0;
45196:
45197: #if defined(LIBXML_WRITER_ENABLED)
45198: int mem_base;
45199: int ret_val;
45200: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
45201: int n_writer;
45202: xmlChar * name; /* element name */
45203: int n_name;
45204: xmlChar * content; /* element content */
45205: int n_content;
45206:
45207: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
45208: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
45209: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
45210: mem_base = xmlMemBlocks();
45211: writer = gen_xmlTextWriterPtr(n_writer, 0);
45212: name = gen_const_xmlChar_ptr(n_name, 1);
45213: content = gen_const_xmlChar_ptr(n_content, 2);
45214:
45215: ret_val = xmlTextWriterWriteElement(writer, (const xmlChar *)name, (const xmlChar *)content);
45216: desret_int(ret_val);
45217: call_tests++;
45218: des_xmlTextWriterPtr(n_writer, writer, 0);
45219: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
45220: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2);
45221: xmlResetLastError();
45222: if (mem_base != xmlMemBlocks()) {
45223: printf("Leak of %d blocks found in xmlTextWriterWriteElement",
45224: xmlMemBlocks() - mem_base);
45225: test_ret++;
45226: printf(" %d", n_writer);
45227: printf(" %d", n_name);
45228: printf(" %d", n_content);
45229: printf("\n");
45230: }
45231: }
45232: }
45233: }
45234: function_tests++;
45235: #endif
45236:
45237: return(test_ret);
45238: }
45239:
45240:
45241: static int
45242: test_xmlTextWriterWriteElementNS(void) {
45243: int test_ret = 0;
45244:
45245: #if defined(LIBXML_WRITER_ENABLED)
45246: int mem_base;
45247: int ret_val;
45248: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
45249: int n_writer;
45250: xmlChar * prefix; /* namespace prefix */
45251: int n_prefix;
45252: xmlChar * name; /* element local name */
45253: int n_name;
45254: xmlChar * namespaceURI; /* namespace URI */
45255: int n_namespaceURI;
45256: xmlChar * content; /* element content */
45257: int n_content;
45258:
45259: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
45260: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
45261: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
45262: for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
45263: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
45264: mem_base = xmlMemBlocks();
45265: writer = gen_xmlTextWriterPtr(n_writer, 0);
45266: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
45267: name = gen_const_xmlChar_ptr(n_name, 2);
45268: namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 3);
45269: content = gen_const_xmlChar_ptr(n_content, 4);
45270:
45271: ret_val = xmlTextWriterWriteElementNS(writer, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)namespaceURI, (const xmlChar *)content);
45272: desret_int(ret_val);
45273: call_tests++;
45274: des_xmlTextWriterPtr(n_writer, writer, 0);
45275: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
45276: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
45277: des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 3);
45278: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 4);
45279: xmlResetLastError();
45280: if (mem_base != xmlMemBlocks()) {
45281: printf("Leak of %d blocks found in xmlTextWriterWriteElementNS",
45282: xmlMemBlocks() - mem_base);
45283: test_ret++;
45284: printf(" %d", n_writer);
45285: printf(" %d", n_prefix);
45286: printf(" %d", n_name);
45287: printf(" %d", n_namespaceURI);
45288: printf(" %d", n_content);
45289: printf("\n");
45290: }
45291: }
45292: }
45293: }
45294: }
45295: }
45296: function_tests++;
45297: #endif
45298:
45299: return(test_ret);
45300: }
45301:
45302:
45303: static int
45304: test_xmlTextWriterWriteFormatAttribute(void) {
45305: int test_ret = 0;
45306:
45307:
45308: /* missing type support */
45309: return(test_ret);
45310: }
45311:
45312:
45313: static int
45314: test_xmlTextWriterWriteFormatAttributeNS(void) {
45315: int test_ret = 0;
45316:
45317:
45318: /* missing type support */
45319: return(test_ret);
45320: }
45321:
45322:
45323: static int
45324: test_xmlTextWriterWriteFormatCDATA(void) {
45325: int test_ret = 0;
45326:
45327:
45328: /* missing type support */
45329: return(test_ret);
45330: }
45331:
45332:
45333: static int
45334: test_xmlTextWriterWriteFormatComment(void) {
45335: int test_ret = 0;
45336:
45337:
45338: /* missing type support */
45339: return(test_ret);
45340: }
45341:
45342:
45343: static int
45344: test_xmlTextWriterWriteFormatDTD(void) {
45345: int test_ret = 0;
45346:
45347:
45348: /* missing type support */
45349: return(test_ret);
45350: }
45351:
45352:
45353: static int
45354: test_xmlTextWriterWriteFormatDTDAttlist(void) {
45355: int test_ret = 0;
45356:
45357:
45358: /* missing type support */
45359: return(test_ret);
45360: }
45361:
45362:
45363: static int
45364: test_xmlTextWriterWriteFormatDTDElement(void) {
45365: int test_ret = 0;
45366:
45367:
45368: /* missing type support */
45369: return(test_ret);
45370: }
45371:
45372:
45373: static int
45374: test_xmlTextWriterWriteFormatDTDInternalEntity(void) {
45375: int test_ret = 0;
45376:
45377:
45378: /* missing type support */
45379: return(test_ret);
45380: }
45381:
45382:
45383: static int
45384: test_xmlTextWriterWriteFormatElement(void) {
45385: int test_ret = 0;
45386:
45387:
45388: /* missing type support */
45389: return(test_ret);
45390: }
45391:
45392:
45393: static int
45394: test_xmlTextWriterWriteFormatElementNS(void) {
45395: int test_ret = 0;
45396:
45397:
45398: /* missing type support */
45399: return(test_ret);
45400: }
45401:
45402:
45403: static int
45404: test_xmlTextWriterWriteFormatPI(void) {
45405: int test_ret = 0;
45406:
45407:
45408: /* missing type support */
45409: return(test_ret);
45410: }
45411:
45412:
45413: static int
45414: test_xmlTextWriterWriteFormatRaw(void) {
45415: int test_ret = 0;
45416:
45417:
45418: /* missing type support */
45419: return(test_ret);
45420: }
45421:
45422:
45423: static int
45424: test_xmlTextWriterWriteFormatString(void) {
45425: int test_ret = 0;
45426:
45427:
45428: /* missing type support */
45429: return(test_ret);
45430: }
45431:
45432:
45433: static int
45434: test_xmlTextWriterWritePI(void) {
45435: int test_ret = 0;
45436:
45437: #if defined(LIBXML_WRITER_ENABLED)
45438: int mem_base;
45439: int ret_val;
45440: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
45441: int n_writer;
45442: xmlChar * target; /* PI target */
45443: int n_target;
45444: xmlChar * content; /* PI content */
45445: int n_content;
45446:
45447: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
45448: for (n_target = 0;n_target < gen_nb_const_xmlChar_ptr;n_target++) {
45449: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
45450: mem_base = xmlMemBlocks();
45451: writer = gen_xmlTextWriterPtr(n_writer, 0);
45452: target = gen_const_xmlChar_ptr(n_target, 1);
45453: content = gen_const_xmlChar_ptr(n_content, 2);
45454:
45455: ret_val = xmlTextWriterWritePI(writer, (const xmlChar *)target, (const xmlChar *)content);
45456: desret_int(ret_val);
45457: call_tests++;
45458: des_xmlTextWriterPtr(n_writer, writer, 0);
45459: des_const_xmlChar_ptr(n_target, (const xmlChar *)target, 1);
45460: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2);
45461: xmlResetLastError();
45462: if (mem_base != xmlMemBlocks()) {
45463: printf("Leak of %d blocks found in xmlTextWriterWritePI",
45464: xmlMemBlocks() - mem_base);
45465: test_ret++;
45466: printf(" %d", n_writer);
45467: printf(" %d", n_target);
45468: printf(" %d", n_content);
45469: printf("\n");
45470: }
45471: }
45472: }
45473: }
45474: function_tests++;
45475: #endif
45476:
45477: return(test_ret);
45478: }
45479:
45480:
45481: static int
45482: test_xmlTextWriterWriteRaw(void) {
45483: int test_ret = 0;
45484:
45485: #if defined(LIBXML_WRITER_ENABLED)
45486: int mem_base;
45487: int ret_val;
45488: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
45489: int n_writer;
45490: xmlChar * content; /* text string */
45491: int n_content;
45492:
45493: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
45494: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
45495: mem_base = xmlMemBlocks();
45496: writer = gen_xmlTextWriterPtr(n_writer, 0);
45497: content = gen_const_xmlChar_ptr(n_content, 1);
45498:
45499: ret_val = xmlTextWriterWriteRaw(writer, (const xmlChar *)content);
45500: desret_int(ret_val);
45501: call_tests++;
45502: des_xmlTextWriterPtr(n_writer, writer, 0);
45503: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
45504: xmlResetLastError();
45505: if (mem_base != xmlMemBlocks()) {
45506: printf("Leak of %d blocks found in xmlTextWriterWriteRaw",
45507: xmlMemBlocks() - mem_base);
45508: test_ret++;
45509: printf(" %d", n_writer);
45510: printf(" %d", n_content);
45511: printf("\n");
45512: }
45513: }
45514: }
45515: function_tests++;
45516: #endif
45517:
45518: return(test_ret);
45519: }
45520:
45521:
45522: static int
45523: test_xmlTextWriterWriteRawLen(void) {
45524: int test_ret = 0;
45525:
45526: #if defined(LIBXML_WRITER_ENABLED)
45527: int mem_base;
45528: int ret_val;
45529: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
45530: int n_writer;
45531: xmlChar * content; /* text string */
45532: int n_content;
45533: int len; /* length of the text string */
45534: int n_len;
45535:
45536: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
45537: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
45538: for (n_len = 0;n_len < gen_nb_int;n_len++) {
45539: mem_base = xmlMemBlocks();
45540: writer = gen_xmlTextWriterPtr(n_writer, 0);
45541: content = gen_const_xmlChar_ptr(n_content, 1);
45542: len = gen_int(n_len, 2);
45543:
45544: ret_val = xmlTextWriterWriteRawLen(writer, (const xmlChar *)content, len);
45545: desret_int(ret_val);
45546: call_tests++;
45547: des_xmlTextWriterPtr(n_writer, writer, 0);
45548: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
45549: des_int(n_len, len, 2);
45550: xmlResetLastError();
45551: if (mem_base != xmlMemBlocks()) {
45552: printf("Leak of %d blocks found in xmlTextWriterWriteRawLen",
45553: xmlMemBlocks() - mem_base);
45554: test_ret++;
45555: printf(" %d", n_writer);
45556: printf(" %d", n_content);
45557: printf(" %d", n_len);
45558: printf("\n");
45559: }
45560: }
45561: }
45562: }
45563: function_tests++;
45564: #endif
45565:
45566: return(test_ret);
45567: }
45568:
45569:
45570: static int
45571: test_xmlTextWriterWriteString(void) {
45572: int test_ret = 0;
45573:
45574: #if defined(LIBXML_WRITER_ENABLED)
45575: int mem_base;
45576: int ret_val;
45577: xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
45578: int n_writer;
45579: xmlChar * content; /* text string */
45580: int n_content;
45581:
45582: for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
45583: for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
45584: mem_base = xmlMemBlocks();
45585: writer = gen_xmlTextWriterPtr(n_writer, 0);
45586: content = gen_const_xmlChar_ptr(n_content, 1);
45587:
45588: ret_val = xmlTextWriterWriteString(writer, (const xmlChar *)content);
45589: desret_int(ret_val);
45590: call_tests++;
45591: des_xmlTextWriterPtr(n_writer, writer, 0);
45592: des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
45593: xmlResetLastError();
45594: if (mem_base != xmlMemBlocks()) {
45595: printf("Leak of %d blocks found in xmlTextWriterWriteString",
45596: xmlMemBlocks() - mem_base);
45597: test_ret++;
45598: printf(" %d", n_writer);
45599: printf(" %d", n_content);
45600: printf("\n");
45601: }
45602: }
45603: }
45604: function_tests++;
45605: #endif
45606:
45607: return(test_ret);
45608: }
45609:
45610:
45611: static int
45612: test_xmlTextWriterWriteVFormatAttribute(void) {
45613: int test_ret = 0;
45614:
45615:
45616: /* missing type support */
45617: return(test_ret);
45618: }
45619:
45620:
45621: static int
45622: test_xmlTextWriterWriteVFormatAttributeNS(void) {
45623: int test_ret = 0;
45624:
45625:
45626: /* missing type support */
45627: return(test_ret);
45628: }
45629:
45630:
45631: static int
45632: test_xmlTextWriterWriteVFormatCDATA(void) {
45633: int test_ret = 0;
45634:
45635:
45636: /* missing type support */
45637: return(test_ret);
45638: }
45639:
45640:
45641: static int
45642: test_xmlTextWriterWriteVFormatComment(void) {
45643: int test_ret = 0;
45644:
45645:
45646: /* missing type support */
45647: return(test_ret);
45648: }
45649:
45650:
45651: static int
45652: test_xmlTextWriterWriteVFormatDTD(void) {
45653: int test_ret = 0;
45654:
45655:
45656: /* missing type support */
45657: return(test_ret);
45658: }
45659:
45660:
45661: static int
45662: test_xmlTextWriterWriteVFormatDTDAttlist(void) {
45663: int test_ret = 0;
45664:
45665:
45666: /* missing type support */
45667: return(test_ret);
45668: }
45669:
45670:
45671: static int
45672: test_xmlTextWriterWriteVFormatDTDElement(void) {
45673: int test_ret = 0;
45674:
45675:
45676: /* missing type support */
45677: return(test_ret);
45678: }
45679:
45680:
45681: static int
45682: test_xmlTextWriterWriteVFormatDTDInternalEntity(void) {
45683: int test_ret = 0;
45684:
45685:
45686: /* missing type support */
45687: return(test_ret);
45688: }
45689:
45690:
45691: static int
45692: test_xmlTextWriterWriteVFormatElement(void) {
45693: int test_ret = 0;
45694:
45695:
45696: /* missing type support */
45697: return(test_ret);
45698: }
45699:
45700:
45701: static int
45702: test_xmlTextWriterWriteVFormatElementNS(void) {
45703: int test_ret = 0;
45704:
45705:
45706: /* missing type support */
45707: return(test_ret);
45708: }
45709:
45710:
45711: static int
45712: test_xmlTextWriterWriteVFormatPI(void) {
45713: int test_ret = 0;
45714:
45715:
45716: /* missing type support */
45717: return(test_ret);
45718: }
45719:
45720:
45721: static int
45722: test_xmlTextWriterWriteVFormatRaw(void) {
45723: int test_ret = 0;
45724:
45725:
45726: /* missing type support */
45727: return(test_ret);
45728: }
45729:
45730:
45731: static int
45732: test_xmlTextWriterWriteVFormatString(void) {
45733: int test_ret = 0;
45734:
45735:
45736: /* missing type support */
45737: return(test_ret);
45738: }
45739:
45740: static int
45741: test_xmlwriter(void) {
45742: int test_ret = 0;
45743:
1.1.1.3 ! misho 45744: if (quiet == 0) printf("Testing xmlwriter : 52 of 80 functions ...\n");
1.1 misho 45745: test_ret += test_xmlNewTextWriter();
45746: test_ret += test_xmlNewTextWriterFilename();
45747: test_ret += test_xmlNewTextWriterMemory();
45748: test_ret += test_xmlNewTextWriterPushParser();
45749: test_ret += test_xmlNewTextWriterTree();
45750: test_ret += test_xmlTextWriterEndAttribute();
45751: test_ret += test_xmlTextWriterEndCDATA();
45752: test_ret += test_xmlTextWriterEndComment();
45753: test_ret += test_xmlTextWriterEndDTD();
45754: test_ret += test_xmlTextWriterEndDTDAttlist();
45755: test_ret += test_xmlTextWriterEndDTDElement();
45756: test_ret += test_xmlTextWriterEndDTDEntity();
45757: test_ret += test_xmlTextWriterEndDocument();
45758: test_ret += test_xmlTextWriterEndElement();
45759: test_ret += test_xmlTextWriterEndPI();
45760: test_ret += test_xmlTextWriterFlush();
45761: test_ret += test_xmlTextWriterFullEndElement();
45762: test_ret += test_xmlTextWriterSetIndent();
45763: test_ret += test_xmlTextWriterSetIndentString();
1.1.1.3 ! misho 45764: test_ret += test_xmlTextWriterSetQuoteChar();
1.1 misho 45765: test_ret += test_xmlTextWriterStartAttribute();
45766: test_ret += test_xmlTextWriterStartAttributeNS();
45767: test_ret += test_xmlTextWriterStartCDATA();
45768: test_ret += test_xmlTextWriterStartComment();
45769: test_ret += test_xmlTextWriterStartDTD();
45770: test_ret += test_xmlTextWriterStartDTDAttlist();
45771: test_ret += test_xmlTextWriterStartDTDElement();
45772: test_ret += test_xmlTextWriterStartDTDEntity();
45773: test_ret += test_xmlTextWriterStartDocument();
45774: test_ret += test_xmlTextWriterStartElement();
45775: test_ret += test_xmlTextWriterStartElementNS();
45776: test_ret += test_xmlTextWriterStartPI();
45777: test_ret += test_xmlTextWriterWriteAttribute();
45778: test_ret += test_xmlTextWriterWriteAttributeNS();
45779: test_ret += test_xmlTextWriterWriteBase64();
45780: test_ret += test_xmlTextWriterWriteBinHex();
45781: test_ret += test_xmlTextWriterWriteCDATA();
45782: test_ret += test_xmlTextWriterWriteComment();
45783: test_ret += test_xmlTextWriterWriteDTD();
45784: test_ret += test_xmlTextWriterWriteDTDAttlist();
45785: test_ret += test_xmlTextWriterWriteDTDElement();
45786: test_ret += test_xmlTextWriterWriteDTDEntity();
45787: test_ret += test_xmlTextWriterWriteDTDExternalEntity();
45788: test_ret += test_xmlTextWriterWriteDTDExternalEntityContents();
45789: test_ret += test_xmlTextWriterWriteDTDInternalEntity();
45790: test_ret += test_xmlTextWriterWriteDTDNotation();
45791: test_ret += test_xmlTextWriterWriteElement();
45792: test_ret += test_xmlTextWriterWriteElementNS();
45793: test_ret += test_xmlTextWriterWriteFormatAttribute();
45794: test_ret += test_xmlTextWriterWriteFormatAttributeNS();
45795: test_ret += test_xmlTextWriterWriteFormatCDATA();
45796: test_ret += test_xmlTextWriterWriteFormatComment();
45797: test_ret += test_xmlTextWriterWriteFormatDTD();
45798: test_ret += test_xmlTextWriterWriteFormatDTDAttlist();
45799: test_ret += test_xmlTextWriterWriteFormatDTDElement();
45800: test_ret += test_xmlTextWriterWriteFormatDTDInternalEntity();
45801: test_ret += test_xmlTextWriterWriteFormatElement();
45802: test_ret += test_xmlTextWriterWriteFormatElementNS();
45803: test_ret += test_xmlTextWriterWriteFormatPI();
45804: test_ret += test_xmlTextWriterWriteFormatRaw();
45805: test_ret += test_xmlTextWriterWriteFormatString();
45806: test_ret += test_xmlTextWriterWritePI();
45807: test_ret += test_xmlTextWriterWriteRaw();
45808: test_ret += test_xmlTextWriterWriteRawLen();
45809: test_ret += test_xmlTextWriterWriteString();
45810: test_ret += test_xmlTextWriterWriteVFormatAttribute();
45811: test_ret += test_xmlTextWriterWriteVFormatAttributeNS();
45812: test_ret += test_xmlTextWriterWriteVFormatCDATA();
45813: test_ret += test_xmlTextWriterWriteVFormatComment();
45814: test_ret += test_xmlTextWriterWriteVFormatDTD();
45815: test_ret += test_xmlTextWriterWriteVFormatDTDAttlist();
45816: test_ret += test_xmlTextWriterWriteVFormatDTDElement();
45817: test_ret += test_xmlTextWriterWriteVFormatDTDInternalEntity();
45818: test_ret += test_xmlTextWriterWriteVFormatElement();
45819: test_ret += test_xmlTextWriterWriteVFormatElementNS();
45820: test_ret += test_xmlTextWriterWriteVFormatPI();
45821: test_ret += test_xmlTextWriterWriteVFormatRaw();
45822: test_ret += test_xmlTextWriterWriteVFormatString();
45823:
45824: if (test_ret != 0)
45825: printf("Module xmlwriter: %d errors\n", test_ret);
45826: return(test_ret);
45827: }
45828:
45829: static int
45830: test_xmlXPathCastBooleanToNumber(void) {
45831: int test_ret = 0;
45832:
45833: #if defined(LIBXML_XPATH_ENABLED)
45834: int mem_base;
45835: double ret_val;
45836: int val; /* a boolean */
45837: int n_val;
45838:
45839: for (n_val = 0;n_val < gen_nb_int;n_val++) {
45840: mem_base = xmlMemBlocks();
45841: val = gen_int(n_val, 0);
45842:
45843: ret_val = xmlXPathCastBooleanToNumber(val);
45844: desret_double(ret_val);
45845: call_tests++;
45846: des_int(n_val, val, 0);
45847: xmlResetLastError();
45848: if (mem_base != xmlMemBlocks()) {
45849: printf("Leak of %d blocks found in xmlXPathCastBooleanToNumber",
45850: xmlMemBlocks() - mem_base);
45851: test_ret++;
45852: printf(" %d", n_val);
45853: printf("\n");
45854: }
45855: }
45856: function_tests++;
45857: #endif
45858:
45859: return(test_ret);
45860: }
45861:
45862:
45863: static int
45864: test_xmlXPathCastBooleanToString(void) {
45865: int test_ret = 0;
45866:
45867: #if defined(LIBXML_XPATH_ENABLED)
45868: int mem_base;
45869: xmlChar * ret_val;
45870: int val; /* a boolean */
45871: int n_val;
45872:
45873: for (n_val = 0;n_val < gen_nb_int;n_val++) {
45874: mem_base = xmlMemBlocks();
45875: val = gen_int(n_val, 0);
45876:
45877: ret_val = xmlXPathCastBooleanToString(val);
45878: desret_xmlChar_ptr(ret_val);
45879: call_tests++;
45880: des_int(n_val, val, 0);
45881: xmlResetLastError();
45882: if (mem_base != xmlMemBlocks()) {
45883: printf("Leak of %d blocks found in xmlXPathCastBooleanToString",
45884: xmlMemBlocks() - mem_base);
45885: test_ret++;
45886: printf(" %d", n_val);
45887: printf("\n");
45888: }
45889: }
45890: function_tests++;
45891: #endif
45892:
45893: return(test_ret);
45894: }
45895:
45896:
45897: static int
45898: test_xmlXPathCastNodeSetToBoolean(void) {
45899: int test_ret = 0;
45900:
45901: #if defined(LIBXML_XPATH_ENABLED)
45902: int mem_base;
45903: int ret_val;
45904: xmlNodeSetPtr ns; /* a node-set */
45905: int n_ns;
45906:
45907: for (n_ns = 0;n_ns < gen_nb_xmlNodeSetPtr;n_ns++) {
45908: mem_base = xmlMemBlocks();
45909: ns = gen_xmlNodeSetPtr(n_ns, 0);
45910:
45911: ret_val = xmlXPathCastNodeSetToBoolean(ns);
45912: desret_int(ret_val);
45913: call_tests++;
45914: des_xmlNodeSetPtr(n_ns, ns, 0);
45915: xmlResetLastError();
45916: if (mem_base != xmlMemBlocks()) {
45917: printf("Leak of %d blocks found in xmlXPathCastNodeSetToBoolean",
45918: xmlMemBlocks() - mem_base);
45919: test_ret++;
45920: printf(" %d", n_ns);
45921: printf("\n");
45922: }
45923: }
45924: function_tests++;
45925: #endif
45926:
45927: return(test_ret);
45928: }
45929:
45930:
45931: static int
45932: test_xmlXPathCastNodeSetToNumber(void) {
45933: int test_ret = 0;
45934:
45935: #if defined(LIBXML_XPATH_ENABLED)
45936: int mem_base;
45937: double ret_val;
45938: xmlNodeSetPtr ns; /* a node-set */
45939: int n_ns;
45940:
45941: for (n_ns = 0;n_ns < gen_nb_xmlNodeSetPtr;n_ns++) {
45942: mem_base = xmlMemBlocks();
45943: ns = gen_xmlNodeSetPtr(n_ns, 0);
45944:
45945: ret_val = xmlXPathCastNodeSetToNumber(ns);
45946: desret_double(ret_val);
45947: call_tests++;
45948: des_xmlNodeSetPtr(n_ns, ns, 0);
45949: xmlResetLastError();
45950: if (mem_base != xmlMemBlocks()) {
45951: printf("Leak of %d blocks found in xmlXPathCastNodeSetToNumber",
45952: xmlMemBlocks() - mem_base);
45953: test_ret++;
45954: printf(" %d", n_ns);
45955: printf("\n");
45956: }
45957: }
45958: function_tests++;
45959: #endif
45960:
45961: return(test_ret);
45962: }
45963:
45964:
45965: static int
45966: test_xmlXPathCastNodeSetToString(void) {
45967: int test_ret = 0;
45968:
45969: #if defined(LIBXML_XPATH_ENABLED)
45970: int mem_base;
45971: xmlChar * ret_val;
45972: xmlNodeSetPtr ns; /* a node-set */
45973: int n_ns;
45974:
45975: for (n_ns = 0;n_ns < gen_nb_xmlNodeSetPtr;n_ns++) {
45976: mem_base = xmlMemBlocks();
45977: ns = gen_xmlNodeSetPtr(n_ns, 0);
45978:
45979: ret_val = xmlXPathCastNodeSetToString(ns);
45980: desret_xmlChar_ptr(ret_val);
45981: call_tests++;
45982: des_xmlNodeSetPtr(n_ns, ns, 0);
45983: xmlResetLastError();
45984: if (mem_base != xmlMemBlocks()) {
45985: printf("Leak of %d blocks found in xmlXPathCastNodeSetToString",
45986: xmlMemBlocks() - mem_base);
45987: test_ret++;
45988: printf(" %d", n_ns);
45989: printf("\n");
45990: }
45991: }
45992: function_tests++;
45993: #endif
45994:
45995: return(test_ret);
45996: }
45997:
45998:
45999: static int
46000: test_xmlXPathCastNodeToNumber(void) {
46001: int test_ret = 0;
46002:
46003: #if defined(LIBXML_XPATH_ENABLED)
46004: int mem_base;
46005: double ret_val;
46006: xmlNodePtr node; /* a node */
46007: int n_node;
46008:
46009: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
46010: mem_base = xmlMemBlocks();
46011: node = gen_xmlNodePtr(n_node, 0);
46012:
46013: ret_val = xmlXPathCastNodeToNumber(node);
46014: desret_double(ret_val);
46015: call_tests++;
46016: des_xmlNodePtr(n_node, node, 0);
46017: xmlResetLastError();
46018: if (mem_base != xmlMemBlocks()) {
46019: printf("Leak of %d blocks found in xmlXPathCastNodeToNumber",
46020: xmlMemBlocks() - mem_base);
46021: test_ret++;
46022: printf(" %d", n_node);
46023: printf("\n");
46024: }
46025: }
46026: function_tests++;
46027: #endif
46028:
46029: return(test_ret);
46030: }
46031:
46032:
46033: static int
46034: test_xmlXPathCastNodeToString(void) {
46035: int test_ret = 0;
46036:
46037: #if defined(LIBXML_XPATH_ENABLED)
46038: int mem_base;
46039: xmlChar * ret_val;
46040: xmlNodePtr node; /* a node */
46041: int n_node;
46042:
46043: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
46044: mem_base = xmlMemBlocks();
46045: node = gen_xmlNodePtr(n_node, 0);
46046:
46047: ret_val = xmlXPathCastNodeToString(node);
46048: desret_xmlChar_ptr(ret_val);
46049: call_tests++;
46050: des_xmlNodePtr(n_node, node, 0);
46051: xmlResetLastError();
46052: if (mem_base != xmlMemBlocks()) {
46053: printf("Leak of %d blocks found in xmlXPathCastNodeToString",
46054: xmlMemBlocks() - mem_base);
46055: test_ret++;
46056: printf(" %d", n_node);
46057: printf("\n");
46058: }
46059: }
46060: function_tests++;
46061: #endif
46062:
46063: return(test_ret);
46064: }
46065:
46066:
46067: static int
46068: test_xmlXPathCastNumberToBoolean(void) {
46069: int test_ret = 0;
46070:
46071: #if defined(LIBXML_XPATH_ENABLED)
46072: int mem_base;
46073: int ret_val;
46074: double val; /* a number */
46075: int n_val;
46076:
46077: for (n_val = 0;n_val < gen_nb_double;n_val++) {
46078: mem_base = xmlMemBlocks();
46079: val = gen_double(n_val, 0);
46080:
46081: ret_val = xmlXPathCastNumberToBoolean(val);
46082: desret_int(ret_val);
46083: call_tests++;
46084: des_double(n_val, val, 0);
46085: xmlResetLastError();
46086: if (mem_base != xmlMemBlocks()) {
46087: printf("Leak of %d blocks found in xmlXPathCastNumberToBoolean",
46088: xmlMemBlocks() - mem_base);
46089: test_ret++;
46090: printf(" %d", n_val);
46091: printf("\n");
46092: }
46093: }
46094: function_tests++;
46095: #endif
46096:
46097: return(test_ret);
46098: }
46099:
46100:
46101: static int
46102: test_xmlXPathCastNumberToString(void) {
46103: int test_ret = 0;
46104:
46105: #if defined(LIBXML_XPATH_ENABLED)
46106: int mem_base;
46107: xmlChar * ret_val;
46108: double val; /* a number */
46109: int n_val;
46110:
46111: for (n_val = 0;n_val < gen_nb_double;n_val++) {
46112: mem_base = xmlMemBlocks();
46113: val = gen_double(n_val, 0);
46114:
46115: ret_val = xmlXPathCastNumberToString(val);
46116: desret_xmlChar_ptr(ret_val);
46117: call_tests++;
46118: des_double(n_val, val, 0);
46119: xmlResetLastError();
46120: if (mem_base != xmlMemBlocks()) {
46121: printf("Leak of %d blocks found in xmlXPathCastNumberToString",
46122: xmlMemBlocks() - mem_base);
46123: test_ret++;
46124: printf(" %d", n_val);
46125: printf("\n");
46126: }
46127: }
46128: function_tests++;
46129: #endif
46130:
46131: return(test_ret);
46132: }
46133:
46134:
46135: static int
46136: test_xmlXPathCastStringToBoolean(void) {
46137: int test_ret = 0;
46138:
46139: #if defined(LIBXML_XPATH_ENABLED)
46140: int mem_base;
46141: int ret_val;
46142: xmlChar * val; /* a string */
46143: int n_val;
46144:
46145: for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) {
46146: mem_base = xmlMemBlocks();
46147: val = gen_const_xmlChar_ptr(n_val, 0);
46148:
46149: ret_val = xmlXPathCastStringToBoolean((const xmlChar *)val);
46150: desret_int(ret_val);
46151: call_tests++;
46152: des_const_xmlChar_ptr(n_val, (const xmlChar *)val, 0);
46153: xmlResetLastError();
46154: if (mem_base != xmlMemBlocks()) {
46155: printf("Leak of %d blocks found in xmlXPathCastStringToBoolean",
46156: xmlMemBlocks() - mem_base);
46157: test_ret++;
46158: printf(" %d", n_val);
46159: printf("\n");
46160: }
46161: }
46162: function_tests++;
46163: #endif
46164:
46165: return(test_ret);
46166: }
46167:
46168:
46169: static int
46170: test_xmlXPathCastStringToNumber(void) {
46171: int test_ret = 0;
46172:
46173: #if defined(LIBXML_XPATH_ENABLED)
46174: int mem_base;
46175: double ret_val;
46176: xmlChar * val; /* a string */
46177: int n_val;
46178:
46179: for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) {
46180: mem_base = xmlMemBlocks();
46181: val = gen_const_xmlChar_ptr(n_val, 0);
46182:
46183: ret_val = xmlXPathCastStringToNumber((const xmlChar *)val);
46184: desret_double(ret_val);
46185: call_tests++;
46186: des_const_xmlChar_ptr(n_val, (const xmlChar *)val, 0);
46187: xmlResetLastError();
46188: if (mem_base != xmlMemBlocks()) {
46189: printf("Leak of %d blocks found in xmlXPathCastStringToNumber",
46190: xmlMemBlocks() - mem_base);
46191: test_ret++;
46192: printf(" %d", n_val);
46193: printf("\n");
46194: }
46195: }
46196: function_tests++;
46197: #endif
46198:
46199: return(test_ret);
46200: }
46201:
46202:
46203: static int
46204: test_xmlXPathCastToBoolean(void) {
46205: int test_ret = 0;
46206:
46207: #if defined(LIBXML_XPATH_ENABLED)
46208: int mem_base;
46209: int 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 = xmlXPathCastToBoolean(val);
46218: desret_int(ret_val);
46219: call_tests++;
46220: des_xmlXPathObjectPtr(n_val, val, 0);
46221: xmlResetLastError();
46222: if (mem_base != xmlMemBlocks()) {
46223: printf("Leak of %d blocks found in xmlXPathCastToBoolean",
46224: xmlMemBlocks() - mem_base);
46225: test_ret++;
46226: printf(" %d", n_val);
46227: printf("\n");
46228: }
46229: }
46230: function_tests++;
46231: #endif
46232:
46233: return(test_ret);
46234: }
46235:
46236:
46237: static int
46238: test_xmlXPathCastToNumber(void) {
46239: int test_ret = 0;
46240:
46241: #if defined(LIBXML_XPATH_ENABLED)
46242: int mem_base;
46243: double ret_val;
46244: xmlXPathObjectPtr val; /* an XPath object */
46245: int n_val;
46246:
46247: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
46248: mem_base = xmlMemBlocks();
46249: val = gen_xmlXPathObjectPtr(n_val, 0);
46250:
46251: ret_val = xmlXPathCastToNumber(val);
46252: desret_double(ret_val);
46253: call_tests++;
46254: des_xmlXPathObjectPtr(n_val, val, 0);
46255: xmlResetLastError();
46256: if (mem_base != xmlMemBlocks()) {
46257: printf("Leak of %d blocks found in xmlXPathCastToNumber",
46258: xmlMemBlocks() - mem_base);
46259: test_ret++;
46260: printf(" %d", n_val);
46261: printf("\n");
46262: }
46263: }
46264: function_tests++;
46265: #endif
46266:
46267: return(test_ret);
46268: }
46269:
46270:
46271: static int
46272: test_xmlXPathCastToString(void) {
46273: int test_ret = 0;
46274:
46275: #if defined(LIBXML_XPATH_ENABLED)
46276: int mem_base;
46277: xmlChar * ret_val;
46278: xmlXPathObjectPtr val; /* an XPath object */
46279: int n_val;
46280:
46281: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
46282: mem_base = xmlMemBlocks();
46283: val = gen_xmlXPathObjectPtr(n_val, 0);
46284:
46285: ret_val = xmlXPathCastToString(val);
46286: desret_xmlChar_ptr(ret_val);
46287: call_tests++;
46288: des_xmlXPathObjectPtr(n_val, val, 0);
46289: xmlResetLastError();
46290: if (mem_base != xmlMemBlocks()) {
46291: printf("Leak of %d blocks found in xmlXPathCastToString",
46292: xmlMemBlocks() - mem_base);
46293: test_ret++;
46294: printf(" %d", n_val);
46295: printf("\n");
46296: }
46297: }
46298: function_tests++;
46299: #endif
46300:
46301: return(test_ret);
46302: }
46303:
46304:
46305: static int
46306: test_xmlXPathCmpNodes(void) {
46307: int test_ret = 0;
46308:
46309: #if defined(LIBXML_XPATH_ENABLED)
46310: int mem_base;
46311: int ret_val;
46312: xmlNodePtr node1; /* the first node */
46313: int n_node1;
46314: xmlNodePtr node2; /* the second node */
46315: int n_node2;
46316:
46317: for (n_node1 = 0;n_node1 < gen_nb_xmlNodePtr;n_node1++) {
46318: for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
46319: mem_base = xmlMemBlocks();
46320: node1 = gen_xmlNodePtr(n_node1, 0);
46321: node2 = gen_xmlNodePtr(n_node2, 1);
46322:
46323: ret_val = xmlXPathCmpNodes(node1, node2);
46324: desret_int(ret_val);
46325: call_tests++;
46326: des_xmlNodePtr(n_node1, node1, 0);
46327: des_xmlNodePtr(n_node2, node2, 1);
46328: xmlResetLastError();
46329: if (mem_base != xmlMemBlocks()) {
46330: printf("Leak of %d blocks found in xmlXPathCmpNodes",
46331: xmlMemBlocks() - mem_base);
46332: test_ret++;
46333: printf(" %d", n_node1);
46334: printf(" %d", n_node2);
46335: printf("\n");
46336: }
46337: }
46338: }
46339: function_tests++;
46340: #endif
46341:
46342: return(test_ret);
46343: }
46344:
46345:
46346: static int
46347: test_xmlXPathCompile(void) {
46348: int test_ret = 0;
46349:
46350:
46351: /* missing type support */
46352: return(test_ret);
46353: }
46354:
46355: #ifdef LIBXML_XPATH_ENABLED
46356:
46357: #define gen_nb_xmlXPathCompExprPtr 1
46358: static xmlXPathCompExprPtr gen_xmlXPathCompExprPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
46359: return(NULL);
46360: }
46361: static void des_xmlXPathCompExprPtr(int no ATTRIBUTE_UNUSED, xmlXPathCompExprPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
46362: }
46363: #endif
46364:
46365: #ifdef LIBXML_XPATH_ENABLED
46366:
46367: #define gen_nb_xmlXPathContextPtr 1
46368: static xmlXPathContextPtr gen_xmlXPathContextPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
46369: return(NULL);
46370: }
46371: static void des_xmlXPathContextPtr(int no ATTRIBUTE_UNUSED, xmlXPathContextPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
46372: }
46373: #endif
46374:
46375:
46376: static int
46377: test_xmlXPathCompiledEval(void) {
46378: int test_ret = 0;
46379:
46380: #if defined(LIBXML_XPATH_ENABLED)
46381: int mem_base;
46382: xmlXPathObjectPtr ret_val;
46383: xmlXPathCompExprPtr comp; /* the compiled XPath expression */
46384: int n_comp;
46385: xmlXPathContextPtr ctx; /* the XPath context */
46386: int n_ctx;
46387:
46388: for (n_comp = 0;n_comp < gen_nb_xmlXPathCompExprPtr;n_comp++) {
46389: for (n_ctx = 0;n_ctx < gen_nb_xmlXPathContextPtr;n_ctx++) {
46390: mem_base = xmlMemBlocks();
46391: comp = gen_xmlXPathCompExprPtr(n_comp, 0);
46392: ctx = gen_xmlXPathContextPtr(n_ctx, 1);
46393:
46394: ret_val = xmlXPathCompiledEval(comp, ctx);
46395: desret_xmlXPathObjectPtr(ret_val);
46396: call_tests++;
46397: des_xmlXPathCompExprPtr(n_comp, comp, 0);
46398: des_xmlXPathContextPtr(n_ctx, ctx, 1);
46399: xmlResetLastError();
46400: if (mem_base != xmlMemBlocks()) {
46401: printf("Leak of %d blocks found in xmlXPathCompiledEval",
46402: xmlMemBlocks() - mem_base);
46403: test_ret++;
46404: printf(" %d", n_comp);
46405: printf(" %d", n_ctx);
46406: printf("\n");
46407: }
46408: }
46409: }
46410: function_tests++;
46411: #endif
46412:
46413: return(test_ret);
46414: }
46415:
46416:
46417: static int
46418: test_xmlXPathCompiledEvalToBoolean(void) {
46419: int test_ret = 0;
46420:
46421: #if defined(LIBXML_XPATH_ENABLED)
46422: int mem_base;
46423: int ret_val;
46424: xmlXPathCompExprPtr comp; /* the compiled XPath expression */
46425: int n_comp;
46426: xmlXPathContextPtr ctxt; /* the XPath context */
46427: int n_ctxt;
46428:
46429: for (n_comp = 0;n_comp < gen_nb_xmlXPathCompExprPtr;n_comp++) {
46430: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
46431: mem_base = xmlMemBlocks();
46432: comp = gen_xmlXPathCompExprPtr(n_comp, 0);
46433: ctxt = gen_xmlXPathContextPtr(n_ctxt, 1);
46434:
46435: ret_val = xmlXPathCompiledEvalToBoolean(comp, ctxt);
46436: desret_int(ret_val);
46437: call_tests++;
46438: des_xmlXPathCompExprPtr(n_comp, comp, 0);
46439: des_xmlXPathContextPtr(n_ctxt, ctxt, 1);
46440: xmlResetLastError();
46441: if (mem_base != xmlMemBlocks()) {
46442: printf("Leak of %d blocks found in xmlXPathCompiledEvalToBoolean",
46443: xmlMemBlocks() - mem_base);
46444: test_ret++;
46445: printf(" %d", n_comp);
46446: printf(" %d", n_ctxt);
46447: printf("\n");
46448: }
46449: }
46450: }
46451: function_tests++;
46452: #endif
46453:
46454: return(test_ret);
46455: }
46456:
46457:
46458: static int
46459: test_xmlXPathContextSetCache(void) {
46460: int test_ret = 0;
46461:
46462: #if defined(LIBXML_XPATH_ENABLED)
46463: int mem_base;
46464: int ret_val;
46465: xmlXPathContextPtr ctxt; /* the XPath context */
46466: int n_ctxt;
46467: int active; /* enables/disables (creates/frees) the cache */
46468: int n_active;
46469: int value; /* a value with semantics dependant on @options */
46470: int n_value;
46471: int options; /* options (currently only the value 0 is used) */
46472: int n_options;
46473:
46474: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
46475: for (n_active = 0;n_active < gen_nb_int;n_active++) {
46476: for (n_value = 0;n_value < gen_nb_int;n_value++) {
46477: for (n_options = 0;n_options < gen_nb_int;n_options++) {
46478: mem_base = xmlMemBlocks();
46479: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
46480: active = gen_int(n_active, 1);
46481: value = gen_int(n_value, 2);
46482: options = gen_int(n_options, 3);
46483:
46484: ret_val = xmlXPathContextSetCache(ctxt, active, value, options);
46485: desret_int(ret_val);
46486: call_tests++;
46487: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
46488: des_int(n_active, active, 1);
46489: des_int(n_value, value, 2);
46490: des_int(n_options, options, 3);
46491: xmlResetLastError();
46492: if (mem_base != xmlMemBlocks()) {
46493: printf("Leak of %d blocks found in xmlXPathContextSetCache",
46494: xmlMemBlocks() - mem_base);
46495: test_ret++;
46496: printf(" %d", n_ctxt);
46497: printf(" %d", n_active);
46498: printf(" %d", n_value);
46499: printf(" %d", n_options);
46500: printf("\n");
46501: }
46502: }
46503: }
46504: }
46505: }
46506: function_tests++;
46507: #endif
46508:
46509: return(test_ret);
46510: }
46511:
46512:
46513: static int
46514: test_xmlXPathConvertBoolean(void) {
46515: int test_ret = 0;
46516:
46517: #if defined(LIBXML_XPATH_ENABLED)
46518: int mem_base;
46519: xmlXPathObjectPtr ret_val;
46520: xmlXPathObjectPtr val; /* an XPath object */
46521: int n_val;
46522:
46523: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
46524: mem_base = xmlMemBlocks();
46525: val = gen_xmlXPathObjectPtr(n_val, 0);
46526:
46527: ret_val = xmlXPathConvertBoolean(val);
46528: val = NULL;
46529: desret_xmlXPathObjectPtr(ret_val);
46530: call_tests++;
46531: des_xmlXPathObjectPtr(n_val, val, 0);
46532: xmlResetLastError();
46533: if (mem_base != xmlMemBlocks()) {
46534: printf("Leak of %d blocks found in xmlXPathConvertBoolean",
46535: xmlMemBlocks() - mem_base);
46536: test_ret++;
46537: printf(" %d", n_val);
46538: printf("\n");
46539: }
46540: }
46541: function_tests++;
46542: #endif
46543:
46544: return(test_ret);
46545: }
46546:
46547:
46548: static int
46549: test_xmlXPathConvertNumber(void) {
46550: int test_ret = 0;
46551:
46552: #if defined(LIBXML_XPATH_ENABLED)
46553: int mem_base;
46554: xmlXPathObjectPtr ret_val;
46555: xmlXPathObjectPtr val; /* an XPath object */
46556: int n_val;
46557:
46558: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
46559: mem_base = xmlMemBlocks();
46560: val = gen_xmlXPathObjectPtr(n_val, 0);
46561:
46562: ret_val = xmlXPathConvertNumber(val);
46563: val = NULL;
46564: desret_xmlXPathObjectPtr(ret_val);
46565: call_tests++;
46566: des_xmlXPathObjectPtr(n_val, val, 0);
46567: xmlResetLastError();
46568: if (mem_base != xmlMemBlocks()) {
46569: printf("Leak of %d blocks found in xmlXPathConvertNumber",
46570: xmlMemBlocks() - mem_base);
46571: test_ret++;
46572: printf(" %d", n_val);
46573: printf("\n");
46574: }
46575: }
46576: function_tests++;
46577: #endif
46578:
46579: return(test_ret);
46580: }
46581:
46582:
46583: static int
46584: test_xmlXPathConvertString(void) {
46585: int test_ret = 0;
46586:
46587: #if defined(LIBXML_XPATH_ENABLED)
46588: int mem_base;
46589: xmlXPathObjectPtr ret_val;
46590: xmlXPathObjectPtr val; /* an XPath object */
46591: int n_val;
46592:
46593: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
46594: mem_base = xmlMemBlocks();
46595: val = gen_xmlXPathObjectPtr(n_val, 0);
46596:
46597: ret_val = xmlXPathConvertString(val);
46598: val = NULL;
46599: desret_xmlXPathObjectPtr(ret_val);
46600: call_tests++;
46601: des_xmlXPathObjectPtr(n_val, val, 0);
46602: xmlResetLastError();
46603: if (mem_base != xmlMemBlocks()) {
46604: printf("Leak of %d blocks found in xmlXPathConvertString",
46605: xmlMemBlocks() - mem_base);
46606: test_ret++;
46607: printf(" %d", n_val);
46608: printf("\n");
46609: }
46610: }
46611: function_tests++;
46612: #endif
46613:
46614: return(test_ret);
46615: }
46616:
46617:
46618: static int
46619: test_xmlXPathCtxtCompile(void) {
46620: int test_ret = 0;
46621:
46622:
46623: /* missing type support */
46624: return(test_ret);
46625: }
46626:
46627:
46628: static int
46629: test_xmlXPathEval(void) {
46630: int test_ret = 0;
46631:
46632: #if defined(LIBXML_XPATH_ENABLED)
46633: int mem_base;
46634: xmlXPathObjectPtr ret_val;
46635: xmlChar * str; /* the XPath expression */
46636: int n_str;
46637: xmlXPathContextPtr ctx; /* the XPath context */
46638: int n_ctx;
46639:
46640: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
46641: for (n_ctx = 0;n_ctx < gen_nb_xmlXPathContextPtr;n_ctx++) {
46642: mem_base = xmlMemBlocks();
46643: str = gen_const_xmlChar_ptr(n_str, 0);
46644: ctx = gen_xmlXPathContextPtr(n_ctx, 1);
46645:
46646: ret_val = xmlXPathEval((const xmlChar *)str, ctx);
46647: desret_xmlXPathObjectPtr(ret_val);
46648: call_tests++;
46649: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
46650: des_xmlXPathContextPtr(n_ctx, ctx, 1);
46651: xmlResetLastError();
46652: if (mem_base != xmlMemBlocks()) {
46653: printf("Leak of %d blocks found in xmlXPathEval",
46654: xmlMemBlocks() - mem_base);
46655: test_ret++;
46656: printf(" %d", n_str);
46657: printf(" %d", n_ctx);
46658: printf("\n");
46659: }
46660: }
46661: }
46662: function_tests++;
46663: #endif
46664:
46665: return(test_ret);
46666: }
46667:
46668:
46669: static int
46670: test_xmlXPathEvalExpression(void) {
46671: int test_ret = 0;
46672:
46673: #if defined(LIBXML_XPATH_ENABLED)
46674: int mem_base;
46675: xmlXPathObjectPtr ret_val;
46676: xmlChar * str; /* the XPath expression */
46677: int n_str;
46678: xmlXPathContextPtr ctxt; /* the XPath context */
46679: int n_ctxt;
46680:
46681: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
46682: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
46683: mem_base = xmlMemBlocks();
46684: str = gen_const_xmlChar_ptr(n_str, 0);
46685: ctxt = gen_xmlXPathContextPtr(n_ctxt, 1);
46686:
46687: ret_val = xmlXPathEvalExpression((const xmlChar *)str, ctxt);
46688: desret_xmlXPathObjectPtr(ret_val);
46689: call_tests++;
46690: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
46691: des_xmlXPathContextPtr(n_ctxt, ctxt, 1);
46692: xmlResetLastError();
46693: if (mem_base != xmlMemBlocks()) {
46694: printf("Leak of %d blocks found in xmlXPathEvalExpression",
46695: xmlMemBlocks() - mem_base);
46696: test_ret++;
46697: printf(" %d", n_str);
46698: printf(" %d", n_ctxt);
46699: printf("\n");
46700: }
46701: }
46702: }
46703: function_tests++;
46704: #endif
46705:
46706: return(test_ret);
46707: }
46708:
46709:
46710: static int
46711: test_xmlXPathEvalPredicate(void) {
46712: int test_ret = 0;
46713:
46714: #if defined(LIBXML_XPATH_ENABLED)
46715: int mem_base;
46716: int ret_val;
46717: xmlXPathContextPtr ctxt; /* the XPath context */
46718: int n_ctxt;
46719: xmlXPathObjectPtr res; /* the Predicate Expression evaluation result */
46720: int n_res;
46721:
46722: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
46723: for (n_res = 0;n_res < gen_nb_xmlXPathObjectPtr;n_res++) {
46724: mem_base = xmlMemBlocks();
46725: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
46726: res = gen_xmlXPathObjectPtr(n_res, 1);
46727:
46728: ret_val = xmlXPathEvalPredicate(ctxt, res);
46729: desret_int(ret_val);
46730: call_tests++;
46731: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
46732: des_xmlXPathObjectPtr(n_res, res, 1);
46733: xmlResetLastError();
46734: if (mem_base != xmlMemBlocks()) {
46735: printf("Leak of %d blocks found in xmlXPathEvalPredicate",
46736: xmlMemBlocks() - mem_base);
46737: test_ret++;
46738: printf(" %d", n_ctxt);
46739: printf(" %d", n_res);
46740: printf("\n");
46741: }
46742: }
46743: }
46744: function_tests++;
46745: #endif
46746:
46747: return(test_ret);
46748: }
46749:
46750:
46751: static int
46752: test_xmlXPathInit(void) {
46753: int test_ret = 0;
46754:
46755: #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
46756: int mem_base;
46757:
46758: mem_base = xmlMemBlocks();
46759:
46760: xmlXPathInit();
46761: call_tests++;
46762: xmlResetLastError();
46763: if (mem_base != xmlMemBlocks()) {
46764: printf("Leak of %d blocks found in xmlXPathInit",
46765: xmlMemBlocks() - mem_base);
46766: test_ret++;
46767: printf("\n");
46768: }
46769: function_tests++;
46770: #endif
46771:
46772: return(test_ret);
46773: }
46774:
46775:
46776: static int
46777: test_xmlXPathIsInf(void) {
46778: int test_ret = 0;
46779:
46780: #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
46781: int mem_base;
46782: int ret_val;
46783: double val; /* a double value */
46784: int n_val;
46785:
46786: for (n_val = 0;n_val < gen_nb_double;n_val++) {
46787: mem_base = xmlMemBlocks();
46788: val = gen_double(n_val, 0);
46789:
46790: ret_val = xmlXPathIsInf(val);
46791: desret_int(ret_val);
46792: call_tests++;
46793: des_double(n_val, val, 0);
46794: xmlResetLastError();
46795: if (mem_base != xmlMemBlocks()) {
46796: printf("Leak of %d blocks found in xmlXPathIsInf",
46797: xmlMemBlocks() - mem_base);
46798: test_ret++;
46799: printf(" %d", n_val);
46800: printf("\n");
46801: }
46802: }
46803: function_tests++;
46804: #endif
46805:
46806: return(test_ret);
46807: }
46808:
46809:
46810: static int
46811: test_xmlXPathIsNaN(void) {
46812: int test_ret = 0;
46813:
46814: #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
46815: int mem_base;
46816: int ret_val;
46817: double val; /* a double value */
46818: int n_val;
46819:
46820: for (n_val = 0;n_val < gen_nb_double;n_val++) {
46821: mem_base = xmlMemBlocks();
46822: val = gen_double(n_val, 0);
46823:
46824: ret_val = xmlXPathIsNaN(val);
46825: desret_int(ret_val);
46826: call_tests++;
46827: des_double(n_val, val, 0);
46828: xmlResetLastError();
46829: if (mem_base != xmlMemBlocks()) {
46830: printf("Leak of %d blocks found in xmlXPathIsNaN",
46831: xmlMemBlocks() - mem_base);
46832: test_ret++;
46833: printf(" %d", n_val);
46834: printf("\n");
46835: }
46836: }
46837: function_tests++;
46838: #endif
46839:
46840: return(test_ret);
46841: }
46842:
46843:
46844: static int
46845: test_xmlXPathNewContext(void) {
46846: int test_ret = 0;
46847:
46848:
46849: /* missing type support */
46850: return(test_ret);
46851: }
46852:
46853:
46854: static int
1.1.1.3 ! misho 46855: test_xmlXPathNodeEval(void) {
! 46856: int test_ret = 0;
! 46857:
! 46858: #if defined(LIBXML_XPATH_ENABLED)
! 46859: int mem_base;
! 46860: xmlXPathObjectPtr ret_val;
! 46861: xmlNodePtr node; /* the node to to use as the context node */
! 46862: int n_node;
! 46863: xmlChar * str; /* the XPath expression */
! 46864: int n_str;
! 46865: xmlXPathContextPtr ctx; /* the XPath context */
! 46866: int n_ctx;
! 46867:
! 46868: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 46869: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
! 46870: for (n_ctx = 0;n_ctx < gen_nb_xmlXPathContextPtr;n_ctx++) {
! 46871: mem_base = xmlMemBlocks();
! 46872: node = gen_xmlNodePtr(n_node, 0);
! 46873: str = gen_const_xmlChar_ptr(n_str, 1);
! 46874: ctx = gen_xmlXPathContextPtr(n_ctx, 2);
! 46875:
! 46876: ret_val = xmlXPathNodeEval(node, (const xmlChar *)str, ctx);
! 46877: desret_xmlXPathObjectPtr(ret_val);
! 46878: call_tests++;
! 46879: des_xmlNodePtr(n_node, node, 0);
! 46880: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
! 46881: des_xmlXPathContextPtr(n_ctx, ctx, 2);
! 46882: xmlResetLastError();
! 46883: if (mem_base != xmlMemBlocks()) {
! 46884: printf("Leak of %d blocks found in xmlXPathNodeEval",
! 46885: xmlMemBlocks() - mem_base);
! 46886: test_ret++;
! 46887: printf(" %d", n_node);
! 46888: printf(" %d", n_str);
! 46889: printf(" %d", n_ctx);
! 46890: printf("\n");
! 46891: }
! 46892: }
! 46893: }
! 46894: }
! 46895: function_tests++;
! 46896: #endif
! 46897:
! 46898: return(test_ret);
! 46899: }
! 46900:
! 46901:
! 46902: static int
1.1 misho 46903: test_xmlXPathNodeSetCreate(void) {
46904: int test_ret = 0;
46905:
46906: #if defined(LIBXML_XPATH_ENABLED)
46907: int mem_base;
46908: xmlNodeSetPtr ret_val;
46909: xmlNodePtr val; /* an initial xmlNodePtr, or NULL */
46910: int n_val;
46911:
46912: for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
46913: mem_base = xmlMemBlocks();
46914: val = gen_xmlNodePtr(n_val, 0);
46915:
46916: ret_val = xmlXPathNodeSetCreate(val);
46917: desret_xmlNodeSetPtr(ret_val);
46918: call_tests++;
46919: des_xmlNodePtr(n_val, val, 0);
46920: xmlResetLastError();
46921: if (mem_base != xmlMemBlocks()) {
46922: printf("Leak of %d blocks found in xmlXPathNodeSetCreate",
46923: xmlMemBlocks() - mem_base);
46924: test_ret++;
46925: printf(" %d", n_val);
46926: printf("\n");
46927: }
46928: }
46929: function_tests++;
46930: #endif
46931:
46932: return(test_ret);
46933: }
46934:
46935:
46936: static int
46937: test_xmlXPathObjectCopy(void) {
46938: int test_ret = 0;
46939:
46940: #if defined(LIBXML_XPATH_ENABLED)
46941: int mem_base;
46942: xmlXPathObjectPtr ret_val;
46943: xmlXPathObjectPtr val; /* the original object */
46944: int n_val;
46945:
46946: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
46947: mem_base = xmlMemBlocks();
46948: val = gen_xmlXPathObjectPtr(n_val, 0);
46949:
46950: ret_val = xmlXPathObjectCopy(val);
46951: desret_xmlXPathObjectPtr(ret_val);
46952: call_tests++;
46953: des_xmlXPathObjectPtr(n_val, val, 0);
46954: xmlResetLastError();
46955: if (mem_base != xmlMemBlocks()) {
46956: printf("Leak of %d blocks found in xmlXPathObjectCopy",
46957: xmlMemBlocks() - mem_base);
46958: test_ret++;
46959: printf(" %d", n_val);
46960: printf("\n");
46961: }
46962: }
46963: function_tests++;
46964: #endif
46965:
46966: return(test_ret);
46967: }
46968:
46969:
46970: static int
46971: test_xmlXPathOrderDocElems(void) {
46972: int test_ret = 0;
46973:
46974: #if defined(LIBXML_XPATH_ENABLED)
46975: int mem_base;
46976: long ret_val;
46977: xmlDocPtr doc; /* an input document */
46978: int n_doc;
46979:
46980: for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
46981: mem_base = xmlMemBlocks();
46982: doc = gen_xmlDocPtr(n_doc, 0);
46983:
46984: ret_val = xmlXPathOrderDocElems(doc);
46985: desret_long(ret_val);
46986: call_tests++;
46987: des_xmlDocPtr(n_doc, doc, 0);
46988: xmlResetLastError();
46989: if (mem_base != xmlMemBlocks()) {
46990: printf("Leak of %d blocks found in xmlXPathOrderDocElems",
46991: xmlMemBlocks() - mem_base);
46992: test_ret++;
46993: printf(" %d", n_doc);
46994: printf("\n");
46995: }
46996: }
46997: function_tests++;
46998: #endif
46999:
47000: return(test_ret);
47001: }
47002:
1.1.1.3 ! misho 47003:
! 47004: static int
! 47005: test_xmlXPathSetContextNode(void) {
! 47006: int test_ret = 0;
! 47007:
! 47008: #if defined(LIBXML_XPATH_ENABLED)
! 47009: int mem_base;
! 47010: int ret_val;
! 47011: xmlNodePtr node; /* the node to to use as the context node */
! 47012: int n_node;
! 47013: xmlXPathContextPtr ctx; /* the XPath context */
! 47014: int n_ctx;
! 47015:
! 47016: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
! 47017: for (n_ctx = 0;n_ctx < gen_nb_xmlXPathContextPtr;n_ctx++) {
! 47018: mem_base = xmlMemBlocks();
! 47019: node = gen_xmlNodePtr(n_node, 0);
! 47020: ctx = gen_xmlXPathContextPtr(n_ctx, 1);
! 47021:
! 47022: ret_val = xmlXPathSetContextNode(node, ctx);
! 47023: desret_int(ret_val);
! 47024: call_tests++;
! 47025: des_xmlNodePtr(n_node, node, 0);
! 47026: des_xmlXPathContextPtr(n_ctx, ctx, 1);
! 47027: xmlResetLastError();
! 47028: if (mem_base != xmlMemBlocks()) {
! 47029: printf("Leak of %d blocks found in xmlXPathSetContextNode",
! 47030: xmlMemBlocks() - mem_base);
! 47031: test_ret++;
! 47032: printf(" %d", n_node);
! 47033: printf(" %d", n_ctx);
! 47034: printf("\n");
! 47035: }
! 47036: }
! 47037: }
! 47038: function_tests++;
! 47039: #endif
! 47040:
! 47041: return(test_ret);
! 47042: }
! 47043:
1.1 misho 47044: static int
47045: test_xpath(void) {
47046: int test_ret = 0;
47047:
1.1.1.3 ! misho 47048: if (quiet == 0) printf("Testing xpath : 32 of 40 functions ...\n");
1.1 misho 47049: test_ret += test_xmlXPathCastBooleanToNumber();
47050: test_ret += test_xmlXPathCastBooleanToString();
47051: test_ret += test_xmlXPathCastNodeSetToBoolean();
47052: test_ret += test_xmlXPathCastNodeSetToNumber();
47053: test_ret += test_xmlXPathCastNodeSetToString();
47054: test_ret += test_xmlXPathCastNodeToNumber();
47055: test_ret += test_xmlXPathCastNodeToString();
47056: test_ret += test_xmlXPathCastNumberToBoolean();
47057: test_ret += test_xmlXPathCastNumberToString();
47058: test_ret += test_xmlXPathCastStringToBoolean();
47059: test_ret += test_xmlXPathCastStringToNumber();
47060: test_ret += test_xmlXPathCastToBoolean();
47061: test_ret += test_xmlXPathCastToNumber();
47062: test_ret += test_xmlXPathCastToString();
47063: test_ret += test_xmlXPathCmpNodes();
47064: test_ret += test_xmlXPathCompile();
47065: test_ret += test_xmlXPathCompiledEval();
47066: test_ret += test_xmlXPathCompiledEvalToBoolean();
47067: test_ret += test_xmlXPathContextSetCache();
47068: test_ret += test_xmlXPathConvertBoolean();
47069: test_ret += test_xmlXPathConvertNumber();
47070: test_ret += test_xmlXPathConvertString();
47071: test_ret += test_xmlXPathCtxtCompile();
47072: test_ret += test_xmlXPathEval();
47073: test_ret += test_xmlXPathEvalExpression();
47074: test_ret += test_xmlXPathEvalPredicate();
47075: test_ret += test_xmlXPathInit();
47076: test_ret += test_xmlXPathIsInf();
47077: test_ret += test_xmlXPathIsNaN();
47078: test_ret += test_xmlXPathNewContext();
1.1.1.3 ! misho 47079: test_ret += test_xmlXPathNodeEval();
1.1 misho 47080: test_ret += test_xmlXPathNodeSetCreate();
47081: test_ret += test_xmlXPathObjectCopy();
47082: test_ret += test_xmlXPathOrderDocElems();
1.1.1.3 ! misho 47083: test_ret += test_xmlXPathSetContextNode();
1.1 misho 47084:
47085: if (test_ret != 0)
47086: printf("Module xpath: %d errors\n", test_ret);
47087: return(test_ret);
47088: }
47089: #ifdef LIBXML_XPATH_ENABLED
47090:
47091: #define gen_nb_xmlXPathParserContextPtr 1
47092: static xmlXPathParserContextPtr gen_xmlXPathParserContextPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
47093: return(NULL);
47094: }
47095: static void des_xmlXPathParserContextPtr(int no ATTRIBUTE_UNUSED, xmlXPathParserContextPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
47096: }
47097: #endif
47098:
47099:
47100: static int
47101: test_valuePop(void) {
47102: int test_ret = 0;
47103:
47104: #if defined(LIBXML_XPATH_ENABLED)
47105: int mem_base;
47106: xmlXPathObjectPtr ret_val;
47107: xmlXPathParserContextPtr ctxt; /* an XPath evaluation context */
47108: int n_ctxt;
47109:
47110: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47111: mem_base = xmlMemBlocks();
47112: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47113:
47114: ret_val = valuePop(ctxt);
47115: desret_xmlXPathObjectPtr(ret_val);
47116: call_tests++;
47117: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47118: xmlResetLastError();
47119: if (mem_base != xmlMemBlocks()) {
47120: printf("Leak of %d blocks found in valuePop",
47121: xmlMemBlocks() - mem_base);
47122: test_ret++;
47123: printf(" %d", n_ctxt);
47124: printf("\n");
47125: }
47126: }
47127: function_tests++;
47128: #endif
47129:
47130: return(test_ret);
47131: }
47132:
47133:
47134: static int
47135: test_valuePush(void) {
47136: int test_ret = 0;
47137:
47138: #if defined(LIBXML_XPATH_ENABLED)
47139: int mem_base;
47140: int ret_val;
47141: xmlXPathParserContextPtr ctxt; /* an XPath evaluation context */
47142: int n_ctxt;
47143: xmlXPathObjectPtr value; /* the XPath object */
47144: int n_value;
47145:
47146: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47147: for (n_value = 0;n_value < gen_nb_xmlXPathObjectPtr;n_value++) {
47148: mem_base = xmlMemBlocks();
47149: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47150: value = gen_xmlXPathObjectPtr(n_value, 1);
47151:
47152: ret_val = valuePush(ctxt, value);
47153: desret_int(ret_val);
47154: call_tests++;
47155: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47156: des_xmlXPathObjectPtr(n_value, value, 1);
47157: xmlResetLastError();
47158: if (mem_base != xmlMemBlocks()) {
47159: printf("Leak of %d blocks found in valuePush",
47160: xmlMemBlocks() - mem_base);
47161: test_ret++;
47162: printf(" %d", n_ctxt);
47163: printf(" %d", n_value);
47164: printf("\n");
47165: }
47166: }
47167: }
47168: function_tests++;
47169: #endif
47170:
47171: return(test_ret);
47172: }
47173:
47174:
47175: static int
47176: test_xmlXPathAddValues(void) {
47177: int test_ret = 0;
47178:
47179: #if defined(LIBXML_XPATH_ENABLED)
47180: int mem_base;
47181: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47182: int n_ctxt;
47183:
47184: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47185: mem_base = xmlMemBlocks();
47186: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47187:
47188: xmlXPathAddValues(ctxt);
47189: call_tests++;
47190: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47191: xmlResetLastError();
47192: if (mem_base != xmlMemBlocks()) {
47193: printf("Leak of %d blocks found in xmlXPathAddValues",
47194: xmlMemBlocks() - mem_base);
47195: test_ret++;
47196: printf(" %d", n_ctxt);
47197: printf("\n");
47198: }
47199: }
47200: function_tests++;
47201: #endif
47202:
47203: return(test_ret);
47204: }
47205:
47206:
47207: static int
47208: test_xmlXPathBooleanFunction(void) {
47209: int test_ret = 0;
47210:
47211: #if defined(LIBXML_XPATH_ENABLED)
47212: int mem_base;
47213: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47214: int n_ctxt;
47215: int nargs; /* the number of arguments */
47216: int n_nargs;
47217:
47218: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47219: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
47220: mem_base = xmlMemBlocks();
47221: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47222: nargs = gen_int(n_nargs, 1);
47223:
47224: xmlXPathBooleanFunction(ctxt, nargs);
47225: call_tests++;
47226: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47227: des_int(n_nargs, nargs, 1);
47228: xmlResetLastError();
47229: if (mem_base != xmlMemBlocks()) {
47230: printf("Leak of %d blocks found in xmlXPathBooleanFunction",
47231: xmlMemBlocks() - mem_base);
47232: test_ret++;
47233: printf(" %d", n_ctxt);
47234: printf(" %d", n_nargs);
47235: printf("\n");
47236: }
47237: }
47238: }
47239: function_tests++;
47240: #endif
47241:
47242: return(test_ret);
47243: }
47244:
47245:
47246: static int
47247: test_xmlXPathCeilingFunction(void) {
47248: int test_ret = 0;
47249:
47250: #if defined(LIBXML_XPATH_ENABLED)
47251: int mem_base;
47252: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47253: int n_ctxt;
47254: int nargs; /* the number of arguments */
47255: int n_nargs;
47256:
47257: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47258: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
47259: mem_base = xmlMemBlocks();
47260: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47261: nargs = gen_int(n_nargs, 1);
47262:
47263: xmlXPathCeilingFunction(ctxt, nargs);
47264: call_tests++;
47265: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47266: des_int(n_nargs, nargs, 1);
47267: xmlResetLastError();
47268: if (mem_base != xmlMemBlocks()) {
47269: printf("Leak of %d blocks found in xmlXPathCeilingFunction",
47270: xmlMemBlocks() - mem_base);
47271: test_ret++;
47272: printf(" %d", n_ctxt);
47273: printf(" %d", n_nargs);
47274: printf("\n");
47275: }
47276: }
47277: }
47278: function_tests++;
47279: #endif
47280:
47281: return(test_ret);
47282: }
47283:
47284:
47285: static int
47286: test_xmlXPathCompareValues(void) {
47287: int test_ret = 0;
47288:
47289: #if defined(LIBXML_XPATH_ENABLED)
47290: int mem_base;
47291: int ret_val;
47292: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47293: int n_ctxt;
47294: int inf; /* less than (1) or greater than (0) */
47295: int n_inf;
47296: int strict; /* is the comparison strict */
47297: int n_strict;
47298:
47299: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47300: for (n_inf = 0;n_inf < gen_nb_int;n_inf++) {
47301: for (n_strict = 0;n_strict < gen_nb_int;n_strict++) {
47302: mem_base = xmlMemBlocks();
47303: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47304: inf = gen_int(n_inf, 1);
47305: strict = gen_int(n_strict, 2);
47306:
47307: ret_val = xmlXPathCompareValues(ctxt, inf, strict);
47308: desret_int(ret_val);
47309: call_tests++;
47310: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47311: des_int(n_inf, inf, 1);
47312: des_int(n_strict, strict, 2);
47313: xmlResetLastError();
47314: if (mem_base != xmlMemBlocks()) {
47315: printf("Leak of %d blocks found in xmlXPathCompareValues",
47316: xmlMemBlocks() - mem_base);
47317: test_ret++;
47318: printf(" %d", n_ctxt);
47319: printf(" %d", n_inf);
47320: printf(" %d", n_strict);
47321: printf("\n");
47322: }
47323: }
47324: }
47325: }
47326: function_tests++;
47327: #endif
47328:
47329: return(test_ret);
47330: }
47331:
47332:
47333: static int
47334: test_xmlXPathConcatFunction(void) {
47335: int test_ret = 0;
47336:
47337: #if defined(LIBXML_XPATH_ENABLED)
47338: int mem_base;
47339: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47340: int n_ctxt;
47341: int nargs; /* the number of arguments */
47342: int n_nargs;
47343:
47344: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47345: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
47346: mem_base = xmlMemBlocks();
47347: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47348: nargs = gen_int(n_nargs, 1);
47349:
47350: xmlXPathConcatFunction(ctxt, nargs);
47351: call_tests++;
47352: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47353: des_int(n_nargs, nargs, 1);
47354: xmlResetLastError();
47355: if (mem_base != xmlMemBlocks()) {
47356: printf("Leak of %d blocks found in xmlXPathConcatFunction",
47357: xmlMemBlocks() - mem_base);
47358: test_ret++;
47359: printf(" %d", n_ctxt);
47360: printf(" %d", n_nargs);
47361: printf("\n");
47362: }
47363: }
47364: }
47365: function_tests++;
47366: #endif
47367:
47368: return(test_ret);
47369: }
47370:
47371:
47372: static int
47373: test_xmlXPathContainsFunction(void) {
47374: int test_ret = 0;
47375:
47376: #if defined(LIBXML_XPATH_ENABLED)
47377: int mem_base;
47378: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47379: int n_ctxt;
47380: int nargs; /* the number of arguments */
47381: int n_nargs;
47382:
47383: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47384: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
47385: mem_base = xmlMemBlocks();
47386: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47387: nargs = gen_int(n_nargs, 1);
47388:
47389: xmlXPathContainsFunction(ctxt, nargs);
47390: call_tests++;
47391: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47392: des_int(n_nargs, nargs, 1);
47393: xmlResetLastError();
47394: if (mem_base != xmlMemBlocks()) {
47395: printf("Leak of %d blocks found in xmlXPathContainsFunction",
47396: xmlMemBlocks() - mem_base);
47397: test_ret++;
47398: printf(" %d", n_ctxt);
47399: printf(" %d", n_nargs);
47400: printf("\n");
47401: }
47402: }
47403: }
47404: function_tests++;
47405: #endif
47406:
47407: return(test_ret);
47408: }
47409:
47410:
47411: static int
47412: test_xmlXPathCountFunction(void) {
47413: int test_ret = 0;
47414:
47415: #if defined(LIBXML_XPATH_ENABLED)
47416: int mem_base;
47417: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47418: int n_ctxt;
47419: int nargs; /* the number of arguments */
47420: int n_nargs;
47421:
47422: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47423: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
47424: mem_base = xmlMemBlocks();
47425: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47426: nargs = gen_int(n_nargs, 1);
47427:
47428: xmlXPathCountFunction(ctxt, nargs);
47429: call_tests++;
47430: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47431: des_int(n_nargs, nargs, 1);
47432: xmlResetLastError();
47433: if (mem_base != xmlMemBlocks()) {
47434: printf("Leak of %d blocks found in xmlXPathCountFunction",
47435: xmlMemBlocks() - mem_base);
47436: test_ret++;
47437: printf(" %d", n_ctxt);
47438: printf(" %d", n_nargs);
47439: printf("\n");
47440: }
47441: }
47442: }
47443: function_tests++;
47444: #endif
47445:
47446: return(test_ret);
47447: }
47448:
47449:
47450: static int
47451: test_xmlXPathDebugDumpCompExpr(void) {
47452: int test_ret = 0;
47453:
47454: #if defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_DEBUG_ENABLED)
47455: int mem_base;
47456: FILE * output; /* the FILE * for the output */
47457: int n_output;
47458: xmlXPathCompExprPtr comp; /* the precompiled XPath expression */
47459: int n_comp;
47460: int depth; /* the indentation level. */
47461: int n_depth;
47462:
47463: for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
47464: for (n_comp = 0;n_comp < gen_nb_xmlXPathCompExprPtr;n_comp++) {
47465: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
47466: mem_base = xmlMemBlocks();
47467: output = gen_FILE_ptr(n_output, 0);
47468: comp = gen_xmlXPathCompExprPtr(n_comp, 1);
47469: depth = gen_int(n_depth, 2);
47470:
47471: xmlXPathDebugDumpCompExpr(output, comp, depth);
47472: call_tests++;
47473: des_FILE_ptr(n_output, output, 0);
47474: des_xmlXPathCompExprPtr(n_comp, comp, 1);
47475: des_int(n_depth, depth, 2);
47476: xmlResetLastError();
47477: if (mem_base != xmlMemBlocks()) {
47478: printf("Leak of %d blocks found in xmlXPathDebugDumpCompExpr",
47479: xmlMemBlocks() - mem_base);
47480: test_ret++;
47481: printf(" %d", n_output);
47482: printf(" %d", n_comp);
47483: printf(" %d", n_depth);
47484: printf("\n");
47485: }
47486: }
47487: }
47488: }
47489: function_tests++;
47490: #endif
47491:
47492: return(test_ret);
47493: }
47494:
47495:
47496: static int
47497: test_xmlXPathDebugDumpObject(void) {
47498: int test_ret = 0;
47499:
47500: #if defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_DEBUG_ENABLED)
47501: int mem_base;
47502: FILE * output; /* the FILE * to dump the output */
47503: int n_output;
47504: xmlXPathObjectPtr cur; /* the object to inspect */
47505: int n_cur;
47506: int depth; /* indentation level */
47507: int n_depth;
47508:
47509: for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
47510: for (n_cur = 0;n_cur < gen_nb_xmlXPathObjectPtr;n_cur++) {
47511: for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
47512: mem_base = xmlMemBlocks();
47513: output = gen_FILE_ptr(n_output, 0);
47514: cur = gen_xmlXPathObjectPtr(n_cur, 1);
47515: depth = gen_int(n_depth, 2);
47516:
47517: xmlXPathDebugDumpObject(output, cur, depth);
47518: call_tests++;
47519: des_FILE_ptr(n_output, output, 0);
47520: des_xmlXPathObjectPtr(n_cur, cur, 1);
47521: des_int(n_depth, depth, 2);
47522: xmlResetLastError();
47523: if (mem_base != xmlMemBlocks()) {
47524: printf("Leak of %d blocks found in xmlXPathDebugDumpObject",
47525: xmlMemBlocks() - mem_base);
47526: test_ret++;
47527: printf(" %d", n_output);
47528: printf(" %d", n_cur);
47529: printf(" %d", n_depth);
47530: printf("\n");
47531: }
47532: }
47533: }
47534: }
47535: function_tests++;
47536: #endif
47537:
47538: return(test_ret);
47539: }
47540:
47541:
47542: static int
47543: test_xmlXPathDifference(void) {
47544: int test_ret = 0;
47545:
47546: #if defined(LIBXML_XPATH_ENABLED)
47547: int mem_base;
47548: xmlNodeSetPtr ret_val;
47549: xmlNodeSetPtr nodes1; /* a node-set */
47550: int n_nodes1;
47551: xmlNodeSetPtr nodes2; /* a node-set */
47552: int n_nodes2;
47553:
47554: for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
47555: for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
47556: mem_base = xmlMemBlocks();
47557: nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
47558: nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
47559:
47560: ret_val = xmlXPathDifference(nodes1, nodes2);
47561: desret_xmlNodeSetPtr(ret_val);
47562: call_tests++;
47563: des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
47564: des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
47565: xmlResetLastError();
47566: if (mem_base != xmlMemBlocks()) {
47567: printf("Leak of %d blocks found in xmlXPathDifference",
47568: xmlMemBlocks() - mem_base);
47569: test_ret++;
47570: printf(" %d", n_nodes1);
47571: printf(" %d", n_nodes2);
47572: printf("\n");
47573: }
47574: }
47575: }
47576: function_tests++;
47577: #endif
47578:
47579: return(test_ret);
47580: }
47581:
47582:
47583: static int
47584: test_xmlXPathDistinct(void) {
47585: int test_ret = 0;
47586:
47587: #if defined(LIBXML_XPATH_ENABLED)
47588: int mem_base;
47589: xmlNodeSetPtr ret_val;
47590: xmlNodeSetPtr nodes; /* a node-set */
47591: int n_nodes;
47592:
47593: for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
47594: mem_base = xmlMemBlocks();
47595: nodes = gen_xmlNodeSetPtr(n_nodes, 0);
47596:
47597: ret_val = xmlXPathDistinct(nodes);
47598: desret_xmlNodeSetPtr(ret_val);
47599: call_tests++;
47600: des_xmlNodeSetPtr(n_nodes, nodes, 0);
47601: xmlResetLastError();
47602: if (mem_base != xmlMemBlocks()) {
47603: printf("Leak of %d blocks found in xmlXPathDistinct",
47604: xmlMemBlocks() - mem_base);
47605: test_ret++;
47606: printf(" %d", n_nodes);
47607: printf("\n");
47608: }
47609: }
47610: function_tests++;
47611: #endif
47612:
47613: return(test_ret);
47614: }
47615:
47616:
47617: static int
47618: test_xmlXPathDistinctSorted(void) {
47619: int test_ret = 0;
47620:
47621: #if defined(LIBXML_XPATH_ENABLED)
47622: int mem_base;
47623: xmlNodeSetPtr ret_val;
47624: xmlNodeSetPtr nodes; /* a node-set, sorted by document order */
47625: int n_nodes;
47626:
47627: for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
47628: mem_base = xmlMemBlocks();
47629: nodes = gen_xmlNodeSetPtr(n_nodes, 0);
47630:
47631: ret_val = xmlXPathDistinctSorted(nodes);
47632: desret_xmlNodeSetPtr(ret_val);
47633: call_tests++;
47634: des_xmlNodeSetPtr(n_nodes, nodes, 0);
47635: xmlResetLastError();
47636: if (mem_base != xmlMemBlocks()) {
47637: printf("Leak of %d blocks found in xmlXPathDistinctSorted",
47638: xmlMemBlocks() - mem_base);
47639: test_ret++;
47640: printf(" %d", n_nodes);
47641: printf("\n");
47642: }
47643: }
47644: function_tests++;
47645: #endif
47646:
47647: return(test_ret);
47648: }
47649:
47650:
47651: static int
47652: test_xmlXPathDivValues(void) {
47653: int test_ret = 0;
47654:
47655: #if defined(LIBXML_XPATH_ENABLED)
47656: int mem_base;
47657: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47658: int n_ctxt;
47659:
47660: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47661: mem_base = xmlMemBlocks();
47662: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47663:
47664: xmlXPathDivValues(ctxt);
47665: call_tests++;
47666: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47667: xmlResetLastError();
47668: if (mem_base != xmlMemBlocks()) {
47669: printf("Leak of %d blocks found in xmlXPathDivValues",
47670: xmlMemBlocks() - mem_base);
47671: test_ret++;
47672: printf(" %d", n_ctxt);
47673: printf("\n");
47674: }
47675: }
47676: function_tests++;
47677: #endif
47678:
47679: return(test_ret);
47680: }
47681:
47682:
47683: static int
47684: test_xmlXPathEqualValues(void) {
47685: int test_ret = 0;
47686:
47687: #if defined(LIBXML_XPATH_ENABLED)
47688: int mem_base;
47689: int ret_val;
47690: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47691: int n_ctxt;
47692:
47693: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47694: mem_base = xmlMemBlocks();
47695: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47696:
47697: ret_val = xmlXPathEqualValues(ctxt);
47698: desret_int(ret_val);
47699: call_tests++;
47700: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47701: xmlResetLastError();
47702: if (mem_base != xmlMemBlocks()) {
47703: printf("Leak of %d blocks found in xmlXPathEqualValues",
47704: xmlMemBlocks() - mem_base);
47705: test_ret++;
47706: printf(" %d", n_ctxt);
47707: printf("\n");
47708: }
47709: }
47710: function_tests++;
47711: #endif
47712:
47713: return(test_ret);
47714: }
47715:
47716:
47717: static int
47718: test_xmlXPathErr(void) {
47719: int test_ret = 0;
47720:
47721: #if defined(LIBXML_XPATH_ENABLED)
47722: int mem_base;
47723: xmlXPathParserContextPtr ctxt; /* a XPath parser context */
47724: int n_ctxt;
47725: int error; /* the error code */
47726: int n_error;
47727:
47728: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47729: for (n_error = 0;n_error < gen_nb_int;n_error++) {
47730: mem_base = xmlMemBlocks();
47731: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47732: error = gen_int(n_error, 1);
47733:
47734: xmlXPathErr(ctxt, error);
47735: call_tests++;
47736: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47737: des_int(n_error, error, 1);
47738: xmlResetLastError();
47739: if (mem_base != xmlMemBlocks()) {
47740: printf("Leak of %d blocks found in xmlXPathErr",
47741: xmlMemBlocks() - mem_base);
47742: test_ret++;
47743: printf(" %d", n_ctxt);
47744: printf(" %d", n_error);
47745: printf("\n");
47746: }
47747: }
47748: }
47749: function_tests++;
47750: #endif
47751:
47752: return(test_ret);
47753: }
47754:
47755:
47756: static int
47757: test_xmlXPathEvalExpr(void) {
47758: int test_ret = 0;
47759:
47760: #if defined(LIBXML_XPATH_ENABLED)
47761: int mem_base;
47762: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47763: int n_ctxt;
47764:
47765: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47766: mem_base = xmlMemBlocks();
47767: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47768:
47769: xmlXPathEvalExpr(ctxt);
47770: call_tests++;
47771: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47772: xmlResetLastError();
47773: if (mem_base != xmlMemBlocks()) {
47774: printf("Leak of %d blocks found in xmlXPathEvalExpr",
47775: xmlMemBlocks() - mem_base);
47776: test_ret++;
47777: printf(" %d", n_ctxt);
47778: printf("\n");
47779: }
47780: }
47781: function_tests++;
47782: #endif
47783:
47784: return(test_ret);
47785: }
47786:
47787:
47788: static int
47789: test_xmlXPathEvaluatePredicateResult(void) {
47790: int test_ret = 0;
47791:
47792: #if defined(LIBXML_XPATH_ENABLED)
47793: int mem_base;
47794: int ret_val;
47795: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47796: int n_ctxt;
47797: xmlXPathObjectPtr res; /* the Predicate Expression evaluation result */
47798: int n_res;
47799:
47800: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47801: for (n_res = 0;n_res < gen_nb_xmlXPathObjectPtr;n_res++) {
47802: mem_base = xmlMemBlocks();
47803: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47804: res = gen_xmlXPathObjectPtr(n_res, 1);
47805:
47806: ret_val = xmlXPathEvaluatePredicateResult(ctxt, res);
47807: desret_int(ret_val);
47808: call_tests++;
47809: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47810: des_xmlXPathObjectPtr(n_res, res, 1);
47811: xmlResetLastError();
47812: if (mem_base != xmlMemBlocks()) {
47813: printf("Leak of %d blocks found in xmlXPathEvaluatePredicateResult",
47814: xmlMemBlocks() - mem_base);
47815: test_ret++;
47816: printf(" %d", n_ctxt);
47817: printf(" %d", n_res);
47818: printf("\n");
47819: }
47820: }
47821: }
47822: function_tests++;
47823: #endif
47824:
47825: return(test_ret);
47826: }
47827:
47828:
47829: static int
47830: test_xmlXPathFalseFunction(void) {
47831: int test_ret = 0;
47832:
47833: #if defined(LIBXML_XPATH_ENABLED)
47834: int mem_base;
47835: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47836: int n_ctxt;
47837: int nargs; /* the number of arguments */
47838: int n_nargs;
47839:
47840: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47841: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
47842: mem_base = xmlMemBlocks();
47843: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47844: nargs = gen_int(n_nargs, 1);
47845:
47846: xmlXPathFalseFunction(ctxt, nargs);
47847: call_tests++;
47848: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47849: des_int(n_nargs, nargs, 1);
47850: xmlResetLastError();
47851: if (mem_base != xmlMemBlocks()) {
47852: printf("Leak of %d blocks found in xmlXPathFalseFunction",
47853: xmlMemBlocks() - mem_base);
47854: test_ret++;
47855: printf(" %d", n_ctxt);
47856: printf(" %d", n_nargs);
47857: printf("\n");
47858: }
47859: }
47860: }
47861: function_tests++;
47862: #endif
47863:
47864: return(test_ret);
47865: }
47866:
47867:
47868: static int
47869: test_xmlXPathFloorFunction(void) {
47870: int test_ret = 0;
47871:
47872: #if defined(LIBXML_XPATH_ENABLED)
47873: int mem_base;
47874: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47875: int n_ctxt;
47876: int nargs; /* the number of arguments */
47877: int n_nargs;
47878:
47879: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47880: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
47881: mem_base = xmlMemBlocks();
47882: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47883: nargs = gen_int(n_nargs, 1);
47884:
47885: xmlXPathFloorFunction(ctxt, nargs);
47886: call_tests++;
47887: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47888: des_int(n_nargs, nargs, 1);
47889: xmlResetLastError();
47890: if (mem_base != xmlMemBlocks()) {
47891: printf("Leak of %d blocks found in xmlXPathFloorFunction",
47892: xmlMemBlocks() - mem_base);
47893: test_ret++;
47894: printf(" %d", n_ctxt);
47895: printf(" %d", n_nargs);
47896: printf("\n");
47897: }
47898: }
47899: }
47900: function_tests++;
47901: #endif
47902:
47903: return(test_ret);
47904: }
47905:
47906:
47907: static int
47908: test_xmlXPathFunctionLookup(void) {
47909: int test_ret = 0;
47910:
47911:
47912: /* missing type support */
47913: return(test_ret);
47914: }
47915:
47916:
47917: static int
47918: test_xmlXPathFunctionLookupNS(void) {
47919: int test_ret = 0;
47920:
47921:
47922: /* missing type support */
47923: return(test_ret);
47924: }
47925:
47926:
47927: static int
47928: test_xmlXPathHasSameNodes(void) {
47929: int test_ret = 0;
47930:
47931: #if defined(LIBXML_XPATH_ENABLED)
47932: int mem_base;
47933: int ret_val;
47934: xmlNodeSetPtr nodes1; /* a node-set */
47935: int n_nodes1;
47936: xmlNodeSetPtr nodes2; /* a node-set */
47937: int n_nodes2;
47938:
47939: for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
47940: for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
47941: mem_base = xmlMemBlocks();
47942: nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
47943: nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
47944:
47945: ret_val = xmlXPathHasSameNodes(nodes1, nodes2);
47946: desret_int(ret_val);
47947: call_tests++;
47948: des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
47949: des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
47950: xmlResetLastError();
47951: if (mem_base != xmlMemBlocks()) {
47952: printf("Leak of %d blocks found in xmlXPathHasSameNodes",
47953: xmlMemBlocks() - mem_base);
47954: test_ret++;
47955: printf(" %d", n_nodes1);
47956: printf(" %d", n_nodes2);
47957: printf("\n");
47958: }
47959: }
47960: }
47961: function_tests++;
47962: #endif
47963:
47964: return(test_ret);
47965: }
47966:
47967:
47968: static int
47969: test_xmlXPathIdFunction(void) {
47970: int test_ret = 0;
47971:
47972: #if defined(LIBXML_XPATH_ENABLED)
47973: int mem_base;
47974: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47975: int n_ctxt;
47976: int nargs; /* the number of arguments */
47977: int n_nargs;
47978:
47979: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47980: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
47981: mem_base = xmlMemBlocks();
47982: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47983: nargs = gen_int(n_nargs, 1);
47984:
47985: xmlXPathIdFunction(ctxt, nargs);
47986: call_tests++;
47987: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47988: des_int(n_nargs, nargs, 1);
47989: xmlResetLastError();
47990: if (mem_base != xmlMemBlocks()) {
47991: printf("Leak of %d blocks found in xmlXPathIdFunction",
47992: xmlMemBlocks() - mem_base);
47993: test_ret++;
47994: printf(" %d", n_ctxt);
47995: printf(" %d", n_nargs);
47996: printf("\n");
47997: }
47998: }
47999: }
48000: function_tests++;
48001: #endif
48002:
48003: return(test_ret);
48004: }
48005:
48006:
48007: static int
48008: test_xmlXPathIntersection(void) {
48009: int test_ret = 0;
48010:
48011: #if defined(LIBXML_XPATH_ENABLED)
48012: int mem_base;
48013: xmlNodeSetPtr ret_val;
48014: xmlNodeSetPtr nodes1; /* a node-set */
48015: int n_nodes1;
48016: xmlNodeSetPtr nodes2; /* a node-set */
48017: int n_nodes2;
48018:
48019: for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
48020: for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
48021: mem_base = xmlMemBlocks();
48022: nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
48023: nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
48024:
48025: ret_val = xmlXPathIntersection(nodes1, nodes2);
48026: desret_xmlNodeSetPtr(ret_val);
48027: call_tests++;
48028: des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
48029: des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
48030: xmlResetLastError();
48031: if (mem_base != xmlMemBlocks()) {
48032: printf("Leak of %d blocks found in xmlXPathIntersection",
48033: xmlMemBlocks() - mem_base);
48034: test_ret++;
48035: printf(" %d", n_nodes1);
48036: printf(" %d", n_nodes2);
48037: printf("\n");
48038: }
48039: }
48040: }
48041: function_tests++;
48042: #endif
48043:
48044: return(test_ret);
48045: }
48046:
48047:
48048: static int
48049: test_xmlXPathIsNodeType(void) {
48050: int test_ret = 0;
48051:
48052: #if defined(LIBXML_XPATH_ENABLED)
48053: int mem_base;
48054: int ret_val;
48055: xmlChar * name; /* a name string */
48056: int n_name;
48057:
48058: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
48059: mem_base = xmlMemBlocks();
48060: name = gen_const_xmlChar_ptr(n_name, 0);
48061:
48062: ret_val = xmlXPathIsNodeType((const xmlChar *)name);
48063: desret_int(ret_val);
48064: call_tests++;
48065: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
48066: xmlResetLastError();
48067: if (mem_base != xmlMemBlocks()) {
48068: printf("Leak of %d blocks found in xmlXPathIsNodeType",
48069: xmlMemBlocks() - mem_base);
48070: test_ret++;
48071: printf(" %d", n_name);
48072: printf("\n");
48073: }
48074: }
48075: function_tests++;
48076: #endif
48077:
48078: return(test_ret);
48079: }
48080:
48081:
48082: static int
48083: test_xmlXPathLangFunction(void) {
48084: int test_ret = 0;
48085:
48086: #if defined(LIBXML_XPATH_ENABLED)
48087: int mem_base;
48088: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48089: int n_ctxt;
48090: int nargs; /* the number of arguments */
48091: int n_nargs;
48092:
48093: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48094: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
48095: mem_base = xmlMemBlocks();
48096: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48097: nargs = gen_int(n_nargs, 1);
48098:
48099: xmlXPathLangFunction(ctxt, nargs);
48100: call_tests++;
48101: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48102: des_int(n_nargs, nargs, 1);
48103: xmlResetLastError();
48104: if (mem_base != xmlMemBlocks()) {
48105: printf("Leak of %d blocks found in xmlXPathLangFunction",
48106: xmlMemBlocks() - mem_base);
48107: test_ret++;
48108: printf(" %d", n_ctxt);
48109: printf(" %d", n_nargs);
48110: printf("\n");
48111: }
48112: }
48113: }
48114: function_tests++;
48115: #endif
48116:
48117: return(test_ret);
48118: }
48119:
48120:
48121: static int
48122: test_xmlXPathLastFunction(void) {
48123: int test_ret = 0;
48124:
48125: #if defined(LIBXML_XPATH_ENABLED)
48126: int mem_base;
48127: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48128: int n_ctxt;
48129: int nargs; /* the number of arguments */
48130: int n_nargs;
48131:
48132: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48133: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
48134: mem_base = xmlMemBlocks();
48135: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48136: nargs = gen_int(n_nargs, 1);
48137:
48138: xmlXPathLastFunction(ctxt, nargs);
48139: call_tests++;
48140: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48141: des_int(n_nargs, nargs, 1);
48142: xmlResetLastError();
48143: if (mem_base != xmlMemBlocks()) {
48144: printf("Leak of %d blocks found in xmlXPathLastFunction",
48145: xmlMemBlocks() - mem_base);
48146: test_ret++;
48147: printf(" %d", n_ctxt);
48148: printf(" %d", n_nargs);
48149: printf("\n");
48150: }
48151: }
48152: }
48153: function_tests++;
48154: #endif
48155:
48156: return(test_ret);
48157: }
48158:
48159:
48160: static int
48161: test_xmlXPathLeading(void) {
48162: int test_ret = 0;
48163:
48164: #if defined(LIBXML_XPATH_ENABLED)
48165: int mem_base;
48166: xmlNodeSetPtr ret_val;
48167: xmlNodeSetPtr nodes1; /* a node-set */
48168: int n_nodes1;
48169: xmlNodeSetPtr nodes2; /* a node-set */
48170: int n_nodes2;
48171:
48172: for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
48173: for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
48174: mem_base = xmlMemBlocks();
48175: nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
48176: nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
48177:
48178: ret_val = xmlXPathLeading(nodes1, nodes2);
48179: desret_xmlNodeSetPtr(ret_val);
48180: call_tests++;
48181: des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
48182: des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
48183: xmlResetLastError();
48184: if (mem_base != xmlMemBlocks()) {
48185: printf("Leak of %d blocks found in xmlXPathLeading",
48186: xmlMemBlocks() - mem_base);
48187: test_ret++;
48188: printf(" %d", n_nodes1);
48189: printf(" %d", n_nodes2);
48190: printf("\n");
48191: }
48192: }
48193: }
48194: function_tests++;
48195: #endif
48196:
48197: return(test_ret);
48198: }
48199:
48200:
48201: static int
48202: test_xmlXPathLeadingSorted(void) {
48203: int test_ret = 0;
48204:
48205: #if defined(LIBXML_XPATH_ENABLED)
48206: int mem_base;
48207: xmlNodeSetPtr ret_val;
48208: xmlNodeSetPtr nodes1; /* a node-set, sorted by document order */
48209: int n_nodes1;
48210: xmlNodeSetPtr nodes2; /* a node-set, sorted by document order */
48211: int n_nodes2;
48212:
48213: for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
48214: for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
48215: mem_base = xmlMemBlocks();
48216: nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
48217: nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
48218:
48219: ret_val = xmlXPathLeadingSorted(nodes1, nodes2);
48220: desret_xmlNodeSetPtr(ret_val);
48221: call_tests++;
48222: des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
48223: des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
48224: xmlResetLastError();
48225: if (mem_base != xmlMemBlocks()) {
48226: printf("Leak of %d blocks found in xmlXPathLeadingSorted",
48227: xmlMemBlocks() - mem_base);
48228: test_ret++;
48229: printf(" %d", n_nodes1);
48230: printf(" %d", n_nodes2);
48231: printf("\n");
48232: }
48233: }
48234: }
48235: function_tests++;
48236: #endif
48237:
48238: return(test_ret);
48239: }
48240:
48241:
48242: static int
48243: test_xmlXPathLocalNameFunction(void) {
48244: int test_ret = 0;
48245:
48246: #if defined(LIBXML_XPATH_ENABLED)
48247: int mem_base;
48248: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48249: int n_ctxt;
48250: int nargs; /* the number of arguments */
48251: int n_nargs;
48252:
48253: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48254: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
48255: mem_base = xmlMemBlocks();
48256: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48257: nargs = gen_int(n_nargs, 1);
48258:
48259: xmlXPathLocalNameFunction(ctxt, nargs);
48260: call_tests++;
48261: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48262: des_int(n_nargs, nargs, 1);
48263: xmlResetLastError();
48264: if (mem_base != xmlMemBlocks()) {
48265: printf("Leak of %d blocks found in xmlXPathLocalNameFunction",
48266: xmlMemBlocks() - mem_base);
48267: test_ret++;
48268: printf(" %d", n_ctxt);
48269: printf(" %d", n_nargs);
48270: printf("\n");
48271: }
48272: }
48273: }
48274: function_tests++;
48275: #endif
48276:
48277: return(test_ret);
48278: }
48279:
48280:
48281: static int
48282: test_xmlXPathModValues(void) {
48283: int test_ret = 0;
48284:
48285: #if defined(LIBXML_XPATH_ENABLED)
48286: int mem_base;
48287: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48288: int n_ctxt;
48289:
48290: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48291: mem_base = xmlMemBlocks();
48292: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48293:
48294: xmlXPathModValues(ctxt);
48295: call_tests++;
48296: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48297: xmlResetLastError();
48298: if (mem_base != xmlMemBlocks()) {
48299: printf("Leak of %d blocks found in xmlXPathModValues",
48300: xmlMemBlocks() - mem_base);
48301: test_ret++;
48302: printf(" %d", n_ctxt);
48303: printf("\n");
48304: }
48305: }
48306: function_tests++;
48307: #endif
48308:
48309: return(test_ret);
48310: }
48311:
48312:
48313: static int
48314: test_xmlXPathMultValues(void) {
48315: int test_ret = 0;
48316:
48317: #if defined(LIBXML_XPATH_ENABLED)
48318: int mem_base;
48319: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48320: int n_ctxt;
48321:
48322: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48323: mem_base = xmlMemBlocks();
48324: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48325:
48326: xmlXPathMultValues(ctxt);
48327: call_tests++;
48328: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48329: xmlResetLastError();
48330: if (mem_base != xmlMemBlocks()) {
48331: printf("Leak of %d blocks found in xmlXPathMultValues",
48332: xmlMemBlocks() - mem_base);
48333: test_ret++;
48334: printf(" %d", n_ctxt);
48335: printf("\n");
48336: }
48337: }
48338: function_tests++;
48339: #endif
48340:
48341: return(test_ret);
48342: }
48343:
48344:
48345: static int
48346: test_xmlXPathNamespaceURIFunction(void) {
48347: int test_ret = 0;
48348:
48349: #if defined(LIBXML_XPATH_ENABLED)
48350: int mem_base;
48351: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48352: int n_ctxt;
48353: int nargs; /* the number of arguments */
48354: int n_nargs;
48355:
48356: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48357: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
48358: mem_base = xmlMemBlocks();
48359: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48360: nargs = gen_int(n_nargs, 1);
48361:
48362: xmlXPathNamespaceURIFunction(ctxt, nargs);
48363: call_tests++;
48364: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48365: des_int(n_nargs, nargs, 1);
48366: xmlResetLastError();
48367: if (mem_base != xmlMemBlocks()) {
48368: printf("Leak of %d blocks found in xmlXPathNamespaceURIFunction",
48369: xmlMemBlocks() - mem_base);
48370: test_ret++;
48371: printf(" %d", n_ctxt);
48372: printf(" %d", n_nargs);
48373: printf("\n");
48374: }
48375: }
48376: }
48377: function_tests++;
48378: #endif
48379:
48380: return(test_ret);
48381: }
48382:
48383:
48384: static int
48385: test_xmlXPathNewBoolean(void) {
48386: int test_ret = 0;
48387:
48388: #if defined(LIBXML_XPATH_ENABLED)
48389: int mem_base;
48390: xmlXPathObjectPtr ret_val;
48391: int val; /* the boolean value */
48392: int n_val;
48393:
48394: for (n_val = 0;n_val < gen_nb_int;n_val++) {
48395: mem_base = xmlMemBlocks();
48396: val = gen_int(n_val, 0);
48397:
48398: ret_val = xmlXPathNewBoolean(val);
48399: desret_xmlXPathObjectPtr(ret_val);
48400: call_tests++;
48401: des_int(n_val, val, 0);
48402: xmlResetLastError();
48403: if (mem_base != xmlMemBlocks()) {
48404: printf("Leak of %d blocks found in xmlXPathNewBoolean",
48405: xmlMemBlocks() - mem_base);
48406: test_ret++;
48407: printf(" %d", n_val);
48408: printf("\n");
48409: }
48410: }
48411: function_tests++;
48412: #endif
48413:
48414: return(test_ret);
48415: }
48416:
48417:
48418: static int
48419: test_xmlXPathNewCString(void) {
48420: int test_ret = 0;
48421:
48422: #if defined(LIBXML_XPATH_ENABLED)
48423: int mem_base;
48424: xmlXPathObjectPtr ret_val;
48425: char * val; /* the char * value */
48426: int n_val;
48427:
48428: for (n_val = 0;n_val < gen_nb_const_char_ptr;n_val++) {
48429: mem_base = xmlMemBlocks();
48430: val = gen_const_char_ptr(n_val, 0);
48431:
48432: ret_val = xmlXPathNewCString((const char *)val);
48433: desret_xmlXPathObjectPtr(ret_val);
48434: call_tests++;
48435: des_const_char_ptr(n_val, (const char *)val, 0);
48436: xmlResetLastError();
48437: if (mem_base != xmlMemBlocks()) {
48438: printf("Leak of %d blocks found in xmlXPathNewCString",
48439: xmlMemBlocks() - mem_base);
48440: test_ret++;
48441: printf(" %d", n_val);
48442: printf("\n");
48443: }
48444: }
48445: function_tests++;
48446: #endif
48447:
48448: return(test_ret);
48449: }
48450:
48451:
48452: static int
48453: test_xmlXPathNewFloat(void) {
48454: int test_ret = 0;
48455:
48456: #if defined(LIBXML_XPATH_ENABLED)
48457: int mem_base;
48458: xmlXPathObjectPtr ret_val;
48459: double val; /* the double value */
48460: int n_val;
48461:
48462: for (n_val = 0;n_val < gen_nb_double;n_val++) {
48463: mem_base = xmlMemBlocks();
48464: val = gen_double(n_val, 0);
48465:
48466: ret_val = xmlXPathNewFloat(val);
48467: desret_xmlXPathObjectPtr(ret_val);
48468: call_tests++;
48469: des_double(n_val, val, 0);
48470: xmlResetLastError();
48471: if (mem_base != xmlMemBlocks()) {
48472: printf("Leak of %d blocks found in xmlXPathNewFloat",
48473: xmlMemBlocks() - mem_base);
48474: test_ret++;
48475: printf(" %d", n_val);
48476: printf("\n");
48477: }
48478: }
48479: function_tests++;
48480: #endif
48481:
48482: return(test_ret);
48483: }
48484:
48485:
48486: static int
48487: test_xmlXPathNewNodeSet(void) {
48488: int test_ret = 0;
48489:
48490: #if defined(LIBXML_XPATH_ENABLED)
48491: int mem_base;
48492: xmlXPathObjectPtr ret_val;
48493: xmlNodePtr val; /* the NodePtr value */
48494: int n_val;
48495:
48496: for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
48497: mem_base = xmlMemBlocks();
48498: val = gen_xmlNodePtr(n_val, 0);
48499:
48500: ret_val = xmlXPathNewNodeSet(val);
48501: desret_xmlXPathObjectPtr(ret_val);
48502: call_tests++;
48503: des_xmlNodePtr(n_val, val, 0);
48504: xmlResetLastError();
48505: if (mem_base != xmlMemBlocks()) {
48506: printf("Leak of %d blocks found in xmlXPathNewNodeSet",
48507: xmlMemBlocks() - mem_base);
48508: test_ret++;
48509: printf(" %d", n_val);
48510: printf("\n");
48511: }
48512: }
48513: function_tests++;
48514: #endif
48515:
48516: return(test_ret);
48517: }
48518:
48519:
48520: static int
48521: test_xmlXPathNewNodeSetList(void) {
48522: int test_ret = 0;
48523:
48524: #if defined(LIBXML_XPATH_ENABLED)
48525: int mem_base;
48526: xmlXPathObjectPtr ret_val;
48527: xmlNodeSetPtr val; /* an existing NodeSet */
48528: int n_val;
48529:
48530: for (n_val = 0;n_val < gen_nb_xmlNodeSetPtr;n_val++) {
48531: mem_base = xmlMemBlocks();
48532: val = gen_xmlNodeSetPtr(n_val, 0);
48533:
48534: ret_val = xmlXPathNewNodeSetList(val);
48535: desret_xmlXPathObjectPtr(ret_val);
48536: call_tests++;
48537: des_xmlNodeSetPtr(n_val, val, 0);
48538: xmlResetLastError();
48539: if (mem_base != xmlMemBlocks()) {
48540: printf("Leak of %d blocks found in xmlXPathNewNodeSetList",
48541: xmlMemBlocks() - mem_base);
48542: test_ret++;
48543: printf(" %d", n_val);
48544: printf("\n");
48545: }
48546: }
48547: function_tests++;
48548: #endif
48549:
48550: return(test_ret);
48551: }
48552:
48553:
48554: static int
48555: test_xmlXPathNewParserContext(void) {
48556: int test_ret = 0;
48557:
48558:
48559: /* missing type support */
48560: return(test_ret);
48561: }
48562:
48563:
48564: static int
48565: test_xmlXPathNewString(void) {
48566: int test_ret = 0;
48567:
48568: #if defined(LIBXML_XPATH_ENABLED)
48569: int mem_base;
48570: xmlXPathObjectPtr ret_val;
48571: xmlChar * val; /* the xmlChar * value */
48572: int n_val;
48573:
48574: for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) {
48575: mem_base = xmlMemBlocks();
48576: val = gen_const_xmlChar_ptr(n_val, 0);
48577:
48578: ret_val = xmlXPathNewString((const xmlChar *)val);
48579: desret_xmlXPathObjectPtr(ret_val);
48580: call_tests++;
48581: des_const_xmlChar_ptr(n_val, (const xmlChar *)val, 0);
48582: xmlResetLastError();
48583: if (mem_base != xmlMemBlocks()) {
48584: printf("Leak of %d blocks found in xmlXPathNewString",
48585: xmlMemBlocks() - mem_base);
48586: test_ret++;
48587: printf(" %d", n_val);
48588: printf("\n");
48589: }
48590: }
48591: function_tests++;
48592: #endif
48593:
48594: return(test_ret);
48595: }
48596:
48597:
48598: static int
48599: test_xmlXPathNextAncestor(void) {
48600: int test_ret = 0;
48601:
48602: #if defined(LIBXML_XPATH_ENABLED)
48603: int mem_base;
48604: xmlNodePtr ret_val;
48605: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48606: int n_ctxt;
48607: xmlNodePtr cur; /* the current node in the traversal */
48608: int n_cur;
48609:
48610: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48611: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48612: mem_base = xmlMemBlocks();
48613: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48614: cur = gen_xmlNodePtr(n_cur, 1);
48615:
48616: ret_val = xmlXPathNextAncestor(ctxt, cur);
48617: desret_xmlNodePtr(ret_val);
48618: call_tests++;
48619: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48620: des_xmlNodePtr(n_cur, cur, 1);
48621: xmlResetLastError();
48622: if (mem_base != xmlMemBlocks()) {
48623: printf("Leak of %d blocks found in xmlXPathNextAncestor",
48624: xmlMemBlocks() - mem_base);
48625: test_ret++;
48626: printf(" %d", n_ctxt);
48627: printf(" %d", n_cur);
48628: printf("\n");
48629: }
48630: }
48631: }
48632: function_tests++;
48633: #endif
48634:
48635: return(test_ret);
48636: }
48637:
48638:
48639: static int
48640: test_xmlXPathNextAncestorOrSelf(void) {
48641: int test_ret = 0;
48642:
48643: #if defined(LIBXML_XPATH_ENABLED)
48644: int mem_base;
48645: xmlNodePtr ret_val;
48646: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48647: int n_ctxt;
48648: xmlNodePtr cur; /* the current node in the traversal */
48649: int n_cur;
48650:
48651: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48652: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48653: mem_base = xmlMemBlocks();
48654: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48655: cur = gen_xmlNodePtr(n_cur, 1);
48656:
48657: ret_val = xmlXPathNextAncestorOrSelf(ctxt, cur);
48658: desret_xmlNodePtr(ret_val);
48659: call_tests++;
48660: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48661: des_xmlNodePtr(n_cur, cur, 1);
48662: xmlResetLastError();
48663: if (mem_base != xmlMemBlocks()) {
48664: printf("Leak of %d blocks found in xmlXPathNextAncestorOrSelf",
48665: xmlMemBlocks() - mem_base);
48666: test_ret++;
48667: printf(" %d", n_ctxt);
48668: printf(" %d", n_cur);
48669: printf("\n");
48670: }
48671: }
48672: }
48673: function_tests++;
48674: #endif
48675:
48676: return(test_ret);
48677: }
48678:
48679:
48680: static int
48681: test_xmlXPathNextAttribute(void) {
48682: int test_ret = 0;
48683:
48684: #if defined(LIBXML_XPATH_ENABLED)
48685: int mem_base;
48686: xmlNodePtr ret_val;
48687: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48688: int n_ctxt;
48689: xmlNodePtr cur; /* the current attribute in the traversal */
48690: int n_cur;
48691:
48692: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48693: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48694: mem_base = xmlMemBlocks();
48695: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48696: cur = gen_xmlNodePtr(n_cur, 1);
48697:
48698: ret_val = xmlXPathNextAttribute(ctxt, cur);
48699: desret_xmlNodePtr(ret_val);
48700: call_tests++;
48701: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48702: des_xmlNodePtr(n_cur, cur, 1);
48703: xmlResetLastError();
48704: if (mem_base != xmlMemBlocks()) {
48705: printf("Leak of %d blocks found in xmlXPathNextAttribute",
48706: xmlMemBlocks() - mem_base);
48707: test_ret++;
48708: printf(" %d", n_ctxt);
48709: printf(" %d", n_cur);
48710: printf("\n");
48711: }
48712: }
48713: }
48714: function_tests++;
48715: #endif
48716:
48717: return(test_ret);
48718: }
48719:
48720:
48721: static int
48722: test_xmlXPathNextChild(void) {
48723: int test_ret = 0;
48724:
48725: #if defined(LIBXML_XPATH_ENABLED)
48726: int mem_base;
48727: xmlNodePtr ret_val;
48728: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48729: int n_ctxt;
48730: xmlNodePtr cur; /* the current node in the traversal */
48731: int n_cur;
48732:
48733: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48734: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48735: mem_base = xmlMemBlocks();
48736: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48737: cur = gen_xmlNodePtr(n_cur, 1);
48738:
48739: ret_val = xmlXPathNextChild(ctxt, cur);
48740: desret_xmlNodePtr(ret_val);
48741: call_tests++;
48742: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48743: des_xmlNodePtr(n_cur, cur, 1);
48744: xmlResetLastError();
48745: if (mem_base != xmlMemBlocks()) {
48746: printf("Leak of %d blocks found in xmlXPathNextChild",
48747: xmlMemBlocks() - mem_base);
48748: test_ret++;
48749: printf(" %d", n_ctxt);
48750: printf(" %d", n_cur);
48751: printf("\n");
48752: }
48753: }
48754: }
48755: function_tests++;
48756: #endif
48757:
48758: return(test_ret);
48759: }
48760:
48761:
48762: static int
48763: test_xmlXPathNextDescendant(void) {
48764: int test_ret = 0;
48765:
48766: #if defined(LIBXML_XPATH_ENABLED)
48767: int mem_base;
48768: xmlNodePtr ret_val;
48769: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48770: int n_ctxt;
48771: xmlNodePtr cur; /* the current node in the traversal */
48772: int n_cur;
48773:
48774: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48775: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48776: mem_base = xmlMemBlocks();
48777: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48778: cur = gen_xmlNodePtr(n_cur, 1);
48779:
48780: ret_val = xmlXPathNextDescendant(ctxt, cur);
48781: desret_xmlNodePtr(ret_val);
48782: call_tests++;
48783: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48784: des_xmlNodePtr(n_cur, cur, 1);
48785: xmlResetLastError();
48786: if (mem_base != xmlMemBlocks()) {
48787: printf("Leak of %d blocks found in xmlXPathNextDescendant",
48788: xmlMemBlocks() - mem_base);
48789: test_ret++;
48790: printf(" %d", n_ctxt);
48791: printf(" %d", n_cur);
48792: printf("\n");
48793: }
48794: }
48795: }
48796: function_tests++;
48797: #endif
48798:
48799: return(test_ret);
48800: }
48801:
48802:
48803: static int
48804: test_xmlXPathNextDescendantOrSelf(void) {
48805: int test_ret = 0;
48806:
48807: #if defined(LIBXML_XPATH_ENABLED)
48808: int mem_base;
48809: xmlNodePtr ret_val;
48810: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48811: int n_ctxt;
48812: xmlNodePtr cur; /* the current node in the traversal */
48813: int n_cur;
48814:
48815: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48816: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48817: mem_base = xmlMemBlocks();
48818: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48819: cur = gen_xmlNodePtr(n_cur, 1);
48820:
48821: ret_val = xmlXPathNextDescendantOrSelf(ctxt, cur);
48822: desret_xmlNodePtr(ret_val);
48823: call_tests++;
48824: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48825: des_xmlNodePtr(n_cur, cur, 1);
48826: xmlResetLastError();
48827: if (mem_base != xmlMemBlocks()) {
48828: printf("Leak of %d blocks found in xmlXPathNextDescendantOrSelf",
48829: xmlMemBlocks() - mem_base);
48830: test_ret++;
48831: printf(" %d", n_ctxt);
48832: printf(" %d", n_cur);
48833: printf("\n");
48834: }
48835: }
48836: }
48837: function_tests++;
48838: #endif
48839:
48840: return(test_ret);
48841: }
48842:
48843:
48844: static int
48845: test_xmlXPathNextFollowing(void) {
48846: int test_ret = 0;
48847:
48848: #if defined(LIBXML_XPATH_ENABLED)
48849: int mem_base;
48850: xmlNodePtr ret_val;
48851: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48852: int n_ctxt;
48853: xmlNodePtr cur; /* the current node in the traversal */
48854: int n_cur;
48855:
48856: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48857: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48858: mem_base = xmlMemBlocks();
48859: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48860: cur = gen_xmlNodePtr(n_cur, 1);
48861:
48862: ret_val = xmlXPathNextFollowing(ctxt, cur);
48863: desret_xmlNodePtr(ret_val);
48864: call_tests++;
48865: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48866: des_xmlNodePtr(n_cur, cur, 1);
48867: xmlResetLastError();
48868: if (mem_base != xmlMemBlocks()) {
48869: printf("Leak of %d blocks found in xmlXPathNextFollowing",
48870: xmlMemBlocks() - mem_base);
48871: test_ret++;
48872: printf(" %d", n_ctxt);
48873: printf(" %d", n_cur);
48874: printf("\n");
48875: }
48876: }
48877: }
48878: function_tests++;
48879: #endif
48880:
48881: return(test_ret);
48882: }
48883:
48884:
48885: static int
48886: test_xmlXPathNextFollowingSibling(void) {
48887: int test_ret = 0;
48888:
48889: #if defined(LIBXML_XPATH_ENABLED)
48890: int mem_base;
48891: xmlNodePtr ret_val;
48892: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48893: int n_ctxt;
48894: xmlNodePtr cur; /* the current node in the traversal */
48895: int n_cur;
48896:
48897: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48898: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48899: mem_base = xmlMemBlocks();
48900: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48901: cur = gen_xmlNodePtr(n_cur, 1);
48902:
48903: ret_val = xmlXPathNextFollowingSibling(ctxt, cur);
48904: desret_xmlNodePtr(ret_val);
48905: call_tests++;
48906: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48907: des_xmlNodePtr(n_cur, cur, 1);
48908: xmlResetLastError();
48909: if (mem_base != xmlMemBlocks()) {
48910: printf("Leak of %d blocks found in xmlXPathNextFollowingSibling",
48911: xmlMemBlocks() - mem_base);
48912: test_ret++;
48913: printf(" %d", n_ctxt);
48914: printf(" %d", n_cur);
48915: printf("\n");
48916: }
48917: }
48918: }
48919: function_tests++;
48920: #endif
48921:
48922: return(test_ret);
48923: }
48924:
48925:
48926: static int
48927: test_xmlXPathNextNamespace(void) {
48928: int test_ret = 0;
48929:
48930: #if defined(LIBXML_XPATH_ENABLED)
48931: int mem_base;
48932: xmlNodePtr ret_val;
48933: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48934: int n_ctxt;
48935: xmlNodePtr cur; /* the current attribute in the traversal */
48936: int n_cur;
48937:
48938: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48939: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48940: mem_base = xmlMemBlocks();
48941: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48942: cur = gen_xmlNodePtr(n_cur, 1);
48943:
48944: ret_val = xmlXPathNextNamespace(ctxt, cur);
48945: desret_xmlNodePtr(ret_val);
48946: call_tests++;
48947: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48948: des_xmlNodePtr(n_cur, cur, 1);
48949: xmlResetLastError();
48950: if (mem_base != xmlMemBlocks()) {
48951: printf("Leak of %d blocks found in xmlXPathNextNamespace",
48952: xmlMemBlocks() - mem_base);
48953: test_ret++;
48954: printf(" %d", n_ctxt);
48955: printf(" %d", n_cur);
48956: printf("\n");
48957: }
48958: }
48959: }
48960: function_tests++;
48961: #endif
48962:
48963: return(test_ret);
48964: }
48965:
48966:
48967: static int
48968: test_xmlXPathNextParent(void) {
48969: int test_ret = 0;
48970:
48971: #if defined(LIBXML_XPATH_ENABLED)
48972: int mem_base;
48973: xmlNodePtr ret_val;
48974: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48975: int n_ctxt;
48976: xmlNodePtr cur; /* the current node in the traversal */
48977: int n_cur;
48978:
48979: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48980: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48981: mem_base = xmlMemBlocks();
48982: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48983: cur = gen_xmlNodePtr(n_cur, 1);
48984:
48985: ret_val = xmlXPathNextParent(ctxt, cur);
48986: desret_xmlNodePtr(ret_val);
48987: call_tests++;
48988: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48989: des_xmlNodePtr(n_cur, cur, 1);
48990: xmlResetLastError();
48991: if (mem_base != xmlMemBlocks()) {
48992: printf("Leak of %d blocks found in xmlXPathNextParent",
48993: xmlMemBlocks() - mem_base);
48994: test_ret++;
48995: printf(" %d", n_ctxt);
48996: printf(" %d", n_cur);
48997: printf("\n");
48998: }
48999: }
49000: }
49001: function_tests++;
49002: #endif
49003:
49004: return(test_ret);
49005: }
49006:
49007:
49008: static int
49009: test_xmlXPathNextPreceding(void) {
49010: int test_ret = 0;
49011:
49012: #if defined(LIBXML_XPATH_ENABLED)
49013: int mem_base;
49014: xmlNodePtr ret_val;
49015: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49016: int n_ctxt;
49017: xmlNodePtr cur; /* the current node in the traversal */
49018: int n_cur;
49019:
49020: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49021: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
49022: mem_base = xmlMemBlocks();
49023: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49024: cur = gen_xmlNodePtr(n_cur, 1);
49025:
49026: ret_val = xmlXPathNextPreceding(ctxt, cur);
49027: desret_xmlNodePtr(ret_val);
49028: call_tests++;
49029: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49030: des_xmlNodePtr(n_cur, cur, 1);
49031: xmlResetLastError();
49032: if (mem_base != xmlMemBlocks()) {
49033: printf("Leak of %d blocks found in xmlXPathNextPreceding",
49034: xmlMemBlocks() - mem_base);
49035: test_ret++;
49036: printf(" %d", n_ctxt);
49037: printf(" %d", n_cur);
49038: printf("\n");
49039: }
49040: }
49041: }
49042: function_tests++;
49043: #endif
49044:
49045: return(test_ret);
49046: }
49047:
49048:
49049: static int
49050: test_xmlXPathNextPrecedingSibling(void) {
49051: int test_ret = 0;
49052:
49053: #if defined(LIBXML_XPATH_ENABLED)
49054: int mem_base;
49055: xmlNodePtr ret_val;
49056: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49057: int n_ctxt;
49058: xmlNodePtr cur; /* the current node in the traversal */
49059: int n_cur;
49060:
49061: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49062: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
49063: mem_base = xmlMemBlocks();
49064: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49065: cur = gen_xmlNodePtr(n_cur, 1);
49066:
49067: ret_val = xmlXPathNextPrecedingSibling(ctxt, cur);
49068: desret_xmlNodePtr(ret_val);
49069: call_tests++;
49070: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49071: des_xmlNodePtr(n_cur, cur, 1);
49072: xmlResetLastError();
49073: if (mem_base != xmlMemBlocks()) {
49074: printf("Leak of %d blocks found in xmlXPathNextPrecedingSibling",
49075: xmlMemBlocks() - mem_base);
49076: test_ret++;
49077: printf(" %d", n_ctxt);
49078: printf(" %d", n_cur);
49079: printf("\n");
49080: }
49081: }
49082: }
49083: function_tests++;
49084: #endif
49085:
49086: return(test_ret);
49087: }
49088:
49089:
49090: static int
49091: test_xmlXPathNextSelf(void) {
49092: int test_ret = 0;
49093:
49094: #if defined(LIBXML_XPATH_ENABLED)
49095: int mem_base;
49096: xmlNodePtr ret_val;
49097: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49098: int n_ctxt;
49099: xmlNodePtr cur; /* the current node in the traversal */
49100: int n_cur;
49101:
49102: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49103: for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
49104: mem_base = xmlMemBlocks();
49105: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49106: cur = gen_xmlNodePtr(n_cur, 1);
49107:
49108: ret_val = xmlXPathNextSelf(ctxt, cur);
49109: desret_xmlNodePtr(ret_val);
49110: call_tests++;
49111: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49112: des_xmlNodePtr(n_cur, cur, 1);
49113: xmlResetLastError();
49114: if (mem_base != xmlMemBlocks()) {
49115: printf("Leak of %d blocks found in xmlXPathNextSelf",
49116: xmlMemBlocks() - mem_base);
49117: test_ret++;
49118: printf(" %d", n_ctxt);
49119: printf(" %d", n_cur);
49120: printf("\n");
49121: }
49122: }
49123: }
49124: function_tests++;
49125: #endif
49126:
49127: return(test_ret);
49128: }
49129:
49130:
49131: static int
49132: test_xmlXPathNodeLeading(void) {
49133: int test_ret = 0;
49134:
49135: #if defined(LIBXML_XPATH_ENABLED)
49136: int mem_base;
49137: xmlNodeSetPtr ret_val;
49138: xmlNodeSetPtr nodes; /* a node-set */
49139: int n_nodes;
49140: xmlNodePtr node; /* a node */
49141: int n_node;
49142:
49143: for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
49144: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
49145: mem_base = xmlMemBlocks();
49146: nodes = gen_xmlNodeSetPtr(n_nodes, 0);
49147: node = gen_xmlNodePtr(n_node, 1);
49148:
49149: ret_val = xmlXPathNodeLeading(nodes, node);
49150: desret_xmlNodeSetPtr(ret_val);
49151: call_tests++;
49152: des_xmlNodeSetPtr(n_nodes, nodes, 0);
49153: des_xmlNodePtr(n_node, node, 1);
49154: xmlResetLastError();
49155: if (mem_base != xmlMemBlocks()) {
49156: printf("Leak of %d blocks found in xmlXPathNodeLeading",
49157: xmlMemBlocks() - mem_base);
49158: test_ret++;
49159: printf(" %d", n_nodes);
49160: printf(" %d", n_node);
49161: printf("\n");
49162: }
49163: }
49164: }
49165: function_tests++;
49166: #endif
49167:
49168: return(test_ret);
49169: }
49170:
49171:
49172: static int
49173: test_xmlXPathNodeLeadingSorted(void) {
49174: int test_ret = 0;
49175:
49176: #if defined(LIBXML_XPATH_ENABLED)
49177: int mem_base;
49178: xmlNodeSetPtr ret_val;
49179: xmlNodeSetPtr nodes; /* a node-set, sorted by document order */
49180: int n_nodes;
49181: xmlNodePtr node; /* a node */
49182: int n_node;
49183:
49184: for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
49185: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
49186: mem_base = xmlMemBlocks();
49187: nodes = gen_xmlNodeSetPtr(n_nodes, 0);
49188: node = gen_xmlNodePtr(n_node, 1);
49189:
49190: ret_val = xmlXPathNodeLeadingSorted(nodes, node);
49191: desret_xmlNodeSetPtr(ret_val);
49192: call_tests++;
49193: des_xmlNodeSetPtr(n_nodes, nodes, 0);
49194: des_xmlNodePtr(n_node, node, 1);
49195: xmlResetLastError();
49196: if (mem_base != xmlMemBlocks()) {
49197: printf("Leak of %d blocks found in xmlXPathNodeLeadingSorted",
49198: xmlMemBlocks() - mem_base);
49199: test_ret++;
49200: printf(" %d", n_nodes);
49201: printf(" %d", n_node);
49202: printf("\n");
49203: }
49204: }
49205: }
49206: function_tests++;
49207: #endif
49208:
49209: return(test_ret);
49210: }
49211:
49212:
49213: static int
49214: test_xmlXPathNodeSetAdd(void) {
49215: int test_ret = 0;
49216:
49217: #if defined(LIBXML_XPATH_ENABLED)
49218: int mem_base;
1.1.1.3 ! misho 49219: int ret_val;
1.1 misho 49220: xmlNodeSetPtr cur; /* the initial node set */
49221: int n_cur;
49222: xmlNodePtr val; /* a new xmlNodePtr */
49223: int n_val;
49224:
49225: for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
49226: for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
49227: mem_base = xmlMemBlocks();
49228: cur = gen_xmlNodeSetPtr(n_cur, 0);
49229: val = gen_xmlNodePtr(n_val, 1);
49230:
1.1.1.3 ! misho 49231: ret_val = xmlXPathNodeSetAdd(cur, val);
! 49232: desret_int(ret_val);
1.1 misho 49233: call_tests++;
49234: des_xmlNodeSetPtr(n_cur, cur, 0);
49235: des_xmlNodePtr(n_val, val, 1);
49236: xmlResetLastError();
49237: if (mem_base != xmlMemBlocks()) {
49238: printf("Leak of %d blocks found in xmlXPathNodeSetAdd",
49239: xmlMemBlocks() - mem_base);
49240: test_ret++;
49241: printf(" %d", n_cur);
49242: printf(" %d", n_val);
49243: printf("\n");
49244: }
49245: }
49246: }
49247: function_tests++;
49248: #endif
49249:
49250: return(test_ret);
49251: }
49252:
49253:
49254: static int
49255: test_xmlXPathNodeSetAddNs(void) {
49256: int test_ret = 0;
49257:
49258: #if defined(LIBXML_XPATH_ENABLED)
49259: int mem_base;
1.1.1.3 ! misho 49260: int ret_val;
1.1 misho 49261: xmlNodeSetPtr cur; /* the initial node set */
49262: int n_cur;
49263: xmlNodePtr node; /* the hosting node */
49264: int n_node;
49265: xmlNsPtr ns; /* a the namespace node */
49266: int n_ns;
49267:
49268: for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
49269: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
49270: for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
49271: mem_base = xmlMemBlocks();
49272: cur = gen_xmlNodeSetPtr(n_cur, 0);
49273: node = gen_xmlNodePtr(n_node, 1);
49274: ns = gen_xmlNsPtr(n_ns, 2);
49275:
1.1.1.3 ! misho 49276: ret_val = xmlXPathNodeSetAddNs(cur, node, ns);
! 49277: desret_int(ret_val);
1.1 misho 49278: call_tests++;
49279: des_xmlNodeSetPtr(n_cur, cur, 0);
49280: des_xmlNodePtr(n_node, node, 1);
49281: des_xmlNsPtr(n_ns, ns, 2);
49282: xmlResetLastError();
49283: if (mem_base != xmlMemBlocks()) {
49284: printf("Leak of %d blocks found in xmlXPathNodeSetAddNs",
49285: xmlMemBlocks() - mem_base);
49286: test_ret++;
49287: printf(" %d", n_cur);
49288: printf(" %d", n_node);
49289: printf(" %d", n_ns);
49290: printf("\n");
49291: }
49292: }
49293: }
49294: }
49295: function_tests++;
49296: #endif
49297:
49298: return(test_ret);
49299: }
49300:
49301:
49302: static int
49303: test_xmlXPathNodeSetAddUnique(void) {
49304: int test_ret = 0;
49305:
49306: #if defined(LIBXML_XPATH_ENABLED)
49307: int mem_base;
1.1.1.3 ! misho 49308: int ret_val;
1.1 misho 49309: xmlNodeSetPtr cur; /* the initial node set */
49310: int n_cur;
49311: xmlNodePtr val; /* a new xmlNodePtr */
49312: int n_val;
49313:
49314: for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
49315: for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
49316: mem_base = xmlMemBlocks();
49317: cur = gen_xmlNodeSetPtr(n_cur, 0);
49318: val = gen_xmlNodePtr(n_val, 1);
49319:
1.1.1.3 ! misho 49320: ret_val = xmlXPathNodeSetAddUnique(cur, val);
! 49321: desret_int(ret_val);
1.1 misho 49322: call_tests++;
49323: des_xmlNodeSetPtr(n_cur, cur, 0);
49324: des_xmlNodePtr(n_val, val, 1);
49325: xmlResetLastError();
49326: if (mem_base != xmlMemBlocks()) {
49327: printf("Leak of %d blocks found in xmlXPathNodeSetAddUnique",
49328: xmlMemBlocks() - mem_base);
49329: test_ret++;
49330: printf(" %d", n_cur);
49331: printf(" %d", n_val);
49332: printf("\n");
49333: }
49334: }
49335: }
49336: function_tests++;
49337: #endif
49338:
49339: return(test_ret);
49340: }
49341:
49342:
49343: static int
49344: test_xmlXPathNodeSetContains(void) {
49345: int test_ret = 0;
49346:
49347: #if defined(LIBXML_XPATH_ENABLED)
49348: int mem_base;
49349: int ret_val;
49350: xmlNodeSetPtr cur; /* the node-set */
49351: int n_cur;
49352: xmlNodePtr val; /* the node */
49353: int n_val;
49354:
49355: for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
49356: for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
49357: mem_base = xmlMemBlocks();
49358: cur = gen_xmlNodeSetPtr(n_cur, 0);
49359: val = gen_xmlNodePtr(n_val, 1);
49360:
49361: ret_val = xmlXPathNodeSetContains(cur, val);
49362: desret_int(ret_val);
49363: call_tests++;
49364: des_xmlNodeSetPtr(n_cur, cur, 0);
49365: des_xmlNodePtr(n_val, val, 1);
49366: xmlResetLastError();
49367: if (mem_base != xmlMemBlocks()) {
49368: printf("Leak of %d blocks found in xmlXPathNodeSetContains",
49369: xmlMemBlocks() - mem_base);
49370: test_ret++;
49371: printf(" %d", n_cur);
49372: printf(" %d", n_val);
49373: printf("\n");
49374: }
49375: }
49376: }
49377: function_tests++;
49378: #endif
49379:
49380: return(test_ret);
49381: }
49382:
49383:
49384: static int
49385: test_xmlXPathNodeSetDel(void) {
49386: int test_ret = 0;
49387:
49388: #if defined(LIBXML_XPATH_ENABLED)
49389: int mem_base;
49390: xmlNodeSetPtr cur; /* the initial node set */
49391: int n_cur;
49392: xmlNodePtr val; /* an xmlNodePtr */
49393: int n_val;
49394:
49395: for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
49396: for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
49397: mem_base = xmlMemBlocks();
49398: cur = gen_xmlNodeSetPtr(n_cur, 0);
49399: val = gen_xmlNodePtr(n_val, 1);
49400:
49401: xmlXPathNodeSetDel(cur, val);
49402: call_tests++;
49403: des_xmlNodeSetPtr(n_cur, cur, 0);
49404: des_xmlNodePtr(n_val, val, 1);
49405: xmlResetLastError();
49406: if (mem_base != xmlMemBlocks()) {
49407: printf("Leak of %d blocks found in xmlXPathNodeSetDel",
49408: xmlMemBlocks() - mem_base);
49409: test_ret++;
49410: printf(" %d", n_cur);
49411: printf(" %d", n_val);
49412: printf("\n");
49413: }
49414: }
49415: }
49416: function_tests++;
49417: #endif
49418:
49419: return(test_ret);
49420: }
49421:
49422:
49423: static int
49424: test_xmlXPathNodeSetMerge(void) {
49425: int test_ret = 0;
49426:
49427: #if defined(LIBXML_XPATH_ENABLED)
49428: int mem_base;
49429: xmlNodeSetPtr ret_val;
49430: xmlNodeSetPtr val1; /* the first NodeSet or NULL */
49431: int n_val1;
49432: xmlNodeSetPtr val2; /* the second NodeSet */
49433: int n_val2;
49434:
49435: for (n_val1 = 0;n_val1 < gen_nb_xmlNodeSetPtr;n_val1++) {
49436: for (n_val2 = 0;n_val2 < gen_nb_xmlNodeSetPtr;n_val2++) {
49437: mem_base = xmlMemBlocks();
49438: val1 = gen_xmlNodeSetPtr(n_val1, 0);
49439: val2 = gen_xmlNodeSetPtr(n_val2, 1);
49440:
49441: ret_val = xmlXPathNodeSetMerge(val1, val2);
49442: desret_xmlNodeSetPtr(ret_val);
49443: call_tests++;
49444: des_xmlNodeSetPtr(n_val1, val1, 0);
49445: des_xmlNodeSetPtr(n_val2, val2, 1);
49446: xmlResetLastError();
49447: if (mem_base != xmlMemBlocks()) {
49448: printf("Leak of %d blocks found in xmlXPathNodeSetMerge",
49449: xmlMemBlocks() - mem_base);
49450: test_ret++;
49451: printf(" %d", n_val1);
49452: printf(" %d", n_val2);
49453: printf("\n");
49454: }
49455: }
49456: }
49457: function_tests++;
49458: #endif
49459:
49460: return(test_ret);
49461: }
49462:
49463:
49464: static int
49465: test_xmlXPathNodeSetRemove(void) {
49466: int test_ret = 0;
49467:
49468: #if defined(LIBXML_XPATH_ENABLED)
49469: int mem_base;
49470: xmlNodeSetPtr cur; /* the initial node set */
49471: int n_cur;
49472: int val; /* the index to remove */
49473: int n_val;
49474:
49475: for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
49476: for (n_val = 0;n_val < gen_nb_int;n_val++) {
49477: mem_base = xmlMemBlocks();
49478: cur = gen_xmlNodeSetPtr(n_cur, 0);
49479: val = gen_int(n_val, 1);
49480:
49481: xmlXPathNodeSetRemove(cur, val);
49482: call_tests++;
49483: des_xmlNodeSetPtr(n_cur, cur, 0);
49484: des_int(n_val, val, 1);
49485: xmlResetLastError();
49486: if (mem_base != xmlMemBlocks()) {
49487: printf("Leak of %d blocks found in xmlXPathNodeSetRemove",
49488: xmlMemBlocks() - mem_base);
49489: test_ret++;
49490: printf(" %d", n_cur);
49491: printf(" %d", n_val);
49492: printf("\n");
49493: }
49494: }
49495: }
49496: function_tests++;
49497: #endif
49498:
49499: return(test_ret);
49500: }
49501:
49502:
49503: static int
49504: test_xmlXPathNodeSetSort(void) {
49505: int test_ret = 0;
49506:
49507: #if defined(LIBXML_XPATH_ENABLED)
49508: int mem_base;
49509: xmlNodeSetPtr set; /* the node set */
49510: int n_set;
49511:
49512: for (n_set = 0;n_set < gen_nb_xmlNodeSetPtr;n_set++) {
49513: mem_base = xmlMemBlocks();
49514: set = gen_xmlNodeSetPtr(n_set, 0);
49515:
49516: xmlXPathNodeSetSort(set);
49517: call_tests++;
49518: des_xmlNodeSetPtr(n_set, set, 0);
49519: xmlResetLastError();
49520: if (mem_base != xmlMemBlocks()) {
49521: printf("Leak of %d blocks found in xmlXPathNodeSetSort",
49522: xmlMemBlocks() - mem_base);
49523: test_ret++;
49524: printf(" %d", n_set);
49525: printf("\n");
49526: }
49527: }
49528: function_tests++;
49529: #endif
49530:
49531: return(test_ret);
49532: }
49533:
49534:
49535: static int
49536: test_xmlXPathNodeTrailing(void) {
49537: int test_ret = 0;
49538:
49539: #if defined(LIBXML_XPATH_ENABLED)
49540: int mem_base;
49541: xmlNodeSetPtr ret_val;
49542: xmlNodeSetPtr nodes; /* a node-set */
49543: int n_nodes;
49544: xmlNodePtr node; /* a node */
49545: int n_node;
49546:
49547: for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
49548: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
49549: mem_base = xmlMemBlocks();
49550: nodes = gen_xmlNodeSetPtr(n_nodes, 0);
49551: node = gen_xmlNodePtr(n_node, 1);
49552:
49553: ret_val = xmlXPathNodeTrailing(nodes, node);
49554: desret_xmlNodeSetPtr(ret_val);
49555: call_tests++;
49556: des_xmlNodeSetPtr(n_nodes, nodes, 0);
49557: des_xmlNodePtr(n_node, node, 1);
49558: xmlResetLastError();
49559: if (mem_base != xmlMemBlocks()) {
49560: printf("Leak of %d blocks found in xmlXPathNodeTrailing",
49561: xmlMemBlocks() - mem_base);
49562: test_ret++;
49563: printf(" %d", n_nodes);
49564: printf(" %d", n_node);
49565: printf("\n");
49566: }
49567: }
49568: }
49569: function_tests++;
49570: #endif
49571:
49572: return(test_ret);
49573: }
49574:
49575:
49576: static int
49577: test_xmlXPathNodeTrailingSorted(void) {
49578: int test_ret = 0;
49579:
49580: #if defined(LIBXML_XPATH_ENABLED)
49581: int mem_base;
49582: xmlNodeSetPtr ret_val;
49583: xmlNodeSetPtr nodes; /* a node-set, sorted by document order */
49584: int n_nodes;
49585: xmlNodePtr node; /* a node */
49586: int n_node;
49587:
49588: for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
49589: for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
49590: mem_base = xmlMemBlocks();
49591: nodes = gen_xmlNodeSetPtr(n_nodes, 0);
49592: node = gen_xmlNodePtr(n_node, 1);
49593:
49594: ret_val = xmlXPathNodeTrailingSorted(nodes, node);
49595: desret_xmlNodeSetPtr(ret_val);
49596: call_tests++;
49597: des_xmlNodeSetPtr(n_nodes, nodes, 0);
49598: des_xmlNodePtr(n_node, node, 1);
49599: xmlResetLastError();
49600: if (mem_base != xmlMemBlocks()) {
49601: printf("Leak of %d blocks found in xmlXPathNodeTrailingSorted",
49602: xmlMemBlocks() - mem_base);
49603: test_ret++;
49604: printf(" %d", n_nodes);
49605: printf(" %d", n_node);
49606: printf("\n");
49607: }
49608: }
49609: }
49610: function_tests++;
49611: #endif
49612:
49613: return(test_ret);
49614: }
49615:
49616:
49617: static int
49618: test_xmlXPathNormalizeFunction(void) {
49619: int test_ret = 0;
49620:
49621: #if defined(LIBXML_XPATH_ENABLED)
49622: int mem_base;
49623: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49624: int n_ctxt;
49625: int nargs; /* the number of arguments */
49626: int n_nargs;
49627:
49628: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49629: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
49630: mem_base = xmlMemBlocks();
49631: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49632: nargs = gen_int(n_nargs, 1);
49633:
49634: xmlXPathNormalizeFunction(ctxt, nargs);
49635: call_tests++;
49636: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49637: des_int(n_nargs, nargs, 1);
49638: xmlResetLastError();
49639: if (mem_base != xmlMemBlocks()) {
49640: printf("Leak of %d blocks found in xmlXPathNormalizeFunction",
49641: xmlMemBlocks() - mem_base);
49642: test_ret++;
49643: printf(" %d", n_ctxt);
49644: printf(" %d", n_nargs);
49645: printf("\n");
49646: }
49647: }
49648: }
49649: function_tests++;
49650: #endif
49651:
49652: return(test_ret);
49653: }
49654:
49655:
49656: static int
49657: test_xmlXPathNotEqualValues(void) {
49658: int test_ret = 0;
49659:
49660: #if defined(LIBXML_XPATH_ENABLED)
49661: int mem_base;
49662: int ret_val;
49663: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49664: int n_ctxt;
49665:
49666: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49667: mem_base = xmlMemBlocks();
49668: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49669:
49670: ret_val = xmlXPathNotEqualValues(ctxt);
49671: desret_int(ret_val);
49672: call_tests++;
49673: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49674: xmlResetLastError();
49675: if (mem_base != xmlMemBlocks()) {
49676: printf("Leak of %d blocks found in xmlXPathNotEqualValues",
49677: xmlMemBlocks() - mem_base);
49678: test_ret++;
49679: printf(" %d", n_ctxt);
49680: printf("\n");
49681: }
49682: }
49683: function_tests++;
49684: #endif
49685:
49686: return(test_ret);
49687: }
49688:
49689:
49690: static int
49691: test_xmlXPathNotFunction(void) {
49692: int test_ret = 0;
49693:
49694: #if defined(LIBXML_XPATH_ENABLED)
49695: int mem_base;
49696: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49697: int n_ctxt;
49698: int nargs; /* the number of arguments */
49699: int n_nargs;
49700:
49701: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49702: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
49703: mem_base = xmlMemBlocks();
49704: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49705: nargs = gen_int(n_nargs, 1);
49706:
49707: xmlXPathNotFunction(ctxt, nargs);
49708: call_tests++;
49709: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49710: des_int(n_nargs, nargs, 1);
49711: xmlResetLastError();
49712: if (mem_base != xmlMemBlocks()) {
49713: printf("Leak of %d blocks found in xmlXPathNotFunction",
49714: xmlMemBlocks() - mem_base);
49715: test_ret++;
49716: printf(" %d", n_ctxt);
49717: printf(" %d", n_nargs);
49718: printf("\n");
49719: }
49720: }
49721: }
49722: function_tests++;
49723: #endif
49724:
49725: return(test_ret);
49726: }
49727:
49728:
49729: static int
49730: test_xmlXPathNsLookup(void) {
49731: int test_ret = 0;
49732:
49733: #if defined(LIBXML_XPATH_ENABLED)
49734: int mem_base;
49735: const xmlChar * ret_val;
49736: xmlXPathContextPtr ctxt; /* the XPath context */
49737: int n_ctxt;
49738: xmlChar * prefix; /* the namespace prefix value */
49739: int n_prefix;
49740:
49741: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
49742: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
49743: mem_base = xmlMemBlocks();
49744: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
49745: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
49746:
49747: ret_val = xmlXPathNsLookup(ctxt, (const xmlChar *)prefix);
49748: desret_const_xmlChar_ptr(ret_val);
49749: call_tests++;
49750: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
49751: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
49752: xmlResetLastError();
49753: if (mem_base != xmlMemBlocks()) {
49754: printf("Leak of %d blocks found in xmlXPathNsLookup",
49755: xmlMemBlocks() - mem_base);
49756: test_ret++;
49757: printf(" %d", n_ctxt);
49758: printf(" %d", n_prefix);
49759: printf("\n");
49760: }
49761: }
49762: }
49763: function_tests++;
49764: #endif
49765:
49766: return(test_ret);
49767: }
49768:
49769:
49770: static int
49771: test_xmlXPathNumberFunction(void) {
49772: int test_ret = 0;
49773:
49774: #if defined(LIBXML_XPATH_ENABLED)
49775: int mem_base;
49776: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49777: int n_ctxt;
49778: int nargs; /* the number of arguments */
49779: int n_nargs;
49780:
49781: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49782: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
49783: mem_base = xmlMemBlocks();
49784: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49785: nargs = gen_int(n_nargs, 1);
49786:
49787: xmlXPathNumberFunction(ctxt, nargs);
49788: call_tests++;
49789: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49790: des_int(n_nargs, nargs, 1);
49791: xmlResetLastError();
49792: if (mem_base != xmlMemBlocks()) {
49793: printf("Leak of %d blocks found in xmlXPathNumberFunction",
49794: xmlMemBlocks() - mem_base);
49795: test_ret++;
49796: printf(" %d", n_ctxt);
49797: printf(" %d", n_nargs);
49798: printf("\n");
49799: }
49800: }
49801: }
49802: function_tests++;
49803: #endif
49804:
49805: return(test_ret);
49806: }
49807:
49808:
49809: static int
49810: test_xmlXPathParseNCName(void) {
49811: int test_ret = 0;
49812:
49813: #if defined(LIBXML_XPATH_ENABLED)
49814: int mem_base;
49815: xmlChar * ret_val;
49816: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49817: int n_ctxt;
49818:
49819: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49820: mem_base = xmlMemBlocks();
49821: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49822:
49823: ret_val = xmlXPathParseNCName(ctxt);
49824: desret_xmlChar_ptr(ret_val);
49825: call_tests++;
49826: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49827: xmlResetLastError();
49828: if (mem_base != xmlMemBlocks()) {
49829: printf("Leak of %d blocks found in xmlXPathParseNCName",
49830: xmlMemBlocks() - mem_base);
49831: test_ret++;
49832: printf(" %d", n_ctxt);
49833: printf("\n");
49834: }
49835: }
49836: function_tests++;
49837: #endif
49838:
49839: return(test_ret);
49840: }
49841:
49842:
49843: static int
49844: test_xmlXPathParseName(void) {
49845: int test_ret = 0;
49846:
49847: #if defined(LIBXML_XPATH_ENABLED)
49848: int mem_base;
49849: xmlChar * ret_val;
49850: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49851: int n_ctxt;
49852:
49853: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49854: mem_base = xmlMemBlocks();
49855: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49856:
49857: ret_val = xmlXPathParseName(ctxt);
49858: desret_xmlChar_ptr(ret_val);
49859: call_tests++;
49860: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49861: xmlResetLastError();
49862: if (mem_base != xmlMemBlocks()) {
49863: printf("Leak of %d blocks found in xmlXPathParseName",
49864: xmlMemBlocks() - mem_base);
49865: test_ret++;
49866: printf(" %d", n_ctxt);
49867: printf("\n");
49868: }
49869: }
49870: function_tests++;
49871: #endif
49872:
49873: return(test_ret);
49874: }
49875:
49876:
49877: static int
49878: test_xmlXPathPopBoolean(void) {
49879: int test_ret = 0;
49880:
49881: #if defined(LIBXML_XPATH_ENABLED)
49882: int mem_base;
49883: int ret_val;
49884: xmlXPathParserContextPtr ctxt; /* an XPath parser context */
49885: int n_ctxt;
49886:
49887: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49888: mem_base = xmlMemBlocks();
49889: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49890:
49891: ret_val = xmlXPathPopBoolean(ctxt);
49892: desret_int(ret_val);
49893: call_tests++;
49894: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49895: xmlResetLastError();
49896: if (mem_base != xmlMemBlocks()) {
49897: printf("Leak of %d blocks found in xmlXPathPopBoolean",
49898: xmlMemBlocks() - mem_base);
49899: test_ret++;
49900: printf(" %d", n_ctxt);
49901: printf("\n");
49902: }
49903: }
49904: function_tests++;
49905: #endif
49906:
49907: return(test_ret);
49908: }
49909:
49910:
49911: static int
49912: test_xmlXPathPopExternal(void) {
49913: int test_ret = 0;
49914:
49915: #if defined(LIBXML_XPATH_ENABLED)
49916: int mem_base;
49917: void * ret_val;
49918: xmlXPathParserContextPtr ctxt; /* an XPath parser context */
49919: int n_ctxt;
49920:
49921: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49922: mem_base = xmlMemBlocks();
49923: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49924:
49925: ret_val = xmlXPathPopExternal(ctxt);
49926: desret_void_ptr(ret_val);
49927: call_tests++;
49928: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49929: xmlResetLastError();
49930: if (mem_base != xmlMemBlocks()) {
49931: printf("Leak of %d blocks found in xmlXPathPopExternal",
49932: xmlMemBlocks() - mem_base);
49933: test_ret++;
49934: printf(" %d", n_ctxt);
49935: printf("\n");
49936: }
49937: }
49938: function_tests++;
49939: #endif
49940:
49941: return(test_ret);
49942: }
49943:
49944:
49945: static int
49946: test_xmlXPathPopNodeSet(void) {
49947: int test_ret = 0;
49948:
49949: #if defined(LIBXML_XPATH_ENABLED)
49950: int mem_base;
49951: xmlNodeSetPtr ret_val;
49952: xmlXPathParserContextPtr ctxt; /* an XPath parser context */
49953: int n_ctxt;
49954:
49955: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49956: mem_base = xmlMemBlocks();
49957: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49958:
49959: ret_val = xmlXPathPopNodeSet(ctxt);
49960: desret_xmlNodeSetPtr(ret_val);
49961: call_tests++;
49962: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49963: xmlResetLastError();
49964: if (mem_base != xmlMemBlocks()) {
49965: printf("Leak of %d blocks found in xmlXPathPopNodeSet",
49966: xmlMemBlocks() - mem_base);
49967: test_ret++;
49968: printf(" %d", n_ctxt);
49969: printf("\n");
49970: }
49971: }
49972: function_tests++;
49973: #endif
49974:
49975: return(test_ret);
49976: }
49977:
49978:
49979: static int
49980: test_xmlXPathPopNumber(void) {
49981: int test_ret = 0;
49982:
49983: #if defined(LIBXML_XPATH_ENABLED)
49984: int mem_base;
49985: double ret_val;
49986: xmlXPathParserContextPtr ctxt; /* an XPath parser context */
49987: int n_ctxt;
49988:
49989: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49990: mem_base = xmlMemBlocks();
49991: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49992:
49993: ret_val = xmlXPathPopNumber(ctxt);
49994: desret_double(ret_val);
49995: call_tests++;
49996: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49997: xmlResetLastError();
49998: if (mem_base != xmlMemBlocks()) {
49999: printf("Leak of %d blocks found in xmlXPathPopNumber",
50000: xmlMemBlocks() - mem_base);
50001: test_ret++;
50002: printf(" %d", n_ctxt);
50003: printf("\n");
50004: }
50005: }
50006: function_tests++;
50007: #endif
50008:
50009: return(test_ret);
50010: }
50011:
50012:
50013: static int
50014: test_xmlXPathPopString(void) {
50015: int test_ret = 0;
50016:
50017: #if defined(LIBXML_XPATH_ENABLED)
50018: int mem_base;
50019: xmlChar * ret_val;
50020: xmlXPathParserContextPtr ctxt; /* an XPath parser context */
50021: int n_ctxt;
50022:
50023: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50024: mem_base = xmlMemBlocks();
50025: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50026:
50027: ret_val = xmlXPathPopString(ctxt);
50028: desret_xmlChar_ptr(ret_val);
50029: call_tests++;
50030: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50031: xmlResetLastError();
50032: if (mem_base != xmlMemBlocks()) {
50033: printf("Leak of %d blocks found in xmlXPathPopString",
50034: xmlMemBlocks() - mem_base);
50035: test_ret++;
50036: printf(" %d", n_ctxt);
50037: printf("\n");
50038: }
50039: }
50040: function_tests++;
50041: #endif
50042:
50043: return(test_ret);
50044: }
50045:
50046:
50047: static int
50048: test_xmlXPathPositionFunction(void) {
50049: int test_ret = 0;
50050:
50051: #if defined(LIBXML_XPATH_ENABLED)
50052: int mem_base;
50053: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50054: int n_ctxt;
50055: int nargs; /* the number of arguments */
50056: int n_nargs;
50057:
50058: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50059: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50060: mem_base = xmlMemBlocks();
50061: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50062: nargs = gen_int(n_nargs, 1);
50063:
50064: xmlXPathPositionFunction(ctxt, nargs);
50065: call_tests++;
50066: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50067: des_int(n_nargs, nargs, 1);
50068: xmlResetLastError();
50069: if (mem_base != xmlMemBlocks()) {
50070: printf("Leak of %d blocks found in xmlXPathPositionFunction",
50071: xmlMemBlocks() - mem_base);
50072: test_ret++;
50073: printf(" %d", n_ctxt);
50074: printf(" %d", n_nargs);
50075: printf("\n");
50076: }
50077: }
50078: }
50079: function_tests++;
50080: #endif
50081:
50082: return(test_ret);
50083: }
50084:
50085:
50086: static int
50087: test_xmlXPathRegisterAllFunctions(void) {
50088: int test_ret = 0;
50089:
50090: #if defined(LIBXML_XPATH_ENABLED)
50091: int mem_base;
50092: xmlXPathContextPtr ctxt; /* the XPath context */
50093: int n_ctxt;
50094:
50095: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
50096: mem_base = xmlMemBlocks();
50097: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
50098:
50099: xmlXPathRegisterAllFunctions(ctxt);
50100: call_tests++;
50101: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
50102: xmlResetLastError();
50103: if (mem_base != xmlMemBlocks()) {
50104: printf("Leak of %d blocks found in xmlXPathRegisterAllFunctions",
50105: xmlMemBlocks() - mem_base);
50106: test_ret++;
50107: printf(" %d", n_ctxt);
50108: printf("\n");
50109: }
50110: }
50111: function_tests++;
50112: #endif
50113:
50114: return(test_ret);
50115: }
50116:
50117:
50118: static int
50119: test_xmlXPathRegisterFunc(void) {
50120: int test_ret = 0;
50121:
50122:
50123: /* missing type support */
50124: return(test_ret);
50125: }
50126:
50127:
50128: static int
50129: test_xmlXPathRegisterFuncLookup(void) {
50130: int test_ret = 0;
50131:
50132:
50133: /* missing type support */
50134: return(test_ret);
50135: }
50136:
50137:
50138: static int
50139: test_xmlXPathRegisterFuncNS(void) {
50140: int test_ret = 0;
50141:
50142:
50143: /* missing type support */
50144: return(test_ret);
50145: }
50146:
50147:
50148: static int
50149: test_xmlXPathRegisterNs(void) {
50150: int test_ret = 0;
50151:
50152: #if defined(LIBXML_XPATH_ENABLED)
50153: int mem_base;
50154: int ret_val;
50155: xmlXPathContextPtr ctxt; /* the XPath context */
50156: int n_ctxt;
50157: xmlChar * prefix; /* the namespace prefix cannot be NULL or empty string */
50158: int n_prefix;
50159: xmlChar * ns_uri; /* the namespace name */
50160: int n_ns_uri;
50161:
50162: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
50163: for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
50164: for (n_ns_uri = 0;n_ns_uri < gen_nb_const_xmlChar_ptr;n_ns_uri++) {
50165: mem_base = xmlMemBlocks();
50166: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
50167: prefix = gen_const_xmlChar_ptr(n_prefix, 1);
50168: ns_uri = gen_const_xmlChar_ptr(n_ns_uri, 2);
50169:
50170: ret_val = xmlXPathRegisterNs(ctxt, (const xmlChar *)prefix, (const xmlChar *)ns_uri);
50171: desret_int(ret_val);
50172: call_tests++;
50173: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
50174: des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
50175: des_const_xmlChar_ptr(n_ns_uri, (const xmlChar *)ns_uri, 2);
50176: xmlResetLastError();
50177: if (mem_base != xmlMemBlocks()) {
50178: printf("Leak of %d blocks found in xmlXPathRegisterNs",
50179: xmlMemBlocks() - mem_base);
50180: test_ret++;
50181: printf(" %d", n_ctxt);
50182: printf(" %d", n_prefix);
50183: printf(" %d", n_ns_uri);
50184: printf("\n");
50185: }
50186: }
50187: }
50188: }
50189: function_tests++;
50190: #endif
50191:
50192: return(test_ret);
50193: }
50194:
50195:
50196: static int
50197: test_xmlXPathRegisterVariable(void) {
50198: int test_ret = 0;
50199:
50200: #if defined(LIBXML_XPATH_ENABLED)
50201: int mem_base;
50202: int ret_val;
50203: xmlXPathContextPtr ctxt; /* the XPath context */
50204: int n_ctxt;
50205: xmlChar * name; /* the variable name */
50206: int n_name;
50207: xmlXPathObjectPtr value; /* the variable value or NULL */
50208: int n_value;
50209:
50210: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
50211: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
50212: for (n_value = 0;n_value < gen_nb_xmlXPathObjectPtr;n_value++) {
50213: mem_base = xmlMemBlocks();
50214: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
50215: name = gen_const_xmlChar_ptr(n_name, 1);
50216: value = gen_xmlXPathObjectPtr(n_value, 2);
50217:
50218: ret_val = xmlXPathRegisterVariable(ctxt, (const xmlChar *)name, value);
50219: desret_int(ret_val);
50220: call_tests++;
50221: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
50222: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
50223: des_xmlXPathObjectPtr(n_value, value, 2);
50224: xmlResetLastError();
50225: if (mem_base != xmlMemBlocks()) {
50226: printf("Leak of %d blocks found in xmlXPathRegisterVariable",
50227: xmlMemBlocks() - mem_base);
50228: test_ret++;
50229: printf(" %d", n_ctxt);
50230: printf(" %d", n_name);
50231: printf(" %d", n_value);
50232: printf("\n");
50233: }
50234: }
50235: }
50236: }
50237: function_tests++;
50238: #endif
50239:
50240: return(test_ret);
50241: }
50242:
50243:
50244: static int
50245: test_xmlXPathRegisterVariableLookup(void) {
50246: int test_ret = 0;
50247:
50248:
50249: /* missing type support */
50250: return(test_ret);
50251: }
50252:
50253:
50254: static int
50255: test_xmlXPathRegisterVariableNS(void) {
50256: int test_ret = 0;
50257:
50258: #if defined(LIBXML_XPATH_ENABLED)
50259: int mem_base;
50260: int ret_val;
50261: xmlXPathContextPtr ctxt; /* the XPath context */
50262: int n_ctxt;
50263: xmlChar * name; /* the variable name */
50264: int n_name;
50265: xmlChar * ns_uri; /* the variable namespace URI */
50266: int n_ns_uri;
50267: xmlXPathObjectPtr value; /* the variable value or NULL */
50268: int n_value;
50269:
50270: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
50271: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
50272: for (n_ns_uri = 0;n_ns_uri < gen_nb_const_xmlChar_ptr;n_ns_uri++) {
50273: for (n_value = 0;n_value < gen_nb_xmlXPathObjectPtr;n_value++) {
50274: mem_base = xmlMemBlocks();
50275: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
50276: name = gen_const_xmlChar_ptr(n_name, 1);
50277: ns_uri = gen_const_xmlChar_ptr(n_ns_uri, 2);
50278: value = gen_xmlXPathObjectPtr(n_value, 3);
50279:
50280: ret_val = xmlXPathRegisterVariableNS(ctxt, (const xmlChar *)name, (const xmlChar *)ns_uri, value);
50281: desret_int(ret_val);
50282: call_tests++;
50283: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
50284: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
50285: des_const_xmlChar_ptr(n_ns_uri, (const xmlChar *)ns_uri, 2);
50286: des_xmlXPathObjectPtr(n_value, value, 3);
50287: xmlResetLastError();
50288: if (mem_base != xmlMemBlocks()) {
50289: printf("Leak of %d blocks found in xmlXPathRegisterVariableNS",
50290: xmlMemBlocks() - mem_base);
50291: test_ret++;
50292: printf(" %d", n_ctxt);
50293: printf(" %d", n_name);
50294: printf(" %d", n_ns_uri);
50295: printf(" %d", n_value);
50296: printf("\n");
50297: }
50298: }
50299: }
50300: }
50301: }
50302: function_tests++;
50303: #endif
50304:
50305: return(test_ret);
50306: }
50307:
50308:
50309: static int
50310: test_xmlXPathRegisteredFuncsCleanup(void) {
50311: int test_ret = 0;
50312:
50313: #if defined(LIBXML_XPATH_ENABLED)
50314: int mem_base;
50315: xmlXPathContextPtr ctxt; /* the XPath context */
50316: int n_ctxt;
50317:
50318: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
50319: mem_base = xmlMemBlocks();
50320: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
50321:
50322: xmlXPathRegisteredFuncsCleanup(ctxt);
50323: call_tests++;
50324: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
50325: xmlResetLastError();
50326: if (mem_base != xmlMemBlocks()) {
50327: printf("Leak of %d blocks found in xmlXPathRegisteredFuncsCleanup",
50328: xmlMemBlocks() - mem_base);
50329: test_ret++;
50330: printf(" %d", n_ctxt);
50331: printf("\n");
50332: }
50333: }
50334: function_tests++;
50335: #endif
50336:
50337: return(test_ret);
50338: }
50339:
50340:
50341: static int
50342: test_xmlXPathRegisteredNsCleanup(void) {
50343: int test_ret = 0;
50344:
50345: #if defined(LIBXML_XPATH_ENABLED)
50346: int mem_base;
50347: xmlXPathContextPtr ctxt; /* the XPath context */
50348: int n_ctxt;
50349:
50350: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
50351: mem_base = xmlMemBlocks();
50352: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
50353:
50354: xmlXPathRegisteredNsCleanup(ctxt);
50355: call_tests++;
50356: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
50357: xmlResetLastError();
50358: if (mem_base != xmlMemBlocks()) {
50359: printf("Leak of %d blocks found in xmlXPathRegisteredNsCleanup",
50360: xmlMemBlocks() - mem_base);
50361: test_ret++;
50362: printf(" %d", n_ctxt);
50363: printf("\n");
50364: }
50365: }
50366: function_tests++;
50367: #endif
50368:
50369: return(test_ret);
50370: }
50371:
50372:
50373: static int
50374: test_xmlXPathRegisteredVariablesCleanup(void) {
50375: int test_ret = 0;
50376:
50377: #if defined(LIBXML_XPATH_ENABLED)
50378: int mem_base;
50379: xmlXPathContextPtr ctxt; /* the XPath context */
50380: int n_ctxt;
50381:
50382: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
50383: mem_base = xmlMemBlocks();
50384: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
50385:
50386: xmlXPathRegisteredVariablesCleanup(ctxt);
50387: call_tests++;
50388: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
50389: xmlResetLastError();
50390: if (mem_base != xmlMemBlocks()) {
50391: printf("Leak of %d blocks found in xmlXPathRegisteredVariablesCleanup",
50392: xmlMemBlocks() - mem_base);
50393: test_ret++;
50394: printf(" %d", n_ctxt);
50395: printf("\n");
50396: }
50397: }
50398: function_tests++;
50399: #endif
50400:
50401: return(test_ret);
50402: }
50403:
50404:
50405: static int
50406: test_xmlXPathRoot(void) {
50407: int test_ret = 0;
50408:
50409: #if defined(LIBXML_XPATH_ENABLED)
50410: int mem_base;
50411: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50412: int n_ctxt;
50413:
50414: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50415: mem_base = xmlMemBlocks();
50416: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50417:
50418: xmlXPathRoot(ctxt);
50419: call_tests++;
50420: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50421: xmlResetLastError();
50422: if (mem_base != xmlMemBlocks()) {
50423: printf("Leak of %d blocks found in xmlXPathRoot",
50424: xmlMemBlocks() - mem_base);
50425: test_ret++;
50426: printf(" %d", n_ctxt);
50427: printf("\n");
50428: }
50429: }
50430: function_tests++;
50431: #endif
50432:
50433: return(test_ret);
50434: }
50435:
50436:
50437: static int
50438: test_xmlXPathRoundFunction(void) {
50439: int test_ret = 0;
50440:
50441: #if defined(LIBXML_XPATH_ENABLED)
50442: int mem_base;
50443: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50444: int n_ctxt;
50445: int nargs; /* the number of arguments */
50446: int n_nargs;
50447:
50448: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50449: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50450: mem_base = xmlMemBlocks();
50451: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50452: nargs = gen_int(n_nargs, 1);
50453:
50454: xmlXPathRoundFunction(ctxt, nargs);
50455: call_tests++;
50456: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50457: des_int(n_nargs, nargs, 1);
50458: xmlResetLastError();
50459: if (mem_base != xmlMemBlocks()) {
50460: printf("Leak of %d blocks found in xmlXPathRoundFunction",
50461: xmlMemBlocks() - mem_base);
50462: test_ret++;
50463: printf(" %d", n_ctxt);
50464: printf(" %d", n_nargs);
50465: printf("\n");
50466: }
50467: }
50468: }
50469: function_tests++;
50470: #endif
50471:
50472: return(test_ret);
50473: }
50474:
50475:
50476: static int
50477: test_xmlXPathStartsWithFunction(void) {
50478: int test_ret = 0;
50479:
50480: #if defined(LIBXML_XPATH_ENABLED)
50481: int mem_base;
50482: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50483: int n_ctxt;
50484: int nargs; /* the number of arguments */
50485: int n_nargs;
50486:
50487: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50488: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50489: mem_base = xmlMemBlocks();
50490: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50491: nargs = gen_int(n_nargs, 1);
50492:
50493: xmlXPathStartsWithFunction(ctxt, nargs);
50494: call_tests++;
50495: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50496: des_int(n_nargs, nargs, 1);
50497: xmlResetLastError();
50498: if (mem_base != xmlMemBlocks()) {
50499: printf("Leak of %d blocks found in xmlXPathStartsWithFunction",
50500: xmlMemBlocks() - mem_base);
50501: test_ret++;
50502: printf(" %d", n_ctxt);
50503: printf(" %d", n_nargs);
50504: printf("\n");
50505: }
50506: }
50507: }
50508: function_tests++;
50509: #endif
50510:
50511: return(test_ret);
50512: }
50513:
50514:
50515: static int
50516: test_xmlXPathStringEvalNumber(void) {
50517: int test_ret = 0;
50518:
50519: #if defined(LIBXML_XPATH_ENABLED)
50520: int mem_base;
50521: double ret_val;
50522: xmlChar * str; /* A string to scan */
50523: int n_str;
50524:
50525: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
50526: mem_base = xmlMemBlocks();
50527: str = gen_const_xmlChar_ptr(n_str, 0);
50528:
50529: ret_val = xmlXPathStringEvalNumber((const xmlChar *)str);
50530: desret_double(ret_val);
50531: call_tests++;
50532: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
50533: xmlResetLastError();
50534: if (mem_base != xmlMemBlocks()) {
50535: printf("Leak of %d blocks found in xmlXPathStringEvalNumber",
50536: xmlMemBlocks() - mem_base);
50537: test_ret++;
50538: printf(" %d", n_str);
50539: printf("\n");
50540: }
50541: }
50542: function_tests++;
50543: #endif
50544:
50545: return(test_ret);
50546: }
50547:
50548:
50549: static int
50550: test_xmlXPathStringFunction(void) {
50551: int test_ret = 0;
50552:
50553: #if defined(LIBXML_XPATH_ENABLED)
50554: int mem_base;
50555: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50556: int n_ctxt;
50557: int nargs; /* the number of arguments */
50558: int n_nargs;
50559:
50560: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50561: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50562: mem_base = xmlMemBlocks();
50563: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50564: nargs = gen_int(n_nargs, 1);
50565:
50566: xmlXPathStringFunction(ctxt, nargs);
50567: call_tests++;
50568: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50569: des_int(n_nargs, nargs, 1);
50570: xmlResetLastError();
50571: if (mem_base != xmlMemBlocks()) {
50572: printf("Leak of %d blocks found in xmlXPathStringFunction",
50573: xmlMemBlocks() - mem_base);
50574: test_ret++;
50575: printf(" %d", n_ctxt);
50576: printf(" %d", n_nargs);
50577: printf("\n");
50578: }
50579: }
50580: }
50581: function_tests++;
50582: #endif
50583:
50584: return(test_ret);
50585: }
50586:
50587:
50588: static int
50589: test_xmlXPathStringLengthFunction(void) {
50590: int test_ret = 0;
50591:
50592: #if defined(LIBXML_XPATH_ENABLED)
50593: int mem_base;
50594: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50595: int n_ctxt;
50596: int nargs; /* the number of arguments */
50597: int n_nargs;
50598:
50599: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50600: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50601: mem_base = xmlMemBlocks();
50602: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50603: nargs = gen_int(n_nargs, 1);
50604:
50605: xmlXPathStringLengthFunction(ctxt, nargs);
50606: call_tests++;
50607: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50608: des_int(n_nargs, nargs, 1);
50609: xmlResetLastError();
50610: if (mem_base != xmlMemBlocks()) {
50611: printf("Leak of %d blocks found in xmlXPathStringLengthFunction",
50612: xmlMemBlocks() - mem_base);
50613: test_ret++;
50614: printf(" %d", n_ctxt);
50615: printf(" %d", n_nargs);
50616: printf("\n");
50617: }
50618: }
50619: }
50620: function_tests++;
50621: #endif
50622:
50623: return(test_ret);
50624: }
50625:
50626:
50627: static int
50628: test_xmlXPathSubValues(void) {
50629: int test_ret = 0;
50630:
50631: #if defined(LIBXML_XPATH_ENABLED)
50632: int mem_base;
50633: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50634: int n_ctxt;
50635:
50636: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50637: mem_base = xmlMemBlocks();
50638: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50639:
50640: xmlXPathSubValues(ctxt);
50641: call_tests++;
50642: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50643: xmlResetLastError();
50644: if (mem_base != xmlMemBlocks()) {
50645: printf("Leak of %d blocks found in xmlXPathSubValues",
50646: xmlMemBlocks() - mem_base);
50647: test_ret++;
50648: printf(" %d", n_ctxt);
50649: printf("\n");
50650: }
50651: }
50652: function_tests++;
50653: #endif
50654:
50655: return(test_ret);
50656: }
50657:
50658:
50659: static int
50660: test_xmlXPathSubstringAfterFunction(void) {
50661: int test_ret = 0;
50662:
50663: #if defined(LIBXML_XPATH_ENABLED)
50664: int mem_base;
50665: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50666: int n_ctxt;
50667: int nargs; /* the number of arguments */
50668: int n_nargs;
50669:
50670: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50671: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50672: mem_base = xmlMemBlocks();
50673: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50674: nargs = gen_int(n_nargs, 1);
50675:
50676: xmlXPathSubstringAfterFunction(ctxt, nargs);
50677: call_tests++;
50678: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50679: des_int(n_nargs, nargs, 1);
50680: xmlResetLastError();
50681: if (mem_base != xmlMemBlocks()) {
50682: printf("Leak of %d blocks found in xmlXPathSubstringAfterFunction",
50683: xmlMemBlocks() - mem_base);
50684: test_ret++;
50685: printf(" %d", n_ctxt);
50686: printf(" %d", n_nargs);
50687: printf("\n");
50688: }
50689: }
50690: }
50691: function_tests++;
50692: #endif
50693:
50694: return(test_ret);
50695: }
50696:
50697:
50698: static int
50699: test_xmlXPathSubstringBeforeFunction(void) {
50700: int test_ret = 0;
50701:
50702: #if defined(LIBXML_XPATH_ENABLED)
50703: int mem_base;
50704: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50705: int n_ctxt;
50706: int nargs; /* the number of arguments */
50707: int n_nargs;
50708:
50709: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50710: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50711: mem_base = xmlMemBlocks();
50712: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50713: nargs = gen_int(n_nargs, 1);
50714:
50715: xmlXPathSubstringBeforeFunction(ctxt, nargs);
50716: call_tests++;
50717: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50718: des_int(n_nargs, nargs, 1);
50719: xmlResetLastError();
50720: if (mem_base != xmlMemBlocks()) {
50721: printf("Leak of %d blocks found in xmlXPathSubstringBeforeFunction",
50722: xmlMemBlocks() - mem_base);
50723: test_ret++;
50724: printf(" %d", n_ctxt);
50725: printf(" %d", n_nargs);
50726: printf("\n");
50727: }
50728: }
50729: }
50730: function_tests++;
50731: #endif
50732:
50733: return(test_ret);
50734: }
50735:
50736:
50737: static int
50738: test_xmlXPathSubstringFunction(void) {
50739: int test_ret = 0;
50740:
50741: #if defined(LIBXML_XPATH_ENABLED)
50742: int mem_base;
50743: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50744: int n_ctxt;
50745: int nargs; /* the number of arguments */
50746: int n_nargs;
50747:
50748: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50749: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50750: mem_base = xmlMemBlocks();
50751: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50752: nargs = gen_int(n_nargs, 1);
50753:
50754: xmlXPathSubstringFunction(ctxt, nargs);
50755: call_tests++;
50756: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50757: des_int(n_nargs, nargs, 1);
50758: xmlResetLastError();
50759: if (mem_base != xmlMemBlocks()) {
50760: printf("Leak of %d blocks found in xmlXPathSubstringFunction",
50761: xmlMemBlocks() - mem_base);
50762: test_ret++;
50763: printf(" %d", n_ctxt);
50764: printf(" %d", n_nargs);
50765: printf("\n");
50766: }
50767: }
50768: }
50769: function_tests++;
50770: #endif
50771:
50772: return(test_ret);
50773: }
50774:
50775:
50776: static int
50777: test_xmlXPathSumFunction(void) {
50778: int test_ret = 0;
50779:
50780: #if defined(LIBXML_XPATH_ENABLED)
50781: int mem_base;
50782: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50783: int n_ctxt;
50784: int nargs; /* the number of arguments */
50785: int n_nargs;
50786:
50787: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50788: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50789: mem_base = xmlMemBlocks();
50790: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50791: nargs = gen_int(n_nargs, 1);
50792:
50793: xmlXPathSumFunction(ctxt, nargs);
50794: call_tests++;
50795: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50796: des_int(n_nargs, nargs, 1);
50797: xmlResetLastError();
50798: if (mem_base != xmlMemBlocks()) {
50799: printf("Leak of %d blocks found in xmlXPathSumFunction",
50800: xmlMemBlocks() - mem_base);
50801: test_ret++;
50802: printf(" %d", n_ctxt);
50803: printf(" %d", n_nargs);
50804: printf("\n");
50805: }
50806: }
50807: }
50808: function_tests++;
50809: #endif
50810:
50811: return(test_ret);
50812: }
50813:
50814:
50815: static int
50816: test_xmlXPathTrailing(void) {
50817: int test_ret = 0;
50818:
50819: #if defined(LIBXML_XPATH_ENABLED)
50820: int mem_base;
50821: xmlNodeSetPtr ret_val;
50822: xmlNodeSetPtr nodes1; /* a node-set */
50823: int n_nodes1;
50824: xmlNodeSetPtr nodes2; /* a node-set */
50825: int n_nodes2;
50826:
50827: for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
50828: for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
50829: mem_base = xmlMemBlocks();
50830: nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
50831: nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
50832:
50833: ret_val = xmlXPathTrailing(nodes1, nodes2);
50834: desret_xmlNodeSetPtr(ret_val);
50835: call_tests++;
50836: des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
50837: des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
50838: xmlResetLastError();
50839: if (mem_base != xmlMemBlocks()) {
50840: printf("Leak of %d blocks found in xmlXPathTrailing",
50841: xmlMemBlocks() - mem_base);
50842: test_ret++;
50843: printf(" %d", n_nodes1);
50844: printf(" %d", n_nodes2);
50845: printf("\n");
50846: }
50847: }
50848: }
50849: function_tests++;
50850: #endif
50851:
50852: return(test_ret);
50853: }
50854:
50855:
50856: static int
50857: test_xmlXPathTrailingSorted(void) {
50858: int test_ret = 0;
50859:
50860: #if defined(LIBXML_XPATH_ENABLED)
50861: int mem_base;
50862: xmlNodeSetPtr ret_val;
50863: xmlNodeSetPtr nodes1; /* a node-set, sorted by document order */
50864: int n_nodes1;
50865: xmlNodeSetPtr nodes2; /* a node-set, sorted by document order */
50866: int n_nodes2;
50867:
50868: for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
50869: for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
50870: mem_base = xmlMemBlocks();
50871: nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
50872: nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
50873:
50874: ret_val = xmlXPathTrailingSorted(nodes1, nodes2);
50875: desret_xmlNodeSetPtr(ret_val);
50876: call_tests++;
50877: des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
50878: des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
50879: xmlResetLastError();
50880: if (mem_base != xmlMemBlocks()) {
50881: printf("Leak of %d blocks found in xmlXPathTrailingSorted",
50882: xmlMemBlocks() - mem_base);
50883: test_ret++;
50884: printf(" %d", n_nodes1);
50885: printf(" %d", n_nodes2);
50886: printf("\n");
50887: }
50888: }
50889: }
50890: function_tests++;
50891: #endif
50892:
50893: return(test_ret);
50894: }
50895:
50896:
50897: static int
50898: test_xmlXPathTranslateFunction(void) {
50899: int test_ret = 0;
50900:
50901: #if defined(LIBXML_XPATH_ENABLED)
50902: int mem_base;
50903: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50904: int n_ctxt;
50905: int nargs; /* the number of arguments */
50906: int n_nargs;
50907:
50908: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50909: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50910: mem_base = xmlMemBlocks();
50911: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50912: nargs = gen_int(n_nargs, 1);
50913:
50914: xmlXPathTranslateFunction(ctxt, nargs);
50915: call_tests++;
50916: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50917: des_int(n_nargs, nargs, 1);
50918: xmlResetLastError();
50919: if (mem_base != xmlMemBlocks()) {
50920: printf("Leak of %d blocks found in xmlXPathTranslateFunction",
50921: xmlMemBlocks() - mem_base);
50922: test_ret++;
50923: printf(" %d", n_ctxt);
50924: printf(" %d", n_nargs);
50925: printf("\n");
50926: }
50927: }
50928: }
50929: function_tests++;
50930: #endif
50931:
50932: return(test_ret);
50933: }
50934:
50935:
50936: static int
50937: test_xmlXPathTrueFunction(void) {
50938: int test_ret = 0;
50939:
50940: #if defined(LIBXML_XPATH_ENABLED)
50941: int mem_base;
50942: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50943: int n_ctxt;
50944: int nargs; /* the number of arguments */
50945: int n_nargs;
50946:
50947: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50948: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50949: mem_base = xmlMemBlocks();
50950: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50951: nargs = gen_int(n_nargs, 1);
50952:
50953: xmlXPathTrueFunction(ctxt, nargs);
50954: call_tests++;
50955: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50956: des_int(n_nargs, nargs, 1);
50957: xmlResetLastError();
50958: if (mem_base != xmlMemBlocks()) {
50959: printf("Leak of %d blocks found in xmlXPathTrueFunction",
50960: xmlMemBlocks() - mem_base);
50961: test_ret++;
50962: printf(" %d", n_ctxt);
50963: printf(" %d", n_nargs);
50964: printf("\n");
50965: }
50966: }
50967: }
50968: function_tests++;
50969: #endif
50970:
50971: return(test_ret);
50972: }
50973:
50974:
50975: static int
50976: test_xmlXPathValueFlipSign(void) {
50977: int test_ret = 0;
50978:
50979: #if defined(LIBXML_XPATH_ENABLED)
50980: int mem_base;
50981: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50982: int n_ctxt;
50983:
50984: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50985: mem_base = xmlMemBlocks();
50986: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50987:
50988: xmlXPathValueFlipSign(ctxt);
50989: call_tests++;
50990: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50991: xmlResetLastError();
50992: if (mem_base != xmlMemBlocks()) {
50993: printf("Leak of %d blocks found in xmlXPathValueFlipSign",
50994: xmlMemBlocks() - mem_base);
50995: test_ret++;
50996: printf(" %d", n_ctxt);
50997: printf("\n");
50998: }
50999: }
51000: function_tests++;
51001: #endif
51002:
51003: return(test_ret);
51004: }
51005:
51006:
51007: static int
51008: test_xmlXPathVariableLookup(void) {
51009: int test_ret = 0;
51010:
51011: #if defined(LIBXML_XPATH_ENABLED)
51012: int mem_base;
51013: xmlXPathObjectPtr ret_val;
51014: xmlXPathContextPtr ctxt; /* the XPath context */
51015: int n_ctxt;
51016: xmlChar * name; /* the variable name */
51017: int n_name;
51018:
51019: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
51020: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
51021: mem_base = xmlMemBlocks();
51022: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
51023: name = gen_const_xmlChar_ptr(n_name, 1);
51024:
51025: ret_val = xmlXPathVariableLookup(ctxt, (const xmlChar *)name);
51026: desret_xmlXPathObjectPtr(ret_val);
51027: call_tests++;
51028: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
51029: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
51030: xmlResetLastError();
51031: if (mem_base != xmlMemBlocks()) {
51032: printf("Leak of %d blocks found in xmlXPathVariableLookup",
51033: xmlMemBlocks() - mem_base);
51034: test_ret++;
51035: printf(" %d", n_ctxt);
51036: printf(" %d", n_name);
51037: printf("\n");
51038: }
51039: }
51040: }
51041: function_tests++;
51042: #endif
51043:
51044: return(test_ret);
51045: }
51046:
51047:
51048: static int
51049: test_xmlXPathVariableLookupNS(void) {
51050: int test_ret = 0;
51051:
51052: #if defined(LIBXML_XPATH_ENABLED)
51053: int mem_base;
51054: xmlXPathObjectPtr ret_val;
51055: xmlXPathContextPtr ctxt; /* the XPath context */
51056: int n_ctxt;
51057: xmlChar * name; /* the variable name */
51058: int n_name;
51059: xmlChar * ns_uri; /* the variable namespace URI */
51060: int n_ns_uri;
51061:
51062: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
51063: for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
51064: for (n_ns_uri = 0;n_ns_uri < gen_nb_const_xmlChar_ptr;n_ns_uri++) {
51065: mem_base = xmlMemBlocks();
51066: ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
51067: name = gen_const_xmlChar_ptr(n_name, 1);
51068: ns_uri = gen_const_xmlChar_ptr(n_ns_uri, 2);
51069:
51070: ret_val = xmlXPathVariableLookupNS(ctxt, (const xmlChar *)name, (const xmlChar *)ns_uri);
51071: desret_xmlXPathObjectPtr(ret_val);
51072: call_tests++;
51073: des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
51074: des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
51075: des_const_xmlChar_ptr(n_ns_uri, (const xmlChar *)ns_uri, 2);
51076: xmlResetLastError();
51077: if (mem_base != xmlMemBlocks()) {
51078: printf("Leak of %d blocks found in xmlXPathVariableLookupNS",
51079: xmlMemBlocks() - mem_base);
51080: test_ret++;
51081: printf(" %d", n_ctxt);
51082: printf(" %d", n_name);
51083: printf(" %d", n_ns_uri);
51084: printf("\n");
51085: }
51086: }
51087: }
51088: }
51089: function_tests++;
51090: #endif
51091:
51092: return(test_ret);
51093: }
51094:
51095:
51096: static int
51097: test_xmlXPathWrapCString(void) {
51098: int test_ret = 0;
51099:
51100: #if defined(LIBXML_XPATH_ENABLED)
51101: int mem_base;
51102: xmlXPathObjectPtr ret_val;
51103: char * val; /* the char * value */
51104: int n_val;
51105:
51106: for (n_val = 0;n_val < gen_nb_char_ptr;n_val++) {
51107: mem_base = xmlMemBlocks();
51108: val = gen_char_ptr(n_val, 0);
51109:
51110: ret_val = xmlXPathWrapCString(val);
51111: desret_xmlXPathObjectPtr(ret_val);
51112: call_tests++;
51113: des_char_ptr(n_val, val, 0);
51114: xmlResetLastError();
51115: if (mem_base != xmlMemBlocks()) {
51116: printf("Leak of %d blocks found in xmlXPathWrapCString",
51117: xmlMemBlocks() - mem_base);
51118: test_ret++;
51119: printf(" %d", n_val);
51120: printf("\n");
51121: }
51122: }
51123: function_tests++;
51124: #endif
51125:
51126: return(test_ret);
51127: }
51128:
51129:
51130: static int
51131: test_xmlXPathWrapExternal(void) {
51132: int test_ret = 0;
51133:
51134: #if defined(LIBXML_XPATH_ENABLED)
51135: int mem_base;
51136: xmlXPathObjectPtr ret_val;
51137: void * val; /* the user data */
51138: int n_val;
51139:
51140: for (n_val = 0;n_val < gen_nb_void_ptr;n_val++) {
51141: mem_base = xmlMemBlocks();
51142: val = gen_void_ptr(n_val, 0);
51143:
51144: ret_val = xmlXPathWrapExternal(val);
51145: desret_xmlXPathObjectPtr(ret_val);
51146: call_tests++;
51147: des_void_ptr(n_val, val, 0);
51148: xmlResetLastError();
51149: if (mem_base != xmlMemBlocks()) {
51150: printf("Leak of %d blocks found in xmlXPathWrapExternal",
51151: xmlMemBlocks() - mem_base);
51152: test_ret++;
51153: printf(" %d", n_val);
51154: printf("\n");
51155: }
51156: }
51157: function_tests++;
51158: #endif
51159:
51160: return(test_ret);
51161: }
51162:
51163:
51164: static int
51165: test_xmlXPathWrapNodeSet(void) {
51166: int test_ret = 0;
51167:
51168: #if defined(LIBXML_XPATH_ENABLED)
51169: int mem_base;
51170: xmlXPathObjectPtr ret_val;
51171: xmlNodeSetPtr val; /* the NodePtr value */
51172: int n_val;
51173:
51174: for (n_val = 0;n_val < gen_nb_xmlNodeSetPtr;n_val++) {
51175: mem_base = xmlMemBlocks();
51176: val = gen_xmlNodeSetPtr(n_val, 0);
51177:
51178: ret_val = xmlXPathWrapNodeSet(val);
51179: desret_xmlXPathObjectPtr(ret_val);
51180: call_tests++;
51181: des_xmlNodeSetPtr(n_val, val, 0);
51182: xmlResetLastError();
51183: if (mem_base != xmlMemBlocks()) {
51184: printf("Leak of %d blocks found in xmlXPathWrapNodeSet",
51185: xmlMemBlocks() - mem_base);
51186: test_ret++;
51187: printf(" %d", n_val);
51188: printf("\n");
51189: }
51190: }
51191: function_tests++;
51192: #endif
51193:
51194: return(test_ret);
51195: }
51196:
51197:
51198: static int
51199: test_xmlXPatherror(void) {
51200: int test_ret = 0;
51201:
51202: #if defined(LIBXML_XPATH_ENABLED)
51203: int mem_base;
51204: xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
51205: int n_ctxt;
51206: const char * file; /* the file name */
51207: int n_file;
51208: int line; /* the line number */
51209: int n_line;
51210: int no; /* the error number */
51211: int n_no;
51212:
51213: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
51214: for (n_file = 0;n_file < gen_nb_filepath;n_file++) {
51215: for (n_line = 0;n_line < gen_nb_int;n_line++) {
51216: for (n_no = 0;n_no < gen_nb_int;n_no++) {
51217: mem_base = xmlMemBlocks();
51218: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
51219: file = gen_filepath(n_file, 1);
51220: line = gen_int(n_line, 2);
51221: no = gen_int(n_no, 3);
51222:
51223: xmlXPatherror(ctxt, file, line, no);
51224: call_tests++;
51225: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
51226: des_filepath(n_file, file, 1);
51227: des_int(n_line, line, 2);
51228: des_int(n_no, no, 3);
51229: xmlResetLastError();
51230: if (mem_base != xmlMemBlocks()) {
51231: printf("Leak of %d blocks found in xmlXPatherror",
51232: xmlMemBlocks() - mem_base);
51233: test_ret++;
51234: printf(" %d", n_ctxt);
51235: printf(" %d", n_file);
51236: printf(" %d", n_line);
51237: printf(" %d", n_no);
51238: printf("\n");
51239: }
51240: }
51241: }
51242: }
51243: }
51244: function_tests++;
51245: #endif
51246:
51247: return(test_ret);
51248: }
51249:
51250: static int
51251: test_xpathInternals(void) {
51252: int test_ret = 0;
51253:
51254: if (quiet == 0) printf("Testing xpathInternals : 106 of 117 functions ...\n");
51255: test_ret += test_valuePop();
51256: test_ret += test_valuePush();
51257: test_ret += test_xmlXPathAddValues();
51258: test_ret += test_xmlXPathBooleanFunction();
51259: test_ret += test_xmlXPathCeilingFunction();
51260: test_ret += test_xmlXPathCompareValues();
51261: test_ret += test_xmlXPathConcatFunction();
51262: test_ret += test_xmlXPathContainsFunction();
51263: test_ret += test_xmlXPathCountFunction();
51264: test_ret += test_xmlXPathDebugDumpCompExpr();
51265: test_ret += test_xmlXPathDebugDumpObject();
51266: test_ret += test_xmlXPathDifference();
51267: test_ret += test_xmlXPathDistinct();
51268: test_ret += test_xmlXPathDistinctSorted();
51269: test_ret += test_xmlXPathDivValues();
51270: test_ret += test_xmlXPathEqualValues();
51271: test_ret += test_xmlXPathErr();
51272: test_ret += test_xmlXPathEvalExpr();
51273: test_ret += test_xmlXPathEvaluatePredicateResult();
51274: test_ret += test_xmlXPathFalseFunction();
51275: test_ret += test_xmlXPathFloorFunction();
51276: test_ret += test_xmlXPathFunctionLookup();
51277: test_ret += test_xmlXPathFunctionLookupNS();
51278: test_ret += test_xmlXPathHasSameNodes();
51279: test_ret += test_xmlXPathIdFunction();
51280: test_ret += test_xmlXPathIntersection();
51281: test_ret += test_xmlXPathIsNodeType();
51282: test_ret += test_xmlXPathLangFunction();
51283: test_ret += test_xmlXPathLastFunction();
51284: test_ret += test_xmlXPathLeading();
51285: test_ret += test_xmlXPathLeadingSorted();
51286: test_ret += test_xmlXPathLocalNameFunction();
51287: test_ret += test_xmlXPathModValues();
51288: test_ret += test_xmlXPathMultValues();
51289: test_ret += test_xmlXPathNamespaceURIFunction();
51290: test_ret += test_xmlXPathNewBoolean();
51291: test_ret += test_xmlXPathNewCString();
51292: test_ret += test_xmlXPathNewFloat();
51293: test_ret += test_xmlXPathNewNodeSet();
51294: test_ret += test_xmlXPathNewNodeSetList();
51295: test_ret += test_xmlXPathNewParserContext();
51296: test_ret += test_xmlXPathNewString();
51297: test_ret += test_xmlXPathNextAncestor();
51298: test_ret += test_xmlXPathNextAncestorOrSelf();
51299: test_ret += test_xmlXPathNextAttribute();
51300: test_ret += test_xmlXPathNextChild();
51301: test_ret += test_xmlXPathNextDescendant();
51302: test_ret += test_xmlXPathNextDescendantOrSelf();
51303: test_ret += test_xmlXPathNextFollowing();
51304: test_ret += test_xmlXPathNextFollowingSibling();
51305: test_ret += test_xmlXPathNextNamespace();
51306: test_ret += test_xmlXPathNextParent();
51307: test_ret += test_xmlXPathNextPreceding();
51308: test_ret += test_xmlXPathNextPrecedingSibling();
51309: test_ret += test_xmlXPathNextSelf();
51310: test_ret += test_xmlXPathNodeLeading();
51311: test_ret += test_xmlXPathNodeLeadingSorted();
51312: test_ret += test_xmlXPathNodeSetAdd();
51313: test_ret += test_xmlXPathNodeSetAddNs();
51314: test_ret += test_xmlXPathNodeSetAddUnique();
51315: test_ret += test_xmlXPathNodeSetContains();
51316: test_ret += test_xmlXPathNodeSetDel();
51317: test_ret += test_xmlXPathNodeSetMerge();
51318: test_ret += test_xmlXPathNodeSetRemove();
51319: test_ret += test_xmlXPathNodeSetSort();
51320: test_ret += test_xmlXPathNodeTrailing();
51321: test_ret += test_xmlXPathNodeTrailingSorted();
51322: test_ret += test_xmlXPathNormalizeFunction();
51323: test_ret += test_xmlXPathNotEqualValues();
51324: test_ret += test_xmlXPathNotFunction();
51325: test_ret += test_xmlXPathNsLookup();
51326: test_ret += test_xmlXPathNumberFunction();
51327: test_ret += test_xmlXPathParseNCName();
51328: test_ret += test_xmlXPathParseName();
51329: test_ret += test_xmlXPathPopBoolean();
51330: test_ret += test_xmlXPathPopExternal();
51331: test_ret += test_xmlXPathPopNodeSet();
51332: test_ret += test_xmlXPathPopNumber();
51333: test_ret += test_xmlXPathPopString();
51334: test_ret += test_xmlXPathPositionFunction();
51335: test_ret += test_xmlXPathRegisterAllFunctions();
51336: test_ret += test_xmlXPathRegisterFunc();
51337: test_ret += test_xmlXPathRegisterFuncLookup();
51338: test_ret += test_xmlXPathRegisterFuncNS();
51339: test_ret += test_xmlXPathRegisterNs();
51340: test_ret += test_xmlXPathRegisterVariable();
51341: test_ret += test_xmlXPathRegisterVariableLookup();
51342: test_ret += test_xmlXPathRegisterVariableNS();
51343: test_ret += test_xmlXPathRegisteredFuncsCleanup();
51344: test_ret += test_xmlXPathRegisteredNsCleanup();
51345: test_ret += test_xmlXPathRegisteredVariablesCleanup();
51346: test_ret += test_xmlXPathRoot();
51347: test_ret += test_xmlXPathRoundFunction();
51348: test_ret += test_xmlXPathStartsWithFunction();
51349: test_ret += test_xmlXPathStringEvalNumber();
51350: test_ret += test_xmlXPathStringFunction();
51351: test_ret += test_xmlXPathStringLengthFunction();
51352: test_ret += test_xmlXPathSubValues();
51353: test_ret += test_xmlXPathSubstringAfterFunction();
51354: test_ret += test_xmlXPathSubstringBeforeFunction();
51355: test_ret += test_xmlXPathSubstringFunction();
51356: test_ret += test_xmlXPathSumFunction();
51357: test_ret += test_xmlXPathTrailing();
51358: test_ret += test_xmlXPathTrailingSorted();
51359: test_ret += test_xmlXPathTranslateFunction();
51360: test_ret += test_xmlXPathTrueFunction();
51361: test_ret += test_xmlXPathValueFlipSign();
51362: test_ret += test_xmlXPathVariableLookup();
51363: test_ret += test_xmlXPathVariableLookupNS();
51364: test_ret += test_xmlXPathWrapCString();
51365: test_ret += test_xmlXPathWrapExternal();
51366: test_ret += test_xmlXPathWrapNodeSet();
51367: test_ret += test_xmlXPatherror();
51368:
51369: if (test_ret != 0)
51370: printf("Module xpathInternals: %d errors\n", test_ret);
51371: return(test_ret);
51372: }
51373:
51374: static int
51375: test_xmlXPtrBuildNodeList(void) {
51376: int test_ret = 0;
51377:
51378: #if defined(LIBXML_XPTR_ENABLED)
51379: int mem_base;
51380: xmlNodePtr ret_val;
51381: xmlXPathObjectPtr obj; /* the XPointer result from the evaluation. */
51382: int n_obj;
51383:
51384: for (n_obj = 0;n_obj < gen_nb_xmlXPathObjectPtr;n_obj++) {
51385: mem_base = xmlMemBlocks();
51386: obj = gen_xmlXPathObjectPtr(n_obj, 0);
51387:
51388: ret_val = xmlXPtrBuildNodeList(obj);
51389: desret_xmlNodePtr(ret_val);
51390: call_tests++;
51391: des_xmlXPathObjectPtr(n_obj, obj, 0);
51392: xmlResetLastError();
51393: if (mem_base != xmlMemBlocks()) {
51394: printf("Leak of %d blocks found in xmlXPtrBuildNodeList",
51395: xmlMemBlocks() - mem_base);
51396: test_ret++;
51397: printf(" %d", n_obj);
51398: printf("\n");
51399: }
51400: }
51401: function_tests++;
51402: #endif
51403:
51404: return(test_ret);
51405: }
51406:
51407:
51408: static int
51409: test_xmlXPtrEval(void) {
51410: int test_ret = 0;
51411:
51412: #if defined(LIBXML_XPTR_ENABLED)
51413: int mem_base;
51414: xmlXPathObjectPtr ret_val;
51415: xmlChar * str; /* the XPointer expression */
51416: int n_str;
51417: xmlXPathContextPtr ctx; /* the XPointer context */
51418: int n_ctx;
51419:
51420: for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
51421: for (n_ctx = 0;n_ctx < gen_nb_xmlXPathContextPtr;n_ctx++) {
51422: mem_base = xmlMemBlocks();
51423: str = gen_const_xmlChar_ptr(n_str, 0);
51424: ctx = gen_xmlXPathContextPtr(n_ctx, 1);
51425:
51426: ret_val = xmlXPtrEval((const xmlChar *)str, ctx);
51427: desret_xmlXPathObjectPtr(ret_val);
51428: call_tests++;
51429: des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
51430: des_xmlXPathContextPtr(n_ctx, ctx, 1);
51431: xmlResetLastError();
51432: if (mem_base != xmlMemBlocks()) {
51433: printf("Leak of %d blocks found in xmlXPtrEval",
51434: xmlMemBlocks() - mem_base);
51435: test_ret++;
51436: printf(" %d", n_str);
51437: printf(" %d", n_ctx);
51438: printf("\n");
51439: }
51440: }
51441: }
51442: function_tests++;
51443: #endif
51444:
51445: return(test_ret);
51446: }
51447:
51448:
51449: static int
51450: test_xmlXPtrEvalRangePredicate(void) {
51451: int test_ret = 0;
51452:
51453: #if defined(LIBXML_XPTR_ENABLED)
51454: int mem_base;
51455: xmlXPathParserContextPtr ctxt; /* the XPointer Parser context */
51456: int n_ctxt;
51457:
51458: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
51459: mem_base = xmlMemBlocks();
51460: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
51461:
51462: xmlXPtrEvalRangePredicate(ctxt);
51463: call_tests++;
51464: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
51465: xmlResetLastError();
51466: if (mem_base != xmlMemBlocks()) {
51467: printf("Leak of %d blocks found in xmlXPtrEvalRangePredicate",
51468: xmlMemBlocks() - mem_base);
51469: test_ret++;
51470: printf(" %d", n_ctxt);
51471: printf("\n");
51472: }
51473: }
51474: function_tests++;
51475: #endif
51476:
51477: return(test_ret);
51478: }
51479:
51480: #ifdef LIBXML_XPTR_ENABLED
51481:
51482: #define gen_nb_xmlLocationSetPtr 1
51483: static xmlLocationSetPtr gen_xmlLocationSetPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
51484: return(NULL);
51485: }
51486: static void des_xmlLocationSetPtr(int no ATTRIBUTE_UNUSED, xmlLocationSetPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
51487: }
51488: #endif
51489:
51490:
51491: static int
51492: test_xmlXPtrLocationSetAdd(void) {
51493: int test_ret = 0;
51494:
51495: #if defined(LIBXML_XPTR_ENABLED)
51496: int mem_base;
51497: xmlLocationSetPtr cur; /* the initial range set */
51498: int n_cur;
51499: xmlXPathObjectPtr val; /* a new xmlXPathObjectPtr */
51500: int n_val;
51501:
51502: for (n_cur = 0;n_cur < gen_nb_xmlLocationSetPtr;n_cur++) {
51503: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
51504: mem_base = xmlMemBlocks();
51505: cur = gen_xmlLocationSetPtr(n_cur, 0);
51506: val = gen_xmlXPathObjectPtr(n_val, 1);
51507:
51508: xmlXPtrLocationSetAdd(cur, val);
51509: call_tests++;
51510: des_xmlLocationSetPtr(n_cur, cur, 0);
51511: des_xmlXPathObjectPtr(n_val, val, 1);
51512: xmlResetLastError();
51513: if (mem_base != xmlMemBlocks()) {
51514: printf("Leak of %d blocks found in xmlXPtrLocationSetAdd",
51515: xmlMemBlocks() - mem_base);
51516: test_ret++;
51517: printf(" %d", n_cur);
51518: printf(" %d", n_val);
51519: printf("\n");
51520: }
51521: }
51522: }
51523: function_tests++;
51524: #endif
51525:
51526: return(test_ret);
51527: }
51528:
51529:
51530: static int
51531: test_xmlXPtrLocationSetCreate(void) {
51532: int test_ret = 0;
51533:
51534:
51535: /* missing type support */
51536: return(test_ret);
51537: }
51538:
51539:
51540: static int
51541: test_xmlXPtrLocationSetDel(void) {
51542: int test_ret = 0;
51543:
51544: #if defined(LIBXML_XPTR_ENABLED)
51545: int mem_base;
51546: xmlLocationSetPtr cur; /* the initial range set */
51547: int n_cur;
51548: xmlXPathObjectPtr val; /* an xmlXPathObjectPtr */
51549: int n_val;
51550:
51551: for (n_cur = 0;n_cur < gen_nb_xmlLocationSetPtr;n_cur++) {
51552: for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
51553: mem_base = xmlMemBlocks();
51554: cur = gen_xmlLocationSetPtr(n_cur, 0);
51555: val = gen_xmlXPathObjectPtr(n_val, 1);
51556:
51557: xmlXPtrLocationSetDel(cur, val);
51558: call_tests++;
51559: des_xmlLocationSetPtr(n_cur, cur, 0);
51560: des_xmlXPathObjectPtr(n_val, val, 1);
51561: xmlResetLastError();
51562: if (mem_base != xmlMemBlocks()) {
51563: printf("Leak of %d blocks found in xmlXPtrLocationSetDel",
51564: xmlMemBlocks() - mem_base);
51565: test_ret++;
51566: printf(" %d", n_cur);
51567: printf(" %d", n_val);
51568: printf("\n");
51569: }
51570: }
51571: }
51572: function_tests++;
51573: #endif
51574:
51575: return(test_ret);
51576: }
51577:
51578:
51579: static int
51580: test_xmlXPtrLocationSetMerge(void) {
51581: int test_ret = 0;
51582:
51583:
51584: /* missing type support */
51585: return(test_ret);
51586: }
51587:
51588:
51589: static int
51590: test_xmlXPtrLocationSetRemove(void) {
51591: int test_ret = 0;
51592:
51593: #if defined(LIBXML_XPTR_ENABLED)
51594: int mem_base;
51595: xmlLocationSetPtr cur; /* the initial range set */
51596: int n_cur;
51597: int val; /* the index to remove */
51598: int n_val;
51599:
51600: for (n_cur = 0;n_cur < gen_nb_xmlLocationSetPtr;n_cur++) {
51601: for (n_val = 0;n_val < gen_nb_int;n_val++) {
51602: mem_base = xmlMemBlocks();
51603: cur = gen_xmlLocationSetPtr(n_cur, 0);
51604: val = gen_int(n_val, 1);
51605:
51606: xmlXPtrLocationSetRemove(cur, val);
51607: call_tests++;
51608: des_xmlLocationSetPtr(n_cur, cur, 0);
51609: des_int(n_val, val, 1);
51610: xmlResetLastError();
51611: if (mem_base != xmlMemBlocks()) {
51612: printf("Leak of %d blocks found in xmlXPtrLocationSetRemove",
51613: xmlMemBlocks() - mem_base);
51614: test_ret++;
51615: printf(" %d", n_cur);
51616: printf(" %d", n_val);
51617: printf("\n");
51618: }
51619: }
51620: }
51621: function_tests++;
51622: #endif
51623:
51624: return(test_ret);
51625: }
51626:
51627:
51628: static int
51629: test_xmlXPtrNewCollapsedRange(void) {
51630: int test_ret = 0;
51631:
51632: #if defined(LIBXML_XPTR_ENABLED)
51633: int mem_base;
51634: xmlXPathObjectPtr ret_val;
51635: xmlNodePtr start; /* the starting and ending node */
51636: int n_start;
51637:
51638: for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
51639: mem_base = xmlMemBlocks();
51640: start = gen_xmlNodePtr(n_start, 0);
51641:
51642: ret_val = xmlXPtrNewCollapsedRange(start);
51643: desret_xmlXPathObjectPtr(ret_val);
51644: call_tests++;
51645: des_xmlNodePtr(n_start, start, 0);
51646: xmlResetLastError();
51647: if (mem_base != xmlMemBlocks()) {
51648: printf("Leak of %d blocks found in xmlXPtrNewCollapsedRange",
51649: xmlMemBlocks() - mem_base);
51650: test_ret++;
51651: printf(" %d", n_start);
51652: printf("\n");
51653: }
51654: }
51655: function_tests++;
51656: #endif
51657:
51658: return(test_ret);
51659: }
51660:
51661:
51662: static int
51663: test_xmlXPtrNewContext(void) {
51664: int test_ret = 0;
51665:
51666:
51667: /* missing type support */
51668: return(test_ret);
51669: }
51670:
51671:
51672: static int
51673: test_xmlXPtrNewLocationSetNodeSet(void) {
51674: int test_ret = 0;
51675:
51676: #if defined(LIBXML_XPTR_ENABLED)
51677: int mem_base;
51678: xmlXPathObjectPtr ret_val;
51679: xmlNodeSetPtr set; /* a node set */
51680: int n_set;
51681:
51682: for (n_set = 0;n_set < gen_nb_xmlNodeSetPtr;n_set++) {
51683: mem_base = xmlMemBlocks();
51684: set = gen_xmlNodeSetPtr(n_set, 0);
51685:
51686: ret_val = xmlXPtrNewLocationSetNodeSet(set);
51687: desret_xmlXPathObjectPtr(ret_val);
51688: call_tests++;
51689: des_xmlNodeSetPtr(n_set, set, 0);
51690: xmlResetLastError();
51691: if (mem_base != xmlMemBlocks()) {
51692: printf("Leak of %d blocks found in xmlXPtrNewLocationSetNodeSet",
51693: xmlMemBlocks() - mem_base);
51694: test_ret++;
51695: printf(" %d", n_set);
51696: printf("\n");
51697: }
51698: }
51699: function_tests++;
51700: #endif
51701:
51702: return(test_ret);
51703: }
51704:
51705:
51706: static int
51707: test_xmlXPtrNewLocationSetNodes(void) {
51708: int test_ret = 0;
51709:
51710: #if defined(LIBXML_XPTR_ENABLED)
51711: int mem_base;
51712: xmlXPathObjectPtr ret_val;
51713: xmlNodePtr start; /* the start NodePtr value */
51714: int n_start;
51715: xmlNodePtr end; /* the end NodePtr value or NULL */
51716: int n_end;
51717:
51718: for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
51719: for (n_end = 0;n_end < gen_nb_xmlNodePtr;n_end++) {
51720: mem_base = xmlMemBlocks();
51721: start = gen_xmlNodePtr(n_start, 0);
51722: end = gen_xmlNodePtr(n_end, 1);
51723:
51724: ret_val = xmlXPtrNewLocationSetNodes(start, end);
51725: desret_xmlXPathObjectPtr(ret_val);
51726: call_tests++;
51727: des_xmlNodePtr(n_start, start, 0);
51728: des_xmlNodePtr(n_end, end, 1);
51729: xmlResetLastError();
51730: if (mem_base != xmlMemBlocks()) {
51731: printf("Leak of %d blocks found in xmlXPtrNewLocationSetNodes",
51732: xmlMemBlocks() - mem_base);
51733: test_ret++;
51734: printf(" %d", n_start);
51735: printf(" %d", n_end);
51736: printf("\n");
51737: }
51738: }
51739: }
51740: function_tests++;
51741: #endif
51742:
51743: return(test_ret);
51744: }
51745:
51746:
51747: static int
51748: test_xmlXPtrNewRange(void) {
51749: int test_ret = 0;
51750:
51751: #if defined(LIBXML_XPTR_ENABLED)
51752: int mem_base;
51753: xmlXPathObjectPtr ret_val;
51754: xmlNodePtr start; /* the starting node */
51755: int n_start;
51756: int startindex; /* the start index */
51757: int n_startindex;
51758: xmlNodePtr end; /* the ending point */
51759: int n_end;
51760: int endindex; /* the ending index */
51761: int n_endindex;
51762:
51763: for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
51764: for (n_startindex = 0;n_startindex < gen_nb_int;n_startindex++) {
51765: for (n_end = 0;n_end < gen_nb_xmlNodePtr;n_end++) {
51766: for (n_endindex = 0;n_endindex < gen_nb_int;n_endindex++) {
51767: mem_base = xmlMemBlocks();
51768: start = gen_xmlNodePtr(n_start, 0);
51769: startindex = gen_int(n_startindex, 1);
51770: end = gen_xmlNodePtr(n_end, 2);
51771: endindex = gen_int(n_endindex, 3);
51772:
51773: ret_val = xmlXPtrNewRange(start, startindex, end, endindex);
51774: desret_xmlXPathObjectPtr(ret_val);
51775: call_tests++;
51776: des_xmlNodePtr(n_start, start, 0);
51777: des_int(n_startindex, startindex, 1);
51778: des_xmlNodePtr(n_end, end, 2);
51779: des_int(n_endindex, endindex, 3);
51780: xmlResetLastError();
51781: if (mem_base != xmlMemBlocks()) {
51782: printf("Leak of %d blocks found in xmlXPtrNewRange",
51783: xmlMemBlocks() - mem_base);
51784: test_ret++;
51785: printf(" %d", n_start);
51786: printf(" %d", n_startindex);
51787: printf(" %d", n_end);
51788: printf(" %d", n_endindex);
51789: printf("\n");
51790: }
51791: }
51792: }
51793: }
51794: }
51795: function_tests++;
51796: #endif
51797:
51798: return(test_ret);
51799: }
51800:
51801:
51802: static int
51803: test_xmlXPtrNewRangeNodeObject(void) {
51804: int test_ret = 0;
51805:
51806: #if defined(LIBXML_XPTR_ENABLED)
51807: int mem_base;
51808: xmlXPathObjectPtr ret_val;
51809: xmlNodePtr start; /* the starting node */
51810: int n_start;
51811: xmlXPathObjectPtr end; /* the ending object */
51812: int n_end;
51813:
51814: for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
51815: for (n_end = 0;n_end < gen_nb_xmlXPathObjectPtr;n_end++) {
51816: mem_base = xmlMemBlocks();
51817: start = gen_xmlNodePtr(n_start, 0);
51818: end = gen_xmlXPathObjectPtr(n_end, 1);
51819:
51820: ret_val = xmlXPtrNewRangeNodeObject(start, end);
51821: desret_xmlXPathObjectPtr(ret_val);
51822: call_tests++;
51823: des_xmlNodePtr(n_start, start, 0);
51824: des_xmlXPathObjectPtr(n_end, end, 1);
51825: xmlResetLastError();
51826: if (mem_base != xmlMemBlocks()) {
51827: printf("Leak of %d blocks found in xmlXPtrNewRangeNodeObject",
51828: xmlMemBlocks() - mem_base);
51829: test_ret++;
51830: printf(" %d", n_start);
51831: printf(" %d", n_end);
51832: printf("\n");
51833: }
51834: }
51835: }
51836: function_tests++;
51837: #endif
51838:
51839: return(test_ret);
51840: }
51841:
51842:
51843: static int
51844: test_xmlXPtrNewRangeNodePoint(void) {
51845: int test_ret = 0;
51846:
51847: #if defined(LIBXML_XPTR_ENABLED)
51848: int mem_base;
51849: xmlXPathObjectPtr ret_val;
51850: xmlNodePtr start; /* the starting node */
51851: int n_start;
51852: xmlXPathObjectPtr end; /* the ending point */
51853: int n_end;
51854:
51855: for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
51856: for (n_end = 0;n_end < gen_nb_xmlXPathObjectPtr;n_end++) {
51857: mem_base = xmlMemBlocks();
51858: start = gen_xmlNodePtr(n_start, 0);
51859: end = gen_xmlXPathObjectPtr(n_end, 1);
51860:
51861: ret_val = xmlXPtrNewRangeNodePoint(start, end);
51862: desret_xmlXPathObjectPtr(ret_val);
51863: call_tests++;
51864: des_xmlNodePtr(n_start, start, 0);
51865: des_xmlXPathObjectPtr(n_end, end, 1);
51866: xmlResetLastError();
51867: if (mem_base != xmlMemBlocks()) {
51868: printf("Leak of %d blocks found in xmlXPtrNewRangeNodePoint",
51869: xmlMemBlocks() - mem_base);
51870: test_ret++;
51871: printf(" %d", n_start);
51872: printf(" %d", n_end);
51873: printf("\n");
51874: }
51875: }
51876: }
51877: function_tests++;
51878: #endif
51879:
51880: return(test_ret);
51881: }
51882:
51883:
51884: static int
51885: test_xmlXPtrNewRangeNodes(void) {
51886: int test_ret = 0;
51887:
51888: #if defined(LIBXML_XPTR_ENABLED)
51889: int mem_base;
51890: xmlXPathObjectPtr ret_val;
51891: xmlNodePtr start; /* the starting node */
51892: int n_start;
51893: xmlNodePtr end; /* the ending node */
51894: int n_end;
51895:
51896: for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
51897: for (n_end = 0;n_end < gen_nb_xmlNodePtr;n_end++) {
51898: mem_base = xmlMemBlocks();
51899: start = gen_xmlNodePtr(n_start, 0);
51900: end = gen_xmlNodePtr(n_end, 1);
51901:
51902: ret_val = xmlXPtrNewRangeNodes(start, end);
51903: desret_xmlXPathObjectPtr(ret_val);
51904: call_tests++;
51905: des_xmlNodePtr(n_start, start, 0);
51906: des_xmlNodePtr(n_end, end, 1);
51907: xmlResetLastError();
51908: if (mem_base != xmlMemBlocks()) {
51909: printf("Leak of %d blocks found in xmlXPtrNewRangeNodes",
51910: xmlMemBlocks() - mem_base);
51911: test_ret++;
51912: printf(" %d", n_start);
51913: printf(" %d", n_end);
51914: printf("\n");
51915: }
51916: }
51917: }
51918: function_tests++;
51919: #endif
51920:
51921: return(test_ret);
51922: }
51923:
51924:
51925: static int
51926: test_xmlXPtrNewRangePointNode(void) {
51927: int test_ret = 0;
51928:
51929: #if defined(LIBXML_XPTR_ENABLED)
51930: int mem_base;
51931: xmlXPathObjectPtr ret_val;
51932: xmlXPathObjectPtr start; /* the starting point */
51933: int n_start;
51934: xmlNodePtr end; /* the ending node */
51935: int n_end;
51936:
51937: for (n_start = 0;n_start < gen_nb_xmlXPathObjectPtr;n_start++) {
51938: for (n_end = 0;n_end < gen_nb_xmlNodePtr;n_end++) {
51939: mem_base = xmlMemBlocks();
51940: start = gen_xmlXPathObjectPtr(n_start, 0);
51941: end = gen_xmlNodePtr(n_end, 1);
51942:
51943: ret_val = xmlXPtrNewRangePointNode(start, end);
51944: desret_xmlXPathObjectPtr(ret_val);
51945: call_tests++;
51946: des_xmlXPathObjectPtr(n_start, start, 0);
51947: des_xmlNodePtr(n_end, end, 1);
51948: xmlResetLastError();
51949: if (mem_base != xmlMemBlocks()) {
51950: printf("Leak of %d blocks found in xmlXPtrNewRangePointNode",
51951: xmlMemBlocks() - mem_base);
51952: test_ret++;
51953: printf(" %d", n_start);
51954: printf(" %d", n_end);
51955: printf("\n");
51956: }
51957: }
51958: }
51959: function_tests++;
51960: #endif
51961:
51962: return(test_ret);
51963: }
51964:
51965:
51966: static int
51967: test_xmlXPtrNewRangePoints(void) {
51968: int test_ret = 0;
51969:
51970: #if defined(LIBXML_XPTR_ENABLED)
51971: int mem_base;
51972: xmlXPathObjectPtr ret_val;
51973: xmlXPathObjectPtr start; /* the starting point */
51974: int n_start;
51975: xmlXPathObjectPtr end; /* the ending point */
51976: int n_end;
51977:
51978: for (n_start = 0;n_start < gen_nb_xmlXPathObjectPtr;n_start++) {
51979: for (n_end = 0;n_end < gen_nb_xmlXPathObjectPtr;n_end++) {
51980: mem_base = xmlMemBlocks();
51981: start = gen_xmlXPathObjectPtr(n_start, 0);
51982: end = gen_xmlXPathObjectPtr(n_end, 1);
51983:
51984: ret_val = xmlXPtrNewRangePoints(start, end);
51985: desret_xmlXPathObjectPtr(ret_val);
51986: call_tests++;
51987: des_xmlXPathObjectPtr(n_start, start, 0);
51988: des_xmlXPathObjectPtr(n_end, end, 1);
51989: xmlResetLastError();
51990: if (mem_base != xmlMemBlocks()) {
51991: printf("Leak of %d blocks found in xmlXPtrNewRangePoints",
51992: xmlMemBlocks() - mem_base);
51993: test_ret++;
51994: printf(" %d", n_start);
51995: printf(" %d", n_end);
51996: printf("\n");
51997: }
51998: }
51999: }
52000: function_tests++;
52001: #endif
52002:
52003: return(test_ret);
52004: }
52005:
52006:
52007: static int
52008: test_xmlXPtrRangeToFunction(void) {
52009: int test_ret = 0;
52010:
52011: #if defined(LIBXML_XPTR_ENABLED)
52012: int mem_base;
52013: xmlXPathParserContextPtr ctxt; /* the XPointer Parser context */
52014: int n_ctxt;
52015: int nargs; /* the number of args */
52016: int n_nargs;
52017:
52018: for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
52019: for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
52020: mem_base = xmlMemBlocks();
52021: ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
52022: nargs = gen_int(n_nargs, 1);
52023:
52024: xmlXPtrRangeToFunction(ctxt, nargs);
52025: call_tests++;
52026: des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
52027: des_int(n_nargs, nargs, 1);
52028: xmlResetLastError();
52029: if (mem_base != xmlMemBlocks()) {
52030: printf("Leak of %d blocks found in xmlXPtrRangeToFunction",
52031: xmlMemBlocks() - mem_base);
52032: test_ret++;
52033: printf(" %d", n_ctxt);
52034: printf(" %d", n_nargs);
52035: printf("\n");
52036: }
52037: }
52038: }
52039: function_tests++;
52040: #endif
52041:
52042: return(test_ret);
52043: }
52044:
52045:
52046: static int
52047: test_xmlXPtrWrapLocationSet(void) {
52048: int test_ret = 0;
52049:
52050: #if defined(LIBXML_XPTR_ENABLED)
52051: int mem_base;
52052: xmlXPathObjectPtr ret_val;
52053: xmlLocationSetPtr val; /* the LocationSet value */
52054: int n_val;
52055:
52056: for (n_val = 0;n_val < gen_nb_xmlLocationSetPtr;n_val++) {
52057: mem_base = xmlMemBlocks();
52058: val = gen_xmlLocationSetPtr(n_val, 0);
52059:
52060: ret_val = xmlXPtrWrapLocationSet(val);
52061: desret_xmlXPathObjectPtr(ret_val);
52062: call_tests++;
52063: des_xmlLocationSetPtr(n_val, val, 0);
52064: xmlResetLastError();
52065: if (mem_base != xmlMemBlocks()) {
52066: printf("Leak of %d blocks found in xmlXPtrWrapLocationSet",
52067: xmlMemBlocks() - mem_base);
52068: test_ret++;
52069: printf(" %d", n_val);
52070: printf("\n");
52071: }
52072: }
52073: function_tests++;
52074: #endif
52075:
52076: return(test_ret);
52077: }
52078:
52079: static int
52080: test_xpointer(void) {
52081: int test_ret = 0;
52082:
52083: if (quiet == 0) printf("Testing xpointer : 17 of 21 functions ...\n");
52084: test_ret += test_xmlXPtrBuildNodeList();
52085: test_ret += test_xmlXPtrEval();
52086: test_ret += test_xmlXPtrEvalRangePredicate();
52087: test_ret += test_xmlXPtrLocationSetAdd();
52088: test_ret += test_xmlXPtrLocationSetCreate();
52089: test_ret += test_xmlXPtrLocationSetDel();
52090: test_ret += test_xmlXPtrLocationSetMerge();
52091: test_ret += test_xmlXPtrLocationSetRemove();
52092: test_ret += test_xmlXPtrNewCollapsedRange();
52093: test_ret += test_xmlXPtrNewContext();
52094: test_ret += test_xmlXPtrNewLocationSetNodeSet();
52095: test_ret += test_xmlXPtrNewLocationSetNodes();
52096: test_ret += test_xmlXPtrNewRange();
52097: test_ret += test_xmlXPtrNewRangeNodeObject();
52098: test_ret += test_xmlXPtrNewRangeNodePoint();
52099: test_ret += test_xmlXPtrNewRangeNodes();
52100: test_ret += test_xmlXPtrNewRangePointNode();
52101: test_ret += test_xmlXPtrNewRangePoints();
52102: test_ret += test_xmlXPtrRangeToFunction();
52103: test_ret += test_xmlXPtrWrapLocationSet();
52104:
52105: if (test_ret != 0)
52106: printf("Module xpointer: %d errors\n", test_ret);
52107: return(test_ret);
52108: }
52109: static int
52110: test_module(const char *module) {
52111: if (!strcmp(module, "HTMLparser")) return(test_HTMLparser());
52112: if (!strcmp(module, "HTMLtree")) return(test_HTMLtree());
52113: if (!strcmp(module, "SAX2")) return(test_SAX2());
52114: if (!strcmp(module, "c14n")) return(test_c14n());
52115: if (!strcmp(module, "catalog")) return(test_catalog());
52116: if (!strcmp(module, "chvalid")) return(test_chvalid());
52117: if (!strcmp(module, "debugXML")) return(test_debugXML());
52118: if (!strcmp(module, "dict")) return(test_dict());
52119: if (!strcmp(module, "encoding")) return(test_encoding());
52120: if (!strcmp(module, "entities")) return(test_entities());
52121: if (!strcmp(module, "hash")) return(test_hash());
52122: if (!strcmp(module, "list")) return(test_list());
52123: if (!strcmp(module, "nanoftp")) return(test_nanoftp());
52124: if (!strcmp(module, "nanohttp")) return(test_nanohttp());
52125: if (!strcmp(module, "parser")) return(test_parser());
52126: if (!strcmp(module, "parserInternals")) return(test_parserInternals());
52127: if (!strcmp(module, "pattern")) return(test_pattern());
52128: if (!strcmp(module, "relaxng")) return(test_relaxng());
52129: if (!strcmp(module, "schemasInternals")) return(test_schemasInternals());
52130: if (!strcmp(module, "schematron")) return(test_schematron());
52131: if (!strcmp(module, "tree")) return(test_tree());
52132: if (!strcmp(module, "uri")) return(test_uri());
52133: if (!strcmp(module, "valid")) return(test_valid());
52134: if (!strcmp(module, "xinclude")) return(test_xinclude());
52135: if (!strcmp(module, "xmlIO")) return(test_xmlIO());
52136: if (!strcmp(module, "xmlautomata")) return(test_xmlautomata());
52137: if (!strcmp(module, "xmlerror")) return(test_xmlerror());
52138: if (!strcmp(module, "xmlmodule")) return(test_xmlmodule());
52139: if (!strcmp(module, "xmlreader")) return(test_xmlreader());
52140: if (!strcmp(module, "xmlregexp")) return(test_xmlregexp());
52141: if (!strcmp(module, "xmlsave")) return(test_xmlsave());
52142: if (!strcmp(module, "xmlschemas")) return(test_xmlschemas());
52143: if (!strcmp(module, "xmlschemastypes")) return(test_xmlschemastypes());
52144: if (!strcmp(module, "xmlstring")) return(test_xmlstring());
52145: if (!strcmp(module, "xmlunicode")) return(test_xmlunicode());
52146: if (!strcmp(module, "xmlwriter")) return(test_xmlwriter());
52147: if (!strcmp(module, "xpath")) return(test_xpath());
52148: if (!strcmp(module, "xpathInternals")) return(test_xpathInternals());
52149: if (!strcmp(module, "xpointer")) return(test_xpointer());
52150: return(0);
52151: }
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