Return to testapi.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2

libxml2 2.9.1

    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:     }
  104:     if (api_root == NULL)
  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: 
  124: #ifdef HAVE_PUTENV
  125:     /* access to the proxy can slow up regression tests a lot */
  126:     putenv((char *) "http_proxy=");
  127: #endif
  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: 
  200: /*
  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(' ');
  290:     if (no == 2) return((xmlChar) '\xf8');
  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/>");
  398:     if (no == 2) return((xmlChar *) "n" "\xf8" "ne");
  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) {
  542:     if (no == 0)
  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
  598: static const xmlChar *static_buf_content = (xmlChar *)"a static buffer";
  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
  739: static void
  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);
 1039:     if (no == 3) return(XML_BUFFER_ALLOC_HYBRID);
 1040:     if (no == 4) return(XML_BUFFER_ALLOC_IMMUTABLE);
 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
 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
 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
 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
 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: 
 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: 
 8490: static int
 8491: test_dict(void) {
 8492:     int test_ret = 0;
 8493: 
 8494:     if (quiet == 0) printf("Testing dict : 10 of 13 functions ...\n");
 8495:     test_ret += test_xmlDictCleanup();
 8496:     test_ret += test_xmlDictCreate();
 8497:     test_ret += test_xmlDictCreateSub();
 8498:     test_ret += test_xmlDictExists();
 8499:     test_ret += test_xmlDictGetUsage();
 8500:     test_ret += test_xmlDictLookup();
 8501:     test_ret += test_xmlDictOwns();
 8502:     test_ret += test_xmlDictQLookup();
 8503:     test_ret += test_xmlDictReference();
 8504:     test_ret += test_xmlDictSetLimit();
 8505:     test_ret += test_xmlDictSize();
 8506:     test_ret += test_xmlInitializeDict();
 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;
17835:     int len; /* the length of the data */
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: 
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: 
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
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
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: 
24183:     if (quiet == 0) printf("Testing tree : 142 of 164 functions ...\n");
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();
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();
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();
24204:     test_ret += test_xmlBufferDetach();
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;
27097:     int len; /* the length of the data */
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
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
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: 
29166:     if (quiet == 0) printf("Testing xmlIO : 40 of 50 functions ...\n");
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();
29192:     test_ret += test_xmlOutputBufferGetContent();
29193:     test_ret += test_xmlOutputBufferGetSize();
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
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
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: 
32955:     if (quiet == 0) printf("Testing xmlreader : 76 of 86 functions ...\n");
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();
33023:     test_ret += test_xmlTextReaderRelaxNGValidateCtxt();
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;
33170:     int len; /* the allocated length of @list */
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;
33225:     int len; /* the allocated length of @list */
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
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
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: 
34937:     if (quiet == 0) printf("Testing xmlschemas : 16 of 27 functions ...\n");
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();
34959:     test_ret += test_xmlSchemaValidateSetFilename();
34960:     test_ret += test_xmlSchemaValidateSetLocator();
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
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
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: 
45744:     if (quiet == 0) printf("Testing xmlwriter : 52 of 80 functions ...\n");
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();
45764:     test_ret += test_xmlTextWriterSetQuoteChar();
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
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
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: 
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: 
47044: static int
47045: test_xpath(void) {
47046:     int test_ret = 0;
47047: 
47048:     if (quiet == 0) printf("Testing xpath : 32 of 40 functions ...\n");
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();
47079:     test_ret += test_xmlXPathNodeEval();
47080:     test_ret += test_xmlXPathNodeSetCreate();
47081:     test_ret += test_xmlXPathObjectCopy();
47082:     test_ret += test_xmlXPathOrderDocElems();
47083:     test_ret += test_xmlXPathSetContextNode();
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;
49219:     int ret_val;
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: 
49231:         ret_val = xmlXPathNodeSetAdd(cur, val);
49232:         desret_int(ret_val);
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;
49260:     int ret_val;
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: 
49276:         ret_val = xmlXPathNodeSetAddNs(cur, node, ns);
49277:         desret_int(ret_val);
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;
49308:     int ret_val;
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: 
49320:         ret_val = xmlXPathNodeSetAddUnique(cur, val);
49321:         desret_int(ret_val);
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: }