src/third_party/libxml/src/testapi.c

   1 /*
   2  * testapi.c: libxml2 API tester program.
   3  *
   4  * Automatically generated by gentest.py from libxml2-api.xml
   5  *
   6  * See Copyright for the status of this software.
   7  *
   8  * daniel@veillard.com
   9  */
  10
  11 #ifdef HAVE_CONFIG_H
  12 #include "libxml.h"
  13 #else
  14 #include <stdio.h>
  15 #endif
  16
  17 #include <stdlib.h> /* for putenv() */
  18 #include <string.h>
  19 #include <libxml/xmlerror.h>
  20 #include <libxml/relaxng.h>
  21
  22 #if defined(_WIN32) && !defined(__CYGWIN__)
  23 #define snprintf _snprintf
  24 #endif
  25
  26 static int testlibxml2(void);
  27 static int test_module(const char *module);
  28
  29 static int generic_errors = 0;
  30 static int call_tests = 0;
  31 static int function_tests = 0;
  32
  33 static xmlChar chartab[1024];
  34 static int inttab[1024];
  35 static unsigned long longtab[1024];
  36
  37 static xmlDocPtr api_doc = NULL;
  38 static xmlDtdPtr api_dtd = NULL;
  39 static xmlNodePtr api_root = NULL;
  40 static xmlAttrPtr api_attr = NULL;
  41 static xmlNsPtr api_ns = NULL;
  42
  43 static void
  44 structured_errors(void *userData ATTRIBUTE_UNUSED,
  45                   xmlErrorPtr error ATTRIBUTE_UNUSED) {
  46     generic_errors++;
  47 }
  48
  49 static void
  50 free_api_doc(void) {
  51     xmlFreeDoc(api_doc);
  52     api_doc = NULL;
  53     api_dtd = NULL;
  54     api_root = NULL;
  55     api_attr = NULL;
  56     api_ns = NULL;
  57 }
  58
  59 static xmlDocPtr
  60 get_api_doc(void) {
  61     if (api_doc == NULL) {
  62         api_doc = xmlReadMemory("<!DOCTYPE root [<!ELEMENT root EMPTY>]><root xmlns:h='http://example.com/' h:foo='bar'/>", 88, "root_test", NULL, 0);
  63         api_root = NULL;
  64         api_attr = NULL;
  65     }
  66     return(api_doc);
  67 }
  68
  69 static xmlDtdPtr
  70 get_api_dtd(void) {
  71     if ((api_dtd == NULL) || (api_dtd->type != XML_DTD_NODE)) {
  72         get_api_doc();
  73         if ((api_doc != NULL) && (api_doc->children != NULL) &&
  74             (api_doc->children->type == XML_DTD_NODE))
  75             api_dtd = (xmlDtdPtr) api_doc->children;
  76     }
  77     return(api_dtd);
  78 }
  79
  80 static xmlNodePtr
  81 get_api_root(void) {
  82     if ((api_root == NULL) || (api_root->type != XML_ELEMENT_NODE)) {
  83         get_api_doc();
  84         if ((api_doc != NULL) && (api_doc->children != NULL) &&
  85             (api_doc->children->next != NULL) &&
  86             (api_doc->children->next->type == XML_ELEMENT_NODE))
  87             api_root = api_doc->children->next;
  88     }
  89     return(api_root);
  90 }
  91
  92 static xmlNsPtr
  93 get_api_ns(void) {
  94     get_api_root();
  95     if (api_root != NULL)
  96         api_ns = api_root->nsDef;
  97     return(api_ns);
  98 }
  99
 100 static xmlAttrPtr
 101 get_api_attr(void) {
 102 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
 103     static int nr = 0;
 104     xmlChar name[20];
 105 #endif
 106
 107     if ((api_root == NULL) || (api_root->type != XML_ELEMENT_NODE)) {
 108         get_api_root();
 109     }
 110     if (api_root == NULL)
 111         return(NULL);
 112     if (api_root->properties != NULL) {
 113         api_attr = api_root->properties;
 114         return(api_root->properties);
 115     }
 116     api_attr = NULL;
 117 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
 118     snprintf((char *) name, 20, "foo%d", nr++);
 119     api_attr = xmlSetProp(api_root, name, (const xmlChar *) "bar");
 120 #endif
 121     return(api_attr);
 122 }
 123
 124 static int quiet = 0;
 125
 126 int main(int argc, char **argv) {
 127     int ret;
 128     int blocks, mem;
 129
 130     /* access to the proxy can slow up regression tests a lot */
 131     putenv((char *) "http_proxy=");
 132
 133     memset(chartab, 0, sizeof(chartab));
 134     strncpy((char *) chartab, "  chartab\n", 20);
 135     memset(inttab, 0, sizeof(inttab));
 136     memset(longtab, 0, sizeof(longtab));
 137
 138     xmlInitParser();
 139 #ifdef LIBXML_SCHEMAS_ENABLED
 140     xmlRelaxNGInitTypes();
 141 #endif
 142
 143     LIBXML_TEST_VERSION
 144
 145     xmlSetStructuredErrorFunc(NULL, structured_errors);
 146
 147     if (argc >= 2) {
 148         if (!strcmp(argv[1], "-q")) {
 149             quiet = 1;
 150             if (argc >= 3)
 151                 ret = test_module(argv[2]);
 152             else
 153                 ret = testlibxml2();
 154         } else {
 155            ret = test_module(argv[1]);
 156         }
 157     } else
 158         ret = testlibxml2();
 159
 160     xmlCleanupParser();
 161     blocks = xmlMemBlocks();
 162     mem = xmlMemUsed();
 163     if ((blocks != 0) || (mem != 0)) {
 164         printf("testapi leaked %d bytes in %d blocks\n", mem, blocks);
 165     }
 166     xmlMemoryDump();
 167
 168     return (ret != 0);
 169 }
 170
 171 #include <libxml/HTMLparser.h>
 172 #include <libxml/HTMLtree.h>
 173 #include <libxml/catalog.h>
 174 #include <libxml/chvalid.h>
 175 #include <libxml/dict.h>
 176 #include <libxml/encoding.h>
 177 #include <libxml/entities.h>
 178 #include <libxml/hash.h>
 179 #include <libxml/list.h>
 180 #include <libxml/nanoftp.h>
 181 #include <libxml/nanohttp.h>
 182 #include <libxml/parser.h>
 183 #include <libxml/parserInternals.h>
 184 #include <libxml/pattern.h>
 185 #include <libxml/relaxng.h>
 186 #include <libxml/schemasInternals.h>
 187 #include <libxml/schematron.h>
 188 #include <libxml/tree.h>
 189 #include <libxml/uri.h>
 190 #include <libxml/valid.h>
 191 #include <libxml/xinclude.h>
 192 #include <libxml/xmlIO.h>
 193 #include <libxml/xmlerror.h>
 194 #include <libxml/xmlreader.h>
 195 #include <libxml/xmlsave.h>
 196 #include <libxml/xmlschemas.h>
 197 #include <libxml/xmlschemastypes.h>
 198 #include <libxml/xmlstring.h>
 199 #include <libxml/xmlwriter.h>
 200 #include <libxml/xpath.h>
 201 #include <libxml/xpointer.h>
 202 #include <libxml/debugXML.h>
 203
 204 /*
 205   We manually define xmlErrMemory because it's normal declaration
 206   is "hidden" by #ifdef IN_LIBXML
 207 */
 208 void xmlErrMemory(xmlParserCtxtPtr ctxt, const char *extra);
 209
 210 /*
 211  We need some "remote" addresses, but want to avoid getting into
 212  name resolution delays, so we use these
 213 */
 214 #define REMOTE1GOOD     "http://localhost/"
 215 #define REMOTE1BAD      "http:http://http"
 216 #define REMOTE2GOOD     "ftp://localhost/foo"
 217
 218 #define gen_nb_void_ptr 2
 219
 220 static void *gen_void_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 221     return(NULL);
 222 }
 223 static void des_void_ptr(int no ATTRIBUTE_UNUSED, void *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 224 }
 225
 226 #if 0
 227 #define gen_nb_const_void_ptr 2
 228
 229 static const void *gen_const_void_ptr(int no, int nr ATTRIBUTE_UNUSED) {
 230     if (no == 0) return((const void *) "immutable string");
 231     return(NULL);
 232 }
 233 static void des_const_void_ptr(int no ATTRIBUTE_UNUSED, const void *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 234 }
 235 #endif
 236
 237 #define gen_nb_userdata 3
 238
 239 static void *gen_userdata(int no, int nr ATTRIBUTE_UNUSED) {
 240     if (no == 0) return((void *) &call_tests);
 241     if (no == 1) return((void *) -1);
 242     return(NULL);
 243 }
 244 static void des_userdata(int no ATTRIBUTE_UNUSED, void *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 245 }
 246
 247
 248 #define gen_nb_int 4
 249
 250 static int gen_int(int no, int nr ATTRIBUTE_UNUSED) {
 251     if (no == 0) return(0);
 252     if (no == 1) return(1);
 253     if (no == 2) return(-1);
 254     if (no == 3) return(122);
 255     return(-1);
 256 }
 257
 258 static void des_int(int no ATTRIBUTE_UNUSED, int val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 259 }
 260
 261 #define gen_nb_parseroptions 5
 262
 263 static int gen_parseroptions(int no, int nr ATTRIBUTE_UNUSED) {
 264     if (no == 0) return(XML_PARSE_NOBLANKS | XML_PARSE_RECOVER);
 265     if (no == 1) return(XML_PARSE_NOENT | XML_PARSE_DTDLOAD | XML_PARSE_DTDATTR | XML_PARSE_DTDVALID | XML_PARSE_NOCDATA);
 266     if (no == 2) return(XML_PARSE_XINCLUDE | XML_PARSE_NOXINCNODE | XML_PARSE_NSCLEAN);
 267     if (no == 3) return(XML_PARSE_XINCLUDE | XML_PARSE_NODICT);
 268     return(XML_PARSE_SAX1);
 269 }
 270
 271 static void des_parseroptions(int no ATTRIBUTE_UNUSED, int val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 272 }
 273
 274 #if 0
 275 #define gen_nb_long 5
 276
 277 static long gen_long(int no, int nr ATTRIBUTE_UNUSED) {
 278     if (no == 0) return(0);
 279     if (no == 1) return(1);
 280     if (no == 2) return(-1);
 281     if (no == 3) return(122);
 282     return(-1);
 283 }
 284
 285 static void des_long(int no ATTRIBUTE_UNUSED, long val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 286 }
 287 #endif
 288
 289 #define gen_nb_xmlChar 4
 290
 291 static xmlChar gen_xmlChar(int no, int nr ATTRIBUTE_UNUSED) {
 292     if (no == 0) return('a');
 293     if (no == 1) return(' ');
 294     if (no == 2) return((xmlChar) 'ø');
 295     return(0);
 296 }
 297
 298 static void des_xmlChar(int no ATTRIBUTE_UNUSED, xmlChar val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 299 }
 300
 301 #define gen_nb_unsigned_int 3
 302
 303 static unsigned int gen_unsigned_int(int no, int nr ATTRIBUTE_UNUSED) {
 304     if (no == 0) return(0);
 305     if (no == 1) return(1);
 306     if (no == 2) return(122);
 307     return((unsigned int) -1);
 308 }
 309
 310 static void des_unsigned_int(int no ATTRIBUTE_UNUSED, unsigned int val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 311 }
 312
 313 #define gen_nb_unsigned_long 4
 314
 315 static unsigned long gen_unsigned_long(int no, int nr ATTRIBUTE_UNUSED) {
 316     if (no == 0) return(0);
 317     if (no == 1) return(1);
 318     if (no == 2) return(122);
 319     return((unsigned long) -1);
 320 }
 321
 322 static void des_unsigned_long(int no ATTRIBUTE_UNUSED, unsigned long val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 323 }
 324
 325 #define gen_nb_double 4
 326
 327 static double gen_double(int no, int nr ATTRIBUTE_UNUSED) {
 328     if (no == 0) return(0);
 329     if (no == 1) return(-1.1);
 330 #if defined(LIBXML_XPATH_ENABLED)
 331     if (no == 2) return(xmlXPathNAN);
 332 #endif
 333     return(-1);
 334 }
 335
 336 static void des_double(int no ATTRIBUTE_UNUSED, double val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 337 }
 338
 339 #define gen_nb_unsigned_long_ptr 2
 340
 341 static unsigned long *gen_unsigned_long_ptr(int no, int nr) {
 342     if (no == 0) return(&longtab[nr]);
 343     return(NULL);
 344 }
 345
 346 static void des_unsigned_long_ptr(int no ATTRIBUTE_UNUSED, unsigned long *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 347 }
 348
 349 #define gen_nb_int_ptr 2
 350
 351 static int *gen_int_ptr(int no, int nr) {
 352     if (no == 0) return(&inttab[nr]);
 353     return(NULL);
 354 }
 355
 356 static void des_int_ptr(int no ATTRIBUTE_UNUSED, int *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 357 }
 358
 359 #define gen_nb_const_char_ptr 4
 360
 361 static char *gen_const_char_ptr(int no, int nr ATTRIBUTE_UNUSED) {
 362     if (no == 0) return((char *) "foo");
 363     if (no == 1) return((char *) "<foo/>");
 364     if (no == 2) return((char *) "test/ent2");
 365     return(NULL);
 366 }
 367 static void des_const_char_ptr(int no ATTRIBUTE_UNUSED, const char *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 368 }
 369
 370 #define gen_nb_xmlChar_ptr 2
 371
 372 static xmlChar *gen_xmlChar_ptr(int no, int nr ATTRIBUTE_UNUSED) {
 373     if (no == 0) return(&chartab[0]);
 374     return(NULL);
 375 }
 376 static void des_xmlChar_ptr(int no ATTRIBUTE_UNUSED, xmlChar *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 377 }
 378
 379 #define gen_nb_FILE_ptr 2
 380
 381 static FILE *gen_FILE_ptr(int no, int nr ATTRIBUTE_UNUSED) {
 382     if (no == 0) return(fopen("test.out", "a+"));
 383     return(NULL);
 384 }
 385 static void des_FILE_ptr(int no ATTRIBUTE_UNUSED, FILE *val, int nr ATTRIBUTE_UNUSED) {
 386     if (val != NULL) fclose(val);
 387 }
 388
 389 #define gen_nb_debug_FILE_ptr 2
 390 static FILE *gen_debug_FILE_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 391     return(fopen("test.out", "a+"));
 392 }
 393 static void des_debug_FILE_ptr(int no ATTRIBUTE_UNUSED, FILE *val, int nr ATTRIBUTE_UNUSED) {
 394     if (val != NULL) fclose(val);
 395 }
 396
 397 #define gen_nb_const_xmlChar_ptr 5
 398
 399 static xmlChar *gen_const_xmlChar_ptr(int no, int nr ATTRIBUTE_UNUSED) {
 400     if (no == 0) return((xmlChar *) "foo");
 401     if (no == 1) return((xmlChar *) "<foo/>");
 402     if (no == 2) return((xmlChar *) "nøne");
 403     if (no == 3) return((xmlChar *) " 2ab ");
 404     return(NULL);
 405 }
 406 static void des_const_xmlChar_ptr(int no ATTRIBUTE_UNUSED, const xmlChar *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 407 }
 408
 409 #define gen_nb_filepath 8
 410
 411 static const char *gen_filepath(int no, int nr ATTRIBUTE_UNUSED) {
 412     if (no == 0) return("missing.xml");
 413     if (no == 1) return("<foo/>");
 414     if (no == 2) return("test/ent2");
 415     if (no == 3) return("test/valid/REC-xml-19980210.xml");
 416     if (no == 4) return("test/valid/dtds/xhtml1-strict.dtd");
 417     if (no == 5) return(REMOTE1GOOD);
 418     if (no == 6) return(REMOTE1BAD);
 419     return(NULL);
 420 }
 421 static void des_filepath(int no ATTRIBUTE_UNUSED, const char *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 422 }
 423
 424 #define gen_nb_eaten_name 2
 425
 426 static xmlChar *gen_eaten_name(int no, int nr ATTRIBUTE_UNUSED) {
 427     if (no == 0) return(xmlStrdup(BAD_CAST "eaten"));
 428     return(NULL);
 429 }
 430 static void des_eaten_name(int no ATTRIBUTE_UNUSED, xmlChar *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 431 }
 432
 433 #define gen_nb_fileoutput 6
 434
 435 static const char *gen_fileoutput(int no, int nr ATTRIBUTE_UNUSED) {
 436     if (no == 0) return("/missing.xml");
 437     if (no == 1) return("<foo/>");
 438     if (no == 2) return(REMOTE2GOOD);
 439     if (no == 3) return(REMOTE1GOOD);
 440     if (no == 4) return(REMOTE1BAD);
 441     return(NULL);
 442 }
 443 static void des_fileoutput(int no ATTRIBUTE_UNUSED, const char *val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 444 }
 445
 446 #define gen_nb_xmlParserCtxtPtr 3
 447 static xmlParserCtxtPtr gen_xmlParserCtxtPtr(int no, int nr ATTRIBUTE_UNUSED) {
 448     if (no == 0) return(xmlNewParserCtxt());
 449     if (no == 1) return(xmlCreateMemoryParserCtxt("<doc/>", 6));
 450     return(NULL);
 451 }
 452 static void des_xmlParserCtxtPtr(int no ATTRIBUTE_UNUSED, xmlParserCtxtPtr val, int nr ATTRIBUTE_UNUSED) {
 453     if (val != NULL)
 454         xmlFreeParserCtxt(val);
 455 }
 456
 457 #define gen_nb_xmlSAXHandlerPtr 2
 458 static xmlSAXHandlerPtr gen_xmlSAXHandlerPtr(int no, int nr ATTRIBUTE_UNUSED) {
 459 #ifdef LIBXML_SAX1_ENABLED
 460     if (no == 0) return((xmlSAXHandlerPtr) &xmlDefaultSAXHandler);
 461 #endif
 462     return(NULL);
 463 }
 464 static void des_xmlSAXHandlerPtr(int no ATTRIBUTE_UNUSED, xmlSAXHandlerPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 465 }
 466
 467 #define gen_nb_xmlValidCtxtPtr 2
 468 static xmlValidCtxtPtr gen_xmlValidCtxtPtr(int no, int nr ATTRIBUTE_UNUSED) {
 469 #ifdef LIBXML_VALID_ENABLED
 470     if (no == 0) return(xmlNewValidCtxt());
 471 #endif
 472     return(NULL);
 473 }
 474 static void des_xmlValidCtxtPtr(int no ATTRIBUTE_UNUSED, xmlValidCtxtPtr val, int nr ATTRIBUTE_UNUSED) {
 475 #ifdef LIBXML_VALID_ENABLED
 476     if (val != NULL)
 477         xmlFreeValidCtxt(val);
 478 #endif
 479 }
 480
 481 #define gen_nb_xmlParserInputBufferPtr 8
 482
 483 static xmlParserInputBufferPtr gen_xmlParserInputBufferPtr(int no, int nr ATTRIBUTE_UNUSED) {
 484     if (no == 0) return(xmlParserInputBufferCreateFilename("missing.xml", XML_CHAR_ENCODING_NONE));
 485     if (no == 1) return(xmlParserInputBufferCreateFilename("<foo/>", XML_CHAR_ENCODING_NONE));
 486     if (no == 2) return(xmlParserInputBufferCreateFilename("test/ent2", XML_CHAR_ENCODING_NONE));
 487     if (no == 3) return(xmlParserInputBufferCreateFilename("test/valid/REC-xml-19980210.xml", XML_CHAR_ENCODING_NONE));
 488     if (no == 4) return(xmlParserInputBufferCreateFilename("test/valid/dtds/xhtml1-strict.dtd", XML_CHAR_ENCODING_NONE));
 489     if (no == 5) return(xmlParserInputBufferCreateFilename(REMOTE1GOOD, XML_CHAR_ENCODING_NONE));
 490     if (no == 6) return(xmlParserInputBufferCreateFilename(REMOTE1BAD, XML_CHAR_ENCODING_NONE));
 491     return(NULL);
 492 }
 493 static void des_xmlParserInputBufferPtr(int no ATTRIBUTE_UNUSED, xmlParserInputBufferPtr val, int nr ATTRIBUTE_UNUSED) {
 494     xmlFreeParserInputBuffer(val);
 495 }
 496
 497 #define gen_nb_xmlDocPtr 4
 498 static xmlDocPtr gen_xmlDocPtr(int no, int nr ATTRIBUTE_UNUSED) {
 499     if (no == 0) return(xmlNewDoc(BAD_CAST "1.0"));
 500     if (no == 1) return(xmlReadMemory("<foo/>", 6, "test", NULL, 0));
 501     if (no == 2) return(xmlReadMemory("<!DOCTYPE foo []> <foo/>", 24, "test", NULL, 0));
 502     return(NULL);
 503 }
 504 static void des_xmlDocPtr(int no ATTRIBUTE_UNUSED, xmlDocPtr val, int nr ATTRIBUTE_UNUSED) {
 505     if ((val != NULL) && (val != api_doc) && (val->doc != api_doc))
 506         xmlFreeDoc(val);
 507 }
 508
 509 #define gen_nb_xmlAttrPtr 2
 510 static xmlAttrPtr gen_xmlAttrPtr(int no, int nr ATTRIBUTE_UNUSED) {
 511     if (no == 0) return(get_api_attr());
 512     return(NULL);
 513 }
 514 static void des_xmlAttrPtr(int no, xmlAttrPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 515     if (no == 0) free_api_doc();
 516 }
 517
 518 #define gen_nb_xmlDictPtr 2
 519 static xmlDictPtr gen_xmlDictPtr(int no, int nr ATTRIBUTE_UNUSED) {
 520     if (no == 0) return(xmlDictCreate());
 521     return(NULL);
 522 }
 523 static void des_xmlDictPtr(int no ATTRIBUTE_UNUSED, xmlDictPtr val, int nr ATTRIBUTE_UNUSED) {
 524     if (val != NULL)
 525         xmlDictFree(val);
 526 }
 527
 528 #define gen_nb_xmlNodePtr 3
 529 static xmlNodePtr gen_xmlNodePtr(int no, int nr ATTRIBUTE_UNUSED) {
 530     if (no == 0) return(xmlNewPI(BAD_CAST "test", NULL));
 531     if (no == 1) return(get_api_root());
 532     return(NULL);
 533 /*     if (no == 2) return((xmlNodePtr) get_api_doc()); */
 534 }
 535 static void des_xmlNodePtr(int no, xmlNodePtr val, int nr ATTRIBUTE_UNUSED) {
 536     if (no == 1) {
 537         free_api_doc();
 538     } else if (val != NULL) {
 539         xmlUnlinkNode(val);
 540         xmlFreeNode(val);
 541     }
 542 }
 543
 544 #define gen_nb_xmlDtdPtr 3
 545 static xmlDtdPtr gen_xmlDtdPtr(int no, int nr ATTRIBUTE_UNUSED) {
 546     if (no == 0)
 547         return(xmlNewDtd(NULL, BAD_CAST "dtd", BAD_CAST"foo", BAD_CAST"bar"));
 548     if (no == 1) return(get_api_dtd());
 549     return(NULL);
 550 }
 551 static void des_xmlDtdPtr(int no, xmlDtdPtr val, int nr ATTRIBUTE_UNUSED) {
 552     if (no == 1) free_api_doc();
 553     else if (val != NULL) {
 554         xmlUnlinkNode((xmlNodePtr) val);
 555         xmlFreeNode((xmlNodePtr) val);
 556     }
 557 }
 558
 559 #define gen_nb_xmlNsPtr 2
 560 static xmlNsPtr gen_xmlNsPtr(int no, int nr ATTRIBUTE_UNUSED) {
 561     if (no == 0) return(get_api_ns());
 562     return(NULL);
 563 }
 564 static void des_xmlNsPtr(int no, xmlNsPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 565     if (no == 0) free_api_doc();
 566 }
 567
 568 #define gen_nb_xmlNodePtr_in 3
 569 static xmlNodePtr gen_xmlNodePtr_in(int no, int nr ATTRIBUTE_UNUSED) {
 570     if (no == 0) return(xmlNewPI(BAD_CAST "test", NULL));
 571     if (no == 0) return(xmlNewText(BAD_CAST "text"));
 572     return(NULL);
 573 }
 574 static void des_xmlNodePtr_in(int no ATTRIBUTE_UNUSED, xmlNodePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 575 }
 576
 577 #ifdef LIBXML_WRITER_ENABLED
 578 #define gen_nb_xmlTextWriterPtr 2
 579 static xmlTextWriterPtr gen_xmlTextWriterPtr(int no, int nr ATTRIBUTE_UNUSED) {
 580     if (no == 0) return(xmlNewTextWriterFilename("test.out", 0));
 581     return(NULL);
 582 }
 583 static void des_xmlTextWriterPtr(int no ATTRIBUTE_UNUSED, xmlTextWriterPtr val, int nr ATTRIBUTE_UNUSED) {
 584     if (val != NULL) xmlFreeTextWriter(val);
 585 }
 586 #endif
 587
 588 #ifdef LIBXML_READER_ENABLED
 589 #define gen_nb_xmlTextReaderPtr 4
 590 static xmlTextReaderPtr gen_xmlTextReaderPtr(int no, int nr ATTRIBUTE_UNUSED) {
 591     if (no == 0) return(xmlNewTextReaderFilename("test/ent2"));
 592     if (no == 1) return(xmlNewTextReaderFilename("test/valid/REC-xml-19980210.xml"));
 593     if (no == 2) return(xmlNewTextReaderFilename("test/valid/dtds/xhtml1-strict.dtd"));
 594     return(NULL);
 595 }
 596 static void des_xmlTextReaderPtr(int no ATTRIBUTE_UNUSED, xmlTextReaderPtr val, int nr ATTRIBUTE_UNUSED) {
 597     if (val != NULL) xmlFreeTextReader(val);
 598 }
 599 #endif
 600
 601 #define gen_nb_xmlBufferPtr 3
 602 static const char *static_buf_content = "a static buffer";
 603 static xmlBufferPtr gen_xmlBufferPtr(int no, int nr ATTRIBUTE_UNUSED) {
 604     if (no == 0) return(xmlBufferCreate());
 605     if (no == 1) return(xmlBufferCreateStatic((void *)static_buf_content, 13));
 606     return(NULL);
 607 }
 608 static void des_xmlBufferPtr(int no ATTRIBUTE_UNUSED, xmlBufferPtr val, int nr ATTRIBUTE_UNUSED) {
 609     if (val != NULL) {
 610         xmlBufferFree(val);
 611     }
 612 }
 613
 614 #define gen_nb_xmlListPtr 2
 615 static xmlListPtr gen_xmlListPtr(int no, int nr ATTRIBUTE_UNUSED) {
 616     if (no == 0) return(xmlListCreate(NULL, NULL));
 617     return(NULL);
 618 }
 619 static void des_xmlListPtr(int no ATTRIBUTE_UNUSED, xmlListPtr val, int nr ATTRIBUTE_UNUSED) {
 620     if (val != NULL) {
 621         xmlListDelete(val);
 622     }
 623 }
 624
 625 #define gen_nb_xmlHashTablePtr 2
 626 static xmlHashTablePtr gen_xmlHashTablePtr(int no, int nr ATTRIBUTE_UNUSED) {
 627     if (no == 0) return(xmlHashCreate(10));
 628     return(NULL);
 629 }
 630 static void des_xmlHashTablePtr(int no ATTRIBUTE_UNUSED, xmlHashTablePtr val, int nr ATTRIBUTE_UNUSED) {
 631     if (val != NULL) {
 632         xmlHashFree(val, NULL);
 633     }
 634 }
 635
 636 #include <libxml/xpathInternals.h>
 637
 638 #ifdef LIBXML_XPATH_ENABLED
 639 #define gen_nb_xmlXPathObjectPtr 5
 640 static xmlXPathObjectPtr gen_xmlXPathObjectPtr(int no, int nr ATTRIBUTE_UNUSED) {
 641     if (no == 0) return(xmlXPathNewString(BAD_CAST "string object"));
 642     if (no == 1) return(xmlXPathNewFloat(1.1));
 643     if (no == 2) return(xmlXPathNewBoolean(1));
 644     if (no == 3) return(xmlXPathNewNodeSet(NULL));
 645     return(NULL);
 646 }
 647 static void des_xmlXPathObjectPtr(int no ATTRIBUTE_UNUSED, xmlXPathObjectPtr val, int nr ATTRIBUTE_UNUSED) {
 648     if (val != NULL) {
 649         xmlXPathFreeObject(val);
 650     }
 651 }
 652 #endif
 653
 654 #ifdef LIBXML_OUTPUT_ENABLED
 655 #define gen_nb_xmlOutputBufferPtr 2
 656 static xmlOutputBufferPtr gen_xmlOutputBufferPtr(int no, int nr ATTRIBUTE_UNUSED) {
 657     if (no == 0) return(xmlOutputBufferCreateFilename("test.out", NULL, 0));
 658     return(NULL);
 659 }
 660 static void des_xmlOutputBufferPtr(int no ATTRIBUTE_UNUSED, xmlOutputBufferPtr val, int nr ATTRIBUTE_UNUSED) {
 661     if (val != NULL) {
 662         xmlOutputBufferClose(val);
 663     }
 664 }
 665 #endif
 666
 667 #ifdef LIBXML_FTP_ENABLED
 668 #define gen_nb_xmlNanoFTPCtxtPtr 4
 669 static void *gen_xmlNanoFTPCtxtPtr(int no, int nr ATTRIBUTE_UNUSED) {
 670     if (no == 0) return(xmlNanoFTPNewCtxt(REMOTE2GOOD));
 671     if (no == 1) return(xmlNanoFTPNewCtxt(REMOTE1GOOD));
 672     if (no == 2) return(xmlNanoFTPNewCtxt("foo"));
 673     return(NULL);
 674 }
 675 static void des_xmlNanoFTPCtxtPtr(int no ATTRIBUTE_UNUSED, void *val, int nr ATTRIBUTE_UNUSED) {
 676     if (val != NULL) {
 677         xmlNanoFTPFreeCtxt(val);
 678     }
 679 }
 680 #endif
 681
 682 #ifdef LIBXML_HTTP_ENABLED
 683 #define gen_nb_xmlNanoHTTPCtxtPtr 1
 684 static void *gen_xmlNanoHTTPCtxtPtr(int no, int nr ATTRIBUTE_UNUSED) {
 685     if (no == 0) return(xmlNanoHTTPOpen(REMOTE1GOOD, NULL));
 686     if (no == 1) return(xmlNanoHTTPOpen(REMOTE2GOOD, NULL));
 687     if (no == 2) return(xmlNanoHTTPOpen(REMOTE1BAD, NULL));
 688     return(NULL);
 689 }
 690 static void des_xmlNanoHTTPCtxtPtr(int no ATTRIBUTE_UNUSED, void *val, int nr ATTRIBUTE_UNUSED) {
 691     if (val != NULL) {
 692         xmlNanoHTTPClose(val);
 693     }
 694 }
 695 #endif
 696
 697 #define gen_nb_xmlCharEncoding 4
 698 static xmlCharEncoding gen_xmlCharEncoding(int no, int nr ATTRIBUTE_UNUSED) {
 699     if (no == 0) return(XML_CHAR_ENCODING_UTF8);
 700     if (no == 1) return(XML_CHAR_ENCODING_NONE);
 701     if (no == 2) return(XML_CHAR_ENCODING_8859_1);
 702     return(XML_CHAR_ENCODING_ERROR);
 703 }
 704 static void des_xmlCharEncoding(int no ATTRIBUTE_UNUSED, xmlCharEncoding val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 705 }
 706
 707 #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
 708
 709 #define gen_nb_xmlExpCtxtPtr 1
 710 static xmlExpCtxtPtr gen_xmlExpCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 711     return(NULL);
 712 }
 713 static void des_xmlExpCtxtPtr(int no ATTRIBUTE_UNUSED, xmlExpCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 714 }
 715
 716 #define gen_nb_xmlExpNodePtr 1
 717 static xmlExpNodePtr gen_xmlExpNodePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 718     return(NULL);
 719 }
 720 static void des_xmlExpNodePtr(int no ATTRIBUTE_UNUSED, xmlExpNodePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 721 }
 722
 723 #endif
 724
 725 #if defined(LIBXML_SCHEMAS_ENABLED)
 726 #define gen_nb_xmlSchemaPtr 1
 727 static xmlSchemaPtr gen_xmlSchemaPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 728     return(NULL);
 729 }
 730 static void des_xmlSchemaPtr(int no ATTRIBUTE_UNUSED, xmlSchemaPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 731 }
 732
 733 #define gen_nb_xmlSchemaValidCtxtPtr 1
 734 static xmlSchemaValidCtxtPtr gen_xmlSchemaValidCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 735     return(NULL);
 736 }
 737 static void des_xmlSchemaValidCtxtPtr(int no ATTRIBUTE_UNUSED, xmlSchemaValidCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 738 }
 739
 740 #endif /* LIBXML_SCHEMAS_ENABLED */
 741
 742 #define gen_nb_xmlHashDeallocator 2
 743 static void
 744 test_xmlHashDeallocator(void *payload ATTRIBUTE_UNUSED, xmlChar *name ATTRIBUTE_UNUSED) {
 745 }
 746
 747 static xmlHashDeallocator gen_xmlHashDeallocator(int no, int nr ATTRIBUTE_UNUSED) {
 748     if (no == 0) return(test_xmlHashDeallocator);
 749     return(NULL);
 750 }
 751 static void des_xmlHashDeallocator(int no ATTRIBUTE_UNUSED, xmlHashDeallocator val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 752 }
 753
 754
 755 static void desret_int(int val ATTRIBUTE_UNUSED) {
 756 }
 757 static void desret_xmlChar(xmlChar val ATTRIBUTE_UNUSED) {
 758 }
 759 static void desret_long(long val ATTRIBUTE_UNUSED) {
 760 }
 761 static void desret_unsigned_long(unsigned long val ATTRIBUTE_UNUSED) {
 762 }
 763 static void desret_double(double val ATTRIBUTE_UNUSED) {
 764 }
 765 static void desret_xmlCharEncoding(xmlCharEncoding val ATTRIBUTE_UNUSED) {
 766 }
 767 #if 0
 768 static void desret_const_void_ptr(void *val ATTRIBUTE_UNUSED) {
 769 }
 770 #endif
 771 static void desret_void_ptr(void *val ATTRIBUTE_UNUSED) {
 772 }
 773 static void desret_const_char_ptr(const char *val ATTRIBUTE_UNUSED) {
 774 }
 775 static void desret_const_xmlChar_ptr(const xmlChar *val ATTRIBUTE_UNUSED) {
 776 }
 777 static void desret_xmlChar_ptr(xmlChar *val) {
 778     if (val != NULL)
 779         xmlFree(val);
 780 }
 781 static void desret_xmlDocPtr(xmlDocPtr val) {
 782     if (val != api_doc)
 783         xmlFreeDoc(val);
 784 }
 785 static void desret_xmlDictPtr(xmlDictPtr val) {
 786     xmlDictFree(val);
 787 }
 788 #ifdef LIBXML_OUTPUT_ENABLED
 789 static void desret_xmlOutputBufferPtr(xmlOutputBufferPtr val) {
 790     xmlOutputBufferClose(val);
 791 }
 792 #endif
 793 #ifdef LIBXML_READER_ENABLED
 794 static void desret_xmlTextReaderPtr(xmlTextReaderPtr val) {
 795     xmlFreeTextReader(val);
 796 }
 797 #endif
 798 static void desret_xmlNodePtr(xmlNodePtr val) {
 799     if ((val != NULL) && (val != api_root) && (val != (xmlNodePtr) api_doc)) {
 800         xmlUnlinkNode(val);
 801         xmlFreeNode(val);
 802     }
 803 }
 804 static void desret_xmlAttrPtr(xmlAttrPtr val) {
 805     if (val != NULL) {
 806         xmlUnlinkNode((xmlNodePtr) val);
 807         xmlFreeNode((xmlNodePtr) val);
 808     }
 809 }
 810 static void desret_xmlEntityPtr(xmlEntityPtr val) {
 811     if (val != NULL) {
 812         xmlUnlinkNode((xmlNodePtr) val);
 813         xmlFreeNode((xmlNodePtr) val);
 814     }
 815 }
 816 static void desret_xmlElementPtr(xmlElementPtr val) {
 817     if (val != NULL) {
 818         xmlUnlinkNode((xmlNodePtr) val);
 819     }
 820 }
 821 static void desret_xmlAttributePtr(xmlAttributePtr val) {
 822     if (val != NULL) {
 823         xmlUnlinkNode((xmlNodePtr) val);
 824     }
 825 }
 826 static void desret_xmlNsPtr(xmlNsPtr val ATTRIBUTE_UNUSED) {
 827 }
 828 static void desret_xmlDtdPtr(xmlDtdPtr val) {
 829     desret_xmlNodePtr((xmlNodePtr)val);
 830 }
 831 #ifdef LIBXML_XPATH_ENABLED
 832 static void desret_xmlXPathObjectPtr(xmlXPathObjectPtr val) {
 833     xmlXPathFreeObject(val);
 834 }
 835 static void desret_xmlNodeSetPtr(xmlNodeSetPtr val) {
 836     xmlXPathFreeNodeSet(val);
 837 }
 838 #endif
 839 static void desret_xmlParserCtxtPtr(xmlParserCtxtPtr val) {
 840     xmlFreeParserCtxt(val);
 841 }
 842 static void desret_xmlParserInputBufferPtr(xmlParserInputBufferPtr val) {
 843     xmlFreeParserInputBuffer(val);
 844 }
 845 static void desret_xmlParserInputPtr(xmlParserInputPtr val) {
 846     xmlFreeInputStream(val);
 847 }
 848 #ifdef LIBXML_WRITER_ENABLED
 849 static void desret_xmlTextWriterPtr(xmlTextWriterPtr val) {
 850     xmlFreeTextWriter(val);
 851 }
 852 #endif
 853 static void desret_xmlBufferPtr(xmlBufferPtr val) {
 854     xmlBufferFree(val);
 855 }
 856 #ifdef LIBXML_SCHEMAS_ENABLED
 857 static void desret_xmlSchemaParserCtxtPtr(xmlSchemaParserCtxtPtr val) {
 858     xmlSchemaFreeParserCtxt(val);
 859 }
 860 static void desret_xmlSchemaTypePtr(xmlSchemaTypePtr val ATTRIBUTE_UNUSED) {
 861 }
 862 static void desret_xmlRelaxNGParserCtxtPtr(xmlRelaxNGParserCtxtPtr val) {
 863     xmlRelaxNGFreeParserCtxt(val);
 864 }
 865 #endif
 866 #ifdef LIBXML_HTML_ENABLED
 867 static void desret_const_htmlEntityDesc_ptr(const htmlEntityDesc * val ATTRIBUTE_UNUSED) {
 868 }
 869 #endif
 870 #ifdef LIBXML_HTTP_ENABLED
 871 static void desret_xmlNanoHTTPCtxtPtr(void *val) {
 872     xmlNanoHTTPClose(val);
 873 }
 874 #endif
 875 #ifdef LIBXML_FTP_ENABLED
 876 static void desret_xmlNanoFTPCtxtPtr(void *val) {
 877     xmlNanoFTPClose(val);
 878 }
 879 #endif
 880 /* cut and pasted from autogenerated to avoid troubles */
 881 #define gen_nb_const_xmlChar_ptr_ptr 1
 882 static xmlChar ** gen_const_xmlChar_ptr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 883     return(NULL);
 884 }
 885 static void des_const_xmlChar_ptr_ptr(int no ATTRIBUTE_UNUSED, const xmlChar ** val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 886 }
 887
 888 #define gen_nb_unsigned_char_ptr 1
 889 static unsigned char * gen_unsigned_char_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 890     return(NULL);
 891 }
 892 static void des_unsigned_char_ptr(int no ATTRIBUTE_UNUSED, unsigned char * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 893 }
 894
 895 #define gen_nb_const_unsigned_char_ptr 1
 896 static unsigned char * gen_const_unsigned_char_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 897     return(NULL);
 898 }
 899 static void des_const_unsigned_char_ptr(int no ATTRIBUTE_UNUSED, const unsigned char * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 900 }
 901
 902 #ifdef LIBXML_HTML_ENABLED
 903 #define gen_nb_const_htmlNodePtr 1
 904 static htmlNodePtr gen_const_htmlNodePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 905     return(NULL);
 906 }
 907 static void des_const_htmlNodePtr(int no ATTRIBUTE_UNUSED, const htmlNodePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 908 }
 909 #endif
 910
 911 #ifdef LIBXML_HTML_ENABLED
 912 #define gen_nb_htmlDocPtr 3
 913 static htmlDocPtr gen_htmlDocPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 914     if (no == 0) return(htmlNewDoc(NULL, NULL));
 915     if (no == 1) return(htmlReadMemory("<html/>", 7, "test", NULL, 0));
 916     return(NULL);
 917 }
 918 static void des_htmlDocPtr(int no ATTRIBUTE_UNUSED, htmlDocPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 919     if ((val != NULL) && (val != api_doc) && (val->doc != api_doc))
 920         xmlFreeDoc(val);
 921 }
 922 static void desret_htmlDocPtr(htmlDocPtr val) {
 923     if ((val != NULL) && (val != api_doc) && (val->doc != api_doc))
 924         xmlFreeDoc(val);
 925 }
 926 #define gen_nb_htmlParserCtxtPtr 3
 927 static htmlParserCtxtPtr gen_htmlParserCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 928     if (no == 0) return(xmlNewParserCtxt());
 929     if (no == 1) return(htmlCreateMemoryParserCtxt("<html/>", 7));
 930     return(NULL);
 931 }
 932 static void des_htmlParserCtxtPtr(int no ATTRIBUTE_UNUSED, htmlParserCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 933     if (val != NULL)
 934         htmlFreeParserCtxt(val);
 935 }
 936 static void desret_htmlParserCtxtPtr(htmlParserCtxtPtr val) {
 937     if (val != NULL)
 938         htmlFreeParserCtxt(val);
 939 }
 940 #endif
 941
 942 #ifdef LIBXML_XPATH_ENABLED
 943 #define gen_nb_xmlNodeSetPtr 1
 944 static xmlNodeSetPtr gen_xmlNodeSetPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 945     return(NULL);
 946 }
 947 static void des_xmlNodeSetPtr(int no ATTRIBUTE_UNUSED, xmlNodeSetPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 948 }
 949 #endif
 950
 951 #ifdef LIBXML_DEBUG_ENABLED
 952 #ifdef LIBXML_XPATH_ENABLED
 953 #define gen_nb_xmlShellCtxtPtr 1
 954 static xmlShellCtxtPtr gen_xmlShellCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 955     return(NULL);
 956 }
 957 static void des_xmlShellCtxtPtr(int no ATTRIBUTE_UNUSED, xmlShellCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 958 }
 959 #endif
 960 #endif
 961
 962 #ifdef LIBXML_PATTERN_ENABLED
 963 #define gen_nb_xmlPatternPtr 1
 964 static xmlPatternPtr gen_xmlPatternPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 965     return(NULL);
 966 }
 967 static void des_xmlPatternPtr(int no ATTRIBUTE_UNUSED, xmlPatternPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 968 }
 969 #endif
 970
 971 #define gen_nb_xmlElementContentPtr 1
 972 static xmlElementContentPtr gen_xmlElementContentPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 973     return(NULL);
 974 }
 975 static void des_xmlElementContentPtr(int no ATTRIBUTE_UNUSED, xmlElementContentPtr val, int nr ATTRIBUTE_UNUSED) {
 976     if (val != NULL)
 977         xmlFreeElementContent(val);
 978 }
 979 static void desret_xmlElementContentPtr(xmlElementContentPtr val) {
 980     if (val != NULL)
 981         xmlFreeElementContent(val);
 982 }
 983
 984 #define gen_nb_xmlParserNodeInfoSeqPtr 1
 985 static xmlParserNodeInfoSeqPtr gen_xmlParserNodeInfoSeqPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 986     return(NULL);
 987 }
 988 static void des_xmlParserNodeInfoSeqPtr(int no ATTRIBUTE_UNUSED, xmlParserNodeInfoSeqPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 989 }
 990
 991 static void desret_const_xmlParserNodeInfo_ptr(const xmlParserNodeInfo *val ATTRIBUTE_UNUSED) {
 992 }
 993
 994 #define gen_nb_void_ptr_ptr 1
 995 static void ** gen_void_ptr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 996     return(NULL);
 997 }
 998 static void des_void_ptr_ptr(int no ATTRIBUTE_UNUSED, void ** val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
 999 }
1000
1001 /************************************************************************
1002  *                                                                      *
1003  *   WARNING: end of the manually maintained part of the test code      *
1004  *            do not remove or alter the CUT HERE line                  *
1005  *                                                                      *
1006  ************************************************************************/
1007
1008 /* CUT HERE: everything below that line is generated */
1009 #ifdef LIBXML_HTML_ENABLED
1010 static void desret_htmlStatus(htmlStatus val ATTRIBUTE_UNUSED) {
1011 }
1012
1013 #endif
1014
1015 #define gen_nb_xmlAttributeDefault 4
1016 static xmlAttributeDefault gen_xmlAttributeDefault(int no, int nr ATTRIBUTE_UNUSED) {
1017     if (no == 1) return(XML_ATTRIBUTE_FIXED);
1018     if (no == 2) return(XML_ATTRIBUTE_IMPLIED);
1019     if (no == 3) return(XML_ATTRIBUTE_NONE);
1020     if (no == 4) return(XML_ATTRIBUTE_REQUIRED);
1021     return(0);
1022 }
1023
1024 static void des_xmlAttributeDefault(int no ATTRIBUTE_UNUSED, xmlAttributeDefault val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1025 }
1026
1027 #define gen_nb_xmlAttributeType 4
1028 static xmlAttributeType gen_xmlAttributeType(int no, int nr ATTRIBUTE_UNUSED) {
1029     if (no == 1) return(XML_ATTRIBUTE_CDATA);
1030     if (no == 2) return(XML_ATTRIBUTE_ENTITIES);
1031     if (no == 3) return(XML_ATTRIBUTE_ENTITY);
1032     if (no == 4) return(XML_ATTRIBUTE_ENUMERATION);
1033     return(0);
1034 }
1035
1036 static void des_xmlAttributeType(int no ATTRIBUTE_UNUSED, xmlAttributeType val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1037 }
1038
1039 #define gen_nb_xmlBufferAllocationScheme 4
1040 static xmlBufferAllocationScheme gen_xmlBufferAllocationScheme(int no, int nr ATTRIBUTE_UNUSED) {
1041     if (no == 1) return(XML_BUFFER_ALLOC_DOUBLEIT);
1042     if (no == 2) return(XML_BUFFER_ALLOC_EXACT);
1043     if (no == 3) return(XML_BUFFER_ALLOC_IMMUTABLE);
1044     if (no == 4) return(XML_BUFFER_ALLOC_IO);
1045     return(0);
1046 }
1047
1048 static void des_xmlBufferAllocationScheme(int no ATTRIBUTE_UNUSED, xmlBufferAllocationScheme val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1049 }
1050
1051 static void desret_xmlBufferAllocationScheme(xmlBufferAllocationScheme val ATTRIBUTE_UNUSED) {
1052 }
1053
1054 #ifdef LIBXML_CATALOG_ENABLED
1055 #define gen_nb_xmlCatalogAllow 4
1056 static xmlCatalogAllow gen_xmlCatalogAllow(int no, int nr ATTRIBUTE_UNUSED) {
1057     if (no == 1) return(XML_CATA_ALLOW_ALL);
1058     if (no == 2) return(XML_CATA_ALLOW_DOCUMENT);
1059     if (no == 3) return(XML_CATA_ALLOW_GLOBAL);
1060     if (no == 4) return(XML_CATA_ALLOW_NONE);
1061     return(0);
1062 }
1063
1064 static void des_xmlCatalogAllow(int no ATTRIBUTE_UNUSED, xmlCatalogAllow val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1065 }
1066
1067 static void desret_xmlCatalogAllow(xmlCatalogAllow val ATTRIBUTE_UNUSED) {
1068 }
1069
1070 #endif
1071
1072 #ifdef LIBXML_CATALOG_ENABLED
1073 #define gen_nb_xmlCatalogPrefer 3
1074 static xmlCatalogPrefer gen_xmlCatalogPrefer(int no, int nr ATTRIBUTE_UNUSED) {
1075     if (no == 1) return(XML_CATA_PREFER_NONE);
1076     if (no == 2) return(XML_CATA_PREFER_PUBLIC);
1077     if (no == 3) return(XML_CATA_PREFER_SYSTEM);
1078     return(0);
1079 }
1080
1081 static void des_xmlCatalogPrefer(int no ATTRIBUTE_UNUSED, xmlCatalogPrefer val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1082 }
1083
1084 static void desret_xmlCatalogPrefer(xmlCatalogPrefer val ATTRIBUTE_UNUSED) {
1085 }
1086
1087 #endif
1088
1089 #define gen_nb_xmlElementContentType 4
1090 static xmlElementContentType gen_xmlElementContentType(int no, int nr ATTRIBUTE_UNUSED) {
1091     if (no == 1) return(XML_ELEMENT_CONTENT_ELEMENT);
1092     if (no == 2) return(XML_ELEMENT_CONTENT_OR);
1093     if (no == 3) return(XML_ELEMENT_CONTENT_PCDATA);
1094     if (no == 4) return(XML_ELEMENT_CONTENT_SEQ);
1095     return(0);
1096 }
1097
1098 static void des_xmlElementContentType(int no ATTRIBUTE_UNUSED, xmlElementContentType val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1099 }
1100
1101 #define gen_nb_xmlElementTypeVal 4
1102 static xmlElementTypeVal gen_xmlElementTypeVal(int no, int nr ATTRIBUTE_UNUSED) {
1103     if (no == 1) return(XML_ELEMENT_TYPE_ANY);
1104     if (no == 2) return(XML_ELEMENT_TYPE_ELEMENT);
1105     if (no == 3) return(XML_ELEMENT_TYPE_EMPTY);
1106     if (no == 4) return(XML_ELEMENT_TYPE_MIXED);
1107     return(0);
1108 }
1109
1110 static void des_xmlElementTypeVal(int no ATTRIBUTE_UNUSED, xmlElementTypeVal val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1111 }
1112
1113 #define gen_nb_xmlFeature 4
1114 static xmlFeature gen_xmlFeature(int no, int nr ATTRIBUTE_UNUSED) {
1115     if (no == 1) return(XML_WITH_AUTOMATA);
1116     if (no == 2) return(XML_WITH_C14N);
1117     if (no == 3) return(XML_WITH_CATALOG);
1118     if (no == 4) return(XML_WITH_DEBUG);
1119     return(0);
1120 }
1121
1122 static void des_xmlFeature(int no ATTRIBUTE_UNUSED, xmlFeature val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1123 }
1124
1125 static void desret_xmlParserErrors(xmlParserErrors val ATTRIBUTE_UNUSED) {
1126 }
1127
1128 #ifdef LIBXML_SCHEMAS_ENABLED
1129 #define gen_nb_xmlSchemaValType 4
1130 static xmlSchemaValType gen_xmlSchemaValType(int no, int nr ATTRIBUTE_UNUSED) {
1131     if (no == 1) return(XML_SCHEMAS_ANYSIMPLETYPE);
1132     if (no == 2) return(XML_SCHEMAS_ANYTYPE);
1133     if (no == 3) return(XML_SCHEMAS_ANYURI);
1134     if (no == 4) return(XML_SCHEMAS_BASE64BINARY);
1135     return(0);
1136 }
1137
1138 static void des_xmlSchemaValType(int no ATTRIBUTE_UNUSED, xmlSchemaValType val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1139 }
1140
1141 static void desret_xmlSchemaValType(xmlSchemaValType val ATTRIBUTE_UNUSED) {
1142 }
1143
1144 #endif
1145
1146 #ifdef LIBXML_SCHEMAS_ENABLED
1147 #define gen_nb_xmlSchemaWhitespaceValueType 4
1148 static xmlSchemaWhitespaceValueType gen_xmlSchemaWhitespaceValueType(int no, int nr ATTRIBUTE_UNUSED) {
1149     if (no == 1) return(XML_SCHEMA_WHITESPACE_COLLAPSE);
1150     if (no == 2) return(XML_SCHEMA_WHITESPACE_PRESERVE);
1151     if (no == 3) return(XML_SCHEMA_WHITESPACE_REPLACE);
1152     if (no == 4) return(XML_SCHEMA_WHITESPACE_UNKNOWN);
1153     return(0);
1154 }
1155
1156 static void des_xmlSchemaWhitespaceValueType(int no ATTRIBUTE_UNUSED, xmlSchemaWhitespaceValueType val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1157 }
1158
1159 #endif
1160
1161 #include <libxml/HTMLparser.h>
1162 #include <libxml/HTMLtree.h>
1163 #include <libxml/SAX2.h>
1164 #include <libxml/c14n.h>
1165 #include <libxml/catalog.h>
1166 #include <libxml/chvalid.h>
1167 #include <libxml/debugXML.h>
1168 #include <libxml/dict.h>
1169 #include <libxml/encoding.h>
1170 #include <libxml/entities.h>
1171 #include <libxml/hash.h>
1172 #include <libxml/list.h>
1173 #include <libxml/nanoftp.h>
1174 #include <libxml/nanohttp.h>
1175 #include <libxml/parser.h>
1176 #include <libxml/parserInternals.h>
1177 #include <libxml/pattern.h>
1178 #include <libxml/relaxng.h>
1179 #include <libxml/schemasInternals.h>
1180 #include <libxml/schematron.h>
1181 #include <libxml/tree.h>
1182 #include <libxml/uri.h>
1183 #include <libxml/valid.h>
1184 #include <libxml/xinclude.h>
1185 #include <libxml/xmlIO.h>
1186 #include <libxml/xmlautomata.h>
1187 #include <libxml/xmlerror.h>
1188 #include <libxml/xmlmodule.h>
1189 #include <libxml/xmlreader.h>
1190 #include <libxml/xmlregexp.h>
1191 #include <libxml/xmlsave.h>
1192 #include <libxml/xmlschemas.h>
1193 #include <libxml/xmlschemastypes.h>
1194 #include <libxml/xmlstring.h>
1195 #include <libxml/xmlunicode.h>
1196 #include <libxml/xmlwriter.h>
1197 #include <libxml/xpath.h>
1198 #include <libxml/xpathInternals.h>
1199 #include <libxml/xpointer.h>
1200 static int test_HTMLparser(void);
1201 static int test_HTMLtree(void);
1202 static int test_SAX2(void);
1203 static int test_c14n(void);
1204 static int test_catalog(void);
1205 static int test_chvalid(void);
1206 static int test_debugXML(void);
1207 static int test_dict(void);
1208 static int test_encoding(void);
1209 static int test_entities(void);
1210 static int test_hash(void);
1211 static int test_list(void);
1212 static int test_nanoftp(void);
1213 static int test_nanohttp(void);
1214 static int test_parser(void);
1215 static int test_parserInternals(void);
1216 static int test_pattern(void);
1217 static int test_relaxng(void);
1218 static int test_schemasInternals(void);
1219 static int test_schematron(void);
1220 static int test_tree(void);
1221 static int test_uri(void);
1222 static int test_valid(void);
1223 static int test_xinclude(void);
1224 static int test_xmlIO(void);
1225 static int test_xmlautomata(void);
1226 static int test_xmlerror(void);
1227 static int test_xmlmodule(void);
1228 static int test_xmlreader(void);
1229 static int test_xmlregexp(void);
1230 static int test_xmlsave(void);
1231 static int test_xmlschemas(void);
1232 static int test_xmlschemastypes(void);
1233 static int test_xmlstring(void);
1234 static int test_xmlunicode(void);
1235 static int test_xmlwriter(void);
1236 static int test_xpath(void);
1237 static int test_xpathInternals(void);
1238 static int test_xpointer(void);
1239
1240 /**
1241  * testlibxml2:
1242  *
1243  * Main entry point of the tester for the full libxml2 module,
1244  * it calls all the tester entry point for each module.
1245  *
1246  * Returns the number of error found
1247  */
1248 static int
1249 testlibxml2(void)
1250 {
1251     int test_ret = 0;
1252
1253     test_ret += test_HTMLparser();
1254     test_ret += test_HTMLtree();
1255     test_ret += test_SAX2();
1256     test_ret += test_c14n();
1257     test_ret += test_catalog();
1258     test_ret += test_chvalid();
1259     test_ret += test_debugXML();
1260     test_ret += test_dict();
1261     test_ret += test_encoding();
1262     test_ret += test_entities();
1263     test_ret += test_hash();
1264     test_ret += test_list();
1265     test_ret += test_nanoftp();
1266     test_ret += test_nanohttp();
1267     test_ret += test_parser();
1268     test_ret += test_parserInternals();
1269     test_ret += test_pattern();
1270     test_ret += test_relaxng();
1271     test_ret += test_schemasInternals();
1272     test_ret += test_schematron();
1273     test_ret += test_tree();
1274     test_ret += test_uri();
1275     test_ret += test_valid();
1276     test_ret += test_xinclude();
1277     test_ret += test_xmlIO();
1278     test_ret += test_xmlautomata();
1279     test_ret += test_xmlerror();
1280     test_ret += test_xmlmodule();
1281     test_ret += test_xmlreader();
1282     test_ret += test_xmlregexp();
1283     test_ret += test_xmlsave();
1284     test_ret += test_xmlschemas();
1285     test_ret += test_xmlschemastypes();
1286     test_ret += test_xmlstring();
1287     test_ret += test_xmlunicode();
1288     test_ret += test_xmlwriter();
1289     test_ret += test_xpath();
1290     test_ret += test_xpathInternals();
1291     test_ret += test_xpointer();
1292
1293     printf("Total: %d functions, %d tests, %d errors\n",
1294            function_tests, call_tests, test_ret);
1295     return(test_ret);
1296 }
1297
1298
1299 static int
1300 test_UTF8ToHtml(void) {
1301     int test_ret = 0;
1302
1303 #if defined(LIBXML_HTML_ENABLED)
1304     int mem_base;
1305     int ret_val;
1306     unsigned char * out; /* a pointer to an array of bytes to store the result */
1307     int n_out;
1308     int * outlen; /* the length of @out */
1309     int n_outlen;
1310     unsigned char * in; /* a pointer to an array of UTF-8 chars */
1311     int n_in;
1312     int * inlen; /* the length of @in */
1313     int n_inlen;
1314
1315     for (n_out = 0;n_out < gen_nb_unsigned_char_ptr;n_out++) {
1316     for (n_outlen = 0;n_outlen < gen_nb_int_ptr;n_outlen++) {
1317     for (n_in = 0;n_in < gen_nb_const_unsigned_char_ptr;n_in++) {
1318     for (n_inlen = 0;n_inlen < gen_nb_int_ptr;n_inlen++) {
1319         mem_base = xmlMemBlocks();
1320         out = gen_unsigned_char_ptr(n_out, 0);
1321         outlen = gen_int_ptr(n_outlen, 1);
1322         in = gen_const_unsigned_char_ptr(n_in, 2);
1323         inlen = gen_int_ptr(n_inlen, 3);
1324
1325         ret_val = UTF8ToHtml(out, outlen, (const unsigned char *)in, inlen);
1326         desret_int(ret_val);
1327         call_tests++;
1328         des_unsigned_char_ptr(n_out, out, 0);
1329         des_int_ptr(n_outlen, outlen, 1);
1330         des_const_unsigned_char_ptr(n_in, (const unsigned char *)in, 2);
1331         des_int_ptr(n_inlen, inlen, 3);
1332         xmlResetLastError();
1333         if (mem_base != xmlMemBlocks()) {
1334             printf("Leak of %d blocks found in UTF8ToHtml",
1335                    xmlMemBlocks() - mem_base);
1336             test_ret++;
1337             printf(" %d", n_out);
1338             printf(" %d", n_outlen);
1339             printf(" %d", n_in);
1340             printf(" %d", n_inlen);
1341             printf("\n");
1342         }
1343     }
1344     }
1345     }
1346     }
1347     function_tests++;
1348 #endif
1349
1350     return(test_ret);
1351 }
1352
1353 #ifdef LIBXML_HTML_ENABLED
1354
1355 #define gen_nb_const_htmlElemDesc_ptr 1
1356 static htmlElemDesc * gen_const_htmlElemDesc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1357     return(NULL);
1358 }
1359 static void des_const_htmlElemDesc_ptr(int no ATTRIBUTE_UNUSED, const htmlElemDesc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1360 }
1361 #endif
1362
1363
1364 static int
1365 test_htmlAttrAllowed(void) {
1366     int test_ret = 0;
1367
1368 #if defined(LIBXML_HTML_ENABLED)
1369     int mem_base;
1370     htmlStatus ret_val;
1371     htmlElemDesc * elt; /* HTML element */
1372     int n_elt;
1373     xmlChar * attr; /* HTML attribute */
1374     int n_attr;
1375     int legacy; /* whether to allow deprecated attributes */
1376     int n_legacy;
1377
1378     for (n_elt = 0;n_elt < gen_nb_const_htmlElemDesc_ptr;n_elt++) {
1379     for (n_attr = 0;n_attr < gen_nb_const_xmlChar_ptr;n_attr++) {
1380     for (n_legacy = 0;n_legacy < gen_nb_int;n_legacy++) {
1381         mem_base = xmlMemBlocks();
1382         elt = gen_const_htmlElemDesc_ptr(n_elt, 0);
1383         attr = gen_const_xmlChar_ptr(n_attr, 1);
1384         legacy = gen_int(n_legacy, 2);
1385
1386         ret_val = htmlAttrAllowed((const htmlElemDesc *)elt, (const xmlChar *)attr, legacy);
1387         desret_htmlStatus(ret_val);
1388         call_tests++;
1389         des_const_htmlElemDesc_ptr(n_elt, (const htmlElemDesc *)elt, 0);
1390         des_const_xmlChar_ptr(n_attr, (const xmlChar *)attr, 1);
1391         des_int(n_legacy, legacy, 2);
1392         xmlResetLastError();
1393         if (mem_base != xmlMemBlocks()) {
1394             printf("Leak of %d blocks found in htmlAttrAllowed",
1395                    xmlMemBlocks() - mem_base);
1396             test_ret++;
1397             printf(" %d", n_elt);
1398             printf(" %d", n_attr);
1399             printf(" %d", n_legacy);
1400             printf("\n");
1401         }
1402     }
1403     }
1404     }
1405     function_tests++;
1406 #endif
1407
1408     return(test_ret);
1409 }
1410
1411 #ifdef LIBXML_HTML_ENABLED
1412
1413 #define gen_nb_htmlNodePtr 1
1414 static htmlNodePtr gen_htmlNodePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1415     return(NULL);
1416 }
1417 static void des_htmlNodePtr(int no ATTRIBUTE_UNUSED, htmlNodePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1418 }
1419 #endif
1420
1421
1422 static int
1423 test_htmlAutoCloseTag(void) {
1424     int test_ret = 0;
1425
1426 #if defined(LIBXML_HTML_ENABLED)
1427     int mem_base;
1428     int ret_val;
1429     htmlDocPtr doc; /* the HTML document */
1430     int n_doc;
1431     xmlChar * name; /* The tag name */
1432     int n_name;
1433     htmlNodePtr elem; /* the HTML element */
1434     int n_elem;
1435
1436     for (n_doc = 0;n_doc < gen_nb_htmlDocPtr;n_doc++) {
1437     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
1438     for (n_elem = 0;n_elem < gen_nb_htmlNodePtr;n_elem++) {
1439         mem_base = xmlMemBlocks();
1440         doc = gen_htmlDocPtr(n_doc, 0);
1441         name = gen_const_xmlChar_ptr(n_name, 1);
1442         elem = gen_htmlNodePtr(n_elem, 2);
1443
1444         ret_val = htmlAutoCloseTag(doc, (const xmlChar *)name, elem);
1445         desret_int(ret_val);
1446         call_tests++;
1447         des_htmlDocPtr(n_doc, doc, 0);
1448         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
1449         des_htmlNodePtr(n_elem, elem, 2);
1450         xmlResetLastError();
1451         if (mem_base != xmlMemBlocks()) {
1452             printf("Leak of %d blocks found in htmlAutoCloseTag",
1453                    xmlMemBlocks() - mem_base);
1454             test_ret++;
1455             printf(" %d", n_doc);
1456             printf(" %d", n_name);
1457             printf(" %d", n_elem);
1458             printf("\n");
1459         }
1460     }
1461     }
1462     }
1463     function_tests++;
1464 #endif
1465
1466     return(test_ret);
1467 }
1468
1469
1470 static int
1471 test_htmlCreateMemoryParserCtxt(void) {
1472     int test_ret = 0;
1473
1474 #if defined(LIBXML_HTML_ENABLED)
1475     int mem_base;
1476     htmlParserCtxtPtr ret_val;
1477     char * buffer; /* a pointer to a char array */
1478     int n_buffer;
1479     int size; /* the size of the array */
1480     int n_size;
1481
1482     for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
1483     for (n_size = 0;n_size < gen_nb_int;n_size++) {
1484         mem_base = xmlMemBlocks();
1485         buffer = gen_const_char_ptr(n_buffer, 0);
1486         size = gen_int(n_size, 1);
1487
1488         ret_val = htmlCreateMemoryParserCtxt((const char *)buffer, size);
1489         desret_htmlParserCtxtPtr(ret_val);
1490         call_tests++;
1491         des_const_char_ptr(n_buffer, (const char *)buffer, 0);
1492         des_int(n_size, size, 1);
1493         xmlResetLastError();
1494         if (mem_base != xmlMemBlocks()) {
1495             printf("Leak of %d blocks found in htmlCreateMemoryParserCtxt",
1496                    xmlMemBlocks() - mem_base);
1497             test_ret++;
1498             printf(" %d", n_buffer);
1499             printf(" %d", n_size);
1500             printf("\n");
1501         }
1502     }
1503     }
1504     function_tests++;
1505 #endif
1506
1507     return(test_ret);
1508 }
1509
1510 #ifdef LIBXML_HTML_ENABLED
1511
1512 #define gen_nb_htmlSAXHandlerPtr 1
1513 static htmlSAXHandlerPtr gen_htmlSAXHandlerPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1514     return(NULL);
1515 }
1516 static void des_htmlSAXHandlerPtr(int no ATTRIBUTE_UNUSED, htmlSAXHandlerPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
1517 }
1518 #endif
1519
1520
1521 static int
1522 test_htmlCreatePushParserCtxt(void) {
1523     int test_ret = 0;
1524
1525 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_PUSH_ENABLED)
1526     int mem_base;
1527     htmlParserCtxtPtr ret_val;
1528     htmlSAXHandlerPtr sax; /* a SAX handler */
1529     int n_sax;
1530     void * user_data; /* The user data returned on SAX callbacks */
1531     int n_user_data;
1532     char * chunk; /* a pointer to an array of chars */
1533     int n_chunk;
1534     int size; /* number of chars in the array */
1535     int n_size;
1536     const char * filename; /* an optional file name or URI */
1537     int n_filename;
1538     xmlCharEncoding enc; /* an optional encoding */
1539     int n_enc;
1540
1541     for (n_sax = 0;n_sax < gen_nb_htmlSAXHandlerPtr;n_sax++) {
1542     for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
1543     for (n_chunk = 0;n_chunk < gen_nb_const_char_ptr;n_chunk++) {
1544     for (n_size = 0;n_size < gen_nb_int;n_size++) {
1545     for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
1546     for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
1547         mem_base = xmlMemBlocks();
1548         sax = gen_htmlSAXHandlerPtr(n_sax, 0);
1549         user_data = gen_userdata(n_user_data, 1);
1550         chunk = gen_const_char_ptr(n_chunk, 2);
1551         size = gen_int(n_size, 3);
1552         filename = gen_fileoutput(n_filename, 4);
1553         enc = gen_xmlCharEncoding(n_enc, 5);
1554
1555         ret_val = htmlCreatePushParserCtxt(sax, user_data, (const char *)chunk, size, filename, enc);
1556         desret_htmlParserCtxtPtr(ret_val);
1557         call_tests++;
1558         des_htmlSAXHandlerPtr(n_sax, sax, 0);
1559         des_userdata(n_user_data, user_data, 1);
1560         des_const_char_ptr(n_chunk, (const char *)chunk, 2);
1561         des_int(n_size, size, 3);
1562         des_fileoutput(n_filename, filename, 4);
1563         des_xmlCharEncoding(n_enc, enc, 5);
1564         xmlResetLastError();
1565         if (mem_base != xmlMemBlocks()) {
1566             printf("Leak of %d blocks found in htmlCreatePushParserCtxt",
1567                    xmlMemBlocks() - mem_base);
1568             test_ret++;
1569             printf(" %d", n_sax);
1570             printf(" %d", n_user_data);
1571             printf(" %d", n_chunk);
1572             printf(" %d", n_size);
1573             printf(" %d", n_filename);
1574             printf(" %d", n_enc);
1575             printf("\n");
1576         }
1577     }
1578     }
1579     }
1580     }
1581     }
1582     }
1583     function_tests++;
1584 #endif
1585
1586     return(test_ret);
1587 }
1588
1589
1590 static int
1591 test_htmlCtxtReadDoc(void) {
1592     int test_ret = 0;
1593
1594 #if defined(LIBXML_HTML_ENABLED)
1595     int mem_base;
1596     htmlDocPtr ret_val;
1597     htmlParserCtxtPtr ctxt; /* an HTML parser context */
1598     int n_ctxt;
1599     xmlChar * cur; /* a pointer to a zero terminated string */
1600     int n_cur;
1601     const char * URL; /* the base URL to use for the document */
1602     int n_URL;
1603     char * encoding; /* the document encoding, or NULL */
1604     int n_encoding;
1605     int options; /* a combination of htmlParserOption(s) */
1606     int n_options;
1607
1608     for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
1609     for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
1610     for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
1611     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
1612     for (n_options = 0;n_options < gen_nb_int;n_options++) {
1613         mem_base = xmlMemBlocks();
1614         ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
1615         cur = gen_const_xmlChar_ptr(n_cur, 1);
1616         URL = gen_filepath(n_URL, 2);
1617         encoding = gen_const_char_ptr(n_encoding, 3);
1618         options = gen_int(n_options, 4);
1619
1620         ret_val = htmlCtxtReadDoc(ctxt, (const xmlChar *)cur, URL, (const char *)encoding, options);
1621         desret_htmlDocPtr(ret_val);
1622         call_tests++;
1623         des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
1624         des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 1);
1625         des_filepath(n_URL, URL, 2);
1626         des_const_char_ptr(n_encoding, (const char *)encoding, 3);
1627         des_int(n_options, options, 4);
1628         xmlResetLastError();
1629         if (mem_base != xmlMemBlocks()) {
1630             printf("Leak of %d blocks found in htmlCtxtReadDoc",
1631                    xmlMemBlocks() - mem_base);
1632             test_ret++;
1633             printf(" %d", n_ctxt);
1634             printf(" %d", n_cur);
1635             printf(" %d", n_URL);
1636             printf(" %d", n_encoding);
1637             printf(" %d", n_options);
1638             printf("\n");
1639         }
1640     }
1641     }
1642     }
1643     }
1644     }
1645     function_tests++;
1646 #endif
1647
1648     return(test_ret);
1649 }
1650
1651
1652 static int
1653 test_htmlCtxtReadFile(void) {
1654     int test_ret = 0;
1655
1656 #if defined(LIBXML_HTML_ENABLED)
1657     htmlDocPtr ret_val;
1658     htmlParserCtxtPtr ctxt; /* an HTML parser context */
1659     int n_ctxt;
1660     const char * filename; /* a file or URL */
1661     int n_filename;
1662     char * encoding; /* the document encoding, or NULL */
1663     int n_encoding;
1664     int options; /* a combination of htmlParserOption(s) */
1665     int n_options;
1666
1667     for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
1668     for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
1669     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
1670     for (n_options = 0;n_options < gen_nb_int;n_options++) {
1671         ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
1672         filename = gen_filepath(n_filename, 1);
1673         encoding = gen_const_char_ptr(n_encoding, 2);
1674         options = gen_int(n_options, 3);
1675
1676         ret_val = htmlCtxtReadFile(ctxt, filename, (const char *)encoding, options);
1677         desret_htmlDocPtr(ret_val);
1678         call_tests++;
1679         des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
1680         des_filepath(n_filename, filename, 1);
1681         des_const_char_ptr(n_encoding, (const char *)encoding, 2);
1682         des_int(n_options, options, 3);
1683         xmlResetLastError();
1684     }
1685     }
1686     }
1687     }
1688     function_tests++;
1689 #endif
1690
1691     return(test_ret);
1692 }
1693
1694
1695 static int
1696 test_htmlCtxtReadMemory(void) {
1697     int test_ret = 0;
1698
1699 #if defined(LIBXML_HTML_ENABLED)
1700     int mem_base;
1701     htmlDocPtr ret_val;
1702     htmlParserCtxtPtr ctxt; /* an HTML parser context */
1703     int n_ctxt;
1704     char * buffer; /* a pointer to a char array */
1705     int n_buffer;
1706     int size; /* the size of the array */
1707     int n_size;
1708     const char * URL; /* the base URL to use for the document */
1709     int n_URL;
1710     char * encoding; /* the document encoding, or NULL */
1711     int n_encoding;
1712     int options; /* a combination of htmlParserOption(s) */
1713     int n_options;
1714
1715     for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
1716     for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
1717     for (n_size = 0;n_size < gen_nb_int;n_size++) {
1718     for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
1719     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
1720     for (n_options = 0;n_options < gen_nb_int;n_options++) {
1721         mem_base = xmlMemBlocks();
1722         ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
1723         buffer = gen_const_char_ptr(n_buffer, 1);
1724         size = gen_int(n_size, 2);
1725         URL = gen_filepath(n_URL, 3);
1726         encoding = gen_const_char_ptr(n_encoding, 4);
1727         options = gen_int(n_options, 5);
1728
1729         ret_val = htmlCtxtReadMemory(ctxt, (const char *)buffer, size, URL, (const char *)encoding, options);
1730         desret_htmlDocPtr(ret_val);
1731         call_tests++;
1732         des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
1733         des_const_char_ptr(n_buffer, (const char *)buffer, 1);
1734         des_int(n_size, size, 2);
1735         des_filepath(n_URL, URL, 3);
1736         des_const_char_ptr(n_encoding, (const char *)encoding, 4);
1737         des_int(n_options, options, 5);
1738         xmlResetLastError();
1739         if (mem_base != xmlMemBlocks()) {
1740             printf("Leak of %d blocks found in htmlCtxtReadMemory",
1741                    xmlMemBlocks() - mem_base);
1742             test_ret++;
1743             printf(" %d", n_ctxt);
1744             printf(" %d", n_buffer);
1745             printf(" %d", n_size);
1746             printf(" %d", n_URL);
1747             printf(" %d", n_encoding);
1748             printf(" %d", n_options);
1749             printf("\n");
1750         }
1751     }
1752     }
1753     }
1754     }
1755     }
1756     }
1757     function_tests++;
1758 #endif
1759
1760     return(test_ret);
1761 }
1762
1763
1764 static int
1765 test_htmlCtxtReset(void) {
1766     int test_ret = 0;
1767
1768 #if defined(LIBXML_HTML_ENABLED)
1769     int mem_base;
1770     htmlParserCtxtPtr ctxt; /* an HTML parser context */
1771     int n_ctxt;
1772
1773     for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
1774         mem_base = xmlMemBlocks();
1775         ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
1776
1777         htmlCtxtReset(ctxt);
1778         call_tests++;
1779         des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
1780         xmlResetLastError();
1781         if (mem_base != xmlMemBlocks()) {
1782             printf("Leak of %d blocks found in htmlCtxtReset",
1783                    xmlMemBlocks() - mem_base);
1784             test_ret++;
1785             printf(" %d", n_ctxt);
1786             printf("\n");
1787         }
1788     }
1789     function_tests++;
1790 #endif
1791
1792     return(test_ret);
1793 }
1794
1795
1796 static int
1797 test_htmlCtxtUseOptions(void) {
1798     int test_ret = 0;
1799
1800 #if defined(LIBXML_HTML_ENABLED)
1801     int mem_base;
1802     int ret_val;
1803     htmlParserCtxtPtr ctxt; /* an HTML parser context */
1804     int n_ctxt;
1805     int options; /* a combination of htmlParserOption(s) */
1806     int n_options;
1807
1808     for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
1809     for (n_options = 0;n_options < gen_nb_int;n_options++) {
1810         mem_base = xmlMemBlocks();
1811         ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
1812         options = gen_int(n_options, 1);
1813
1814         ret_val = htmlCtxtUseOptions(ctxt, options);
1815         desret_int(ret_val);
1816         call_tests++;
1817         des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
1818         des_int(n_options, options, 1);
1819         xmlResetLastError();
1820         if (mem_base != xmlMemBlocks()) {
1821             printf("Leak of %d blocks found in htmlCtxtUseOptions",
1822                    xmlMemBlocks() - mem_base);
1823             test_ret++;
1824             printf(" %d", n_ctxt);
1825             printf(" %d", n_options);
1826             printf("\n");
1827         }
1828     }
1829     }
1830     function_tests++;
1831 #endif
1832
1833     return(test_ret);
1834 }
1835
1836
1837 static int
1838 test_htmlElementAllowedHere(void) {
1839     int test_ret = 0;
1840
1841 #if defined(LIBXML_HTML_ENABLED)
1842     int mem_base;
1843     int ret_val;
1844     htmlElemDesc * parent; /* HTML parent element */
1845     int n_parent;
1846     xmlChar * elt; /* HTML element */
1847     int n_elt;
1848
1849     for (n_parent = 0;n_parent < gen_nb_const_htmlElemDesc_ptr;n_parent++) {
1850     for (n_elt = 0;n_elt < gen_nb_const_xmlChar_ptr;n_elt++) {
1851         mem_base = xmlMemBlocks();
1852         parent = gen_const_htmlElemDesc_ptr(n_parent, 0);
1853         elt = gen_const_xmlChar_ptr(n_elt, 1);
1854
1855         ret_val = htmlElementAllowedHere((const htmlElemDesc *)parent, (const xmlChar *)elt);
1856         desret_int(ret_val);
1857         call_tests++;
1858         des_const_htmlElemDesc_ptr(n_parent, (const htmlElemDesc *)parent, 0);
1859         des_const_xmlChar_ptr(n_elt, (const xmlChar *)elt, 1);
1860         xmlResetLastError();
1861         if (mem_base != xmlMemBlocks()) {
1862             printf("Leak of %d blocks found in htmlElementAllowedHere",
1863                    xmlMemBlocks() - mem_base);
1864             test_ret++;
1865             printf(" %d", n_parent);
1866             printf(" %d", n_elt);
1867             printf("\n");
1868         }
1869     }
1870     }
1871     function_tests++;
1872 #endif
1873
1874     return(test_ret);
1875 }
1876
1877
1878 static int
1879 test_htmlElementStatusHere(void) {
1880     int test_ret = 0;
1881
1882 #if defined(LIBXML_HTML_ENABLED)
1883     int mem_base;
1884     htmlStatus ret_val;
1885     htmlElemDesc * parent; /* HTML parent element */
1886     int n_parent;
1887     htmlElemDesc * elt; /* HTML element */
1888     int n_elt;
1889
1890     for (n_parent = 0;n_parent < gen_nb_const_htmlElemDesc_ptr;n_parent++) {
1891     for (n_elt = 0;n_elt < gen_nb_const_htmlElemDesc_ptr;n_elt++) {
1892         mem_base = xmlMemBlocks();
1893         parent = gen_const_htmlElemDesc_ptr(n_parent, 0);
1894         elt = gen_const_htmlElemDesc_ptr(n_elt, 1);
1895
1896         ret_val = htmlElementStatusHere((const htmlElemDesc *)parent, (const htmlElemDesc *)elt);
1897         desret_htmlStatus(ret_val);
1898         call_tests++;
1899         des_const_htmlElemDesc_ptr(n_parent, (const htmlElemDesc *)parent, 0);
1900         des_const_htmlElemDesc_ptr(n_elt, (const htmlElemDesc *)elt, 1);
1901         xmlResetLastError();
1902         if (mem_base != xmlMemBlocks()) {
1903             printf("Leak of %d blocks found in htmlElementStatusHere",
1904                    xmlMemBlocks() - mem_base);
1905             test_ret++;
1906             printf(" %d", n_parent);
1907             printf(" %d", n_elt);
1908             printf("\n");
1909         }
1910     }
1911     }
1912     function_tests++;
1913 #endif
1914
1915     return(test_ret);
1916 }
1917
1918
1919 static int
1920 test_htmlEncodeEntities(void) {
1921     int test_ret = 0;
1922
1923 #if defined(LIBXML_HTML_ENABLED)
1924     int mem_base;
1925     int ret_val;
1926     unsigned char * out; /* a pointer to an array of bytes to store the result */
1927     int n_out;
1928     int * outlen; /* the length of @out */
1929     int n_outlen;
1930     unsigned char * in; /* a pointer to an array of UTF-8 chars */
1931     int n_in;
1932     int * inlen; /* the length of @in */
1933     int n_inlen;
1934     int quoteChar; /* the quote character to escape (' or ") or zero. */
1935     int n_quoteChar;
1936
1937     for (n_out = 0;n_out < gen_nb_unsigned_char_ptr;n_out++) {
1938     for (n_outlen = 0;n_outlen < gen_nb_int_ptr;n_outlen++) {
1939     for (n_in = 0;n_in < gen_nb_const_unsigned_char_ptr;n_in++) {
1940     for (n_inlen = 0;n_inlen < gen_nb_int_ptr;n_inlen++) {
1941     for (n_quoteChar = 0;n_quoteChar < gen_nb_int;n_quoteChar++) {
1942         mem_base = xmlMemBlocks();
1943         out = gen_unsigned_char_ptr(n_out, 0);
1944         outlen = gen_int_ptr(n_outlen, 1);
1945         in = gen_const_unsigned_char_ptr(n_in, 2);
1946         inlen = gen_int_ptr(n_inlen, 3);
1947         quoteChar = gen_int(n_quoteChar, 4);
1948
1949         ret_val = htmlEncodeEntities(out, outlen, (const unsigned char *)in, inlen, quoteChar);
1950         desret_int(ret_val);
1951         call_tests++;
1952         des_unsigned_char_ptr(n_out, out, 0);
1953         des_int_ptr(n_outlen, outlen, 1);
1954         des_const_unsigned_char_ptr(n_in, (const unsigned char *)in, 2);
1955         des_int_ptr(n_inlen, inlen, 3);
1956         des_int(n_quoteChar, quoteChar, 4);
1957         xmlResetLastError();
1958         if (mem_base != xmlMemBlocks()) {
1959             printf("Leak of %d blocks found in htmlEncodeEntities",
1960                    xmlMemBlocks() - mem_base);
1961             test_ret++;
1962             printf(" %d", n_out);
1963             printf(" %d", n_outlen);
1964             printf(" %d", n_in);
1965             printf(" %d", n_inlen);
1966             printf(" %d", n_quoteChar);
1967             printf("\n");
1968         }
1969     }
1970     }
1971     }
1972     }
1973     }
1974     function_tests++;
1975 #endif
1976
1977     return(test_ret);
1978 }
1979
1980
1981 static int
1982 test_htmlEntityLookup(void) {
1983     int test_ret = 0;
1984
1985 #if defined(LIBXML_HTML_ENABLED)
1986     int mem_base;
1987     const htmlEntityDesc * ret_val;
1988     xmlChar * name; /* the entity name */
1989     int n_name;
1990
1991     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
1992         mem_base = xmlMemBlocks();
1993         name = gen_const_xmlChar_ptr(n_name, 0);
1994
1995         ret_val = htmlEntityLookup((const xmlChar *)name);
1996         desret_const_htmlEntityDesc_ptr(ret_val);
1997         call_tests++;
1998         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
1999         xmlResetLastError();
2000         if (mem_base != xmlMemBlocks()) {
2001             printf("Leak of %d blocks found in htmlEntityLookup",
2002                    xmlMemBlocks() - mem_base);
2003             test_ret++;
2004             printf(" %d", n_name);
2005             printf("\n");
2006         }
2007     }
2008     function_tests++;
2009 #endif
2010
2011     return(test_ret);
2012 }
2013
2014
2015 static int
2016 test_htmlEntityValueLookup(void) {
2017     int test_ret = 0;
2018
2019 #if defined(LIBXML_HTML_ENABLED)
2020     int mem_base;
2021     const htmlEntityDesc * ret_val;
2022     unsigned int value; /* the entity's unicode value */
2023     int n_value;
2024
2025     for (n_value = 0;n_value < gen_nb_unsigned_int;n_value++) {
2026         mem_base = xmlMemBlocks();
2027         value = gen_unsigned_int(n_value, 0);
2028
2029         ret_val = htmlEntityValueLookup(value);
2030         desret_const_htmlEntityDesc_ptr(ret_val);
2031         call_tests++;
2032         des_unsigned_int(n_value, value, 0);
2033         xmlResetLastError();
2034         if (mem_base != xmlMemBlocks()) {
2035             printf("Leak of %d blocks found in htmlEntityValueLookup",
2036                    xmlMemBlocks() - mem_base);
2037             test_ret++;
2038             printf(" %d", n_value);
2039             printf("\n");
2040         }
2041     }
2042     function_tests++;
2043 #endif
2044
2045     return(test_ret);
2046 }
2047
2048
2049 static int
2050 test_htmlHandleOmittedElem(void) {
2051     int test_ret = 0;
2052
2053 #if defined(LIBXML_HTML_ENABLED)
2054     int mem_base;
2055     int ret_val;
2056     int val; /* int 0 or 1 */
2057     int n_val;
2058
2059     for (n_val = 0;n_val < gen_nb_int;n_val++) {
2060         mem_base = xmlMemBlocks();
2061         val = gen_int(n_val, 0);
2062
2063         ret_val = htmlHandleOmittedElem(val);
2064         desret_int(ret_val);
2065         call_tests++;
2066         des_int(n_val, val, 0);
2067         xmlResetLastError();
2068         if (mem_base != xmlMemBlocks()) {
2069             printf("Leak of %d blocks found in htmlHandleOmittedElem",
2070                    xmlMemBlocks() - mem_base);
2071             test_ret++;
2072             printf(" %d", n_val);
2073             printf("\n");
2074         }
2075     }
2076     function_tests++;
2077 #endif
2078
2079     return(test_ret);
2080 }
2081
2082
2083 static int
2084 test_htmlIsAutoClosed(void) {
2085     int test_ret = 0;
2086
2087 #if defined(LIBXML_HTML_ENABLED)
2088     int mem_base;
2089     int ret_val;
2090     htmlDocPtr doc; /* the HTML document */
2091     int n_doc;
2092     htmlNodePtr elem; /* the HTML element */
2093     int n_elem;
2094
2095     for (n_doc = 0;n_doc < gen_nb_htmlDocPtr;n_doc++) {
2096     for (n_elem = 0;n_elem < gen_nb_htmlNodePtr;n_elem++) {
2097         mem_base = xmlMemBlocks();
2098         doc = gen_htmlDocPtr(n_doc, 0);
2099         elem = gen_htmlNodePtr(n_elem, 1);
2100
2101         ret_val = htmlIsAutoClosed(doc, elem);
2102         desret_int(ret_val);
2103         call_tests++;
2104         des_htmlDocPtr(n_doc, doc, 0);
2105         des_htmlNodePtr(n_elem, elem, 1);
2106         xmlResetLastError();
2107         if (mem_base != xmlMemBlocks()) {
2108             printf("Leak of %d blocks found in htmlIsAutoClosed",
2109                    xmlMemBlocks() - mem_base);
2110             test_ret++;
2111             printf(" %d", n_doc);
2112             printf(" %d", n_elem);
2113             printf("\n");
2114         }
2115     }
2116     }
2117     function_tests++;
2118 #endif
2119
2120     return(test_ret);
2121 }
2122
2123
2124 static int
2125 test_htmlIsScriptAttribute(void) {
2126     int test_ret = 0;
2127
2128 #if defined(LIBXML_HTML_ENABLED)
2129     int mem_base;
2130     int ret_val;
2131     xmlChar * name; /* an attribute name */
2132     int n_name;
2133
2134     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
2135         mem_base = xmlMemBlocks();
2136         name = gen_const_xmlChar_ptr(n_name, 0);
2137
2138         ret_val = htmlIsScriptAttribute((const xmlChar *)name);
2139         desret_int(ret_val);
2140         call_tests++;
2141         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
2142         xmlResetLastError();
2143         if (mem_base != xmlMemBlocks()) {
2144             printf("Leak of %d blocks found in htmlIsScriptAttribute",
2145                    xmlMemBlocks() - mem_base);
2146             test_ret++;
2147             printf(" %d", n_name);
2148             printf("\n");
2149         }
2150     }
2151     function_tests++;
2152 #endif
2153
2154     return(test_ret);
2155 }
2156
2157
2158 static int
2159 test_htmlNewParserCtxt(void) {
2160     int test_ret = 0;
2161
2162 #if defined(LIBXML_HTML_ENABLED)
2163     int mem_base;
2164     htmlParserCtxtPtr ret_val;
2165
2166         mem_base = xmlMemBlocks();
2167
2168         ret_val = htmlNewParserCtxt();
2169         desret_htmlParserCtxtPtr(ret_val);
2170         call_tests++;
2171         xmlResetLastError();
2172         if (mem_base != xmlMemBlocks()) {
2173             printf("Leak of %d blocks found in htmlNewParserCtxt",
2174                    xmlMemBlocks() - mem_base);
2175             test_ret++;
2176             printf("\n");
2177         }
2178     function_tests++;
2179 #endif
2180
2181     return(test_ret);
2182 }
2183
2184
2185 static int
2186 test_htmlNodeStatus(void) {
2187     int test_ret = 0;
2188
2189 #if defined(LIBXML_HTML_ENABLED)
2190     int mem_base;
2191     htmlStatus ret_val;
2192     htmlNodePtr node; /* an htmlNodePtr in a tree */
2193     int n_node;
2194     int legacy; /* whether to allow deprecated elements (YES is faster here for Element nodes) */
2195     int n_legacy;
2196
2197     for (n_node = 0;n_node < gen_nb_const_htmlNodePtr;n_node++) {
2198     for (n_legacy = 0;n_legacy < gen_nb_int;n_legacy++) {
2199         mem_base = xmlMemBlocks();
2200         node = gen_const_htmlNodePtr(n_node, 0);
2201         legacy = gen_int(n_legacy, 1);
2202
2203         ret_val = htmlNodeStatus((const htmlNodePtr)node, legacy);
2204         desret_htmlStatus(ret_val);
2205         call_tests++;
2206         des_const_htmlNodePtr(n_node, (const htmlNodePtr)node, 0);
2207         des_int(n_legacy, legacy, 1);
2208         xmlResetLastError();
2209         if (mem_base != xmlMemBlocks()) {
2210             printf("Leak of %d blocks found in htmlNodeStatus",
2211                    xmlMemBlocks() - mem_base);
2212             test_ret++;
2213             printf(" %d", n_node);
2214             printf(" %d", n_legacy);
2215             printf("\n");
2216         }
2217     }
2218     }
2219     function_tests++;
2220 #endif
2221
2222     return(test_ret);
2223 }
2224
2225
2226 static int
2227 test_htmlParseCharRef(void) {
2228     int test_ret = 0;
2229
2230 #if defined(LIBXML_HTML_ENABLED)
2231     int mem_base;
2232     int ret_val;
2233     htmlParserCtxtPtr ctxt; /* an HTML parser context */
2234     int n_ctxt;
2235
2236     for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
2237         mem_base = xmlMemBlocks();
2238         ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
2239
2240         ret_val = htmlParseCharRef(ctxt);
2241         desret_int(ret_val);
2242         call_tests++;
2243         des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
2244         xmlResetLastError();
2245         if (mem_base != xmlMemBlocks()) {
2246             printf("Leak of %d blocks found in htmlParseCharRef",
2247                    xmlMemBlocks() - mem_base);
2248             test_ret++;
2249             printf(" %d", n_ctxt);
2250             printf("\n");
2251         }
2252     }
2253     function_tests++;
2254 #endif
2255
2256     return(test_ret);
2257 }
2258
2259
2260 static int
2261 test_htmlParseChunk(void) {
2262     int test_ret = 0;
2263
2264 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_PUSH_ENABLED)
2265     int mem_base;
2266     int ret_val;
2267     htmlParserCtxtPtr ctxt; /* an HTML parser context */
2268     int n_ctxt;
2269     char * chunk; /* an char array */
2270     int n_chunk;
2271     int size; /* the size in byte of the chunk */
2272     int n_size;
2273     int terminate; /* last chunk indicator */
2274     int n_terminate;
2275
2276     for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
2277     for (n_chunk = 0;n_chunk < gen_nb_const_char_ptr;n_chunk++) {
2278     for (n_size = 0;n_size < gen_nb_int;n_size++) {
2279     for (n_terminate = 0;n_terminate < gen_nb_int;n_terminate++) {
2280         mem_base = xmlMemBlocks();
2281         ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
2282         chunk = gen_const_char_ptr(n_chunk, 1);
2283         size = gen_int(n_size, 2);
2284         terminate = gen_int(n_terminate, 3);
2285
2286         ret_val = htmlParseChunk(ctxt, (const char *)chunk, size, terminate);
2287         if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;}
2288         desret_int(ret_val);
2289         call_tests++;
2290         des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
2291         des_const_char_ptr(n_chunk, (const char *)chunk, 1);
2292         des_int(n_size, size, 2);
2293         des_int(n_terminate, terminate, 3);
2294         xmlResetLastError();
2295         if (mem_base != xmlMemBlocks()) {
2296             printf("Leak of %d blocks found in htmlParseChunk",
2297                    xmlMemBlocks() - mem_base);
2298             test_ret++;
2299             printf(" %d", n_ctxt);
2300             printf(" %d", n_chunk);
2301             printf(" %d", n_size);
2302             printf(" %d", n_terminate);
2303             printf("\n");
2304         }
2305     }
2306     }
2307     }
2308     }
2309     function_tests++;
2310 #endif
2311
2312     return(test_ret);
2313 }
2314
2315
2316 static int
2317 test_htmlParseDoc(void) {
2318     int test_ret = 0;
2319
2320 #if defined(LIBXML_HTML_ENABLED)
2321     int mem_base;
2322     htmlDocPtr ret_val;
2323     xmlChar * cur; /* a pointer to an array of xmlChar */
2324     int n_cur;
2325     char * encoding; /* a free form C string describing the HTML document encoding, or NULL */
2326     int n_encoding;
2327
2328     for (n_cur = 0;n_cur < gen_nb_xmlChar_ptr;n_cur++) {
2329     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
2330         mem_base = xmlMemBlocks();
2331         cur = gen_xmlChar_ptr(n_cur, 0);
2332         encoding = gen_const_char_ptr(n_encoding, 1);
2333
2334         ret_val = htmlParseDoc(cur, (const char *)encoding);
2335         desret_htmlDocPtr(ret_val);
2336         call_tests++;
2337         des_xmlChar_ptr(n_cur, cur, 0);
2338         des_const_char_ptr(n_encoding, (const char *)encoding, 1);
2339         xmlResetLastError();
2340         if (mem_base != xmlMemBlocks()) {
2341             printf("Leak of %d blocks found in htmlParseDoc",
2342                    xmlMemBlocks() - mem_base);
2343             test_ret++;
2344             printf(" %d", n_cur);
2345             printf(" %d", n_encoding);
2346             printf("\n");
2347         }
2348     }
2349     }
2350     function_tests++;
2351 #endif
2352
2353     return(test_ret);
2354 }
2355
2356
2357 static int
2358 test_htmlParseDocument(void) {
2359     int test_ret = 0;
2360
2361 #if defined(LIBXML_HTML_ENABLED)
2362     int mem_base;
2363     int ret_val;
2364     htmlParserCtxtPtr ctxt; /* an HTML parser context */
2365     int n_ctxt;
2366
2367     for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
2368         mem_base = xmlMemBlocks();
2369         ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
2370
2371         ret_val = htmlParseDocument(ctxt);
2372         if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;}
2373         desret_int(ret_val);
2374         call_tests++;
2375         des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
2376         xmlResetLastError();
2377         if (mem_base != xmlMemBlocks()) {
2378             printf("Leak of %d blocks found in htmlParseDocument",
2379                    xmlMemBlocks() - mem_base);
2380             test_ret++;
2381             printf(" %d", n_ctxt);
2382             printf("\n");
2383         }
2384     }
2385     function_tests++;
2386 #endif
2387
2388     return(test_ret);
2389 }
2390
2391
2392 static int
2393 test_htmlParseElement(void) {
2394     int test_ret = 0;
2395
2396 #if defined(LIBXML_HTML_ENABLED)
2397     int mem_base;
2398     htmlParserCtxtPtr ctxt; /* an HTML parser context */
2399     int n_ctxt;
2400
2401     for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
2402         mem_base = xmlMemBlocks();
2403         ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
2404
2405         htmlParseElement(ctxt);
2406         call_tests++;
2407         des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
2408         xmlResetLastError();
2409         if (mem_base != xmlMemBlocks()) {
2410             printf("Leak of %d blocks found in htmlParseElement",
2411                    xmlMemBlocks() - mem_base);
2412             test_ret++;
2413             printf(" %d", n_ctxt);
2414             printf("\n");
2415         }
2416     }
2417     function_tests++;
2418 #endif
2419
2420     return(test_ret);
2421 }
2422
2423
2424 static int
2425 test_htmlParseEntityRef(void) {
2426     int test_ret = 0;
2427
2428 #if defined(LIBXML_HTML_ENABLED)
2429     int mem_base;
2430     const htmlEntityDesc * ret_val;
2431     htmlParserCtxtPtr ctxt; /* an HTML parser context */
2432     int n_ctxt;
2433     xmlChar ** str; /* location to store the entity name */
2434     int n_str;
2435
2436     for (n_ctxt = 0;n_ctxt < gen_nb_htmlParserCtxtPtr;n_ctxt++) {
2437     for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr_ptr;n_str++) {
2438         mem_base = xmlMemBlocks();
2439         ctxt = gen_htmlParserCtxtPtr(n_ctxt, 0);
2440         str = gen_const_xmlChar_ptr_ptr(n_str, 1);
2441
2442         ret_val = htmlParseEntityRef(ctxt, (const xmlChar **)str);
2443         desret_const_htmlEntityDesc_ptr(ret_val);
2444         call_tests++;
2445         des_htmlParserCtxtPtr(n_ctxt, ctxt, 0);
2446         des_const_xmlChar_ptr_ptr(n_str, (const xmlChar **)str, 1);
2447         xmlResetLastError();
2448         if (mem_base != xmlMemBlocks()) {
2449             printf("Leak of %d blocks found in htmlParseEntityRef",
2450                    xmlMemBlocks() - mem_base);
2451             test_ret++;
2452             printf(" %d", n_ctxt);
2453             printf(" %d", n_str);
2454             printf("\n");
2455         }
2456     }
2457     }
2458     function_tests++;
2459 #endif
2460
2461     return(test_ret);
2462 }
2463
2464
2465 static int
2466 test_htmlParseFile(void) {
2467     int test_ret = 0;
2468
2469 #if defined(LIBXML_HTML_ENABLED)
2470     htmlDocPtr ret_val;
2471     const char * filename; /* the filename */
2472     int n_filename;
2473     char * encoding; /* a free form C string describing the HTML document encoding, or NULL */
2474     int n_encoding;
2475
2476     for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
2477     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
2478         filename = gen_filepath(n_filename, 0);
2479         encoding = gen_const_char_ptr(n_encoding, 1);
2480
2481         ret_val = htmlParseFile(filename, (const char *)encoding);
2482         desret_htmlDocPtr(ret_val);
2483         call_tests++;
2484         des_filepath(n_filename, filename, 0);
2485         des_const_char_ptr(n_encoding, (const char *)encoding, 1);
2486         xmlResetLastError();
2487     }
2488     }
2489     function_tests++;
2490 #endif
2491
2492     return(test_ret);
2493 }
2494
2495
2496 static int
2497 test_htmlReadDoc(void) {
2498     int test_ret = 0;
2499
2500 #if defined(LIBXML_HTML_ENABLED)
2501     int mem_base;
2502     htmlDocPtr ret_val;
2503     xmlChar * cur; /* a pointer to a zero terminated string */
2504     int n_cur;
2505     const char * URL; /* the base URL to use for the document */
2506     int n_URL;
2507     char * encoding; /* the document encoding, or NULL */
2508     int n_encoding;
2509     int options; /* a combination of htmlParserOption(s) */
2510     int n_options;
2511
2512     for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
2513     for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
2514     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
2515     for (n_options = 0;n_options < gen_nb_int;n_options++) {
2516         mem_base = xmlMemBlocks();
2517         cur = gen_const_xmlChar_ptr(n_cur, 0);
2518         URL = gen_filepath(n_URL, 1);
2519         encoding = gen_const_char_ptr(n_encoding, 2);
2520         options = gen_int(n_options, 3);
2521
2522         ret_val = htmlReadDoc((const xmlChar *)cur, URL, (const char *)encoding, options);
2523         desret_htmlDocPtr(ret_val);
2524         call_tests++;
2525         des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
2526         des_filepath(n_URL, URL, 1);
2527         des_const_char_ptr(n_encoding, (const char *)encoding, 2);
2528         des_int(n_options, options, 3);
2529         xmlResetLastError();
2530         if (mem_base != xmlMemBlocks()) {
2531             printf("Leak of %d blocks found in htmlReadDoc",
2532                    xmlMemBlocks() - mem_base);
2533             test_ret++;
2534             printf(" %d", n_cur);
2535             printf(" %d", n_URL);
2536             printf(" %d", n_encoding);
2537             printf(" %d", n_options);
2538             printf("\n");
2539         }
2540     }
2541     }
2542     }
2543     }
2544     function_tests++;
2545 #endif
2546
2547     return(test_ret);
2548 }
2549
2550
2551 static int
2552 test_htmlReadFile(void) {
2553     int test_ret = 0;
2554
2555 #if defined(LIBXML_HTML_ENABLED)
2556     int mem_base;
2557     htmlDocPtr ret_val;
2558     const char * filename; /* a file or URL */
2559     int n_filename;
2560     char * encoding; /* the document encoding, or NULL */
2561     int n_encoding;
2562     int options; /* a combination of htmlParserOption(s) */
2563     int n_options;
2564
2565     for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
2566     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
2567     for (n_options = 0;n_options < gen_nb_int;n_options++) {
2568         mem_base = xmlMemBlocks();
2569         filename = gen_filepath(n_filename, 0);
2570         encoding = gen_const_char_ptr(n_encoding, 1);
2571         options = gen_int(n_options, 2);
2572
2573         ret_val = htmlReadFile(filename, (const char *)encoding, options);
2574         desret_htmlDocPtr(ret_val);
2575         call_tests++;
2576         des_filepath(n_filename, filename, 0);
2577         des_const_char_ptr(n_encoding, (const char *)encoding, 1);
2578         des_int(n_options, options, 2);
2579         xmlResetLastError();
2580         if (mem_base != xmlMemBlocks()) {
2581             printf("Leak of %d blocks found in htmlReadFile",
2582                    xmlMemBlocks() - mem_base);
2583             test_ret++;
2584             printf(" %d", n_filename);
2585             printf(" %d", n_encoding);
2586             printf(" %d", n_options);
2587             printf("\n");
2588         }
2589     }
2590     }
2591     }
2592     function_tests++;
2593 #endif
2594
2595     return(test_ret);
2596 }
2597
2598
2599 static int
2600 test_htmlReadMemory(void) {
2601     int test_ret = 0;
2602
2603 #if defined(LIBXML_HTML_ENABLED)
2604     int mem_base;
2605     htmlDocPtr ret_val;
2606     char * buffer; /* a pointer to a char array */
2607     int n_buffer;
2608     int size; /* the size of the array */
2609     int n_size;
2610     const char * URL; /* the base URL to use for the document */
2611     int n_URL;
2612     char * encoding; /* the document encoding, or NULL */
2613     int n_encoding;
2614     int options; /* a combination of htmlParserOption(s) */
2615     int n_options;
2616
2617     for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
2618     for (n_size = 0;n_size < gen_nb_int;n_size++) {
2619     for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
2620     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
2621     for (n_options = 0;n_options < gen_nb_int;n_options++) {
2622         mem_base = xmlMemBlocks();
2623         buffer = gen_const_char_ptr(n_buffer, 0);
2624         size = gen_int(n_size, 1);
2625         URL = gen_filepath(n_URL, 2);
2626         encoding = gen_const_char_ptr(n_encoding, 3);
2627         options = gen_int(n_options, 4);
2628
2629         ret_val = htmlReadMemory((const char *)buffer, size, URL, (const char *)encoding, options);
2630         desret_htmlDocPtr(ret_val);
2631         call_tests++;
2632         des_const_char_ptr(n_buffer, (const char *)buffer, 0);
2633         des_int(n_size, size, 1);
2634         des_filepath(n_URL, URL, 2);
2635         des_const_char_ptr(n_encoding, (const char *)encoding, 3);
2636         des_int(n_options, options, 4);
2637         xmlResetLastError();
2638         if (mem_base != xmlMemBlocks()) {
2639             printf("Leak of %d blocks found in htmlReadMemory",
2640                    xmlMemBlocks() - mem_base);
2641             test_ret++;
2642             printf(" %d", n_buffer);
2643             printf(" %d", n_size);
2644             printf(" %d", n_URL);
2645             printf(" %d", n_encoding);
2646             printf(" %d", n_options);
2647             printf("\n");
2648         }
2649     }
2650     }
2651     }
2652     }
2653     }
2654     function_tests++;
2655 #endif
2656
2657     return(test_ret);
2658 }
2659
2660
2661 static int
2662 test_htmlSAXParseDoc(void) {
2663     int test_ret = 0;
2664
2665 #if defined(LIBXML_HTML_ENABLED)
2666     int mem_base;
2667     htmlDocPtr ret_val;
2668     xmlChar * cur; /* a pointer to an array of xmlChar */
2669     int n_cur;
2670     char * encoding; /* a free form C string describing the HTML document encoding, or NULL */
2671     int n_encoding;
2672     htmlSAXHandlerPtr sax; /* the SAX handler block */
2673     int n_sax;
2674     void * userData; /* if using SAX, this pointer will be provided on callbacks. */
2675     int n_userData;
2676
2677     for (n_cur = 0;n_cur < gen_nb_xmlChar_ptr;n_cur++) {
2678     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
2679     for (n_sax = 0;n_sax < gen_nb_htmlSAXHandlerPtr;n_sax++) {
2680     for (n_userData = 0;n_userData < gen_nb_userdata;n_userData++) {
2681         mem_base = xmlMemBlocks();
2682         cur = gen_xmlChar_ptr(n_cur, 0);
2683         encoding = gen_const_char_ptr(n_encoding, 1);
2684         sax = gen_htmlSAXHandlerPtr(n_sax, 2);
2685         userData = gen_userdata(n_userData, 3);
2686
2687         ret_val = htmlSAXParseDoc(cur, (const char *)encoding, sax, userData);
2688         desret_htmlDocPtr(ret_val);
2689         call_tests++;
2690         des_xmlChar_ptr(n_cur, cur, 0);
2691         des_const_char_ptr(n_encoding, (const char *)encoding, 1);
2692         des_htmlSAXHandlerPtr(n_sax, sax, 2);
2693         des_userdata(n_userData, userData, 3);
2694         xmlResetLastError();
2695         if (mem_base != xmlMemBlocks()) {
2696             printf("Leak of %d blocks found in htmlSAXParseDoc",
2697                    xmlMemBlocks() - mem_base);
2698             test_ret++;
2699             printf(" %d", n_cur);
2700             printf(" %d", n_encoding);
2701             printf(" %d", n_sax);
2702             printf(" %d", n_userData);
2703             printf("\n");
2704         }
2705     }
2706     }
2707     }
2708     }
2709     function_tests++;
2710 #endif
2711
2712     return(test_ret);
2713 }
2714
2715
2716 static int
2717 test_htmlSAXParseFile(void) {
2718     int test_ret = 0;
2719
2720 #if defined(LIBXML_HTML_ENABLED)
2721     int mem_base;
2722     htmlDocPtr ret_val;
2723     const char * filename; /* the filename */
2724     int n_filename;
2725     char * encoding; /* a free form C string describing the HTML document encoding, or NULL */
2726     int n_encoding;
2727     htmlSAXHandlerPtr sax; /* the SAX handler block */
2728     int n_sax;
2729     void * userData; /* if using SAX, this pointer will be provided on callbacks. */
2730     int n_userData;
2731
2732     for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
2733     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
2734     for (n_sax = 0;n_sax < gen_nb_htmlSAXHandlerPtr;n_sax++) {
2735     for (n_userData = 0;n_userData < gen_nb_userdata;n_userData++) {
2736         mem_base = xmlMemBlocks();
2737         filename = gen_filepath(n_filename, 0);
2738         encoding = gen_const_char_ptr(n_encoding, 1);
2739         sax = gen_htmlSAXHandlerPtr(n_sax, 2);
2740         userData = gen_userdata(n_userData, 3);
2741
2742         ret_val = htmlSAXParseFile(filename, (const char *)encoding, sax, userData);
2743         desret_htmlDocPtr(ret_val);
2744         call_tests++;
2745         des_filepath(n_filename, filename, 0);
2746         des_const_char_ptr(n_encoding, (const char *)encoding, 1);
2747         des_htmlSAXHandlerPtr(n_sax, sax, 2);
2748         des_userdata(n_userData, userData, 3);
2749         xmlResetLastError();
2750         if (mem_base != xmlMemBlocks()) {
2751             printf("Leak of %d blocks found in htmlSAXParseFile",
2752                    xmlMemBlocks() - mem_base);
2753             test_ret++;
2754             printf(" %d", n_filename);
2755             printf(" %d", n_encoding);
2756             printf(" %d", n_sax);
2757             printf(" %d", n_userData);
2758             printf("\n");
2759         }
2760     }
2761     }
2762     }
2763     }
2764     function_tests++;
2765 #endif
2766
2767     return(test_ret);
2768 }
2769
2770
2771 static int
2772 test_htmlTagLookup(void) {
2773     int test_ret = 0;
2774
2775
2776     /* missing type support */
2777     return(test_ret);
2778 }
2779
2780 static int
2781 test_HTMLparser(void) {
2782     int test_ret = 0;
2783
2784     if (quiet == 0) printf("Testing HTMLparser : 32 of 38 functions ...\n");
2785     test_ret += test_UTF8ToHtml();
2786     test_ret += test_htmlAttrAllowed();
2787     test_ret += test_htmlAutoCloseTag();
2788     test_ret += test_htmlCreateMemoryParserCtxt();
2789     test_ret += test_htmlCreatePushParserCtxt();
2790     test_ret += test_htmlCtxtReadDoc();
2791     test_ret += test_htmlCtxtReadFile();
2792     test_ret += test_htmlCtxtReadMemory();
2793     test_ret += test_htmlCtxtReset();
2794     test_ret += test_htmlCtxtUseOptions();
2795     test_ret += test_htmlElementAllowedHere();
2796     test_ret += test_htmlElementStatusHere();
2797     test_ret += test_htmlEncodeEntities();
2798     test_ret += test_htmlEntityLookup();
2799     test_ret += test_htmlEntityValueLookup();
2800     test_ret += test_htmlHandleOmittedElem();
2801     test_ret += test_htmlIsAutoClosed();
2802     test_ret += test_htmlIsScriptAttribute();
2803     test_ret += test_htmlNewParserCtxt();
2804     test_ret += test_htmlNodeStatus();
2805     test_ret += test_htmlParseCharRef();
2806     test_ret += test_htmlParseChunk();
2807     test_ret += test_htmlParseDoc();
2808     test_ret += test_htmlParseDocument();
2809     test_ret += test_htmlParseElement();
2810     test_ret += test_htmlParseEntityRef();
2811     test_ret += test_htmlParseFile();
2812     test_ret += test_htmlReadDoc();
2813     test_ret += test_htmlReadFile();
2814     test_ret += test_htmlReadMemory();
2815     test_ret += test_htmlSAXParseDoc();
2816     test_ret += test_htmlSAXParseFile();
2817     test_ret += test_htmlTagLookup();
2818
2819     if (test_ret != 0)
2820         printf("Module HTMLparser: %d errors\n", test_ret);
2821     return(test_ret);
2822 }
2823
2824 static int
2825 test_htmlDocContentDumpFormatOutput(void) {
2826     int test_ret = 0;
2827
2828 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
2829     int mem_base;
2830     xmlOutputBufferPtr buf; /* the HTML buffer output */
2831     int n_buf;
2832     xmlDocPtr cur; /* the document */
2833     int n_cur;
2834     char * encoding; /* the encoding string */
2835     int n_encoding;
2836     int format; /* should formatting spaces been added */
2837     int n_format;
2838
2839     for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
2840     for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
2841     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
2842     for (n_format = 0;n_format < gen_nb_int;n_format++) {
2843         mem_base = xmlMemBlocks();
2844         buf = gen_xmlOutputBufferPtr(n_buf, 0);
2845         cur = gen_xmlDocPtr(n_cur, 1);
2846         encoding = gen_const_char_ptr(n_encoding, 2);
2847         format = gen_int(n_format, 3);
2848
2849         htmlDocContentDumpFormatOutput(buf, cur, (const char *)encoding, format);
2850         call_tests++;
2851         des_xmlOutputBufferPtr(n_buf, buf, 0);
2852         des_xmlDocPtr(n_cur, cur, 1);
2853         des_const_char_ptr(n_encoding, (const char *)encoding, 2);
2854         des_int(n_format, format, 3);
2855         xmlResetLastError();
2856         if (mem_base != xmlMemBlocks()) {
2857             printf("Leak of %d blocks found in htmlDocContentDumpFormatOutput",
2858                    xmlMemBlocks() - mem_base);
2859             test_ret++;
2860             printf(" %d", n_buf);
2861             printf(" %d", n_cur);
2862             printf(" %d", n_encoding);
2863             printf(" %d", n_format);
2864             printf("\n");
2865         }
2866     }
2867     }
2868     }
2869     }
2870     function_tests++;
2871 #endif
2872
2873     return(test_ret);
2874 }
2875
2876
2877 static int
2878 test_htmlDocContentDumpOutput(void) {
2879     int test_ret = 0;
2880
2881 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
2882     int mem_base;
2883     xmlOutputBufferPtr buf; /* the HTML buffer output */
2884     int n_buf;
2885     xmlDocPtr cur; /* the document */
2886     int n_cur;
2887     char * encoding; /* the encoding string */
2888     int n_encoding;
2889
2890     for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
2891     for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
2892     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
2893         mem_base = xmlMemBlocks();
2894         buf = gen_xmlOutputBufferPtr(n_buf, 0);
2895         cur = gen_xmlDocPtr(n_cur, 1);
2896         encoding = gen_const_char_ptr(n_encoding, 2);
2897
2898         htmlDocContentDumpOutput(buf, cur, (const char *)encoding);
2899         call_tests++;
2900         des_xmlOutputBufferPtr(n_buf, buf, 0);
2901         des_xmlDocPtr(n_cur, cur, 1);
2902         des_const_char_ptr(n_encoding, (const char *)encoding, 2);
2903         xmlResetLastError();
2904         if (mem_base != xmlMemBlocks()) {
2905             printf("Leak of %d blocks found in htmlDocContentDumpOutput",
2906                    xmlMemBlocks() - mem_base);
2907             test_ret++;
2908             printf(" %d", n_buf);
2909             printf(" %d", n_cur);
2910             printf(" %d", n_encoding);
2911             printf("\n");
2912         }
2913     }
2914     }
2915     }
2916     function_tests++;
2917 #endif
2918
2919     return(test_ret);
2920 }
2921
2922
2923 static int
2924 test_htmlDocDump(void) {
2925     int test_ret = 0;
2926
2927 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
2928     int mem_base;
2929     int ret_val;
2930     FILE * f; /* the FILE* */
2931     int n_f;
2932     xmlDocPtr cur; /* the document */
2933     int n_cur;
2934
2935     for (n_f = 0;n_f < gen_nb_FILE_ptr;n_f++) {
2936     for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
2937         mem_base = xmlMemBlocks();
2938         f = gen_FILE_ptr(n_f, 0);
2939         cur = gen_xmlDocPtr(n_cur, 1);
2940
2941         ret_val = htmlDocDump(f, cur);
2942         desret_int(ret_val);
2943         call_tests++;
2944         des_FILE_ptr(n_f, f, 0);
2945         des_xmlDocPtr(n_cur, cur, 1);
2946         xmlResetLastError();
2947         if (mem_base != xmlMemBlocks()) {
2948             printf("Leak of %d blocks found in htmlDocDump",
2949                    xmlMemBlocks() - mem_base);
2950             test_ret++;
2951             printf(" %d", n_f);
2952             printf(" %d", n_cur);
2953             printf("\n");
2954         }
2955     }
2956     }
2957     function_tests++;
2958 #endif
2959
2960     return(test_ret);
2961 }
2962
2963
2964 #define gen_nb_xmlChar_ptr_ptr 1
2965 static xmlChar ** gen_xmlChar_ptr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
2966     return(NULL);
2967 }
2968 static void des_xmlChar_ptr_ptr(int no ATTRIBUTE_UNUSED, xmlChar ** val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
2969 }
2970
2971 static int
2972 test_htmlDocDumpMemory(void) {
2973     int test_ret = 0;
2974
2975 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
2976     int mem_base;
2977     xmlDocPtr cur; /* the document */
2978     int n_cur;
2979     xmlChar ** mem; /* OUT: the memory pointer */
2980     int n_mem;
2981     int * size; /* OUT: the memory length */
2982     int n_size;
2983
2984     for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
2985     for (n_mem = 0;n_mem < gen_nb_xmlChar_ptr_ptr;n_mem++) {
2986     for (n_size = 0;n_size < gen_nb_int_ptr;n_size++) {
2987         mem_base = xmlMemBlocks();
2988         cur = gen_xmlDocPtr(n_cur, 0);
2989         mem = gen_xmlChar_ptr_ptr(n_mem, 1);
2990         size = gen_int_ptr(n_size, 2);
2991
2992         htmlDocDumpMemory(cur, mem, size);
2993         call_tests++;
2994         des_xmlDocPtr(n_cur, cur, 0);
2995         des_xmlChar_ptr_ptr(n_mem, mem, 1);
2996         des_int_ptr(n_size, size, 2);
2997         xmlResetLastError();
2998         if (mem_base != xmlMemBlocks()) {
2999             printf("Leak of %d blocks found in htmlDocDumpMemory",
3000                    xmlMemBlocks() - mem_base);
3001             test_ret++;
3002             printf(" %d", n_cur);
3003             printf(" %d", n_mem);
3004             printf(" %d", n_size);
3005             printf("\n");
3006         }
3007     }
3008     }
3009     }
3010     function_tests++;
3011 #endif
3012
3013     return(test_ret);
3014 }
3015
3016
3017 static int
3018 test_htmlDocDumpMemoryFormat(void) {
3019     int test_ret = 0;
3020
3021 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
3022     int mem_base;
3023     xmlDocPtr cur; /* the document */
3024     int n_cur;
3025     xmlChar ** mem; /* OUT: the memory pointer */
3026     int n_mem;
3027     int * size; /* OUT: the memory length */
3028     int n_size;
3029     int format; /* should formatting spaces been added */
3030     int n_format;
3031
3032     for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
3033     for (n_mem = 0;n_mem < gen_nb_xmlChar_ptr_ptr;n_mem++) {
3034     for (n_size = 0;n_size < gen_nb_int_ptr;n_size++) {
3035     for (n_format = 0;n_format < gen_nb_int;n_format++) {
3036         mem_base = xmlMemBlocks();
3037         cur = gen_xmlDocPtr(n_cur, 0);
3038         mem = gen_xmlChar_ptr_ptr(n_mem, 1);
3039         size = gen_int_ptr(n_size, 2);
3040         format = gen_int(n_format, 3);
3041
3042         htmlDocDumpMemoryFormat(cur, mem, size, format);
3043         call_tests++;
3044         des_xmlDocPtr(n_cur, cur, 0);
3045         des_xmlChar_ptr_ptr(n_mem, mem, 1);
3046         des_int_ptr(n_size, size, 2);
3047         des_int(n_format, format, 3);
3048         xmlResetLastError();
3049         if (mem_base != xmlMemBlocks()) {
3050             printf("Leak of %d blocks found in htmlDocDumpMemoryFormat",
3051                    xmlMemBlocks() - mem_base);
3052             test_ret++;
3053             printf(" %d", n_cur);
3054             printf(" %d", n_mem);
3055             printf(" %d", n_size);
3056             printf(" %d", n_format);
3057             printf("\n");
3058         }
3059     }
3060     }
3061     }
3062     }
3063     function_tests++;
3064 #endif
3065
3066     return(test_ret);
3067 }
3068
3069
3070 static int
3071 test_htmlGetMetaEncoding(void) {
3072     int test_ret = 0;
3073
3074 #if defined(LIBXML_HTML_ENABLED)
3075     int mem_base;
3076     const xmlChar * ret_val;
3077     htmlDocPtr doc; /* the document */
3078     int n_doc;
3079
3080     for (n_doc = 0;n_doc < gen_nb_htmlDocPtr;n_doc++) {
3081         mem_base = xmlMemBlocks();
3082         doc = gen_htmlDocPtr(n_doc, 0);
3083
3084         ret_val = htmlGetMetaEncoding(doc);
3085         desret_const_xmlChar_ptr(ret_val);
3086         call_tests++;
3087         des_htmlDocPtr(n_doc, doc, 0);
3088         xmlResetLastError();
3089         if (mem_base != xmlMemBlocks()) {
3090             printf("Leak of %d blocks found in htmlGetMetaEncoding",
3091                    xmlMemBlocks() - mem_base);
3092             test_ret++;
3093             printf(" %d", n_doc);
3094             printf("\n");
3095         }
3096     }
3097     function_tests++;
3098 #endif
3099
3100     return(test_ret);
3101 }
3102
3103
3104 static int
3105 test_htmlIsBooleanAttr(void) {
3106     int test_ret = 0;
3107
3108 #if defined(LIBXML_HTML_ENABLED)
3109     int mem_base;
3110     int ret_val;
3111     xmlChar * name; /* the name of the attribute to check */
3112     int n_name;
3113
3114     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
3115         mem_base = xmlMemBlocks();
3116         name = gen_const_xmlChar_ptr(n_name, 0);
3117
3118         ret_val = htmlIsBooleanAttr((const xmlChar *)name);
3119         desret_int(ret_val);
3120         call_tests++;
3121         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
3122         xmlResetLastError();
3123         if (mem_base != xmlMemBlocks()) {
3124             printf("Leak of %d blocks found in htmlIsBooleanAttr",
3125                    xmlMemBlocks() - mem_base);
3126             test_ret++;
3127             printf(" %d", n_name);
3128             printf("\n");
3129         }
3130     }
3131     function_tests++;
3132 #endif
3133
3134     return(test_ret);
3135 }
3136
3137
3138 static int
3139 test_htmlNewDoc(void) {
3140     int test_ret = 0;
3141
3142 #if defined(LIBXML_HTML_ENABLED)
3143     int mem_base;
3144     htmlDocPtr ret_val;
3145     xmlChar * URI; /* URI for the dtd, or NULL */
3146     int n_URI;
3147     xmlChar * ExternalID; /* the external ID of the DTD, or NULL */
3148     int n_ExternalID;
3149
3150     for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
3151     for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
3152         mem_base = xmlMemBlocks();
3153         URI = gen_const_xmlChar_ptr(n_URI, 0);
3154         ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 1);
3155
3156         ret_val = htmlNewDoc((const xmlChar *)URI, (const xmlChar *)ExternalID);
3157         desret_htmlDocPtr(ret_val);
3158         call_tests++;
3159         des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 0);
3160         des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 1);
3161         xmlResetLastError();
3162         if (mem_base != xmlMemBlocks()) {
3163             printf("Leak of %d blocks found in htmlNewDoc",
3164                    xmlMemBlocks() - mem_base);
3165             test_ret++;
3166             printf(" %d", n_URI);
3167             printf(" %d", n_ExternalID);
3168             printf("\n");
3169         }
3170     }
3171     }
3172     function_tests++;
3173 #endif
3174
3175     return(test_ret);
3176 }
3177
3178
3179 static int
3180 test_htmlNewDocNoDtD(void) {
3181     int test_ret = 0;
3182
3183 #if defined(LIBXML_HTML_ENABLED)
3184     int mem_base;
3185     htmlDocPtr ret_val;
3186     xmlChar * URI; /* URI for the dtd, or NULL */
3187     int n_URI;
3188     xmlChar * ExternalID; /* the external ID of the DTD, or NULL */
3189     int n_ExternalID;
3190
3191     for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
3192     for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
3193         mem_base = xmlMemBlocks();
3194         URI = gen_const_xmlChar_ptr(n_URI, 0);
3195         ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 1);
3196
3197         ret_val = htmlNewDocNoDtD((const xmlChar *)URI, (const xmlChar *)ExternalID);
3198         desret_htmlDocPtr(ret_val);
3199         call_tests++;
3200         des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 0);
3201         des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 1);
3202         xmlResetLastError();
3203         if (mem_base != xmlMemBlocks()) {
3204             printf("Leak of %d blocks found in htmlNewDocNoDtD",
3205                    xmlMemBlocks() - mem_base);
3206             test_ret++;
3207             printf(" %d", n_URI);
3208             printf(" %d", n_ExternalID);
3209             printf("\n");
3210         }
3211     }
3212     }
3213     function_tests++;
3214 #endif
3215
3216     return(test_ret);
3217 }
3218
3219
3220 static int
3221 test_htmlNodeDump(void) {
3222     int test_ret = 0;
3223
3224 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
3225     int mem_base;
3226     int ret_val;
3227     xmlBufferPtr buf; /* the HTML buffer output */
3228     int n_buf;
3229     xmlDocPtr doc; /* the document */
3230     int n_doc;
3231     xmlNodePtr cur; /* the current node */
3232     int n_cur;
3233
3234     for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
3235     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
3236     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
3237         mem_base = xmlMemBlocks();
3238         buf = gen_xmlBufferPtr(n_buf, 0);
3239         doc = gen_xmlDocPtr(n_doc, 1);
3240         cur = gen_xmlNodePtr(n_cur, 2);
3241
3242         ret_val = htmlNodeDump(buf, doc, cur);
3243         desret_int(ret_val);
3244         call_tests++;
3245         des_xmlBufferPtr(n_buf, buf, 0);
3246         des_xmlDocPtr(n_doc, doc, 1);
3247         des_xmlNodePtr(n_cur, cur, 2);
3248         xmlResetLastError();
3249         if (mem_base != xmlMemBlocks()) {
3250             printf("Leak of %d blocks found in htmlNodeDump",
3251                    xmlMemBlocks() - mem_base);
3252             test_ret++;
3253             printf(" %d", n_buf);
3254             printf(" %d", n_doc);
3255             printf(" %d", n_cur);
3256             printf("\n");
3257         }
3258     }
3259     }
3260     }
3261     function_tests++;
3262 #endif
3263
3264     return(test_ret);
3265 }
3266
3267
3268 static int
3269 test_htmlNodeDumpFile(void) {
3270     int test_ret = 0;
3271
3272 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
3273     int mem_base;
3274     FILE * out; /* the FILE pointer */
3275     int n_out;
3276     xmlDocPtr doc; /* the document */
3277     int n_doc;
3278     xmlNodePtr cur; /* the current node */
3279     int n_cur;
3280
3281     for (n_out = 0;n_out < gen_nb_FILE_ptr;n_out++) {
3282     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
3283     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
3284         mem_base = xmlMemBlocks();
3285         out = gen_FILE_ptr(n_out, 0);
3286         doc = gen_xmlDocPtr(n_doc, 1);
3287         cur = gen_xmlNodePtr(n_cur, 2);
3288
3289         htmlNodeDumpFile(out, doc, cur);
3290         call_tests++;
3291         des_FILE_ptr(n_out, out, 0);
3292         des_xmlDocPtr(n_doc, doc, 1);
3293         des_xmlNodePtr(n_cur, cur, 2);
3294         xmlResetLastError();
3295         if (mem_base != xmlMemBlocks()) {
3296             printf("Leak of %d blocks found in htmlNodeDumpFile",
3297                    xmlMemBlocks() - mem_base);
3298             test_ret++;
3299             printf(" %d", n_out);
3300             printf(" %d", n_doc);
3301             printf(" %d", n_cur);
3302             printf("\n");
3303         }
3304     }
3305     }
3306     }
3307     function_tests++;
3308 #endif
3309
3310     return(test_ret);
3311 }
3312
3313
3314 static int
3315 test_htmlNodeDumpFileFormat(void) {
3316     int test_ret = 0;
3317
3318 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
3319     int mem_base;
3320     int ret_val;
3321     FILE * out; /* the FILE pointer */
3322     int n_out;
3323     xmlDocPtr doc; /* the document */
3324     int n_doc;
3325     xmlNodePtr cur; /* the current node */
3326     int n_cur;
3327     char * encoding; /* the document encoding */
3328     int n_encoding;
3329     int format; /* should formatting spaces been added */
3330     int n_format;
3331
3332     for (n_out = 0;n_out < gen_nb_FILE_ptr;n_out++) {
3333     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
3334     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
3335     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
3336     for (n_format = 0;n_format < gen_nb_int;n_format++) {
3337         mem_base = xmlMemBlocks();
3338         out = gen_FILE_ptr(n_out, 0);
3339         doc = gen_xmlDocPtr(n_doc, 1);
3340         cur = gen_xmlNodePtr(n_cur, 2);
3341         encoding = gen_const_char_ptr(n_encoding, 3);
3342         format = gen_int(n_format, 4);
3343
3344         ret_val = htmlNodeDumpFileFormat(out, doc, cur, (const char *)encoding, format);
3345         desret_int(ret_val);
3346         call_tests++;
3347         des_FILE_ptr(n_out, out, 0);
3348         des_xmlDocPtr(n_doc, doc, 1);
3349         des_xmlNodePtr(n_cur, cur, 2);
3350         des_const_char_ptr(n_encoding, (const char *)encoding, 3);
3351         des_int(n_format, format, 4);
3352         xmlResetLastError();
3353         if (mem_base != xmlMemBlocks()) {
3354             printf("Leak of %d blocks found in htmlNodeDumpFileFormat",
3355                    xmlMemBlocks() - mem_base);
3356             test_ret++;
3357             printf(" %d", n_out);
3358             printf(" %d", n_doc);
3359             printf(" %d", n_cur);
3360             printf(" %d", n_encoding);
3361             printf(" %d", n_format);
3362             printf("\n");
3363         }
3364     }
3365     }
3366     }
3367     }
3368     }
3369     function_tests++;
3370 #endif
3371
3372     return(test_ret);
3373 }
3374
3375
3376 static int
3377 test_htmlNodeDumpFormatOutput(void) {
3378     int test_ret = 0;
3379
3380 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
3381     int mem_base;
3382     xmlOutputBufferPtr buf; /* the HTML buffer output */
3383     int n_buf;
3384     xmlDocPtr doc; /* the document */
3385     int n_doc;
3386     xmlNodePtr cur; /* the current node */
3387     int n_cur;
3388     char * encoding; /* the encoding string */
3389     int n_encoding;
3390     int format; /* should formatting spaces been added */
3391     int n_format;
3392
3393     for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
3394     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
3395     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
3396     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
3397     for (n_format = 0;n_format < gen_nb_int;n_format++) {
3398         mem_base = xmlMemBlocks();
3399         buf = gen_xmlOutputBufferPtr(n_buf, 0);
3400         doc = gen_xmlDocPtr(n_doc, 1);
3401         cur = gen_xmlNodePtr(n_cur, 2);
3402         encoding = gen_const_char_ptr(n_encoding, 3);
3403         format = gen_int(n_format, 4);
3404
3405         htmlNodeDumpFormatOutput(buf, doc, cur, (const char *)encoding, format);
3406         call_tests++;
3407         des_xmlOutputBufferPtr(n_buf, buf, 0);
3408         des_xmlDocPtr(n_doc, doc, 1);
3409         des_xmlNodePtr(n_cur, cur, 2);
3410         des_const_char_ptr(n_encoding, (const char *)encoding, 3);
3411         des_int(n_format, format, 4);
3412         xmlResetLastError();
3413         if (mem_base != xmlMemBlocks()) {
3414             printf("Leak of %d blocks found in htmlNodeDumpFormatOutput",
3415                    xmlMemBlocks() - mem_base);
3416             test_ret++;
3417             printf(" %d", n_buf);
3418             printf(" %d", n_doc);
3419             printf(" %d", n_cur);
3420             printf(" %d", n_encoding);
3421             printf(" %d", n_format);
3422             printf("\n");
3423         }
3424     }
3425     }
3426     }
3427     }
3428     }
3429     function_tests++;
3430 #endif
3431
3432     return(test_ret);
3433 }
3434
3435
3436 static int
3437 test_htmlNodeDumpOutput(void) {
3438     int test_ret = 0;
3439
3440 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
3441     int mem_base;
3442     xmlOutputBufferPtr buf; /* the HTML buffer output */
3443     int n_buf;
3444     xmlDocPtr doc; /* the document */
3445     int n_doc;
3446     xmlNodePtr cur; /* the current node */
3447     int n_cur;
3448     char * encoding; /* the encoding string */
3449     int n_encoding;
3450
3451     for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
3452     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
3453     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
3454     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
3455         mem_base = xmlMemBlocks();
3456         buf = gen_xmlOutputBufferPtr(n_buf, 0);
3457         doc = gen_xmlDocPtr(n_doc, 1);
3458         cur = gen_xmlNodePtr(n_cur, 2);
3459         encoding = gen_const_char_ptr(n_encoding, 3);
3460
3461         htmlNodeDumpOutput(buf, doc, cur, (const char *)encoding);
3462         call_tests++;
3463         des_xmlOutputBufferPtr(n_buf, buf, 0);
3464         des_xmlDocPtr(n_doc, doc, 1);
3465         des_xmlNodePtr(n_cur, cur, 2);
3466         des_const_char_ptr(n_encoding, (const char *)encoding, 3);
3467         xmlResetLastError();
3468         if (mem_base != xmlMemBlocks()) {
3469             printf("Leak of %d blocks found in htmlNodeDumpOutput",
3470                    xmlMemBlocks() - mem_base);
3471             test_ret++;
3472             printf(" %d", n_buf);
3473             printf(" %d", n_doc);
3474             printf(" %d", n_cur);
3475             printf(" %d", n_encoding);
3476             printf("\n");
3477         }
3478     }
3479     }
3480     }
3481     }
3482     function_tests++;
3483 #endif
3484
3485     return(test_ret);
3486 }
3487
3488
3489 static int
3490 test_htmlSaveFile(void) {
3491     int test_ret = 0;
3492
3493 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
3494     int mem_base;
3495     int ret_val;
3496     const char * filename; /* the filename (or URL) */
3497     int n_filename;
3498     xmlDocPtr cur; /* the document */
3499     int n_cur;
3500
3501     for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
3502     for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
3503         mem_base = xmlMemBlocks();
3504         filename = gen_fileoutput(n_filename, 0);
3505         cur = gen_xmlDocPtr(n_cur, 1);
3506
3507         ret_val = htmlSaveFile(filename, cur);
3508         desret_int(ret_val);
3509         call_tests++;
3510         des_fileoutput(n_filename, filename, 0);
3511         des_xmlDocPtr(n_cur, cur, 1);
3512         xmlResetLastError();
3513         if (mem_base != xmlMemBlocks()) {
3514             printf("Leak of %d blocks found in htmlSaveFile",
3515                    xmlMemBlocks() - mem_base);
3516             test_ret++;
3517             printf(" %d", n_filename);
3518             printf(" %d", n_cur);
3519             printf("\n");
3520         }
3521     }
3522     }
3523     function_tests++;
3524 #endif
3525
3526     return(test_ret);
3527 }
3528
3529
3530 static int
3531 test_htmlSaveFileEnc(void) {
3532     int test_ret = 0;
3533
3534 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
3535     int mem_base;
3536     int ret_val;
3537     const char * filename; /* the filename */
3538     int n_filename;
3539     xmlDocPtr cur; /* the document */
3540     int n_cur;
3541     char * encoding; /* the document encoding */
3542     int n_encoding;
3543
3544     for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
3545     for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
3546     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
3547         mem_base = xmlMemBlocks();
3548         filename = gen_fileoutput(n_filename, 0);
3549         cur = gen_xmlDocPtr(n_cur, 1);
3550         encoding = gen_const_char_ptr(n_encoding, 2);
3551
3552         ret_val = htmlSaveFileEnc(filename, cur, (const char *)encoding);
3553         desret_int(ret_val);
3554         call_tests++;
3555         des_fileoutput(n_filename, filename, 0);
3556         des_xmlDocPtr(n_cur, cur, 1);
3557         des_const_char_ptr(n_encoding, (const char *)encoding, 2);
3558         xmlResetLastError();
3559         if (mem_base != xmlMemBlocks()) {
3560             printf("Leak of %d blocks found in htmlSaveFileEnc",
3561                    xmlMemBlocks() - mem_base);
3562             test_ret++;
3563             printf(" %d", n_filename);
3564             printf(" %d", n_cur);
3565             printf(" %d", n_encoding);
3566             printf("\n");
3567         }
3568     }
3569     }
3570     }
3571     function_tests++;
3572 #endif
3573
3574     return(test_ret);
3575 }
3576
3577
3578 static int
3579 test_htmlSaveFileFormat(void) {
3580     int test_ret = 0;
3581
3582 #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
3583     int mem_base;
3584     int ret_val;
3585     const char * filename; /* the filename */
3586     int n_filename;
3587     xmlDocPtr cur; /* the document */
3588     int n_cur;
3589     char * encoding; /* the document encoding */
3590     int n_encoding;
3591     int format; /* should formatting spaces been added */
3592     int n_format;
3593
3594     for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
3595     for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
3596     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
3597     for (n_format = 0;n_format < gen_nb_int;n_format++) {
3598         mem_base = xmlMemBlocks();
3599         filename = gen_fileoutput(n_filename, 0);
3600         cur = gen_xmlDocPtr(n_cur, 1);
3601         encoding = gen_const_char_ptr(n_encoding, 2);
3602         format = gen_int(n_format, 3);
3603
3604         ret_val = htmlSaveFileFormat(filename, cur, (const char *)encoding, format);
3605         desret_int(ret_val);
3606         call_tests++;
3607         des_fileoutput(n_filename, filename, 0);
3608         des_xmlDocPtr(n_cur, cur, 1);
3609         des_const_char_ptr(n_encoding, (const char *)encoding, 2);
3610         des_int(n_format, format, 3);
3611         xmlResetLastError();
3612         if (mem_base != xmlMemBlocks()) {
3613             printf("Leak of %d blocks found in htmlSaveFileFormat",
3614                    xmlMemBlocks() - mem_base);
3615             test_ret++;
3616             printf(" %d", n_filename);
3617             printf(" %d", n_cur);
3618             printf(" %d", n_encoding);
3619             printf(" %d", n_format);
3620             printf("\n");
3621         }
3622     }
3623     }
3624     }
3625     }
3626     function_tests++;
3627 #endif
3628
3629     return(test_ret);
3630 }
3631
3632
3633 static int
3634 test_htmlSetMetaEncoding(void) {
3635     int test_ret = 0;
3636
3637 #if defined(LIBXML_HTML_ENABLED)
3638     int mem_base;
3639     int ret_val;
3640     htmlDocPtr doc; /* the document */
3641     int n_doc;
3642     xmlChar * encoding; /* the encoding string */
3643     int n_encoding;
3644
3645     for (n_doc = 0;n_doc < gen_nb_htmlDocPtr;n_doc++) {
3646     for (n_encoding = 0;n_encoding < gen_nb_const_xmlChar_ptr;n_encoding++) {
3647         mem_base = xmlMemBlocks();
3648         doc = gen_htmlDocPtr(n_doc, 0);
3649         encoding = gen_const_xmlChar_ptr(n_encoding, 1);
3650
3651         ret_val = htmlSetMetaEncoding(doc, (const xmlChar *)encoding);
3652         desret_int(ret_val);
3653         call_tests++;
3654         des_htmlDocPtr(n_doc, doc, 0);
3655         des_const_xmlChar_ptr(n_encoding, (const xmlChar *)encoding, 1);
3656         xmlResetLastError();
3657         if (mem_base != xmlMemBlocks()) {
3658             printf("Leak of %d blocks found in htmlSetMetaEncoding",
3659                    xmlMemBlocks() - mem_base);
3660             test_ret++;
3661             printf(" %d", n_doc);
3662             printf(" %d", n_encoding);
3663             printf("\n");
3664         }
3665     }
3666     }
3667     function_tests++;
3668 #endif
3669
3670     return(test_ret);
3671 }
3672
3673 static int
3674 test_HTMLtree(void) {
3675     int test_ret = 0;
3676
3677     if (quiet == 0) printf("Testing HTMLtree : 18 of 18 functions ...\n");
3678     test_ret += test_htmlDocContentDumpFormatOutput();
3679     test_ret += test_htmlDocContentDumpOutput();
3680     test_ret += test_htmlDocDump();
3681     test_ret += test_htmlDocDumpMemory();
3682     test_ret += test_htmlDocDumpMemoryFormat();
3683     test_ret += test_htmlGetMetaEncoding();
3684     test_ret += test_htmlIsBooleanAttr();
3685     test_ret += test_htmlNewDoc();
3686     test_ret += test_htmlNewDocNoDtD();
3687     test_ret += test_htmlNodeDump();
3688     test_ret += test_htmlNodeDumpFile();
3689     test_ret += test_htmlNodeDumpFileFormat();
3690     test_ret += test_htmlNodeDumpFormatOutput();
3691     test_ret += test_htmlNodeDumpOutput();
3692     test_ret += test_htmlSaveFile();
3693     test_ret += test_htmlSaveFileEnc();
3694     test_ret += test_htmlSaveFileFormat();
3695     test_ret += test_htmlSetMetaEncoding();
3696
3697     if (test_ret != 0)
3698         printf("Module HTMLtree: %d errors\n", test_ret);
3699     return(test_ret);
3700 }
3701
3702 static int
3703 test_docbDefaultSAXHandlerInit(void) {
3704     int test_ret = 0;
3705
3706 #if defined(LIBXML_DOCB_ENABLED)
3707 #ifdef LIBXML_DOCB_ENABLED
3708     int mem_base;
3709
3710         mem_base = xmlMemBlocks();
3711
3712         docbDefaultSAXHandlerInit();
3713         call_tests++;
3714         xmlResetLastError();
3715         if (mem_base != xmlMemBlocks()) {
3716             printf("Leak of %d blocks found in docbDefaultSAXHandlerInit",
3717                    xmlMemBlocks() - mem_base);
3718             test_ret++;
3719             printf("\n");
3720         }
3721     function_tests++;
3722 #endif
3723 #endif
3724
3725     return(test_ret);
3726 }
3727
3728
3729 static int
3730 test_htmlDefaultSAXHandlerInit(void) {
3731     int test_ret = 0;
3732
3733 #if defined(LIBXML_HTML_ENABLED)
3734 #ifdef LIBXML_HTML_ENABLED
3735     int mem_base;
3736
3737         mem_base = xmlMemBlocks();
3738
3739         htmlDefaultSAXHandlerInit();
3740         call_tests++;
3741         xmlResetLastError();
3742         if (mem_base != xmlMemBlocks()) {
3743             printf("Leak of %d blocks found in htmlDefaultSAXHandlerInit",
3744                    xmlMemBlocks() - mem_base);
3745             test_ret++;
3746             printf("\n");
3747         }
3748     function_tests++;
3749 #endif
3750 #endif
3751
3752     return(test_ret);
3753 }
3754
3755
3756 static int
3757 test_xmlDefaultSAXHandlerInit(void) {
3758     int test_ret = 0;
3759
3760     int mem_base;
3761
3762         mem_base = xmlMemBlocks();
3763
3764         xmlDefaultSAXHandlerInit();
3765         call_tests++;
3766         xmlResetLastError();
3767         if (mem_base != xmlMemBlocks()) {
3768             printf("Leak of %d blocks found in xmlDefaultSAXHandlerInit",
3769                    xmlMemBlocks() - mem_base);
3770             test_ret++;
3771             printf("\n");
3772         }
3773     function_tests++;
3774
3775     return(test_ret);
3776 }
3777
3778
3779 #define gen_nb_xmlEnumerationPtr 1
3780 static xmlEnumerationPtr gen_xmlEnumerationPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
3781     return(NULL);
3782 }
3783 static void des_xmlEnumerationPtr(int no ATTRIBUTE_UNUSED, xmlEnumerationPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
3784 }
3785
3786 static int
3787 test_xmlSAX2AttributeDecl(void) {
3788     int test_ret = 0;
3789
3790     int mem_base;
3791     void * ctx; /* the user data (XML parser context) */
3792     int n_ctx;
3793     xmlChar * elem; /* the name of the element */
3794     int n_elem;
3795     xmlChar * fullname; /* the attribute name */
3796     int n_fullname;
3797     int type; /* the attribute type */
3798     int n_type;
3799     int def; /* the type of default value */
3800     int n_def;
3801     xmlChar * defaultValue; /* the attribute default value */
3802     int n_defaultValue;
3803     xmlEnumerationPtr tree; /* the tree of enumerated value set */
3804     int n_tree;
3805
3806     for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
3807     for (n_elem = 0;n_elem < gen_nb_const_xmlChar_ptr;n_elem++) {
3808     for (n_fullname = 0;n_fullname < gen_nb_const_xmlChar_ptr;n_fullname++) {
3809     for (n_type = 0;n_type < gen_nb_int;n_type++) {
3810     for (n_def = 0;n_def < gen_nb_int;n_def++) {
3811     for (n_defaultValue = 0;n_defaultValue < gen_nb_const_xmlChar_ptr;n_defaultValue++) {
3812     for (n_tree = 0;n_tree < gen_nb_xmlEnumerationPtr;n_tree++) {
3813         mem_base = xmlMemBlocks();
3814         ctx = gen_void_ptr(n_ctx, 0);
3815         elem = gen_const_xmlChar_ptr(n_elem, 1);
3816         fullname = gen_const_xmlChar_ptr(n_fullname, 2);
3817         type = gen_int(n_type, 3);
3818         def = gen_int(n_def, 4);
3819         defaultValue = gen_const_xmlChar_ptr(n_defaultValue, 5);
3820         tree = gen_xmlEnumerationPtr(n_tree, 6);
3821
3822         xmlSAX2AttributeDecl(ctx, (const xmlChar *)elem, (const xmlChar *)fullname, type, def, (const xmlChar *)defaultValue, tree);
3823         call_tests++;
3824         des_void_ptr(n_ctx, ctx, 0);
3825         des_const_xmlChar_ptr(n_elem, (const xmlChar *)elem, 1);
3826         des_const_xmlChar_ptr(n_fullname, (const xmlChar *)fullname, 2);
3827         des_int(n_type, type, 3);
3828         des_int(n_def, def, 4);
3829         des_const_xmlChar_ptr(n_defaultValue, (const xmlChar *)defaultValue, 5);
3830         des_xmlEnumerationPtr(n_tree, tree, 6);
3831         xmlResetLastError();
3832         if (mem_base != xmlMemBlocks()) {
3833             printf("Leak of %d blocks found in xmlSAX2AttributeDecl",
3834                    xmlMemBlocks() - mem_base);
3835             test_ret++;
3836             printf(" %d", n_ctx);
3837             printf(" %d", n_elem);
3838             printf(" %d", n_fullname);
3839             printf(" %d", n_type);
3840             printf(" %d", n_def);
3841             printf(" %d", n_defaultValue);
3842             printf(" %d", n_tree);
3843             printf("\n");
3844         }
3845     }
3846     }
3847     }
3848     }
3849     }
3850     }
3851     }
3852     function_tests++;
3853
3854     return(test_ret);
3855 }
3856
3857
3858 static int
3859 test_xmlSAX2CDataBlock(void) {
3860     int test_ret = 0;
3861
3862     int mem_base;
3863     void * ctx; /* the user data (XML parser context) */
3864     int n_ctx;
3865     xmlChar * value; /* The pcdata content */
3866     int n_value;
3867     int len; /* the block length */
3868     int n_len;
3869
3870     for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
3871     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
3872     for (n_len = 0;n_len < gen_nb_int;n_len++) {
3873         mem_base = xmlMemBlocks();
3874         ctx = gen_void_ptr(n_ctx, 0);
3875         value = gen_const_xmlChar_ptr(n_value, 1);
3876         len = gen_int(n_len, 2);
3877
3878         xmlSAX2CDataBlock(ctx, (const xmlChar *)value, len);
3879         call_tests++;
3880         des_void_ptr(n_ctx, ctx, 0);
3881         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
3882         des_int(n_len, len, 2);
3883         xmlResetLastError();
3884         if (mem_base != xmlMemBlocks()) {
3885             printf("Leak of %d blocks found in xmlSAX2CDataBlock",
3886                    xmlMemBlocks() - mem_base);
3887             test_ret++;
3888             printf(" %d", n_ctx);
3889             printf(" %d", n_value);
3890             printf(" %d", n_len);
3891             printf("\n");
3892         }
3893     }
3894     }
3895     }
3896     function_tests++;
3897
3898     return(test_ret);
3899 }
3900
3901
3902 static int
3903 test_xmlSAX2Characters(void) {
3904     int test_ret = 0;
3905
3906     int mem_base;
3907     void * ctx; /* the user data (XML parser context) */
3908     int n_ctx;
3909     xmlChar * ch; /* a xmlChar string */
3910     int n_ch;
3911     int len; /* the number of xmlChar */
3912     int n_len;
3913
3914     for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
3915     for (n_ch = 0;n_ch < gen_nb_const_xmlChar_ptr;n_ch++) {
3916     for (n_len = 0;n_len < gen_nb_int;n_len++) {
3917         mem_base = xmlMemBlocks();
3918         ctx = gen_void_ptr(n_ctx, 0);
3919         ch = gen_const_xmlChar_ptr(n_ch, 1);
3920         len = gen_int(n_len, 2);
3921
3922         xmlSAX2Characters(ctx, (const xmlChar *)ch, len);
3923         call_tests++;
3924         des_void_ptr(n_ctx, ctx, 0);
3925         des_const_xmlChar_ptr(n_ch, (const xmlChar *)ch, 1);
3926         des_int(n_len, len, 2);
3927         xmlResetLastError();
3928         if (mem_base != xmlMemBlocks()) {
3929             printf("Leak of %d blocks found in xmlSAX2Characters",
3930                    xmlMemBlocks() - mem_base);
3931             test_ret++;
3932             printf(" %d", n_ctx);
3933             printf(" %d", n_ch);
3934             printf(" %d", n_len);
3935             printf("\n");
3936         }
3937     }
3938     }
3939     }
3940     function_tests++;
3941
3942     return(test_ret);
3943 }
3944
3945
3946 static int
3947 test_xmlSAX2Comment(void) {
3948     int test_ret = 0;
3949
3950     int mem_base;
3951     void * ctx; /* the user data (XML parser context) */
3952     int n_ctx;
3953     xmlChar * value; /* the xmlSAX2Comment content */
3954     int n_value;
3955
3956     for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
3957     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
3958         mem_base = xmlMemBlocks();
3959         ctx = gen_void_ptr(n_ctx, 0);
3960         value = gen_const_xmlChar_ptr(n_value, 1);
3961
3962         xmlSAX2Comment(ctx, (const xmlChar *)value);
3963         call_tests++;
3964         des_void_ptr(n_ctx, ctx, 0);
3965         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
3966         xmlResetLastError();
3967         if (mem_base != xmlMemBlocks()) {
3968             printf("Leak of %d blocks found in xmlSAX2Comment",
3969                    xmlMemBlocks() - mem_base);
3970             test_ret++;
3971             printf(" %d", n_ctx);
3972             printf(" %d", n_value);
3973             printf("\n");
3974         }
3975     }
3976     }
3977     function_tests++;
3978
3979     return(test_ret);
3980 }
3981
3982
3983 static int
3984 test_xmlSAX2ElementDecl(void) {
3985     int test_ret = 0;
3986
3987     int mem_base;
3988     void * ctx; /* the user data (XML parser context) */
3989     int n_ctx;
3990     xmlChar * name; /* the element name */
3991     int n_name;
3992     int type; /* the element type */
3993     int n_type;
3994     xmlElementContentPtr content; /* the element value tree */
3995     int n_content;
3996
3997     for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
3998     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
3999     for (n_type = 0;n_type < gen_nb_int;n_type++) {
4000     for (n_content = 0;n_content < gen_nb_xmlElementContentPtr;n_content++) {
4001         mem_base = xmlMemBlocks();
4002         ctx = gen_void_ptr(n_ctx, 0);
4003         name = gen_const_xmlChar_ptr(n_name, 1);
4004         type = gen_int(n_type, 2);
4005         content = gen_xmlElementContentPtr(n_content, 3);
4006
4007         xmlSAX2ElementDecl(ctx, (const xmlChar *)name, type, content);
4008         call_tests++;
4009         des_void_ptr(n_ctx, ctx, 0);
4010         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
4011         des_int(n_type, type, 2);
4012         des_xmlElementContentPtr(n_content, content, 3);
4013         xmlResetLastError();
4014         if (mem_base != xmlMemBlocks()) {
4015             printf("Leak of %d blocks found in xmlSAX2ElementDecl",
4016                    xmlMemBlocks() - mem_base);
4017             test_ret++;
4018             printf(" %d", n_ctx);
4019             printf(" %d", n_name);
4020             printf(" %d", n_type);
4021             printf(" %d", n_content);
4022             printf("\n");
4023         }
4024     }
4025     }
4026     }
4027     }
4028     function_tests++;
4029
4030     return(test_ret);
4031 }
4032
4033
4034 static int
4035 test_xmlSAX2EndDocument(void) {
4036     int test_ret = 0;
4037
4038     int mem_base;
4039     void * ctx; /* the user data (XML parser context) */
4040     int n_ctx;
4041
4042     for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4043         mem_base = xmlMemBlocks();
4044         ctx = gen_void_ptr(n_ctx, 0);
4045
4046         xmlSAX2EndDocument(ctx);
4047         call_tests++;
4048         des_void_ptr(n_ctx, ctx, 0);
4049         xmlResetLastError();
4050         if (mem_base != xmlMemBlocks()) {
4051             printf("Leak of %d blocks found in xmlSAX2EndDocument",
4052                    xmlMemBlocks() - mem_base);
4053             test_ret++;
4054             printf(" %d", n_ctx);
4055             printf("\n");
4056         }
4057     }
4058     function_tests++;
4059
4060     return(test_ret);
4061 }
4062
4063
4064 static int
4065 test_xmlSAX2EndElement(void) {
4066     int test_ret = 0;
4067
4068 #if defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_DOCB_ENABLED)
4069 #ifdef LIBXML_SAX1_ENABLED
4070     int mem_base;
4071     void * ctx; /* the user data (XML parser context) */
4072     int n_ctx;
4073     xmlChar * name; /* The element name */
4074     int n_name;
4075
4076     for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4077     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
4078         mem_base = xmlMemBlocks();
4079         ctx = gen_void_ptr(n_ctx, 0);
4080         name = gen_const_xmlChar_ptr(n_name, 1);
4081
4082         xmlSAX2EndElement(ctx, (const xmlChar *)name);
4083         call_tests++;
4084         des_void_ptr(n_ctx, ctx, 0);
4085         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
4086         xmlResetLastError();
4087         if (mem_base != xmlMemBlocks()) {
4088             printf("Leak of %d blocks found in xmlSAX2EndElement",
4089                    xmlMemBlocks() - mem_base);
4090             test_ret++;
4091             printf(" %d", n_ctx);
4092             printf(" %d", n_name);
4093             printf("\n");
4094         }
4095     }
4096     }
4097     function_tests++;
4098 #endif
4099 #endif
4100
4101     return(test_ret);
4102 }
4103
4104
4105 static int
4106 test_xmlSAX2EndElementNs(void) {
4107     int test_ret = 0;
4108
4109     int mem_base;
4110     void * ctx; /* the user data (XML parser context) */
4111     int n_ctx;
4112     xmlChar * localname; /* the local name of the element */
4113     int n_localname;
4114     xmlChar * prefix; /* the element namespace prefix if available */
4115     int n_prefix;
4116     xmlChar * URI; /* the element namespace name if available */
4117     int n_URI;
4118
4119     for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4120     for (n_localname = 0;n_localname < gen_nb_const_xmlChar_ptr;n_localname++) {
4121     for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
4122     for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
4123         mem_base = xmlMemBlocks();
4124         ctx = gen_void_ptr(n_ctx, 0);
4125         localname = gen_const_xmlChar_ptr(n_localname, 1);
4126         prefix = gen_const_xmlChar_ptr(n_prefix, 2);
4127         URI = gen_const_xmlChar_ptr(n_URI, 3);
4128
4129         xmlSAX2EndElementNs(ctx, (const xmlChar *)localname, (const xmlChar *)prefix, (const xmlChar *)URI);
4130         call_tests++;
4131         des_void_ptr(n_ctx, ctx, 0);
4132         des_const_xmlChar_ptr(n_localname, (const xmlChar *)localname, 1);
4133         des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 2);
4134         des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 3);
4135         xmlResetLastError();
4136         if (mem_base != xmlMemBlocks()) {
4137             printf("Leak of %d blocks found in xmlSAX2EndElementNs",
4138                    xmlMemBlocks() - mem_base);
4139             test_ret++;
4140             printf(" %d", n_ctx);
4141             printf(" %d", n_localname);
4142             printf(" %d", n_prefix);
4143             printf(" %d", n_URI);
4144             printf("\n");
4145         }
4146     }
4147     }
4148     }
4149     }
4150     function_tests++;
4151
4152     return(test_ret);
4153 }
4154
4155
4156 static int
4157 test_xmlSAX2EntityDecl(void) {
4158     int test_ret = 0;
4159
4160     int mem_base;
4161     void * ctx; /* the user data (XML parser context) */
4162     int n_ctx;
4163     xmlChar * name; /* the entity name */
4164     int n_name;
4165     int type; /* the entity type */
4166     int n_type;
4167     xmlChar * publicId; /* The public ID of the entity */
4168     int n_publicId;
4169     xmlChar * systemId; /* The system ID of the entity */
4170     int n_systemId;
4171     xmlChar * content; /* the entity value (without processing). */
4172     int n_content;
4173
4174     for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4175     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
4176     for (n_type = 0;n_type < gen_nb_int;n_type++) {
4177     for (n_publicId = 0;n_publicId < gen_nb_const_xmlChar_ptr;n_publicId++) {
4178     for (n_systemId = 0;n_systemId < gen_nb_const_xmlChar_ptr;n_systemId++) {
4179     for (n_content = 0;n_content < gen_nb_xmlChar_ptr;n_content++) {
4180         mem_base = xmlMemBlocks();
4181         ctx = gen_void_ptr(n_ctx, 0);
4182         name = gen_const_xmlChar_ptr(n_name, 1);
4183         type = gen_int(n_type, 2);
4184         publicId = gen_const_xmlChar_ptr(n_publicId, 3);
4185         systemId = gen_const_xmlChar_ptr(n_systemId, 4);
4186         content = gen_xmlChar_ptr(n_content, 5);
4187
4188         xmlSAX2EntityDecl(ctx, (const xmlChar *)name, type, (const xmlChar *)publicId, (const xmlChar *)systemId, content);
4189         call_tests++;
4190         des_void_ptr(n_ctx, ctx, 0);
4191         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
4192         des_int(n_type, type, 2);
4193         des_const_xmlChar_ptr(n_publicId, (const xmlChar *)publicId, 3);
4194         des_const_xmlChar_ptr(n_systemId, (const xmlChar *)systemId, 4);
4195         des_xmlChar_ptr(n_content, content, 5);
4196         xmlResetLastError();
4197         if (mem_base != xmlMemBlocks()) {
4198             printf("Leak of %d blocks found in xmlSAX2EntityDecl",
4199                    xmlMemBlocks() - mem_base);
4200             test_ret++;
4201             printf(" %d", n_ctx);
4202             printf(" %d", n_name);
4203             printf(" %d", n_type);
4204             printf(" %d", n_publicId);
4205             printf(" %d", n_systemId);
4206             printf(" %d", n_content);
4207             printf("\n");
4208         }
4209     }
4210     }
4211     }
4212     }
4213     }
4214     }
4215     function_tests++;
4216
4217     return(test_ret);
4218 }
4219
4220
4221 static int
4222 test_xmlSAX2ExternalSubset(void) {
4223     int test_ret = 0;
4224
4225     int mem_base;
4226     void * ctx; /* the user data (XML parser context) */
4227     int n_ctx;
4228     xmlChar * name; /* the root element name */
4229     int n_name;
4230     xmlChar * ExternalID; /* the external ID */
4231     int n_ExternalID;
4232     xmlChar * SystemID; /* the SYSTEM ID (e.g. filename or URL) */
4233     int n_SystemID;
4234
4235     for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4236     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
4237     for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
4238     for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
4239         mem_base = xmlMemBlocks();
4240         ctx = gen_void_ptr(n_ctx, 0);
4241         name = gen_const_xmlChar_ptr(n_name, 1);
4242         ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 2);
4243         SystemID = gen_const_xmlChar_ptr(n_SystemID, 3);
4244
4245         xmlSAX2ExternalSubset(ctx, (const xmlChar *)name, (const xmlChar *)ExternalID, (const xmlChar *)SystemID);
4246         call_tests++;
4247         des_void_ptr(n_ctx, ctx, 0);
4248         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
4249         des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 2);
4250         des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 3);
4251         xmlResetLastError();
4252         if (mem_base != xmlMemBlocks()) {
4253             printf("Leak of %d blocks found in xmlSAX2ExternalSubset",
4254                    xmlMemBlocks() - mem_base);
4255             test_ret++;
4256             printf(" %d", n_ctx);
4257             printf(" %d", n_name);
4258             printf(" %d", n_ExternalID);
4259             printf(" %d", n_SystemID);
4260             printf("\n");
4261         }
4262     }
4263     }
4264     }
4265     }
4266     function_tests++;
4267
4268     return(test_ret);
4269 }
4270
4271
4272 static int
4273 test_xmlSAX2GetColumnNumber(void) {
4274     int test_ret = 0;
4275
4276     int mem_base;
4277     int ret_val;
4278     void * ctx; /* the user data (XML parser context) */
4279     int n_ctx;
4280
4281     for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4282         mem_base = xmlMemBlocks();
4283         ctx = gen_void_ptr(n_ctx, 0);
4284
4285         ret_val = xmlSAX2GetColumnNumber(ctx);
4286         desret_int(ret_val);
4287         call_tests++;
4288         des_void_ptr(n_ctx, ctx, 0);
4289         xmlResetLastError();
4290         if (mem_base != xmlMemBlocks()) {
4291             printf("Leak of %d blocks found in xmlSAX2GetColumnNumber",
4292                    xmlMemBlocks() - mem_base);
4293             test_ret++;
4294             printf(" %d", n_ctx);
4295             printf("\n");
4296         }
4297     }
4298     function_tests++;
4299
4300     return(test_ret);
4301 }
4302
4303
4304 static int
4305 test_xmlSAX2GetEntity(void) {
4306     int test_ret = 0;
4307
4308     int mem_base;
4309     xmlEntityPtr ret_val;
4310     void * ctx; /* the user data (XML parser context) */
4311     int n_ctx;
4312     xmlChar * name; /* The entity name */
4313     int n_name;
4314
4315     for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4316     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
4317         mem_base = xmlMemBlocks();
4318         ctx = gen_void_ptr(n_ctx, 0);
4319         name = gen_const_xmlChar_ptr(n_name, 1);
4320
4321         ret_val = xmlSAX2GetEntity(ctx, (const xmlChar *)name);
4322         desret_xmlEntityPtr(ret_val);
4323         call_tests++;
4324         des_void_ptr(n_ctx, ctx, 0);
4325         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
4326         xmlResetLastError();
4327         if (mem_base != xmlMemBlocks()) {
4328             printf("Leak of %d blocks found in xmlSAX2GetEntity",
4329                    xmlMemBlocks() - mem_base);
4330             test_ret++;
4331             printf(" %d", n_ctx);
4332             printf(" %d", n_name);
4333             printf("\n");
4334         }
4335     }
4336     }
4337     function_tests++;
4338
4339     return(test_ret);
4340 }
4341
4342
4343 static int
4344 test_xmlSAX2GetLineNumber(void) {
4345     int test_ret = 0;
4346
4347     int mem_base;
4348     int ret_val;
4349     void * ctx; /* the user data (XML parser context) */
4350     int n_ctx;
4351
4352     for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4353         mem_base = xmlMemBlocks();
4354         ctx = gen_void_ptr(n_ctx, 0);
4355
4356         ret_val = xmlSAX2GetLineNumber(ctx);
4357         desret_int(ret_val);
4358         call_tests++;
4359         des_void_ptr(n_ctx, ctx, 0);
4360         xmlResetLastError();
4361         if (mem_base != xmlMemBlocks()) {
4362             printf("Leak of %d blocks found in xmlSAX2GetLineNumber",
4363                    xmlMemBlocks() - mem_base);
4364             test_ret++;
4365             printf(" %d", n_ctx);
4366             printf("\n");
4367         }
4368     }
4369     function_tests++;
4370
4371     return(test_ret);
4372 }
4373
4374
4375 static int
4376 test_xmlSAX2GetParameterEntity(void) {
4377     int test_ret = 0;
4378
4379     int mem_base;
4380     xmlEntityPtr ret_val;
4381     void * ctx; /* the user data (XML parser context) */
4382     int n_ctx;
4383     xmlChar * name; /* The entity name */
4384     int n_name;
4385
4386     for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4387     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
4388         mem_base = xmlMemBlocks();
4389         ctx = gen_void_ptr(n_ctx, 0);
4390         name = gen_const_xmlChar_ptr(n_name, 1);
4391
4392         ret_val = xmlSAX2GetParameterEntity(ctx, (const xmlChar *)name);
4393         desret_xmlEntityPtr(ret_val);
4394         call_tests++;
4395         des_void_ptr(n_ctx, ctx, 0);
4396         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
4397         xmlResetLastError();
4398         if (mem_base != xmlMemBlocks()) {
4399             printf("Leak of %d blocks found in xmlSAX2GetParameterEntity",
4400                    xmlMemBlocks() - mem_base);
4401             test_ret++;
4402             printf(" %d", n_ctx);
4403             printf(" %d", n_name);
4404             printf("\n");
4405         }
4406     }
4407     }
4408     function_tests++;
4409
4410     return(test_ret);
4411 }
4412
4413
4414 static int
4415 test_xmlSAX2GetPublicId(void) {
4416     int test_ret = 0;
4417
4418     int mem_base;
4419     const xmlChar * ret_val;
4420     void * ctx; /* the user data (XML parser context) */
4421     int n_ctx;
4422
4423     for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4424         mem_base = xmlMemBlocks();
4425         ctx = gen_void_ptr(n_ctx, 0);
4426
4427         ret_val = xmlSAX2GetPublicId(ctx);
4428         desret_const_xmlChar_ptr(ret_val);
4429         call_tests++;
4430         des_void_ptr(n_ctx, ctx, 0);
4431         xmlResetLastError();
4432         if (mem_base != xmlMemBlocks()) {
4433             printf("Leak of %d blocks found in xmlSAX2GetPublicId",
4434                    xmlMemBlocks() - mem_base);
4435             test_ret++;
4436             printf(" %d", n_ctx);
4437             printf("\n");
4438         }
4439     }
4440     function_tests++;
4441
4442     return(test_ret);
4443 }
4444
4445
4446 static int
4447 test_xmlSAX2GetSystemId(void) {
4448     int test_ret = 0;
4449
4450     int mem_base;
4451     const xmlChar * ret_val;
4452     void * ctx; /* the user data (XML parser context) */
4453     int n_ctx;
4454
4455     for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4456         mem_base = xmlMemBlocks();
4457         ctx = gen_void_ptr(n_ctx, 0);
4458
4459         ret_val = xmlSAX2GetSystemId(ctx);
4460         desret_const_xmlChar_ptr(ret_val);
4461         call_tests++;
4462         des_void_ptr(n_ctx, ctx, 0);
4463         xmlResetLastError();
4464         if (mem_base != xmlMemBlocks()) {
4465             printf("Leak of %d blocks found in xmlSAX2GetSystemId",
4466                    xmlMemBlocks() - mem_base);
4467             test_ret++;
4468             printf(" %d", n_ctx);
4469             printf("\n");
4470         }
4471     }
4472     function_tests++;
4473
4474     return(test_ret);
4475 }
4476
4477
4478 static int
4479 test_xmlSAX2HasExternalSubset(void) {
4480     int test_ret = 0;
4481
4482     int mem_base;
4483     int ret_val;
4484     void * ctx; /* the user data (XML parser context) */
4485     int n_ctx;
4486
4487     for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4488         mem_base = xmlMemBlocks();
4489         ctx = gen_void_ptr(n_ctx, 0);
4490
4491         ret_val = xmlSAX2HasExternalSubset(ctx);
4492         desret_int(ret_val);
4493         call_tests++;
4494         des_void_ptr(n_ctx, ctx, 0);
4495         xmlResetLastError();
4496         if (mem_base != xmlMemBlocks()) {
4497             printf("Leak of %d blocks found in xmlSAX2HasExternalSubset",
4498                    xmlMemBlocks() - mem_base);
4499             test_ret++;
4500             printf(" %d", n_ctx);
4501             printf("\n");
4502         }
4503     }
4504     function_tests++;
4505
4506     return(test_ret);
4507 }
4508
4509
4510 static int
4511 test_xmlSAX2HasInternalSubset(void) {
4512     int test_ret = 0;
4513
4514     int mem_base;
4515     int ret_val;
4516     void * ctx; /* the user data (XML parser context) */
4517     int n_ctx;
4518
4519     for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4520         mem_base = xmlMemBlocks();
4521         ctx = gen_void_ptr(n_ctx, 0);
4522
4523         ret_val = xmlSAX2HasInternalSubset(ctx);
4524         desret_int(ret_val);
4525         call_tests++;
4526         des_void_ptr(n_ctx, ctx, 0);
4527         xmlResetLastError();
4528         if (mem_base != xmlMemBlocks()) {
4529             printf("Leak of %d blocks found in xmlSAX2HasInternalSubset",
4530                    xmlMemBlocks() - mem_base);
4531             test_ret++;
4532             printf(" %d", n_ctx);
4533             printf("\n");
4534         }
4535     }
4536     function_tests++;
4537
4538     return(test_ret);
4539 }
4540
4541
4542 static int
4543 test_xmlSAX2IgnorableWhitespace(void) {
4544     int test_ret = 0;
4545
4546     int mem_base;
4547     void * ctx; /* the user data (XML parser context) */
4548     int n_ctx;
4549     xmlChar * ch; /* a xmlChar string */
4550     int n_ch;
4551     int len; /* the number of xmlChar */
4552     int n_len;
4553
4554     for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4555     for (n_ch = 0;n_ch < gen_nb_const_xmlChar_ptr;n_ch++) {
4556     for (n_len = 0;n_len < gen_nb_int;n_len++) {
4557         mem_base = xmlMemBlocks();
4558         ctx = gen_void_ptr(n_ctx, 0);
4559         ch = gen_const_xmlChar_ptr(n_ch, 1);
4560         len = gen_int(n_len, 2);
4561
4562         xmlSAX2IgnorableWhitespace(ctx, (const xmlChar *)ch, len);
4563         call_tests++;
4564         des_void_ptr(n_ctx, ctx, 0);
4565         des_const_xmlChar_ptr(n_ch, (const xmlChar *)ch, 1);
4566         des_int(n_len, len, 2);
4567         xmlResetLastError();
4568         if (mem_base != xmlMemBlocks()) {
4569             printf("Leak of %d blocks found in xmlSAX2IgnorableWhitespace",
4570                    xmlMemBlocks() - mem_base);
4571             test_ret++;
4572             printf(" %d", n_ctx);
4573             printf(" %d", n_ch);
4574             printf(" %d", n_len);
4575             printf("\n");
4576         }
4577     }
4578     }
4579     }
4580     function_tests++;
4581
4582     return(test_ret);
4583 }
4584
4585
4586 #define gen_nb_xmlSAXHandler_ptr 1
4587 static xmlSAXHandler * gen_xmlSAXHandler_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
4588     return(NULL);
4589 }
4590 static void des_xmlSAXHandler_ptr(int no ATTRIBUTE_UNUSED, xmlSAXHandler * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
4591 }
4592
4593 static int
4594 test_xmlSAX2InitDefaultSAXHandler(void) {
4595     int test_ret = 0;
4596
4597     int mem_base;
4598     xmlSAXHandler * hdlr; /* the SAX handler */
4599     int n_hdlr;
4600     int warning; /* flag if non-zero sets the handler warning procedure */
4601     int n_warning;
4602
4603     for (n_hdlr = 0;n_hdlr < gen_nb_xmlSAXHandler_ptr;n_hdlr++) {
4604     for (n_warning = 0;n_warning < gen_nb_int;n_warning++) {
4605         mem_base = xmlMemBlocks();
4606         hdlr = gen_xmlSAXHandler_ptr(n_hdlr, 0);
4607         warning = gen_int(n_warning, 1);
4608
4609         xmlSAX2InitDefaultSAXHandler(hdlr, warning);
4610         call_tests++;
4611         des_xmlSAXHandler_ptr(n_hdlr, hdlr, 0);
4612         des_int(n_warning, warning, 1);
4613         xmlResetLastError();
4614         if (mem_base != xmlMemBlocks()) {
4615             printf("Leak of %d blocks found in xmlSAX2InitDefaultSAXHandler",
4616                    xmlMemBlocks() - mem_base);
4617             test_ret++;
4618             printf(" %d", n_hdlr);
4619             printf(" %d", n_warning);
4620             printf("\n");
4621         }
4622     }
4623     }
4624     function_tests++;
4625
4626     return(test_ret);
4627 }
4628
4629
4630 static int
4631 test_xmlSAX2InitDocbDefaultSAXHandler(void) {
4632     int test_ret = 0;
4633
4634 #if defined(LIBXML_DOCB_ENABLED)
4635     int mem_base;
4636     xmlSAXHandler * hdlr; /* the SAX handler */
4637     int n_hdlr;
4638
4639     for (n_hdlr = 0;n_hdlr < gen_nb_xmlSAXHandler_ptr;n_hdlr++) {
4640         mem_base = xmlMemBlocks();
4641         hdlr = gen_xmlSAXHandler_ptr(n_hdlr, 0);
4642
4643         xmlSAX2InitDocbDefaultSAXHandler(hdlr);
4644         call_tests++;
4645         des_xmlSAXHandler_ptr(n_hdlr, hdlr, 0);
4646         xmlResetLastError();
4647         if (mem_base != xmlMemBlocks()) {
4648             printf("Leak of %d blocks found in xmlSAX2InitDocbDefaultSAXHandler",
4649                    xmlMemBlocks() - mem_base);
4650             test_ret++;
4651             printf(" %d", n_hdlr);
4652             printf("\n");
4653         }
4654     }
4655     function_tests++;
4656 #endif
4657
4658     return(test_ret);
4659 }
4660
4661
4662 static int
4663 test_xmlSAX2InitHtmlDefaultSAXHandler(void) {
4664     int test_ret = 0;
4665
4666 #if defined(LIBXML_HTML_ENABLED)
4667     int mem_base;
4668     xmlSAXHandler * hdlr; /* the SAX handler */
4669     int n_hdlr;
4670
4671     for (n_hdlr = 0;n_hdlr < gen_nb_xmlSAXHandler_ptr;n_hdlr++) {
4672         mem_base = xmlMemBlocks();
4673         hdlr = gen_xmlSAXHandler_ptr(n_hdlr, 0);
4674
4675         xmlSAX2InitHtmlDefaultSAXHandler(hdlr);
4676         call_tests++;
4677         des_xmlSAXHandler_ptr(n_hdlr, hdlr, 0);
4678         xmlResetLastError();
4679         if (mem_base != xmlMemBlocks()) {
4680             printf("Leak of %d blocks found in xmlSAX2InitHtmlDefaultSAXHandler",
4681                    xmlMemBlocks() - mem_base);
4682             test_ret++;
4683             printf(" %d", n_hdlr);
4684             printf("\n");
4685         }
4686     }
4687     function_tests++;
4688 #endif
4689
4690     return(test_ret);
4691 }
4692
4693
4694 static int
4695 test_xmlSAX2InternalSubset(void) {
4696     int test_ret = 0;
4697
4698     int mem_base;
4699     void * ctx; /* the user data (XML parser context) */
4700     int n_ctx;
4701     xmlChar * name; /* the root element name */
4702     int n_name;
4703     xmlChar * ExternalID; /* the external ID */
4704     int n_ExternalID;
4705     xmlChar * SystemID; /* the SYSTEM ID (e.g. filename or URL) */
4706     int n_SystemID;
4707
4708     for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4709     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
4710     for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
4711     for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
4712         mem_base = xmlMemBlocks();
4713         ctx = gen_void_ptr(n_ctx, 0);
4714         name = gen_const_xmlChar_ptr(n_name, 1);
4715         ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 2);
4716         SystemID = gen_const_xmlChar_ptr(n_SystemID, 3);
4717
4718         xmlSAX2InternalSubset(ctx, (const xmlChar *)name, (const xmlChar *)ExternalID, (const xmlChar *)SystemID);
4719         call_tests++;
4720         des_void_ptr(n_ctx, ctx, 0);
4721         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
4722         des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 2);
4723         des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 3);
4724         xmlResetLastError();
4725         if (mem_base != xmlMemBlocks()) {
4726             printf("Leak of %d blocks found in xmlSAX2InternalSubset",
4727                    xmlMemBlocks() - mem_base);
4728             test_ret++;
4729             printf(" %d", n_ctx);
4730             printf(" %d", n_name);
4731             printf(" %d", n_ExternalID);
4732             printf(" %d", n_SystemID);
4733             printf("\n");
4734         }
4735     }
4736     }
4737     }
4738     }
4739     function_tests++;
4740
4741     return(test_ret);
4742 }
4743
4744
4745 static int
4746 test_xmlSAX2IsStandalone(void) {
4747     int test_ret = 0;
4748
4749     int mem_base;
4750     int ret_val;
4751     void * ctx; /* the user data (XML parser context) */
4752     int n_ctx;
4753
4754     for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4755         mem_base = xmlMemBlocks();
4756         ctx = gen_void_ptr(n_ctx, 0);
4757
4758         ret_val = xmlSAX2IsStandalone(ctx);
4759         desret_int(ret_val);
4760         call_tests++;
4761         des_void_ptr(n_ctx, ctx, 0);
4762         xmlResetLastError();
4763         if (mem_base != xmlMemBlocks()) {
4764             printf("Leak of %d blocks found in xmlSAX2IsStandalone",
4765                    xmlMemBlocks() - mem_base);
4766             test_ret++;
4767             printf(" %d", n_ctx);
4768             printf("\n");
4769         }
4770     }
4771     function_tests++;
4772
4773     return(test_ret);
4774 }
4775
4776
4777 static int
4778 test_xmlSAX2NotationDecl(void) {
4779     int test_ret = 0;
4780
4781     int mem_base;
4782     void * ctx; /* the user data (XML parser context) */
4783     int n_ctx;
4784     xmlChar * name; /* The name of the notation */
4785     int n_name;
4786     xmlChar * publicId; /* The public ID of the entity */
4787     int n_publicId;
4788     xmlChar * systemId; /* The system ID of the entity */
4789     int n_systemId;
4790
4791     for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4792     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
4793     for (n_publicId = 0;n_publicId < gen_nb_const_xmlChar_ptr;n_publicId++) {
4794     for (n_systemId = 0;n_systemId < gen_nb_const_xmlChar_ptr;n_systemId++) {
4795         mem_base = xmlMemBlocks();
4796         ctx = gen_void_ptr(n_ctx, 0);
4797         name = gen_const_xmlChar_ptr(n_name, 1);
4798         publicId = gen_const_xmlChar_ptr(n_publicId, 2);
4799         systemId = gen_const_xmlChar_ptr(n_systemId, 3);
4800
4801         xmlSAX2NotationDecl(ctx, (const xmlChar *)name, (const xmlChar *)publicId, (const xmlChar *)systemId);
4802         call_tests++;
4803         des_void_ptr(n_ctx, ctx, 0);
4804         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
4805         des_const_xmlChar_ptr(n_publicId, (const xmlChar *)publicId, 2);
4806         des_const_xmlChar_ptr(n_systemId, (const xmlChar *)systemId, 3);
4807         xmlResetLastError();
4808         if (mem_base != xmlMemBlocks()) {
4809             printf("Leak of %d blocks found in xmlSAX2NotationDecl",
4810                    xmlMemBlocks() - mem_base);
4811             test_ret++;
4812             printf(" %d", n_ctx);
4813             printf(" %d", n_name);
4814             printf(" %d", n_publicId);
4815             printf(" %d", n_systemId);
4816             printf("\n");
4817         }
4818     }
4819     }
4820     }
4821     }
4822     function_tests++;
4823
4824     return(test_ret);
4825 }
4826
4827
4828 static int
4829 test_xmlSAX2ProcessingInstruction(void) {
4830     int test_ret = 0;
4831
4832     int mem_base;
4833     void * ctx; /* the user data (XML parser context) */
4834     int n_ctx;
4835     xmlChar * target; /* the target name */
4836     int n_target;
4837     xmlChar * data; /* the PI data's */
4838     int n_data;
4839
4840     for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4841     for (n_target = 0;n_target < gen_nb_const_xmlChar_ptr;n_target++) {
4842     for (n_data = 0;n_data < gen_nb_const_xmlChar_ptr;n_data++) {
4843         mem_base = xmlMemBlocks();
4844         ctx = gen_void_ptr(n_ctx, 0);
4845         target = gen_const_xmlChar_ptr(n_target, 1);
4846         data = gen_const_xmlChar_ptr(n_data, 2);
4847
4848         xmlSAX2ProcessingInstruction(ctx, (const xmlChar *)target, (const xmlChar *)data);
4849         call_tests++;
4850         des_void_ptr(n_ctx, ctx, 0);
4851         des_const_xmlChar_ptr(n_target, (const xmlChar *)target, 1);
4852         des_const_xmlChar_ptr(n_data, (const xmlChar *)data, 2);
4853         xmlResetLastError();
4854         if (mem_base != xmlMemBlocks()) {
4855             printf("Leak of %d blocks found in xmlSAX2ProcessingInstruction",
4856                    xmlMemBlocks() - mem_base);
4857             test_ret++;
4858             printf(" %d", n_ctx);
4859             printf(" %d", n_target);
4860             printf(" %d", n_data);
4861             printf("\n");
4862         }
4863     }
4864     }
4865     }
4866     function_tests++;
4867
4868     return(test_ret);
4869 }
4870
4871
4872 static int
4873 test_xmlSAX2Reference(void) {
4874     int test_ret = 0;
4875
4876     int mem_base;
4877     void * ctx; /* the user data (XML parser context) */
4878     int n_ctx;
4879     xmlChar * name; /* The entity name */
4880     int n_name;
4881
4882     for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4883     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
4884         mem_base = xmlMemBlocks();
4885         ctx = gen_void_ptr(n_ctx, 0);
4886         name = gen_const_xmlChar_ptr(n_name, 1);
4887
4888         xmlSAX2Reference(ctx, (const xmlChar *)name);
4889         call_tests++;
4890         des_void_ptr(n_ctx, ctx, 0);
4891         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
4892         xmlResetLastError();
4893         if (mem_base != xmlMemBlocks()) {
4894             printf("Leak of %d blocks found in xmlSAX2Reference",
4895                    xmlMemBlocks() - mem_base);
4896             test_ret++;
4897             printf(" %d", n_ctx);
4898             printf(" %d", n_name);
4899             printf("\n");
4900         }
4901     }
4902     }
4903     function_tests++;
4904
4905     return(test_ret);
4906 }
4907
4908
4909 static int
4910 test_xmlSAX2ResolveEntity(void) {
4911     int test_ret = 0;
4912
4913     int mem_base;
4914     xmlParserInputPtr ret_val;
4915     void * ctx; /* the user data (XML parser context) */
4916     int n_ctx;
4917     xmlChar * publicId; /* The public ID of the entity */
4918     int n_publicId;
4919     xmlChar * systemId; /* The system ID of the entity */
4920     int n_systemId;
4921
4922     for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4923     for (n_publicId = 0;n_publicId < gen_nb_const_xmlChar_ptr;n_publicId++) {
4924     for (n_systemId = 0;n_systemId < gen_nb_const_xmlChar_ptr;n_systemId++) {
4925         mem_base = xmlMemBlocks();
4926         ctx = gen_void_ptr(n_ctx, 0);
4927         publicId = gen_const_xmlChar_ptr(n_publicId, 1);
4928         systemId = gen_const_xmlChar_ptr(n_systemId, 2);
4929
4930         ret_val = xmlSAX2ResolveEntity(ctx, (const xmlChar *)publicId, (const xmlChar *)systemId);
4931         desret_xmlParserInputPtr(ret_val);
4932         call_tests++;
4933         des_void_ptr(n_ctx, ctx, 0);
4934         des_const_xmlChar_ptr(n_publicId, (const xmlChar *)publicId, 1);
4935         des_const_xmlChar_ptr(n_systemId, (const xmlChar *)systemId, 2);
4936         xmlResetLastError();
4937         if (mem_base != xmlMemBlocks()) {
4938             printf("Leak of %d blocks found in xmlSAX2ResolveEntity",
4939                    xmlMemBlocks() - mem_base);
4940             test_ret++;
4941             printf(" %d", n_ctx);
4942             printf(" %d", n_publicId);
4943             printf(" %d", n_systemId);
4944             printf("\n");
4945         }
4946     }
4947     }
4948     }
4949     function_tests++;
4950
4951     return(test_ret);
4952 }
4953
4954
4955 #define gen_nb_xmlSAXLocatorPtr 1
4956 static xmlSAXLocatorPtr gen_xmlSAXLocatorPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
4957     return(NULL);
4958 }
4959 static void des_xmlSAXLocatorPtr(int no ATTRIBUTE_UNUSED, xmlSAXLocatorPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
4960 }
4961
4962 static int
4963 test_xmlSAX2SetDocumentLocator(void) {
4964     int test_ret = 0;
4965
4966     int mem_base;
4967     void * ctx; /* the user data (XML parser context) */
4968     int n_ctx;
4969     xmlSAXLocatorPtr loc; /* A SAX Locator */
4970     int n_loc;
4971
4972     for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
4973     for (n_loc = 0;n_loc < gen_nb_xmlSAXLocatorPtr;n_loc++) {
4974         mem_base = xmlMemBlocks();
4975         ctx = gen_void_ptr(n_ctx, 0);
4976         loc = gen_xmlSAXLocatorPtr(n_loc, 1);
4977
4978         xmlSAX2SetDocumentLocator(ctx, loc);
4979         call_tests++;
4980         des_void_ptr(n_ctx, ctx, 0);
4981         des_xmlSAXLocatorPtr(n_loc, loc, 1);
4982         xmlResetLastError();
4983         if (mem_base != xmlMemBlocks()) {
4984             printf("Leak of %d blocks found in xmlSAX2SetDocumentLocator",
4985                    xmlMemBlocks() - mem_base);
4986             test_ret++;
4987             printf(" %d", n_ctx);
4988             printf(" %d", n_loc);
4989             printf("\n");
4990         }
4991     }
4992     }
4993     function_tests++;
4994
4995     return(test_ret);
4996 }
4997
4998
4999 static int
5000 test_xmlSAX2StartDocument(void) {
5001     int test_ret = 0;
5002
5003     int mem_base;
5004     void * ctx; /* the user data (XML parser context) */
5005     int n_ctx;
5006
5007     for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
5008         mem_base = xmlMemBlocks();
5009         ctx = gen_void_ptr(n_ctx, 0);
5010
5011         xmlSAX2StartDocument(ctx);
5012         call_tests++;
5013         des_void_ptr(n_ctx, ctx, 0);
5014         xmlResetLastError();
5015         if (mem_base != xmlMemBlocks()) {
5016             printf("Leak of %d blocks found in xmlSAX2StartDocument",
5017                    xmlMemBlocks() - mem_base);
5018             test_ret++;
5019             printf(" %d", n_ctx);
5020             printf("\n");
5021         }
5022     }
5023     function_tests++;
5024
5025     return(test_ret);
5026 }
5027
5028
5029 static int
5030 test_xmlSAX2StartElement(void) {
5031     int test_ret = 0;
5032
5033 #if defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_DOCB_ENABLED)
5034 #ifdef LIBXML_SAX1_ENABLED
5035     int mem_base;
5036     void * ctx; /* the user data (XML parser context) */
5037     int n_ctx;
5038     xmlChar * fullname; /* The element name, including namespace prefix */
5039     int n_fullname;
5040     xmlChar ** atts; /* An array of name/value attributes pairs, NULL terminated */
5041     int n_atts;
5042
5043     for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
5044     for (n_fullname = 0;n_fullname < gen_nb_const_xmlChar_ptr;n_fullname++) {
5045     for (n_atts = 0;n_atts < gen_nb_const_xmlChar_ptr_ptr;n_atts++) {
5046         mem_base = xmlMemBlocks();
5047         ctx = gen_void_ptr(n_ctx, 0);
5048         fullname = gen_const_xmlChar_ptr(n_fullname, 1);
5049         atts = gen_const_xmlChar_ptr_ptr(n_atts, 2);
5050
5051         xmlSAX2StartElement(ctx, (const xmlChar *)fullname, (const xmlChar **)atts);
5052         call_tests++;
5053         des_void_ptr(n_ctx, ctx, 0);
5054         des_const_xmlChar_ptr(n_fullname, (const xmlChar *)fullname, 1);
5055         des_const_xmlChar_ptr_ptr(n_atts, (const xmlChar **)atts, 2);
5056         xmlResetLastError();
5057         if (mem_base != xmlMemBlocks()) {
5058             printf("Leak of %d blocks found in xmlSAX2StartElement",
5059                    xmlMemBlocks() - mem_base);
5060             test_ret++;
5061             printf(" %d", n_ctx);
5062             printf(" %d", n_fullname);
5063             printf(" %d", n_atts);
5064             printf("\n");
5065         }
5066     }
5067     }
5068     }
5069     function_tests++;
5070 #endif
5071 #endif
5072
5073     return(test_ret);
5074 }
5075
5076
5077 static int
5078 test_xmlSAX2StartElementNs(void) {
5079     int test_ret = 0;
5080
5081     int mem_base;
5082     void * ctx; /* the user data (XML parser context) */
5083     int n_ctx;
5084     xmlChar * localname; /* the local name of the element */
5085     int n_localname;
5086     xmlChar * prefix; /* the element namespace prefix if available */
5087     int n_prefix;
5088     xmlChar * URI; /* the element namespace name if available */
5089     int n_URI;
5090     int nb_namespaces; /* number of namespace definitions on that node */
5091     int n_nb_namespaces;
5092     xmlChar ** namespaces; /* pointer to the array of prefix/URI pairs namespace definitions */
5093     int n_namespaces;
5094     int nb_attributes; /* the number of attributes on that node */
5095     int n_nb_attributes;
5096     int nb_defaulted; /* the number of defaulted attributes. */
5097     int n_nb_defaulted;
5098     xmlChar ** attributes; /* pointer to the array of (localname/prefix/URI/value/end) attribute values. */
5099     int n_attributes;
5100
5101     for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
5102     for (n_localname = 0;n_localname < gen_nb_const_xmlChar_ptr;n_localname++) {
5103     for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
5104     for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
5105     for (n_nb_namespaces = 0;n_nb_namespaces < gen_nb_int;n_nb_namespaces++) {
5106     for (n_namespaces = 0;n_namespaces < gen_nb_const_xmlChar_ptr_ptr;n_namespaces++) {
5107     for (n_nb_attributes = 0;n_nb_attributes < gen_nb_int;n_nb_attributes++) {
5108     for (n_nb_defaulted = 0;n_nb_defaulted < gen_nb_int;n_nb_defaulted++) {
5109     for (n_attributes = 0;n_attributes < gen_nb_const_xmlChar_ptr_ptr;n_attributes++) {
5110         mem_base = xmlMemBlocks();
5111         ctx = gen_void_ptr(n_ctx, 0);
5112         localname = gen_const_xmlChar_ptr(n_localname, 1);
5113         prefix = gen_const_xmlChar_ptr(n_prefix, 2);
5114         URI = gen_const_xmlChar_ptr(n_URI, 3);
5115         nb_namespaces = gen_int(n_nb_namespaces, 4);
5116         namespaces = gen_const_xmlChar_ptr_ptr(n_namespaces, 5);
5117         nb_attributes = gen_int(n_nb_attributes, 6);
5118         nb_defaulted = gen_int(n_nb_defaulted, 7);
5119         attributes = gen_const_xmlChar_ptr_ptr(n_attributes, 8);
5120
5121         xmlSAX2StartElementNs(ctx, (const xmlChar *)localname, (const xmlChar *)prefix, (const xmlChar *)URI, nb_namespaces, (const xmlChar **)namespaces, nb_attributes, nb_defaulted, (const xmlChar **)attributes);
5122         call_tests++;
5123         des_void_ptr(n_ctx, ctx, 0);
5124         des_const_xmlChar_ptr(n_localname, (const xmlChar *)localname, 1);
5125         des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 2);
5126         des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 3);
5127         des_int(n_nb_namespaces, nb_namespaces, 4);
5128         des_const_xmlChar_ptr_ptr(n_namespaces, (const xmlChar **)namespaces, 5);
5129         des_int(n_nb_attributes, nb_attributes, 6);
5130         des_int(n_nb_defaulted, nb_defaulted, 7);
5131         des_const_xmlChar_ptr_ptr(n_attributes, (const xmlChar **)attributes, 8);
5132         xmlResetLastError();
5133         if (mem_base != xmlMemBlocks()) {
5134             printf("Leak of %d blocks found in xmlSAX2StartElementNs",
5135                    xmlMemBlocks() - mem_base);
5136             test_ret++;
5137             printf(" %d", n_ctx);
5138             printf(" %d", n_localname);
5139             printf(" %d", n_prefix);
5140             printf(" %d", n_URI);
5141             printf(" %d", n_nb_namespaces);
5142             printf(" %d", n_namespaces);
5143             printf(" %d", n_nb_attributes);
5144             printf(" %d", n_nb_defaulted);
5145             printf(" %d", n_attributes);
5146             printf("\n");
5147         }
5148     }
5149     }
5150     }
5151     }
5152     }
5153     }
5154     }
5155     }
5156     }
5157     function_tests++;
5158
5159     return(test_ret);
5160 }
5161
5162
5163 static int
5164 test_xmlSAX2UnparsedEntityDecl(void) {
5165     int test_ret = 0;
5166
5167     int mem_base;
5168     void * ctx; /* the user data (XML parser context) */
5169     int n_ctx;
5170     xmlChar * name; /* The name of the entity */
5171     int n_name;
5172     xmlChar * publicId; /* The public ID of the entity */
5173     int n_publicId;
5174     xmlChar * systemId; /* The system ID of the entity */
5175     int n_systemId;
5176     xmlChar * notationName; /* the name of the notation */
5177     int n_notationName;
5178
5179     for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
5180     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
5181     for (n_publicId = 0;n_publicId < gen_nb_const_xmlChar_ptr;n_publicId++) {
5182     for (n_systemId = 0;n_systemId < gen_nb_const_xmlChar_ptr;n_systemId++) {
5183     for (n_notationName = 0;n_notationName < gen_nb_const_xmlChar_ptr;n_notationName++) {
5184         mem_base = xmlMemBlocks();
5185         ctx = gen_void_ptr(n_ctx, 0);
5186         name = gen_const_xmlChar_ptr(n_name, 1);
5187         publicId = gen_const_xmlChar_ptr(n_publicId, 2);
5188         systemId = gen_const_xmlChar_ptr(n_systemId, 3);
5189         notationName = gen_const_xmlChar_ptr(n_notationName, 4);
5190
5191         xmlSAX2UnparsedEntityDecl(ctx, (const xmlChar *)name, (const xmlChar *)publicId, (const xmlChar *)systemId, (const xmlChar *)notationName);
5192         call_tests++;
5193         des_void_ptr(n_ctx, ctx, 0);
5194         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
5195         des_const_xmlChar_ptr(n_publicId, (const xmlChar *)publicId, 2);
5196         des_const_xmlChar_ptr(n_systemId, (const xmlChar *)systemId, 3);
5197         des_const_xmlChar_ptr(n_notationName, (const xmlChar *)notationName, 4);
5198         xmlResetLastError();
5199         if (mem_base != xmlMemBlocks()) {
5200             printf("Leak of %d blocks found in xmlSAX2UnparsedEntityDecl",
5201                    xmlMemBlocks() - mem_base);
5202             test_ret++;
5203             printf(" %d", n_ctx);
5204             printf(" %d", n_name);
5205             printf(" %d", n_publicId);
5206             printf(" %d", n_systemId);
5207             printf(" %d", n_notationName);
5208             printf("\n");
5209         }
5210     }
5211     }
5212     }
5213     }
5214     }
5215     function_tests++;
5216
5217     return(test_ret);
5218 }
5219
5220
5221 static int
5222 test_xmlSAXDefaultVersion(void) {
5223     int test_ret = 0;
5224
5225 #if defined(LIBXML_SAX1_ENABLED)
5226 #ifdef LIBXML_SAX1_ENABLED
5227     int mem_base;
5228     int ret_val;
5229     int version; /* the version, 1 or 2 */
5230     int n_version;
5231
5232     for (n_version = 0;n_version < gen_nb_int;n_version++) {
5233         mem_base = xmlMemBlocks();
5234         version = gen_int(n_version, 0);
5235
5236         ret_val = xmlSAXDefaultVersion(version);
5237         desret_int(ret_val);
5238         call_tests++;
5239         des_int(n_version, version, 0);
5240         xmlResetLastError();
5241         if (mem_base != xmlMemBlocks()) {
5242             printf("Leak of %d blocks found in xmlSAXDefaultVersion",
5243                    xmlMemBlocks() - mem_base);
5244             test_ret++;
5245             printf(" %d", n_version);
5246             printf("\n");
5247         }
5248     }
5249     function_tests++;
5250 #endif
5251 #endif
5252
5253     return(test_ret);
5254 }
5255
5256
5257 static int
5258 test_xmlSAXVersion(void) {
5259     int test_ret = 0;
5260
5261     int mem_base;
5262     int ret_val;
5263     xmlSAXHandler * hdlr; /* the SAX handler */
5264     int n_hdlr;
5265     int version; /* the version, 1 or 2 */
5266     int n_version;
5267
5268     for (n_hdlr = 0;n_hdlr < gen_nb_xmlSAXHandler_ptr;n_hdlr++) {
5269     for (n_version = 0;n_version < gen_nb_int;n_version++) {
5270         mem_base = xmlMemBlocks();
5271         hdlr = gen_xmlSAXHandler_ptr(n_hdlr, 0);
5272         version = gen_int(n_version, 1);
5273
5274         ret_val = xmlSAXVersion(hdlr, version);
5275         desret_int(ret_val);
5276         call_tests++;
5277         des_xmlSAXHandler_ptr(n_hdlr, hdlr, 0);
5278         des_int(n_version, version, 1);
5279         xmlResetLastError();
5280         if (mem_base != xmlMemBlocks()) {
5281             printf("Leak of %d blocks found in xmlSAXVersion",
5282                    xmlMemBlocks() - mem_base);
5283             test_ret++;
5284             printf(" %d", n_hdlr);
5285             printf(" %d", n_version);
5286             printf("\n");
5287         }
5288     }
5289     }
5290     function_tests++;
5291
5292     return(test_ret);
5293 }
5294
5295 static int
5296 test_SAX2(void) {
5297     int test_ret = 0;
5298
5299     if (quiet == 0) printf("Testing SAX2 : 38 of 38 functions ...\n");
5300     test_ret += test_docbDefaultSAXHandlerInit();
5301     test_ret += test_htmlDefaultSAXHandlerInit();
5302     test_ret += test_xmlDefaultSAXHandlerInit();
5303     test_ret += test_xmlSAX2AttributeDecl();
5304     test_ret += test_xmlSAX2CDataBlock();
5305     test_ret += test_xmlSAX2Characters();
5306     test_ret += test_xmlSAX2Comment();
5307     test_ret += test_xmlSAX2ElementDecl();
5308     test_ret += test_xmlSAX2EndDocument();
5309     test_ret += test_xmlSAX2EndElement();
5310     test_ret += test_xmlSAX2EndElementNs();
5311     test_ret += test_xmlSAX2EntityDecl();
5312     test_ret += test_xmlSAX2ExternalSubset();
5313     test_ret += test_xmlSAX2GetColumnNumber();
5314     test_ret += test_xmlSAX2GetEntity();
5315     test_ret += test_xmlSAX2GetLineNumber();
5316     test_ret += test_xmlSAX2GetParameterEntity();
5317     test_ret += test_xmlSAX2GetPublicId();
5318     test_ret += test_xmlSAX2GetSystemId();
5319     test_ret += test_xmlSAX2HasExternalSubset();
5320     test_ret += test_xmlSAX2HasInternalSubset();
5321     test_ret += test_xmlSAX2IgnorableWhitespace();
5322     test_ret += test_xmlSAX2InitDefaultSAXHandler();
5323     test_ret += test_xmlSAX2InitDocbDefaultSAXHandler();
5324     test_ret += test_xmlSAX2InitHtmlDefaultSAXHandler();
5325     test_ret += test_xmlSAX2InternalSubset();
5326     test_ret += test_xmlSAX2IsStandalone();
5327     test_ret += test_xmlSAX2NotationDecl();
5328     test_ret += test_xmlSAX2ProcessingInstruction();
5329     test_ret += test_xmlSAX2Reference();
5330     test_ret += test_xmlSAX2ResolveEntity();
5331     test_ret += test_xmlSAX2SetDocumentLocator();
5332     test_ret += test_xmlSAX2StartDocument();
5333     test_ret += test_xmlSAX2StartElement();
5334     test_ret += test_xmlSAX2StartElementNs();
5335     test_ret += test_xmlSAX2UnparsedEntityDecl();
5336     test_ret += test_xmlSAXDefaultVersion();
5337     test_ret += test_xmlSAXVersion();
5338
5339     if (test_ret != 0)
5340         printf("Module SAX2: %d errors\n", test_ret);
5341     return(test_ret);
5342 }
5343
5344 static int
5345 test_xmlC14NDocDumpMemory(void) {
5346     int test_ret = 0;
5347
5348 #if defined(LIBXML_C14N_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
5349     int mem_base;
5350     int ret_val;
5351     xmlDocPtr doc; /* the XML document for canonization */
5352     int n_doc;
5353     xmlNodeSetPtr nodes; /* the nodes set to be included in the canonized image or NULL if all document nodes should be included */
5354     int n_nodes;
5355     int mode; /* the c14n mode (see @xmlC14NMode) */
5356     int n_mode;
5357     xmlChar ** inclusive_ns_prefixes; /* the list of inclusive namespace prefixes ended with a NULL or NULL if there is no inclusive namespaces (only for exclusive canonicalization, ignored otherwise) */
5358     int n_inclusive_ns_prefixes;
5359     int with_comments; /* include comments in the result (!=0) or not (==0) */
5360     int n_with_comments;
5361     xmlChar ** doc_txt_ptr; /* the memory pointer for allocated canonical XML text; the caller of this functions is responsible for calling xmlFree() to free allocated memory */
5362     int n_doc_txt_ptr;
5363
5364     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
5365     for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
5366     for (n_mode = 0;n_mode < gen_nb_int;n_mode++) {
5367     for (n_inclusive_ns_prefixes = 0;n_inclusive_ns_prefixes < gen_nb_xmlChar_ptr_ptr;n_inclusive_ns_prefixes++) {
5368     for (n_with_comments = 0;n_with_comments < gen_nb_int;n_with_comments++) {
5369     for (n_doc_txt_ptr = 0;n_doc_txt_ptr < gen_nb_xmlChar_ptr_ptr;n_doc_txt_ptr++) {
5370         mem_base = xmlMemBlocks();
5371         doc = gen_xmlDocPtr(n_doc, 0);
5372         nodes = gen_xmlNodeSetPtr(n_nodes, 1);
5373         mode = gen_int(n_mode, 2);
5374         inclusive_ns_prefixes = gen_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, 3);
5375         with_comments = gen_int(n_with_comments, 4);
5376         doc_txt_ptr = gen_xmlChar_ptr_ptr(n_doc_txt_ptr, 5);
5377
5378         ret_val = xmlC14NDocDumpMemory(doc, nodes, mode, inclusive_ns_prefixes, with_comments, doc_txt_ptr);
5379         desret_int(ret_val);
5380         call_tests++;
5381         des_xmlDocPtr(n_doc, doc, 0);
5382         des_xmlNodeSetPtr(n_nodes, nodes, 1);
5383         des_int(n_mode, mode, 2);
5384         des_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, inclusive_ns_prefixes, 3);
5385         des_int(n_with_comments, with_comments, 4);
5386         des_xmlChar_ptr_ptr(n_doc_txt_ptr, doc_txt_ptr, 5);
5387         xmlResetLastError();
5388         if (mem_base != xmlMemBlocks()) {
5389             printf("Leak of %d blocks found in xmlC14NDocDumpMemory",
5390                    xmlMemBlocks() - mem_base);
5391             test_ret++;
5392             printf(" %d", n_doc);
5393             printf(" %d", n_nodes);
5394             printf(" %d", n_mode);
5395             printf(" %d", n_inclusive_ns_prefixes);
5396             printf(" %d", n_with_comments);
5397             printf(" %d", n_doc_txt_ptr);
5398             printf("\n");
5399         }
5400     }
5401     }
5402     }
5403     }
5404     }
5405     }
5406     function_tests++;
5407 #endif
5408
5409     return(test_ret);
5410 }
5411
5412
5413 static int
5414 test_xmlC14NDocSave(void) {
5415     int test_ret = 0;
5416
5417 #if defined(LIBXML_C14N_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
5418     int mem_base;
5419     int ret_val;
5420     xmlDocPtr doc; /* the XML document for canonization */
5421     int n_doc;
5422     xmlNodeSetPtr nodes; /* the nodes set to be included in the canonized image or NULL if all document nodes should be included */
5423     int n_nodes;
5424     int mode; /* the c14n mode (see @xmlC14NMode) */
5425     int n_mode;
5426     xmlChar ** inclusive_ns_prefixes; /* the list of inclusive namespace prefixes ended with a NULL or NULL if there is no inclusive namespaces (only for exclusive canonicalization, ignored otherwise) */
5427     int n_inclusive_ns_prefixes;
5428     int with_comments; /* include comments in the result (!=0) or not (==0) */
5429     int n_with_comments;
5430     const char * filename; /* the filename to store canonical XML image */
5431     int n_filename;
5432     int compression; /* the compression level (zlib requred): -1 - libxml default, 0 - uncompressed, >0 - compression level */
5433     int n_compression;
5434
5435     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
5436     for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
5437     for (n_mode = 0;n_mode < gen_nb_int;n_mode++) {
5438     for (n_inclusive_ns_prefixes = 0;n_inclusive_ns_prefixes < gen_nb_xmlChar_ptr_ptr;n_inclusive_ns_prefixes++) {
5439     for (n_with_comments = 0;n_with_comments < gen_nb_int;n_with_comments++) {
5440     for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
5441     for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
5442         mem_base = xmlMemBlocks();
5443         doc = gen_xmlDocPtr(n_doc, 0);
5444         nodes = gen_xmlNodeSetPtr(n_nodes, 1);
5445         mode = gen_int(n_mode, 2);
5446         inclusive_ns_prefixes = gen_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, 3);
5447         with_comments = gen_int(n_with_comments, 4);
5448         filename = gen_fileoutput(n_filename, 5);
5449         compression = gen_int(n_compression, 6);
5450
5451         ret_val = xmlC14NDocSave(doc, nodes, mode, inclusive_ns_prefixes, with_comments, filename, compression);
5452         desret_int(ret_val);
5453         call_tests++;
5454         des_xmlDocPtr(n_doc, doc, 0);
5455         des_xmlNodeSetPtr(n_nodes, nodes, 1);
5456         des_int(n_mode, mode, 2);
5457         des_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, inclusive_ns_prefixes, 3);
5458         des_int(n_with_comments, with_comments, 4);
5459         des_fileoutput(n_filename, filename, 5);
5460         des_int(n_compression, compression, 6);
5461         xmlResetLastError();
5462         if (mem_base != xmlMemBlocks()) {
5463             printf("Leak of %d blocks found in xmlC14NDocSave",
5464                    xmlMemBlocks() - mem_base);
5465             test_ret++;
5466             printf(" %d", n_doc);
5467             printf(" %d", n_nodes);
5468             printf(" %d", n_mode);
5469             printf(" %d", n_inclusive_ns_prefixes);
5470             printf(" %d", n_with_comments);
5471             printf(" %d", n_filename);
5472             printf(" %d", n_compression);
5473             printf("\n");
5474         }
5475     }
5476     }
5477     }
5478     }
5479     }
5480     }
5481     }
5482     function_tests++;
5483 #endif
5484
5485     return(test_ret);
5486 }
5487
5488
5489 static int
5490 test_xmlC14NDocSaveTo(void) {
5491     int test_ret = 0;
5492
5493 #if defined(LIBXML_C14N_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
5494     int mem_base;
5495     int ret_val;
5496     xmlDocPtr doc; /* the XML document for canonization */
5497     int n_doc;
5498     xmlNodeSetPtr nodes; /* the nodes set to be included in the canonized image or NULL if all document nodes should be included */
5499     int n_nodes;
5500     int mode; /* the c14n mode (see @xmlC14NMode) */
5501     int n_mode;
5502     xmlChar ** inclusive_ns_prefixes; /* the list of inclusive namespace prefixes ended with a NULL or NULL if there is no inclusive namespaces (only for exclusive canonicalization, ignored otherwise) */
5503     int n_inclusive_ns_prefixes;
5504     int with_comments; /* include comments in the result (!=0) or not (==0) */
5505     int n_with_comments;
5506     xmlOutputBufferPtr buf; /* the output buffer to store canonical XML; this buffer MUST have encoder==NULL because C14N requires UTF-8 output */
5507     int n_buf;
5508
5509     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
5510     for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
5511     for (n_mode = 0;n_mode < gen_nb_int;n_mode++) {
5512     for (n_inclusive_ns_prefixes = 0;n_inclusive_ns_prefixes < gen_nb_xmlChar_ptr_ptr;n_inclusive_ns_prefixes++) {
5513     for (n_with_comments = 0;n_with_comments < gen_nb_int;n_with_comments++) {
5514     for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
5515         mem_base = xmlMemBlocks();
5516         doc = gen_xmlDocPtr(n_doc, 0);
5517         nodes = gen_xmlNodeSetPtr(n_nodes, 1);
5518         mode = gen_int(n_mode, 2);
5519         inclusive_ns_prefixes = gen_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, 3);
5520         with_comments = gen_int(n_with_comments, 4);
5521         buf = gen_xmlOutputBufferPtr(n_buf, 5);
5522
5523         ret_val = xmlC14NDocSaveTo(doc, nodes, mode, inclusive_ns_prefixes, with_comments, buf);
5524         desret_int(ret_val);
5525         call_tests++;
5526         des_xmlDocPtr(n_doc, doc, 0);
5527         des_xmlNodeSetPtr(n_nodes, nodes, 1);
5528         des_int(n_mode, mode, 2);
5529         des_xmlChar_ptr_ptr(n_inclusive_ns_prefixes, inclusive_ns_prefixes, 3);
5530         des_int(n_with_comments, with_comments, 4);
5531         des_xmlOutputBufferPtr(n_buf, buf, 5);
5532         xmlResetLastError();
5533         if (mem_base != xmlMemBlocks()) {
5534             printf("Leak of %d blocks found in xmlC14NDocSaveTo",
5535                    xmlMemBlocks() - mem_base);
5536             test_ret++;
5537             printf(" %d", n_doc);
5538             printf(" %d", n_nodes);
5539             printf(" %d", n_mode);
5540             printf(" %d", n_inclusive_ns_prefixes);
5541             printf(" %d", n_with_comments);
5542             printf(" %d", n_buf);
5543             printf("\n");
5544         }
5545     }
5546     }
5547     }
5548     }
5549     }
5550     }
5551     function_tests++;
5552 #endif
5553
5554     return(test_ret);
5555 }
5556
5557
5558 static int
5559 test_xmlC14NExecute(void) {
5560     int test_ret = 0;
5561
5562
5563     /* missing type support */
5564     return(test_ret);
5565 }
5566
5567 static int
5568 test_c14n(void) {
5569     int test_ret = 0;
5570
5571     if (quiet == 0) printf("Testing c14n : 3 of 4 functions ...\n");
5572     test_ret += test_xmlC14NDocDumpMemory();
5573     test_ret += test_xmlC14NDocSave();
5574     test_ret += test_xmlC14NDocSaveTo();
5575     test_ret += test_xmlC14NExecute();
5576
5577     if (test_ret != 0)
5578         printf("Module c14n: %d errors\n", test_ret);
5579     return(test_ret);
5580 }
5581 #ifdef LIBXML_CATALOG_ENABLED
5582
5583 #define gen_nb_xmlCatalogPtr 1
5584 static xmlCatalogPtr gen_xmlCatalogPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
5585     return(NULL);
5586 }
5587 static void des_xmlCatalogPtr(int no ATTRIBUTE_UNUSED, xmlCatalogPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
5588 }
5589 #endif
5590
5591
5592 static int
5593 test_xmlACatalogAdd(void) {
5594     int test_ret = 0;
5595
5596 #if defined(LIBXML_CATALOG_ENABLED)
5597     int mem_base;
5598     int ret_val;
5599     xmlCatalogPtr catal; /* a Catalog */
5600     int n_catal;
5601     xmlChar * type; /* the type of record to add to the catalog */
5602     int n_type;
5603     xmlChar * orig; /* the system, public or prefix to match */
5604     int n_orig;
5605     xmlChar * replace; /* the replacement value for the match */
5606     int n_replace;
5607
5608     for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
5609     for (n_type = 0;n_type < gen_nb_const_xmlChar_ptr;n_type++) {
5610     for (n_orig = 0;n_orig < gen_nb_const_xmlChar_ptr;n_orig++) {
5611     for (n_replace = 0;n_replace < gen_nb_const_xmlChar_ptr;n_replace++) {
5612         mem_base = xmlMemBlocks();
5613         catal = gen_xmlCatalogPtr(n_catal, 0);
5614         type = gen_const_xmlChar_ptr(n_type, 1);
5615         orig = gen_const_xmlChar_ptr(n_orig, 2);
5616         replace = gen_const_xmlChar_ptr(n_replace, 3);
5617
5618         ret_val = xmlACatalogAdd(catal, (const xmlChar *)type, (const xmlChar *)orig, (const xmlChar *)replace);
5619         desret_int(ret_val);
5620         call_tests++;
5621         des_xmlCatalogPtr(n_catal, catal, 0);
5622         des_const_xmlChar_ptr(n_type, (const xmlChar *)type, 1);
5623         des_const_xmlChar_ptr(n_orig, (const xmlChar *)orig, 2);
5624         des_const_xmlChar_ptr(n_replace, (const xmlChar *)replace, 3);
5625         xmlResetLastError();
5626         if (mem_base != xmlMemBlocks()) {
5627             printf("Leak of %d blocks found in xmlACatalogAdd",
5628                    xmlMemBlocks() - mem_base);
5629             test_ret++;
5630             printf(" %d", n_catal);
5631             printf(" %d", n_type);
5632             printf(" %d", n_orig);
5633             printf(" %d", n_replace);
5634             printf("\n");
5635         }
5636     }
5637     }
5638     }
5639     }
5640     function_tests++;
5641 #endif
5642
5643     return(test_ret);
5644 }
5645
5646
5647 static int
5648 test_xmlACatalogDump(void) {
5649     int test_ret = 0;
5650
5651 #if defined(LIBXML_CATALOG_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
5652     int mem_base;
5653     xmlCatalogPtr catal; /* a Catalog */
5654     int n_catal;
5655     FILE * out; /* the file. */
5656     int n_out;
5657
5658     for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
5659     for (n_out = 0;n_out < gen_nb_FILE_ptr;n_out++) {
5660         mem_base = xmlMemBlocks();
5661         catal = gen_xmlCatalogPtr(n_catal, 0);
5662         out = gen_FILE_ptr(n_out, 1);
5663
5664         xmlACatalogDump(catal, out);
5665         call_tests++;
5666         des_xmlCatalogPtr(n_catal, catal, 0);
5667         des_FILE_ptr(n_out, out, 1);
5668         xmlResetLastError();
5669         if (mem_base != xmlMemBlocks()) {
5670             printf("Leak of %d blocks found in xmlACatalogDump",
5671                    xmlMemBlocks() - mem_base);
5672             test_ret++;
5673             printf(" %d", n_catal);
5674             printf(" %d", n_out);
5675             printf("\n");
5676         }
5677     }
5678     }
5679     function_tests++;
5680 #endif
5681
5682     return(test_ret);
5683 }
5684
5685
5686 static int
5687 test_xmlACatalogRemove(void) {
5688     int test_ret = 0;
5689
5690 #if defined(LIBXML_CATALOG_ENABLED)
5691     int mem_base;
5692     int ret_val;
5693     xmlCatalogPtr catal; /* a Catalog */
5694     int n_catal;
5695     xmlChar * value; /* the value to remove */
5696     int n_value;
5697
5698     for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
5699     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
5700         mem_base = xmlMemBlocks();
5701         catal = gen_xmlCatalogPtr(n_catal, 0);
5702         value = gen_const_xmlChar_ptr(n_value, 1);
5703
5704         ret_val = xmlACatalogRemove(catal, (const xmlChar *)value);
5705         desret_int(ret_val);
5706         call_tests++;
5707         des_xmlCatalogPtr(n_catal, catal, 0);
5708         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
5709         xmlResetLastError();
5710         if (mem_base != xmlMemBlocks()) {
5711             printf("Leak of %d blocks found in xmlACatalogRemove",
5712                    xmlMemBlocks() - mem_base);
5713             test_ret++;
5714             printf(" %d", n_catal);
5715             printf(" %d", n_value);
5716             printf("\n");
5717         }
5718     }
5719     }
5720     function_tests++;
5721 #endif
5722
5723     return(test_ret);
5724 }
5725
5726
5727 static int
5728 test_xmlACatalogResolve(void) {
5729     int test_ret = 0;
5730
5731 #if defined(LIBXML_CATALOG_ENABLED)
5732     int mem_base;
5733     xmlChar * ret_val;
5734     xmlCatalogPtr catal; /* a Catalog */
5735     int n_catal;
5736     xmlChar * pubID; /* the public ID string */
5737     int n_pubID;
5738     xmlChar * sysID; /* the system ID string */
5739     int n_sysID;
5740
5741     for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
5742     for (n_pubID = 0;n_pubID < gen_nb_const_xmlChar_ptr;n_pubID++) {
5743     for (n_sysID = 0;n_sysID < gen_nb_const_xmlChar_ptr;n_sysID++) {
5744         mem_base = xmlMemBlocks();
5745         catal = gen_xmlCatalogPtr(n_catal, 0);
5746         pubID = gen_const_xmlChar_ptr(n_pubID, 1);
5747         sysID = gen_const_xmlChar_ptr(n_sysID, 2);
5748
5749         ret_val = xmlACatalogResolve(catal, (const xmlChar *)pubID, (const xmlChar *)sysID);
5750         desret_xmlChar_ptr(ret_val);
5751         call_tests++;
5752         des_xmlCatalogPtr(n_catal, catal, 0);
5753         des_const_xmlChar_ptr(n_pubID, (const xmlChar *)pubID, 1);
5754         des_const_xmlChar_ptr(n_sysID, (const xmlChar *)sysID, 2);
5755         xmlResetLastError();
5756         if (mem_base != xmlMemBlocks()) {
5757             printf("Leak of %d blocks found in xmlACatalogResolve",
5758                    xmlMemBlocks() - mem_base);
5759             test_ret++;
5760             printf(" %d", n_catal);
5761             printf(" %d", n_pubID);
5762             printf(" %d", n_sysID);
5763             printf("\n");
5764         }
5765     }
5766     }
5767     }
5768     function_tests++;
5769 #endif
5770
5771     return(test_ret);
5772 }
5773
5774
5775 static int
5776 test_xmlACatalogResolvePublic(void) {
5777     int test_ret = 0;
5778
5779 #if defined(LIBXML_CATALOG_ENABLED)
5780     int mem_base;
5781     xmlChar * ret_val;
5782     xmlCatalogPtr catal; /* a Catalog */
5783     int n_catal;
5784     xmlChar * pubID; /* the public ID string */
5785     int n_pubID;
5786
5787     for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
5788     for (n_pubID = 0;n_pubID < gen_nb_const_xmlChar_ptr;n_pubID++) {
5789         mem_base = xmlMemBlocks();
5790         catal = gen_xmlCatalogPtr(n_catal, 0);
5791         pubID = gen_const_xmlChar_ptr(n_pubID, 1);
5792
5793         ret_val = xmlACatalogResolvePublic(catal, (const xmlChar *)pubID);
5794         desret_xmlChar_ptr(ret_val);
5795         call_tests++;
5796         des_xmlCatalogPtr(n_catal, catal, 0);
5797         des_const_xmlChar_ptr(n_pubID, (const xmlChar *)pubID, 1);
5798         xmlResetLastError();
5799         if (mem_base != xmlMemBlocks()) {
5800             printf("Leak of %d blocks found in xmlACatalogResolvePublic",
5801                    xmlMemBlocks() - mem_base);
5802             test_ret++;
5803             printf(" %d", n_catal);
5804             printf(" %d", n_pubID);
5805             printf("\n");
5806         }
5807     }
5808     }
5809     function_tests++;
5810 #endif
5811
5812     return(test_ret);
5813 }
5814
5815
5816 static int
5817 test_xmlACatalogResolveSystem(void) {
5818     int test_ret = 0;
5819
5820 #if defined(LIBXML_CATALOG_ENABLED)
5821     int mem_base;
5822     xmlChar * ret_val;
5823     xmlCatalogPtr catal; /* a Catalog */
5824     int n_catal;
5825     xmlChar * sysID; /* the system ID string */
5826     int n_sysID;
5827
5828     for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
5829     for (n_sysID = 0;n_sysID < gen_nb_const_xmlChar_ptr;n_sysID++) {
5830         mem_base = xmlMemBlocks();
5831         catal = gen_xmlCatalogPtr(n_catal, 0);
5832         sysID = gen_const_xmlChar_ptr(n_sysID, 1);
5833
5834         ret_val = xmlACatalogResolveSystem(catal, (const xmlChar *)sysID);
5835         desret_xmlChar_ptr(ret_val);
5836         call_tests++;
5837         des_xmlCatalogPtr(n_catal, catal, 0);
5838         des_const_xmlChar_ptr(n_sysID, (const xmlChar *)sysID, 1);
5839         xmlResetLastError();
5840         if (mem_base != xmlMemBlocks()) {
5841             printf("Leak of %d blocks found in xmlACatalogResolveSystem",
5842                    xmlMemBlocks() - mem_base);
5843             test_ret++;
5844             printf(" %d", n_catal);
5845             printf(" %d", n_sysID);
5846             printf("\n");
5847         }
5848     }
5849     }
5850     function_tests++;
5851 #endif
5852
5853     return(test_ret);
5854 }
5855
5856
5857 static int
5858 test_xmlACatalogResolveURI(void) {
5859     int test_ret = 0;
5860
5861 #if defined(LIBXML_CATALOG_ENABLED)
5862     int mem_base;
5863     xmlChar * ret_val;
5864     xmlCatalogPtr catal; /* a Catalog */
5865     int n_catal;
5866     xmlChar * URI; /* the URI */
5867     int n_URI;
5868
5869     for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
5870     for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
5871         mem_base = xmlMemBlocks();
5872         catal = gen_xmlCatalogPtr(n_catal, 0);
5873         URI = gen_const_xmlChar_ptr(n_URI, 1);
5874
5875         ret_val = xmlACatalogResolveURI(catal, (const xmlChar *)URI);
5876         desret_xmlChar_ptr(ret_val);
5877         call_tests++;
5878         des_xmlCatalogPtr(n_catal, catal, 0);
5879         des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 1);
5880         xmlResetLastError();
5881         if (mem_base != xmlMemBlocks()) {
5882             printf("Leak of %d blocks found in xmlACatalogResolveURI",
5883                    xmlMemBlocks() - mem_base);
5884             test_ret++;
5885             printf(" %d", n_catal);
5886             printf(" %d", n_URI);
5887             printf("\n");
5888         }
5889     }
5890     }
5891     function_tests++;
5892 #endif
5893
5894     return(test_ret);
5895 }
5896
5897
5898 static int
5899 test_xmlCatalogAdd(void) {
5900     int test_ret = 0;
5901
5902 #if defined(LIBXML_CATALOG_ENABLED)
5903     int mem_base;
5904     int ret_val;
5905     xmlChar * type; /* the type of record to add to the catalog */
5906     int n_type;
5907     xmlChar * orig; /* the system, public or prefix to match */
5908     int n_orig;
5909     xmlChar * replace; /* the replacement value for the match */
5910     int n_replace;
5911
5912     for (n_type = 0;n_type < gen_nb_const_xmlChar_ptr;n_type++) {
5913     for (n_orig = 0;n_orig < gen_nb_const_xmlChar_ptr;n_orig++) {
5914     for (n_replace = 0;n_replace < gen_nb_const_xmlChar_ptr;n_replace++) {
5915         mem_base = xmlMemBlocks();
5916         type = gen_const_xmlChar_ptr(n_type, 0);
5917         orig = gen_const_xmlChar_ptr(n_orig, 1);
5918         replace = gen_const_xmlChar_ptr(n_replace, 2);
5919
5920         ret_val = xmlCatalogAdd((const xmlChar *)type, (const xmlChar *)orig, (const xmlChar *)replace);
5921         desret_int(ret_val);
5922         call_tests++;
5923         des_const_xmlChar_ptr(n_type, (const xmlChar *)type, 0);
5924         des_const_xmlChar_ptr(n_orig, (const xmlChar *)orig, 1);
5925         des_const_xmlChar_ptr(n_replace, (const xmlChar *)replace, 2);
5926         xmlResetLastError();
5927         if (mem_base != xmlMemBlocks()) {
5928             printf("Leak of %d blocks found in xmlCatalogAdd",
5929                    xmlMemBlocks() - mem_base);
5930             test_ret++;
5931             printf(" %d", n_type);
5932             printf(" %d", n_orig);
5933             printf(" %d", n_replace);
5934             printf("\n");
5935         }
5936     }
5937     }
5938     }
5939     function_tests++;
5940 #endif
5941
5942     return(test_ret);
5943 }
5944
5945
5946 static int
5947 test_xmlCatalogCleanup(void) {
5948     int test_ret = 0;
5949
5950 #if defined(LIBXML_CATALOG_ENABLED)
5951
5952
5953         xmlCatalogCleanup();
5954         call_tests++;
5955         xmlResetLastError();
5956     function_tests++;
5957 #endif
5958
5959     return(test_ret);
5960 }
5961
5962
5963 static int
5964 test_xmlCatalogConvert(void) {
5965     int test_ret = 0;
5966
5967 #if defined(LIBXML_CATALOG_ENABLED)
5968     int ret_val;
5969
5970
5971         ret_val = xmlCatalogConvert();
5972         desret_int(ret_val);
5973         call_tests++;
5974         xmlResetLastError();
5975     function_tests++;
5976 #endif
5977
5978     return(test_ret);
5979 }
5980
5981
5982 static int
5983 test_xmlCatalogDump(void) {
5984     int test_ret = 0;
5985
5986 #if defined(LIBXML_CATALOG_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
5987     int mem_base;
5988     FILE * out; /* the file. */
5989     int n_out;
5990
5991     for (n_out = 0;n_out < gen_nb_FILE_ptr;n_out++) {
5992         mem_base = xmlMemBlocks();
5993         out = gen_FILE_ptr(n_out, 0);
5994
5995         xmlCatalogDump(out);
5996         call_tests++;
5997         des_FILE_ptr(n_out, out, 0);
5998         xmlResetLastError();
5999         if (mem_base != xmlMemBlocks()) {
6000             printf("Leak of %d blocks found in xmlCatalogDump",
6001                    xmlMemBlocks() - mem_base);
6002             test_ret++;
6003             printf(" %d", n_out);
6004             printf("\n");
6005         }
6006     }
6007     function_tests++;
6008 #endif
6009
6010     return(test_ret);
6011 }
6012
6013
6014 static int
6015 test_xmlCatalogGetDefaults(void) {
6016     int test_ret = 0;
6017
6018 #if defined(LIBXML_CATALOG_ENABLED)
6019     int mem_base;
6020     xmlCatalogAllow ret_val;
6021
6022         mem_base = xmlMemBlocks();
6023
6024         ret_val = xmlCatalogGetDefaults();
6025         desret_xmlCatalogAllow(ret_val);
6026         call_tests++;
6027         xmlResetLastError();
6028         if (mem_base != xmlMemBlocks()) {
6029             printf("Leak of %d blocks found in xmlCatalogGetDefaults",
6030                    xmlMemBlocks() - mem_base);
6031             test_ret++;
6032             printf("\n");
6033         }
6034     function_tests++;
6035 #endif
6036
6037     return(test_ret);
6038 }
6039
6040
6041 static int
6042 test_xmlCatalogIsEmpty(void) {
6043     int test_ret = 0;
6044
6045 #if defined(LIBXML_CATALOG_ENABLED)
6046     int mem_base;
6047     int ret_val;
6048     xmlCatalogPtr catal; /* should this create an SGML catalog */
6049     int n_catal;
6050
6051     for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
6052         mem_base = xmlMemBlocks();
6053         catal = gen_xmlCatalogPtr(n_catal, 0);
6054
6055         ret_val = xmlCatalogIsEmpty(catal);
6056         desret_int(ret_val);
6057         call_tests++;
6058         des_xmlCatalogPtr(n_catal, catal, 0);
6059         xmlResetLastError();
6060         if (mem_base != xmlMemBlocks()) {
6061             printf("Leak of %d blocks found in xmlCatalogIsEmpty",
6062                    xmlMemBlocks() - mem_base);
6063             test_ret++;
6064             printf(" %d", n_catal);
6065             printf("\n");
6066         }
6067     }
6068     function_tests++;
6069 #endif
6070
6071     return(test_ret);
6072 }
6073
6074
6075 static int
6076 test_xmlCatalogLocalResolve(void) {
6077     int test_ret = 0;
6078
6079 #if defined(LIBXML_CATALOG_ENABLED)
6080     int mem_base;
6081     xmlChar * ret_val;
6082     void * catalogs; /* a document's list of catalogs */
6083     int n_catalogs;
6084     xmlChar * pubID; /* the public ID string */
6085     int n_pubID;
6086     xmlChar * sysID; /* the system ID string */
6087     int n_sysID;
6088
6089     for (n_catalogs = 0;n_catalogs < gen_nb_void_ptr;n_catalogs++) {
6090     for (n_pubID = 0;n_pubID < gen_nb_const_xmlChar_ptr;n_pubID++) {
6091     for (n_sysID = 0;n_sysID < gen_nb_const_xmlChar_ptr;n_sysID++) {
6092         mem_base = xmlMemBlocks();
6093         catalogs = gen_void_ptr(n_catalogs, 0);
6094         pubID = gen_const_xmlChar_ptr(n_pubID, 1);
6095         sysID = gen_const_xmlChar_ptr(n_sysID, 2);
6096
6097         ret_val = xmlCatalogLocalResolve(catalogs, (const xmlChar *)pubID, (const xmlChar *)sysID);
6098         desret_xmlChar_ptr(ret_val);
6099         call_tests++;
6100         des_void_ptr(n_catalogs, catalogs, 0);
6101         des_const_xmlChar_ptr(n_pubID, (const xmlChar *)pubID, 1);
6102         des_const_xmlChar_ptr(n_sysID, (const xmlChar *)sysID, 2);
6103         xmlResetLastError();
6104         if (mem_base != xmlMemBlocks()) {
6105             printf("Leak of %d blocks found in xmlCatalogLocalResolve",
6106                    xmlMemBlocks() - mem_base);
6107             test_ret++;
6108             printf(" %d", n_catalogs);
6109             printf(" %d", n_pubID);
6110             printf(" %d", n_sysID);
6111             printf("\n");
6112         }
6113     }
6114     }
6115     }
6116     function_tests++;
6117 #endif
6118
6119     return(test_ret);
6120 }
6121
6122
6123 static int
6124 test_xmlCatalogLocalResolveURI(void) {
6125     int test_ret = 0;
6126
6127 #if defined(LIBXML_CATALOG_ENABLED)
6128     int mem_base;
6129     xmlChar * ret_val;
6130     void * catalogs; /* a document's list of catalogs */
6131     int n_catalogs;
6132     xmlChar * URI; /* the URI */
6133     int n_URI;
6134
6135     for (n_catalogs = 0;n_catalogs < gen_nb_void_ptr;n_catalogs++) {
6136     for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
6137         mem_base = xmlMemBlocks();
6138         catalogs = gen_void_ptr(n_catalogs, 0);
6139         URI = gen_const_xmlChar_ptr(n_URI, 1);
6140
6141         ret_val = xmlCatalogLocalResolveURI(catalogs, (const xmlChar *)URI);
6142         desret_xmlChar_ptr(ret_val);
6143         call_tests++;
6144         des_void_ptr(n_catalogs, catalogs, 0);
6145         des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 1);
6146         xmlResetLastError();
6147         if (mem_base != xmlMemBlocks()) {
6148             printf("Leak of %d blocks found in xmlCatalogLocalResolveURI",
6149                    xmlMemBlocks() - mem_base);
6150             test_ret++;
6151             printf(" %d", n_catalogs);
6152             printf(" %d", n_URI);
6153             printf("\n");
6154         }
6155     }
6156     }
6157     function_tests++;
6158 #endif
6159
6160     return(test_ret);
6161 }
6162
6163
6164 static int
6165 test_xmlCatalogRemove(void) {
6166     int test_ret = 0;
6167
6168 #if defined(LIBXML_CATALOG_ENABLED)
6169     int ret_val;
6170     xmlChar * value; /* the value to remove */
6171     int n_value;
6172
6173     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
6174         value = gen_const_xmlChar_ptr(n_value, 0);
6175
6176         ret_val = xmlCatalogRemove((const xmlChar *)value);
6177         desret_int(ret_val);
6178         call_tests++;
6179         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
6180         xmlResetLastError();
6181     }
6182     function_tests++;
6183 #endif
6184
6185     return(test_ret);
6186 }
6187
6188
6189 static int
6190 test_xmlCatalogResolve(void) {
6191     int test_ret = 0;
6192
6193 #if defined(LIBXML_CATALOG_ENABLED)
6194     xmlChar * ret_val;
6195     xmlChar * pubID; /* the public ID string */
6196     int n_pubID;
6197     xmlChar * sysID; /* the system ID string */
6198     int n_sysID;
6199
6200     for (n_pubID = 0;n_pubID < gen_nb_const_xmlChar_ptr;n_pubID++) {
6201     for (n_sysID = 0;n_sysID < gen_nb_const_xmlChar_ptr;n_sysID++) {
6202         pubID = gen_const_xmlChar_ptr(n_pubID, 0);
6203         sysID = gen_const_xmlChar_ptr(n_sysID, 1);
6204
6205         ret_val = xmlCatalogResolve((const xmlChar *)pubID, (const xmlChar *)sysID);
6206         desret_xmlChar_ptr(ret_val);
6207         call_tests++;
6208         des_const_xmlChar_ptr(n_pubID, (const xmlChar *)pubID, 0);
6209         des_const_xmlChar_ptr(n_sysID, (const xmlChar *)sysID, 1);
6210         xmlResetLastError();
6211     }
6212     }
6213     function_tests++;
6214 #endif
6215
6216     return(test_ret);
6217 }
6218
6219
6220 static int
6221 test_xmlCatalogResolvePublic(void) {
6222     int test_ret = 0;
6223
6224 #if defined(LIBXML_CATALOG_ENABLED)
6225     int mem_base;
6226     xmlChar * ret_val;
6227     xmlChar * pubID; /* the public ID string */
6228     int n_pubID;
6229
6230     for (n_pubID = 0;n_pubID < gen_nb_const_xmlChar_ptr;n_pubID++) {
6231         mem_base = xmlMemBlocks();
6232         pubID = gen_const_xmlChar_ptr(n_pubID, 0);
6233
6234         ret_val = xmlCatalogResolvePublic((const xmlChar *)pubID);
6235         desret_xmlChar_ptr(ret_val);
6236         call_tests++;
6237         des_const_xmlChar_ptr(n_pubID, (const xmlChar *)pubID, 0);
6238         xmlResetLastError();
6239         if (mem_base != xmlMemBlocks()) {
6240             printf("Leak of %d blocks found in xmlCatalogResolvePublic",
6241                    xmlMemBlocks() - mem_base);
6242             test_ret++;
6243             printf(" %d", n_pubID);
6244             printf("\n");
6245         }
6246     }
6247     function_tests++;
6248 #endif
6249
6250     return(test_ret);
6251 }
6252
6253
6254 static int
6255 test_xmlCatalogResolveSystem(void) {
6256     int test_ret = 0;
6257
6258 #if defined(LIBXML_CATALOG_ENABLED)
6259     int mem_base;
6260     xmlChar * ret_val;
6261     xmlChar * sysID; /* the system ID string */
6262     int n_sysID;
6263
6264     for (n_sysID = 0;n_sysID < gen_nb_const_xmlChar_ptr;n_sysID++) {
6265         mem_base = xmlMemBlocks();
6266         sysID = gen_const_xmlChar_ptr(n_sysID, 0);
6267
6268         ret_val = xmlCatalogResolveSystem((const xmlChar *)sysID);
6269         desret_xmlChar_ptr(ret_val);
6270         call_tests++;
6271         des_const_xmlChar_ptr(n_sysID, (const xmlChar *)sysID, 0);
6272         xmlResetLastError();
6273         if (mem_base != xmlMemBlocks()) {
6274             printf("Leak of %d blocks found in xmlCatalogResolveSystem",
6275                    xmlMemBlocks() - mem_base);
6276             test_ret++;
6277             printf(" %d", n_sysID);
6278             printf("\n");
6279         }
6280     }
6281     function_tests++;
6282 #endif
6283
6284     return(test_ret);
6285 }
6286
6287
6288 static int
6289 test_xmlCatalogResolveURI(void) {
6290     int test_ret = 0;
6291
6292 #if defined(LIBXML_CATALOG_ENABLED)
6293     int mem_base;
6294     xmlChar * ret_val;
6295     xmlChar * URI; /* the URI */
6296     int n_URI;
6297
6298     for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
6299         mem_base = xmlMemBlocks();
6300         URI = gen_const_xmlChar_ptr(n_URI, 0);
6301
6302         ret_val = xmlCatalogResolveURI((const xmlChar *)URI);
6303         desret_xmlChar_ptr(ret_val);
6304         call_tests++;
6305         des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 0);
6306         xmlResetLastError();
6307         if (mem_base != xmlMemBlocks()) {
6308             printf("Leak of %d blocks found in xmlCatalogResolveURI",
6309                    xmlMemBlocks() - mem_base);
6310             test_ret++;
6311             printf(" %d", n_URI);
6312             printf("\n");
6313         }
6314     }
6315     function_tests++;
6316 #endif
6317
6318     return(test_ret);
6319 }
6320
6321
6322 static int
6323 test_xmlCatalogSetDefaultPrefer(void) {
6324     int test_ret = 0;
6325
6326 #if defined(LIBXML_CATALOG_ENABLED)
6327     int mem_base;
6328     xmlCatalogPrefer ret_val;
6329     xmlCatalogPrefer prefer; /* the default preference for delegation */
6330     int n_prefer;
6331
6332     for (n_prefer = 0;n_prefer < gen_nb_xmlCatalogPrefer;n_prefer++) {
6333         mem_base = xmlMemBlocks();
6334         prefer = gen_xmlCatalogPrefer(n_prefer, 0);
6335
6336         ret_val = xmlCatalogSetDefaultPrefer(prefer);
6337         desret_xmlCatalogPrefer(ret_val);
6338         call_tests++;
6339         des_xmlCatalogPrefer(n_prefer, prefer, 0);
6340         xmlResetLastError();
6341         if (mem_base != xmlMemBlocks()) {
6342             printf("Leak of %d blocks found in xmlCatalogSetDefaultPrefer",
6343                    xmlMemBlocks() - mem_base);
6344             test_ret++;
6345             printf(" %d", n_prefer);
6346             printf("\n");
6347         }
6348     }
6349     function_tests++;
6350 #endif
6351
6352     return(test_ret);
6353 }
6354
6355
6356 static int
6357 test_xmlCatalogSetDefaults(void) {
6358     int test_ret = 0;
6359
6360 #if defined(LIBXML_CATALOG_ENABLED)
6361     int mem_base;
6362     xmlCatalogAllow allow; /* what catalogs should be accepted */
6363     int n_allow;
6364
6365     for (n_allow = 0;n_allow < gen_nb_xmlCatalogAllow;n_allow++) {
6366         mem_base = xmlMemBlocks();
6367         allow = gen_xmlCatalogAllow(n_allow, 0);
6368
6369         xmlCatalogSetDefaults(allow);
6370         call_tests++;
6371         des_xmlCatalogAllow(n_allow, allow, 0);
6372         xmlResetLastError();
6373         if (mem_base != xmlMemBlocks()) {
6374             printf("Leak of %d blocks found in xmlCatalogSetDefaults",
6375                    xmlMemBlocks() - mem_base);
6376             test_ret++;
6377             printf(" %d", n_allow);
6378             printf("\n");
6379         }
6380     }
6381     function_tests++;
6382 #endif
6383
6384     return(test_ret);
6385 }
6386
6387
6388 static int
6389 test_xmlConvertSGMLCatalog(void) {
6390     int test_ret = 0;
6391
6392 #if defined(LIBXML_CATALOG_ENABLED)
6393     int mem_base;
6394     int ret_val;
6395     xmlCatalogPtr catal; /* the catalog */
6396     int n_catal;
6397
6398     for (n_catal = 0;n_catal < gen_nb_xmlCatalogPtr;n_catal++) {
6399         mem_base = xmlMemBlocks();
6400         catal = gen_xmlCatalogPtr(n_catal, 0);
6401
6402         ret_val = xmlConvertSGMLCatalog(catal);
6403         desret_int(ret_val);
6404         call_tests++;
6405         des_xmlCatalogPtr(n_catal, catal, 0);
6406         xmlResetLastError();
6407         if (mem_base != xmlMemBlocks()) {
6408             printf("Leak of %d blocks found in xmlConvertSGMLCatalog",
6409                    xmlMemBlocks() - mem_base);
6410             test_ret++;
6411             printf(" %d", n_catal);
6412             printf("\n");
6413         }
6414     }
6415     function_tests++;
6416 #endif
6417
6418     return(test_ret);
6419 }
6420
6421
6422 static int
6423 test_xmlInitializeCatalog(void) {
6424     int test_ret = 0;
6425
6426 #if defined(LIBXML_CATALOG_ENABLED)
6427     int mem_base;
6428
6429         mem_base = xmlMemBlocks();
6430
6431         xmlInitializeCatalog();
6432         call_tests++;
6433         xmlResetLastError();
6434         if (mem_base != xmlMemBlocks()) {
6435             printf("Leak of %d blocks found in xmlInitializeCatalog",
6436                    xmlMemBlocks() - mem_base);
6437             test_ret++;
6438             printf("\n");
6439         }
6440     function_tests++;
6441 #endif
6442
6443     return(test_ret);
6444 }
6445
6446
6447 static int
6448 test_xmlLoadACatalog(void) {
6449     int test_ret = 0;
6450
6451
6452     /* missing type support */
6453     return(test_ret);
6454 }
6455
6456
6457 static int
6458 test_xmlLoadCatalog(void) {
6459     int test_ret = 0;
6460
6461 #if defined(LIBXML_CATALOG_ENABLED)
6462     int ret_val;
6463     const char * filename; /* a file path */
6464     int n_filename;
6465
6466     for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
6467         filename = gen_filepath(n_filename, 0);
6468
6469         ret_val = xmlLoadCatalog(filename);
6470         desret_int(ret_val);
6471         call_tests++;
6472         des_filepath(n_filename, filename, 0);
6473         xmlResetLastError();
6474     }
6475     function_tests++;
6476 #endif
6477
6478     return(test_ret);
6479 }
6480
6481
6482 static int
6483 test_xmlLoadCatalogs(void) {
6484     int test_ret = 0;
6485
6486 #if defined(LIBXML_CATALOG_ENABLED)
6487     char * pathss; /* a list of directories separated by a colon or a space. */
6488     int n_pathss;
6489
6490     for (n_pathss = 0;n_pathss < gen_nb_const_char_ptr;n_pathss++) {
6491         pathss = gen_const_char_ptr(n_pathss, 0);
6492
6493         xmlLoadCatalogs((const char *)pathss);
6494         call_tests++;
6495         des_const_char_ptr(n_pathss, (const char *)pathss, 0);
6496         xmlResetLastError();
6497     }
6498     function_tests++;
6499 #endif
6500
6501     return(test_ret);
6502 }
6503
6504
6505 static int
6506 test_xmlLoadSGMLSuperCatalog(void) {
6507     int test_ret = 0;
6508
6509
6510     /* missing type support */
6511     return(test_ret);
6512 }
6513
6514
6515 static int
6516 test_xmlNewCatalog(void) {
6517     int test_ret = 0;
6518
6519
6520     /* missing type support */
6521     return(test_ret);
6522 }
6523
6524
6525 static int
6526 test_xmlParseCatalogFile(void) {
6527     int test_ret = 0;
6528
6529 #if defined(LIBXML_CATALOG_ENABLED)
6530     int mem_base;
6531     xmlDocPtr ret_val;
6532     const char * filename; /* the filename */
6533     int n_filename;
6534
6535     for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
6536         mem_base = xmlMemBlocks();
6537         filename = gen_filepath(n_filename, 0);
6538
6539         ret_val = xmlParseCatalogFile(filename);
6540         desret_xmlDocPtr(ret_val);
6541         call_tests++;
6542         des_filepath(n_filename, filename, 0);
6543         xmlResetLastError();
6544         if (mem_base != xmlMemBlocks()) {
6545             printf("Leak of %d blocks found in xmlParseCatalogFile",
6546                    xmlMemBlocks() - mem_base);
6547             test_ret++;
6548             printf(" %d", n_filename);
6549             printf("\n");
6550         }
6551     }
6552     function_tests++;
6553 #endif
6554
6555     return(test_ret);
6556 }
6557
6558 static int
6559 test_catalog(void) {
6560     int test_ret = 0;
6561
6562     if (quiet == 0) printf("Testing catalog : 27 of 36 functions ...\n");
6563     test_ret += test_xmlACatalogAdd();
6564     test_ret += test_xmlACatalogDump();
6565     test_ret += test_xmlACatalogRemove();
6566     test_ret += test_xmlACatalogResolve();
6567     test_ret += test_xmlACatalogResolvePublic();
6568     test_ret += test_xmlACatalogResolveSystem();
6569     test_ret += test_xmlACatalogResolveURI();
6570     test_ret += test_xmlCatalogAdd();
6571     test_ret += test_xmlCatalogCleanup();
6572     test_ret += test_xmlCatalogConvert();
6573     test_ret += test_xmlCatalogDump();
6574     test_ret += test_xmlCatalogGetDefaults();
6575     test_ret += test_xmlCatalogIsEmpty();
6576     test_ret += test_xmlCatalogLocalResolve();
6577     test_ret += test_xmlCatalogLocalResolveURI();
6578     test_ret += test_xmlCatalogRemove();
6579     test_ret += test_xmlCatalogResolve();
6580     test_ret += test_xmlCatalogResolvePublic();
6581     test_ret += test_xmlCatalogResolveSystem();
6582     test_ret += test_xmlCatalogResolveURI();
6583     test_ret += test_xmlCatalogSetDefaultPrefer();
6584     test_ret += test_xmlCatalogSetDefaults();
6585     test_ret += test_xmlConvertSGMLCatalog();
6586     test_ret += test_xmlInitializeCatalog();
6587     test_ret += test_xmlLoadACatalog();
6588     test_ret += test_xmlLoadCatalog();
6589     test_ret += test_xmlLoadCatalogs();
6590     test_ret += test_xmlLoadSGMLSuperCatalog();
6591     test_ret += test_xmlNewCatalog();
6592     test_ret += test_xmlParseCatalogFile();
6593
6594     if (test_ret != 0)
6595         printf("Module catalog: %d errors\n", test_ret);
6596     return(test_ret);
6597 }
6598
6599 #define gen_nb_const_xmlChRangeGroup_ptr 1
6600 static xmlChRangeGroup * gen_const_xmlChRangeGroup_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
6601     return(NULL);
6602 }
6603 static void des_const_xmlChRangeGroup_ptr(int no ATTRIBUTE_UNUSED, const xmlChRangeGroup * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
6604 }
6605
6606 static int
6607 test_xmlCharInRange(void) {
6608     int test_ret = 0;
6609
6610     int mem_base;
6611     int ret_val;
6612     unsigned int val; /* character to be validated */
6613     int n_val;
6614     xmlChRangeGroup * rptr; /* pointer to range to be used to validate */
6615     int n_rptr;
6616
6617     for (n_val = 0;n_val < gen_nb_unsigned_int;n_val++) {
6618     for (n_rptr = 0;n_rptr < gen_nb_const_xmlChRangeGroup_ptr;n_rptr++) {
6619         mem_base = xmlMemBlocks();
6620         val = gen_unsigned_int(n_val, 0);
6621         rptr = gen_const_xmlChRangeGroup_ptr(n_rptr, 1);
6622
6623         ret_val = xmlCharInRange(val, (const xmlChRangeGroup *)rptr);
6624         desret_int(ret_val);
6625         call_tests++;
6626         des_unsigned_int(n_val, val, 0);
6627         des_const_xmlChRangeGroup_ptr(n_rptr, (const xmlChRangeGroup *)rptr, 1);
6628         xmlResetLastError();
6629         if (mem_base != xmlMemBlocks()) {
6630             printf("Leak of %d blocks found in xmlCharInRange",
6631                    xmlMemBlocks() - mem_base);
6632             test_ret++;
6633             printf(" %d", n_val);
6634             printf(" %d", n_rptr);
6635             printf("\n");
6636         }
6637     }
6638     }
6639     function_tests++;
6640
6641     return(test_ret);
6642 }
6643
6644
6645 static int
6646 test_xmlIsBaseChar(void) {
6647     int test_ret = 0;
6648
6649     int mem_base;
6650     int ret_val;
6651     unsigned int ch; /* character to validate */
6652     int n_ch;
6653
6654     for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
6655         mem_base = xmlMemBlocks();
6656         ch = gen_unsigned_int(n_ch, 0);
6657
6658         ret_val = xmlIsBaseChar(ch);
6659         desret_int(ret_val);
6660         call_tests++;
6661         des_unsigned_int(n_ch, ch, 0);
6662         xmlResetLastError();
6663         if (mem_base != xmlMemBlocks()) {
6664             printf("Leak of %d blocks found in xmlIsBaseChar",
6665                    xmlMemBlocks() - mem_base);
6666             test_ret++;
6667             printf(" %d", n_ch);
6668             printf("\n");
6669         }
6670     }
6671     function_tests++;
6672
6673     return(test_ret);
6674 }
6675
6676
6677 static int
6678 test_xmlIsBlank(void) {
6679     int test_ret = 0;
6680
6681     int mem_base;
6682     int ret_val;
6683     unsigned int ch; /* character to validate */
6684     int n_ch;
6685
6686     for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
6687         mem_base = xmlMemBlocks();
6688         ch = gen_unsigned_int(n_ch, 0);
6689
6690         ret_val = xmlIsBlank(ch);
6691         desret_int(ret_val);
6692         call_tests++;
6693         des_unsigned_int(n_ch, ch, 0);
6694         xmlResetLastError();
6695         if (mem_base != xmlMemBlocks()) {
6696             printf("Leak of %d blocks found in xmlIsBlank",
6697                    xmlMemBlocks() - mem_base);
6698             test_ret++;
6699             printf(" %d", n_ch);
6700             printf("\n");
6701         }
6702     }
6703     function_tests++;
6704
6705     return(test_ret);
6706 }
6707
6708
6709 static int
6710 test_xmlIsChar(void) {
6711     int test_ret = 0;
6712
6713     int mem_base;
6714     int ret_val;
6715     unsigned int ch; /* character to validate */
6716     int n_ch;
6717
6718     for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
6719         mem_base = xmlMemBlocks();
6720         ch = gen_unsigned_int(n_ch, 0);
6721
6722         ret_val = xmlIsChar(ch);
6723         desret_int(ret_val);
6724         call_tests++;
6725         des_unsigned_int(n_ch, ch, 0);
6726         xmlResetLastError();
6727         if (mem_base != xmlMemBlocks()) {
6728             printf("Leak of %d blocks found in xmlIsChar",
6729                    xmlMemBlocks() - mem_base);
6730             test_ret++;
6731             printf(" %d", n_ch);
6732             printf("\n");
6733         }
6734     }
6735     function_tests++;
6736
6737     return(test_ret);
6738 }
6739
6740
6741 static int
6742 test_xmlIsCombining(void) {
6743     int test_ret = 0;
6744
6745     int mem_base;
6746     int ret_val;
6747     unsigned int ch; /* character to validate */
6748     int n_ch;
6749
6750     for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
6751         mem_base = xmlMemBlocks();
6752         ch = gen_unsigned_int(n_ch, 0);
6753
6754         ret_val = xmlIsCombining(ch);
6755         desret_int(ret_val);
6756         call_tests++;
6757         des_unsigned_int(n_ch, ch, 0);
6758         xmlResetLastError();
6759         if (mem_base != xmlMemBlocks()) {
6760             printf("Leak of %d blocks found in xmlIsCombining",
6761                    xmlMemBlocks() - mem_base);
6762             test_ret++;
6763             printf(" %d", n_ch);
6764             printf("\n");
6765         }
6766     }
6767     function_tests++;
6768
6769     return(test_ret);
6770 }
6771
6772
6773 static int
6774 test_xmlIsDigit(void) {
6775     int test_ret = 0;
6776
6777     int mem_base;
6778     int ret_val;
6779     unsigned int ch; /* character to validate */
6780     int n_ch;
6781
6782     for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
6783         mem_base = xmlMemBlocks();
6784         ch = gen_unsigned_int(n_ch, 0);
6785
6786         ret_val = xmlIsDigit(ch);
6787         desret_int(ret_val);
6788         call_tests++;
6789         des_unsigned_int(n_ch, ch, 0);
6790         xmlResetLastError();
6791         if (mem_base != xmlMemBlocks()) {
6792             printf("Leak of %d blocks found in xmlIsDigit",
6793                    xmlMemBlocks() - mem_base);
6794             test_ret++;
6795             printf(" %d", n_ch);
6796             printf("\n");
6797         }
6798     }
6799     function_tests++;
6800
6801     return(test_ret);
6802 }
6803
6804
6805 static int
6806 test_xmlIsExtender(void) {
6807     int test_ret = 0;
6808
6809     int mem_base;
6810     int ret_val;
6811     unsigned int ch; /* character to validate */
6812     int n_ch;
6813
6814     for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
6815         mem_base = xmlMemBlocks();
6816         ch = gen_unsigned_int(n_ch, 0);
6817
6818         ret_val = xmlIsExtender(ch);
6819         desret_int(ret_val);
6820         call_tests++;
6821         des_unsigned_int(n_ch, ch, 0);
6822         xmlResetLastError();
6823         if (mem_base != xmlMemBlocks()) {
6824             printf("Leak of %d blocks found in xmlIsExtender",
6825                    xmlMemBlocks() - mem_base);
6826             test_ret++;
6827             printf(" %d", n_ch);
6828             printf("\n");
6829         }
6830     }
6831     function_tests++;
6832
6833     return(test_ret);
6834 }
6835
6836
6837 static int
6838 test_xmlIsIdeographic(void) {
6839     int test_ret = 0;
6840
6841     int mem_base;
6842     int ret_val;
6843     unsigned int ch; /* character to validate */
6844     int n_ch;
6845
6846     for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
6847         mem_base = xmlMemBlocks();
6848         ch = gen_unsigned_int(n_ch, 0);
6849
6850         ret_val = xmlIsIdeographic(ch);
6851         desret_int(ret_val);
6852         call_tests++;
6853         des_unsigned_int(n_ch, ch, 0);
6854         xmlResetLastError();
6855         if (mem_base != xmlMemBlocks()) {
6856             printf("Leak of %d blocks found in xmlIsIdeographic",
6857                    xmlMemBlocks() - mem_base);
6858             test_ret++;
6859             printf(" %d", n_ch);
6860             printf("\n");
6861         }
6862     }
6863     function_tests++;
6864
6865     return(test_ret);
6866 }
6867
6868
6869 static int
6870 test_xmlIsPubidChar(void) {
6871     int test_ret = 0;
6872
6873     int mem_base;
6874     int ret_val;
6875     unsigned int ch; /* character to validate */
6876     int n_ch;
6877
6878     for (n_ch = 0;n_ch < gen_nb_unsigned_int;n_ch++) {
6879         mem_base = xmlMemBlocks();
6880         ch = gen_unsigned_int(n_ch, 0);
6881
6882         ret_val = xmlIsPubidChar(ch);
6883         desret_int(ret_val);
6884         call_tests++;
6885         des_unsigned_int(n_ch, ch, 0);
6886         xmlResetLastError();
6887         if (mem_base != xmlMemBlocks()) {
6888             printf("Leak of %d blocks found in xmlIsPubidChar",
6889                    xmlMemBlocks() - mem_base);
6890             test_ret++;
6891             printf(" %d", n_ch);
6892             printf("\n");
6893         }
6894     }
6895     function_tests++;
6896
6897     return(test_ret);
6898 }
6899
6900 static int
6901 test_chvalid(void) {
6902     int test_ret = 0;
6903
6904     if (quiet == 0) printf("Testing chvalid : 9 of 9 functions ...\n");
6905     test_ret += test_xmlCharInRange();
6906     test_ret += test_xmlIsBaseChar();
6907     test_ret += test_xmlIsBlank();
6908     test_ret += test_xmlIsChar();
6909     test_ret += test_xmlIsCombining();
6910     test_ret += test_xmlIsDigit();
6911     test_ret += test_xmlIsExtender();
6912     test_ret += test_xmlIsIdeographic();
6913     test_ret += test_xmlIsPubidChar();
6914
6915     if (test_ret != 0)
6916         printf("Module chvalid: %d errors\n", test_ret);
6917     return(test_ret);
6918 }
6919
6920 static int
6921 test_xmlBoolToText(void) {
6922     int test_ret = 0;
6923
6924 #if defined(LIBXML_DEBUG_ENABLED)
6925     int mem_base;
6926     const char * ret_val;
6927     int boolval; /* a bool to turn into text */
6928     int n_boolval;
6929
6930     for (n_boolval = 0;n_boolval < gen_nb_int;n_boolval++) {
6931         mem_base = xmlMemBlocks();
6932         boolval = gen_int(n_boolval, 0);
6933
6934         ret_val = xmlBoolToText(boolval);
6935         desret_const_char_ptr(ret_val);
6936         call_tests++;
6937         des_int(n_boolval, boolval, 0);
6938         xmlResetLastError();
6939         if (mem_base != xmlMemBlocks()) {
6940             printf("Leak of %d blocks found in xmlBoolToText",
6941                    xmlMemBlocks() - mem_base);
6942             test_ret++;
6943             printf(" %d", n_boolval);
6944             printf("\n");
6945         }
6946     }
6947     function_tests++;
6948 #endif
6949
6950     return(test_ret);
6951 }
6952
6953
6954 static int
6955 test_xmlDebugCheckDocument(void) {
6956     int test_ret = 0;
6957
6958 #if defined(LIBXML_DEBUG_ENABLED)
6959     int mem_base;
6960     int ret_val;
6961     FILE * output; /* the FILE * for the output */
6962     int n_output;
6963     xmlDocPtr doc; /* the document */
6964     int n_doc;
6965
6966     for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
6967     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
6968         mem_base = xmlMemBlocks();
6969         output = gen_debug_FILE_ptr(n_output, 0);
6970         doc = gen_xmlDocPtr(n_doc, 1);
6971
6972         ret_val = xmlDebugCheckDocument(output, doc);
6973         desret_int(ret_val);
6974         call_tests++;
6975         des_debug_FILE_ptr(n_output, output, 0);
6976         des_xmlDocPtr(n_doc, doc, 1);
6977         xmlResetLastError();
6978         if (mem_base != xmlMemBlocks()) {
6979             printf("Leak of %d blocks found in xmlDebugCheckDocument",
6980                    xmlMemBlocks() - mem_base);
6981             test_ret++;
6982             printf(" %d", n_output);
6983             printf(" %d", n_doc);
6984             printf("\n");
6985         }
6986     }
6987     }
6988     function_tests++;
6989 #endif
6990
6991     return(test_ret);
6992 }
6993
6994
6995 static int
6996 test_xmlDebugDumpAttr(void) {
6997     int test_ret = 0;
6998
6999 #if defined(LIBXML_DEBUG_ENABLED)
7000     int mem_base;
7001     FILE * output; /* the FILE * for the output */
7002     int n_output;
7003     xmlAttrPtr attr; /* the attribute */
7004     int n_attr;
7005     int depth; /* the indentation level. */
7006     int n_depth;
7007
7008     for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
7009     for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
7010     for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
7011         mem_base = xmlMemBlocks();
7012         output = gen_debug_FILE_ptr(n_output, 0);
7013         attr = gen_xmlAttrPtr(n_attr, 1);
7014         depth = gen_int(n_depth, 2);
7015
7016         xmlDebugDumpAttr(output, attr, depth);
7017         call_tests++;
7018         des_debug_FILE_ptr(n_output, output, 0);
7019         des_xmlAttrPtr(n_attr, attr, 1);
7020         des_int(n_depth, depth, 2);
7021         xmlResetLastError();
7022         if (mem_base != xmlMemBlocks()) {
7023             printf("Leak of %d blocks found in xmlDebugDumpAttr",
7024                    xmlMemBlocks() - mem_base);
7025             test_ret++;
7026             printf(" %d", n_output);
7027             printf(" %d", n_attr);
7028             printf(" %d", n_depth);
7029             printf("\n");
7030         }
7031     }
7032     }
7033     }
7034     function_tests++;
7035 #endif
7036
7037     return(test_ret);
7038 }
7039
7040
7041 static int
7042 test_xmlDebugDumpAttrList(void) {
7043     int test_ret = 0;
7044
7045 #if defined(LIBXML_DEBUG_ENABLED)
7046     int mem_base;
7047     FILE * output; /* the FILE * for the output */
7048     int n_output;
7049     xmlAttrPtr attr; /* the attribute list */
7050     int n_attr;
7051     int depth; /* the indentation level. */
7052     int n_depth;
7053
7054     for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
7055     for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
7056     for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
7057         mem_base = xmlMemBlocks();
7058         output = gen_debug_FILE_ptr(n_output, 0);
7059         attr = gen_xmlAttrPtr(n_attr, 1);
7060         depth = gen_int(n_depth, 2);
7061
7062         xmlDebugDumpAttrList(output, attr, depth);
7063         call_tests++;
7064         des_debug_FILE_ptr(n_output, output, 0);
7065         des_xmlAttrPtr(n_attr, attr, 1);
7066         des_int(n_depth, depth, 2);
7067         xmlResetLastError();
7068         if (mem_base != xmlMemBlocks()) {
7069             printf("Leak of %d blocks found in xmlDebugDumpAttrList",
7070                    xmlMemBlocks() - mem_base);
7071             test_ret++;
7072             printf(" %d", n_output);
7073             printf(" %d", n_attr);
7074             printf(" %d", n_depth);
7075             printf("\n");
7076         }
7077     }
7078     }
7079     }
7080     function_tests++;
7081 #endif
7082
7083     return(test_ret);
7084 }
7085
7086
7087 static int
7088 test_xmlDebugDumpDTD(void) {
7089     int test_ret = 0;
7090
7091 #if defined(LIBXML_DEBUG_ENABLED)
7092     int mem_base;
7093     FILE * output; /* the FILE * for the output */
7094     int n_output;
7095     xmlDtdPtr dtd; /* the DTD */
7096     int n_dtd;
7097
7098     for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
7099     for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
7100         mem_base = xmlMemBlocks();
7101         output = gen_debug_FILE_ptr(n_output, 0);
7102         dtd = gen_xmlDtdPtr(n_dtd, 1);
7103
7104         xmlDebugDumpDTD(output, dtd);
7105         call_tests++;
7106         des_debug_FILE_ptr(n_output, output, 0);
7107         des_xmlDtdPtr(n_dtd, dtd, 1);
7108         xmlResetLastError();
7109         if (mem_base != xmlMemBlocks()) {
7110             printf("Leak of %d blocks found in xmlDebugDumpDTD",
7111                    xmlMemBlocks() - mem_base);
7112             test_ret++;
7113             printf(" %d", n_output);
7114             printf(" %d", n_dtd);
7115             printf("\n");
7116         }
7117     }
7118     }
7119     function_tests++;
7120 #endif
7121
7122     return(test_ret);
7123 }
7124
7125
7126 static int
7127 test_xmlDebugDumpDocument(void) {
7128     int test_ret = 0;
7129
7130 #if defined(LIBXML_DEBUG_ENABLED)
7131     int mem_base;
7132     FILE * output; /* the FILE * for the output */
7133     int n_output;
7134     xmlDocPtr doc; /* the document */
7135     int n_doc;
7136
7137     for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
7138     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
7139         mem_base = xmlMemBlocks();
7140         output = gen_debug_FILE_ptr(n_output, 0);
7141         doc = gen_xmlDocPtr(n_doc, 1);
7142
7143         xmlDebugDumpDocument(output, doc);
7144         call_tests++;
7145         des_debug_FILE_ptr(n_output, output, 0);
7146         des_xmlDocPtr(n_doc, doc, 1);
7147         xmlResetLastError();
7148         if (mem_base != xmlMemBlocks()) {
7149             printf("Leak of %d blocks found in xmlDebugDumpDocument",
7150                    xmlMemBlocks() - mem_base);
7151             test_ret++;
7152             printf(" %d", n_output);
7153             printf(" %d", n_doc);
7154             printf("\n");
7155         }
7156     }
7157     }
7158     function_tests++;
7159 #endif
7160
7161     return(test_ret);
7162 }
7163
7164
7165 static int
7166 test_xmlDebugDumpDocumentHead(void) {
7167     int test_ret = 0;
7168
7169 #if defined(LIBXML_DEBUG_ENABLED)
7170     int mem_base;
7171     FILE * output; /* the FILE * for the output */
7172     int n_output;
7173     xmlDocPtr doc; /* the document */
7174     int n_doc;
7175
7176     for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
7177     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
7178         mem_base = xmlMemBlocks();
7179         output = gen_debug_FILE_ptr(n_output, 0);
7180         doc = gen_xmlDocPtr(n_doc, 1);
7181
7182         xmlDebugDumpDocumentHead(output, doc);
7183         call_tests++;
7184         des_debug_FILE_ptr(n_output, output, 0);
7185         des_xmlDocPtr(n_doc, doc, 1);
7186         xmlResetLastError();
7187         if (mem_base != xmlMemBlocks()) {
7188             printf("Leak of %d blocks found in xmlDebugDumpDocumentHead",
7189                    xmlMemBlocks() - mem_base);
7190             test_ret++;
7191             printf(" %d", n_output);
7192             printf(" %d", n_doc);
7193             printf("\n");
7194         }
7195     }
7196     }
7197     function_tests++;
7198 #endif
7199
7200     return(test_ret);
7201 }
7202
7203
7204 static int
7205 test_xmlDebugDumpEntities(void) {
7206     int test_ret = 0;
7207
7208 #if defined(LIBXML_DEBUG_ENABLED)
7209     int mem_base;
7210     FILE * output; /* the FILE * for the output */
7211     int n_output;
7212     xmlDocPtr doc; /* the document */
7213     int n_doc;
7214
7215     for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
7216     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
7217         mem_base = xmlMemBlocks();
7218         output = gen_debug_FILE_ptr(n_output, 0);
7219         doc = gen_xmlDocPtr(n_doc, 1);
7220
7221         xmlDebugDumpEntities(output, doc);
7222         call_tests++;
7223         des_debug_FILE_ptr(n_output, output, 0);
7224         des_xmlDocPtr(n_doc, doc, 1);
7225         xmlResetLastError();
7226         if (mem_base != xmlMemBlocks()) {
7227             printf("Leak of %d blocks found in xmlDebugDumpEntities",
7228                    xmlMemBlocks() - mem_base);
7229             test_ret++;
7230             printf(" %d", n_output);
7231             printf(" %d", n_doc);
7232             printf("\n");
7233         }
7234     }
7235     }
7236     function_tests++;
7237 #endif
7238
7239     return(test_ret);
7240 }
7241
7242
7243 static int
7244 test_xmlDebugDumpNode(void) {
7245     int test_ret = 0;
7246
7247 #if defined(LIBXML_DEBUG_ENABLED)
7248     int mem_base;
7249     FILE * output; /* the FILE * for the output */
7250     int n_output;
7251     xmlNodePtr node; /* the node */
7252     int n_node;
7253     int depth; /* the indentation level. */
7254     int n_depth;
7255
7256     for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
7257     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7258     for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
7259         mem_base = xmlMemBlocks();
7260         output = gen_debug_FILE_ptr(n_output, 0);
7261         node = gen_xmlNodePtr(n_node, 1);
7262         depth = gen_int(n_depth, 2);
7263
7264         xmlDebugDumpNode(output, node, depth);
7265         call_tests++;
7266         des_debug_FILE_ptr(n_output, output, 0);
7267         des_xmlNodePtr(n_node, node, 1);
7268         des_int(n_depth, depth, 2);
7269         xmlResetLastError();
7270         if (mem_base != xmlMemBlocks()) {
7271             printf("Leak of %d blocks found in xmlDebugDumpNode",
7272                    xmlMemBlocks() - mem_base);
7273             test_ret++;
7274             printf(" %d", n_output);
7275             printf(" %d", n_node);
7276             printf(" %d", n_depth);
7277             printf("\n");
7278         }
7279     }
7280     }
7281     }
7282     function_tests++;
7283 #endif
7284
7285     return(test_ret);
7286 }
7287
7288
7289 static int
7290 test_xmlDebugDumpNodeList(void) {
7291     int test_ret = 0;
7292
7293 #if defined(LIBXML_DEBUG_ENABLED)
7294     int mem_base;
7295     FILE * output; /* the FILE * for the output */
7296     int n_output;
7297     xmlNodePtr node; /* the node list */
7298     int n_node;
7299     int depth; /* the indentation level. */
7300     int n_depth;
7301
7302     for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
7303     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7304     for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
7305         mem_base = xmlMemBlocks();
7306         output = gen_debug_FILE_ptr(n_output, 0);
7307         node = gen_xmlNodePtr(n_node, 1);
7308         depth = gen_int(n_depth, 2);
7309
7310         xmlDebugDumpNodeList(output, node, depth);
7311         call_tests++;
7312         des_debug_FILE_ptr(n_output, output, 0);
7313         des_xmlNodePtr(n_node, node, 1);
7314         des_int(n_depth, depth, 2);
7315         xmlResetLastError();
7316         if (mem_base != xmlMemBlocks()) {
7317             printf("Leak of %d blocks found in xmlDebugDumpNodeList",
7318                    xmlMemBlocks() - mem_base);
7319             test_ret++;
7320             printf(" %d", n_output);
7321             printf(" %d", n_node);
7322             printf(" %d", n_depth);
7323             printf("\n");
7324         }
7325     }
7326     }
7327     }
7328     function_tests++;
7329 #endif
7330
7331     return(test_ret);
7332 }
7333
7334
7335 static int
7336 test_xmlDebugDumpOneNode(void) {
7337     int test_ret = 0;
7338
7339 #if defined(LIBXML_DEBUG_ENABLED)
7340     int mem_base;
7341     FILE * output; /* the FILE * for the output */
7342     int n_output;
7343     xmlNodePtr node; /* the node */
7344     int n_node;
7345     int depth; /* the indentation level. */
7346     int n_depth;
7347
7348     for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
7349     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7350     for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
7351         mem_base = xmlMemBlocks();
7352         output = gen_debug_FILE_ptr(n_output, 0);
7353         node = gen_xmlNodePtr(n_node, 1);
7354         depth = gen_int(n_depth, 2);
7355
7356         xmlDebugDumpOneNode(output, node, depth);
7357         call_tests++;
7358         des_debug_FILE_ptr(n_output, output, 0);
7359         des_xmlNodePtr(n_node, node, 1);
7360         des_int(n_depth, depth, 2);
7361         xmlResetLastError();
7362         if (mem_base != xmlMemBlocks()) {
7363             printf("Leak of %d blocks found in xmlDebugDumpOneNode",
7364                    xmlMemBlocks() - mem_base);
7365             test_ret++;
7366             printf(" %d", n_output);
7367             printf(" %d", n_node);
7368             printf(" %d", n_depth);
7369             printf("\n");
7370         }
7371     }
7372     }
7373     }
7374     function_tests++;
7375 #endif
7376
7377     return(test_ret);
7378 }
7379
7380
7381 static int
7382 test_xmlDebugDumpString(void) {
7383     int test_ret = 0;
7384
7385 #if defined(LIBXML_DEBUG_ENABLED)
7386     int mem_base;
7387     FILE * output; /* the FILE * for the output */
7388     int n_output;
7389     xmlChar * str; /* the string */
7390     int n_str;
7391
7392     for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
7393     for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
7394         mem_base = xmlMemBlocks();
7395         output = gen_debug_FILE_ptr(n_output, 0);
7396         str = gen_const_xmlChar_ptr(n_str, 1);
7397
7398         xmlDebugDumpString(output, (const xmlChar *)str);
7399         call_tests++;
7400         des_debug_FILE_ptr(n_output, output, 0);
7401         des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
7402         xmlResetLastError();
7403         if (mem_base != xmlMemBlocks()) {
7404             printf("Leak of %d blocks found in xmlDebugDumpString",
7405                    xmlMemBlocks() - mem_base);
7406             test_ret++;
7407             printf(" %d", n_output);
7408             printf(" %d", n_str);
7409             printf("\n");
7410         }
7411     }
7412     }
7413     function_tests++;
7414 #endif
7415
7416     return(test_ret);
7417 }
7418
7419
7420 static int
7421 test_xmlLsCountNode(void) {
7422     int test_ret = 0;
7423
7424 #if defined(LIBXML_DEBUG_ENABLED)
7425     int mem_base;
7426     int ret_val;
7427     xmlNodePtr node; /* the node to count */
7428     int n_node;
7429
7430     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7431         mem_base = xmlMemBlocks();
7432         node = gen_xmlNodePtr(n_node, 0);
7433
7434         ret_val = xmlLsCountNode(node);
7435         desret_int(ret_val);
7436         call_tests++;
7437         des_xmlNodePtr(n_node, node, 0);
7438         xmlResetLastError();
7439         if (mem_base != xmlMemBlocks()) {
7440             printf("Leak of %d blocks found in xmlLsCountNode",
7441                    xmlMemBlocks() - mem_base);
7442             test_ret++;
7443             printf(" %d", n_node);
7444             printf("\n");
7445         }
7446     }
7447     function_tests++;
7448 #endif
7449
7450     return(test_ret);
7451 }
7452
7453
7454 static int
7455 test_xmlLsOneNode(void) {
7456     int test_ret = 0;
7457
7458 #if defined(LIBXML_DEBUG_ENABLED)
7459     int mem_base;
7460     FILE * output; /* the FILE * for the output */
7461     int n_output;
7462     xmlNodePtr node; /* the node to dump */
7463     int n_node;
7464
7465     for (n_output = 0;n_output < gen_nb_debug_FILE_ptr;n_output++) {
7466     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7467         mem_base = xmlMemBlocks();
7468         output = gen_debug_FILE_ptr(n_output, 0);
7469         node = gen_xmlNodePtr(n_node, 1);
7470
7471         xmlLsOneNode(output, node);
7472         call_tests++;
7473         des_debug_FILE_ptr(n_output, output, 0);
7474         des_xmlNodePtr(n_node, node, 1);
7475         xmlResetLastError();
7476         if (mem_base != xmlMemBlocks()) {
7477             printf("Leak of %d blocks found in xmlLsOneNode",
7478                    xmlMemBlocks() - mem_base);
7479             test_ret++;
7480             printf(" %d", n_output);
7481             printf(" %d", n_node);
7482             printf("\n");
7483         }
7484     }
7485     }
7486     function_tests++;
7487 #endif
7488
7489     return(test_ret);
7490 }
7491
7492
7493 #define gen_nb_char_ptr 1
7494 static char * gen_char_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
7495     return(NULL);
7496 }
7497 static void des_char_ptr(int no ATTRIBUTE_UNUSED, char * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
7498 }
7499
7500 static int
7501 test_xmlShell(void) {
7502     int test_ret = 0;
7503
7504
7505     /* missing type support */
7506     return(test_ret);
7507 }
7508
7509
7510 static int
7511 test_xmlShellBase(void) {
7512     int test_ret = 0;
7513
7514 #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
7515     int mem_base;
7516     int ret_val;
7517     xmlShellCtxtPtr ctxt; /* the shell context */
7518     int n_ctxt;
7519     char * arg; /* unused */
7520     int n_arg;
7521     xmlNodePtr node; /* a node */
7522     int n_node;
7523     xmlNodePtr node2; /* unused */
7524     int n_node2;
7525
7526     for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
7527     for (n_arg = 0;n_arg < gen_nb_char_ptr;n_arg++) {
7528     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7529     for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
7530         mem_base = xmlMemBlocks();
7531         ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
7532         arg = gen_char_ptr(n_arg, 1);
7533         node = gen_xmlNodePtr(n_node, 2);
7534         node2 = gen_xmlNodePtr(n_node2, 3);
7535
7536         ret_val = xmlShellBase(ctxt, arg, node, node2);
7537         desret_int(ret_val);
7538         call_tests++;
7539         des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
7540         des_char_ptr(n_arg, arg, 1);
7541         des_xmlNodePtr(n_node, node, 2);
7542         des_xmlNodePtr(n_node2, node2, 3);
7543         xmlResetLastError();
7544         if (mem_base != xmlMemBlocks()) {
7545             printf("Leak of %d blocks found in xmlShellBase",
7546                    xmlMemBlocks() - mem_base);
7547             test_ret++;
7548             printf(" %d", n_ctxt);
7549             printf(" %d", n_arg);
7550             printf(" %d", n_node);
7551             printf(" %d", n_node2);
7552             printf("\n");
7553         }
7554     }
7555     }
7556     }
7557     }
7558     function_tests++;
7559 #endif
7560
7561     return(test_ret);
7562 }
7563
7564
7565 static int
7566 test_xmlShellCat(void) {
7567     int test_ret = 0;
7568
7569 #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
7570     int mem_base;
7571     int ret_val;
7572     xmlShellCtxtPtr ctxt; /* the shell context */
7573     int n_ctxt;
7574     char * arg; /* unused */
7575     int n_arg;
7576     xmlNodePtr node; /* a node */
7577     int n_node;
7578     xmlNodePtr node2; /* unused */
7579     int n_node2;
7580
7581     for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
7582     for (n_arg = 0;n_arg < gen_nb_char_ptr;n_arg++) {
7583     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7584     for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
7585         mem_base = xmlMemBlocks();
7586         ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
7587         arg = gen_char_ptr(n_arg, 1);
7588         node = gen_xmlNodePtr(n_node, 2);
7589         node2 = gen_xmlNodePtr(n_node2, 3);
7590
7591         ret_val = xmlShellCat(ctxt, arg, node, node2);
7592         desret_int(ret_val);
7593         call_tests++;
7594         des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
7595         des_char_ptr(n_arg, arg, 1);
7596         des_xmlNodePtr(n_node, node, 2);
7597         des_xmlNodePtr(n_node2, node2, 3);
7598         xmlResetLastError();
7599         if (mem_base != xmlMemBlocks()) {
7600             printf("Leak of %d blocks found in xmlShellCat",
7601                    xmlMemBlocks() - mem_base);
7602             test_ret++;
7603             printf(" %d", n_ctxt);
7604             printf(" %d", n_arg);
7605             printf(" %d", n_node);
7606             printf(" %d", n_node2);
7607             printf("\n");
7608         }
7609     }
7610     }
7611     }
7612     }
7613     function_tests++;
7614 #endif
7615
7616     return(test_ret);
7617 }
7618
7619
7620 static int
7621 test_xmlShellDir(void) {
7622     int test_ret = 0;
7623
7624 #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
7625     int mem_base;
7626     int ret_val;
7627     xmlShellCtxtPtr ctxt; /* the shell context */
7628     int n_ctxt;
7629     char * arg; /* unused */
7630     int n_arg;
7631     xmlNodePtr node; /* a node */
7632     int n_node;
7633     xmlNodePtr node2; /* unused */
7634     int n_node2;
7635
7636     for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
7637     for (n_arg = 0;n_arg < gen_nb_char_ptr;n_arg++) {
7638     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7639     for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
7640         mem_base = xmlMemBlocks();
7641         ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
7642         arg = gen_char_ptr(n_arg, 1);
7643         node = gen_xmlNodePtr(n_node, 2);
7644         node2 = gen_xmlNodePtr(n_node2, 3);
7645
7646         ret_val = xmlShellDir(ctxt, arg, node, node2);
7647         desret_int(ret_val);
7648         call_tests++;
7649         des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
7650         des_char_ptr(n_arg, arg, 1);
7651         des_xmlNodePtr(n_node, node, 2);
7652         des_xmlNodePtr(n_node2, node2, 3);
7653         xmlResetLastError();
7654         if (mem_base != xmlMemBlocks()) {
7655             printf("Leak of %d blocks found in xmlShellDir",
7656                    xmlMemBlocks() - mem_base);
7657             test_ret++;
7658             printf(" %d", n_ctxt);
7659             printf(" %d", n_arg);
7660             printf(" %d", n_node);
7661             printf(" %d", n_node2);
7662             printf("\n");
7663         }
7664     }
7665     }
7666     }
7667     }
7668     function_tests++;
7669 #endif
7670
7671     return(test_ret);
7672 }
7673
7674
7675 static int
7676 test_xmlShellDu(void) {
7677     int test_ret = 0;
7678
7679 #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
7680     int mem_base;
7681     int ret_val;
7682     xmlShellCtxtPtr ctxt; /* the shell context */
7683     int n_ctxt;
7684     char * arg; /* unused */
7685     int n_arg;
7686     xmlNodePtr tree; /* a node defining a subtree */
7687     int n_tree;
7688     xmlNodePtr node2; /* unused */
7689     int n_node2;
7690
7691     for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
7692     for (n_arg = 0;n_arg < gen_nb_char_ptr;n_arg++) {
7693     for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) {
7694     for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
7695         mem_base = xmlMemBlocks();
7696         ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
7697         arg = gen_char_ptr(n_arg, 1);
7698         tree = gen_xmlNodePtr(n_tree, 2);
7699         node2 = gen_xmlNodePtr(n_node2, 3);
7700
7701         ret_val = xmlShellDu(ctxt, arg, tree, node2);
7702         desret_int(ret_val);
7703         call_tests++;
7704         des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
7705         des_char_ptr(n_arg, arg, 1);
7706         des_xmlNodePtr(n_tree, tree, 2);
7707         des_xmlNodePtr(n_node2, node2, 3);
7708         xmlResetLastError();
7709         if (mem_base != xmlMemBlocks()) {
7710             printf("Leak of %d blocks found in xmlShellDu",
7711                    xmlMemBlocks() - mem_base);
7712             test_ret++;
7713             printf(" %d", n_ctxt);
7714             printf(" %d", n_arg);
7715             printf(" %d", n_tree);
7716             printf(" %d", n_node2);
7717             printf("\n");
7718         }
7719     }
7720     }
7721     }
7722     }
7723     function_tests++;
7724 #endif
7725
7726     return(test_ret);
7727 }
7728
7729
7730 static int
7731 test_xmlShellList(void) {
7732     int test_ret = 0;
7733
7734 #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
7735     int mem_base;
7736     int ret_val;
7737     xmlShellCtxtPtr ctxt; /* the shell context */
7738     int n_ctxt;
7739     char * arg; /* unused */
7740     int n_arg;
7741     xmlNodePtr node; /* a node */
7742     int n_node;
7743     xmlNodePtr node2; /* unused */
7744     int n_node2;
7745
7746     for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
7747     for (n_arg = 0;n_arg < gen_nb_char_ptr;n_arg++) {
7748     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7749     for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
7750         mem_base = xmlMemBlocks();
7751         ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
7752         arg = gen_char_ptr(n_arg, 1);
7753         node = gen_xmlNodePtr(n_node, 2);
7754         node2 = gen_xmlNodePtr(n_node2, 3);
7755
7756         ret_val = xmlShellList(ctxt, arg, node, node2);
7757         desret_int(ret_val);
7758         call_tests++;
7759         des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
7760         des_char_ptr(n_arg, arg, 1);
7761         des_xmlNodePtr(n_node, node, 2);
7762         des_xmlNodePtr(n_node2, node2, 3);
7763         xmlResetLastError();
7764         if (mem_base != xmlMemBlocks()) {
7765             printf("Leak of %d blocks found in xmlShellList",
7766                    xmlMemBlocks() - mem_base);
7767             test_ret++;
7768             printf(" %d", n_ctxt);
7769             printf(" %d", n_arg);
7770             printf(" %d", n_node);
7771             printf(" %d", n_node2);
7772             printf("\n");
7773         }
7774     }
7775     }
7776     }
7777     }
7778     function_tests++;
7779 #endif
7780
7781     return(test_ret);
7782 }
7783
7784
7785 static int
7786 test_xmlShellLoad(void) {
7787     int test_ret = 0;
7788
7789 #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
7790     int mem_base;
7791     int ret_val;
7792     xmlShellCtxtPtr ctxt; /* the shell context */
7793     int n_ctxt;
7794     char * filename; /* the file name */
7795     int n_filename;
7796     xmlNodePtr node; /* unused */
7797     int n_node;
7798     xmlNodePtr node2; /* unused */
7799     int n_node2;
7800
7801     for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
7802     for (n_filename = 0;n_filename < gen_nb_char_ptr;n_filename++) {
7803     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7804     for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
7805         mem_base = xmlMemBlocks();
7806         ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
7807         filename = gen_char_ptr(n_filename, 1);
7808         node = gen_xmlNodePtr(n_node, 2);
7809         node2 = gen_xmlNodePtr(n_node2, 3);
7810
7811         ret_val = xmlShellLoad(ctxt, filename, node, node2);
7812         desret_int(ret_val);
7813         call_tests++;
7814         des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
7815         des_char_ptr(n_filename, filename, 1);
7816         des_xmlNodePtr(n_node, node, 2);
7817         des_xmlNodePtr(n_node2, node2, 3);
7818         xmlResetLastError();
7819         if (mem_base != xmlMemBlocks()) {
7820             printf("Leak of %d blocks found in xmlShellLoad",
7821                    xmlMemBlocks() - mem_base);
7822             test_ret++;
7823             printf(" %d", n_ctxt);
7824             printf(" %d", n_filename);
7825             printf(" %d", n_node);
7826             printf(" %d", n_node2);
7827             printf("\n");
7828         }
7829     }
7830     }
7831     }
7832     }
7833     function_tests++;
7834 #endif
7835
7836     return(test_ret);
7837 }
7838
7839
7840 static int
7841 test_xmlShellPrintXPathResult(void) {
7842     int test_ret = 0;
7843
7844 #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
7845     int mem_base;
7846     xmlXPathObjectPtr list; /* a valid result generated by an xpath evaluation */
7847     int n_list;
7848
7849     for (n_list = 0;n_list < gen_nb_xmlXPathObjectPtr;n_list++) {
7850         mem_base = xmlMemBlocks();
7851         list = gen_xmlXPathObjectPtr(n_list, 0);
7852
7853         xmlShellPrintXPathResult(list);
7854         call_tests++;
7855         des_xmlXPathObjectPtr(n_list, list, 0);
7856         xmlResetLastError();
7857         if (mem_base != xmlMemBlocks()) {
7858             printf("Leak of %d blocks found in xmlShellPrintXPathResult",
7859                    xmlMemBlocks() - mem_base);
7860             test_ret++;
7861             printf(" %d", n_list);
7862             printf("\n");
7863         }
7864     }
7865     function_tests++;
7866 #endif
7867
7868     return(test_ret);
7869 }
7870
7871
7872 static int
7873 test_xmlShellPwd(void) {
7874     int test_ret = 0;
7875
7876 #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED)
7877     int mem_base;
7878     int ret_val;
7879     xmlShellCtxtPtr ctxt; /* the shell context */
7880     int n_ctxt;
7881     char * buffer; /* the output buffer */
7882     int n_buffer;
7883     xmlNodePtr node; /* a node */
7884     int n_node;
7885     xmlNodePtr node2; /* unused */
7886     int n_node2;
7887
7888     for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
7889     for (n_buffer = 0;n_buffer < gen_nb_char_ptr;n_buffer++) {
7890     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7891     for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
7892         mem_base = xmlMemBlocks();
7893         ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
7894         buffer = gen_char_ptr(n_buffer, 1);
7895         node = gen_xmlNodePtr(n_node, 2);
7896         node2 = gen_xmlNodePtr(n_node2, 3);
7897
7898         ret_val = xmlShellPwd(ctxt, buffer, node, node2);
7899         desret_int(ret_val);
7900         call_tests++;
7901         des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
7902         des_char_ptr(n_buffer, buffer, 1);
7903         des_xmlNodePtr(n_node, node, 2);
7904         des_xmlNodePtr(n_node2, node2, 3);
7905         xmlResetLastError();
7906         if (mem_base != xmlMemBlocks()) {
7907             printf("Leak of %d blocks found in xmlShellPwd",
7908                    xmlMemBlocks() - mem_base);
7909             test_ret++;
7910             printf(" %d", n_ctxt);
7911             printf(" %d", n_buffer);
7912             printf(" %d", n_node);
7913             printf(" %d", n_node2);
7914             printf("\n");
7915         }
7916     }
7917     }
7918     }
7919     }
7920     function_tests++;
7921 #endif
7922
7923     return(test_ret);
7924 }
7925
7926
7927 static int
7928 test_xmlShellSave(void) {
7929     int test_ret = 0;
7930
7931 #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
7932     int mem_base;
7933     int ret_val;
7934     xmlShellCtxtPtr ctxt; /* the shell context */
7935     int n_ctxt;
7936     char * filename; /* the file name (optional) */
7937     int n_filename;
7938     xmlNodePtr node; /* unused */
7939     int n_node;
7940     xmlNodePtr node2; /* unused */
7941     int n_node2;
7942
7943     for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
7944     for (n_filename = 0;n_filename < gen_nb_char_ptr;n_filename++) {
7945     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
7946     for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
7947         mem_base = xmlMemBlocks();
7948         ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
7949         filename = gen_char_ptr(n_filename, 1);
7950         node = gen_xmlNodePtr(n_node, 2);
7951         node2 = gen_xmlNodePtr(n_node2, 3);
7952
7953         ret_val = xmlShellSave(ctxt, filename, node, node2);
7954         desret_int(ret_val);
7955         call_tests++;
7956         des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
7957         des_char_ptr(n_filename, filename, 1);
7958         des_xmlNodePtr(n_node, node, 2);
7959         des_xmlNodePtr(n_node2, node2, 3);
7960         xmlResetLastError();
7961         if (mem_base != xmlMemBlocks()) {
7962             printf("Leak of %d blocks found in xmlShellSave",
7963                    xmlMemBlocks() - mem_base);
7964             test_ret++;
7965             printf(" %d", n_ctxt);
7966             printf(" %d", n_filename);
7967             printf(" %d", n_node);
7968             printf(" %d", n_node2);
7969             printf("\n");
7970         }
7971     }
7972     }
7973     }
7974     }
7975     function_tests++;
7976 #endif
7977
7978     return(test_ret);
7979 }
7980
7981
7982 static int
7983 test_xmlShellValidate(void) {
7984     int test_ret = 0;
7985
7986 #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_VALID_ENABLED)
7987     int mem_base;
7988     int ret_val;
7989     xmlShellCtxtPtr ctxt; /* the shell context */
7990     int n_ctxt;
7991     char * dtd; /* the DTD URI (optional) */
7992     int n_dtd;
7993     xmlNodePtr node; /* unused */
7994     int n_node;
7995     xmlNodePtr node2; /* unused */
7996     int n_node2;
7997
7998     for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
7999     for (n_dtd = 0;n_dtd < gen_nb_char_ptr;n_dtd++) {
8000     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
8001     for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
8002         mem_base = xmlMemBlocks();
8003         ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
8004         dtd = gen_char_ptr(n_dtd, 1);
8005         node = gen_xmlNodePtr(n_node, 2);
8006         node2 = gen_xmlNodePtr(n_node2, 3);
8007
8008         ret_val = xmlShellValidate(ctxt, dtd, node, node2);
8009         desret_int(ret_val);
8010         call_tests++;
8011         des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
8012         des_char_ptr(n_dtd, dtd, 1);
8013         des_xmlNodePtr(n_node, node, 2);
8014         des_xmlNodePtr(n_node2, node2, 3);
8015         xmlResetLastError();
8016         if (mem_base != xmlMemBlocks()) {
8017             printf("Leak of %d blocks found in xmlShellValidate",
8018                    xmlMemBlocks() - mem_base);
8019             test_ret++;
8020             printf(" %d", n_ctxt);
8021             printf(" %d", n_dtd);
8022             printf(" %d", n_node);
8023             printf(" %d", n_node2);
8024             printf("\n");
8025         }
8026     }
8027     }
8028     }
8029     }
8030     function_tests++;
8031 #endif
8032
8033     return(test_ret);
8034 }
8035
8036
8037 static int
8038 test_xmlShellWrite(void) {
8039     int test_ret = 0;
8040
8041 #if defined(LIBXML_DEBUG_ENABLED) && defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
8042     int mem_base;
8043     int ret_val;
8044     xmlShellCtxtPtr ctxt; /* the shell context */
8045     int n_ctxt;
8046     char * filename; /* the file name */
8047     int n_filename;
8048     xmlNodePtr node; /* a node in the tree */
8049     int n_node;
8050     xmlNodePtr node2; /* unused */
8051     int n_node2;
8052
8053     for (n_ctxt = 0;n_ctxt < gen_nb_xmlShellCtxtPtr;n_ctxt++) {
8054     for (n_filename = 0;n_filename < gen_nb_char_ptr;n_filename++) {
8055     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
8056     for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
8057         mem_base = xmlMemBlocks();
8058         ctxt = gen_xmlShellCtxtPtr(n_ctxt, 0);
8059         filename = gen_char_ptr(n_filename, 1);
8060         node = gen_xmlNodePtr(n_node, 2);
8061         node2 = gen_xmlNodePtr(n_node2, 3);
8062
8063         ret_val = xmlShellWrite(ctxt, filename, node, node2);
8064         desret_int(ret_val);
8065         call_tests++;
8066         des_xmlShellCtxtPtr(n_ctxt, ctxt, 0);
8067         des_char_ptr(n_filename, filename, 1);
8068         des_xmlNodePtr(n_node, node, 2);
8069         des_xmlNodePtr(n_node2, node2, 3);
8070         xmlResetLastError();
8071         if (mem_base != xmlMemBlocks()) {
8072             printf("Leak of %d blocks found in xmlShellWrite",
8073                    xmlMemBlocks() - mem_base);
8074             test_ret++;
8075             printf(" %d", n_ctxt);
8076             printf(" %d", n_filename);
8077             printf(" %d", n_node);
8078             printf(" %d", n_node2);
8079             printf("\n");
8080         }
8081     }
8082     }
8083     }
8084     }
8085     function_tests++;
8086 #endif
8087
8088     return(test_ret);
8089 }
8090
8091 static int
8092 test_debugXML(void) {
8093     int test_ret = 0;
8094
8095     if (quiet == 0) printf("Testing debugXML : 25 of 28 functions ...\n");
8096     test_ret += test_xmlBoolToText();
8097     test_ret += test_xmlDebugCheckDocument();
8098     test_ret += test_xmlDebugDumpAttr();
8099     test_ret += test_xmlDebugDumpAttrList();
8100     test_ret += test_xmlDebugDumpDTD();
8101     test_ret += test_xmlDebugDumpDocument();
8102     test_ret += test_xmlDebugDumpDocumentHead();
8103     test_ret += test_xmlDebugDumpEntities();
8104     test_ret += test_xmlDebugDumpNode();
8105     test_ret += test_xmlDebugDumpNodeList();
8106     test_ret += test_xmlDebugDumpOneNode();
8107     test_ret += test_xmlDebugDumpString();
8108     test_ret += test_xmlLsCountNode();
8109     test_ret += test_xmlLsOneNode();
8110     test_ret += test_xmlShell();
8111     test_ret += test_xmlShellBase();
8112     test_ret += test_xmlShellCat();
8113     test_ret += test_xmlShellDir();
8114     test_ret += test_xmlShellDu();
8115     test_ret += test_xmlShellList();
8116     test_ret += test_xmlShellLoad();
8117     test_ret += test_xmlShellPrintXPathResult();
8118     test_ret += test_xmlShellPwd();
8119     test_ret += test_xmlShellSave();
8120     test_ret += test_xmlShellValidate();
8121     test_ret += test_xmlShellWrite();
8122
8123     if (test_ret != 0)
8124         printf("Module debugXML: %d errors\n", test_ret);
8125     return(test_ret);
8126 }
8127
8128 static int
8129 test_xmlDictCleanup(void) {
8130     int test_ret = 0;
8131
8132     int mem_base;
8133
8134         mem_base = xmlMemBlocks();
8135
8136         xmlDictCleanup();
8137         call_tests++;
8138         xmlResetLastError();
8139         if (mem_base != xmlMemBlocks()) {
8140             printf("Leak of %d blocks found in xmlDictCleanup",
8141                    xmlMemBlocks() - mem_base);
8142             test_ret++;
8143             printf("\n");
8144         }
8145     function_tests++;
8146
8147     return(test_ret);
8148 }
8149
8150
8151 static int
8152 test_xmlDictCreate(void) {
8153     int test_ret = 0;
8154
8155     int mem_base;
8156     xmlDictPtr ret_val;
8157
8158         mem_base = xmlMemBlocks();
8159
8160         ret_val = xmlDictCreate();
8161         desret_xmlDictPtr(ret_val);
8162         call_tests++;
8163         xmlResetLastError();
8164         if (mem_base != xmlMemBlocks()) {
8165             printf("Leak of %d blocks found in xmlDictCreate",
8166                    xmlMemBlocks() - mem_base);
8167             test_ret++;
8168             printf("\n");
8169         }
8170     function_tests++;
8171
8172     return(test_ret);
8173 }
8174
8175
8176 static int
8177 test_xmlDictCreateSub(void) {
8178     int test_ret = 0;
8179
8180     int mem_base;
8181     xmlDictPtr ret_val;
8182     xmlDictPtr sub; /* an existing dictionnary */
8183     int n_sub;
8184
8185     for (n_sub = 0;n_sub < gen_nb_xmlDictPtr;n_sub++) {
8186         mem_base = xmlMemBlocks();
8187         sub = gen_xmlDictPtr(n_sub, 0);
8188
8189         ret_val = xmlDictCreateSub(sub);
8190         desret_xmlDictPtr(ret_val);
8191         call_tests++;
8192         des_xmlDictPtr(n_sub, sub, 0);
8193         xmlResetLastError();
8194         if (mem_base != xmlMemBlocks()) {
8195             printf("Leak of %d blocks found in xmlDictCreateSub",
8196                    xmlMemBlocks() - mem_base);
8197             test_ret++;
8198             printf(" %d", n_sub);
8199             printf("\n");
8200         }
8201     }
8202     function_tests++;
8203
8204     return(test_ret);
8205 }
8206
8207
8208 static int
8209 test_xmlDictExists(void) {
8210     int test_ret = 0;
8211
8212     int mem_base;
8213     const xmlChar * ret_val;
8214     xmlDictPtr dict; /* the dictionnary */
8215     int n_dict;
8216     xmlChar * name; /* the name of the userdata */
8217     int n_name;
8218     int len; /* the length of the name, if -1 it is recomputed */
8219     int n_len;
8220
8221     for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) {
8222     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
8223     for (n_len = 0;n_len < gen_nb_int;n_len++) {
8224         mem_base = xmlMemBlocks();
8225         dict = gen_xmlDictPtr(n_dict, 0);
8226         name = gen_const_xmlChar_ptr(n_name, 1);
8227         len = gen_int(n_len, 2);
8228
8229         ret_val = xmlDictExists(dict, (const xmlChar *)name, len);
8230         desret_const_xmlChar_ptr(ret_val);
8231         call_tests++;
8232         des_xmlDictPtr(n_dict, dict, 0);
8233         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
8234         des_int(n_len, len, 2);
8235         xmlResetLastError();
8236         if (mem_base != xmlMemBlocks()) {
8237             printf("Leak of %d blocks found in xmlDictExists",
8238                    xmlMemBlocks() - mem_base);
8239             test_ret++;
8240             printf(" %d", n_dict);
8241             printf(" %d", n_name);
8242             printf(" %d", n_len);
8243             printf("\n");
8244         }
8245     }
8246     }
8247     }
8248     function_tests++;
8249
8250     return(test_ret);
8251 }
8252
8253
8254 static int
8255 test_xmlDictLookup(void) {
8256     int test_ret = 0;
8257
8258     int mem_base;
8259     const xmlChar * ret_val;
8260     xmlDictPtr dict; /* the dictionnary */
8261     int n_dict;
8262     xmlChar * name; /* the name of the userdata */
8263     int n_name;
8264     int len; /* the length of the name, if -1 it is recomputed */
8265     int n_len;
8266
8267     for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) {
8268     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
8269     for (n_len = 0;n_len < gen_nb_int;n_len++) {
8270         mem_base = xmlMemBlocks();
8271         dict = gen_xmlDictPtr(n_dict, 0);
8272         name = gen_const_xmlChar_ptr(n_name, 1);
8273         len = gen_int(n_len, 2);
8274
8275         ret_val = xmlDictLookup(dict, (const xmlChar *)name, len);
8276         desret_const_xmlChar_ptr(ret_val);
8277         call_tests++;
8278         des_xmlDictPtr(n_dict, dict, 0);
8279         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
8280         des_int(n_len, len, 2);
8281         xmlResetLastError();
8282         if (mem_base != xmlMemBlocks()) {
8283             printf("Leak of %d blocks found in xmlDictLookup",
8284                    xmlMemBlocks() - mem_base);
8285             test_ret++;
8286             printf(" %d", n_dict);
8287             printf(" %d", n_name);
8288             printf(" %d", n_len);
8289             printf("\n");
8290         }
8291     }
8292     }
8293     }
8294     function_tests++;
8295
8296     return(test_ret);
8297 }
8298
8299
8300 static int
8301 test_xmlDictOwns(void) {
8302     int test_ret = 0;
8303
8304     int mem_base;
8305     int ret_val;
8306     xmlDictPtr dict; /* the dictionnary */
8307     int n_dict;
8308     xmlChar * str; /* the string */
8309     int n_str;
8310
8311     for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) {
8312     for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
8313         mem_base = xmlMemBlocks();
8314         dict = gen_xmlDictPtr(n_dict, 0);
8315         str = gen_const_xmlChar_ptr(n_str, 1);
8316
8317         ret_val = xmlDictOwns(dict, (const xmlChar *)str);
8318         desret_int(ret_val);
8319         call_tests++;
8320         des_xmlDictPtr(n_dict, dict, 0);
8321         des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
8322         xmlResetLastError();
8323         if (mem_base != xmlMemBlocks()) {
8324             printf("Leak of %d blocks found in xmlDictOwns",
8325                    xmlMemBlocks() - mem_base);
8326             test_ret++;
8327             printf(" %d", n_dict);
8328             printf(" %d", n_str);
8329             printf("\n");
8330         }
8331     }
8332     }
8333     function_tests++;
8334
8335     return(test_ret);
8336 }
8337
8338
8339 static int
8340 test_xmlDictQLookup(void) {
8341     int test_ret = 0;
8342
8343     int mem_base;
8344     const xmlChar * ret_val;
8345     xmlDictPtr dict; /* the dictionnary */
8346     int n_dict;
8347     xmlChar * prefix; /* the prefix */
8348     int n_prefix;
8349     xmlChar * name; /* the name */
8350     int n_name;
8351
8352     for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) {
8353     for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
8354     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
8355         mem_base = xmlMemBlocks();
8356         dict = gen_xmlDictPtr(n_dict, 0);
8357         prefix = gen_const_xmlChar_ptr(n_prefix, 1);
8358         name = gen_const_xmlChar_ptr(n_name, 2);
8359
8360         ret_val = xmlDictQLookup(dict, (const xmlChar *)prefix, (const xmlChar *)name);
8361         desret_const_xmlChar_ptr(ret_val);
8362         call_tests++;
8363         des_xmlDictPtr(n_dict, dict, 0);
8364         des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
8365         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
8366         xmlResetLastError();
8367         if (mem_base != xmlMemBlocks()) {
8368             printf("Leak of %d blocks found in xmlDictQLookup",
8369                    xmlMemBlocks() - mem_base);
8370             test_ret++;
8371             printf(" %d", n_dict);
8372             printf(" %d", n_prefix);
8373             printf(" %d", n_name);
8374             printf("\n");
8375         }
8376     }
8377     }
8378     }
8379     function_tests++;
8380
8381     return(test_ret);
8382 }
8383
8384
8385 static int
8386 test_xmlDictReference(void) {
8387     int test_ret = 0;
8388
8389     int mem_base;
8390     int ret_val;
8391     xmlDictPtr dict; /* the dictionnary */
8392     int n_dict;
8393
8394     for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) {
8395         mem_base = xmlMemBlocks();
8396         dict = gen_xmlDictPtr(n_dict, 0);
8397
8398         ret_val = xmlDictReference(dict);
8399         xmlDictFree(dict);
8400         desret_int(ret_val);
8401         call_tests++;
8402         des_xmlDictPtr(n_dict, dict, 0);
8403         xmlResetLastError();
8404         if (mem_base != xmlMemBlocks()) {
8405             printf("Leak of %d blocks found in xmlDictReference",
8406                    xmlMemBlocks() - mem_base);
8407             test_ret++;
8408             printf(" %d", n_dict);
8409             printf("\n");
8410         }
8411     }
8412     function_tests++;
8413
8414     return(test_ret);
8415 }
8416
8417
8418 static int
8419 test_xmlDictSize(void) {
8420     int test_ret = 0;
8421
8422     int mem_base;
8423     int ret_val;
8424     xmlDictPtr dict; /* the dictionnary */
8425     int n_dict;
8426
8427     for (n_dict = 0;n_dict < gen_nb_xmlDictPtr;n_dict++) {
8428         mem_base = xmlMemBlocks();
8429         dict = gen_xmlDictPtr(n_dict, 0);
8430
8431         ret_val = xmlDictSize(dict);
8432         desret_int(ret_val);
8433         call_tests++;
8434         des_xmlDictPtr(n_dict, dict, 0);
8435         xmlResetLastError();
8436         if (mem_base != xmlMemBlocks()) {
8437             printf("Leak of %d blocks found in xmlDictSize",
8438                    xmlMemBlocks() - mem_base);
8439             test_ret++;
8440             printf(" %d", n_dict);
8441             printf("\n");
8442         }
8443     }
8444     function_tests++;
8445
8446     return(test_ret);
8447 }
8448
8449 static int
8450 test_dict(void) {
8451     int test_ret = 0;
8452
8453     if (quiet == 0) printf("Testing dict : 9 of 10 functions ...\n");
8454     test_ret += test_xmlDictCleanup();
8455     test_ret += test_xmlDictCreate();
8456     test_ret += test_xmlDictCreateSub();
8457     test_ret += test_xmlDictExists();
8458     test_ret += test_xmlDictLookup();
8459     test_ret += test_xmlDictOwns();
8460     test_ret += test_xmlDictQLookup();
8461     test_ret += test_xmlDictReference();
8462     test_ret += test_xmlDictSize();
8463
8464     if (test_ret != 0)
8465         printf("Module dict: %d errors\n", test_ret);
8466     return(test_ret);
8467 }
8468
8469 static int
8470 test_UTF8Toisolat1(void) {
8471     int test_ret = 0;
8472
8473 #if defined(LIBXML_OUTPUT_ENABLED)
8474 #ifdef LIBXML_OUTPUT_ENABLED
8475     int mem_base;
8476     int ret_val;
8477     unsigned char * out; /* a pointer to an array of bytes to store the result */
8478     int n_out;
8479     int * outlen; /* the length of @out */
8480     int n_outlen;
8481     unsigned char * in; /* a pointer to an array of UTF-8 chars */
8482     int n_in;
8483     int * inlen; /* the length of @in */
8484     int n_inlen;
8485
8486     for (n_out = 0;n_out < gen_nb_unsigned_char_ptr;n_out++) {
8487     for (n_outlen = 0;n_outlen < gen_nb_int_ptr;n_outlen++) {
8488     for (n_in = 0;n_in < gen_nb_const_unsigned_char_ptr;n_in++) {
8489     for (n_inlen = 0;n_inlen < gen_nb_int_ptr;n_inlen++) {
8490         mem_base = xmlMemBlocks();
8491         out = gen_unsigned_char_ptr(n_out, 0);
8492         outlen = gen_int_ptr(n_outlen, 1);
8493         in = gen_const_unsigned_char_ptr(n_in, 2);
8494         inlen = gen_int_ptr(n_inlen, 3);
8495
8496         ret_val = UTF8Toisolat1(out, outlen, (const unsigned char *)in, inlen);
8497         desret_int(ret_val);
8498         call_tests++;
8499         des_unsigned_char_ptr(n_out, out, 0);
8500         des_int_ptr(n_outlen, outlen, 1);
8501         des_const_unsigned_char_ptr(n_in, (const unsigned char *)in, 2);
8502         des_int_ptr(n_inlen, inlen, 3);
8503         xmlResetLastError();
8504         if (mem_base != xmlMemBlocks()) {
8505             printf("Leak of %d blocks found in UTF8Toisolat1",
8506                    xmlMemBlocks() - mem_base);
8507             test_ret++;
8508             printf(" %d", n_out);
8509             printf(" %d", n_outlen);
8510             printf(" %d", n_in);
8511             printf(" %d", n_inlen);
8512             printf("\n");
8513         }
8514     }
8515     }
8516     }
8517     }
8518     function_tests++;
8519 #endif
8520 #endif
8521
8522     return(test_ret);
8523 }
8524
8525
8526 static int
8527 test_isolat1ToUTF8(void) {
8528     int test_ret = 0;
8529
8530     int mem_base;
8531     int ret_val;
8532     unsigned char * out; /* a pointer to an array of bytes to store the result */
8533     int n_out;
8534     int * outlen; /* the length of @out */
8535     int n_outlen;
8536     unsigned char * in; /* a pointer to an array of ISO Latin 1 chars */
8537     int n_in;
8538     int * inlen; /* the length of @in */
8539     int n_inlen;
8540
8541     for (n_out = 0;n_out < gen_nb_unsigned_char_ptr;n_out++) {
8542     for (n_outlen = 0;n_outlen < gen_nb_int_ptr;n_outlen++) {
8543     for (n_in = 0;n_in < gen_nb_const_unsigned_char_ptr;n_in++) {
8544     for (n_inlen = 0;n_inlen < gen_nb_int_ptr;n_inlen++) {
8545         mem_base = xmlMemBlocks();
8546         out = gen_unsigned_char_ptr(n_out, 0);
8547         outlen = gen_int_ptr(n_outlen, 1);
8548         in = gen_const_unsigned_char_ptr(n_in, 2);
8549         inlen = gen_int_ptr(n_inlen, 3);
8550
8551         ret_val = isolat1ToUTF8(out, outlen, (const unsigned char *)in, inlen);
8552         desret_int(ret_val);
8553         call_tests++;
8554         des_unsigned_char_ptr(n_out, out, 0);
8555         des_int_ptr(n_outlen, outlen, 1);
8556         des_const_unsigned_char_ptr(n_in, (const unsigned char *)in, 2);
8557         des_int_ptr(n_inlen, inlen, 3);
8558         xmlResetLastError();
8559         if (mem_base != xmlMemBlocks()) {
8560             printf("Leak of %d blocks found in isolat1ToUTF8",
8561                    xmlMemBlocks() - mem_base);
8562             test_ret++;
8563             printf(" %d", n_out);
8564             printf(" %d", n_outlen);
8565             printf(" %d", n_in);
8566             printf(" %d", n_inlen);
8567             printf("\n");
8568         }
8569     }
8570     }
8571     }
8572     }
8573     function_tests++;
8574
8575     return(test_ret);
8576 }
8577
8578
8579 static int
8580 test_xmlAddEncodingAlias(void) {
8581     int test_ret = 0;
8582
8583     int ret_val;
8584     char * name; /* the encoding name as parsed, in UTF-8 format (ASCII actually) */
8585     int n_name;
8586     char * alias; /* the alias name as parsed, in UTF-8 format (ASCII actually) */
8587     int n_alias;
8588
8589     for (n_name = 0;n_name < gen_nb_const_char_ptr;n_name++) {
8590     for (n_alias = 0;n_alias < gen_nb_const_char_ptr;n_alias++) {
8591         name = gen_const_char_ptr(n_name, 0);
8592         alias = gen_const_char_ptr(n_alias, 1);
8593
8594         ret_val = xmlAddEncodingAlias((const char *)name, (const char *)alias);
8595         desret_int(ret_val);
8596         call_tests++;
8597         des_const_char_ptr(n_name, (const char *)name, 0);
8598         des_const_char_ptr(n_alias, (const char *)alias, 1);
8599         xmlResetLastError();
8600     }
8601     }
8602     function_tests++;
8603
8604     return(test_ret);
8605 }
8606
8607
8608 #define gen_nb_xmlCharEncodingHandler_ptr 1
8609 static xmlCharEncodingHandler * gen_xmlCharEncodingHandler_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
8610     return(NULL);
8611 }
8612 static void des_xmlCharEncodingHandler_ptr(int no ATTRIBUTE_UNUSED, xmlCharEncodingHandler * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
8613 }
8614
8615 static int
8616 test_xmlCharEncCloseFunc(void) {
8617     int test_ret = 0;
8618
8619     int mem_base;
8620     int ret_val;
8621     xmlCharEncodingHandler * handler; /* char enconding transformation data structure */
8622     int n_handler;
8623
8624     for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandler_ptr;n_handler++) {
8625         mem_base = xmlMemBlocks();
8626         handler = gen_xmlCharEncodingHandler_ptr(n_handler, 0);
8627
8628         ret_val = xmlCharEncCloseFunc(handler);
8629         desret_int(ret_val);
8630         call_tests++;
8631         des_xmlCharEncodingHandler_ptr(n_handler, handler, 0);
8632         xmlResetLastError();
8633         if (mem_base != xmlMemBlocks()) {
8634             printf("Leak of %d blocks found in xmlCharEncCloseFunc",
8635                    xmlMemBlocks() - mem_base);
8636             test_ret++;
8637             printf(" %d", n_handler);
8638             printf("\n");
8639         }
8640     }
8641     function_tests++;
8642
8643     return(test_ret);
8644 }
8645
8646
8647 static int
8648 test_xmlCharEncFirstLine(void) {
8649     int test_ret = 0;
8650
8651     int mem_base;
8652     int ret_val;
8653     xmlCharEncodingHandler * handler; /* char enconding transformation data structure */
8654     int n_handler;
8655     xmlBufferPtr out; /* an xmlBuffer for the output. */
8656     int n_out;
8657     xmlBufferPtr in; /* an xmlBuffer for the input */
8658     int n_in;
8659
8660     for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandler_ptr;n_handler++) {
8661     for (n_out = 0;n_out < gen_nb_xmlBufferPtr;n_out++) {
8662     for (n_in = 0;n_in < gen_nb_xmlBufferPtr;n_in++) {
8663         mem_base = xmlMemBlocks();
8664         handler = gen_xmlCharEncodingHandler_ptr(n_handler, 0);
8665         out = gen_xmlBufferPtr(n_out, 1);
8666         in = gen_xmlBufferPtr(n_in, 2);
8667
8668         ret_val = xmlCharEncFirstLine(handler, out, in);
8669         desret_int(ret_val);
8670         call_tests++;
8671         des_xmlCharEncodingHandler_ptr(n_handler, handler, 0);
8672         des_xmlBufferPtr(n_out, out, 1);
8673         des_xmlBufferPtr(n_in, in, 2);
8674         xmlResetLastError();
8675         if (mem_base != xmlMemBlocks()) {
8676             printf("Leak of %d blocks found in xmlCharEncFirstLine",
8677                    xmlMemBlocks() - mem_base);
8678             test_ret++;
8679             printf(" %d", n_handler);
8680             printf(" %d", n_out);
8681             printf(" %d", n_in);
8682             printf("\n");
8683         }
8684     }
8685     }
8686     }
8687     function_tests++;
8688
8689     return(test_ret);
8690 }
8691
8692
8693 static int
8694 test_xmlCharEncInFunc(void) {
8695     int test_ret = 0;
8696
8697     int mem_base;
8698     int ret_val;
8699     xmlCharEncodingHandler * handler; /* char encoding transformation data structure */
8700     int n_handler;
8701     xmlBufferPtr out; /* an xmlBuffer for the output. */
8702     int n_out;
8703     xmlBufferPtr in; /* an xmlBuffer for the input */
8704     int n_in;
8705
8706     for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandler_ptr;n_handler++) {
8707     for (n_out = 0;n_out < gen_nb_xmlBufferPtr;n_out++) {
8708     for (n_in = 0;n_in < gen_nb_xmlBufferPtr;n_in++) {
8709         mem_base = xmlMemBlocks();
8710         handler = gen_xmlCharEncodingHandler_ptr(n_handler, 0);
8711         out = gen_xmlBufferPtr(n_out, 1);
8712         in = gen_xmlBufferPtr(n_in, 2);
8713
8714         ret_val = xmlCharEncInFunc(handler, out, in);
8715         desret_int(ret_val);
8716         call_tests++;
8717         des_xmlCharEncodingHandler_ptr(n_handler, handler, 0);
8718         des_xmlBufferPtr(n_out, out, 1);
8719         des_xmlBufferPtr(n_in, in, 2);
8720         xmlResetLastError();
8721         if (mem_base != xmlMemBlocks()) {
8722             printf("Leak of %d blocks found in xmlCharEncInFunc",
8723                    xmlMemBlocks() - mem_base);
8724             test_ret++;
8725             printf(" %d", n_handler);
8726             printf(" %d", n_out);
8727             printf(" %d", n_in);
8728             printf("\n");
8729         }
8730     }
8731     }
8732     }
8733     function_tests++;
8734
8735     return(test_ret);
8736 }
8737
8738
8739 static int
8740 test_xmlCharEncOutFunc(void) {
8741     int test_ret = 0;
8742
8743     int mem_base;
8744     int ret_val;
8745     xmlCharEncodingHandler * handler; /* char enconding transformation data structure */
8746     int n_handler;
8747     xmlBufferPtr out; /* an xmlBuffer for the output. */
8748     int n_out;
8749     xmlBufferPtr in; /* an xmlBuffer for the input */
8750     int n_in;
8751
8752     for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandler_ptr;n_handler++) {
8753     for (n_out = 0;n_out < gen_nb_xmlBufferPtr;n_out++) {
8754     for (n_in = 0;n_in < gen_nb_xmlBufferPtr;n_in++) {
8755         mem_base = xmlMemBlocks();
8756         handler = gen_xmlCharEncodingHandler_ptr(n_handler, 0);
8757         out = gen_xmlBufferPtr(n_out, 1);
8758         in = gen_xmlBufferPtr(n_in, 2);
8759
8760         ret_val = xmlCharEncOutFunc(handler, out, in);
8761         desret_int(ret_val);
8762         call_tests++;
8763         des_xmlCharEncodingHandler_ptr(n_handler, handler, 0);
8764         des_xmlBufferPtr(n_out, out, 1);
8765         des_xmlBufferPtr(n_in, in, 2);
8766         xmlResetLastError();
8767         if (mem_base != xmlMemBlocks()) {
8768             printf("Leak of %d blocks found in xmlCharEncOutFunc",
8769                    xmlMemBlocks() - mem_base);
8770             test_ret++;
8771             printf(" %d", n_handler);
8772             printf(" %d", n_out);
8773             printf(" %d", n_in);
8774             printf("\n");
8775         }
8776     }
8777     }
8778     }
8779     function_tests++;
8780
8781     return(test_ret);
8782 }
8783
8784
8785 static int
8786 test_xmlCleanupCharEncodingHandlers(void) {
8787     int test_ret = 0;
8788
8789
8790
8791         xmlCleanupCharEncodingHandlers();
8792         call_tests++;
8793         xmlResetLastError();
8794     function_tests++;
8795
8796     return(test_ret);
8797 }
8798
8799
8800 static int
8801 test_xmlCleanupEncodingAliases(void) {
8802     int test_ret = 0;
8803
8804     int mem_base;
8805
8806         mem_base = xmlMemBlocks();
8807
8808         xmlCleanupEncodingAliases();
8809         call_tests++;
8810         xmlResetLastError();
8811         if (mem_base != xmlMemBlocks()) {
8812             printf("Leak of %d blocks found in xmlCleanupEncodingAliases",
8813                    xmlMemBlocks() - mem_base);
8814             test_ret++;
8815             printf("\n");
8816         }
8817     function_tests++;
8818
8819     return(test_ret);
8820 }
8821
8822
8823 static int
8824 test_xmlDelEncodingAlias(void) {
8825     int test_ret = 0;
8826
8827     int mem_base;
8828     int ret_val;
8829     char * alias; /* the alias name as parsed, in UTF-8 format (ASCII actually) */
8830     int n_alias;
8831
8832     for (n_alias = 0;n_alias < gen_nb_const_char_ptr;n_alias++) {
8833         mem_base = xmlMemBlocks();
8834         alias = gen_const_char_ptr(n_alias, 0);
8835
8836         ret_val = xmlDelEncodingAlias((const char *)alias);
8837         desret_int(ret_val);
8838         call_tests++;
8839         des_const_char_ptr(n_alias, (const char *)alias, 0);
8840         xmlResetLastError();
8841         if (mem_base != xmlMemBlocks()) {
8842             printf("Leak of %d blocks found in xmlDelEncodingAlias",
8843                    xmlMemBlocks() - mem_base);
8844             test_ret++;
8845             printf(" %d", n_alias);
8846             printf("\n");
8847         }
8848     }
8849     function_tests++;
8850
8851     return(test_ret);
8852 }
8853
8854
8855 static int
8856 test_xmlDetectCharEncoding(void) {
8857     int test_ret = 0;
8858
8859     int mem_base;
8860     xmlCharEncoding ret_val;
8861     unsigned char * in; /* a pointer to the first bytes of the XML entity, must be at least 2 bytes long (at least 4 if encoding is UTF4 variant). */
8862     int n_in;
8863     int len; /* pointer to the length of the buffer */
8864     int n_len;
8865
8866     for (n_in = 0;n_in < gen_nb_const_unsigned_char_ptr;n_in++) {
8867     for (n_len = 0;n_len < gen_nb_int;n_len++) {
8868         mem_base = xmlMemBlocks();
8869         in = gen_const_unsigned_char_ptr(n_in, 0);
8870         len = gen_int(n_len, 1);
8871
8872         ret_val = xmlDetectCharEncoding((const unsigned char *)in, len);
8873         desret_xmlCharEncoding(ret_val);
8874         call_tests++;
8875         des_const_unsigned_char_ptr(n_in, (const unsigned char *)in, 0);
8876         des_int(n_len, len, 1);
8877         xmlResetLastError();
8878         if (mem_base != xmlMemBlocks()) {
8879             printf("Leak of %d blocks found in xmlDetectCharEncoding",
8880                    xmlMemBlocks() - mem_base);
8881             test_ret++;
8882             printf(" %d", n_in);
8883             printf(" %d", n_len);
8884             printf("\n");
8885         }
8886     }
8887     }
8888     function_tests++;
8889
8890     return(test_ret);
8891 }
8892
8893
8894 static int
8895 test_xmlFindCharEncodingHandler(void) {
8896     int test_ret = 0;
8897
8898
8899     /* missing type support */
8900     return(test_ret);
8901 }
8902
8903
8904 static int
8905 test_xmlGetCharEncodingHandler(void) {
8906     int test_ret = 0;
8907
8908
8909     /* missing type support */
8910     return(test_ret);
8911 }
8912
8913
8914 static int
8915 test_xmlGetCharEncodingName(void) {
8916     int test_ret = 0;
8917
8918     int mem_base;
8919     const char * ret_val;
8920     xmlCharEncoding enc; /* the encoding */
8921     int n_enc;
8922
8923     for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
8924         mem_base = xmlMemBlocks();
8925         enc = gen_xmlCharEncoding(n_enc, 0);
8926
8927         ret_val = xmlGetCharEncodingName(enc);
8928         desret_const_char_ptr(ret_val);
8929         call_tests++;
8930         des_xmlCharEncoding(n_enc, enc, 0);
8931         xmlResetLastError();
8932         if (mem_base != xmlMemBlocks()) {
8933             printf("Leak of %d blocks found in xmlGetCharEncodingName",
8934                    xmlMemBlocks() - mem_base);
8935             test_ret++;
8936             printf(" %d", n_enc);
8937             printf("\n");
8938         }
8939     }
8940     function_tests++;
8941
8942     return(test_ret);
8943 }
8944
8945
8946 static int
8947 test_xmlGetEncodingAlias(void) {
8948     int test_ret = 0;
8949
8950     int mem_base;
8951     const char * ret_val;
8952     char * alias; /* the alias name as parsed, in UTF-8 format (ASCII actually) */
8953     int n_alias;
8954
8955     for (n_alias = 0;n_alias < gen_nb_const_char_ptr;n_alias++) {
8956         mem_base = xmlMemBlocks();
8957         alias = gen_const_char_ptr(n_alias, 0);
8958
8959         ret_val = xmlGetEncodingAlias((const char *)alias);
8960         desret_const_char_ptr(ret_val);
8961         call_tests++;
8962         des_const_char_ptr(n_alias, (const char *)alias, 0);
8963         xmlResetLastError();
8964         if (mem_base != xmlMemBlocks()) {
8965             printf("Leak of %d blocks found in xmlGetEncodingAlias",
8966                    xmlMemBlocks() - mem_base);
8967             test_ret++;
8968             printf(" %d", n_alias);
8969             printf("\n");
8970         }
8971     }
8972     function_tests++;
8973
8974     return(test_ret);
8975 }
8976
8977
8978 static int
8979 test_xmlInitCharEncodingHandlers(void) {
8980     int test_ret = 0;
8981
8982
8983
8984         xmlInitCharEncodingHandlers();
8985         call_tests++;
8986         xmlResetLastError();
8987     function_tests++;
8988
8989     return(test_ret);
8990 }
8991
8992
8993 static int
8994 test_xmlNewCharEncodingHandler(void) {
8995     int test_ret = 0;
8996
8997
8998     /* missing type support */
8999     return(test_ret);
9000 }
9001
9002
9003 static int
9004 test_xmlParseCharEncoding(void) {
9005     int test_ret = 0;
9006
9007     int mem_base;
9008     xmlCharEncoding ret_val;
9009     char * name; /* the encoding name as parsed, in UTF-8 format (ASCII actually) */
9010     int n_name;
9011
9012     for (n_name = 0;n_name < gen_nb_const_char_ptr;n_name++) {
9013         mem_base = xmlMemBlocks();
9014         name = gen_const_char_ptr(n_name, 0);
9015
9016         ret_val = xmlParseCharEncoding((const char *)name);
9017         desret_xmlCharEncoding(ret_val);
9018         call_tests++;
9019         des_const_char_ptr(n_name, (const char *)name, 0);
9020         xmlResetLastError();
9021         if (mem_base != xmlMemBlocks()) {
9022             printf("Leak of %d blocks found in xmlParseCharEncoding",
9023                    xmlMemBlocks() - mem_base);
9024             test_ret++;
9025             printf(" %d", n_name);
9026             printf("\n");
9027         }
9028     }
9029     function_tests++;
9030
9031     return(test_ret);
9032 }
9033
9034
9035 #define gen_nb_xmlCharEncodingHandlerPtr 1
9036 static xmlCharEncodingHandlerPtr gen_xmlCharEncodingHandlerPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
9037     return(NULL);
9038 }
9039 static void des_xmlCharEncodingHandlerPtr(int no ATTRIBUTE_UNUSED, xmlCharEncodingHandlerPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
9040 }
9041
9042 static int
9043 test_xmlRegisterCharEncodingHandler(void) {
9044     int test_ret = 0;
9045
9046     int mem_base;
9047     xmlCharEncodingHandlerPtr handler; /* the xmlCharEncodingHandlerPtr handler block */
9048     int n_handler;
9049
9050     for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandlerPtr;n_handler++) {
9051         mem_base = xmlMemBlocks();
9052         handler = gen_xmlCharEncodingHandlerPtr(n_handler, 0);
9053
9054         xmlRegisterCharEncodingHandler(handler);
9055         call_tests++;
9056         des_xmlCharEncodingHandlerPtr(n_handler, handler, 0);
9057         xmlResetLastError();
9058         if (mem_base != xmlMemBlocks()) {
9059             printf("Leak of %d blocks found in xmlRegisterCharEncodingHandler",
9060                    xmlMemBlocks() - mem_base);
9061             test_ret++;
9062             printf(" %d", n_handler);
9063             printf("\n");
9064         }
9065     }
9066     function_tests++;
9067
9068     return(test_ret);
9069 }
9070
9071 static int
9072 test_encoding(void) {
9073     int test_ret = 0;
9074
9075     if (quiet == 0) printf("Testing encoding : 16 of 19 functions ...\n");
9076     test_ret += test_UTF8Toisolat1();
9077     test_ret += test_isolat1ToUTF8();
9078     test_ret += test_xmlAddEncodingAlias();
9079     test_ret += test_xmlCharEncCloseFunc();
9080     test_ret += test_xmlCharEncFirstLine();
9081     test_ret += test_xmlCharEncInFunc();
9082     test_ret += test_xmlCharEncOutFunc();
9083     test_ret += test_xmlCleanupCharEncodingHandlers();
9084     test_ret += test_xmlCleanupEncodingAliases();
9085     test_ret += test_xmlDelEncodingAlias();
9086     test_ret += test_xmlDetectCharEncoding();
9087     test_ret += test_xmlFindCharEncodingHandler();
9088     test_ret += test_xmlGetCharEncodingHandler();
9089     test_ret += test_xmlGetCharEncodingName();
9090     test_ret += test_xmlGetEncodingAlias();
9091     test_ret += test_xmlInitCharEncodingHandlers();
9092     test_ret += test_xmlNewCharEncodingHandler();
9093     test_ret += test_xmlParseCharEncoding();
9094     test_ret += test_xmlRegisterCharEncodingHandler();
9095
9096     if (test_ret != 0)
9097         printf("Module encoding: %d errors\n", test_ret);
9098     return(test_ret);
9099 }
9100
9101 static int
9102 test_xmlAddDocEntity(void) {
9103     int test_ret = 0;
9104
9105     int mem_base;
9106     xmlEntityPtr ret_val;
9107     xmlDocPtr doc; /* the document */
9108     int n_doc;
9109     xmlChar * name; /* the entity name */
9110     int n_name;
9111     int type; /* the entity type XML_xxx_yyy_ENTITY */
9112     int n_type;
9113     xmlChar * ExternalID; /* the entity external ID if available */
9114     int n_ExternalID;
9115     xmlChar * SystemID; /* the entity system ID if available */
9116     int n_SystemID;
9117     xmlChar * content; /* the entity content */
9118     int n_content;
9119
9120     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
9121     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9122     for (n_type = 0;n_type < gen_nb_int;n_type++) {
9123     for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
9124     for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
9125     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
9126         mem_base = xmlMemBlocks();
9127         doc = gen_xmlDocPtr(n_doc, 0);
9128         name = gen_const_xmlChar_ptr(n_name, 1);
9129         type = gen_int(n_type, 2);
9130         ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 3);
9131         SystemID = gen_const_xmlChar_ptr(n_SystemID, 4);
9132         content = gen_const_xmlChar_ptr(n_content, 5);
9133
9134         ret_val = xmlAddDocEntity(doc, (const xmlChar *)name, type, (const xmlChar *)ExternalID, (const xmlChar *)SystemID, (const xmlChar *)content);
9135         desret_xmlEntityPtr(ret_val);
9136         call_tests++;
9137         des_xmlDocPtr(n_doc, doc, 0);
9138         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9139         des_int(n_type, type, 2);
9140         des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 3);
9141         des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 4);
9142         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 5);
9143         xmlResetLastError();
9144         if (mem_base != xmlMemBlocks()) {
9145             printf("Leak of %d blocks found in xmlAddDocEntity",
9146                    xmlMemBlocks() - mem_base);
9147             test_ret++;
9148             printf(" %d", n_doc);
9149             printf(" %d", n_name);
9150             printf(" %d", n_type);
9151             printf(" %d", n_ExternalID);
9152             printf(" %d", n_SystemID);
9153             printf(" %d", n_content);
9154             printf("\n");
9155         }
9156     }
9157     }
9158     }
9159     }
9160     }
9161     }
9162     function_tests++;
9163
9164     return(test_ret);
9165 }
9166
9167
9168 static int
9169 test_xmlAddDtdEntity(void) {
9170     int test_ret = 0;
9171
9172     int mem_base;
9173     xmlEntityPtr ret_val;
9174     xmlDocPtr doc; /* the document */
9175     int n_doc;
9176     xmlChar * name; /* the entity name */
9177     int n_name;
9178     int type; /* the entity type XML_xxx_yyy_ENTITY */
9179     int n_type;
9180     xmlChar * ExternalID; /* the entity external ID if available */
9181     int n_ExternalID;
9182     xmlChar * SystemID; /* the entity system ID if available */
9183     int n_SystemID;
9184     xmlChar * content; /* the entity content */
9185     int n_content;
9186
9187     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
9188     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9189     for (n_type = 0;n_type < gen_nb_int;n_type++) {
9190     for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
9191     for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
9192     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
9193         mem_base = xmlMemBlocks();
9194         doc = gen_xmlDocPtr(n_doc, 0);
9195         name = gen_const_xmlChar_ptr(n_name, 1);
9196         type = gen_int(n_type, 2);
9197         ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 3);
9198         SystemID = gen_const_xmlChar_ptr(n_SystemID, 4);
9199         content = gen_const_xmlChar_ptr(n_content, 5);
9200
9201         ret_val = xmlAddDtdEntity(doc, (const xmlChar *)name, type, (const xmlChar *)ExternalID, (const xmlChar *)SystemID, (const xmlChar *)content);
9202         desret_xmlEntityPtr(ret_val);
9203         call_tests++;
9204         des_xmlDocPtr(n_doc, doc, 0);
9205         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9206         des_int(n_type, type, 2);
9207         des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 3);
9208         des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 4);
9209         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 5);
9210         xmlResetLastError();
9211         if (mem_base != xmlMemBlocks()) {
9212             printf("Leak of %d blocks found in xmlAddDtdEntity",
9213                    xmlMemBlocks() - mem_base);
9214             test_ret++;
9215             printf(" %d", n_doc);
9216             printf(" %d", n_name);
9217             printf(" %d", n_type);
9218             printf(" %d", n_ExternalID);
9219             printf(" %d", n_SystemID);
9220             printf(" %d", n_content);
9221             printf("\n");
9222         }
9223     }
9224     }
9225     }
9226     }
9227     }
9228     }
9229     function_tests++;
9230
9231     return(test_ret);
9232 }
9233
9234
9235 static int
9236 test_xmlCleanupPredefinedEntities(void) {
9237     int test_ret = 0;
9238
9239 #if defined(LIBXML_LEGACY_ENABLED)
9240 #ifdef LIBXML_LEGACY_ENABLED
9241     int mem_base;
9242
9243         mem_base = xmlMemBlocks();
9244
9245         xmlCleanupPredefinedEntities();
9246         call_tests++;
9247         xmlResetLastError();
9248         if (mem_base != xmlMemBlocks()) {
9249             printf("Leak of %d blocks found in xmlCleanupPredefinedEntities",
9250                    xmlMemBlocks() - mem_base);
9251             test_ret++;
9252             printf("\n");
9253         }
9254     function_tests++;
9255 #endif
9256 #endif
9257
9258     return(test_ret);
9259 }
9260
9261
9262 #define gen_nb_xmlEntitiesTablePtr 1
9263 static xmlEntitiesTablePtr gen_xmlEntitiesTablePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
9264     return(NULL);
9265 }
9266 static void des_xmlEntitiesTablePtr(int no ATTRIBUTE_UNUSED, xmlEntitiesTablePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
9267 }
9268
9269 static int
9270 test_xmlCopyEntitiesTable(void) {
9271     int test_ret = 0;
9272
9273
9274     /* missing type support */
9275     return(test_ret);
9276 }
9277
9278
9279 static int
9280 test_xmlCreateEntitiesTable(void) {
9281     int test_ret = 0;
9282
9283
9284     /* missing type support */
9285     return(test_ret);
9286 }
9287
9288
9289 static int
9290 test_xmlDumpEntitiesTable(void) {
9291     int test_ret = 0;
9292
9293 #if defined(LIBXML_OUTPUT_ENABLED)
9294     int mem_base;
9295     xmlBufferPtr buf; /* An XML buffer. */
9296     int n_buf;
9297     xmlEntitiesTablePtr table; /* An entity table */
9298     int n_table;
9299
9300     for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
9301     for (n_table = 0;n_table < gen_nb_xmlEntitiesTablePtr;n_table++) {
9302         mem_base = xmlMemBlocks();
9303         buf = gen_xmlBufferPtr(n_buf, 0);
9304         table = gen_xmlEntitiesTablePtr(n_table, 1);
9305
9306         xmlDumpEntitiesTable(buf, table);
9307         call_tests++;
9308         des_xmlBufferPtr(n_buf, buf, 0);
9309         des_xmlEntitiesTablePtr(n_table, table, 1);
9310         xmlResetLastError();
9311         if (mem_base != xmlMemBlocks()) {
9312             printf("Leak of %d blocks found in xmlDumpEntitiesTable",
9313                    xmlMemBlocks() - mem_base);
9314             test_ret++;
9315             printf(" %d", n_buf);
9316             printf(" %d", n_table);
9317             printf("\n");
9318         }
9319     }
9320     }
9321     function_tests++;
9322 #endif
9323
9324     return(test_ret);
9325 }
9326
9327
9328 #define gen_nb_xmlEntityPtr 1
9329 static xmlEntityPtr gen_xmlEntityPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
9330     return(NULL);
9331 }
9332 static void des_xmlEntityPtr(int no ATTRIBUTE_UNUSED, xmlEntityPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
9333 }
9334
9335 static int
9336 test_xmlDumpEntityDecl(void) {
9337     int test_ret = 0;
9338
9339 #if defined(LIBXML_OUTPUT_ENABLED)
9340     int mem_base;
9341     xmlBufferPtr buf; /* An XML buffer. */
9342     int n_buf;
9343     xmlEntityPtr ent; /* An entity table */
9344     int n_ent;
9345
9346     for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
9347     for (n_ent = 0;n_ent < gen_nb_xmlEntityPtr;n_ent++) {
9348         mem_base = xmlMemBlocks();
9349         buf = gen_xmlBufferPtr(n_buf, 0);
9350         ent = gen_xmlEntityPtr(n_ent, 1);
9351
9352         xmlDumpEntityDecl(buf, ent);
9353         call_tests++;
9354         des_xmlBufferPtr(n_buf, buf, 0);
9355         des_xmlEntityPtr(n_ent, ent, 1);
9356         xmlResetLastError();
9357         if (mem_base != xmlMemBlocks()) {
9358             printf("Leak of %d blocks found in xmlDumpEntityDecl",
9359                    xmlMemBlocks() - mem_base);
9360             test_ret++;
9361             printf(" %d", n_buf);
9362             printf(" %d", n_ent);
9363             printf("\n");
9364         }
9365     }
9366     }
9367     function_tests++;
9368 #endif
9369
9370     return(test_ret);
9371 }
9372
9373
9374 static int
9375 test_xmlEncodeEntitiesReentrant(void) {
9376     int test_ret = 0;
9377
9378     int mem_base;
9379     xmlChar * ret_val;
9380     xmlDocPtr doc; /* the document containing the string */
9381     int n_doc;
9382     xmlChar * input; /* A string to convert to XML. */
9383     int n_input;
9384
9385     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
9386     for (n_input = 0;n_input < gen_nb_const_xmlChar_ptr;n_input++) {
9387         mem_base = xmlMemBlocks();
9388         doc = gen_xmlDocPtr(n_doc, 0);
9389         input = gen_const_xmlChar_ptr(n_input, 1);
9390
9391         ret_val = xmlEncodeEntitiesReentrant(doc, (const xmlChar *)input);
9392         desret_xmlChar_ptr(ret_val);
9393         call_tests++;
9394         des_xmlDocPtr(n_doc, doc, 0);
9395         des_const_xmlChar_ptr(n_input, (const xmlChar *)input, 1);
9396         xmlResetLastError();
9397         if (mem_base != xmlMemBlocks()) {
9398             printf("Leak of %d blocks found in xmlEncodeEntitiesReentrant",
9399                    xmlMemBlocks() - mem_base);
9400             test_ret++;
9401             printf(" %d", n_doc);
9402             printf(" %d", n_input);
9403             printf("\n");
9404         }
9405     }
9406     }
9407     function_tests++;
9408
9409     return(test_ret);
9410 }
9411
9412
9413 static int
9414 test_xmlEncodeSpecialChars(void) {
9415     int test_ret = 0;
9416
9417     int mem_base;
9418     xmlChar * ret_val;
9419     xmlDocPtr doc; /* the document containing the string */
9420     int n_doc;
9421     xmlChar * input; /* A string to convert to XML. */
9422     int n_input;
9423
9424     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
9425     for (n_input = 0;n_input < gen_nb_const_xmlChar_ptr;n_input++) {
9426         mem_base = xmlMemBlocks();
9427         doc = gen_xmlDocPtr(n_doc, 0);
9428         input = gen_const_xmlChar_ptr(n_input, 1);
9429
9430         ret_val = xmlEncodeSpecialChars(doc, (const xmlChar *)input);
9431         desret_xmlChar_ptr(ret_val);
9432         call_tests++;
9433         des_xmlDocPtr(n_doc, doc, 0);
9434         des_const_xmlChar_ptr(n_input, (const xmlChar *)input, 1);
9435         xmlResetLastError();
9436         if (mem_base != xmlMemBlocks()) {
9437             printf("Leak of %d blocks found in xmlEncodeSpecialChars",
9438                    xmlMemBlocks() - mem_base);
9439             test_ret++;
9440             printf(" %d", n_doc);
9441             printf(" %d", n_input);
9442             printf("\n");
9443         }
9444     }
9445     }
9446     function_tests++;
9447
9448     return(test_ret);
9449 }
9450
9451
9452 static int
9453 test_xmlGetDocEntity(void) {
9454     int test_ret = 0;
9455
9456     int mem_base;
9457     xmlEntityPtr ret_val;
9458     xmlDocPtr doc; /* the document referencing the entity */
9459     int n_doc;
9460     xmlChar * name; /* the entity name */
9461     int n_name;
9462
9463     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
9464     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9465         mem_base = xmlMemBlocks();
9466         doc = gen_xmlDocPtr(n_doc, 0);
9467         name = gen_const_xmlChar_ptr(n_name, 1);
9468
9469         ret_val = xmlGetDocEntity(doc, (const xmlChar *)name);
9470         desret_xmlEntityPtr(ret_val);
9471         call_tests++;
9472         des_xmlDocPtr(n_doc, doc, 0);
9473         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9474         xmlResetLastError();
9475         if (mem_base != xmlMemBlocks()) {
9476             printf("Leak of %d blocks found in xmlGetDocEntity",
9477                    xmlMemBlocks() - mem_base);
9478             test_ret++;
9479             printf(" %d", n_doc);
9480             printf(" %d", n_name);
9481             printf("\n");
9482         }
9483     }
9484     }
9485     function_tests++;
9486
9487     return(test_ret);
9488 }
9489
9490
9491 static int
9492 test_xmlGetDtdEntity(void) {
9493     int test_ret = 0;
9494
9495     int mem_base;
9496     xmlEntityPtr ret_val;
9497     xmlDocPtr doc; /* the document referencing the entity */
9498     int n_doc;
9499     xmlChar * name; /* the entity name */
9500     int n_name;
9501
9502     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
9503     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9504         mem_base = xmlMemBlocks();
9505         doc = gen_xmlDocPtr(n_doc, 0);
9506         name = gen_const_xmlChar_ptr(n_name, 1);
9507
9508         ret_val = xmlGetDtdEntity(doc, (const xmlChar *)name);
9509         desret_xmlEntityPtr(ret_val);
9510         call_tests++;
9511         des_xmlDocPtr(n_doc, doc, 0);
9512         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9513         xmlResetLastError();
9514         if (mem_base != xmlMemBlocks()) {
9515             printf("Leak of %d blocks found in xmlGetDtdEntity",
9516                    xmlMemBlocks() - mem_base);
9517             test_ret++;
9518             printf(" %d", n_doc);
9519             printf(" %d", n_name);
9520             printf("\n");
9521         }
9522     }
9523     }
9524     function_tests++;
9525
9526     return(test_ret);
9527 }
9528
9529
9530 static int
9531 test_xmlGetParameterEntity(void) {
9532     int test_ret = 0;
9533
9534     int mem_base;
9535     xmlEntityPtr ret_val;
9536     xmlDocPtr doc; /* the document referencing the entity */
9537     int n_doc;
9538     xmlChar * name; /* the entity name */
9539     int n_name;
9540
9541     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
9542     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9543         mem_base = xmlMemBlocks();
9544         doc = gen_xmlDocPtr(n_doc, 0);
9545         name = gen_const_xmlChar_ptr(n_name, 1);
9546
9547         ret_val = xmlGetParameterEntity(doc, (const xmlChar *)name);
9548         desret_xmlEntityPtr(ret_val);
9549         call_tests++;
9550         des_xmlDocPtr(n_doc, doc, 0);
9551         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9552         xmlResetLastError();
9553         if (mem_base != xmlMemBlocks()) {
9554             printf("Leak of %d blocks found in xmlGetParameterEntity",
9555                    xmlMemBlocks() - mem_base);
9556             test_ret++;
9557             printf(" %d", n_doc);
9558             printf(" %d", n_name);
9559             printf("\n");
9560         }
9561     }
9562     }
9563     function_tests++;
9564
9565     return(test_ret);
9566 }
9567
9568
9569 static int
9570 test_xmlGetPredefinedEntity(void) {
9571     int test_ret = 0;
9572
9573     int mem_base;
9574     xmlEntityPtr ret_val;
9575     xmlChar * name; /* the entity name */
9576     int n_name;
9577
9578     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9579         mem_base = xmlMemBlocks();
9580         name = gen_const_xmlChar_ptr(n_name, 0);
9581
9582         ret_val = xmlGetPredefinedEntity((const xmlChar *)name);
9583         desret_xmlEntityPtr(ret_val);
9584         call_tests++;
9585         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
9586         xmlResetLastError();
9587         if (mem_base != xmlMemBlocks()) {
9588             printf("Leak of %d blocks found in xmlGetPredefinedEntity",
9589                    xmlMemBlocks() - mem_base);
9590             test_ret++;
9591             printf(" %d", n_name);
9592             printf("\n");
9593         }
9594     }
9595     function_tests++;
9596
9597     return(test_ret);
9598 }
9599
9600
9601 static int
9602 test_xmlInitializePredefinedEntities(void) {
9603     int test_ret = 0;
9604
9605 #if defined(LIBXML_LEGACY_ENABLED)
9606 #ifdef LIBXML_LEGACY_ENABLED
9607     int mem_base;
9608
9609         mem_base = xmlMemBlocks();
9610
9611         xmlInitializePredefinedEntities();
9612         call_tests++;
9613         xmlResetLastError();
9614         if (mem_base != xmlMemBlocks()) {
9615             printf("Leak of %d blocks found in xmlInitializePredefinedEntities",
9616                    xmlMemBlocks() - mem_base);
9617             test_ret++;
9618             printf("\n");
9619         }
9620     function_tests++;
9621 #endif
9622 #endif
9623
9624     return(test_ret);
9625 }
9626
9627
9628 static int
9629 test_xmlNewEntity(void) {
9630     int test_ret = 0;
9631
9632     int mem_base;
9633     xmlEntityPtr ret_val;
9634     xmlDocPtr doc; /* the document */
9635     int n_doc;
9636     xmlChar * name; /* the entity name */
9637     int n_name;
9638     int type; /* the entity type XML_xxx_yyy_ENTITY */
9639     int n_type;
9640     xmlChar * ExternalID; /* the entity external ID if available */
9641     int n_ExternalID;
9642     xmlChar * SystemID; /* the entity system ID if available */
9643     int n_SystemID;
9644     xmlChar * content; /* the entity content */
9645     int n_content;
9646
9647     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
9648     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9649     for (n_type = 0;n_type < gen_nb_int;n_type++) {
9650     for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
9651     for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
9652     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
9653         mem_base = xmlMemBlocks();
9654         doc = gen_xmlDocPtr(n_doc, 0);
9655         name = gen_const_xmlChar_ptr(n_name, 1);
9656         type = gen_int(n_type, 2);
9657         ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 3);
9658         SystemID = gen_const_xmlChar_ptr(n_SystemID, 4);
9659         content = gen_const_xmlChar_ptr(n_content, 5);
9660
9661         ret_val = xmlNewEntity(doc, (const xmlChar *)name, type, (const xmlChar *)ExternalID, (const xmlChar *)SystemID, (const xmlChar *)content);
9662         desret_xmlEntityPtr(ret_val);
9663         call_tests++;
9664         des_xmlDocPtr(n_doc, doc, 0);
9665         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9666         des_int(n_type, type, 2);
9667         des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 3);
9668         des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 4);
9669         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 5);
9670         xmlResetLastError();
9671         if (mem_base != xmlMemBlocks()) {
9672             printf("Leak of %d blocks found in xmlNewEntity",
9673                    xmlMemBlocks() - mem_base);
9674             test_ret++;
9675             printf(" %d", n_doc);
9676             printf(" %d", n_name);
9677             printf(" %d", n_type);
9678             printf(" %d", n_ExternalID);
9679             printf(" %d", n_SystemID);
9680             printf(" %d", n_content);
9681             printf("\n");
9682         }
9683     }
9684     }
9685     }
9686     }
9687     }
9688     }
9689     function_tests++;
9690
9691     return(test_ret);
9692 }
9693
9694 static int
9695 test_entities(void) {
9696     int test_ret = 0;
9697
9698     if (quiet == 0) printf("Testing entities : 13 of 17 functions ...\n");
9699     test_ret += test_xmlAddDocEntity();
9700     test_ret += test_xmlAddDtdEntity();
9701     test_ret += test_xmlCleanupPredefinedEntities();
9702     test_ret += test_xmlCopyEntitiesTable();
9703     test_ret += test_xmlCreateEntitiesTable();
9704     test_ret += test_xmlDumpEntitiesTable();
9705     test_ret += test_xmlDumpEntityDecl();
9706     test_ret += test_xmlEncodeEntitiesReentrant();
9707     test_ret += test_xmlEncodeSpecialChars();
9708     test_ret += test_xmlGetDocEntity();
9709     test_ret += test_xmlGetDtdEntity();
9710     test_ret += test_xmlGetParameterEntity();
9711     test_ret += test_xmlGetPredefinedEntity();
9712     test_ret += test_xmlInitializePredefinedEntities();
9713     test_ret += test_xmlNewEntity();
9714
9715     if (test_ret != 0)
9716         printf("Module entities: %d errors\n", test_ret);
9717     return(test_ret);
9718 }
9719
9720 static int
9721 test_xmlHashAddEntry(void) {
9722     int test_ret = 0;
9723
9724     int mem_base;
9725     int ret_val;
9726     xmlHashTablePtr table; /* the hash table */
9727     int n_table;
9728     xmlChar * name; /* the name of the userdata */
9729     int n_name;
9730     void * userdata; /* a pointer to the userdata */
9731     int n_userdata;
9732
9733     for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
9734     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9735     for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) {
9736         mem_base = xmlMemBlocks();
9737         table = gen_xmlHashTablePtr(n_table, 0);
9738         name = gen_const_xmlChar_ptr(n_name, 1);
9739         userdata = gen_userdata(n_userdata, 2);
9740
9741         ret_val = xmlHashAddEntry(table, (const xmlChar *)name, userdata);
9742         desret_int(ret_val);
9743         call_tests++;
9744         des_xmlHashTablePtr(n_table, table, 0);
9745         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9746         des_userdata(n_userdata, userdata, 2);
9747         xmlResetLastError();
9748         if (mem_base != xmlMemBlocks()) {
9749             printf("Leak of %d blocks found in xmlHashAddEntry",
9750                    xmlMemBlocks() - mem_base);
9751             test_ret++;
9752             printf(" %d", n_table);
9753             printf(" %d", n_name);
9754             printf(" %d", n_userdata);
9755             printf("\n");
9756         }
9757     }
9758     }
9759     }
9760     function_tests++;
9761
9762     return(test_ret);
9763 }
9764
9765
9766 static int
9767 test_xmlHashAddEntry2(void) {
9768     int test_ret = 0;
9769
9770     int mem_base;
9771     int ret_val;
9772     xmlHashTablePtr table; /* the hash table */
9773     int n_table;
9774     xmlChar * name; /* the name of the userdata */
9775     int n_name;
9776     xmlChar * name2; /* a second name of the userdata */
9777     int n_name2;
9778     void * userdata; /* a pointer to the userdata */
9779     int n_userdata;
9780
9781     for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
9782     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9783     for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
9784     for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) {
9785         mem_base = xmlMemBlocks();
9786         table = gen_xmlHashTablePtr(n_table, 0);
9787         name = gen_const_xmlChar_ptr(n_name, 1);
9788         name2 = gen_const_xmlChar_ptr(n_name2, 2);
9789         userdata = gen_userdata(n_userdata, 3);
9790
9791         ret_val = xmlHashAddEntry2(table, (const xmlChar *)name, (const xmlChar *)name2, userdata);
9792         desret_int(ret_val);
9793         call_tests++;
9794         des_xmlHashTablePtr(n_table, table, 0);
9795         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9796         des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
9797         des_userdata(n_userdata, userdata, 3);
9798         xmlResetLastError();
9799         if (mem_base != xmlMemBlocks()) {
9800             printf("Leak of %d blocks found in xmlHashAddEntry2",
9801                    xmlMemBlocks() - mem_base);
9802             test_ret++;
9803             printf(" %d", n_table);
9804             printf(" %d", n_name);
9805             printf(" %d", n_name2);
9806             printf(" %d", n_userdata);
9807             printf("\n");
9808         }
9809     }
9810     }
9811     }
9812     }
9813     function_tests++;
9814
9815     return(test_ret);
9816 }
9817
9818
9819 static int
9820 test_xmlHashAddEntry3(void) {
9821     int test_ret = 0;
9822
9823     int mem_base;
9824     int ret_val;
9825     xmlHashTablePtr table; /* the hash table */
9826     int n_table;
9827     xmlChar * name; /* the name of the userdata */
9828     int n_name;
9829     xmlChar * name2; /* a second name of the userdata */
9830     int n_name2;
9831     xmlChar * name3; /* a third name of the userdata */
9832     int n_name3;
9833     void * userdata; /* a pointer to the userdata */
9834     int n_userdata;
9835
9836     for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
9837     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9838     for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
9839     for (n_name3 = 0;n_name3 < gen_nb_const_xmlChar_ptr;n_name3++) {
9840     for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) {
9841         mem_base = xmlMemBlocks();
9842         table = gen_xmlHashTablePtr(n_table, 0);
9843         name = gen_const_xmlChar_ptr(n_name, 1);
9844         name2 = gen_const_xmlChar_ptr(n_name2, 2);
9845         name3 = gen_const_xmlChar_ptr(n_name3, 3);
9846         userdata = gen_userdata(n_userdata, 4);
9847
9848         ret_val = xmlHashAddEntry3(table, (const xmlChar *)name, (const xmlChar *)name2, (const xmlChar *)name3, userdata);
9849         desret_int(ret_val);
9850         call_tests++;
9851         des_xmlHashTablePtr(n_table, table, 0);
9852         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9853         des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
9854         des_const_xmlChar_ptr(n_name3, (const xmlChar *)name3, 3);
9855         des_userdata(n_userdata, userdata, 4);
9856         xmlResetLastError();
9857         if (mem_base != xmlMemBlocks()) {
9858             printf("Leak of %d blocks found in xmlHashAddEntry3",
9859                    xmlMemBlocks() - mem_base);
9860             test_ret++;
9861             printf(" %d", n_table);
9862             printf(" %d", n_name);
9863             printf(" %d", n_name2);
9864             printf(" %d", n_name3);
9865             printf(" %d", n_userdata);
9866             printf("\n");
9867         }
9868     }
9869     }
9870     }
9871     }
9872     }
9873     function_tests++;
9874
9875     return(test_ret);
9876 }
9877
9878
9879 static int
9880 test_xmlHashCopy(void) {
9881     int test_ret = 0;
9882
9883
9884     /* missing type support */
9885     return(test_ret);
9886 }
9887
9888
9889 static int
9890 test_xmlHashCreate(void) {
9891     int test_ret = 0;
9892
9893
9894     /* missing type support */
9895     return(test_ret);
9896 }
9897
9898
9899 static int
9900 test_xmlHashCreateDict(void) {
9901     int test_ret = 0;
9902
9903
9904     /* missing type support */
9905     return(test_ret);
9906 }
9907
9908
9909 static int
9910 test_xmlHashLookup(void) {
9911     int test_ret = 0;
9912
9913     int mem_base;
9914     void * ret_val;
9915     xmlHashTablePtr table; /* the hash table */
9916     int n_table;
9917     xmlChar * name; /* the name of the userdata */
9918     int n_name;
9919
9920     for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
9921     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9922         mem_base = xmlMemBlocks();
9923         table = gen_xmlHashTablePtr(n_table, 0);
9924         name = gen_const_xmlChar_ptr(n_name, 1);
9925
9926         ret_val = xmlHashLookup(table, (const xmlChar *)name);
9927         desret_void_ptr(ret_val);
9928         call_tests++;
9929         des_xmlHashTablePtr(n_table, table, 0);
9930         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9931         xmlResetLastError();
9932         if (mem_base != xmlMemBlocks()) {
9933             printf("Leak of %d blocks found in xmlHashLookup",
9934                    xmlMemBlocks() - mem_base);
9935             test_ret++;
9936             printf(" %d", n_table);
9937             printf(" %d", n_name);
9938             printf("\n");
9939         }
9940     }
9941     }
9942     function_tests++;
9943
9944     return(test_ret);
9945 }
9946
9947
9948 static int
9949 test_xmlHashLookup2(void) {
9950     int test_ret = 0;
9951
9952     int mem_base;
9953     void * ret_val;
9954     xmlHashTablePtr table; /* the hash table */
9955     int n_table;
9956     xmlChar * name; /* the name of the userdata */
9957     int n_name;
9958     xmlChar * name2; /* a second name of the userdata */
9959     int n_name2;
9960
9961     for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
9962     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
9963     for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
9964         mem_base = xmlMemBlocks();
9965         table = gen_xmlHashTablePtr(n_table, 0);
9966         name = gen_const_xmlChar_ptr(n_name, 1);
9967         name2 = gen_const_xmlChar_ptr(n_name2, 2);
9968
9969         ret_val = xmlHashLookup2(table, (const xmlChar *)name, (const xmlChar *)name2);
9970         desret_void_ptr(ret_val);
9971         call_tests++;
9972         des_xmlHashTablePtr(n_table, table, 0);
9973         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
9974         des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
9975         xmlResetLastError();
9976         if (mem_base != xmlMemBlocks()) {
9977             printf("Leak of %d blocks found in xmlHashLookup2",
9978                    xmlMemBlocks() - mem_base);
9979             test_ret++;
9980             printf(" %d", n_table);
9981             printf(" %d", n_name);
9982             printf(" %d", n_name2);
9983             printf("\n");
9984         }
9985     }
9986     }
9987     }
9988     function_tests++;
9989
9990     return(test_ret);
9991 }
9992
9993
9994 static int
9995 test_xmlHashLookup3(void) {
9996     int test_ret = 0;
9997
9998     int mem_base;
9999     void * ret_val;
10000     xmlHashTablePtr table; /* the hash table */
10001     int n_table;
10002     xmlChar * name; /* the name of the userdata */
10003     int n_name;
10004     xmlChar * name2; /* a second name of the userdata */
10005     int n_name2;
10006     xmlChar * name3; /* a third name of the userdata */
10007     int n_name3;
10008
10009     for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10010     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10011     for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
10012     for (n_name3 = 0;n_name3 < gen_nb_const_xmlChar_ptr;n_name3++) {
10013         mem_base = xmlMemBlocks();
10014         table = gen_xmlHashTablePtr(n_table, 0);
10015         name = gen_const_xmlChar_ptr(n_name, 1);
10016         name2 = gen_const_xmlChar_ptr(n_name2, 2);
10017         name3 = gen_const_xmlChar_ptr(n_name3, 3);
10018
10019         ret_val = xmlHashLookup3(table, (const xmlChar *)name, (const xmlChar *)name2, (const xmlChar *)name3);
10020         desret_void_ptr(ret_val);
10021         call_tests++;
10022         des_xmlHashTablePtr(n_table, table, 0);
10023         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
10024         des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
10025         des_const_xmlChar_ptr(n_name3, (const xmlChar *)name3, 3);
10026         xmlResetLastError();
10027         if (mem_base != xmlMemBlocks()) {
10028             printf("Leak of %d blocks found in xmlHashLookup3",
10029                    xmlMemBlocks() - mem_base);
10030             test_ret++;
10031             printf(" %d", n_table);
10032             printf(" %d", n_name);
10033             printf(" %d", n_name2);
10034             printf(" %d", n_name3);
10035             printf("\n");
10036         }
10037     }
10038     }
10039     }
10040     }
10041     function_tests++;
10042
10043     return(test_ret);
10044 }
10045
10046
10047 static int
10048 test_xmlHashQLookup(void) {
10049     int test_ret = 0;
10050
10051     int mem_base;
10052     void * ret_val;
10053     xmlHashTablePtr table; /* the hash table */
10054     int n_table;
10055     xmlChar * prefix; /* the prefix of the userdata */
10056     int n_prefix;
10057     xmlChar * name; /* the name of the userdata */
10058     int n_name;
10059
10060     for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10061     for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
10062     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10063         mem_base = xmlMemBlocks();
10064         table = gen_xmlHashTablePtr(n_table, 0);
10065         prefix = gen_const_xmlChar_ptr(n_prefix, 1);
10066         name = gen_const_xmlChar_ptr(n_name, 2);
10067
10068         ret_val = xmlHashQLookup(table, (const xmlChar *)prefix, (const xmlChar *)name);
10069         desret_void_ptr(ret_val);
10070         call_tests++;
10071         des_xmlHashTablePtr(n_table, table, 0);
10072         des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
10073         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
10074         xmlResetLastError();
10075         if (mem_base != xmlMemBlocks()) {
10076             printf("Leak of %d blocks found in xmlHashQLookup",
10077                    xmlMemBlocks() - mem_base);
10078             test_ret++;
10079             printf(" %d", n_table);
10080             printf(" %d", n_prefix);
10081             printf(" %d", n_name);
10082             printf("\n");
10083         }
10084     }
10085     }
10086     }
10087     function_tests++;
10088
10089     return(test_ret);
10090 }
10091
10092
10093 static int
10094 test_xmlHashQLookup2(void) {
10095     int test_ret = 0;
10096
10097     int mem_base;
10098     void * ret_val;
10099     xmlHashTablePtr table; /* the hash table */
10100     int n_table;
10101     xmlChar * prefix; /* the prefix of the userdata */
10102     int n_prefix;
10103     xmlChar * name; /* the name of the userdata */
10104     int n_name;
10105     xmlChar * prefix2; /* the second prefix of the userdata */
10106     int n_prefix2;
10107     xmlChar * name2; /* a second name of the userdata */
10108     int n_name2;
10109
10110     for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10111     for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
10112     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10113     for (n_prefix2 = 0;n_prefix2 < gen_nb_const_xmlChar_ptr;n_prefix2++) {
10114     for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
10115         mem_base = xmlMemBlocks();
10116         table = gen_xmlHashTablePtr(n_table, 0);
10117         prefix = gen_const_xmlChar_ptr(n_prefix, 1);
10118         name = gen_const_xmlChar_ptr(n_name, 2);
10119         prefix2 = gen_const_xmlChar_ptr(n_prefix2, 3);
10120         name2 = gen_const_xmlChar_ptr(n_name2, 4);
10121
10122         ret_val = xmlHashQLookup2(table, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)prefix2, (const xmlChar *)name2);
10123         desret_void_ptr(ret_val);
10124         call_tests++;
10125         des_xmlHashTablePtr(n_table, table, 0);
10126         des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
10127         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
10128         des_const_xmlChar_ptr(n_prefix2, (const xmlChar *)prefix2, 3);
10129         des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 4);
10130         xmlResetLastError();
10131         if (mem_base != xmlMemBlocks()) {
10132             printf("Leak of %d blocks found in xmlHashQLookup2",
10133                    xmlMemBlocks() - mem_base);
10134             test_ret++;
10135             printf(" %d", n_table);
10136             printf(" %d", n_prefix);
10137             printf(" %d", n_name);
10138             printf(" %d", n_prefix2);
10139             printf(" %d", n_name2);
10140             printf("\n");
10141         }
10142     }
10143     }
10144     }
10145     }
10146     }
10147     function_tests++;
10148
10149     return(test_ret);
10150 }
10151
10152
10153 static int
10154 test_xmlHashQLookup3(void) {
10155     int test_ret = 0;
10156
10157     int mem_base;
10158     void * ret_val;
10159     xmlHashTablePtr table; /* the hash table */
10160     int n_table;
10161     xmlChar * prefix; /* the prefix of the userdata */
10162     int n_prefix;
10163     xmlChar * name; /* the name of the userdata */
10164     int n_name;
10165     xmlChar * prefix2; /* the second prefix of the userdata */
10166     int n_prefix2;
10167     xmlChar * name2; /* a second name of the userdata */
10168     int n_name2;
10169     xmlChar * prefix3; /* the third prefix of the userdata */
10170     int n_prefix3;
10171     xmlChar * name3; /* a third name of the userdata */
10172     int n_name3;
10173
10174     for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10175     for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
10176     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10177     for (n_prefix2 = 0;n_prefix2 < gen_nb_const_xmlChar_ptr;n_prefix2++) {
10178     for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
10179     for (n_prefix3 = 0;n_prefix3 < gen_nb_const_xmlChar_ptr;n_prefix3++) {
10180     for (n_name3 = 0;n_name3 < gen_nb_const_xmlChar_ptr;n_name3++) {
10181         mem_base = xmlMemBlocks();
10182         table = gen_xmlHashTablePtr(n_table, 0);
10183         prefix = gen_const_xmlChar_ptr(n_prefix, 1);
10184         name = gen_const_xmlChar_ptr(n_name, 2);
10185         prefix2 = gen_const_xmlChar_ptr(n_prefix2, 3);
10186         name2 = gen_const_xmlChar_ptr(n_name2, 4);
10187         prefix3 = gen_const_xmlChar_ptr(n_prefix3, 5);
10188         name3 = gen_const_xmlChar_ptr(n_name3, 6);
10189
10190         ret_val = xmlHashQLookup3(table, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)prefix2, (const xmlChar *)name2, (const xmlChar *)prefix3, (const xmlChar *)name3);
10191         desret_void_ptr(ret_val);
10192         call_tests++;
10193         des_xmlHashTablePtr(n_table, table, 0);
10194         des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
10195         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
10196         des_const_xmlChar_ptr(n_prefix2, (const xmlChar *)prefix2, 3);
10197         des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 4);
10198         des_const_xmlChar_ptr(n_prefix3, (const xmlChar *)prefix3, 5);
10199         des_const_xmlChar_ptr(n_name3, (const xmlChar *)name3, 6);
10200         xmlResetLastError();
10201         if (mem_base != xmlMemBlocks()) {
10202             printf("Leak of %d blocks found in xmlHashQLookup3",
10203                    xmlMemBlocks() - mem_base);
10204             test_ret++;
10205             printf(" %d", n_table);
10206             printf(" %d", n_prefix);
10207             printf(" %d", n_name);
10208             printf(" %d", n_prefix2);
10209             printf(" %d", n_name2);
10210             printf(" %d", n_prefix3);
10211             printf(" %d", n_name3);
10212             printf("\n");
10213         }
10214     }
10215     }
10216     }
10217     }
10218     }
10219     }
10220     }
10221     function_tests++;
10222
10223     return(test_ret);
10224 }
10225
10226
10227 static int
10228 test_xmlHashRemoveEntry(void) {
10229     int test_ret = 0;
10230
10231     int mem_base;
10232     int ret_val;
10233     xmlHashTablePtr table; /* the hash table */
10234     int n_table;
10235     xmlChar * name; /* the name of the userdata */
10236     int n_name;
10237     xmlHashDeallocator f; /* the deallocator function for removed item (if any) */
10238     int n_f;
10239
10240     for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10241     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10242     for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) {
10243         mem_base = xmlMemBlocks();
10244         table = gen_xmlHashTablePtr(n_table, 0);
10245         name = gen_const_xmlChar_ptr(n_name, 1);
10246         f = gen_xmlHashDeallocator(n_f, 2);
10247
10248         ret_val = xmlHashRemoveEntry(table, (const xmlChar *)name, f);
10249         desret_int(ret_val);
10250         call_tests++;
10251         des_xmlHashTablePtr(n_table, table, 0);
10252         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
10253         des_xmlHashDeallocator(n_f, f, 2);
10254         xmlResetLastError();
10255         if (mem_base != xmlMemBlocks()) {
10256             printf("Leak of %d blocks found in xmlHashRemoveEntry",
10257                    xmlMemBlocks() - mem_base);
10258             test_ret++;
10259             printf(" %d", n_table);
10260             printf(" %d", n_name);
10261             printf(" %d", n_f);
10262             printf("\n");
10263         }
10264     }
10265     }
10266     }
10267     function_tests++;
10268
10269     return(test_ret);
10270 }
10271
10272
10273 static int
10274 test_xmlHashRemoveEntry2(void) {
10275     int test_ret = 0;
10276
10277     int mem_base;
10278     int ret_val;
10279     xmlHashTablePtr table; /* the hash table */
10280     int n_table;
10281     xmlChar * name; /* the name of the userdata */
10282     int n_name;
10283     xmlChar * name2; /* a second name of the userdata */
10284     int n_name2;
10285     xmlHashDeallocator f; /* the deallocator function for removed item (if any) */
10286     int n_f;
10287
10288     for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10289     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10290     for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
10291     for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) {
10292         mem_base = xmlMemBlocks();
10293         table = gen_xmlHashTablePtr(n_table, 0);
10294         name = gen_const_xmlChar_ptr(n_name, 1);
10295         name2 = gen_const_xmlChar_ptr(n_name2, 2);
10296         f = gen_xmlHashDeallocator(n_f, 3);
10297
10298         ret_val = xmlHashRemoveEntry2(table, (const xmlChar *)name, (const xmlChar *)name2, f);
10299         desret_int(ret_val);
10300         call_tests++;
10301         des_xmlHashTablePtr(n_table, table, 0);
10302         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
10303         des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
10304         des_xmlHashDeallocator(n_f, f, 3);
10305         xmlResetLastError();
10306         if (mem_base != xmlMemBlocks()) {
10307             printf("Leak of %d blocks found in xmlHashRemoveEntry2",
10308                    xmlMemBlocks() - mem_base);
10309             test_ret++;
10310             printf(" %d", n_table);
10311             printf(" %d", n_name);
10312             printf(" %d", n_name2);
10313             printf(" %d", n_f);
10314             printf("\n");
10315         }
10316     }
10317     }
10318     }
10319     }
10320     function_tests++;
10321
10322     return(test_ret);
10323 }
10324
10325
10326 static int
10327 test_xmlHashRemoveEntry3(void) {
10328     int test_ret = 0;
10329
10330     int mem_base;
10331     int ret_val;
10332     xmlHashTablePtr table; /* the hash table */
10333     int n_table;
10334     xmlChar * name; /* the name of the userdata */
10335     int n_name;
10336     xmlChar * name2; /* a second name of the userdata */
10337     int n_name2;
10338     xmlChar * name3; /* a third name of the userdata */
10339     int n_name3;
10340     xmlHashDeallocator f; /* the deallocator function for removed item (if any) */
10341     int n_f;
10342
10343     for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10344     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10345     for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
10346     for (n_name3 = 0;n_name3 < gen_nb_const_xmlChar_ptr;n_name3++) {
10347     for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) {
10348         mem_base = xmlMemBlocks();
10349         table = gen_xmlHashTablePtr(n_table, 0);
10350         name = gen_const_xmlChar_ptr(n_name, 1);
10351         name2 = gen_const_xmlChar_ptr(n_name2, 2);
10352         name3 = gen_const_xmlChar_ptr(n_name3, 3);
10353         f = gen_xmlHashDeallocator(n_f, 4);
10354
10355         ret_val = xmlHashRemoveEntry3(table, (const xmlChar *)name, (const xmlChar *)name2, (const xmlChar *)name3, f);
10356         desret_int(ret_val);
10357         call_tests++;
10358         des_xmlHashTablePtr(n_table, table, 0);
10359         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
10360         des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
10361         des_const_xmlChar_ptr(n_name3, (const xmlChar *)name3, 3);
10362         des_xmlHashDeallocator(n_f, f, 4);
10363         xmlResetLastError();
10364         if (mem_base != xmlMemBlocks()) {
10365             printf("Leak of %d blocks found in xmlHashRemoveEntry3",
10366                    xmlMemBlocks() - mem_base);
10367             test_ret++;
10368             printf(" %d", n_table);
10369             printf(" %d", n_name);
10370             printf(" %d", n_name2);
10371             printf(" %d", n_name3);
10372             printf(" %d", n_f);
10373             printf("\n");
10374         }
10375     }
10376     }
10377     }
10378     }
10379     }
10380     function_tests++;
10381
10382     return(test_ret);
10383 }
10384
10385
10386 static int
10387 test_xmlHashScan(void) {
10388     int test_ret = 0;
10389
10390
10391     /* missing type support */
10392     return(test_ret);
10393 }
10394
10395
10396 static int
10397 test_xmlHashScan3(void) {
10398     int test_ret = 0;
10399
10400
10401     /* missing type support */
10402     return(test_ret);
10403 }
10404
10405
10406 static int
10407 test_xmlHashScanFull(void) {
10408     int test_ret = 0;
10409
10410
10411     /* missing type support */
10412     return(test_ret);
10413 }
10414
10415
10416 static int
10417 test_xmlHashScanFull3(void) {
10418     int test_ret = 0;
10419
10420
10421     /* missing type support */
10422     return(test_ret);
10423 }
10424
10425
10426 static int
10427 test_xmlHashSize(void) {
10428     int test_ret = 0;
10429
10430     int mem_base;
10431     int ret_val;
10432     xmlHashTablePtr table; /* the hash table */
10433     int n_table;
10434
10435     for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10436         mem_base = xmlMemBlocks();
10437         table = gen_xmlHashTablePtr(n_table, 0);
10438
10439         ret_val = xmlHashSize(table);
10440         desret_int(ret_val);
10441         call_tests++;
10442         des_xmlHashTablePtr(n_table, table, 0);
10443         xmlResetLastError();
10444         if (mem_base != xmlMemBlocks()) {
10445             printf("Leak of %d blocks found in xmlHashSize",
10446                    xmlMemBlocks() - mem_base);
10447             test_ret++;
10448             printf(" %d", n_table);
10449             printf("\n");
10450         }
10451     }
10452     function_tests++;
10453
10454     return(test_ret);
10455 }
10456
10457
10458 static int
10459 test_xmlHashUpdateEntry(void) {
10460     int test_ret = 0;
10461
10462     int mem_base;
10463     int ret_val;
10464     xmlHashTablePtr table; /* the hash table */
10465     int n_table;
10466     xmlChar * name; /* the name of the userdata */
10467     int n_name;
10468     void * userdata; /* a pointer to the userdata */
10469     int n_userdata;
10470     xmlHashDeallocator f; /* the deallocator function for replaced item (if any) */
10471     int n_f;
10472
10473     for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10474     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10475     for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) {
10476     for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) {
10477         mem_base = xmlMemBlocks();
10478         table = gen_xmlHashTablePtr(n_table, 0);
10479         name = gen_const_xmlChar_ptr(n_name, 1);
10480         userdata = gen_userdata(n_userdata, 2);
10481         f = gen_xmlHashDeallocator(n_f, 3);
10482
10483         ret_val = xmlHashUpdateEntry(table, (const xmlChar *)name, userdata, f);
10484         desret_int(ret_val);
10485         call_tests++;
10486         des_xmlHashTablePtr(n_table, table, 0);
10487         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
10488         des_userdata(n_userdata, userdata, 2);
10489         des_xmlHashDeallocator(n_f, f, 3);
10490         xmlResetLastError();
10491         if (mem_base != xmlMemBlocks()) {
10492             printf("Leak of %d blocks found in xmlHashUpdateEntry",
10493                    xmlMemBlocks() - mem_base);
10494             test_ret++;
10495             printf(" %d", n_table);
10496             printf(" %d", n_name);
10497             printf(" %d", n_userdata);
10498             printf(" %d", n_f);
10499             printf("\n");
10500         }
10501     }
10502     }
10503     }
10504     }
10505     function_tests++;
10506
10507     return(test_ret);
10508 }
10509
10510
10511 static int
10512 test_xmlHashUpdateEntry2(void) {
10513     int test_ret = 0;
10514
10515     int mem_base;
10516     int ret_val;
10517     xmlHashTablePtr table; /* the hash table */
10518     int n_table;
10519     xmlChar * name; /* the name of the userdata */
10520     int n_name;
10521     xmlChar * name2; /* a second name of the userdata */
10522     int n_name2;
10523     void * userdata; /* a pointer to the userdata */
10524     int n_userdata;
10525     xmlHashDeallocator f; /* the deallocator function for replaced item (if any) */
10526     int n_f;
10527
10528     for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10529     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10530     for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
10531     for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) {
10532     for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) {
10533         mem_base = xmlMemBlocks();
10534         table = gen_xmlHashTablePtr(n_table, 0);
10535         name = gen_const_xmlChar_ptr(n_name, 1);
10536         name2 = gen_const_xmlChar_ptr(n_name2, 2);
10537         userdata = gen_userdata(n_userdata, 3);
10538         f = gen_xmlHashDeallocator(n_f, 4);
10539
10540         ret_val = xmlHashUpdateEntry2(table, (const xmlChar *)name, (const xmlChar *)name2, userdata, f);
10541         desret_int(ret_val);
10542         call_tests++;
10543         des_xmlHashTablePtr(n_table, table, 0);
10544         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
10545         des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
10546         des_userdata(n_userdata, userdata, 3);
10547         des_xmlHashDeallocator(n_f, f, 4);
10548         xmlResetLastError();
10549         if (mem_base != xmlMemBlocks()) {
10550             printf("Leak of %d blocks found in xmlHashUpdateEntry2",
10551                    xmlMemBlocks() - mem_base);
10552             test_ret++;
10553             printf(" %d", n_table);
10554             printf(" %d", n_name);
10555             printf(" %d", n_name2);
10556             printf(" %d", n_userdata);
10557             printf(" %d", n_f);
10558             printf("\n");
10559         }
10560     }
10561     }
10562     }
10563     }
10564     }
10565     function_tests++;
10566
10567     return(test_ret);
10568 }
10569
10570
10571 static int
10572 test_xmlHashUpdateEntry3(void) {
10573     int test_ret = 0;
10574
10575     int mem_base;
10576     int ret_val;
10577     xmlHashTablePtr table; /* the hash table */
10578     int n_table;
10579     xmlChar * name; /* the name of the userdata */
10580     int n_name;
10581     xmlChar * name2; /* a second name of the userdata */
10582     int n_name2;
10583     xmlChar * name3; /* a third name of the userdata */
10584     int n_name3;
10585     void * userdata; /* a pointer to the userdata */
10586     int n_userdata;
10587     xmlHashDeallocator f; /* the deallocator function for replaced item (if any) */
10588     int n_f;
10589
10590     for (n_table = 0;n_table < gen_nb_xmlHashTablePtr;n_table++) {
10591     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
10592     for (n_name2 = 0;n_name2 < gen_nb_const_xmlChar_ptr;n_name2++) {
10593     for (n_name3 = 0;n_name3 < gen_nb_const_xmlChar_ptr;n_name3++) {
10594     for (n_userdata = 0;n_userdata < gen_nb_userdata;n_userdata++) {
10595     for (n_f = 0;n_f < gen_nb_xmlHashDeallocator;n_f++) {
10596         mem_base = xmlMemBlocks();
10597         table = gen_xmlHashTablePtr(n_table, 0);
10598         name = gen_const_xmlChar_ptr(n_name, 1);
10599         name2 = gen_const_xmlChar_ptr(n_name2, 2);
10600         name3 = gen_const_xmlChar_ptr(n_name3, 3);
10601         userdata = gen_userdata(n_userdata, 4);
10602         f = gen_xmlHashDeallocator(n_f, 5);
10603
10604         ret_val = xmlHashUpdateEntry3(table, (const xmlChar *)name, (const xmlChar *)name2, (const xmlChar *)name3, userdata, f);
10605         desret_int(ret_val);
10606         call_tests++;
10607         des_xmlHashTablePtr(n_table, table, 0);
10608         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
10609         des_const_xmlChar_ptr(n_name2, (const xmlChar *)name2, 2);
10610         des_const_xmlChar_ptr(n_name3, (const xmlChar *)name3, 3);
10611         des_userdata(n_userdata, userdata, 4);
10612         des_xmlHashDeallocator(n_f, f, 5);
10613         xmlResetLastError();
10614         if (mem_base != xmlMemBlocks()) {
10615             printf("Leak of %d blocks found in xmlHashUpdateEntry3",
10616                    xmlMemBlocks() - mem_base);
10617             test_ret++;
10618             printf(" %d", n_table);
10619             printf(" %d", n_name);
10620             printf(" %d", n_name2);
10621             printf(" %d", n_name3);
10622             printf(" %d", n_userdata);
10623             printf(" %d", n_f);
10624             printf("\n");
10625         }
10626     }
10627     }
10628     }
10629     }
10630     }
10631     }
10632     function_tests++;
10633
10634     return(test_ret);
10635 }
10636
10637 static int
10638 test_hash(void) {
10639     int test_ret = 0;
10640
10641     if (quiet == 0) printf("Testing hash : 16 of 24 functions ...\n");
10642     test_ret += test_xmlHashAddEntry();
10643     test_ret += test_xmlHashAddEntry2();
10644     test_ret += test_xmlHashAddEntry3();
10645     test_ret += test_xmlHashCopy();
10646     test_ret += test_xmlHashCreate();
10647     test_ret += test_xmlHashCreateDict();
10648     test_ret += test_xmlHashLookup();
10649     test_ret += test_xmlHashLookup2();
10650     test_ret += test_xmlHashLookup3();
10651     test_ret += test_xmlHashQLookup();
10652     test_ret += test_xmlHashQLookup2();
10653     test_ret += test_xmlHashQLookup3();
10654     test_ret += test_xmlHashRemoveEntry();
10655     test_ret += test_xmlHashRemoveEntry2();
10656     test_ret += test_xmlHashRemoveEntry3();
10657     test_ret += test_xmlHashScan();
10658     test_ret += test_xmlHashScan3();
10659     test_ret += test_xmlHashScanFull();
10660     test_ret += test_xmlHashScanFull3();
10661     test_ret += test_xmlHashSize();
10662     test_ret += test_xmlHashUpdateEntry();
10663     test_ret += test_xmlHashUpdateEntry2();
10664     test_ret += test_xmlHashUpdateEntry3();
10665
10666     if (test_ret != 0)
10667         printf("Module hash: %d errors\n", test_ret);
10668     return(test_ret);
10669 }
10670
10671 #define gen_nb_xmlLinkPtr 1
10672 static xmlLinkPtr gen_xmlLinkPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
10673     return(NULL);
10674 }
10675 static void des_xmlLinkPtr(int no ATTRIBUTE_UNUSED, xmlLinkPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
10676 }
10677
10678 static int
10679 test_xmlLinkGetData(void) {
10680     int test_ret = 0;
10681
10682     int mem_base;
10683     void * ret_val;
10684     xmlLinkPtr lk; /* a link */
10685     int n_lk;
10686
10687     for (n_lk = 0;n_lk < gen_nb_xmlLinkPtr;n_lk++) {
10688         mem_base = xmlMemBlocks();
10689         lk = gen_xmlLinkPtr(n_lk, 0);
10690
10691         ret_val = xmlLinkGetData(lk);
10692         desret_void_ptr(ret_val);
10693         call_tests++;
10694         des_xmlLinkPtr(n_lk, lk, 0);
10695         xmlResetLastError();
10696         if (mem_base != xmlMemBlocks()) {
10697             printf("Leak of %d blocks found in xmlLinkGetData",
10698                    xmlMemBlocks() - mem_base);
10699             test_ret++;
10700             printf(" %d", n_lk);
10701             printf("\n");
10702         }
10703     }
10704     function_tests++;
10705
10706     return(test_ret);
10707 }
10708
10709
10710 static int
10711 test_xmlListAppend(void) {
10712     int test_ret = 0;
10713
10714     int mem_base;
10715     int ret_val;
10716     xmlListPtr l; /* a list */
10717     int n_l;
10718     void * data; /* the data */
10719     int n_data;
10720
10721     for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
10722     for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
10723         mem_base = xmlMemBlocks();
10724         l = gen_xmlListPtr(n_l, 0);
10725         data = gen_userdata(n_data, 1);
10726
10727         ret_val = xmlListAppend(l, data);
10728         desret_int(ret_val);
10729         call_tests++;
10730         des_xmlListPtr(n_l, l, 0);
10731         des_userdata(n_data, data, 1);
10732         xmlResetLastError();
10733         if (mem_base != xmlMemBlocks()) {
10734             printf("Leak of %d blocks found in xmlListAppend",
10735                    xmlMemBlocks() - mem_base);
10736             test_ret++;
10737             printf(" %d", n_l);
10738             printf(" %d", n_data);
10739             printf("\n");
10740         }
10741     }
10742     }
10743     function_tests++;
10744
10745     return(test_ret);
10746 }
10747
10748
10749 static int
10750 test_xmlListClear(void) {
10751     int test_ret = 0;
10752
10753     int mem_base;
10754     xmlListPtr l; /* a list */
10755     int n_l;
10756
10757     for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
10758         mem_base = xmlMemBlocks();
10759         l = gen_xmlListPtr(n_l, 0);
10760
10761         xmlListClear(l);
10762         call_tests++;
10763         des_xmlListPtr(n_l, l, 0);
10764         xmlResetLastError();
10765         if (mem_base != xmlMemBlocks()) {
10766             printf("Leak of %d blocks found in xmlListClear",
10767                    xmlMemBlocks() - mem_base);
10768             test_ret++;
10769             printf(" %d", n_l);
10770             printf("\n");
10771         }
10772     }
10773     function_tests++;
10774
10775     return(test_ret);
10776 }
10777
10778
10779 #define gen_nb_const_xmlListPtr 1
10780 static xmlListPtr gen_const_xmlListPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
10781     return(NULL);
10782 }
10783 static void des_const_xmlListPtr(int no ATTRIBUTE_UNUSED, const xmlListPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
10784 }
10785
10786 static int
10787 test_xmlListCopy(void) {
10788     int test_ret = 0;
10789
10790     int mem_base;
10791     int ret_val;
10792     xmlListPtr cur; /* the new list */
10793     int n_cur;
10794     xmlListPtr old; /* the old list */
10795     int n_old;
10796
10797     for (n_cur = 0;n_cur < gen_nb_xmlListPtr;n_cur++) {
10798     for (n_old = 0;n_old < gen_nb_const_xmlListPtr;n_old++) {
10799         mem_base = xmlMemBlocks();
10800         cur = gen_xmlListPtr(n_cur, 0);
10801         old = gen_const_xmlListPtr(n_old, 1);
10802
10803         ret_val = xmlListCopy(cur, (const xmlListPtr)old);
10804         desret_int(ret_val);
10805         call_tests++;
10806         des_xmlListPtr(n_cur, cur, 0);
10807         des_const_xmlListPtr(n_old, (const xmlListPtr)old, 1);
10808         xmlResetLastError();
10809         if (mem_base != xmlMemBlocks()) {
10810             printf("Leak of %d blocks found in xmlListCopy",
10811                    xmlMemBlocks() - mem_base);
10812             test_ret++;
10813             printf(" %d", n_cur);
10814             printf(" %d", n_old);
10815             printf("\n");
10816         }
10817     }
10818     }
10819     function_tests++;
10820
10821     return(test_ret);
10822 }
10823
10824
10825 static int
10826 test_xmlListCreate(void) {
10827     int test_ret = 0;
10828
10829
10830     /* missing type support */
10831     return(test_ret);
10832 }
10833
10834
10835 static int
10836 test_xmlListDup(void) {
10837     int test_ret = 0;
10838
10839
10840     /* missing type support */
10841     return(test_ret);
10842 }
10843
10844
10845 static int
10846 test_xmlListEmpty(void) {
10847     int test_ret = 0;
10848
10849     int mem_base;
10850     int ret_val;
10851     xmlListPtr l; /* a list */
10852     int n_l;
10853
10854     for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
10855         mem_base = xmlMemBlocks();
10856         l = gen_xmlListPtr(n_l, 0);
10857
10858         ret_val = xmlListEmpty(l);
10859         desret_int(ret_val);
10860         call_tests++;
10861         des_xmlListPtr(n_l, l, 0);
10862         xmlResetLastError();
10863         if (mem_base != xmlMemBlocks()) {
10864             printf("Leak of %d blocks found in xmlListEmpty",
10865                    xmlMemBlocks() - mem_base);
10866             test_ret++;
10867             printf(" %d", n_l);
10868             printf("\n");
10869         }
10870     }
10871     function_tests++;
10872
10873     return(test_ret);
10874 }
10875
10876
10877 static int
10878 test_xmlListEnd(void) {
10879     int test_ret = 0;
10880
10881
10882     /* missing type support */
10883     return(test_ret);
10884 }
10885
10886
10887 static int
10888 test_xmlListFront(void) {
10889     int test_ret = 0;
10890
10891
10892     /* missing type support */
10893     return(test_ret);
10894 }
10895
10896
10897 static int
10898 test_xmlListInsert(void) {
10899     int test_ret = 0;
10900
10901     int mem_base;
10902     int ret_val;
10903     xmlListPtr l; /* a list */
10904     int n_l;
10905     void * data; /* the data */
10906     int n_data;
10907
10908     for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
10909     for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
10910         mem_base = xmlMemBlocks();
10911         l = gen_xmlListPtr(n_l, 0);
10912         data = gen_userdata(n_data, 1);
10913
10914         ret_val = xmlListInsert(l, data);
10915         desret_int(ret_val);
10916         call_tests++;
10917         des_xmlListPtr(n_l, l, 0);
10918         des_userdata(n_data, data, 1);
10919         xmlResetLastError();
10920         if (mem_base != xmlMemBlocks()) {
10921             printf("Leak of %d blocks found in xmlListInsert",
10922                    xmlMemBlocks() - mem_base);
10923             test_ret++;
10924             printf(" %d", n_l);
10925             printf(" %d", n_data);
10926             printf("\n");
10927         }
10928     }
10929     }
10930     function_tests++;
10931
10932     return(test_ret);
10933 }
10934
10935
10936 static int
10937 test_xmlListMerge(void) {
10938     int test_ret = 0;
10939
10940     int mem_base;
10941     xmlListPtr l1; /* the original list */
10942     int n_l1;
10943     xmlListPtr l2; /* the new list */
10944     int n_l2;
10945
10946     for (n_l1 = 0;n_l1 < gen_nb_xmlListPtr;n_l1++) {
10947     for (n_l2 = 0;n_l2 < gen_nb_xmlListPtr;n_l2++) {
10948         mem_base = xmlMemBlocks();
10949         l1 = gen_xmlListPtr(n_l1, 0);
10950         l2 = gen_xmlListPtr(n_l2, 1);
10951
10952         xmlListMerge(l1, l2);
10953         call_tests++;
10954         des_xmlListPtr(n_l1, l1, 0);
10955         des_xmlListPtr(n_l2, l2, 1);
10956         xmlResetLastError();
10957         if (mem_base != xmlMemBlocks()) {
10958             printf("Leak of %d blocks found in xmlListMerge",
10959                    xmlMemBlocks() - mem_base);
10960             test_ret++;
10961             printf(" %d", n_l1);
10962             printf(" %d", n_l2);
10963             printf("\n");
10964         }
10965     }
10966     }
10967     function_tests++;
10968
10969     return(test_ret);
10970 }
10971
10972
10973 static int
10974 test_xmlListPopBack(void) {
10975     int test_ret = 0;
10976
10977     int mem_base;
10978     xmlListPtr l; /* a list */
10979     int n_l;
10980
10981     for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
10982         mem_base = xmlMemBlocks();
10983         l = gen_xmlListPtr(n_l, 0);
10984
10985         xmlListPopBack(l);
10986         call_tests++;
10987         des_xmlListPtr(n_l, l, 0);
10988         xmlResetLastError();
10989         if (mem_base != xmlMemBlocks()) {
10990             printf("Leak of %d blocks found in xmlListPopBack",
10991                    xmlMemBlocks() - mem_base);
10992             test_ret++;
10993             printf(" %d", n_l);
10994             printf("\n");
10995         }
10996     }
10997     function_tests++;
10998
10999     return(test_ret);
11000 }
11001
11002
11003 static int
11004 test_xmlListPopFront(void) {
11005     int test_ret = 0;
11006
11007     int mem_base;
11008     xmlListPtr l; /* a list */
11009     int n_l;
11010
11011     for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11012         mem_base = xmlMemBlocks();
11013         l = gen_xmlListPtr(n_l, 0);
11014
11015         xmlListPopFront(l);
11016         call_tests++;
11017         des_xmlListPtr(n_l, l, 0);
11018         xmlResetLastError();
11019         if (mem_base != xmlMemBlocks()) {
11020             printf("Leak of %d blocks found in xmlListPopFront",
11021                    xmlMemBlocks() - mem_base);
11022             test_ret++;
11023             printf(" %d", n_l);
11024             printf("\n");
11025         }
11026     }
11027     function_tests++;
11028
11029     return(test_ret);
11030 }
11031
11032
11033 static int
11034 test_xmlListPushBack(void) {
11035     int test_ret = 0;
11036
11037     int mem_base;
11038     int ret_val;
11039     xmlListPtr l; /* a list */
11040     int n_l;
11041     void * data; /* new data */
11042     int n_data;
11043
11044     for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11045     for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
11046         mem_base = xmlMemBlocks();
11047         l = gen_xmlListPtr(n_l, 0);
11048         data = gen_userdata(n_data, 1);
11049
11050         ret_val = xmlListPushBack(l, data);
11051         desret_int(ret_val);
11052         call_tests++;
11053         des_xmlListPtr(n_l, l, 0);
11054         des_userdata(n_data, data, 1);
11055         xmlResetLastError();
11056         if (mem_base != xmlMemBlocks()) {
11057             printf("Leak of %d blocks found in xmlListPushBack",
11058                    xmlMemBlocks() - mem_base);
11059             test_ret++;
11060             printf(" %d", n_l);
11061             printf(" %d", n_data);
11062             printf("\n");
11063         }
11064     }
11065     }
11066     function_tests++;
11067
11068     return(test_ret);
11069 }
11070
11071
11072 static int
11073 test_xmlListPushFront(void) {
11074     int test_ret = 0;
11075
11076     int mem_base;
11077     int ret_val;
11078     xmlListPtr l; /* a list */
11079     int n_l;
11080     void * data; /* new data */
11081     int n_data;
11082
11083     for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11084     for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
11085         mem_base = xmlMemBlocks();
11086         l = gen_xmlListPtr(n_l, 0);
11087         data = gen_userdata(n_data, 1);
11088
11089         ret_val = xmlListPushFront(l, data);
11090         desret_int(ret_val);
11091         call_tests++;
11092         des_xmlListPtr(n_l, l, 0);
11093         des_userdata(n_data, data, 1);
11094         xmlResetLastError();
11095         if (mem_base != xmlMemBlocks()) {
11096             printf("Leak of %d blocks found in xmlListPushFront",
11097                    xmlMemBlocks() - mem_base);
11098             test_ret++;
11099             printf(" %d", n_l);
11100             printf(" %d", n_data);
11101             printf("\n");
11102         }
11103     }
11104     }
11105     function_tests++;
11106
11107     return(test_ret);
11108 }
11109
11110
11111 static int
11112 test_xmlListRemoveAll(void) {
11113     int test_ret = 0;
11114
11115     int mem_base;
11116     int ret_val;
11117     xmlListPtr l; /* a list */
11118     int n_l;
11119     void * data; /* list data */
11120     int n_data;
11121
11122     for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11123     for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
11124         mem_base = xmlMemBlocks();
11125         l = gen_xmlListPtr(n_l, 0);
11126         data = gen_userdata(n_data, 1);
11127
11128         ret_val = xmlListRemoveAll(l, data);
11129         desret_int(ret_val);
11130         call_tests++;
11131         des_xmlListPtr(n_l, l, 0);
11132         des_userdata(n_data, data, 1);
11133         xmlResetLastError();
11134         if (mem_base != xmlMemBlocks()) {
11135             printf("Leak of %d blocks found in xmlListRemoveAll",
11136                    xmlMemBlocks() - mem_base);
11137             test_ret++;
11138             printf(" %d", n_l);
11139             printf(" %d", n_data);
11140             printf("\n");
11141         }
11142     }
11143     }
11144     function_tests++;
11145
11146     return(test_ret);
11147 }
11148
11149
11150 static int
11151 test_xmlListRemoveFirst(void) {
11152     int test_ret = 0;
11153
11154     int mem_base;
11155     int ret_val;
11156     xmlListPtr l; /* a list */
11157     int n_l;
11158     void * data; /* list data */
11159     int n_data;
11160
11161     for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11162     for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
11163         mem_base = xmlMemBlocks();
11164         l = gen_xmlListPtr(n_l, 0);
11165         data = gen_userdata(n_data, 1);
11166
11167         ret_val = xmlListRemoveFirst(l, data);
11168         desret_int(ret_val);
11169         call_tests++;
11170         des_xmlListPtr(n_l, l, 0);
11171         des_userdata(n_data, data, 1);
11172         xmlResetLastError();
11173         if (mem_base != xmlMemBlocks()) {
11174             printf("Leak of %d blocks found in xmlListRemoveFirst",
11175                    xmlMemBlocks() - mem_base);
11176             test_ret++;
11177             printf(" %d", n_l);
11178             printf(" %d", n_data);
11179             printf("\n");
11180         }
11181     }
11182     }
11183     function_tests++;
11184
11185     return(test_ret);
11186 }
11187
11188
11189 static int
11190 test_xmlListRemoveLast(void) {
11191     int test_ret = 0;
11192
11193     int mem_base;
11194     int ret_val;
11195     xmlListPtr l; /* a list */
11196     int n_l;
11197     void * data; /* list data */
11198     int n_data;
11199
11200     for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11201     for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
11202         mem_base = xmlMemBlocks();
11203         l = gen_xmlListPtr(n_l, 0);
11204         data = gen_userdata(n_data, 1);
11205
11206         ret_val = xmlListRemoveLast(l, data);
11207         desret_int(ret_val);
11208         call_tests++;
11209         des_xmlListPtr(n_l, l, 0);
11210         des_userdata(n_data, data, 1);
11211         xmlResetLastError();
11212         if (mem_base != xmlMemBlocks()) {
11213             printf("Leak of %d blocks found in xmlListRemoveLast",
11214                    xmlMemBlocks() - mem_base);
11215             test_ret++;
11216             printf(" %d", n_l);
11217             printf(" %d", n_data);
11218             printf("\n");
11219         }
11220     }
11221     }
11222     function_tests++;
11223
11224     return(test_ret);
11225 }
11226
11227
11228 static int
11229 test_xmlListReverse(void) {
11230     int test_ret = 0;
11231
11232     int mem_base;
11233     xmlListPtr l; /* a list */
11234     int n_l;
11235
11236     for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11237         mem_base = xmlMemBlocks();
11238         l = gen_xmlListPtr(n_l, 0);
11239
11240         xmlListReverse(l);
11241         call_tests++;
11242         des_xmlListPtr(n_l, l, 0);
11243         xmlResetLastError();
11244         if (mem_base != xmlMemBlocks()) {
11245             printf("Leak of %d blocks found in xmlListReverse",
11246                    xmlMemBlocks() - mem_base);
11247             test_ret++;
11248             printf(" %d", n_l);
11249             printf("\n");
11250         }
11251     }
11252     function_tests++;
11253
11254     return(test_ret);
11255 }
11256
11257
11258 static int
11259 test_xmlListReverseSearch(void) {
11260     int test_ret = 0;
11261
11262     int mem_base;
11263     void * ret_val;
11264     xmlListPtr l; /* a list */
11265     int n_l;
11266     void * data; /* a search value */
11267     int n_data;
11268
11269     for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11270     for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
11271         mem_base = xmlMemBlocks();
11272         l = gen_xmlListPtr(n_l, 0);
11273         data = gen_userdata(n_data, 1);
11274
11275         ret_val = xmlListReverseSearch(l, data);
11276         desret_void_ptr(ret_val);
11277         call_tests++;
11278         des_xmlListPtr(n_l, l, 0);
11279         des_userdata(n_data, data, 1);
11280         xmlResetLastError();
11281         if (mem_base != xmlMemBlocks()) {
11282             printf("Leak of %d blocks found in xmlListReverseSearch",
11283                    xmlMemBlocks() - mem_base);
11284             test_ret++;
11285             printf(" %d", n_l);
11286             printf(" %d", n_data);
11287             printf("\n");
11288         }
11289     }
11290     }
11291     function_tests++;
11292
11293     return(test_ret);
11294 }
11295
11296
11297 static int
11298 test_xmlListReverseWalk(void) {
11299     int test_ret = 0;
11300
11301
11302     /* missing type support */
11303     return(test_ret);
11304 }
11305
11306
11307 static int
11308 test_xmlListSearch(void) {
11309     int test_ret = 0;
11310
11311     int mem_base;
11312     void * ret_val;
11313     xmlListPtr l; /* a list */
11314     int n_l;
11315     void * data; /* a search value */
11316     int n_data;
11317
11318     for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11319     for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
11320         mem_base = xmlMemBlocks();
11321         l = gen_xmlListPtr(n_l, 0);
11322         data = gen_userdata(n_data, 1);
11323
11324         ret_val = xmlListSearch(l, data);
11325         desret_void_ptr(ret_val);
11326         call_tests++;
11327         des_xmlListPtr(n_l, l, 0);
11328         des_userdata(n_data, data, 1);
11329         xmlResetLastError();
11330         if (mem_base != xmlMemBlocks()) {
11331             printf("Leak of %d blocks found in xmlListSearch",
11332                    xmlMemBlocks() - mem_base);
11333             test_ret++;
11334             printf(" %d", n_l);
11335             printf(" %d", n_data);
11336             printf("\n");
11337         }
11338     }
11339     }
11340     function_tests++;
11341
11342     return(test_ret);
11343 }
11344
11345
11346 static int
11347 test_xmlListSize(void) {
11348     int test_ret = 0;
11349
11350     int mem_base;
11351     int ret_val;
11352     xmlListPtr l; /* a list */
11353     int n_l;
11354
11355     for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11356         mem_base = xmlMemBlocks();
11357         l = gen_xmlListPtr(n_l, 0);
11358
11359         ret_val = xmlListSize(l);
11360         desret_int(ret_val);
11361         call_tests++;
11362         des_xmlListPtr(n_l, l, 0);
11363         xmlResetLastError();
11364         if (mem_base != xmlMemBlocks()) {
11365             printf("Leak of %d blocks found in xmlListSize",
11366                    xmlMemBlocks() - mem_base);
11367             test_ret++;
11368             printf(" %d", n_l);
11369             printf("\n");
11370         }
11371     }
11372     function_tests++;
11373
11374     return(test_ret);
11375 }
11376
11377
11378 static int
11379 test_xmlListSort(void) {
11380     int test_ret = 0;
11381
11382     int mem_base;
11383     xmlListPtr l; /* a list */
11384     int n_l;
11385
11386     for (n_l = 0;n_l < gen_nb_xmlListPtr;n_l++) {
11387         mem_base = xmlMemBlocks();
11388         l = gen_xmlListPtr(n_l, 0);
11389
11390         xmlListSort(l);
11391         call_tests++;
11392         des_xmlListPtr(n_l, l, 0);
11393         xmlResetLastError();
11394         if (mem_base != xmlMemBlocks()) {
11395             printf("Leak of %d blocks found in xmlListSort",
11396                    xmlMemBlocks() - mem_base);
11397             test_ret++;
11398             printf(" %d", n_l);
11399             printf("\n");
11400         }
11401     }
11402     function_tests++;
11403
11404     return(test_ret);
11405 }
11406
11407
11408 static int
11409 test_xmlListWalk(void) {
11410     int test_ret = 0;
11411
11412
11413     /* missing type support */
11414     return(test_ret);
11415 }
11416
11417 static int
11418 test_list(void) {
11419     int test_ret = 0;
11420
11421     if (quiet == 0) printf("Testing list : 19 of 26 functions ...\n");
11422     test_ret += test_xmlLinkGetData();
11423     test_ret += test_xmlListAppend();
11424     test_ret += test_xmlListClear();
11425     test_ret += test_xmlListCopy();
11426     test_ret += test_xmlListCreate();
11427     test_ret += test_xmlListDup();
11428     test_ret += test_xmlListEmpty();
11429     test_ret += test_xmlListEnd();
11430     test_ret += test_xmlListFront();
11431     test_ret += test_xmlListInsert();
11432     test_ret += test_xmlListMerge();
11433     test_ret += test_xmlListPopBack();
11434     test_ret += test_xmlListPopFront();
11435     test_ret += test_xmlListPushBack();
11436     test_ret += test_xmlListPushFront();
11437     test_ret += test_xmlListRemoveAll();
11438     test_ret += test_xmlListRemoveFirst();
11439     test_ret += test_xmlListRemoveLast();
11440     test_ret += test_xmlListReverse();
11441     test_ret += test_xmlListReverseSearch();
11442     test_ret += test_xmlListReverseWalk();
11443     test_ret += test_xmlListSearch();
11444     test_ret += test_xmlListSize();
11445     test_ret += test_xmlListSort();
11446     test_ret += test_xmlListWalk();
11447
11448     if (test_ret != 0)
11449         printf("Module list: %d errors\n", test_ret);
11450     return(test_ret);
11451 }
11452
11453 static int
11454 test_xmlNanoFTPCheckResponse(void) {
11455     int test_ret = 0;
11456
11457 #if defined(LIBXML_FTP_ENABLED)
11458     int mem_base;
11459     int ret_val;
11460     void * ctx; /* an FTP context */
11461     int n_ctx;
11462
11463     for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
11464         mem_base = xmlMemBlocks();
11465         ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
11466
11467         ret_val = xmlNanoFTPCheckResponse(ctx);
11468         desret_int(ret_val);
11469         call_tests++;
11470         des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
11471         xmlResetLastError();
11472         if (mem_base != xmlMemBlocks()) {
11473             printf("Leak of %d blocks found in xmlNanoFTPCheckResponse",
11474                    xmlMemBlocks() - mem_base);
11475             test_ret++;
11476             printf(" %d", n_ctx);
11477             printf("\n");
11478         }
11479     }
11480     function_tests++;
11481 #endif
11482
11483     return(test_ret);
11484 }
11485
11486
11487 static int
11488 test_xmlNanoFTPCleanup(void) {
11489     int test_ret = 0;
11490
11491 #if defined(LIBXML_FTP_ENABLED)
11492     int mem_base;
11493
11494         mem_base = xmlMemBlocks();
11495
11496         xmlNanoFTPCleanup();
11497         call_tests++;
11498         xmlResetLastError();
11499         if (mem_base != xmlMemBlocks()) {
11500             printf("Leak of %d blocks found in xmlNanoFTPCleanup",
11501                    xmlMemBlocks() - mem_base);
11502             test_ret++;
11503             printf("\n");
11504         }
11505     function_tests++;
11506 #endif
11507
11508     return(test_ret);
11509 }
11510
11511
11512 static int
11513 test_xmlNanoFTPCloseConnection(void) {
11514     int test_ret = 0;
11515
11516 #if defined(LIBXML_FTP_ENABLED)
11517     int mem_base;
11518     int ret_val;
11519     void * ctx; /* an FTP context */
11520     int n_ctx;
11521
11522     for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
11523         mem_base = xmlMemBlocks();
11524         ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
11525
11526         ret_val = xmlNanoFTPCloseConnection(ctx);
11527         desret_int(ret_val);
11528         call_tests++;
11529         des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
11530         xmlResetLastError();
11531         if (mem_base != xmlMemBlocks()) {
11532             printf("Leak of %d blocks found in xmlNanoFTPCloseConnection",
11533                    xmlMemBlocks() - mem_base);
11534             test_ret++;
11535             printf(" %d", n_ctx);
11536             printf("\n");
11537         }
11538     }
11539     function_tests++;
11540 #endif
11541
11542     return(test_ret);
11543 }
11544
11545
11546 static int
11547 test_xmlNanoFTPCwd(void) {
11548     int test_ret = 0;
11549
11550 #if defined(LIBXML_FTP_ENABLED)
11551     int mem_base;
11552     int ret_val;
11553     void * ctx; /* an FTP context */
11554     int n_ctx;
11555     char * directory; /* a directory on the server */
11556     int n_directory;
11557
11558     for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
11559     for (n_directory = 0;n_directory < gen_nb_const_char_ptr;n_directory++) {
11560         mem_base = xmlMemBlocks();
11561         ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
11562         directory = gen_const_char_ptr(n_directory, 1);
11563
11564         ret_val = xmlNanoFTPCwd(ctx, (const char *)directory);
11565         desret_int(ret_val);
11566         call_tests++;
11567         des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
11568         des_const_char_ptr(n_directory, (const char *)directory, 1);
11569         xmlResetLastError();
11570         if (mem_base != xmlMemBlocks()) {
11571             printf("Leak of %d blocks found in xmlNanoFTPCwd",
11572                    xmlMemBlocks() - mem_base);
11573             test_ret++;
11574             printf(" %d", n_ctx);
11575             printf(" %d", n_directory);
11576             printf("\n");
11577         }
11578     }
11579     }
11580     function_tests++;
11581 #endif
11582
11583     return(test_ret);
11584 }
11585
11586
11587 static int
11588 test_xmlNanoFTPDele(void) {
11589     int test_ret = 0;
11590
11591 #if defined(LIBXML_FTP_ENABLED)
11592     int mem_base;
11593     int ret_val;
11594     void * ctx; /* an FTP context */
11595     int n_ctx;
11596     const char * file; /* a file or directory on the server */
11597     int n_file;
11598
11599     for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
11600     for (n_file = 0;n_file < gen_nb_filepath;n_file++) {
11601         mem_base = xmlMemBlocks();
11602         ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
11603         file = gen_filepath(n_file, 1);
11604
11605         ret_val = xmlNanoFTPDele(ctx, file);
11606         desret_int(ret_val);
11607         call_tests++;
11608         des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
11609         des_filepath(n_file, file, 1);
11610         xmlResetLastError();
11611         if (mem_base != xmlMemBlocks()) {
11612             printf("Leak of %d blocks found in xmlNanoFTPDele",
11613                    xmlMemBlocks() - mem_base);
11614             test_ret++;
11615             printf(" %d", n_ctx);
11616             printf(" %d", n_file);
11617             printf("\n");
11618         }
11619     }
11620     }
11621     function_tests++;
11622 #endif
11623
11624     return(test_ret);
11625 }
11626
11627
11628 static int
11629 test_xmlNanoFTPGet(void) {
11630     int test_ret = 0;
11631
11632
11633     /* missing type support */
11634     return(test_ret);
11635 }
11636
11637
11638 static int
11639 test_xmlNanoFTPGetConnection(void) {
11640     int test_ret = 0;
11641
11642 #if defined(LIBXML_FTP_ENABLED)
11643     int mem_base;
11644     int ret_val;
11645     void * ctx; /* an FTP context */
11646     int n_ctx;
11647
11648     for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
11649         mem_base = xmlMemBlocks();
11650         ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
11651
11652         ret_val = xmlNanoFTPGetConnection(ctx);
11653         desret_int(ret_val);
11654         call_tests++;
11655         des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
11656         xmlResetLastError();
11657         if (mem_base != xmlMemBlocks()) {
11658             printf("Leak of %d blocks found in xmlNanoFTPGetConnection",
11659                    xmlMemBlocks() - mem_base);
11660             test_ret++;
11661             printf(" %d", n_ctx);
11662             printf("\n");
11663         }
11664     }
11665     function_tests++;
11666 #endif
11667
11668     return(test_ret);
11669 }
11670
11671
11672 static int
11673 test_xmlNanoFTPGetResponse(void) {
11674     int test_ret = 0;
11675
11676 #if defined(LIBXML_FTP_ENABLED)
11677     int mem_base;
11678     int ret_val;
11679     void * ctx; /* an FTP context */
11680     int n_ctx;
11681
11682     for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
11683         mem_base = xmlMemBlocks();
11684         ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
11685
11686         ret_val = xmlNanoFTPGetResponse(ctx);
11687         desret_int(ret_val);
11688         call_tests++;
11689         des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
11690         xmlResetLastError();
11691         if (mem_base != xmlMemBlocks()) {
11692             printf("Leak of %d blocks found in xmlNanoFTPGetResponse",
11693                    xmlMemBlocks() - mem_base);
11694             test_ret++;
11695             printf(" %d", n_ctx);
11696             printf("\n");
11697         }
11698     }
11699     function_tests++;
11700 #endif
11701
11702     return(test_ret);
11703 }
11704
11705
11706 static int
11707 test_xmlNanoFTPGetSocket(void) {
11708     int test_ret = 0;
11709
11710 #if defined(LIBXML_FTP_ENABLED)
11711     int mem_base;
11712     int ret_val;
11713     void * ctx; /* an FTP context */
11714     int n_ctx;
11715     const char * filename; /* the file to retrieve (or NULL if path is in context). */
11716     int n_filename;
11717
11718     for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
11719     for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
11720         mem_base = xmlMemBlocks();
11721         ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
11722         filename = gen_filepath(n_filename, 1);
11723
11724         ret_val = xmlNanoFTPGetSocket(ctx, filename);
11725         desret_int(ret_val);
11726         call_tests++;
11727         des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
11728         des_filepath(n_filename, filename, 1);
11729         xmlResetLastError();
11730         if (mem_base != xmlMemBlocks()) {
11731             printf("Leak of %d blocks found in xmlNanoFTPGetSocket",
11732                    xmlMemBlocks() - mem_base);
11733             test_ret++;
11734             printf(" %d", n_ctx);
11735             printf(" %d", n_filename);
11736             printf("\n");
11737         }
11738     }
11739     }
11740     function_tests++;
11741 #endif
11742
11743     return(test_ret);
11744 }
11745
11746
11747 static int
11748 test_xmlNanoFTPInit(void) {
11749     int test_ret = 0;
11750
11751 #if defined(LIBXML_FTP_ENABLED)
11752     int mem_base;
11753
11754         mem_base = xmlMemBlocks();
11755
11756         xmlNanoFTPInit();
11757         call_tests++;
11758         xmlResetLastError();
11759         if (mem_base != xmlMemBlocks()) {
11760             printf("Leak of %d blocks found in xmlNanoFTPInit",
11761                    xmlMemBlocks() - mem_base);
11762             test_ret++;
11763             printf("\n");
11764         }
11765     function_tests++;
11766 #endif
11767
11768     return(test_ret);
11769 }
11770
11771
11772 static int
11773 test_xmlNanoFTPList(void) {
11774     int test_ret = 0;
11775
11776
11777     /* missing type support */
11778     return(test_ret);
11779 }
11780
11781
11782 static int
11783 test_xmlNanoFTPNewCtxt(void) {
11784     int test_ret = 0;
11785
11786 #if defined(LIBXML_FTP_ENABLED)
11787     int mem_base;
11788     void * ret_val;
11789     const char * URL; /* The URL used to initialize the context */
11790     int n_URL;
11791
11792     for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
11793         mem_base = xmlMemBlocks();
11794         URL = gen_filepath(n_URL, 0);
11795
11796         ret_val = xmlNanoFTPNewCtxt(URL);
11797         desret_xmlNanoFTPCtxtPtr(ret_val);
11798         call_tests++;
11799         des_filepath(n_URL, URL, 0);
11800         xmlResetLastError();
11801         if (mem_base != xmlMemBlocks()) {
11802             printf("Leak of %d blocks found in xmlNanoFTPNewCtxt",
11803                    xmlMemBlocks() - mem_base);
11804             test_ret++;
11805             printf(" %d", n_URL);
11806             printf("\n");
11807         }
11808     }
11809     function_tests++;
11810 #endif
11811
11812     return(test_ret);
11813 }
11814
11815
11816 static int
11817 test_xmlNanoFTPOpen(void) {
11818     int test_ret = 0;
11819
11820 #if defined(LIBXML_FTP_ENABLED)
11821     int mem_base;
11822     void * ret_val;
11823     const char * URL; /* the URL to the resource */
11824     int n_URL;
11825
11826     for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
11827         mem_base = xmlMemBlocks();
11828         URL = gen_filepath(n_URL, 0);
11829
11830         ret_val = xmlNanoFTPOpen(URL);
11831         desret_xmlNanoFTPCtxtPtr(ret_val);
11832         call_tests++;
11833         des_filepath(n_URL, URL, 0);
11834         xmlResetLastError();
11835         if (mem_base != xmlMemBlocks()) {
11836             printf("Leak of %d blocks found in xmlNanoFTPOpen",
11837                    xmlMemBlocks() - mem_base);
11838             test_ret++;
11839             printf(" %d", n_URL);
11840             printf("\n");
11841         }
11842     }
11843     function_tests++;
11844 #endif
11845
11846     return(test_ret);
11847 }
11848
11849
11850 static int
11851 test_xmlNanoFTPProxy(void) {
11852     int test_ret = 0;
11853
11854 #if defined(LIBXML_FTP_ENABLED)
11855     char * host; /* the proxy host name */
11856     int n_host;
11857     int port; /* the proxy port */
11858     int n_port;
11859     char * user; /* the proxy user name */
11860     int n_user;
11861     char * passwd; /* the proxy password */
11862     int n_passwd;
11863     int type; /* the type of proxy 1 for using SITE, 2 for USER a@b */
11864     int n_type;
11865
11866     for (n_host = 0;n_host < gen_nb_const_char_ptr;n_host++) {
11867     for (n_port = 0;n_port < gen_nb_int;n_port++) {
11868     for (n_user = 0;n_user < gen_nb_const_char_ptr;n_user++) {
11869     for (n_passwd = 0;n_passwd < gen_nb_const_char_ptr;n_passwd++) {
11870     for (n_type = 0;n_type < gen_nb_int;n_type++) {
11871         host = gen_const_char_ptr(n_host, 0);
11872         port = gen_int(n_port, 1);
11873         user = gen_const_char_ptr(n_user, 2);
11874         passwd = gen_const_char_ptr(n_passwd, 3);
11875         type = gen_int(n_type, 4);
11876
11877         xmlNanoFTPProxy((const char *)host, port, (const char *)user, (const char *)passwd, type);
11878         call_tests++;
11879         des_const_char_ptr(n_host, (const char *)host, 0);
11880         des_int(n_port, port, 1);
11881         des_const_char_ptr(n_user, (const char *)user, 2);
11882         des_const_char_ptr(n_passwd, (const char *)passwd, 3);
11883         des_int(n_type, type, 4);
11884         xmlResetLastError();
11885     }
11886     }
11887     }
11888     }
11889     }
11890     function_tests++;
11891 #endif
11892
11893     return(test_ret);
11894 }
11895
11896
11897 static int
11898 test_xmlNanoFTPQuit(void) {
11899     int test_ret = 0;
11900
11901 #if defined(LIBXML_FTP_ENABLED)
11902     int mem_base;
11903     int ret_val;
11904     void * ctx; /* an FTP context */
11905     int n_ctx;
11906
11907     for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
11908         mem_base = xmlMemBlocks();
11909         ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
11910
11911         ret_val = xmlNanoFTPQuit(ctx);
11912         desret_int(ret_val);
11913         call_tests++;
11914         des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
11915         xmlResetLastError();
11916         if (mem_base != xmlMemBlocks()) {
11917             printf("Leak of %d blocks found in xmlNanoFTPQuit",
11918                    xmlMemBlocks() - mem_base);
11919             test_ret++;
11920             printf(" %d", n_ctx);
11921             printf("\n");
11922         }
11923     }
11924     function_tests++;
11925 #endif
11926
11927     return(test_ret);
11928 }
11929
11930
11931 static int
11932 test_xmlNanoFTPRead(void) {
11933     int test_ret = 0;
11934
11935 #if defined(LIBXML_FTP_ENABLED)
11936     int mem_base;
11937     int ret_val;
11938     void * ctx; /* the FTP context */
11939     int n_ctx;
11940     void * dest; /* a buffer */
11941     int n_dest;
11942     int len; /* the buffer length */
11943     int n_len;
11944
11945     for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
11946     for (n_dest = 0;n_dest < gen_nb_void_ptr;n_dest++) {
11947     for (n_len = 0;n_len < gen_nb_int;n_len++) {
11948         mem_base = xmlMemBlocks();
11949         ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
11950         dest = gen_void_ptr(n_dest, 1);
11951         len = gen_int(n_len, 2);
11952
11953         ret_val = xmlNanoFTPRead(ctx, dest, len);
11954         desret_int(ret_val);
11955         call_tests++;
11956         des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
11957         des_void_ptr(n_dest, dest, 1);
11958         des_int(n_len, len, 2);
11959         xmlResetLastError();
11960         if (mem_base != xmlMemBlocks()) {
11961             printf("Leak of %d blocks found in xmlNanoFTPRead",
11962                    xmlMemBlocks() - mem_base);
11963             test_ret++;
11964             printf(" %d", n_ctx);
11965             printf(" %d", n_dest);
11966             printf(" %d", n_len);
11967             printf("\n");
11968         }
11969     }
11970     }
11971     }
11972     function_tests++;
11973 #endif
11974
11975     return(test_ret);
11976 }
11977
11978
11979 static int
11980 test_xmlNanoFTPScanProxy(void) {
11981     int test_ret = 0;
11982
11983 #if defined(LIBXML_FTP_ENABLED)
11984     const char * URL; /* The proxy URL used to initialize the proxy context */
11985     int n_URL;
11986
11987     for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
11988         URL = gen_filepath(n_URL, 0);
11989
11990         xmlNanoFTPScanProxy(URL);
11991         call_tests++;
11992         des_filepath(n_URL, URL, 0);
11993         xmlResetLastError();
11994     }
11995     function_tests++;
11996 #endif
11997
11998     return(test_ret);
11999 }
12000
12001
12002 static int
12003 test_xmlNanoFTPUpdateURL(void) {
12004     int test_ret = 0;
12005
12006 #if defined(LIBXML_FTP_ENABLED)
12007     int mem_base;
12008     int ret_val;
12009     void * ctx; /* an FTP context */
12010     int n_ctx;
12011     const char * URL; /* The URL used to update the context */
12012     int n_URL;
12013
12014     for (n_ctx = 0;n_ctx < gen_nb_xmlNanoFTPCtxtPtr;n_ctx++) {
12015     for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
12016         mem_base = xmlMemBlocks();
12017         ctx = gen_xmlNanoFTPCtxtPtr(n_ctx, 0);
12018         URL = gen_filepath(n_URL, 1);
12019
12020         ret_val = xmlNanoFTPUpdateURL(ctx, URL);
12021         desret_int(ret_val);
12022         call_tests++;
12023         des_xmlNanoFTPCtxtPtr(n_ctx, ctx, 0);
12024         des_filepath(n_URL, URL, 1);
12025         xmlResetLastError();
12026         if (mem_base != xmlMemBlocks()) {
12027             printf("Leak of %d blocks found in xmlNanoFTPUpdateURL",
12028                    xmlMemBlocks() - mem_base);
12029             test_ret++;
12030             printf(" %d", n_ctx);
12031             printf(" %d", n_URL);
12032             printf("\n");
12033         }
12034     }
12035     }
12036     function_tests++;
12037 #endif
12038
12039     return(test_ret);
12040 }
12041
12042 static int
12043 test_nanoftp(void) {
12044     int test_ret = 0;
12045
12046     if (quiet == 0) printf("Testing nanoftp : 16 of 22 functions ...\n");
12047     test_ret += test_xmlNanoFTPCheckResponse();
12048     test_ret += test_xmlNanoFTPCleanup();
12049     test_ret += test_xmlNanoFTPCloseConnection();
12050     test_ret += test_xmlNanoFTPCwd();
12051     test_ret += test_xmlNanoFTPDele();
12052     test_ret += test_xmlNanoFTPGet();
12053     test_ret += test_xmlNanoFTPGetConnection();
12054     test_ret += test_xmlNanoFTPGetResponse();
12055     test_ret += test_xmlNanoFTPGetSocket();
12056     test_ret += test_xmlNanoFTPInit();
12057     test_ret += test_xmlNanoFTPList();
12058     test_ret += test_xmlNanoFTPNewCtxt();
12059     test_ret += test_xmlNanoFTPOpen();
12060     test_ret += test_xmlNanoFTPProxy();
12061     test_ret += test_xmlNanoFTPQuit();
12062     test_ret += test_xmlNanoFTPRead();
12063     test_ret += test_xmlNanoFTPScanProxy();
12064     test_ret += test_xmlNanoFTPUpdateURL();
12065
12066     if (test_ret != 0)
12067         printf("Module nanoftp: %d errors\n", test_ret);
12068     return(test_ret);
12069 }
12070
12071 static int
12072 test_xmlNanoHTTPAuthHeader(void) {
12073     int test_ret = 0;
12074
12075 #if defined(LIBXML_HTTP_ENABLED)
12076     int mem_base;
12077     const char * ret_val;
12078     void * ctx; /* the HTTP context */
12079     int n_ctx;
12080
12081     for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
12082         mem_base = xmlMemBlocks();
12083         ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
12084
12085         ret_val = xmlNanoHTTPAuthHeader(ctx);
12086         desret_const_char_ptr(ret_val);
12087         call_tests++;
12088         des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
12089         xmlResetLastError();
12090         if (mem_base != xmlMemBlocks()) {
12091             printf("Leak of %d blocks found in xmlNanoHTTPAuthHeader",
12092                    xmlMemBlocks() - mem_base);
12093             test_ret++;
12094             printf(" %d", n_ctx);
12095             printf("\n");
12096         }
12097     }
12098     function_tests++;
12099 #endif
12100
12101     return(test_ret);
12102 }
12103
12104
12105 static int
12106 test_xmlNanoHTTPCleanup(void) {
12107     int test_ret = 0;
12108
12109 #if defined(LIBXML_HTTP_ENABLED)
12110     int mem_base;
12111
12112         mem_base = xmlMemBlocks();
12113
12114         xmlNanoHTTPCleanup();
12115         call_tests++;
12116         xmlResetLastError();
12117         if (mem_base != xmlMemBlocks()) {
12118             printf("Leak of %d blocks found in xmlNanoHTTPCleanup",
12119                    xmlMemBlocks() - mem_base);
12120             test_ret++;
12121             printf("\n");
12122         }
12123     function_tests++;
12124 #endif
12125
12126     return(test_ret);
12127 }
12128
12129
12130 static int
12131 test_xmlNanoHTTPContentLength(void) {
12132     int test_ret = 0;
12133
12134 #if defined(LIBXML_HTTP_ENABLED)
12135     int mem_base;
12136     int ret_val;
12137     void * ctx; /* the HTTP context */
12138     int n_ctx;
12139
12140     for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
12141         mem_base = xmlMemBlocks();
12142         ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
12143
12144         ret_val = xmlNanoHTTPContentLength(ctx);
12145         desret_int(ret_val);
12146         call_tests++;
12147         des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
12148         xmlResetLastError();
12149         if (mem_base != xmlMemBlocks()) {
12150             printf("Leak of %d blocks found in xmlNanoHTTPContentLength",
12151                    xmlMemBlocks() - mem_base);
12152             test_ret++;
12153             printf(" %d", n_ctx);
12154             printf("\n");
12155         }
12156     }
12157     function_tests++;
12158 #endif
12159
12160     return(test_ret);
12161 }
12162
12163
12164 static int
12165 test_xmlNanoHTTPEncoding(void) {
12166     int test_ret = 0;
12167
12168 #if defined(LIBXML_HTTP_ENABLED)
12169     int mem_base;
12170     const char * ret_val;
12171     void * ctx; /* the HTTP context */
12172     int n_ctx;
12173
12174     for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
12175         mem_base = xmlMemBlocks();
12176         ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
12177
12178         ret_val = xmlNanoHTTPEncoding(ctx);
12179         desret_const_char_ptr(ret_val);
12180         call_tests++;
12181         des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
12182         xmlResetLastError();
12183         if (mem_base != xmlMemBlocks()) {
12184             printf("Leak of %d blocks found in xmlNanoHTTPEncoding",
12185                    xmlMemBlocks() - mem_base);
12186             test_ret++;
12187             printf(" %d", n_ctx);
12188             printf("\n");
12189         }
12190     }
12191     function_tests++;
12192 #endif
12193
12194     return(test_ret);
12195 }
12196
12197
12198 #define gen_nb_char_ptr_ptr 1
12199 static char ** gen_char_ptr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
12200     return(NULL);
12201 }
12202 static void des_char_ptr_ptr(int no ATTRIBUTE_UNUSED, char ** val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
12203 }
12204
12205 static int
12206 test_xmlNanoHTTPFetch(void) {
12207     int test_ret = 0;
12208
12209 #if defined(LIBXML_HTTP_ENABLED)
12210     int mem_base;
12211     int ret_val;
12212     const char * URL; /* The URL to load */
12213     int n_URL;
12214     const char * filename; /* the filename where the content should be saved */
12215     int n_filename;
12216     char ** contentType; /* if available the Content-Type information will be returned at that location */
12217     int n_contentType;
12218
12219     for (n_URL = 0;n_URL < gen_nb_fileoutput;n_URL++) {
12220     for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
12221     for (n_contentType = 0;n_contentType < gen_nb_char_ptr_ptr;n_contentType++) {
12222         mem_base = xmlMemBlocks();
12223         URL = gen_fileoutput(n_URL, 0);
12224         filename = gen_fileoutput(n_filename, 1);
12225         contentType = gen_char_ptr_ptr(n_contentType, 2);
12226
12227         ret_val = xmlNanoHTTPFetch(URL, filename, contentType);
12228         desret_int(ret_val);
12229         call_tests++;
12230         des_fileoutput(n_URL, URL, 0);
12231         des_fileoutput(n_filename, filename, 1);
12232         des_char_ptr_ptr(n_contentType, contentType, 2);
12233         xmlResetLastError();
12234         if (mem_base != xmlMemBlocks()) {
12235             printf("Leak of %d blocks found in xmlNanoHTTPFetch",
12236                    xmlMemBlocks() - mem_base);
12237             test_ret++;
12238             printf(" %d", n_URL);
12239             printf(" %d", n_filename);
12240             printf(" %d", n_contentType);
12241             printf("\n");
12242         }
12243     }
12244     }
12245     }
12246     function_tests++;
12247 #endif
12248
12249     return(test_ret);
12250 }
12251
12252
12253 static int
12254 test_xmlNanoHTTPInit(void) {
12255     int test_ret = 0;
12256
12257 #if defined(LIBXML_HTTP_ENABLED)
12258     int mem_base;
12259
12260         mem_base = xmlMemBlocks();
12261
12262         xmlNanoHTTPInit();
12263         call_tests++;
12264         xmlResetLastError();
12265         if (mem_base != xmlMemBlocks()) {
12266             printf("Leak of %d blocks found in xmlNanoHTTPInit",
12267                    xmlMemBlocks() - mem_base);
12268             test_ret++;
12269             printf("\n");
12270         }
12271     function_tests++;
12272 #endif
12273
12274     return(test_ret);
12275 }
12276
12277
12278 static int
12279 test_xmlNanoHTTPMimeType(void) {
12280     int test_ret = 0;
12281
12282 #if defined(LIBXML_HTTP_ENABLED)
12283     int mem_base;
12284     const char * ret_val;
12285     void * ctx; /* the HTTP context */
12286     int n_ctx;
12287
12288     for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
12289         mem_base = xmlMemBlocks();
12290         ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
12291
12292         ret_val = xmlNanoHTTPMimeType(ctx);
12293         desret_const_char_ptr(ret_val);
12294         call_tests++;
12295         des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
12296         xmlResetLastError();
12297         if (mem_base != xmlMemBlocks()) {
12298             printf("Leak of %d blocks found in xmlNanoHTTPMimeType",
12299                    xmlMemBlocks() - mem_base);
12300             test_ret++;
12301             printf(" %d", n_ctx);
12302             printf("\n");
12303         }
12304     }
12305     function_tests++;
12306 #endif
12307
12308     return(test_ret);
12309 }
12310
12311
12312 static int
12313 test_xmlNanoHTTPOpen(void) {
12314     int test_ret = 0;
12315
12316 #if defined(LIBXML_HTTP_ENABLED)
12317     int mem_base;
12318     void * ret_val;
12319     const char * URL; /* The URL to load */
12320     int n_URL;
12321     char ** contentType; /* if available the Content-Type information will be returned at that location */
12322     int n_contentType;
12323
12324     for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
12325     for (n_contentType = 0;n_contentType < gen_nb_char_ptr_ptr;n_contentType++) {
12326         mem_base = xmlMemBlocks();
12327         URL = gen_filepath(n_URL, 0);
12328         contentType = gen_char_ptr_ptr(n_contentType, 1);
12329
12330         ret_val = xmlNanoHTTPOpen(URL, contentType);
12331         desret_xmlNanoHTTPCtxtPtr(ret_val);
12332         call_tests++;
12333         des_filepath(n_URL, URL, 0);
12334         des_char_ptr_ptr(n_contentType, contentType, 1);
12335         xmlResetLastError();
12336         if (mem_base != xmlMemBlocks()) {
12337             printf("Leak of %d blocks found in xmlNanoHTTPOpen",
12338                    xmlMemBlocks() - mem_base);
12339             test_ret++;
12340             printf(" %d", n_URL);
12341             printf(" %d", n_contentType);
12342             printf("\n");
12343         }
12344     }
12345     }
12346     function_tests++;
12347 #endif
12348
12349     return(test_ret);
12350 }
12351
12352
12353 static int
12354 test_xmlNanoHTTPOpenRedir(void) {
12355     int test_ret = 0;
12356
12357 #if defined(LIBXML_HTTP_ENABLED)
12358     int mem_base;
12359     void * ret_val;
12360     const char * URL; /* The URL to load */
12361     int n_URL;
12362     char ** contentType; /* if available the Content-Type information will be returned at that location */
12363     int n_contentType;
12364     char ** redir; /* if available the redirected URL will be returned */
12365     int n_redir;
12366
12367     for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
12368     for (n_contentType = 0;n_contentType < gen_nb_char_ptr_ptr;n_contentType++) {
12369     for (n_redir = 0;n_redir < gen_nb_char_ptr_ptr;n_redir++) {
12370         mem_base = xmlMemBlocks();
12371         URL = gen_filepath(n_URL, 0);
12372         contentType = gen_char_ptr_ptr(n_contentType, 1);
12373         redir = gen_char_ptr_ptr(n_redir, 2);
12374
12375         ret_val = xmlNanoHTTPOpenRedir(URL, contentType, redir);
12376         desret_xmlNanoHTTPCtxtPtr(ret_val);
12377         call_tests++;
12378         des_filepath(n_URL, URL, 0);
12379         des_char_ptr_ptr(n_contentType, contentType, 1);
12380         des_char_ptr_ptr(n_redir, redir, 2);
12381         xmlResetLastError();
12382         if (mem_base != xmlMemBlocks()) {
12383             printf("Leak of %d blocks found in xmlNanoHTTPOpenRedir",
12384                    xmlMemBlocks() - mem_base);
12385             test_ret++;
12386             printf(" %d", n_URL);
12387             printf(" %d", n_contentType);
12388             printf(" %d", n_redir);
12389             printf("\n");
12390         }
12391     }
12392     }
12393     }
12394     function_tests++;
12395 #endif
12396
12397     return(test_ret);
12398 }
12399
12400
12401 static int
12402 test_xmlNanoHTTPRead(void) {
12403     int test_ret = 0;
12404
12405 #if defined(LIBXML_HTTP_ENABLED)
12406     int mem_base;
12407     int ret_val;
12408     void * ctx; /* the HTTP context */
12409     int n_ctx;
12410     void * dest; /* a buffer */
12411     int n_dest;
12412     int len; /* the buffer length */
12413     int n_len;
12414
12415     for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
12416     for (n_dest = 0;n_dest < gen_nb_void_ptr;n_dest++) {
12417     for (n_len = 0;n_len < gen_nb_int;n_len++) {
12418         mem_base = xmlMemBlocks();
12419         ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
12420         dest = gen_void_ptr(n_dest, 1);
12421         len = gen_int(n_len, 2);
12422
12423         ret_val = xmlNanoHTTPRead(ctx, dest, len);
12424         desret_int(ret_val);
12425         call_tests++;
12426         des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
12427         des_void_ptr(n_dest, dest, 1);
12428         des_int(n_len, len, 2);
12429         xmlResetLastError();
12430         if (mem_base != xmlMemBlocks()) {
12431             printf("Leak of %d blocks found in xmlNanoHTTPRead",
12432                    xmlMemBlocks() - mem_base);
12433             test_ret++;
12434             printf(" %d", n_ctx);
12435             printf(" %d", n_dest);
12436             printf(" %d", n_len);
12437             printf("\n");
12438         }
12439     }
12440     }
12441     }
12442     function_tests++;
12443 #endif
12444
12445     return(test_ret);
12446 }
12447
12448
12449 static int
12450 test_xmlNanoHTTPRedir(void) {
12451     int test_ret = 0;
12452
12453
12454     /* missing type support */
12455     return(test_ret);
12456 }
12457
12458
12459 static int
12460 test_xmlNanoHTTPReturnCode(void) {
12461     int test_ret = 0;
12462
12463 #if defined(LIBXML_HTTP_ENABLED)
12464     int mem_base;
12465     int ret_val;
12466     void * ctx; /* the HTTP context */
12467     int n_ctx;
12468
12469     for (n_ctx = 0;n_ctx < gen_nb_xmlNanoHTTPCtxtPtr;n_ctx++) {
12470         mem_base = xmlMemBlocks();
12471         ctx = gen_xmlNanoHTTPCtxtPtr(n_ctx, 0);
12472
12473         ret_val = xmlNanoHTTPReturnCode(ctx);
12474         desret_int(ret_val);
12475         call_tests++;
12476         des_xmlNanoHTTPCtxtPtr(n_ctx, ctx, 0);
12477         xmlResetLastError();
12478         if (mem_base != xmlMemBlocks()) {
12479             printf("Leak of %d blocks found in xmlNanoHTTPReturnCode",
12480                    xmlMemBlocks() - mem_base);
12481             test_ret++;
12482             printf(" %d", n_ctx);
12483             printf("\n");
12484         }
12485     }
12486     function_tests++;
12487 #endif
12488
12489     return(test_ret);
12490 }
12491
12492
12493 static int
12494 test_xmlNanoHTTPSave(void) {
12495     int test_ret = 0;
12496
12497 #if defined(LIBXML_HTTP_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
12498     int mem_base;
12499     int ret_val;
12500     void * ctxt; /* the HTTP context */
12501     int n_ctxt;
12502     const char * filename; /* the filename where the content should be saved */
12503     int n_filename;
12504
12505     for (n_ctxt = 0;n_ctxt < gen_nb_void_ptr;n_ctxt++) {
12506     for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
12507         mem_base = xmlMemBlocks();
12508         ctxt = gen_void_ptr(n_ctxt, 0);
12509         filename = gen_fileoutput(n_filename, 1);
12510
12511         ret_val = xmlNanoHTTPSave(ctxt, filename);
12512         desret_int(ret_val);
12513         call_tests++;
12514         des_void_ptr(n_ctxt, ctxt, 0);
12515         des_fileoutput(n_filename, filename, 1);
12516         xmlResetLastError();
12517         if (mem_base != xmlMemBlocks()) {
12518             printf("Leak of %d blocks found in xmlNanoHTTPSave",
12519                    xmlMemBlocks() - mem_base);
12520             test_ret++;
12521             printf(" %d", n_ctxt);
12522             printf(" %d", n_filename);
12523             printf("\n");
12524         }
12525     }
12526     }
12527     function_tests++;
12528 #endif
12529
12530     return(test_ret);
12531 }
12532
12533
12534 static int
12535 test_xmlNanoHTTPScanProxy(void) {
12536     int test_ret = 0;
12537
12538 #if defined(LIBXML_HTTP_ENABLED)
12539     const char * URL; /* The proxy URL used to initialize the proxy context */
12540     int n_URL;
12541
12542     for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
12543         URL = gen_filepath(n_URL, 0);
12544
12545         xmlNanoHTTPScanProxy(URL);
12546         call_tests++;
12547         des_filepath(n_URL, URL, 0);
12548         xmlResetLastError();
12549     }
12550     function_tests++;
12551 #endif
12552
12553     return(test_ret);
12554 }
12555
12556 static int
12557 test_nanohttp(void) {
12558     int test_ret = 0;
12559
12560     if (quiet == 0) printf("Testing nanohttp : 13 of 17 functions ...\n");
12561     test_ret += test_xmlNanoHTTPAuthHeader();
12562     test_ret += test_xmlNanoHTTPCleanup();
12563     test_ret += test_xmlNanoHTTPContentLength();
12564     test_ret += test_xmlNanoHTTPEncoding();
12565     test_ret += test_xmlNanoHTTPFetch();
12566     test_ret += test_xmlNanoHTTPInit();
12567     test_ret += test_xmlNanoHTTPMimeType();
12568     test_ret += test_xmlNanoHTTPOpen();
12569     test_ret += test_xmlNanoHTTPOpenRedir();
12570     test_ret += test_xmlNanoHTTPRead();
12571     test_ret += test_xmlNanoHTTPRedir();
12572     test_ret += test_xmlNanoHTTPReturnCode();
12573     test_ret += test_xmlNanoHTTPSave();
12574     test_ret += test_xmlNanoHTTPScanProxy();
12575
12576     if (test_ret != 0)
12577         printf("Module nanohttp: %d errors\n", test_ret);
12578     return(test_ret);
12579 }
12580
12581 static int
12582 test_xmlByteConsumed(void) {
12583     int test_ret = 0;
12584
12585     int mem_base;
12586     long ret_val;
12587     xmlParserCtxtPtr ctxt; /* an XML parser context */
12588     int n_ctxt;
12589
12590     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
12591         mem_base = xmlMemBlocks();
12592         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
12593
12594         ret_val = xmlByteConsumed(ctxt);
12595         desret_long(ret_val);
12596         call_tests++;
12597         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
12598         xmlResetLastError();
12599         if (mem_base != xmlMemBlocks()) {
12600             printf("Leak of %d blocks found in xmlByteConsumed",
12601                    xmlMemBlocks() - mem_base);
12602             test_ret++;
12603             printf(" %d", n_ctxt);
12604             printf("\n");
12605         }
12606     }
12607     function_tests++;
12608
12609     return(test_ret);
12610 }
12611
12612
12613 static int
12614 test_xmlClearNodeInfoSeq(void) {
12615     int test_ret = 0;
12616
12617     int mem_base;
12618     xmlParserNodeInfoSeqPtr seq; /* a node info sequence pointer */
12619     int n_seq;
12620
12621     for (n_seq = 0;n_seq < gen_nb_xmlParserNodeInfoSeqPtr;n_seq++) {
12622         mem_base = xmlMemBlocks();
12623         seq = gen_xmlParserNodeInfoSeqPtr(n_seq, 0);
12624
12625         xmlClearNodeInfoSeq(seq);
12626         call_tests++;
12627         des_xmlParserNodeInfoSeqPtr(n_seq, seq, 0);
12628         xmlResetLastError();
12629         if (mem_base != xmlMemBlocks()) {
12630             printf("Leak of %d blocks found in xmlClearNodeInfoSeq",
12631                    xmlMemBlocks() - mem_base);
12632             test_ret++;
12633             printf(" %d", n_seq);
12634             printf("\n");
12635         }
12636     }
12637     function_tests++;
12638
12639     return(test_ret);
12640 }
12641
12642
12643 static int
12644 test_xmlClearParserCtxt(void) {
12645     int test_ret = 0;
12646
12647     int mem_base;
12648     xmlParserCtxtPtr ctxt; /* an XML parser context */
12649     int n_ctxt;
12650
12651     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
12652         mem_base = xmlMemBlocks();
12653         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
12654
12655         xmlClearParserCtxt(ctxt);
12656         call_tests++;
12657         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
12658         xmlResetLastError();
12659         if (mem_base != xmlMemBlocks()) {
12660             printf("Leak of %d blocks found in xmlClearParserCtxt",
12661                    xmlMemBlocks() - mem_base);
12662             test_ret++;
12663             printf(" %d", n_ctxt);
12664             printf("\n");
12665         }
12666     }
12667     function_tests++;
12668
12669     return(test_ret);
12670 }
12671
12672
12673 static int
12674 test_xmlCreateDocParserCtxt(void) {
12675     int test_ret = 0;
12676
12677     int mem_base;
12678     xmlParserCtxtPtr ret_val;
12679     xmlChar * cur; /* a pointer to an array of xmlChar */
12680     int n_cur;
12681
12682     for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
12683         mem_base = xmlMemBlocks();
12684         cur = gen_const_xmlChar_ptr(n_cur, 0);
12685
12686         ret_val = xmlCreateDocParserCtxt((const xmlChar *)cur);
12687         desret_xmlParserCtxtPtr(ret_val);
12688         call_tests++;
12689         des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
12690         xmlResetLastError();
12691         if (mem_base != xmlMemBlocks()) {
12692             printf("Leak of %d blocks found in xmlCreateDocParserCtxt",
12693                    xmlMemBlocks() - mem_base);
12694             test_ret++;
12695             printf(" %d", n_cur);
12696             printf("\n");
12697         }
12698     }
12699     function_tests++;
12700
12701     return(test_ret);
12702 }
12703
12704
12705 static int
12706 test_xmlCreatePushParserCtxt(void) {
12707     int test_ret = 0;
12708
12709 #if defined(LIBXML_PUSH_ENABLED)
12710     int mem_base;
12711     xmlParserCtxtPtr ret_val;
12712     xmlSAXHandlerPtr sax; /* a SAX handler */
12713     int n_sax;
12714     void * user_data; /* The user data returned on SAX callbacks */
12715     int n_user_data;
12716     char * chunk; /* a pointer to an array of chars */
12717     int n_chunk;
12718     int size; /* number of chars in the array */
12719     int n_size;
12720     const char * filename; /* an optional file name or URI */
12721     int n_filename;
12722
12723     for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
12724     for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
12725     for (n_chunk = 0;n_chunk < gen_nb_const_char_ptr;n_chunk++) {
12726     for (n_size = 0;n_size < gen_nb_int;n_size++) {
12727     for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
12728         mem_base = xmlMemBlocks();
12729         sax = gen_xmlSAXHandlerPtr(n_sax, 0);
12730         user_data = gen_userdata(n_user_data, 1);
12731         chunk = gen_const_char_ptr(n_chunk, 2);
12732         size = gen_int(n_size, 3);
12733         filename = gen_fileoutput(n_filename, 4);
12734
12735         ret_val = xmlCreatePushParserCtxt(sax, user_data, (const char *)chunk, size, filename);
12736         desret_xmlParserCtxtPtr(ret_val);
12737         call_tests++;
12738         des_xmlSAXHandlerPtr(n_sax, sax, 0);
12739         des_userdata(n_user_data, user_data, 1);
12740         des_const_char_ptr(n_chunk, (const char *)chunk, 2);
12741         des_int(n_size, size, 3);
12742         des_fileoutput(n_filename, filename, 4);
12743         xmlResetLastError();
12744         if (mem_base != xmlMemBlocks()) {
12745             printf("Leak of %d blocks found in xmlCreatePushParserCtxt",
12746                    xmlMemBlocks() - mem_base);
12747             test_ret++;
12748             printf(" %d", n_sax);
12749             printf(" %d", n_user_data);
12750             printf(" %d", n_chunk);
12751             printf(" %d", n_size);
12752             printf(" %d", n_filename);
12753             printf("\n");
12754         }
12755     }
12756     }
12757     }
12758     }
12759     }
12760     function_tests++;
12761 #endif
12762
12763     return(test_ret);
12764 }
12765
12766
12767 static int
12768 test_xmlCtxtReadDoc(void) {
12769     int test_ret = 0;
12770
12771     int mem_base;
12772     xmlDocPtr ret_val;
12773     xmlParserCtxtPtr ctxt; /* an XML parser context */
12774     int n_ctxt;
12775     xmlChar * cur; /* a pointer to a zero terminated string */
12776     int n_cur;
12777     const char * URL; /* the base URL to use for the document */
12778     int n_URL;
12779     char * encoding; /* the document encoding, or NULL */
12780     int n_encoding;
12781     int options; /* a combination of xmlParserOption */
12782     int n_options;
12783
12784     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
12785     for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
12786     for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
12787     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
12788     for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
12789         mem_base = xmlMemBlocks();
12790         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
12791         cur = gen_const_xmlChar_ptr(n_cur, 1);
12792         URL = gen_filepath(n_URL, 2);
12793         encoding = gen_const_char_ptr(n_encoding, 3);
12794         options = gen_parseroptions(n_options, 4);
12795
12796         ret_val = xmlCtxtReadDoc(ctxt, (const xmlChar *)cur, URL, (const char *)encoding, options);
12797         desret_xmlDocPtr(ret_val);
12798         call_tests++;
12799         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
12800         des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 1);
12801         des_filepath(n_URL, URL, 2);
12802         des_const_char_ptr(n_encoding, (const char *)encoding, 3);
12803         des_parseroptions(n_options, options, 4);
12804         xmlResetLastError();
12805         if (mem_base != xmlMemBlocks()) {
12806             printf("Leak of %d blocks found in xmlCtxtReadDoc",
12807                    xmlMemBlocks() - mem_base);
12808             test_ret++;
12809             printf(" %d", n_ctxt);
12810             printf(" %d", n_cur);
12811             printf(" %d", n_URL);
12812             printf(" %d", n_encoding);
12813             printf(" %d", n_options);
12814             printf("\n");
12815         }
12816     }
12817     }
12818     }
12819     }
12820     }
12821     function_tests++;
12822
12823     return(test_ret);
12824 }
12825
12826
12827 static int
12828 test_xmlCtxtReadFile(void) {
12829     int test_ret = 0;
12830
12831     int mem_base;
12832     xmlDocPtr ret_val;
12833     xmlParserCtxtPtr ctxt; /* an XML parser context */
12834     int n_ctxt;
12835     const char * filename; /* a file or URL */
12836     int n_filename;
12837     char * encoding; /* the document encoding, or NULL */
12838     int n_encoding;
12839     int options; /* a combination of xmlParserOption */
12840     int n_options;
12841
12842     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
12843     for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
12844     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
12845     for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
12846         mem_base = xmlMemBlocks();
12847         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
12848         filename = gen_filepath(n_filename, 1);
12849         encoding = gen_const_char_ptr(n_encoding, 2);
12850         options = gen_parseroptions(n_options, 3);
12851
12852         ret_val = xmlCtxtReadFile(ctxt, filename, (const char *)encoding, options);
12853         desret_xmlDocPtr(ret_val);
12854         call_tests++;
12855         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
12856         des_filepath(n_filename, filename, 1);
12857         des_const_char_ptr(n_encoding, (const char *)encoding, 2);
12858         des_parseroptions(n_options, options, 3);
12859         xmlResetLastError();
12860         if (mem_base != xmlMemBlocks()) {
12861             printf("Leak of %d blocks found in xmlCtxtReadFile",
12862                    xmlMemBlocks() - mem_base);
12863             test_ret++;
12864             printf(" %d", n_ctxt);
12865             printf(" %d", n_filename);
12866             printf(" %d", n_encoding);
12867             printf(" %d", n_options);
12868             printf("\n");
12869         }
12870     }
12871     }
12872     }
12873     }
12874     function_tests++;
12875
12876     return(test_ret);
12877 }
12878
12879
12880 static int
12881 test_xmlCtxtReadMemory(void) {
12882     int test_ret = 0;
12883
12884     int mem_base;
12885     xmlDocPtr ret_val;
12886     xmlParserCtxtPtr ctxt; /* an XML parser context */
12887     int n_ctxt;
12888     char * buffer; /* a pointer to a char array */
12889     int n_buffer;
12890     int size; /* the size of the array */
12891     int n_size;
12892     const char * URL; /* the base URL to use for the document */
12893     int n_URL;
12894     char * encoding; /* the document encoding, or NULL */
12895     int n_encoding;
12896     int options; /* a combination of xmlParserOption */
12897     int n_options;
12898
12899     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
12900     for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
12901     for (n_size = 0;n_size < gen_nb_int;n_size++) {
12902     for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
12903     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
12904     for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
12905         mem_base = xmlMemBlocks();
12906         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
12907         buffer = gen_const_char_ptr(n_buffer, 1);
12908         size = gen_int(n_size, 2);
12909         URL = gen_filepath(n_URL, 3);
12910         encoding = gen_const_char_ptr(n_encoding, 4);
12911         options = gen_parseroptions(n_options, 5);
12912
12913         ret_val = xmlCtxtReadMemory(ctxt, (const char *)buffer, size, URL, (const char *)encoding, options);
12914         desret_xmlDocPtr(ret_val);
12915         call_tests++;
12916         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
12917         des_const_char_ptr(n_buffer, (const char *)buffer, 1);
12918         des_int(n_size, size, 2);
12919         des_filepath(n_URL, URL, 3);
12920         des_const_char_ptr(n_encoding, (const char *)encoding, 4);
12921         des_parseroptions(n_options, options, 5);
12922         xmlResetLastError();
12923         if (mem_base != xmlMemBlocks()) {
12924             printf("Leak of %d blocks found in xmlCtxtReadMemory",
12925                    xmlMemBlocks() - mem_base);
12926             test_ret++;
12927             printf(" %d", n_ctxt);
12928             printf(" %d", n_buffer);
12929             printf(" %d", n_size);
12930             printf(" %d", n_URL);
12931             printf(" %d", n_encoding);
12932             printf(" %d", n_options);
12933             printf("\n");
12934         }
12935     }
12936     }
12937     }
12938     }
12939     }
12940     }
12941     function_tests++;
12942
12943     return(test_ret);
12944 }
12945
12946
12947 static int
12948 test_xmlCtxtReset(void) {
12949     int test_ret = 0;
12950
12951     int mem_base;
12952     xmlParserCtxtPtr ctxt; /* an XML parser context */
12953     int n_ctxt;
12954
12955     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
12956         mem_base = xmlMemBlocks();
12957         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
12958
12959         xmlCtxtReset(ctxt);
12960         call_tests++;
12961         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
12962         xmlResetLastError();
12963         if (mem_base != xmlMemBlocks()) {
12964             printf("Leak of %d blocks found in xmlCtxtReset",
12965                    xmlMemBlocks() - mem_base);
12966             test_ret++;
12967             printf(" %d", n_ctxt);
12968             printf("\n");
12969         }
12970     }
12971     function_tests++;
12972
12973     return(test_ret);
12974 }
12975
12976
12977 static int
12978 test_xmlCtxtResetPush(void) {
12979     int test_ret = 0;
12980
12981     int mem_base;
12982     int ret_val;
12983     xmlParserCtxtPtr ctxt; /* an XML parser context */
12984     int n_ctxt;
12985     char * chunk; /* a pointer to an array of chars */
12986     int n_chunk;
12987     int size; /* number of chars in the array */
12988     int n_size;
12989     const char * filename; /* an optional file name or URI */
12990     int n_filename;
12991     char * encoding; /* the document encoding, or NULL */
12992     int n_encoding;
12993
12994     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
12995     for (n_chunk = 0;n_chunk < gen_nb_const_char_ptr;n_chunk++) {
12996     for (n_size = 0;n_size < gen_nb_int;n_size++) {
12997     for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
12998     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
12999         mem_base = xmlMemBlocks();
13000         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
13001         chunk = gen_const_char_ptr(n_chunk, 1);
13002         size = gen_int(n_size, 2);
13003         filename = gen_filepath(n_filename, 3);
13004         encoding = gen_const_char_ptr(n_encoding, 4);
13005
13006         ret_val = xmlCtxtResetPush(ctxt, (const char *)chunk, size, filename, (const char *)encoding);
13007         desret_int(ret_val);
13008         call_tests++;
13009         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
13010         des_const_char_ptr(n_chunk, (const char *)chunk, 1);
13011         des_int(n_size, size, 2);
13012         des_filepath(n_filename, filename, 3);
13013         des_const_char_ptr(n_encoding, (const char *)encoding, 4);
13014         xmlResetLastError();
13015         if (mem_base != xmlMemBlocks()) {
13016             printf("Leak of %d blocks found in xmlCtxtResetPush",
13017                    xmlMemBlocks() - mem_base);
13018             test_ret++;
13019             printf(" %d", n_ctxt);
13020             printf(" %d", n_chunk);
13021             printf(" %d", n_size);
13022             printf(" %d", n_filename);
13023             printf(" %d", n_encoding);
13024             printf("\n");
13025         }
13026     }
13027     }
13028     }
13029     }
13030     }
13031     function_tests++;
13032
13033     return(test_ret);
13034 }
13035
13036
13037 static int
13038 test_xmlCtxtUseOptions(void) {
13039     int test_ret = 0;
13040
13041     int mem_base;
13042     int ret_val;
13043     xmlParserCtxtPtr ctxt; /* an XML parser context */
13044     int n_ctxt;
13045     int options; /* a combination of xmlParserOption */
13046     int n_options;
13047
13048     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
13049     for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
13050         mem_base = xmlMemBlocks();
13051         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
13052         options = gen_parseroptions(n_options, 1);
13053
13054         ret_val = xmlCtxtUseOptions(ctxt, options);
13055         desret_int(ret_val);
13056         call_tests++;
13057         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
13058         des_parseroptions(n_options, options, 1);
13059         xmlResetLastError();
13060         if (mem_base != xmlMemBlocks()) {
13061             printf("Leak of %d blocks found in xmlCtxtUseOptions",
13062                    xmlMemBlocks() - mem_base);
13063             test_ret++;
13064             printf(" %d", n_ctxt);
13065             printf(" %d", n_options);
13066             printf("\n");
13067         }
13068     }
13069     }
13070     function_tests++;
13071
13072     return(test_ret);
13073 }
13074
13075
13076 static int
13077 test_xmlGetExternalEntityLoader(void) {
13078     int test_ret = 0;
13079
13080
13081     /* missing type support */
13082     return(test_ret);
13083 }
13084
13085
13086 static int
13087 test_xmlGetFeature(void) {
13088     int test_ret = 0;
13089
13090 #if defined(LIBXML_LEGACY_ENABLED)
13091 #ifdef LIBXML_LEGACY_ENABLED
13092     int mem_base;
13093     int ret_val;
13094     xmlParserCtxtPtr ctxt; /* an XML/HTML parser context */
13095     int n_ctxt;
13096     char * name; /* the feature name */
13097     int n_name;
13098     void * result; /* location to store the result */
13099     int n_result;
13100
13101     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
13102     for (n_name = 0;n_name < gen_nb_const_char_ptr;n_name++) {
13103     for (n_result = 0;n_result < gen_nb_void_ptr;n_result++) {
13104         mem_base = xmlMemBlocks();
13105         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
13106         name = gen_const_char_ptr(n_name, 1);
13107         result = gen_void_ptr(n_result, 2);
13108
13109         ret_val = xmlGetFeature(ctxt, (const char *)name, result);
13110         desret_int(ret_val);
13111         call_tests++;
13112         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
13113         des_const_char_ptr(n_name, (const char *)name, 1);
13114         des_void_ptr(n_result, result, 2);
13115         xmlResetLastError();
13116         if (mem_base != xmlMemBlocks()) {
13117             printf("Leak of %d blocks found in xmlGetFeature",
13118                    xmlMemBlocks() - mem_base);
13119             test_ret++;
13120             printf(" %d", n_ctxt);
13121             printf(" %d", n_name);
13122             printf(" %d", n_result);
13123             printf("\n");
13124         }
13125     }
13126     }
13127     }
13128     function_tests++;
13129 #endif
13130 #endif
13131
13132     return(test_ret);
13133 }
13134
13135
13136 #define gen_nb_const_char_ptr_ptr 1
13137 static char ** gen_const_char_ptr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
13138     return(NULL);
13139 }
13140 static void des_const_char_ptr_ptr(int no ATTRIBUTE_UNUSED, const char ** val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
13141 }
13142
13143 static int
13144 test_xmlGetFeaturesList(void) {
13145     int test_ret = 0;
13146
13147 #if defined(LIBXML_LEGACY_ENABLED)
13148 #ifdef LIBXML_LEGACY_ENABLED
13149     int mem_base;
13150     int ret_val;
13151     int * len; /* the length of the features name array (input/output) */
13152     int n_len;
13153     char ** result; /* an array of string to be filled with the features name. */
13154     int n_result;
13155
13156     for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
13157     for (n_result = 0;n_result < gen_nb_const_char_ptr_ptr;n_result++) {
13158         mem_base = xmlMemBlocks();
13159         len = gen_int_ptr(n_len, 0);
13160         result = gen_const_char_ptr_ptr(n_result, 1);
13161
13162         ret_val = xmlGetFeaturesList(len, (const char **)result);
13163         desret_int(ret_val);
13164         call_tests++;
13165         des_int_ptr(n_len, len, 0);
13166         des_const_char_ptr_ptr(n_result, (const char **)result, 1);
13167         xmlResetLastError();
13168         if (mem_base != xmlMemBlocks()) {
13169             printf("Leak of %d blocks found in xmlGetFeaturesList",
13170                    xmlMemBlocks() - mem_base);
13171             test_ret++;
13172             printf(" %d", n_len);
13173             printf(" %d", n_result);
13174             printf("\n");
13175         }
13176     }
13177     }
13178     function_tests++;
13179 #endif
13180 #endif
13181
13182     return(test_ret);
13183 }
13184
13185
13186 static int
13187 test_xmlHasFeature(void) {
13188     int test_ret = 0;
13189
13190     int mem_base;
13191     int ret_val;
13192     xmlFeature feature; /* the feature to be examined */
13193     int n_feature;
13194
13195     for (n_feature = 0;n_feature < gen_nb_xmlFeature;n_feature++) {
13196         mem_base = xmlMemBlocks();
13197         feature = gen_xmlFeature(n_feature, 0);
13198
13199         ret_val = xmlHasFeature(feature);
13200         desret_int(ret_val);
13201         call_tests++;
13202         des_xmlFeature(n_feature, feature, 0);
13203         xmlResetLastError();
13204         if (mem_base != xmlMemBlocks()) {
13205             printf("Leak of %d blocks found in xmlHasFeature",
13206                    xmlMemBlocks() - mem_base);
13207             test_ret++;
13208             printf(" %d", n_feature);
13209             printf("\n");
13210         }
13211     }
13212     function_tests++;
13213
13214     return(test_ret);
13215 }
13216
13217
13218 static int
13219 test_xmlIOParseDTD(void) {
13220     int test_ret = 0;
13221
13222 #if defined(LIBXML_VALID_ENABLED)
13223 #ifdef LIBXML_VALID_ENABLED
13224     xmlDtdPtr ret_val;
13225     xmlSAXHandlerPtr sax; /* the SAX handler block or NULL */
13226     int n_sax;
13227     xmlParserInputBufferPtr input; /* an Input Buffer */
13228     int n_input;
13229     xmlCharEncoding enc; /* the charset encoding if known */
13230     int n_enc;
13231
13232     for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
13233     for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) {
13234     for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
13235         sax = gen_xmlSAXHandlerPtr(n_sax, 0);
13236         input = gen_xmlParserInputBufferPtr(n_input, 1);
13237         enc = gen_xmlCharEncoding(n_enc, 2);
13238
13239         ret_val = xmlIOParseDTD(sax, input, enc);
13240         input = NULL;
13241         desret_xmlDtdPtr(ret_val);
13242         call_tests++;
13243         des_xmlSAXHandlerPtr(n_sax, sax, 0);
13244         des_xmlParserInputBufferPtr(n_input, input, 1);
13245         des_xmlCharEncoding(n_enc, enc, 2);
13246         xmlResetLastError();
13247     }
13248     }
13249     }
13250     function_tests++;
13251 #endif
13252 #endif
13253
13254     return(test_ret);
13255 }
13256
13257
13258 static int
13259 test_xmlInitNodeInfoSeq(void) {
13260     int test_ret = 0;
13261
13262     int mem_base;
13263     xmlParserNodeInfoSeqPtr seq; /* a node info sequence pointer */
13264     int n_seq;
13265
13266     for (n_seq = 0;n_seq < gen_nb_xmlParserNodeInfoSeqPtr;n_seq++) {
13267         mem_base = xmlMemBlocks();
13268         seq = gen_xmlParserNodeInfoSeqPtr(n_seq, 0);
13269
13270         xmlInitNodeInfoSeq(seq);
13271         call_tests++;
13272         des_xmlParserNodeInfoSeqPtr(n_seq, seq, 0);
13273         xmlResetLastError();
13274         if (mem_base != xmlMemBlocks()) {
13275             printf("Leak of %d blocks found in xmlInitNodeInfoSeq",
13276                    xmlMemBlocks() - mem_base);
13277             test_ret++;
13278             printf(" %d", n_seq);
13279             printf("\n");
13280         }
13281     }
13282     function_tests++;
13283
13284     return(test_ret);
13285 }
13286
13287
13288 static int
13289 test_xmlInitParser(void) {
13290     int test_ret = 0;
13291
13292     int mem_base;
13293
13294         mem_base = xmlMemBlocks();
13295
13296         xmlInitParser();
13297         call_tests++;
13298         xmlResetLastError();
13299         if (mem_base != xmlMemBlocks()) {
13300             printf("Leak of %d blocks found in xmlInitParser",
13301                    xmlMemBlocks() - mem_base);
13302             test_ret++;
13303             printf("\n");
13304         }
13305     function_tests++;
13306
13307     return(test_ret);
13308 }
13309
13310
13311 static int
13312 test_xmlInitParserCtxt(void) {
13313     int test_ret = 0;
13314
13315     int mem_base;
13316     int ret_val;
13317     xmlParserCtxtPtr ctxt; /* an XML parser context */
13318     int n_ctxt;
13319
13320     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
13321         mem_base = xmlMemBlocks();
13322         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
13323
13324         ret_val = xmlInitParserCtxt(ctxt);
13325         desret_int(ret_val);
13326         call_tests++;
13327         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
13328         xmlResetLastError();
13329         if (mem_base != xmlMemBlocks()) {
13330             printf("Leak of %d blocks found in xmlInitParserCtxt",
13331                    xmlMemBlocks() - mem_base);
13332             test_ret++;
13333             printf(" %d", n_ctxt);
13334             printf("\n");
13335         }
13336     }
13337     function_tests++;
13338
13339     return(test_ret);
13340 }
13341
13342
13343 static int
13344 test_xmlKeepBlanksDefault(void) {
13345     int test_ret = 0;
13346
13347     int mem_base;
13348     int ret_val;
13349     int val; /* int 0 or 1 */
13350     int n_val;
13351
13352     for (n_val = 0;n_val < gen_nb_int;n_val++) {
13353         mem_base = xmlMemBlocks();
13354         val = gen_int(n_val, 0);
13355
13356         ret_val = xmlKeepBlanksDefault(val);
13357         desret_int(ret_val);
13358         call_tests++;
13359         des_int(n_val, val, 0);
13360         xmlResetLastError();
13361         if (mem_base != xmlMemBlocks()) {
13362             printf("Leak of %d blocks found in xmlKeepBlanksDefault",
13363                    xmlMemBlocks() - mem_base);
13364             test_ret++;
13365             printf(" %d", n_val);
13366             printf("\n");
13367         }
13368     }
13369     function_tests++;
13370
13371     return(test_ret);
13372 }
13373
13374
13375 static int
13376 test_xmlLineNumbersDefault(void) {
13377     int test_ret = 0;
13378
13379     int mem_base;
13380     int ret_val;
13381     int val; /* int 0 or 1 */
13382     int n_val;
13383
13384     for (n_val = 0;n_val < gen_nb_int;n_val++) {
13385         mem_base = xmlMemBlocks();
13386         val = gen_int(n_val, 0);
13387
13388         ret_val = xmlLineNumbersDefault(val);
13389         desret_int(ret_val);
13390         call_tests++;
13391         des_int(n_val, val, 0);
13392         xmlResetLastError();
13393         if (mem_base != xmlMemBlocks()) {
13394             printf("Leak of %d blocks found in xmlLineNumbersDefault",
13395                    xmlMemBlocks() - mem_base);
13396             test_ret++;
13397             printf(" %d", n_val);
13398             printf("\n");
13399         }
13400     }
13401     function_tests++;
13402
13403     return(test_ret);
13404 }
13405
13406
13407 static int
13408 test_xmlLoadExternalEntity(void) {
13409     int test_ret = 0;
13410
13411     int mem_base;
13412     xmlParserInputPtr ret_val;
13413     const char * URL; /* the URL for the entity to load */
13414     int n_URL;
13415     char * ID; /* the Public ID for the entity to load */
13416     int n_ID;
13417     xmlParserCtxtPtr ctxt; /* the context in which the entity is called or NULL */
13418     int n_ctxt;
13419
13420     for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
13421     for (n_ID = 0;n_ID < gen_nb_const_char_ptr;n_ID++) {
13422     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
13423         mem_base = xmlMemBlocks();
13424         URL = gen_filepath(n_URL, 0);
13425         ID = gen_const_char_ptr(n_ID, 1);
13426         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 2);
13427
13428         ret_val = xmlLoadExternalEntity(URL, (const char *)ID, ctxt);
13429         desret_xmlParserInputPtr(ret_val);
13430         call_tests++;
13431         des_filepath(n_URL, URL, 0);
13432         des_const_char_ptr(n_ID, (const char *)ID, 1);
13433         des_xmlParserCtxtPtr(n_ctxt, ctxt, 2);
13434         xmlResetLastError();
13435         if (mem_base != xmlMemBlocks()) {
13436             printf("Leak of %d blocks found in xmlLoadExternalEntity",
13437                    xmlMemBlocks() - mem_base);
13438             test_ret++;
13439             printf(" %d", n_URL);
13440             printf(" %d", n_ID);
13441             printf(" %d", n_ctxt);
13442             printf("\n");
13443         }
13444     }
13445     }
13446     }
13447     function_tests++;
13448
13449     return(test_ret);
13450 }
13451
13452
13453 static int
13454 test_xmlNewIOInputStream(void) {
13455     int test_ret = 0;
13456
13457     int mem_base;
13458     xmlParserInputPtr ret_val;
13459     xmlParserCtxtPtr ctxt; /* an XML parser context */
13460     int n_ctxt;
13461     xmlParserInputBufferPtr input; /* an I/O Input */
13462     int n_input;
13463     xmlCharEncoding enc; /* the charset encoding if known */
13464     int n_enc;
13465
13466     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
13467     for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) {
13468     for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
13469         mem_base = xmlMemBlocks();
13470         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
13471         input = gen_xmlParserInputBufferPtr(n_input, 1);
13472         enc = gen_xmlCharEncoding(n_enc, 2);
13473
13474         ret_val = xmlNewIOInputStream(ctxt, input, enc);
13475         if (ret_val != NULL) input = NULL;
13476         desret_xmlParserInputPtr(ret_val);
13477         call_tests++;
13478         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
13479         des_xmlParserInputBufferPtr(n_input, input, 1);
13480         des_xmlCharEncoding(n_enc, enc, 2);
13481         xmlResetLastError();
13482         if (mem_base != xmlMemBlocks()) {
13483             printf("Leak of %d blocks found in xmlNewIOInputStream",
13484                    xmlMemBlocks() - mem_base);
13485             test_ret++;
13486             printf(" %d", n_ctxt);
13487             printf(" %d", n_input);
13488             printf(" %d", n_enc);
13489             printf("\n");
13490         }
13491     }
13492     }
13493     }
13494     function_tests++;
13495
13496     return(test_ret);
13497 }
13498
13499
13500 static int
13501 test_xmlNewParserCtxt(void) {
13502     int test_ret = 0;
13503
13504     int mem_base;
13505     xmlParserCtxtPtr ret_val;
13506
13507         mem_base = xmlMemBlocks();
13508
13509         ret_val = xmlNewParserCtxt();
13510         desret_xmlParserCtxtPtr(ret_val);
13511         call_tests++;
13512         xmlResetLastError();
13513         if (mem_base != xmlMemBlocks()) {
13514             printf("Leak of %d blocks found in xmlNewParserCtxt",
13515                    xmlMemBlocks() - mem_base);
13516             test_ret++;
13517             printf("\n");
13518         }
13519     function_tests++;
13520
13521     return(test_ret);
13522 }
13523
13524
13525 #define gen_nb_xmlNodePtr_ptr 1
13526 static xmlNodePtr * gen_xmlNodePtr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
13527     return(NULL);
13528 }
13529 static void des_xmlNodePtr_ptr(int no ATTRIBUTE_UNUSED, xmlNodePtr * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
13530 }
13531
13532 static int
13533 test_xmlParseBalancedChunkMemory(void) {
13534     int test_ret = 0;
13535
13536 #if defined(LIBXML_SAX1_ENABLED)
13537 #ifdef LIBXML_SAX1_ENABLED
13538     int mem_base;
13539     int ret_val;
13540     xmlDocPtr doc; /* the document the chunk pertains to */
13541     int n_doc;
13542     xmlSAXHandlerPtr sax; /* the SAX handler bloc (possibly NULL) */
13543     int n_sax;
13544     void * user_data; /* The user data returned on SAX callbacks (possibly NULL) */
13545     int n_user_data;
13546     int depth; /* Used for loop detection, use 0 */
13547     int n_depth;
13548     xmlChar * string; /* the input string in UTF8 or ISO-Latin (zero terminated) */
13549     int n_string;
13550     xmlNodePtr * lst; /* the return value for the set of parsed nodes */
13551     int n_lst;
13552
13553     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
13554     for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
13555     for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
13556     for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
13557     for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) {
13558     for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) {
13559         mem_base = xmlMemBlocks();
13560         doc = gen_xmlDocPtr(n_doc, 0);
13561         sax = gen_xmlSAXHandlerPtr(n_sax, 1);
13562         user_data = gen_userdata(n_user_data, 2);
13563         depth = gen_int(n_depth, 3);
13564         string = gen_const_xmlChar_ptr(n_string, 4);
13565         lst = gen_xmlNodePtr_ptr(n_lst, 5);
13566
13567 #ifdef LIBXML_SAX1_ENABLED
13568         if (sax == (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) user_data = NULL;
13569 #endif
13570
13571
13572         ret_val = xmlParseBalancedChunkMemory(doc, sax, user_data, depth, (const xmlChar *)string, lst);
13573         desret_int(ret_val);
13574         call_tests++;
13575         des_xmlDocPtr(n_doc, doc, 0);
13576         des_xmlSAXHandlerPtr(n_sax, sax, 1);
13577         des_userdata(n_user_data, user_data, 2);
13578         des_int(n_depth, depth, 3);
13579         des_const_xmlChar_ptr(n_string, (const xmlChar *)string, 4);
13580         des_xmlNodePtr_ptr(n_lst, lst, 5);
13581         xmlResetLastError();
13582         if (mem_base != xmlMemBlocks()) {
13583             printf("Leak of %d blocks found in xmlParseBalancedChunkMemory",
13584                    xmlMemBlocks() - mem_base);
13585             test_ret++;
13586             printf(" %d", n_doc);
13587             printf(" %d", n_sax);
13588             printf(" %d", n_user_data);
13589             printf(" %d", n_depth);
13590             printf(" %d", n_string);
13591             printf(" %d", n_lst);
13592             printf("\n");
13593         }
13594     }
13595     }
13596     }
13597     }
13598     }
13599     }
13600     function_tests++;
13601 #endif
13602 #endif
13603
13604     return(test_ret);
13605 }
13606
13607
13608 static int
13609 test_xmlParseBalancedChunkMemoryRecover(void) {
13610     int test_ret = 0;
13611
13612 #if defined(LIBXML_SAX1_ENABLED)
13613 #ifdef LIBXML_SAX1_ENABLED
13614     int mem_base;
13615     int ret_val;
13616     xmlDocPtr doc; /* the document the chunk pertains to */
13617     int n_doc;
13618     xmlSAXHandlerPtr sax; /* the SAX handler bloc (possibly NULL) */
13619     int n_sax;
13620     void * user_data; /* The user data returned on SAX callbacks (possibly NULL) */
13621     int n_user_data;
13622     int depth; /* Used for loop detection, use 0 */
13623     int n_depth;
13624     xmlChar * string; /* the input string in UTF8 or ISO-Latin (zero terminated) */
13625     int n_string;
13626     xmlNodePtr * lst; /* the return value for the set of parsed nodes */
13627     int n_lst;
13628     int recover; /* return nodes even if the data is broken (use 0) */
13629     int n_recover;
13630
13631     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
13632     for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
13633     for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
13634     for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
13635     for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) {
13636     for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) {
13637     for (n_recover = 0;n_recover < gen_nb_int;n_recover++) {
13638         mem_base = xmlMemBlocks();
13639         doc = gen_xmlDocPtr(n_doc, 0);
13640         sax = gen_xmlSAXHandlerPtr(n_sax, 1);
13641         user_data = gen_userdata(n_user_data, 2);
13642         depth = gen_int(n_depth, 3);
13643         string = gen_const_xmlChar_ptr(n_string, 4);
13644         lst = gen_xmlNodePtr_ptr(n_lst, 5);
13645         recover = gen_int(n_recover, 6);
13646
13647 #ifdef LIBXML_SAX1_ENABLED
13648         if (sax == (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) user_data = NULL;
13649 #endif
13650
13651
13652         ret_val = xmlParseBalancedChunkMemoryRecover(doc, sax, user_data, depth, (const xmlChar *)string, lst, recover);
13653         desret_int(ret_val);
13654         call_tests++;
13655         des_xmlDocPtr(n_doc, doc, 0);
13656         des_xmlSAXHandlerPtr(n_sax, sax, 1);
13657         des_userdata(n_user_data, user_data, 2);
13658         des_int(n_depth, depth, 3);
13659         des_const_xmlChar_ptr(n_string, (const xmlChar *)string, 4);
13660         des_xmlNodePtr_ptr(n_lst, lst, 5);
13661         des_int(n_recover, recover, 6);
13662         xmlResetLastError();
13663         if (mem_base != xmlMemBlocks()) {
13664             printf("Leak of %d blocks found in xmlParseBalancedChunkMemoryRecover",
13665                    xmlMemBlocks() - mem_base);
13666             test_ret++;
13667             printf(" %d", n_doc);
13668             printf(" %d", n_sax);
13669             printf(" %d", n_user_data);
13670             printf(" %d", n_depth);
13671             printf(" %d", n_string);
13672             printf(" %d", n_lst);
13673             printf(" %d", n_recover);
13674             printf("\n");
13675         }
13676     }
13677     }
13678     }
13679     }
13680     }
13681     }
13682     }
13683     function_tests++;
13684 #endif
13685 #endif
13686
13687     return(test_ret);
13688 }
13689
13690
13691 static int
13692 test_xmlParseChunk(void) {
13693     int test_ret = 0;
13694
13695 #if defined(LIBXML_PUSH_ENABLED)
13696     int mem_base;
13697     int ret_val;
13698     xmlParserCtxtPtr ctxt; /* an XML parser context */
13699     int n_ctxt;
13700     char * chunk; /* an char array */
13701     int n_chunk;
13702     int size; /* the size in byte of the chunk */
13703     int n_size;
13704     int terminate; /* last chunk indicator */
13705     int n_terminate;
13706
13707     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
13708     for (n_chunk = 0;n_chunk < gen_nb_const_char_ptr;n_chunk++) {
13709     for (n_size = 0;n_size < gen_nb_int;n_size++) {
13710     for (n_terminate = 0;n_terminate < gen_nb_int;n_terminate++) {
13711         mem_base = xmlMemBlocks();
13712         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
13713         chunk = gen_const_char_ptr(n_chunk, 1);
13714         size = gen_int(n_size, 2);
13715         terminate = gen_int(n_terminate, 3);
13716
13717         ret_val = xmlParseChunk(ctxt, (const char *)chunk, size, terminate);
13718         if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;}
13719         desret_int(ret_val);
13720         call_tests++;
13721         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
13722         des_const_char_ptr(n_chunk, (const char *)chunk, 1);
13723         des_int(n_size, size, 2);
13724         des_int(n_terminate, terminate, 3);
13725         xmlResetLastError();
13726         if (mem_base != xmlMemBlocks()) {
13727             printf("Leak of %d blocks found in xmlParseChunk",
13728                    xmlMemBlocks() - mem_base);
13729             test_ret++;
13730             printf(" %d", n_ctxt);
13731             printf(" %d", n_chunk);
13732             printf(" %d", n_size);
13733             printf(" %d", n_terminate);
13734             printf("\n");
13735         }
13736     }
13737     }
13738     }
13739     }
13740     function_tests++;
13741 #endif
13742
13743     return(test_ret);
13744 }
13745
13746
13747 static int
13748 test_xmlParseCtxtExternalEntity(void) {
13749     int test_ret = 0;
13750
13751     int mem_base;
13752     int ret_val;
13753     xmlParserCtxtPtr ctx; /* the existing parsing context */
13754     int n_ctx;
13755     xmlChar * URL; /* the URL for the entity to load */
13756     int n_URL;
13757     xmlChar * ID; /* the System ID for the entity to load */
13758     int n_ID;
13759     xmlNodePtr * lst; /* the return value for the set of parsed nodes */
13760     int n_lst;
13761
13762     for (n_ctx = 0;n_ctx < gen_nb_xmlParserCtxtPtr;n_ctx++) {
13763     for (n_URL = 0;n_URL < gen_nb_const_xmlChar_ptr;n_URL++) {
13764     for (n_ID = 0;n_ID < gen_nb_const_xmlChar_ptr;n_ID++) {
13765     for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) {
13766         mem_base = xmlMemBlocks();
13767         ctx = gen_xmlParserCtxtPtr(n_ctx, 0);
13768         URL = gen_const_xmlChar_ptr(n_URL, 1);
13769         ID = gen_const_xmlChar_ptr(n_ID, 2);
13770         lst = gen_xmlNodePtr_ptr(n_lst, 3);
13771
13772         ret_val = xmlParseCtxtExternalEntity(ctx, (const xmlChar *)URL, (const xmlChar *)ID, lst);
13773         desret_int(ret_val);
13774         call_tests++;
13775         des_xmlParserCtxtPtr(n_ctx, ctx, 0);
13776         des_const_xmlChar_ptr(n_URL, (const xmlChar *)URL, 1);
13777         des_const_xmlChar_ptr(n_ID, (const xmlChar *)ID, 2);
13778         des_xmlNodePtr_ptr(n_lst, lst, 3);
13779         xmlResetLastError();
13780         if (mem_base != xmlMemBlocks()) {
13781             printf("Leak of %d blocks found in xmlParseCtxtExternalEntity",
13782                    xmlMemBlocks() - mem_base);
13783             test_ret++;
13784             printf(" %d", n_ctx);
13785             printf(" %d", n_URL);
13786             printf(" %d", n_ID);
13787             printf(" %d", n_lst);
13788             printf("\n");
13789         }
13790     }
13791     }
13792     }
13793     }
13794     function_tests++;
13795
13796     return(test_ret);
13797 }
13798
13799
13800 static int
13801 test_xmlParseDTD(void) {
13802     int test_ret = 0;
13803
13804 #if defined(LIBXML_VALID_ENABLED)
13805 #ifdef LIBXML_VALID_ENABLED
13806     int mem_base;
13807     xmlDtdPtr ret_val;
13808     xmlChar * ExternalID; /* a NAME* containing the External ID of the DTD */
13809     int n_ExternalID;
13810     xmlChar * SystemID; /* a NAME* containing the URL to the DTD */
13811     int n_SystemID;
13812
13813     for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
13814     for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
13815         mem_base = xmlMemBlocks();
13816         ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 0);
13817         SystemID = gen_const_xmlChar_ptr(n_SystemID, 1);
13818
13819         ret_val = xmlParseDTD((const xmlChar *)ExternalID, (const xmlChar *)SystemID);
13820         desret_xmlDtdPtr(ret_val);
13821         call_tests++;
13822         des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 0);
13823         des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 1);
13824         xmlResetLastError();
13825         if (mem_base != xmlMemBlocks()) {
13826             printf("Leak of %d blocks found in xmlParseDTD",
13827                    xmlMemBlocks() - mem_base);
13828             test_ret++;
13829             printf(" %d", n_ExternalID);
13830             printf(" %d", n_SystemID);
13831             printf("\n");
13832         }
13833     }
13834     }
13835     function_tests++;
13836 #endif
13837 #endif
13838
13839     return(test_ret);
13840 }
13841
13842
13843 static int
13844 test_xmlParseDoc(void) {
13845     int test_ret = 0;
13846
13847 #if defined(LIBXML_SAX1_ENABLED)
13848 #ifdef LIBXML_SAX1_ENABLED
13849     int mem_base;
13850     xmlDocPtr ret_val;
13851     xmlChar * cur; /* a pointer to an array of xmlChar */
13852     int n_cur;
13853
13854     for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
13855         mem_base = xmlMemBlocks();
13856         cur = gen_const_xmlChar_ptr(n_cur, 0);
13857
13858         ret_val = xmlParseDoc((const xmlChar *)cur);
13859         desret_xmlDocPtr(ret_val);
13860         call_tests++;
13861         des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
13862         xmlResetLastError();
13863         if (mem_base != xmlMemBlocks()) {
13864             printf("Leak of %d blocks found in xmlParseDoc",
13865                    xmlMemBlocks() - mem_base);
13866             test_ret++;
13867             printf(" %d", n_cur);
13868             printf("\n");
13869         }
13870     }
13871     function_tests++;
13872 #endif
13873 #endif
13874
13875     return(test_ret);
13876 }
13877
13878
13879 static int
13880 test_xmlParseDocument(void) {
13881     int test_ret = 0;
13882
13883     int mem_base;
13884     int ret_val;
13885     xmlParserCtxtPtr ctxt; /* an XML parser context */
13886     int n_ctxt;
13887
13888     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
13889         mem_base = xmlMemBlocks();
13890         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
13891
13892         ret_val = xmlParseDocument(ctxt);
13893         if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;}
13894         desret_int(ret_val);
13895         call_tests++;
13896         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
13897         xmlResetLastError();
13898         if (mem_base != xmlMemBlocks()) {
13899             printf("Leak of %d blocks found in xmlParseDocument",
13900                    xmlMemBlocks() - mem_base);
13901             test_ret++;
13902             printf(" %d", n_ctxt);
13903             printf("\n");
13904         }
13905     }
13906     function_tests++;
13907
13908     return(test_ret);
13909 }
13910
13911
13912 static int
13913 test_xmlParseEntity(void) {
13914     int test_ret = 0;
13915
13916 #if defined(LIBXML_SAX1_ENABLED)
13917 #ifdef LIBXML_SAX1_ENABLED
13918     int mem_base;
13919     xmlDocPtr ret_val;
13920     const char * filename; /* the filename */
13921     int n_filename;
13922
13923     for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
13924         mem_base = xmlMemBlocks();
13925         filename = gen_filepath(n_filename, 0);
13926
13927         ret_val = xmlParseEntity(filename);
13928         desret_xmlDocPtr(ret_val);
13929         call_tests++;
13930         des_filepath(n_filename, filename, 0);
13931         xmlResetLastError();
13932         if (mem_base != xmlMemBlocks()) {
13933             printf("Leak of %d blocks found in xmlParseEntity",
13934                    xmlMemBlocks() - mem_base);
13935             test_ret++;
13936             printf(" %d", n_filename);
13937             printf("\n");
13938         }
13939     }
13940     function_tests++;
13941 #endif
13942 #endif
13943
13944     return(test_ret);
13945 }
13946
13947
13948 static int
13949 test_xmlParseExtParsedEnt(void) {
13950     int test_ret = 0;
13951
13952     int mem_base;
13953     int ret_val;
13954     xmlParserCtxtPtr ctxt; /* an XML parser context */
13955     int n_ctxt;
13956
13957     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
13958         mem_base = xmlMemBlocks();
13959         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
13960
13961         ret_val = xmlParseExtParsedEnt(ctxt);
13962         if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;}
13963         desret_int(ret_val);
13964         call_tests++;
13965         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
13966         xmlResetLastError();
13967         if (mem_base != xmlMemBlocks()) {
13968             printf("Leak of %d blocks found in xmlParseExtParsedEnt",
13969                    xmlMemBlocks() - mem_base);
13970             test_ret++;
13971             printf(" %d", n_ctxt);
13972             printf("\n");
13973         }
13974     }
13975     function_tests++;
13976
13977     return(test_ret);
13978 }
13979
13980
13981 static int
13982 test_xmlParseExternalEntity(void) {
13983     int test_ret = 0;
13984
13985 #if defined(LIBXML_SAX1_ENABLED)
13986 #ifdef LIBXML_SAX1_ENABLED
13987     int mem_base;
13988     int ret_val;
13989     xmlDocPtr doc; /* the document the chunk pertains to */
13990     int n_doc;
13991     xmlSAXHandlerPtr sax; /* the SAX handler bloc (possibly NULL) */
13992     int n_sax;
13993     void * user_data; /* The user data returned on SAX callbacks (possibly NULL) */
13994     int n_user_data;
13995     int depth; /* Used for loop detection, use 0 */
13996     int n_depth;
13997     xmlChar * URL; /* the URL for the entity to load */
13998     int n_URL;
13999     xmlChar * ID; /* the System ID for the entity to load */
14000     int n_ID;
14001     xmlNodePtr * lst; /* the return value for the set of parsed nodes */
14002     int n_lst;
14003
14004     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
14005     for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
14006     for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
14007     for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
14008     for (n_URL = 0;n_URL < gen_nb_const_xmlChar_ptr;n_URL++) {
14009     for (n_ID = 0;n_ID < gen_nb_const_xmlChar_ptr;n_ID++) {
14010     for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) {
14011         mem_base = xmlMemBlocks();
14012         doc = gen_xmlDocPtr(n_doc, 0);
14013         sax = gen_xmlSAXHandlerPtr(n_sax, 1);
14014         user_data = gen_userdata(n_user_data, 2);
14015         depth = gen_int(n_depth, 3);
14016         URL = gen_const_xmlChar_ptr(n_URL, 4);
14017         ID = gen_const_xmlChar_ptr(n_ID, 5);
14018         lst = gen_xmlNodePtr_ptr(n_lst, 6);
14019
14020         ret_val = xmlParseExternalEntity(doc, sax, user_data, depth, (const xmlChar *)URL, (const xmlChar *)ID, lst);
14021         desret_int(ret_val);
14022         call_tests++;
14023         des_xmlDocPtr(n_doc, doc, 0);
14024         des_xmlSAXHandlerPtr(n_sax, sax, 1);
14025         des_userdata(n_user_data, user_data, 2);
14026         des_int(n_depth, depth, 3);
14027         des_const_xmlChar_ptr(n_URL, (const xmlChar *)URL, 4);
14028         des_const_xmlChar_ptr(n_ID, (const xmlChar *)ID, 5);
14029         des_xmlNodePtr_ptr(n_lst, lst, 6);
14030         xmlResetLastError();
14031         if (mem_base != xmlMemBlocks()) {
14032             printf("Leak of %d blocks found in xmlParseExternalEntity",
14033                    xmlMemBlocks() - mem_base);
14034             test_ret++;
14035             printf(" %d", n_doc);
14036             printf(" %d", n_sax);
14037             printf(" %d", n_user_data);
14038             printf(" %d", n_depth);
14039             printf(" %d", n_URL);
14040             printf(" %d", n_ID);
14041             printf(" %d", n_lst);
14042             printf("\n");
14043         }
14044     }
14045     }
14046     }
14047     }
14048     }
14049     }
14050     }
14051     function_tests++;
14052 #endif
14053 #endif
14054
14055     return(test_ret);
14056 }
14057
14058
14059 static int
14060 test_xmlParseFile(void) {
14061     int test_ret = 0;
14062
14063 #if defined(LIBXML_SAX1_ENABLED)
14064 #ifdef LIBXML_SAX1_ENABLED
14065     int mem_base;
14066     xmlDocPtr ret_val;
14067     const char * filename; /* the filename */
14068     int n_filename;
14069
14070     for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
14071         mem_base = xmlMemBlocks();
14072         filename = gen_filepath(n_filename, 0);
14073
14074         ret_val = xmlParseFile(filename);
14075         desret_xmlDocPtr(ret_val);
14076         call_tests++;
14077         des_filepath(n_filename, filename, 0);
14078         xmlResetLastError();
14079         if (mem_base != xmlMemBlocks()) {
14080             printf("Leak of %d blocks found in xmlParseFile",
14081                    xmlMemBlocks() - mem_base);
14082             test_ret++;
14083             printf(" %d", n_filename);
14084             printf("\n");
14085         }
14086     }
14087     function_tests++;
14088 #endif
14089 #endif
14090
14091     return(test_ret);
14092 }
14093
14094
14095 static int
14096 test_xmlParseInNodeContext(void) {
14097     int test_ret = 0;
14098
14099     int mem_base;
14100     xmlParserErrors ret_val;
14101     xmlNodePtr node; /* the context node */
14102     int n_node;
14103     char * data; /* the input string */
14104     int n_data;
14105     int datalen; /* the input string length in bytes */
14106     int n_datalen;
14107     int options; /* a combination of xmlParserOption */
14108     int n_options;
14109     xmlNodePtr * lst; /* the return value for the set of parsed nodes */
14110     int n_lst;
14111
14112     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
14113     for (n_data = 0;n_data < gen_nb_const_char_ptr;n_data++) {
14114     for (n_datalen = 0;n_datalen < gen_nb_int;n_datalen++) {
14115     for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
14116     for (n_lst = 0;n_lst < gen_nb_xmlNodePtr_ptr;n_lst++) {
14117         mem_base = xmlMemBlocks();
14118         node = gen_xmlNodePtr(n_node, 0);
14119         data = gen_const_char_ptr(n_data, 1);
14120         datalen = gen_int(n_datalen, 2);
14121         options = gen_parseroptions(n_options, 3);
14122         lst = gen_xmlNodePtr_ptr(n_lst, 4);
14123
14124         ret_val = xmlParseInNodeContext(node, (const char *)data, datalen, options, lst);
14125         desret_xmlParserErrors(ret_val);
14126         call_tests++;
14127         des_xmlNodePtr(n_node, node, 0);
14128         des_const_char_ptr(n_data, (const char *)data, 1);
14129         des_int(n_datalen, datalen, 2);
14130         des_parseroptions(n_options, options, 3);
14131         des_xmlNodePtr_ptr(n_lst, lst, 4);
14132         xmlResetLastError();
14133         if (mem_base != xmlMemBlocks()) {
14134             printf("Leak of %d blocks found in xmlParseInNodeContext",
14135                    xmlMemBlocks() - mem_base);
14136             test_ret++;
14137             printf(" %d", n_node);
14138             printf(" %d", n_data);
14139             printf(" %d", n_datalen);
14140             printf(" %d", n_options);
14141             printf(" %d", n_lst);
14142             printf("\n");
14143         }
14144     }
14145     }
14146     }
14147     }
14148     }
14149     function_tests++;
14150
14151     return(test_ret);
14152 }
14153
14154
14155 static int
14156 test_xmlParseMemory(void) {
14157     int test_ret = 0;
14158
14159 #if defined(LIBXML_SAX1_ENABLED)
14160 #ifdef LIBXML_SAX1_ENABLED
14161     int mem_base;
14162     xmlDocPtr ret_val;
14163     char * buffer; /* an pointer to a char array */
14164     int n_buffer;
14165     int size; /* the size of the array */
14166     int n_size;
14167
14168     for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
14169     for (n_size = 0;n_size < gen_nb_int;n_size++) {
14170         mem_base = xmlMemBlocks();
14171         buffer = gen_const_char_ptr(n_buffer, 0);
14172         size = gen_int(n_size, 1);
14173
14174         ret_val = xmlParseMemory((const char *)buffer, size);
14175         desret_xmlDocPtr(ret_val);
14176         call_tests++;
14177         des_const_char_ptr(n_buffer, (const char *)buffer, 0);
14178         des_int(n_size, size, 1);
14179         xmlResetLastError();
14180         if (mem_base != xmlMemBlocks()) {
14181             printf("Leak of %d blocks found in xmlParseMemory",
14182                    xmlMemBlocks() - mem_base);
14183             test_ret++;
14184             printf(" %d", n_buffer);
14185             printf(" %d", n_size);
14186             printf("\n");
14187         }
14188     }
14189     }
14190     function_tests++;
14191 #endif
14192 #endif
14193
14194     return(test_ret);
14195 }
14196
14197
14198 #define gen_nb_const_xmlParserNodeInfoPtr 1
14199 static xmlParserNodeInfoPtr gen_const_xmlParserNodeInfoPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14200     return(NULL);
14201 }
14202 static void des_const_xmlParserNodeInfoPtr(int no ATTRIBUTE_UNUSED, const xmlParserNodeInfoPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14203 }
14204
14205 static int
14206 test_xmlParserAddNodeInfo(void) {
14207     int test_ret = 0;
14208
14209     int mem_base;
14210     xmlParserCtxtPtr ctxt; /* an XML parser context */
14211     int n_ctxt;
14212     xmlParserNodeInfoPtr info; /* a node info sequence pointer */
14213     int n_info;
14214
14215     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
14216     for (n_info = 0;n_info < gen_nb_const_xmlParserNodeInfoPtr;n_info++) {
14217         mem_base = xmlMemBlocks();
14218         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
14219         info = gen_const_xmlParserNodeInfoPtr(n_info, 1);
14220
14221         xmlParserAddNodeInfo(ctxt, (const xmlParserNodeInfoPtr)info);
14222         call_tests++;
14223         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
14224         des_const_xmlParserNodeInfoPtr(n_info, (const xmlParserNodeInfoPtr)info, 1);
14225         xmlResetLastError();
14226         if (mem_base != xmlMemBlocks()) {
14227             printf("Leak of %d blocks found in xmlParserAddNodeInfo",
14228                    xmlMemBlocks() - mem_base);
14229             test_ret++;
14230             printf(" %d", n_ctxt);
14231             printf(" %d", n_info);
14232             printf("\n");
14233         }
14234     }
14235     }
14236     function_tests++;
14237
14238     return(test_ret);
14239 }
14240
14241
14242 #define gen_nb_const_xmlParserCtxtPtr 1
14243 static xmlParserCtxtPtr gen_const_xmlParserCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14244     return(NULL);
14245 }
14246 static void des_const_xmlParserCtxtPtr(int no ATTRIBUTE_UNUSED, const xmlParserCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14247 }
14248
14249 #define gen_nb_const_xmlNodePtr 1
14250 static xmlNodePtr gen_const_xmlNodePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14251     return(NULL);
14252 }
14253 static void des_const_xmlNodePtr(int no ATTRIBUTE_UNUSED, const xmlNodePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14254 }
14255
14256 static int
14257 test_xmlParserFindNodeInfo(void) {
14258     int test_ret = 0;
14259
14260     int mem_base;
14261     const xmlParserNodeInfo * ret_val;
14262     xmlParserCtxtPtr ctx; /* an XML parser context */
14263     int n_ctx;
14264     xmlNodePtr node; /* an XML node within the tree */
14265     int n_node;
14266
14267     for (n_ctx = 0;n_ctx < gen_nb_const_xmlParserCtxtPtr;n_ctx++) {
14268     for (n_node = 0;n_node < gen_nb_const_xmlNodePtr;n_node++) {
14269         mem_base = xmlMemBlocks();
14270         ctx = gen_const_xmlParserCtxtPtr(n_ctx, 0);
14271         node = gen_const_xmlNodePtr(n_node, 1);
14272
14273         ret_val = xmlParserFindNodeInfo((const xmlParserCtxtPtr)ctx, (const xmlNodePtr)node);
14274         desret_const_xmlParserNodeInfo_ptr(ret_val);
14275         call_tests++;
14276         des_const_xmlParserCtxtPtr(n_ctx, (const xmlParserCtxtPtr)ctx, 0);
14277         des_const_xmlNodePtr(n_node, (const xmlNodePtr)node, 1);
14278         xmlResetLastError();
14279         if (mem_base != xmlMemBlocks()) {
14280             printf("Leak of %d blocks found in xmlParserFindNodeInfo",
14281                    xmlMemBlocks() - mem_base);
14282             test_ret++;
14283             printf(" %d", n_ctx);
14284             printf(" %d", n_node);
14285             printf("\n");
14286         }
14287     }
14288     }
14289     function_tests++;
14290
14291     return(test_ret);
14292 }
14293
14294
14295 #define gen_nb_const_xmlParserNodeInfoSeqPtr 1
14296 static xmlParserNodeInfoSeqPtr gen_const_xmlParserNodeInfoSeqPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14297     return(NULL);
14298 }
14299 static void des_const_xmlParserNodeInfoSeqPtr(int no ATTRIBUTE_UNUSED, const xmlParserNodeInfoSeqPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14300 }
14301
14302 static int
14303 test_xmlParserFindNodeInfoIndex(void) {
14304     int test_ret = 0;
14305
14306     int mem_base;
14307     unsigned long ret_val;
14308     xmlParserNodeInfoSeqPtr seq; /* a node info sequence pointer */
14309     int n_seq;
14310     xmlNodePtr node; /* an XML node pointer */
14311     int n_node;
14312
14313     for (n_seq = 0;n_seq < gen_nb_const_xmlParserNodeInfoSeqPtr;n_seq++) {
14314     for (n_node = 0;n_node < gen_nb_const_xmlNodePtr;n_node++) {
14315         mem_base = xmlMemBlocks();
14316         seq = gen_const_xmlParserNodeInfoSeqPtr(n_seq, 0);
14317         node = gen_const_xmlNodePtr(n_node, 1);
14318
14319         ret_val = xmlParserFindNodeInfoIndex((const xmlParserNodeInfoSeqPtr)seq, (const xmlNodePtr)node);
14320         desret_unsigned_long(ret_val);
14321         call_tests++;
14322         des_const_xmlParserNodeInfoSeqPtr(n_seq, (const xmlParserNodeInfoSeqPtr)seq, 0);
14323         des_const_xmlNodePtr(n_node, (const xmlNodePtr)node, 1);
14324         xmlResetLastError();
14325         if (mem_base != xmlMemBlocks()) {
14326             printf("Leak of %d blocks found in xmlParserFindNodeInfoIndex",
14327                    xmlMemBlocks() - mem_base);
14328             test_ret++;
14329             printf(" %d", n_seq);
14330             printf(" %d", n_node);
14331             printf("\n");
14332         }
14333     }
14334     }
14335     function_tests++;
14336
14337     return(test_ret);
14338 }
14339
14340
14341 #define gen_nb_xmlParserInputPtr 1
14342 static xmlParserInputPtr gen_xmlParserInputPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14343     return(NULL);
14344 }
14345 static void des_xmlParserInputPtr(int no ATTRIBUTE_UNUSED, xmlParserInputPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
14346 }
14347
14348 static int
14349 test_xmlParserInputGrow(void) {
14350     int test_ret = 0;
14351
14352     int mem_base;
14353     int ret_val;
14354     xmlParserInputPtr in; /* an XML parser input */
14355     int n_in;
14356     int len; /* an indicative size for the lookahead */
14357     int n_len;
14358
14359     for (n_in = 0;n_in < gen_nb_xmlParserInputPtr;n_in++) {
14360     for (n_len = 0;n_len < gen_nb_int;n_len++) {
14361         mem_base = xmlMemBlocks();
14362         in = gen_xmlParserInputPtr(n_in, 0);
14363         len = gen_int(n_len, 1);
14364
14365         ret_val = xmlParserInputGrow(in, len);
14366         desret_int(ret_val);
14367         call_tests++;
14368         des_xmlParserInputPtr(n_in, in, 0);
14369         des_int(n_len, len, 1);
14370         xmlResetLastError();
14371         if (mem_base != xmlMemBlocks()) {
14372             printf("Leak of %d blocks found in xmlParserInputGrow",
14373                    xmlMemBlocks() - mem_base);
14374             test_ret++;
14375             printf(" %d", n_in);
14376             printf(" %d", n_len);
14377             printf("\n");
14378         }
14379     }
14380     }
14381     function_tests++;
14382
14383     return(test_ret);
14384 }
14385
14386
14387 static int
14388 test_xmlParserInputRead(void) {
14389     int test_ret = 0;
14390
14391     int mem_base;
14392     int ret_val;
14393     xmlParserInputPtr in; /* an XML parser input */
14394     int n_in;
14395     int len; /* an indicative size for the lookahead */
14396     int n_len;
14397
14398     for (n_in = 0;n_in < gen_nb_xmlParserInputPtr;n_in++) {
14399     for (n_len = 0;n_len < gen_nb_int;n_len++) {
14400         mem_base = xmlMemBlocks();
14401         in = gen_xmlParserInputPtr(n_in, 0);
14402         len = gen_int(n_len, 1);
14403
14404         ret_val = xmlParserInputRead(in, len);
14405         desret_int(ret_val);
14406         call_tests++;
14407         des_xmlParserInputPtr(n_in, in, 0);
14408         des_int(n_len, len, 1);
14409         xmlResetLastError();
14410         if (mem_base != xmlMemBlocks()) {
14411             printf("Leak of %d blocks found in xmlParserInputRead",
14412                    xmlMemBlocks() - mem_base);
14413             test_ret++;
14414             printf(" %d", n_in);
14415             printf(" %d", n_len);
14416             printf("\n");
14417         }
14418     }
14419     }
14420     function_tests++;
14421
14422     return(test_ret);
14423 }
14424
14425
14426 static int
14427 test_xmlPedanticParserDefault(void) {
14428     int test_ret = 0;
14429
14430     int mem_base;
14431     int ret_val;
14432     int val; /* int 0 or 1 */
14433     int n_val;
14434
14435     for (n_val = 0;n_val < gen_nb_int;n_val++) {
14436         mem_base = xmlMemBlocks();
14437         val = gen_int(n_val, 0);
14438
14439         ret_val = xmlPedanticParserDefault(val);
14440         desret_int(ret_val);
14441         call_tests++;
14442         des_int(n_val, val, 0);
14443         xmlResetLastError();
14444         if (mem_base != xmlMemBlocks()) {
14445             printf("Leak of %d blocks found in xmlPedanticParserDefault",
14446                    xmlMemBlocks() - mem_base);
14447             test_ret++;
14448             printf(" %d", n_val);
14449             printf("\n");
14450         }
14451     }
14452     function_tests++;
14453
14454     return(test_ret);
14455 }
14456
14457
14458 static int
14459 test_xmlReadDoc(void) {
14460     int test_ret = 0;
14461
14462     int mem_base;
14463     xmlDocPtr ret_val;
14464     xmlChar * cur; /* a pointer to a zero terminated string */
14465     int n_cur;
14466     const char * URL; /* the base URL to use for the document */
14467     int n_URL;
14468     char * encoding; /* the document encoding, or NULL */
14469     int n_encoding;
14470     int options; /* a combination of xmlParserOption */
14471     int n_options;
14472
14473     for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
14474     for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
14475     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
14476     for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
14477         mem_base = xmlMemBlocks();
14478         cur = gen_const_xmlChar_ptr(n_cur, 0);
14479         URL = gen_filepath(n_URL, 1);
14480         encoding = gen_const_char_ptr(n_encoding, 2);
14481         options = gen_parseroptions(n_options, 3);
14482
14483         ret_val = xmlReadDoc((const xmlChar *)cur, URL, (const char *)encoding, options);
14484         desret_xmlDocPtr(ret_val);
14485         call_tests++;
14486         des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
14487         des_filepath(n_URL, URL, 1);
14488         des_const_char_ptr(n_encoding, (const char *)encoding, 2);
14489         des_parseroptions(n_options, options, 3);
14490         xmlResetLastError();
14491         if (mem_base != xmlMemBlocks()) {
14492             printf("Leak of %d blocks found in xmlReadDoc",
14493                    xmlMemBlocks() - mem_base);
14494             test_ret++;
14495             printf(" %d", n_cur);
14496             printf(" %d", n_URL);
14497             printf(" %d", n_encoding);
14498             printf(" %d", n_options);
14499             printf("\n");
14500         }
14501     }
14502     }
14503     }
14504     }
14505     function_tests++;
14506
14507     return(test_ret);
14508 }
14509
14510
14511 static int
14512 test_xmlReadFile(void) {
14513     int test_ret = 0;
14514
14515     int mem_base;
14516     xmlDocPtr ret_val;
14517     const char * filename; /* a file or URL */
14518     int n_filename;
14519     char * encoding; /* the document encoding, or NULL */
14520     int n_encoding;
14521     int options; /* a combination of xmlParserOption */
14522     int n_options;
14523
14524     for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
14525     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
14526     for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
14527         mem_base = xmlMemBlocks();
14528         filename = gen_filepath(n_filename, 0);
14529         encoding = gen_const_char_ptr(n_encoding, 1);
14530         options = gen_parseroptions(n_options, 2);
14531
14532         ret_val = xmlReadFile(filename, (const char *)encoding, options);
14533         desret_xmlDocPtr(ret_val);
14534         call_tests++;
14535         des_filepath(n_filename, filename, 0);
14536         des_const_char_ptr(n_encoding, (const char *)encoding, 1);
14537         des_parseroptions(n_options, options, 2);
14538         xmlResetLastError();
14539         if (mem_base != xmlMemBlocks()) {
14540             printf("Leak of %d blocks found in xmlReadFile",
14541                    xmlMemBlocks() - mem_base);
14542             test_ret++;
14543             printf(" %d", n_filename);
14544             printf(" %d", n_encoding);
14545             printf(" %d", n_options);
14546             printf("\n");
14547         }
14548     }
14549     }
14550     }
14551     function_tests++;
14552
14553     return(test_ret);
14554 }
14555
14556
14557 static int
14558 test_xmlReadMemory(void) {
14559     int test_ret = 0;
14560
14561     int mem_base;
14562     xmlDocPtr ret_val;
14563     char * buffer; /* a pointer to a char array */
14564     int n_buffer;
14565     int size; /* the size of the array */
14566     int n_size;
14567     const char * URL; /* the base URL to use for the document */
14568     int n_URL;
14569     char * encoding; /* the document encoding, or NULL */
14570     int n_encoding;
14571     int options; /* a combination of xmlParserOption */
14572     int n_options;
14573
14574     for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
14575     for (n_size = 0;n_size < gen_nb_int;n_size++) {
14576     for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
14577     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
14578     for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
14579         mem_base = xmlMemBlocks();
14580         buffer = gen_const_char_ptr(n_buffer, 0);
14581         size = gen_int(n_size, 1);
14582         URL = gen_filepath(n_URL, 2);
14583         encoding = gen_const_char_ptr(n_encoding, 3);
14584         options = gen_parseroptions(n_options, 4);
14585
14586         ret_val = xmlReadMemory((const char *)buffer, size, URL, (const char *)encoding, options);
14587         desret_xmlDocPtr(ret_val);
14588         call_tests++;
14589         des_const_char_ptr(n_buffer, (const char *)buffer, 0);
14590         des_int(n_size, size, 1);
14591         des_filepath(n_URL, URL, 2);
14592         des_const_char_ptr(n_encoding, (const char *)encoding, 3);
14593         des_parseroptions(n_options, options, 4);
14594         xmlResetLastError();
14595         if (mem_base != xmlMemBlocks()) {
14596             printf("Leak of %d blocks found in xmlReadMemory",
14597                    xmlMemBlocks() - mem_base);
14598             test_ret++;
14599             printf(" %d", n_buffer);
14600             printf(" %d", n_size);
14601             printf(" %d", n_URL);
14602             printf(" %d", n_encoding);
14603             printf(" %d", n_options);
14604             printf("\n");
14605         }
14606     }
14607     }
14608     }
14609     }
14610     }
14611     function_tests++;
14612
14613     return(test_ret);
14614 }
14615
14616
14617 static int
14618 test_xmlRecoverDoc(void) {
14619     int test_ret = 0;
14620
14621 #if defined(LIBXML_SAX1_ENABLED)
14622 #ifdef LIBXML_SAX1_ENABLED
14623     int mem_base;
14624     xmlDocPtr ret_val;
14625     xmlChar * cur; /* a pointer to an array of xmlChar */
14626     int n_cur;
14627
14628     for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
14629         mem_base = xmlMemBlocks();
14630         cur = gen_const_xmlChar_ptr(n_cur, 0);
14631
14632         ret_val = xmlRecoverDoc((const xmlChar *)cur);
14633         desret_xmlDocPtr(ret_val);
14634         call_tests++;
14635         des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
14636         xmlResetLastError();
14637         if (mem_base != xmlMemBlocks()) {
14638             printf("Leak of %d blocks found in xmlRecoverDoc",
14639                    xmlMemBlocks() - mem_base);
14640             test_ret++;
14641             printf(" %d", n_cur);
14642             printf("\n");
14643         }
14644     }
14645     function_tests++;
14646 #endif
14647 #endif
14648
14649     return(test_ret);
14650 }
14651
14652
14653 static int
14654 test_xmlRecoverFile(void) {
14655     int test_ret = 0;
14656
14657 #if defined(LIBXML_SAX1_ENABLED)
14658 #ifdef LIBXML_SAX1_ENABLED
14659     int mem_base;
14660     xmlDocPtr ret_val;
14661     const char * filename; /* the filename */
14662     int n_filename;
14663
14664     for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
14665         mem_base = xmlMemBlocks();
14666         filename = gen_filepath(n_filename, 0);
14667
14668         ret_val = xmlRecoverFile(filename);
14669         desret_xmlDocPtr(ret_val);
14670         call_tests++;
14671         des_filepath(n_filename, filename, 0);
14672         xmlResetLastError();
14673         if (mem_base != xmlMemBlocks()) {
14674             printf("Leak of %d blocks found in xmlRecoverFile",
14675                    xmlMemBlocks() - mem_base);
14676             test_ret++;
14677             printf(" %d", n_filename);
14678             printf("\n");
14679         }
14680     }
14681     function_tests++;
14682 #endif
14683 #endif
14684
14685     return(test_ret);
14686 }
14687
14688
14689 static int
14690 test_xmlRecoverMemory(void) {
14691     int test_ret = 0;
14692
14693 #if defined(LIBXML_SAX1_ENABLED)
14694 #ifdef LIBXML_SAX1_ENABLED
14695     int mem_base;
14696     xmlDocPtr ret_val;
14697     char * buffer; /* an pointer to a char array */
14698     int n_buffer;
14699     int size; /* the size of the array */
14700     int n_size;
14701
14702     for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
14703     for (n_size = 0;n_size < gen_nb_int;n_size++) {
14704         mem_base = xmlMemBlocks();
14705         buffer = gen_const_char_ptr(n_buffer, 0);
14706         size = gen_int(n_size, 1);
14707
14708         ret_val = xmlRecoverMemory((const char *)buffer, size);
14709         desret_xmlDocPtr(ret_val);
14710         call_tests++;
14711         des_const_char_ptr(n_buffer, (const char *)buffer, 0);
14712         des_int(n_size, size, 1);
14713         xmlResetLastError();
14714         if (mem_base != xmlMemBlocks()) {
14715             printf("Leak of %d blocks found in xmlRecoverMemory",
14716                    xmlMemBlocks() - mem_base);
14717             test_ret++;
14718             printf(" %d", n_buffer);
14719             printf(" %d", n_size);
14720             printf("\n");
14721         }
14722     }
14723     }
14724     function_tests++;
14725 #endif
14726 #endif
14727
14728     return(test_ret);
14729 }
14730
14731
14732 static int
14733 test_xmlSAXParseDTD(void) {
14734     int test_ret = 0;
14735
14736 #if defined(LIBXML_VALID_ENABLED)
14737 #ifdef LIBXML_SAX1_ENABLED
14738     int mem_base;
14739     xmlDtdPtr ret_val;
14740     xmlSAXHandlerPtr sax; /* the SAX handler block */
14741     int n_sax;
14742     xmlChar * ExternalID; /* a NAME* containing the External ID of the DTD */
14743     int n_ExternalID;
14744     xmlChar * SystemID; /* a NAME* containing the URL to the DTD */
14745     int n_SystemID;
14746
14747     for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
14748     for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
14749     for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
14750         mem_base = xmlMemBlocks();
14751         sax = gen_xmlSAXHandlerPtr(n_sax, 0);
14752         ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 1);
14753         SystemID = gen_const_xmlChar_ptr(n_SystemID, 2);
14754
14755         ret_val = xmlSAXParseDTD(sax, (const xmlChar *)ExternalID, (const xmlChar *)SystemID);
14756         desret_xmlDtdPtr(ret_val);
14757         call_tests++;
14758         des_xmlSAXHandlerPtr(n_sax, sax, 0);
14759         des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 1);
14760         des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 2);
14761         xmlResetLastError();
14762         if (mem_base != xmlMemBlocks()) {
14763             printf("Leak of %d blocks found in xmlSAXParseDTD",
14764                    xmlMemBlocks() - mem_base);
14765             test_ret++;
14766             printf(" %d", n_sax);
14767             printf(" %d", n_ExternalID);
14768             printf(" %d", n_SystemID);
14769             printf("\n");
14770         }
14771     }
14772     }
14773     }
14774     function_tests++;
14775 #endif
14776 #endif
14777
14778     return(test_ret);
14779 }
14780
14781
14782 static int
14783 test_xmlSAXParseDoc(void) {
14784     int test_ret = 0;
14785
14786 #if defined(LIBXML_SAX1_ENABLED)
14787 #ifdef LIBXML_SAX1_ENABLED
14788     int mem_base;
14789     xmlDocPtr ret_val;
14790     xmlSAXHandlerPtr sax; /* the SAX handler block */
14791     int n_sax;
14792     xmlChar * cur; /* a pointer to an array of xmlChar */
14793     int n_cur;
14794     int recovery; /* work in recovery mode, i.e. tries to read no Well Formed documents */
14795     int n_recovery;
14796
14797     for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
14798     for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
14799     for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) {
14800         mem_base = xmlMemBlocks();
14801         sax = gen_xmlSAXHandlerPtr(n_sax, 0);
14802         cur = gen_const_xmlChar_ptr(n_cur, 1);
14803         recovery = gen_int(n_recovery, 2);
14804
14805         ret_val = xmlSAXParseDoc(sax, (const xmlChar *)cur, recovery);
14806         desret_xmlDocPtr(ret_val);
14807         call_tests++;
14808         des_xmlSAXHandlerPtr(n_sax, sax, 0);
14809         des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 1);
14810         des_int(n_recovery, recovery, 2);
14811         xmlResetLastError();
14812         if (mem_base != xmlMemBlocks()) {
14813             printf("Leak of %d blocks found in xmlSAXParseDoc",
14814                    xmlMemBlocks() - mem_base);
14815             test_ret++;
14816             printf(" %d", n_sax);
14817             printf(" %d", n_cur);
14818             printf(" %d", n_recovery);
14819             printf("\n");
14820         }
14821     }
14822     }
14823     }
14824     function_tests++;
14825 #endif
14826 #endif
14827
14828     return(test_ret);
14829 }
14830
14831
14832 static int
14833 test_xmlSAXParseEntity(void) {
14834     int test_ret = 0;
14835
14836 #if defined(LIBXML_SAX1_ENABLED)
14837 #ifdef LIBXML_SAX1_ENABLED
14838     int mem_base;
14839     xmlDocPtr ret_val;
14840     xmlSAXHandlerPtr sax; /* the SAX handler block */
14841     int n_sax;
14842     const char * filename; /* the filename */
14843     int n_filename;
14844
14845     for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
14846     for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
14847         mem_base = xmlMemBlocks();
14848         sax = gen_xmlSAXHandlerPtr(n_sax, 0);
14849         filename = gen_filepath(n_filename, 1);
14850
14851         ret_val = xmlSAXParseEntity(sax, filename);
14852         desret_xmlDocPtr(ret_val);
14853         call_tests++;
14854         des_xmlSAXHandlerPtr(n_sax, sax, 0);
14855         des_filepath(n_filename, filename, 1);
14856         xmlResetLastError();
14857         if (mem_base != xmlMemBlocks()) {
14858             printf("Leak of %d blocks found in xmlSAXParseEntity",
14859                    xmlMemBlocks() - mem_base);
14860             test_ret++;
14861             printf(" %d", n_sax);
14862             printf(" %d", n_filename);
14863             printf("\n");
14864         }
14865     }
14866     }
14867     function_tests++;
14868 #endif
14869 #endif
14870
14871     return(test_ret);
14872 }
14873
14874
14875 static int
14876 test_xmlSAXParseFile(void) {
14877     int test_ret = 0;
14878
14879 #if defined(LIBXML_SAX1_ENABLED)
14880 #ifdef LIBXML_SAX1_ENABLED
14881     int mem_base;
14882     xmlDocPtr ret_val;
14883     xmlSAXHandlerPtr sax; /* the SAX handler block */
14884     int n_sax;
14885     const char * filename; /* the filename */
14886     int n_filename;
14887     int recovery; /* work in recovery mode, i.e. tries to read no Well Formed documents */
14888     int n_recovery;
14889
14890     for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
14891     for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
14892     for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) {
14893         mem_base = xmlMemBlocks();
14894         sax = gen_xmlSAXHandlerPtr(n_sax, 0);
14895         filename = gen_filepath(n_filename, 1);
14896         recovery = gen_int(n_recovery, 2);
14897
14898         ret_val = xmlSAXParseFile(sax, filename, recovery);
14899         desret_xmlDocPtr(ret_val);
14900         call_tests++;
14901         des_xmlSAXHandlerPtr(n_sax, sax, 0);
14902         des_filepath(n_filename, filename, 1);
14903         des_int(n_recovery, recovery, 2);
14904         xmlResetLastError();
14905         if (mem_base != xmlMemBlocks()) {
14906             printf("Leak of %d blocks found in xmlSAXParseFile",
14907                    xmlMemBlocks() - mem_base);
14908             test_ret++;
14909             printf(" %d", n_sax);
14910             printf(" %d", n_filename);
14911             printf(" %d", n_recovery);
14912             printf("\n");
14913         }
14914     }
14915     }
14916     }
14917     function_tests++;
14918 #endif
14919 #endif
14920
14921     return(test_ret);
14922 }
14923
14924
14925 static int
14926 test_xmlSAXParseFileWithData(void) {
14927     int test_ret = 0;
14928
14929 #if defined(LIBXML_SAX1_ENABLED)
14930 #ifdef LIBXML_SAX1_ENABLED
14931     int mem_base;
14932     xmlDocPtr ret_val;
14933     xmlSAXHandlerPtr sax; /* the SAX handler block */
14934     int n_sax;
14935     const char * filename; /* the filename */
14936     int n_filename;
14937     int recovery; /* work in recovery mode, i.e. tries to read no Well Formed documents */
14938     int n_recovery;
14939     void * data; /* the userdata */
14940     int n_data;
14941
14942     for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
14943     for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
14944     for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) {
14945     for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
14946         mem_base = xmlMemBlocks();
14947         sax = gen_xmlSAXHandlerPtr(n_sax, 0);
14948         filename = gen_filepath(n_filename, 1);
14949         recovery = gen_int(n_recovery, 2);
14950         data = gen_userdata(n_data, 3);
14951
14952         ret_val = xmlSAXParseFileWithData(sax, filename, recovery, data);
14953         desret_xmlDocPtr(ret_val);
14954         call_tests++;
14955         des_xmlSAXHandlerPtr(n_sax, sax, 0);
14956         des_filepath(n_filename, filename, 1);
14957         des_int(n_recovery, recovery, 2);
14958         des_userdata(n_data, data, 3);
14959         xmlResetLastError();
14960         if (mem_base != xmlMemBlocks()) {
14961             printf("Leak of %d blocks found in xmlSAXParseFileWithData",
14962                    xmlMemBlocks() - mem_base);
14963             test_ret++;
14964             printf(" %d", n_sax);
14965             printf(" %d", n_filename);
14966             printf(" %d", n_recovery);
14967             printf(" %d", n_data);
14968             printf("\n");
14969         }
14970     }
14971     }
14972     }
14973     }
14974     function_tests++;
14975 #endif
14976 #endif
14977
14978     return(test_ret);
14979 }
14980
14981
14982 static int
14983 test_xmlSAXParseMemory(void) {
14984     int test_ret = 0;
14985
14986 #if defined(LIBXML_SAX1_ENABLED)
14987 #ifdef LIBXML_SAX1_ENABLED
14988     int mem_base;
14989     xmlDocPtr ret_val;
14990     xmlSAXHandlerPtr sax; /* the SAX handler block */
14991     int n_sax;
14992     char * buffer; /* an pointer to a char array */
14993     int n_buffer;
14994     int size; /* the size of the array */
14995     int n_size;
14996     int recovery; /* work in recovery mode, i.e. tries to read not Well Formed documents */
14997     int n_recovery;
14998
14999     for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
15000     for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
15001     for (n_size = 0;n_size < gen_nb_int;n_size++) {
15002     for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) {
15003         mem_base = xmlMemBlocks();
15004         sax = gen_xmlSAXHandlerPtr(n_sax, 0);
15005         buffer = gen_const_char_ptr(n_buffer, 1);
15006         size = gen_int(n_size, 2);
15007         recovery = gen_int(n_recovery, 3);
15008
15009         ret_val = xmlSAXParseMemory(sax, (const char *)buffer, size, recovery);
15010         desret_xmlDocPtr(ret_val);
15011         call_tests++;
15012         des_xmlSAXHandlerPtr(n_sax, sax, 0);
15013         des_const_char_ptr(n_buffer, (const char *)buffer, 1);
15014         des_int(n_size, size, 2);
15015         des_int(n_recovery, recovery, 3);
15016         xmlResetLastError();
15017         if (mem_base != xmlMemBlocks()) {
15018             printf("Leak of %d blocks found in xmlSAXParseMemory",
15019                    xmlMemBlocks() - mem_base);
15020             test_ret++;
15021             printf(" %d", n_sax);
15022             printf(" %d", n_buffer);
15023             printf(" %d", n_size);
15024             printf(" %d", n_recovery);
15025             printf("\n");
15026         }
15027     }
15028     }
15029     }
15030     }
15031     function_tests++;
15032 #endif
15033 #endif
15034
15035     return(test_ret);
15036 }
15037
15038
15039 static int
15040 test_xmlSAXParseMemoryWithData(void) {
15041     int test_ret = 0;
15042
15043 #if defined(LIBXML_SAX1_ENABLED)
15044 #ifdef LIBXML_SAX1_ENABLED
15045     int mem_base;
15046     xmlDocPtr ret_val;
15047     xmlSAXHandlerPtr sax; /* the SAX handler block */
15048     int n_sax;
15049     char * buffer; /* an pointer to a char array */
15050     int n_buffer;
15051     int size; /* the size of the array */
15052     int n_size;
15053     int recovery; /* work in recovery mode, i.e. tries to read no Well Formed documents */
15054     int n_recovery;
15055     void * data; /* the userdata */
15056     int n_data;
15057
15058     for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
15059     for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
15060     for (n_size = 0;n_size < gen_nb_int;n_size++) {
15061     for (n_recovery = 0;n_recovery < gen_nb_int;n_recovery++) {
15062     for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
15063         mem_base = xmlMemBlocks();
15064         sax = gen_xmlSAXHandlerPtr(n_sax, 0);
15065         buffer = gen_const_char_ptr(n_buffer, 1);
15066         size = gen_int(n_size, 2);
15067         recovery = gen_int(n_recovery, 3);
15068         data = gen_userdata(n_data, 4);
15069
15070         ret_val = xmlSAXParseMemoryWithData(sax, (const char *)buffer, size, recovery, data);
15071         desret_xmlDocPtr(ret_val);
15072         call_tests++;
15073         des_xmlSAXHandlerPtr(n_sax, sax, 0);
15074         des_const_char_ptr(n_buffer, (const char *)buffer, 1);
15075         des_int(n_size, size, 2);
15076         des_int(n_recovery, recovery, 3);
15077         des_userdata(n_data, data, 4);
15078         xmlResetLastError();
15079         if (mem_base != xmlMemBlocks()) {
15080             printf("Leak of %d blocks found in xmlSAXParseMemoryWithData",
15081                    xmlMemBlocks() - mem_base);
15082             test_ret++;
15083             printf(" %d", n_sax);
15084             printf(" %d", n_buffer);
15085             printf(" %d", n_size);
15086             printf(" %d", n_recovery);
15087             printf(" %d", n_data);
15088             printf("\n");
15089         }
15090     }
15091     }
15092     }
15093     }
15094     }
15095     function_tests++;
15096 #endif
15097 #endif
15098
15099     return(test_ret);
15100 }
15101
15102
15103 static int
15104 test_xmlSAXUserParseFile(void) {
15105     int test_ret = 0;
15106
15107 #if defined(LIBXML_SAX1_ENABLED)
15108 #ifdef LIBXML_SAX1_ENABLED
15109     int mem_base;
15110     int ret_val;
15111     xmlSAXHandlerPtr sax; /* a SAX handler */
15112     int n_sax;
15113     void * user_data; /* The user data returned on SAX callbacks */
15114     int n_user_data;
15115     const char * filename; /* a file name */
15116     int n_filename;
15117
15118     for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
15119     for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
15120     for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
15121         mem_base = xmlMemBlocks();
15122         sax = gen_xmlSAXHandlerPtr(n_sax, 0);
15123         user_data = gen_userdata(n_user_data, 1);
15124         filename = gen_filepath(n_filename, 2);
15125
15126 #ifdef LIBXML_SAX1_ENABLED
15127         if (sax == (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) user_data = NULL;
15128 #endif
15129
15130
15131         ret_val = xmlSAXUserParseFile(sax, user_data, filename);
15132         desret_int(ret_val);
15133         call_tests++;
15134         des_xmlSAXHandlerPtr(n_sax, sax, 0);
15135         des_userdata(n_user_data, user_data, 1);
15136         des_filepath(n_filename, filename, 2);
15137         xmlResetLastError();
15138         if (mem_base != xmlMemBlocks()) {
15139             printf("Leak of %d blocks found in xmlSAXUserParseFile",
15140                    xmlMemBlocks() - mem_base);
15141             test_ret++;
15142             printf(" %d", n_sax);
15143             printf(" %d", n_user_data);
15144             printf(" %d", n_filename);
15145             printf("\n");
15146         }
15147     }
15148     }
15149     }
15150     function_tests++;
15151 #endif
15152 #endif
15153
15154     return(test_ret);
15155 }
15156
15157
15158 static int
15159 test_xmlSAXUserParseMemory(void) {
15160     int test_ret = 0;
15161
15162 #if defined(LIBXML_SAX1_ENABLED)
15163 #ifdef LIBXML_SAX1_ENABLED
15164     int mem_base;
15165     int ret_val;
15166     xmlSAXHandlerPtr sax; /* a SAX handler */
15167     int n_sax;
15168     void * user_data; /* The user data returned on SAX callbacks */
15169     int n_user_data;
15170     char * buffer; /* an in-memory XML document input */
15171     int n_buffer;
15172     int size; /* the length of the XML document in bytes */
15173     int n_size;
15174
15175     for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
15176     for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
15177     for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
15178     for (n_size = 0;n_size < gen_nb_int;n_size++) {
15179         mem_base = xmlMemBlocks();
15180         sax = gen_xmlSAXHandlerPtr(n_sax, 0);
15181         user_data = gen_userdata(n_user_data, 1);
15182         buffer = gen_const_char_ptr(n_buffer, 2);
15183         size = gen_int(n_size, 3);
15184
15185 #ifdef LIBXML_SAX1_ENABLED
15186         if (sax == (xmlSAXHandlerPtr)&xmlDefaultSAXHandler) user_data = NULL;
15187 #endif
15188
15189
15190         ret_val = xmlSAXUserParseMemory(sax, user_data, (const char *)buffer, size);
15191         desret_int(ret_val);
15192         call_tests++;
15193         des_xmlSAXHandlerPtr(n_sax, sax, 0);
15194         des_userdata(n_user_data, user_data, 1);
15195         des_const_char_ptr(n_buffer, (const char *)buffer, 2);
15196         des_int(n_size, size, 3);
15197         xmlResetLastError();
15198         if (mem_base != xmlMemBlocks()) {
15199             printf("Leak of %d blocks found in xmlSAXUserParseMemory",
15200                    xmlMemBlocks() - mem_base);
15201             test_ret++;
15202             printf(" %d", n_sax);
15203             printf(" %d", n_user_data);
15204             printf(" %d", n_buffer);
15205             printf(" %d", n_size);
15206             printf("\n");
15207         }
15208     }
15209     }
15210     }
15211     }
15212     function_tests++;
15213 #endif
15214 #endif
15215
15216     return(test_ret);
15217 }
15218
15219
15220 static int
15221 test_xmlSetExternalEntityLoader(void) {
15222     int test_ret = 0;
15223
15224
15225     /* missing type support */
15226     return(test_ret);
15227 }
15228
15229
15230 static int
15231 test_xmlSetFeature(void) {
15232     int test_ret = 0;
15233
15234 #if defined(LIBXML_LEGACY_ENABLED)
15235 #ifdef LIBXML_LEGACY_ENABLED
15236     int mem_base;
15237     int ret_val;
15238     xmlParserCtxtPtr ctxt; /* an XML/HTML parser context */
15239     int n_ctxt;
15240     char * name; /* the feature name */
15241     int n_name;
15242     void * value; /* pointer to the location of the new value */
15243     int n_value;
15244
15245     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15246     for (n_name = 0;n_name < gen_nb_const_char_ptr;n_name++) {
15247     for (n_value = 0;n_value < gen_nb_void_ptr;n_value++) {
15248         mem_base = xmlMemBlocks();
15249         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15250         name = gen_const_char_ptr(n_name, 1);
15251         value = gen_void_ptr(n_value, 2);
15252
15253         ret_val = xmlSetFeature(ctxt, (const char *)name, value);
15254         desret_int(ret_val);
15255         call_tests++;
15256         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15257         des_const_char_ptr(n_name, (const char *)name, 1);
15258         des_void_ptr(n_value, value, 2);
15259         xmlResetLastError();
15260         if (mem_base != xmlMemBlocks()) {
15261             printf("Leak of %d blocks found in xmlSetFeature",
15262                    xmlMemBlocks() - mem_base);
15263             test_ret++;
15264             printf(" %d", n_ctxt);
15265             printf(" %d", n_name);
15266             printf(" %d", n_value);
15267             printf("\n");
15268         }
15269     }
15270     }
15271     }
15272     function_tests++;
15273 #endif
15274 #endif
15275
15276     return(test_ret);
15277 }
15278
15279
15280 static int
15281 test_xmlSetupParserForBuffer(void) {
15282     int test_ret = 0;
15283
15284 #if defined(LIBXML_SAX1_ENABLED)
15285 #ifdef LIBXML_SAX1_ENABLED
15286     int mem_base;
15287     xmlParserCtxtPtr ctxt; /* an XML parser context */
15288     int n_ctxt;
15289     xmlChar * buffer; /* a xmlChar * buffer */
15290     int n_buffer;
15291     const char * filename; /* a file name */
15292     int n_filename;
15293
15294     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15295     for (n_buffer = 0;n_buffer < gen_nb_const_xmlChar_ptr;n_buffer++) {
15296     for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
15297         mem_base = xmlMemBlocks();
15298         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15299         buffer = gen_const_xmlChar_ptr(n_buffer, 1);
15300         filename = gen_filepath(n_filename, 2);
15301
15302         xmlSetupParserForBuffer(ctxt, (const xmlChar *)buffer, filename);
15303         call_tests++;
15304         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15305         des_const_xmlChar_ptr(n_buffer, (const xmlChar *)buffer, 1);
15306         des_filepath(n_filename, filename, 2);
15307         xmlResetLastError();
15308         if (mem_base != xmlMemBlocks()) {
15309             printf("Leak of %d blocks found in xmlSetupParserForBuffer",
15310                    xmlMemBlocks() - mem_base);
15311             test_ret++;
15312             printf(" %d", n_ctxt);
15313             printf(" %d", n_buffer);
15314             printf(" %d", n_filename);
15315             printf("\n");
15316         }
15317     }
15318     }
15319     }
15320     function_tests++;
15321 #endif
15322 #endif
15323
15324     return(test_ret);
15325 }
15326
15327
15328 static int
15329 test_xmlStopParser(void) {
15330     int test_ret = 0;
15331
15332 #ifdef LIBXML_PUSH_ENABLED
15333     int mem_base;
15334     xmlParserCtxtPtr ctxt; /* an XML parser context */
15335     int n_ctxt;
15336
15337     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15338         mem_base = xmlMemBlocks();
15339         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15340
15341         xmlStopParser(ctxt);
15342         call_tests++;
15343         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15344         xmlResetLastError();
15345         if (mem_base != xmlMemBlocks()) {
15346             printf("Leak of %d blocks found in xmlStopParser",
15347                    xmlMemBlocks() - mem_base);
15348             test_ret++;
15349             printf(" %d", n_ctxt);
15350             printf("\n");
15351         }
15352     }
15353     function_tests++;
15354 #endif
15355
15356     return(test_ret);
15357 }
15358
15359
15360 static int
15361 test_xmlSubstituteEntitiesDefault(void) {
15362     int test_ret = 0;
15363
15364     int mem_base;
15365     int ret_val;
15366     int val; /* int 0 or 1 */
15367     int n_val;
15368
15369     for (n_val = 0;n_val < gen_nb_int;n_val++) {
15370         mem_base = xmlMemBlocks();
15371         val = gen_int(n_val, 0);
15372
15373         ret_val = xmlSubstituteEntitiesDefault(val);
15374         desret_int(ret_val);
15375         call_tests++;
15376         des_int(n_val, val, 0);
15377         xmlResetLastError();
15378         if (mem_base != xmlMemBlocks()) {
15379             printf("Leak of %d blocks found in xmlSubstituteEntitiesDefault",
15380                    xmlMemBlocks() - mem_base);
15381             test_ret++;
15382             printf(" %d", n_val);
15383             printf("\n");
15384         }
15385     }
15386     function_tests++;
15387
15388     return(test_ret);
15389 }
15390
15391 static int
15392 test_parser(void) {
15393     int test_ret = 0;
15394
15395     if (quiet == 0) printf("Testing parser : 61 of 70 functions ...\n");
15396     test_ret += test_xmlByteConsumed();
15397     test_ret += test_xmlClearNodeInfoSeq();
15398     test_ret += test_xmlClearParserCtxt();
15399     test_ret += test_xmlCreateDocParserCtxt();
15400     test_ret += test_xmlCreatePushParserCtxt();
15401     test_ret += test_xmlCtxtReadDoc();
15402     test_ret += test_xmlCtxtReadFile();
15403     test_ret += test_xmlCtxtReadMemory();
15404     test_ret += test_xmlCtxtReset();
15405     test_ret += test_xmlCtxtResetPush();
15406     test_ret += test_xmlCtxtUseOptions();
15407     test_ret += test_xmlGetExternalEntityLoader();
15408     test_ret += test_xmlGetFeature();
15409     test_ret += test_xmlGetFeaturesList();
15410     test_ret += test_xmlHasFeature();
15411     test_ret += test_xmlIOParseDTD();
15412     test_ret += test_xmlInitNodeInfoSeq();
15413     test_ret += test_xmlInitParser();
15414     test_ret += test_xmlInitParserCtxt();
15415     test_ret += test_xmlKeepBlanksDefault();
15416     test_ret += test_xmlLineNumbersDefault();
15417     test_ret += test_xmlLoadExternalEntity();
15418     test_ret += test_xmlNewIOInputStream();
15419     test_ret += test_xmlNewParserCtxt();
15420     test_ret += test_xmlParseBalancedChunkMemory();
15421     test_ret += test_xmlParseBalancedChunkMemoryRecover();
15422     test_ret += test_xmlParseChunk();
15423     test_ret += test_xmlParseCtxtExternalEntity();
15424     test_ret += test_xmlParseDTD();
15425     test_ret += test_xmlParseDoc();
15426     test_ret += test_xmlParseDocument();
15427     test_ret += test_xmlParseEntity();
15428     test_ret += test_xmlParseExtParsedEnt();
15429     test_ret += test_xmlParseExternalEntity();
15430     test_ret += test_xmlParseFile();
15431     test_ret += test_xmlParseInNodeContext();
15432     test_ret += test_xmlParseMemory();
15433     test_ret += test_xmlParserAddNodeInfo();
15434     test_ret += test_xmlParserFindNodeInfo();
15435     test_ret += test_xmlParserFindNodeInfoIndex();
15436     test_ret += test_xmlParserInputGrow();
15437     test_ret += test_xmlParserInputRead();
15438     test_ret += test_xmlPedanticParserDefault();
15439     test_ret += test_xmlReadDoc();
15440     test_ret += test_xmlReadFile();
15441     test_ret += test_xmlReadMemory();
15442     test_ret += test_xmlRecoverDoc();
15443     test_ret += test_xmlRecoverFile();
15444     test_ret += test_xmlRecoverMemory();
15445     test_ret += test_xmlSAXParseDTD();
15446     test_ret += test_xmlSAXParseDoc();
15447     test_ret += test_xmlSAXParseEntity();
15448     test_ret += test_xmlSAXParseFile();
15449     test_ret += test_xmlSAXParseFileWithData();
15450     test_ret += test_xmlSAXParseMemory();
15451     test_ret += test_xmlSAXParseMemoryWithData();
15452     test_ret += test_xmlSAXUserParseFile();
15453     test_ret += test_xmlSAXUserParseMemory();
15454     test_ret += test_xmlSetExternalEntityLoader();
15455     test_ret += test_xmlSetFeature();
15456     test_ret += test_xmlSetupParserForBuffer();
15457     test_ret += test_xmlStopParser();
15458     test_ret += test_xmlSubstituteEntitiesDefault();
15459
15460     if (test_ret != 0)
15461         printf("Module parser: %d errors\n", test_ret);
15462     return(test_ret);
15463 }
15464
15465 static int
15466 test_htmlCreateFileParserCtxt(void) {
15467     int test_ret = 0;
15468
15469 #if defined(LIBXML_HTML_ENABLED)
15470     int mem_base;
15471     htmlParserCtxtPtr ret_val;
15472     const char * filename; /* the filename */
15473     int n_filename;
15474     char * encoding; /* a free form C string describing the HTML document encoding, or NULL */
15475     int n_encoding;
15476
15477     for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
15478     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
15479         mem_base = xmlMemBlocks();
15480         filename = gen_fileoutput(n_filename, 0);
15481         encoding = gen_const_char_ptr(n_encoding, 1);
15482
15483         ret_val = htmlCreateFileParserCtxt(filename, (const char *)encoding);
15484         desret_htmlParserCtxtPtr(ret_val);
15485         call_tests++;
15486         des_fileoutput(n_filename, filename, 0);
15487         des_const_char_ptr(n_encoding, (const char *)encoding, 1);
15488         xmlResetLastError();
15489         if (mem_base != xmlMemBlocks()) {
15490             printf("Leak of %d blocks found in htmlCreateFileParserCtxt",
15491                    xmlMemBlocks() - mem_base);
15492             test_ret++;
15493             printf(" %d", n_filename);
15494             printf(" %d", n_encoding);
15495             printf("\n");
15496         }
15497     }
15498     }
15499     function_tests++;
15500 #endif
15501
15502     return(test_ret);
15503 }
15504
15505
15506 static int
15507 test_htmlInitAutoClose(void) {
15508     int test_ret = 0;
15509
15510 #if defined(LIBXML_HTML_ENABLED)
15511     int mem_base;
15512
15513         mem_base = xmlMemBlocks();
15514
15515         htmlInitAutoClose();
15516         call_tests++;
15517         xmlResetLastError();
15518         if (mem_base != xmlMemBlocks()) {
15519             printf("Leak of %d blocks found in htmlInitAutoClose",
15520                    xmlMemBlocks() - mem_base);
15521             test_ret++;
15522             printf("\n");
15523         }
15524     function_tests++;
15525 #endif
15526
15527     return(test_ret);
15528 }
15529
15530
15531 static int
15532 test_inputPop(void) {
15533     int test_ret = 0;
15534
15535     int mem_base;
15536     xmlParserInputPtr ret_val;
15537     xmlParserCtxtPtr ctxt; /* an XML parser context */
15538     int n_ctxt;
15539
15540     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15541         mem_base = xmlMemBlocks();
15542         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15543
15544         ret_val = inputPop(ctxt);
15545         desret_xmlParserInputPtr(ret_val);
15546         call_tests++;
15547         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15548         xmlResetLastError();
15549         if (mem_base != xmlMemBlocks()) {
15550             printf("Leak of %d blocks found in inputPop",
15551                    xmlMemBlocks() - mem_base);
15552             test_ret++;
15553             printf(" %d", n_ctxt);
15554             printf("\n");
15555         }
15556     }
15557     function_tests++;
15558
15559     return(test_ret);
15560 }
15561
15562
15563 static int
15564 test_inputPush(void) {
15565     int test_ret = 0;
15566
15567     int mem_base;
15568     int ret_val;
15569     xmlParserCtxtPtr ctxt; /* an XML parser context */
15570     int n_ctxt;
15571     xmlParserInputPtr value; /* the parser input */
15572     int n_value;
15573
15574     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15575     for (n_value = 0;n_value < gen_nb_xmlParserInputPtr;n_value++) {
15576         mem_base = xmlMemBlocks();
15577         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15578         value = gen_xmlParserInputPtr(n_value, 1);
15579
15580         ret_val = inputPush(ctxt, value);
15581         desret_int(ret_val);
15582         call_tests++;
15583         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15584         des_xmlParserInputPtr(n_value, value, 1);
15585         xmlResetLastError();
15586         if (mem_base != xmlMemBlocks()) {
15587             printf("Leak of %d blocks found in inputPush",
15588                    xmlMemBlocks() - mem_base);
15589             test_ret++;
15590             printf(" %d", n_ctxt);
15591             printf(" %d", n_value);
15592             printf("\n");
15593         }
15594     }
15595     }
15596     function_tests++;
15597
15598     return(test_ret);
15599 }
15600
15601
15602 static int
15603 test_namePop(void) {
15604     int test_ret = 0;
15605
15606     int mem_base;
15607     const xmlChar * ret_val;
15608     xmlParserCtxtPtr ctxt; /* an XML parser context */
15609     int n_ctxt;
15610
15611     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15612         mem_base = xmlMemBlocks();
15613         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15614
15615         ret_val = namePop(ctxt);
15616         desret_const_xmlChar_ptr(ret_val);
15617         call_tests++;
15618         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15619         xmlResetLastError();
15620         if (mem_base != xmlMemBlocks()) {
15621             printf("Leak of %d blocks found in namePop",
15622                    xmlMemBlocks() - mem_base);
15623             test_ret++;
15624             printf(" %d", n_ctxt);
15625             printf("\n");
15626         }
15627     }
15628     function_tests++;
15629
15630     return(test_ret);
15631 }
15632
15633
15634 static int
15635 test_namePush(void) {
15636     int test_ret = 0;
15637
15638     int mem_base;
15639     int ret_val;
15640     xmlParserCtxtPtr ctxt; /* an XML parser context */
15641     int n_ctxt;
15642     xmlChar * value; /* the element name */
15643     int n_value;
15644
15645     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15646     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
15647         mem_base = xmlMemBlocks();
15648         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15649         value = gen_const_xmlChar_ptr(n_value, 1);
15650
15651         ret_val = namePush(ctxt, (const xmlChar *)value);
15652         desret_int(ret_val);
15653         call_tests++;
15654         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15655         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
15656         xmlResetLastError();
15657         if (mem_base != xmlMemBlocks()) {
15658             printf("Leak of %d blocks found in namePush",
15659                    xmlMemBlocks() - mem_base);
15660             test_ret++;
15661             printf(" %d", n_ctxt);
15662             printf(" %d", n_value);
15663             printf("\n");
15664         }
15665     }
15666     }
15667     function_tests++;
15668
15669     return(test_ret);
15670 }
15671
15672
15673 static int
15674 test_nodePop(void) {
15675     int test_ret = 0;
15676
15677     int mem_base;
15678     xmlNodePtr ret_val;
15679     xmlParserCtxtPtr ctxt; /* an XML parser context */
15680     int n_ctxt;
15681
15682     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15683         mem_base = xmlMemBlocks();
15684         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15685
15686         ret_val = nodePop(ctxt);
15687         desret_xmlNodePtr(ret_val);
15688         call_tests++;
15689         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15690         xmlResetLastError();
15691         if (mem_base != xmlMemBlocks()) {
15692             printf("Leak of %d blocks found in nodePop",
15693                    xmlMemBlocks() - mem_base);
15694             test_ret++;
15695             printf(" %d", n_ctxt);
15696             printf("\n");
15697         }
15698     }
15699     function_tests++;
15700
15701     return(test_ret);
15702 }
15703
15704
15705 static int
15706 test_nodePush(void) {
15707     int test_ret = 0;
15708
15709     int mem_base;
15710     int ret_val;
15711     xmlParserCtxtPtr ctxt; /* an XML parser context */
15712     int n_ctxt;
15713     xmlNodePtr value; /* the element node */
15714     int n_value;
15715
15716     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
15717     for (n_value = 0;n_value < gen_nb_xmlNodePtr;n_value++) {
15718         mem_base = xmlMemBlocks();
15719         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
15720         value = gen_xmlNodePtr(n_value, 1);
15721
15722         ret_val = nodePush(ctxt, value);
15723         desret_int(ret_val);
15724         call_tests++;
15725         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
15726         des_xmlNodePtr(n_value, value, 1);
15727         xmlResetLastError();
15728         if (mem_base != xmlMemBlocks()) {
15729             printf("Leak of %d blocks found in nodePush",
15730                    xmlMemBlocks() - mem_base);
15731             test_ret++;
15732             printf(" %d", n_ctxt);
15733             printf(" %d", n_value);
15734             printf("\n");
15735         }
15736     }
15737     }
15738     function_tests++;
15739
15740     return(test_ret);
15741 }
15742
15743
15744 static int
15745 test_xmlCheckLanguageID(void) {
15746     int test_ret = 0;
15747
15748     int mem_base;
15749     int ret_val;
15750     xmlChar * lang; /* pointer to the string value */
15751     int n_lang;
15752
15753     for (n_lang = 0;n_lang < gen_nb_const_xmlChar_ptr;n_lang++) {
15754         mem_base = xmlMemBlocks();
15755         lang = gen_const_xmlChar_ptr(n_lang, 0);
15756
15757         ret_val = xmlCheckLanguageID((const xmlChar *)lang);
15758         desret_int(ret_val);
15759         call_tests++;
15760         des_const_xmlChar_ptr(n_lang, (const xmlChar *)lang, 0);
15761         xmlResetLastError();
15762         if (mem_base != xmlMemBlocks()) {
15763             printf("Leak of %d blocks found in xmlCheckLanguageID",
15764                    xmlMemBlocks() - mem_base);
15765             test_ret++;
15766             printf(" %d", n_lang);
15767             printf("\n");
15768         }
15769     }
15770     function_tests++;
15771
15772     return(test_ret);
15773 }
15774
15775
15776 static int
15777 test_xmlCopyChar(void) {
15778     int test_ret = 0;
15779
15780     int mem_base;
15781     int ret_val;
15782     int len; /* Ignored, compatibility */
15783     int n_len;
15784     xmlChar * out; /* pointer to an array of xmlChar */
15785     int n_out;
15786     int val; /* the char value */
15787     int n_val;
15788
15789     for (n_len = 0;n_len < gen_nb_int;n_len++) {
15790     for (n_out = 0;n_out < gen_nb_xmlChar_ptr;n_out++) {
15791     for (n_val = 0;n_val < gen_nb_int;n_val++) {
15792         mem_base = xmlMemBlocks();
15793         len = gen_int(n_len, 0);
15794         out = gen_xmlChar_ptr(n_out, 1);
15795         val = gen_int(n_val, 2);
15796
15797         ret_val = xmlCopyChar(len, out, val);
15798         desret_int(ret_val);
15799         call_tests++;
15800         des_int(n_len, len, 0);
15801         des_xmlChar_ptr(n_out, out, 1);
15802         des_int(n_val, val, 2);
15803         xmlResetLastError();
15804         if (mem_base != xmlMemBlocks()) {
15805             printf("Leak of %d blocks found in xmlCopyChar",
15806                    xmlMemBlocks() - mem_base);
15807             test_ret++;
15808             printf(" %d", n_len);
15809             printf(" %d", n_out);
15810             printf(" %d", n_val);
15811             printf("\n");
15812         }
15813     }
15814     }
15815     }
15816     function_tests++;
15817
15818     return(test_ret);
15819 }
15820
15821
15822 static int
15823 test_xmlCopyCharMultiByte(void) {
15824     int test_ret = 0;
15825
15826     int mem_base;
15827     int ret_val;
15828     xmlChar * out; /* pointer to an array of xmlChar */
15829     int n_out;
15830     int val; /* the char value */
15831     int n_val;
15832
15833     for (n_out = 0;n_out < gen_nb_xmlChar_ptr;n_out++) {
15834     for (n_val = 0;n_val < gen_nb_int;n_val++) {
15835         mem_base = xmlMemBlocks();
15836         out = gen_xmlChar_ptr(n_out, 0);
15837         val = gen_int(n_val, 1);
15838
15839         ret_val = xmlCopyCharMultiByte(out, val);
15840         desret_int(ret_val);
15841         call_tests++;
15842         des_xmlChar_ptr(n_out, out, 0);
15843         des_int(n_val, val, 1);
15844         xmlResetLastError();
15845         if (mem_base != xmlMemBlocks()) {
15846             printf("Leak of %d blocks found in xmlCopyCharMultiByte",
15847                    xmlMemBlocks() - mem_base);
15848             test_ret++;
15849             printf(" %d", n_out);
15850             printf(" %d", n_val);
15851             printf("\n");
15852         }
15853     }
15854     }
15855     function_tests++;
15856
15857     return(test_ret);
15858 }
15859
15860
15861 static int
15862 test_xmlCreateEntityParserCtxt(void) {
15863     int test_ret = 0;
15864
15865     int mem_base;
15866     xmlParserCtxtPtr ret_val;
15867     xmlChar * URL; /* the entity URL */
15868     int n_URL;
15869     xmlChar * ID; /* the entity PUBLIC ID */
15870     int n_ID;
15871     xmlChar * base; /* a possible base for the target URI */
15872     int n_base;
15873
15874     for (n_URL = 0;n_URL < gen_nb_const_xmlChar_ptr;n_URL++) {
15875     for (n_ID = 0;n_ID < gen_nb_const_xmlChar_ptr;n_ID++) {
15876     for (n_base = 0;n_base < gen_nb_const_xmlChar_ptr;n_base++) {
15877         mem_base = xmlMemBlocks();
15878         URL = gen_const_xmlChar_ptr(n_URL, 0);
15879         ID = gen_const_xmlChar_ptr(n_ID, 1);
15880         base = gen_const_xmlChar_ptr(n_base, 2);
15881
15882         ret_val = xmlCreateEntityParserCtxt((const xmlChar *)URL, (const xmlChar *)ID, (const xmlChar *)base);
15883         desret_xmlParserCtxtPtr(ret_val);
15884         call_tests++;
15885         des_const_xmlChar_ptr(n_URL, (const xmlChar *)URL, 0);
15886         des_const_xmlChar_ptr(n_ID, (const xmlChar *)ID, 1);
15887         des_const_xmlChar_ptr(n_base, (const xmlChar *)base, 2);
15888         xmlResetLastError();
15889         if (mem_base != xmlMemBlocks()) {
15890             printf("Leak of %d blocks found in xmlCreateEntityParserCtxt",
15891                    xmlMemBlocks() - mem_base);
15892             test_ret++;
15893             printf(" %d", n_URL);
15894             printf(" %d", n_ID);
15895             printf(" %d", n_base);
15896             printf("\n");
15897         }
15898     }
15899     }
15900     }
15901     function_tests++;
15902
15903     return(test_ret);
15904 }
15905
15906
15907 static int
15908 test_xmlCreateFileParserCtxt(void) {
15909     int test_ret = 0;
15910
15911     int mem_base;
15912     xmlParserCtxtPtr ret_val;
15913     const char * filename; /* the filename */
15914     int n_filename;
15915
15916     for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
15917         mem_base = xmlMemBlocks();
15918         filename = gen_fileoutput(n_filename, 0);
15919
15920         ret_val = xmlCreateFileParserCtxt(filename);
15921         desret_xmlParserCtxtPtr(ret_val);
15922         call_tests++;
15923         des_fileoutput(n_filename, filename, 0);
15924         xmlResetLastError();
15925         if (mem_base != xmlMemBlocks()) {
15926             printf("Leak of %d blocks found in xmlCreateFileParserCtxt",
15927                    xmlMemBlocks() - mem_base);
15928             test_ret++;
15929             printf(" %d", n_filename);
15930             printf("\n");
15931         }
15932     }
15933     function_tests++;
15934
15935     return(test_ret);
15936 }
15937
15938
15939 static int
15940 test_xmlCreateMemoryParserCtxt(void) {
15941     int test_ret = 0;
15942
15943     int mem_base;
15944     xmlParserCtxtPtr ret_val;
15945     char * buffer; /* a pointer to a char array */
15946     int n_buffer;
15947     int size; /* the size of the array */
15948     int n_size;
15949
15950     for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
15951     for (n_size = 0;n_size < gen_nb_int;n_size++) {
15952         mem_base = xmlMemBlocks();
15953         buffer = gen_const_char_ptr(n_buffer, 0);
15954         size = gen_int(n_size, 1);
15955
15956         ret_val = xmlCreateMemoryParserCtxt((const char *)buffer, size);
15957         desret_xmlParserCtxtPtr(ret_val);
15958         call_tests++;
15959         des_const_char_ptr(n_buffer, (const char *)buffer, 0);
15960         des_int(n_size, size, 1);
15961         xmlResetLastError();
15962         if (mem_base != xmlMemBlocks()) {
15963             printf("Leak of %d blocks found in xmlCreateMemoryParserCtxt",
15964                    xmlMemBlocks() - mem_base);
15965             test_ret++;
15966             printf(" %d", n_buffer);
15967             printf(" %d", n_size);
15968             printf("\n");
15969         }
15970     }
15971     }
15972     function_tests++;
15973
15974     return(test_ret);
15975 }
15976
15977
15978 static int
15979 test_xmlCreateURLParserCtxt(void) {
15980     int test_ret = 0;
15981
15982     int mem_base;
15983     xmlParserCtxtPtr ret_val;
15984     const char * filename; /* the filename or URL */
15985     int n_filename;
15986     int options; /* a combination of xmlParserOption */
15987     int n_options;
15988
15989     for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
15990     for (n_options = 0;n_options < gen_nb_int;n_options++) {
15991         mem_base = xmlMemBlocks();
15992         filename = gen_fileoutput(n_filename, 0);
15993         options = gen_int(n_options, 1);
15994
15995         ret_val = xmlCreateURLParserCtxt(filename, options);
15996         desret_xmlParserCtxtPtr(ret_val);
15997         call_tests++;
15998         des_fileoutput(n_filename, filename, 0);
15999         des_int(n_options, options, 1);
16000         xmlResetLastError();
16001         if (mem_base != xmlMemBlocks()) {
16002             printf("Leak of %d blocks found in xmlCreateURLParserCtxt",
16003                    xmlMemBlocks() - mem_base);
16004             test_ret++;
16005             printf(" %d", n_filename);
16006             printf(" %d", n_options);
16007             printf("\n");
16008         }
16009     }
16010     }
16011     function_tests++;
16012
16013     return(test_ret);
16014 }
16015
16016
16017 static int
16018 test_xmlCurrentChar(void) {
16019     int test_ret = 0;
16020
16021     int mem_base;
16022     int ret_val;
16023     xmlParserCtxtPtr ctxt; /* the XML parser context */
16024     int n_ctxt;
16025     int * len; /* pointer to the length of the char read */
16026     int n_len;
16027
16028     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16029     for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
16030         mem_base = xmlMemBlocks();
16031         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16032         len = gen_int_ptr(n_len, 1);
16033
16034         ret_val = xmlCurrentChar(ctxt, len);
16035         desret_int(ret_val);
16036         call_tests++;
16037         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16038         des_int_ptr(n_len, len, 1);
16039         xmlResetLastError();
16040         if (mem_base != xmlMemBlocks()) {
16041             printf("Leak of %d blocks found in xmlCurrentChar",
16042                    xmlMemBlocks() - mem_base);
16043             test_ret++;
16044             printf(" %d", n_ctxt);
16045             printf(" %d", n_len);
16046             printf("\n");
16047         }
16048     }
16049     }
16050     function_tests++;
16051
16052     return(test_ret);
16053 }
16054
16055
16056 static int
16057 test_xmlErrMemory(void) {
16058     int test_ret = 0;
16059
16060     int mem_base;
16061     xmlParserCtxtPtr ctxt; /* an XML parser context */
16062     int n_ctxt;
16063     char * extra; /* extra informations */
16064     int n_extra;
16065
16066     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16067     for (n_extra = 0;n_extra < gen_nb_const_char_ptr;n_extra++) {
16068         mem_base = xmlMemBlocks();
16069         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16070         extra = gen_const_char_ptr(n_extra, 1);
16071
16072         xmlErrMemory(ctxt, (const char *)extra);
16073         call_tests++;
16074         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16075         des_const_char_ptr(n_extra, (const char *)extra, 1);
16076         xmlResetLastError();
16077         if (mem_base != xmlMemBlocks()) {
16078             printf("Leak of %d blocks found in xmlErrMemory",
16079                    xmlMemBlocks() - mem_base);
16080             test_ret++;
16081             printf(" %d", n_ctxt);
16082             printf(" %d", n_extra);
16083             printf("\n");
16084         }
16085     }
16086     }
16087     function_tests++;
16088
16089     return(test_ret);
16090 }
16091
16092
16093 static int
16094 test_xmlIsLetter(void) {
16095     int test_ret = 0;
16096
16097     int mem_base;
16098     int ret_val;
16099     int c; /* an unicode character (int) */
16100     int n_c;
16101
16102     for (n_c = 0;n_c < gen_nb_int;n_c++) {
16103         mem_base = xmlMemBlocks();
16104         c = gen_int(n_c, 0);
16105
16106         ret_val = xmlIsLetter(c);
16107         desret_int(ret_val);
16108         call_tests++;
16109         des_int(n_c, c, 0);
16110         xmlResetLastError();
16111         if (mem_base != xmlMemBlocks()) {
16112             printf("Leak of %d blocks found in xmlIsLetter",
16113                    xmlMemBlocks() - mem_base);
16114             test_ret++;
16115             printf(" %d", n_c);
16116             printf("\n");
16117         }
16118     }
16119     function_tests++;
16120
16121     return(test_ret);
16122 }
16123
16124
16125 static int
16126 test_xmlNewEntityInputStream(void) {
16127     int test_ret = 0;
16128
16129     int mem_base;
16130     xmlParserInputPtr ret_val;
16131     xmlParserCtxtPtr ctxt; /* an XML parser context */
16132     int n_ctxt;
16133     xmlEntityPtr entity; /* an Entity pointer */
16134     int n_entity;
16135
16136     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16137     for (n_entity = 0;n_entity < gen_nb_xmlEntityPtr;n_entity++) {
16138         mem_base = xmlMemBlocks();
16139         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16140         entity = gen_xmlEntityPtr(n_entity, 1);
16141
16142         ret_val = xmlNewEntityInputStream(ctxt, entity);
16143         desret_xmlParserInputPtr(ret_val);
16144         call_tests++;
16145         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16146         des_xmlEntityPtr(n_entity, entity, 1);
16147         xmlResetLastError();
16148         if (mem_base != xmlMemBlocks()) {
16149             printf("Leak of %d blocks found in xmlNewEntityInputStream",
16150                    xmlMemBlocks() - mem_base);
16151             test_ret++;
16152             printf(" %d", n_ctxt);
16153             printf(" %d", n_entity);
16154             printf("\n");
16155         }
16156     }
16157     }
16158     function_tests++;
16159
16160     return(test_ret);
16161 }
16162
16163
16164 static int
16165 test_xmlNewInputFromFile(void) {
16166     int test_ret = 0;
16167
16168     int mem_base;
16169     xmlParserInputPtr ret_val;
16170     xmlParserCtxtPtr ctxt; /* an XML parser context */
16171     int n_ctxt;
16172     const char * filename; /* the filename to use as entity */
16173     int n_filename;
16174
16175     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16176     for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
16177         mem_base = xmlMemBlocks();
16178         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16179         filename = gen_filepath(n_filename, 1);
16180
16181         ret_val = xmlNewInputFromFile(ctxt, filename);
16182         desret_xmlParserInputPtr(ret_val);
16183         call_tests++;
16184         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16185         des_filepath(n_filename, filename, 1);
16186         xmlResetLastError();
16187         if (mem_base != xmlMemBlocks()) {
16188             printf("Leak of %d blocks found in xmlNewInputFromFile",
16189                    xmlMemBlocks() - mem_base);
16190             test_ret++;
16191             printf(" %d", n_ctxt);
16192             printf(" %d", n_filename);
16193             printf("\n");
16194         }
16195     }
16196     }
16197     function_tests++;
16198
16199     return(test_ret);
16200 }
16201
16202
16203 static int
16204 test_xmlNewInputStream(void) {
16205     int test_ret = 0;
16206
16207     int mem_base;
16208     xmlParserInputPtr ret_val;
16209     xmlParserCtxtPtr ctxt; /* an XML parser context */
16210     int n_ctxt;
16211
16212     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16213         mem_base = xmlMemBlocks();
16214         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16215
16216         ret_val = xmlNewInputStream(ctxt);
16217         desret_xmlParserInputPtr(ret_val);
16218         call_tests++;
16219         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16220         xmlResetLastError();
16221         if (mem_base != xmlMemBlocks()) {
16222             printf("Leak of %d blocks found in xmlNewInputStream",
16223                    xmlMemBlocks() - mem_base);
16224             test_ret++;
16225             printf(" %d", n_ctxt);
16226             printf("\n");
16227         }
16228     }
16229     function_tests++;
16230
16231     return(test_ret);
16232 }
16233
16234
16235 static int
16236 test_xmlNewStringInputStream(void) {
16237     int test_ret = 0;
16238
16239     int mem_base;
16240     xmlParserInputPtr ret_val;
16241     xmlParserCtxtPtr ctxt; /* an XML parser context */
16242     int n_ctxt;
16243     xmlChar * buffer; /* an memory buffer */
16244     int n_buffer;
16245
16246     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16247     for (n_buffer = 0;n_buffer < gen_nb_const_xmlChar_ptr;n_buffer++) {
16248         mem_base = xmlMemBlocks();
16249         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16250         buffer = gen_const_xmlChar_ptr(n_buffer, 1);
16251
16252         ret_val = xmlNewStringInputStream(ctxt, (const xmlChar *)buffer);
16253         desret_xmlParserInputPtr(ret_val);
16254         call_tests++;
16255         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16256         des_const_xmlChar_ptr(n_buffer, (const xmlChar *)buffer, 1);
16257         xmlResetLastError();
16258         if (mem_base != xmlMemBlocks()) {
16259             printf("Leak of %d blocks found in xmlNewStringInputStream",
16260                    xmlMemBlocks() - mem_base);
16261             test_ret++;
16262             printf(" %d", n_ctxt);
16263             printf(" %d", n_buffer);
16264             printf("\n");
16265         }
16266     }
16267     }
16268     function_tests++;
16269
16270     return(test_ret);
16271 }
16272
16273
16274 static int
16275 test_xmlNextChar(void) {
16276     int test_ret = 0;
16277
16278     int mem_base;
16279     xmlParserCtxtPtr ctxt; /* the XML parser context */
16280     int n_ctxt;
16281
16282     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16283         mem_base = xmlMemBlocks();
16284         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16285
16286         xmlNextChar(ctxt);
16287         call_tests++;
16288         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16289         xmlResetLastError();
16290         if (mem_base != xmlMemBlocks()) {
16291             printf("Leak of %d blocks found in xmlNextChar",
16292                    xmlMemBlocks() - mem_base);
16293             test_ret++;
16294             printf(" %d", n_ctxt);
16295             printf("\n");
16296         }
16297     }
16298     function_tests++;
16299
16300     return(test_ret);
16301 }
16302
16303
16304 static int
16305 test_xmlParserInputShrink(void) {
16306     int test_ret = 0;
16307
16308     int mem_base;
16309     xmlParserInputPtr in; /* an XML parser input */
16310     int n_in;
16311
16312     for (n_in = 0;n_in < gen_nb_xmlParserInputPtr;n_in++) {
16313         mem_base = xmlMemBlocks();
16314         in = gen_xmlParserInputPtr(n_in, 0);
16315
16316         xmlParserInputShrink(in);
16317         call_tests++;
16318         des_xmlParserInputPtr(n_in, in, 0);
16319         xmlResetLastError();
16320         if (mem_base != xmlMemBlocks()) {
16321             printf("Leak of %d blocks found in xmlParserInputShrink",
16322                    xmlMemBlocks() - mem_base);
16323             test_ret++;
16324             printf(" %d", n_in);
16325             printf("\n");
16326         }
16327     }
16328     function_tests++;
16329
16330     return(test_ret);
16331 }
16332
16333
16334 static int
16335 test_xmlPopInput(void) {
16336     int test_ret = 0;
16337
16338     int mem_base;
16339     xmlChar ret_val;
16340     xmlParserCtxtPtr ctxt; /* an XML parser context */
16341     int n_ctxt;
16342
16343     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16344         mem_base = xmlMemBlocks();
16345         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16346
16347         ret_val = xmlPopInput(ctxt);
16348         desret_xmlChar(ret_val);
16349         call_tests++;
16350         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16351         xmlResetLastError();
16352         if (mem_base != xmlMemBlocks()) {
16353             printf("Leak of %d blocks found in xmlPopInput",
16354                    xmlMemBlocks() - mem_base);
16355             test_ret++;
16356             printf(" %d", n_ctxt);
16357             printf("\n");
16358         }
16359     }
16360     function_tests++;
16361
16362     return(test_ret);
16363 }
16364
16365
16366 static int
16367 test_xmlPushInput(void) {
16368     int test_ret = 0;
16369
16370     int mem_base;
16371     int ret_val;
16372     xmlParserCtxtPtr ctxt; /* an XML parser context */
16373     int n_ctxt;
16374     xmlParserInputPtr input; /* an XML parser input fragment (entity, XML fragment ...). */
16375     int n_input;
16376
16377     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16378     for (n_input = 0;n_input < gen_nb_xmlParserInputPtr;n_input++) {
16379         mem_base = xmlMemBlocks();
16380         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16381         input = gen_xmlParserInputPtr(n_input, 1);
16382
16383         ret_val = xmlPushInput(ctxt, input);
16384         desret_int(ret_val);
16385         call_tests++;
16386         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16387         des_xmlParserInputPtr(n_input, input, 1);
16388         xmlResetLastError();
16389         if (mem_base != xmlMemBlocks()) {
16390             printf("Leak of %d blocks found in xmlPushInput",
16391                    xmlMemBlocks() - mem_base);
16392             test_ret++;
16393             printf(" %d", n_ctxt);
16394             printf(" %d", n_input);
16395             printf("\n");
16396         }
16397     }
16398     }
16399     function_tests++;
16400
16401     return(test_ret);
16402 }
16403
16404
16405 static int
16406 test_xmlSetEntityReferenceFunc(void) {
16407     int test_ret = 0;
16408
16409
16410     /* missing type support */
16411     return(test_ret);
16412 }
16413
16414
16415 static int
16416 test_xmlSplitQName(void) {
16417     int test_ret = 0;
16418
16419     int mem_base;
16420     xmlChar * ret_val;
16421     xmlParserCtxtPtr ctxt; /* an XML parser context */
16422     int n_ctxt;
16423     xmlChar * name; /* an XML parser context */
16424     int n_name;
16425     xmlChar ** prefix; /* a xmlChar ** */
16426     int n_prefix;
16427
16428     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16429     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
16430     for (n_prefix = 0;n_prefix < gen_nb_xmlChar_ptr_ptr;n_prefix++) {
16431         mem_base = xmlMemBlocks();
16432         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16433         name = gen_const_xmlChar_ptr(n_name, 1);
16434         prefix = gen_xmlChar_ptr_ptr(n_prefix, 2);
16435
16436         ret_val = xmlSplitQName(ctxt, (const xmlChar *)name, prefix);
16437         desret_xmlChar_ptr(ret_val);
16438         call_tests++;
16439         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16440         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
16441         des_xmlChar_ptr_ptr(n_prefix, prefix, 2);
16442         xmlResetLastError();
16443         if (mem_base != xmlMemBlocks()) {
16444             printf("Leak of %d blocks found in xmlSplitQName",
16445                    xmlMemBlocks() - mem_base);
16446             test_ret++;
16447             printf(" %d", n_ctxt);
16448             printf(" %d", n_name);
16449             printf(" %d", n_prefix);
16450             printf("\n");
16451         }
16452     }
16453     }
16454     }
16455     function_tests++;
16456
16457     return(test_ret);
16458 }
16459
16460
16461 static int
16462 test_xmlStringCurrentChar(void) {
16463     int test_ret = 0;
16464
16465     int mem_base;
16466     int ret_val;
16467     xmlParserCtxtPtr ctxt; /* the XML parser context */
16468     int n_ctxt;
16469     xmlChar * cur; /* pointer to the beginning of the char */
16470     int n_cur;
16471     int * len; /* pointer to the length of the char read */
16472     int n_len;
16473
16474     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16475     for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
16476     for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
16477         mem_base = xmlMemBlocks();
16478         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16479         cur = gen_const_xmlChar_ptr(n_cur, 1);
16480         len = gen_int_ptr(n_len, 2);
16481
16482         ret_val = xmlStringCurrentChar(ctxt, (const xmlChar *)cur, len);
16483         desret_int(ret_val);
16484         call_tests++;
16485         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16486         des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 1);
16487         des_int_ptr(n_len, len, 2);
16488         xmlResetLastError();
16489         if (mem_base != xmlMemBlocks()) {
16490             printf("Leak of %d blocks found in xmlStringCurrentChar",
16491                    xmlMemBlocks() - mem_base);
16492             test_ret++;
16493             printf(" %d", n_ctxt);
16494             printf(" %d", n_cur);
16495             printf(" %d", n_len);
16496             printf("\n");
16497         }
16498     }
16499     }
16500     }
16501     function_tests++;
16502
16503     return(test_ret);
16504 }
16505
16506
16507 static int
16508 test_xmlStringDecodeEntities(void) {
16509     int test_ret = 0;
16510
16511     int mem_base;
16512     xmlChar * ret_val;
16513     xmlParserCtxtPtr ctxt; /* the parser context */
16514     int n_ctxt;
16515     xmlChar * str; /* the input string */
16516     int n_str;
16517     int what; /* combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF */
16518     int n_what;
16519     xmlChar end; /* an end marker xmlChar, 0 if none */
16520     int n_end;
16521     xmlChar end2; /* an end marker xmlChar, 0 if none */
16522     int n_end2;
16523     xmlChar end3; /* an end marker xmlChar, 0 if none */
16524     int n_end3;
16525
16526     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16527     for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
16528     for (n_what = 0;n_what < gen_nb_int;n_what++) {
16529     for (n_end = 0;n_end < gen_nb_xmlChar;n_end++) {
16530     for (n_end2 = 0;n_end2 < gen_nb_xmlChar;n_end2++) {
16531     for (n_end3 = 0;n_end3 < gen_nb_xmlChar;n_end3++) {
16532         mem_base = xmlMemBlocks();
16533         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16534         str = gen_const_xmlChar_ptr(n_str, 1);
16535         what = gen_int(n_what, 2);
16536         end = gen_xmlChar(n_end, 3);
16537         end2 = gen_xmlChar(n_end2, 4);
16538         end3 = gen_xmlChar(n_end3, 5);
16539
16540         ret_val = xmlStringDecodeEntities(ctxt, (const xmlChar *)str, what, end, end2, end3);
16541         desret_xmlChar_ptr(ret_val);
16542         call_tests++;
16543         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16544         des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
16545         des_int(n_what, what, 2);
16546         des_xmlChar(n_end, end, 3);
16547         des_xmlChar(n_end2, end2, 4);
16548         des_xmlChar(n_end3, end3, 5);
16549         xmlResetLastError();
16550         if (mem_base != xmlMemBlocks()) {
16551             printf("Leak of %d blocks found in xmlStringDecodeEntities",
16552                    xmlMemBlocks() - mem_base);
16553             test_ret++;
16554             printf(" %d", n_ctxt);
16555             printf(" %d", n_str);
16556             printf(" %d", n_what);
16557             printf(" %d", n_end);
16558             printf(" %d", n_end2);
16559             printf(" %d", n_end3);
16560             printf("\n");
16561         }
16562     }
16563     }
16564     }
16565     }
16566     }
16567     }
16568     function_tests++;
16569
16570     return(test_ret);
16571 }
16572
16573
16574 static int
16575 test_xmlStringLenDecodeEntities(void) {
16576     int test_ret = 0;
16577
16578     int mem_base;
16579     xmlChar * ret_val;
16580     xmlParserCtxtPtr ctxt; /* the parser context */
16581     int n_ctxt;
16582     xmlChar * str; /* the input string */
16583     int n_str;
16584     int len; /* the string length */
16585     int n_len;
16586     int what; /* combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF */
16587     int n_what;
16588     xmlChar end; /* an end marker xmlChar, 0 if none */
16589     int n_end;
16590     xmlChar end2; /* an end marker xmlChar, 0 if none */
16591     int n_end2;
16592     xmlChar end3; /* an end marker xmlChar, 0 if none */
16593     int n_end3;
16594
16595     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16596     for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
16597     for (n_len = 0;n_len < gen_nb_int;n_len++) {
16598     for (n_what = 0;n_what < gen_nb_int;n_what++) {
16599     for (n_end = 0;n_end < gen_nb_xmlChar;n_end++) {
16600     for (n_end2 = 0;n_end2 < gen_nb_xmlChar;n_end2++) {
16601     for (n_end3 = 0;n_end3 < gen_nb_xmlChar;n_end3++) {
16602         mem_base = xmlMemBlocks();
16603         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16604         str = gen_const_xmlChar_ptr(n_str, 1);
16605         len = gen_int(n_len, 2);
16606         what = gen_int(n_what, 3);
16607         end = gen_xmlChar(n_end, 4);
16608         end2 = gen_xmlChar(n_end2, 5);
16609         end3 = gen_xmlChar(n_end3, 6);
16610
16611         ret_val = xmlStringLenDecodeEntities(ctxt, (const xmlChar *)str, len, what, end, end2, end3);
16612         desret_xmlChar_ptr(ret_val);
16613         call_tests++;
16614         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16615         des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
16616         des_int(n_len, len, 2);
16617         des_int(n_what, what, 3);
16618         des_xmlChar(n_end, end, 4);
16619         des_xmlChar(n_end2, end2, 5);
16620         des_xmlChar(n_end3, end3, 6);
16621         xmlResetLastError();
16622         if (mem_base != xmlMemBlocks()) {
16623             printf("Leak of %d blocks found in xmlStringLenDecodeEntities",
16624                    xmlMemBlocks() - mem_base);
16625             test_ret++;
16626             printf(" %d", n_ctxt);
16627             printf(" %d", n_str);
16628             printf(" %d", n_len);
16629             printf(" %d", n_what);
16630             printf(" %d", n_end);
16631             printf(" %d", n_end2);
16632             printf(" %d", n_end3);
16633             printf("\n");
16634         }
16635     }
16636     }
16637     }
16638     }
16639     }
16640     }
16641     }
16642     function_tests++;
16643
16644     return(test_ret);
16645 }
16646
16647
16648 static int
16649 test_xmlSwitchEncoding(void) {
16650     int test_ret = 0;
16651
16652     int mem_base;
16653     int ret_val;
16654     xmlParserCtxtPtr ctxt; /* the parser context */
16655     int n_ctxt;
16656     xmlCharEncoding enc; /* the encoding value (number) */
16657     int n_enc;
16658
16659     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16660     for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
16661         mem_base = xmlMemBlocks();
16662         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16663         enc = gen_xmlCharEncoding(n_enc, 1);
16664
16665         ret_val = xmlSwitchEncoding(ctxt, enc);
16666         desret_int(ret_val);
16667         call_tests++;
16668         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16669         des_xmlCharEncoding(n_enc, enc, 1);
16670         xmlResetLastError();
16671         if (mem_base != xmlMemBlocks()) {
16672             printf("Leak of %d blocks found in xmlSwitchEncoding",
16673                    xmlMemBlocks() - mem_base);
16674             test_ret++;
16675             printf(" %d", n_ctxt);
16676             printf(" %d", n_enc);
16677             printf("\n");
16678         }
16679     }
16680     }
16681     function_tests++;
16682
16683     return(test_ret);
16684 }
16685
16686
16687 static int
16688 test_xmlSwitchInputEncoding(void) {
16689     int test_ret = 0;
16690
16691     int mem_base;
16692     int ret_val;
16693     xmlParserCtxtPtr ctxt; /* the parser context */
16694     int n_ctxt;
16695     xmlParserInputPtr input; /* the input stream */
16696     int n_input;
16697     xmlCharEncodingHandlerPtr handler; /* the encoding handler */
16698     int n_handler;
16699
16700     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16701     for (n_input = 0;n_input < gen_nb_xmlParserInputPtr;n_input++) {
16702     for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandlerPtr;n_handler++) {
16703         mem_base = xmlMemBlocks();
16704         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16705         input = gen_xmlParserInputPtr(n_input, 1);
16706         handler = gen_xmlCharEncodingHandlerPtr(n_handler, 2);
16707
16708         ret_val = xmlSwitchInputEncoding(ctxt, input, handler);
16709         desret_int(ret_val);
16710         call_tests++;
16711         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16712         des_xmlParserInputPtr(n_input, input, 1);
16713         des_xmlCharEncodingHandlerPtr(n_handler, handler, 2);
16714         xmlResetLastError();
16715         if (mem_base != xmlMemBlocks()) {
16716             printf("Leak of %d blocks found in xmlSwitchInputEncoding",
16717                    xmlMemBlocks() - mem_base);
16718             test_ret++;
16719             printf(" %d", n_ctxt);
16720             printf(" %d", n_input);
16721             printf(" %d", n_handler);
16722             printf("\n");
16723         }
16724     }
16725     }
16726     }
16727     function_tests++;
16728
16729     return(test_ret);
16730 }
16731
16732
16733 static int
16734 test_xmlSwitchToEncoding(void) {
16735     int test_ret = 0;
16736
16737     int mem_base;
16738     int ret_val;
16739     xmlParserCtxtPtr ctxt; /* the parser context */
16740     int n_ctxt;
16741     xmlCharEncodingHandlerPtr handler; /* the encoding handler */
16742     int n_handler;
16743
16744     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
16745     for (n_handler = 0;n_handler < gen_nb_xmlCharEncodingHandlerPtr;n_handler++) {
16746         mem_base = xmlMemBlocks();
16747         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
16748         handler = gen_xmlCharEncodingHandlerPtr(n_handler, 1);
16749
16750         ret_val = xmlSwitchToEncoding(ctxt, handler);
16751         desret_int(ret_val);
16752         call_tests++;
16753         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
16754         des_xmlCharEncodingHandlerPtr(n_handler, handler, 1);
16755         xmlResetLastError();
16756         if (mem_base != xmlMemBlocks()) {
16757             printf("Leak of %d blocks found in xmlSwitchToEncoding",
16758                    xmlMemBlocks() - mem_base);
16759             test_ret++;
16760             printf(" %d", n_ctxt);
16761             printf(" %d", n_handler);
16762             printf("\n");
16763         }
16764     }
16765     }
16766     function_tests++;
16767
16768     return(test_ret);
16769 }
16770
16771 static int
16772 test_parserInternals(void) {
16773     int test_ret = 0;
16774
16775     if (quiet == 0) printf("Testing parserInternals : 33 of 90 functions ...\n");
16776     test_ret += test_htmlCreateFileParserCtxt();
16777     test_ret += test_htmlInitAutoClose();
16778     test_ret += test_inputPop();
16779     test_ret += test_inputPush();
16780     test_ret += test_namePop();
16781     test_ret += test_namePush();
16782     test_ret += test_nodePop();
16783     test_ret += test_nodePush();
16784     test_ret += test_xmlCheckLanguageID();
16785     test_ret += test_xmlCopyChar();
16786     test_ret += test_xmlCopyCharMultiByte();
16787     test_ret += test_xmlCreateEntityParserCtxt();
16788     test_ret += test_xmlCreateFileParserCtxt();
16789     test_ret += test_xmlCreateMemoryParserCtxt();
16790     test_ret += test_xmlCreateURLParserCtxt();
16791     test_ret += test_xmlCurrentChar();
16792     test_ret += test_xmlErrMemory();
16793     test_ret += test_xmlIsLetter();
16794     test_ret += test_xmlNewEntityInputStream();
16795     test_ret += test_xmlNewInputFromFile();
16796     test_ret += test_xmlNewInputStream();
16797     test_ret += test_xmlNewStringInputStream();
16798     test_ret += test_xmlNextChar();
16799     test_ret += test_xmlParserInputShrink();
16800     test_ret += test_xmlPopInput();
16801     test_ret += test_xmlPushInput();
16802     test_ret += test_xmlSetEntityReferenceFunc();
16803     test_ret += test_xmlSplitQName();
16804     test_ret += test_xmlStringCurrentChar();
16805     test_ret += test_xmlStringDecodeEntities();
16806     test_ret += test_xmlStringLenDecodeEntities();
16807     test_ret += test_xmlSwitchEncoding();
16808     test_ret += test_xmlSwitchInputEncoding();
16809     test_ret += test_xmlSwitchToEncoding();
16810
16811     if (test_ret != 0)
16812         printf("Module parserInternals: %d errors\n", test_ret);
16813     return(test_ret);
16814 }
16815
16816 static int
16817 test_xmlPatternFromRoot(void) {
16818     int test_ret = 0;
16819
16820 #if defined(LIBXML_PATTERN_ENABLED)
16821     int mem_base;
16822     int ret_val;
16823     xmlPatternPtr comp; /* the precompiled pattern */
16824     int n_comp;
16825
16826     for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) {
16827         mem_base = xmlMemBlocks();
16828         comp = gen_xmlPatternPtr(n_comp, 0);
16829
16830         ret_val = xmlPatternFromRoot(comp);
16831         desret_int(ret_val);
16832         call_tests++;
16833         des_xmlPatternPtr(n_comp, comp, 0);
16834         xmlResetLastError();
16835         if (mem_base != xmlMemBlocks()) {
16836             printf("Leak of %d blocks found in xmlPatternFromRoot",
16837                    xmlMemBlocks() - mem_base);
16838             test_ret++;
16839             printf(" %d", n_comp);
16840             printf("\n");
16841         }
16842     }
16843     function_tests++;
16844 #endif
16845
16846     return(test_ret);
16847 }
16848
16849
16850 static int
16851 test_xmlPatternGetStreamCtxt(void) {
16852     int test_ret = 0;
16853
16854
16855     /* missing type support */
16856     return(test_ret);
16857 }
16858
16859
16860 static int
16861 test_xmlPatternMatch(void) {
16862     int test_ret = 0;
16863
16864 #if defined(LIBXML_PATTERN_ENABLED)
16865     int mem_base;
16866     int ret_val;
16867     xmlPatternPtr comp; /* the precompiled pattern */
16868     int n_comp;
16869     xmlNodePtr node; /* a node */
16870     int n_node;
16871
16872     for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) {
16873     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
16874         mem_base = xmlMemBlocks();
16875         comp = gen_xmlPatternPtr(n_comp, 0);
16876         node = gen_xmlNodePtr(n_node, 1);
16877
16878         ret_val = xmlPatternMatch(comp, node);
16879         desret_int(ret_val);
16880         call_tests++;
16881         des_xmlPatternPtr(n_comp, comp, 0);
16882         des_xmlNodePtr(n_node, node, 1);
16883         xmlResetLastError();
16884         if (mem_base != xmlMemBlocks()) {
16885             printf("Leak of %d blocks found in xmlPatternMatch",
16886                    xmlMemBlocks() - mem_base);
16887             test_ret++;
16888             printf(" %d", n_comp);
16889             printf(" %d", n_node);
16890             printf("\n");
16891         }
16892     }
16893     }
16894     function_tests++;
16895 #endif
16896
16897     return(test_ret);
16898 }
16899
16900
16901 static int
16902 test_xmlPatternMaxDepth(void) {
16903     int test_ret = 0;
16904
16905 #if defined(LIBXML_PATTERN_ENABLED)
16906     int mem_base;
16907     int ret_val;
16908     xmlPatternPtr comp; /* the precompiled pattern */
16909     int n_comp;
16910
16911     for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) {
16912         mem_base = xmlMemBlocks();
16913         comp = gen_xmlPatternPtr(n_comp, 0);
16914
16915         ret_val = xmlPatternMaxDepth(comp);
16916         desret_int(ret_val);
16917         call_tests++;
16918         des_xmlPatternPtr(n_comp, comp, 0);
16919         xmlResetLastError();
16920         if (mem_base != xmlMemBlocks()) {
16921             printf("Leak of %d blocks found in xmlPatternMaxDepth",
16922                    xmlMemBlocks() - mem_base);
16923             test_ret++;
16924             printf(" %d", n_comp);
16925             printf("\n");
16926         }
16927     }
16928     function_tests++;
16929 #endif
16930
16931     return(test_ret);
16932 }
16933
16934
16935 static int
16936 test_xmlPatternMinDepth(void) {
16937     int test_ret = 0;
16938
16939 #if defined(LIBXML_PATTERN_ENABLED)
16940     int mem_base;
16941     int ret_val;
16942     xmlPatternPtr comp; /* the precompiled pattern */
16943     int n_comp;
16944
16945     for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) {
16946         mem_base = xmlMemBlocks();
16947         comp = gen_xmlPatternPtr(n_comp, 0);
16948
16949         ret_val = xmlPatternMinDepth(comp);
16950         desret_int(ret_val);
16951         call_tests++;
16952         des_xmlPatternPtr(n_comp, comp, 0);
16953         xmlResetLastError();
16954         if (mem_base != xmlMemBlocks()) {
16955             printf("Leak of %d blocks found in xmlPatternMinDepth",
16956                    xmlMemBlocks() - mem_base);
16957             test_ret++;
16958             printf(" %d", n_comp);
16959             printf("\n");
16960         }
16961     }
16962     function_tests++;
16963 #endif
16964
16965     return(test_ret);
16966 }
16967
16968
16969 static int
16970 test_xmlPatternStreamable(void) {
16971     int test_ret = 0;
16972
16973 #if defined(LIBXML_PATTERN_ENABLED)
16974     int mem_base;
16975     int ret_val;
16976     xmlPatternPtr comp; /* the precompiled pattern */
16977     int n_comp;
16978
16979     for (n_comp = 0;n_comp < gen_nb_xmlPatternPtr;n_comp++) {
16980         mem_base = xmlMemBlocks();
16981         comp = gen_xmlPatternPtr(n_comp, 0);
16982
16983         ret_val = xmlPatternStreamable(comp);
16984         desret_int(ret_val);
16985         call_tests++;
16986         des_xmlPatternPtr(n_comp, comp, 0);
16987         xmlResetLastError();
16988         if (mem_base != xmlMemBlocks()) {
16989             printf("Leak of %d blocks found in xmlPatternStreamable",
16990                    xmlMemBlocks() - mem_base);
16991             test_ret++;
16992             printf(" %d", n_comp);
16993             printf("\n");
16994         }
16995     }
16996     function_tests++;
16997 #endif
16998
16999     return(test_ret);
17000 }
17001
17002
17003 static int
17004 test_xmlPatterncompile(void) {
17005     int test_ret = 0;
17006
17007
17008     /* missing type support */
17009     return(test_ret);
17010 }
17011
17012 #ifdef LIBXML_PATTERN_ENABLED
17013
17014 #define gen_nb_xmlStreamCtxtPtr 1
17015 static xmlStreamCtxtPtr gen_xmlStreamCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17016     return(NULL);
17017 }
17018 static void des_xmlStreamCtxtPtr(int no ATTRIBUTE_UNUSED, xmlStreamCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17019 }
17020 #endif
17021
17022
17023 static int
17024 test_xmlStreamPop(void) {
17025     int test_ret = 0;
17026
17027 #if defined(LIBXML_PATTERN_ENABLED)
17028     int mem_base;
17029     int ret_val;
17030     xmlStreamCtxtPtr stream; /* the stream context */
17031     int n_stream;
17032
17033     for (n_stream = 0;n_stream < gen_nb_xmlStreamCtxtPtr;n_stream++) {
17034         mem_base = xmlMemBlocks();
17035         stream = gen_xmlStreamCtxtPtr(n_stream, 0);
17036
17037         ret_val = xmlStreamPop(stream);
17038         desret_int(ret_val);
17039         call_tests++;
17040         des_xmlStreamCtxtPtr(n_stream, stream, 0);
17041         xmlResetLastError();
17042         if (mem_base != xmlMemBlocks()) {
17043             printf("Leak of %d blocks found in xmlStreamPop",
17044                    xmlMemBlocks() - mem_base);
17045             test_ret++;
17046             printf(" %d", n_stream);
17047             printf("\n");
17048         }
17049     }
17050     function_tests++;
17051 #endif
17052
17053     return(test_ret);
17054 }
17055
17056
17057 static int
17058 test_xmlStreamPush(void) {
17059     int test_ret = 0;
17060
17061 #if defined(LIBXML_PATTERN_ENABLED)
17062     int mem_base;
17063     int ret_val;
17064     xmlStreamCtxtPtr stream; /* the stream context */
17065     int n_stream;
17066     xmlChar * name; /* the current name */
17067     int n_name;
17068     xmlChar * ns; /* the namespace name */
17069     int n_ns;
17070
17071     for (n_stream = 0;n_stream < gen_nb_xmlStreamCtxtPtr;n_stream++) {
17072     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
17073     for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) {
17074         mem_base = xmlMemBlocks();
17075         stream = gen_xmlStreamCtxtPtr(n_stream, 0);
17076         name = gen_const_xmlChar_ptr(n_name, 1);
17077         ns = gen_const_xmlChar_ptr(n_ns, 2);
17078
17079         ret_val = xmlStreamPush(stream, (const xmlChar *)name, (const xmlChar *)ns);
17080         desret_int(ret_val);
17081         call_tests++;
17082         des_xmlStreamCtxtPtr(n_stream, stream, 0);
17083         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
17084         des_const_xmlChar_ptr(n_ns, (const xmlChar *)ns, 2);
17085         xmlResetLastError();
17086         if (mem_base != xmlMemBlocks()) {
17087             printf("Leak of %d blocks found in xmlStreamPush",
17088                    xmlMemBlocks() - mem_base);
17089             test_ret++;
17090             printf(" %d", n_stream);
17091             printf(" %d", n_name);
17092             printf(" %d", n_ns);
17093             printf("\n");
17094         }
17095     }
17096     }
17097     }
17098     function_tests++;
17099 #endif
17100
17101     return(test_ret);
17102 }
17103
17104
17105 static int
17106 test_xmlStreamPushAttr(void) {
17107     int test_ret = 0;
17108
17109 #if defined(LIBXML_PATTERN_ENABLED)
17110     int mem_base;
17111     int ret_val;
17112     xmlStreamCtxtPtr stream; /* the stream context */
17113     int n_stream;
17114     xmlChar * name; /* the current name */
17115     int n_name;
17116     xmlChar * ns; /* the namespace name */
17117     int n_ns;
17118
17119     for (n_stream = 0;n_stream < gen_nb_xmlStreamCtxtPtr;n_stream++) {
17120     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
17121     for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) {
17122         mem_base = xmlMemBlocks();
17123         stream = gen_xmlStreamCtxtPtr(n_stream, 0);
17124         name = gen_const_xmlChar_ptr(n_name, 1);
17125         ns = gen_const_xmlChar_ptr(n_ns, 2);
17126
17127         ret_val = xmlStreamPushAttr(stream, (const xmlChar *)name, (const xmlChar *)ns);
17128         desret_int(ret_val);
17129         call_tests++;
17130         des_xmlStreamCtxtPtr(n_stream, stream, 0);
17131         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
17132         des_const_xmlChar_ptr(n_ns, (const xmlChar *)ns, 2);
17133         xmlResetLastError();
17134         if (mem_base != xmlMemBlocks()) {
17135             printf("Leak of %d blocks found in xmlStreamPushAttr",
17136                    xmlMemBlocks() - mem_base);
17137             test_ret++;
17138             printf(" %d", n_stream);
17139             printf(" %d", n_name);
17140             printf(" %d", n_ns);
17141             printf("\n");
17142         }
17143     }
17144     }
17145     }
17146     function_tests++;
17147 #endif
17148
17149     return(test_ret);
17150 }
17151
17152
17153 static int
17154 test_xmlStreamPushNode(void) {
17155     int test_ret = 0;
17156
17157 #if defined(LIBXML_PATTERN_ENABLED)
17158     int mem_base;
17159     int ret_val;
17160     xmlStreamCtxtPtr stream; /* the stream context */
17161     int n_stream;
17162     xmlChar * name; /* the current name */
17163     int n_name;
17164     xmlChar * ns; /* the namespace name */
17165     int n_ns;
17166     int nodeType; /* the type of the node being pushed */
17167     int n_nodeType;
17168
17169     for (n_stream = 0;n_stream < gen_nb_xmlStreamCtxtPtr;n_stream++) {
17170     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
17171     for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) {
17172     for (n_nodeType = 0;n_nodeType < gen_nb_int;n_nodeType++) {
17173         mem_base = xmlMemBlocks();
17174         stream = gen_xmlStreamCtxtPtr(n_stream, 0);
17175         name = gen_const_xmlChar_ptr(n_name, 1);
17176         ns = gen_const_xmlChar_ptr(n_ns, 2);
17177         nodeType = gen_int(n_nodeType, 3);
17178
17179         ret_val = xmlStreamPushNode(stream, (const xmlChar *)name, (const xmlChar *)ns, nodeType);
17180         desret_int(ret_val);
17181         call_tests++;
17182         des_xmlStreamCtxtPtr(n_stream, stream, 0);
17183         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
17184         des_const_xmlChar_ptr(n_ns, (const xmlChar *)ns, 2);
17185         des_int(n_nodeType, nodeType, 3);
17186         xmlResetLastError();
17187         if (mem_base != xmlMemBlocks()) {
17188             printf("Leak of %d blocks found in xmlStreamPushNode",
17189                    xmlMemBlocks() - mem_base);
17190             test_ret++;
17191             printf(" %d", n_stream);
17192             printf(" %d", n_name);
17193             printf(" %d", n_ns);
17194             printf(" %d", n_nodeType);
17195             printf("\n");
17196         }
17197     }
17198     }
17199     }
17200     }
17201     function_tests++;
17202 #endif
17203
17204     return(test_ret);
17205 }
17206
17207
17208 static int
17209 test_xmlStreamWantsAnyNode(void) {
17210     int test_ret = 0;
17211
17212 #if defined(LIBXML_PATTERN_ENABLED)
17213     int mem_base;
17214     int ret_val;
17215     xmlStreamCtxtPtr streamCtxt; /* the stream context */
17216     int n_streamCtxt;
17217
17218     for (n_streamCtxt = 0;n_streamCtxt < gen_nb_xmlStreamCtxtPtr;n_streamCtxt++) {
17219         mem_base = xmlMemBlocks();
17220         streamCtxt = gen_xmlStreamCtxtPtr(n_streamCtxt, 0);
17221
17222         ret_val = xmlStreamWantsAnyNode(streamCtxt);
17223         desret_int(ret_val);
17224         call_tests++;
17225         des_xmlStreamCtxtPtr(n_streamCtxt, streamCtxt, 0);
17226         xmlResetLastError();
17227         if (mem_base != xmlMemBlocks()) {
17228             printf("Leak of %d blocks found in xmlStreamWantsAnyNode",
17229                    xmlMemBlocks() - mem_base);
17230             test_ret++;
17231             printf(" %d", n_streamCtxt);
17232             printf("\n");
17233         }
17234     }
17235     function_tests++;
17236 #endif
17237
17238     return(test_ret);
17239 }
17240
17241 static int
17242 test_pattern(void) {
17243     int test_ret = 0;
17244
17245     if (quiet == 0) printf("Testing pattern : 10 of 15 functions ...\n");
17246     test_ret += test_xmlPatternFromRoot();
17247     test_ret += test_xmlPatternGetStreamCtxt();
17248     test_ret += test_xmlPatternMatch();
17249     test_ret += test_xmlPatternMaxDepth();
17250     test_ret += test_xmlPatternMinDepth();
17251     test_ret += test_xmlPatternStreamable();
17252     test_ret += test_xmlPatterncompile();
17253     test_ret += test_xmlStreamPop();
17254     test_ret += test_xmlStreamPush();
17255     test_ret += test_xmlStreamPushAttr();
17256     test_ret += test_xmlStreamPushNode();
17257     test_ret += test_xmlStreamWantsAnyNode();
17258
17259     if (test_ret != 0)
17260         printf("Module pattern: %d errors\n", test_ret);
17261     return(test_ret);
17262 }
17263 #ifdef LIBXML_SCHEMAS_ENABLED
17264
17265 #define gen_nb_xmlRelaxNGPtr 1
17266 static xmlRelaxNGPtr gen_xmlRelaxNGPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17267     return(NULL);
17268 }
17269 static void des_xmlRelaxNGPtr(int no ATTRIBUTE_UNUSED, xmlRelaxNGPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17270 }
17271 #endif
17272
17273
17274 static int
17275 test_xmlRelaxNGDump(void) {
17276     int test_ret = 0;
17277
17278 #if defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
17279     int mem_base;
17280     FILE * output; /* the file output */
17281     int n_output;
17282     xmlRelaxNGPtr schema; /* a schema structure */
17283     int n_schema;
17284
17285     for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
17286     for (n_schema = 0;n_schema < gen_nb_xmlRelaxNGPtr;n_schema++) {
17287         mem_base = xmlMemBlocks();
17288         output = gen_FILE_ptr(n_output, 0);
17289         schema = gen_xmlRelaxNGPtr(n_schema, 1);
17290
17291         xmlRelaxNGDump(output, schema);
17292         call_tests++;
17293         des_FILE_ptr(n_output, output, 0);
17294         des_xmlRelaxNGPtr(n_schema, schema, 1);
17295         xmlResetLastError();
17296         if (mem_base != xmlMemBlocks()) {
17297             printf("Leak of %d blocks found in xmlRelaxNGDump",
17298                    xmlMemBlocks() - mem_base);
17299             test_ret++;
17300             printf(" %d", n_output);
17301             printf(" %d", n_schema);
17302             printf("\n");
17303         }
17304     }
17305     }
17306     function_tests++;
17307 #endif
17308
17309     return(test_ret);
17310 }
17311
17312
17313 static int
17314 test_xmlRelaxNGDumpTree(void) {
17315     int test_ret = 0;
17316
17317 #if defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
17318     int mem_base;
17319     FILE * output; /* the file output */
17320     int n_output;
17321     xmlRelaxNGPtr schema; /* a schema structure */
17322     int n_schema;
17323
17324     for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
17325     for (n_schema = 0;n_schema < gen_nb_xmlRelaxNGPtr;n_schema++) {
17326         mem_base = xmlMemBlocks();
17327         output = gen_FILE_ptr(n_output, 0);
17328         schema = gen_xmlRelaxNGPtr(n_schema, 1);
17329
17330         xmlRelaxNGDumpTree(output, schema);
17331         call_tests++;
17332         des_FILE_ptr(n_output, output, 0);
17333         des_xmlRelaxNGPtr(n_schema, schema, 1);
17334         xmlResetLastError();
17335         if (mem_base != xmlMemBlocks()) {
17336             printf("Leak of %d blocks found in xmlRelaxNGDumpTree",
17337                    xmlMemBlocks() - mem_base);
17338             test_ret++;
17339             printf(" %d", n_output);
17340             printf(" %d", n_schema);
17341             printf("\n");
17342         }
17343     }
17344     }
17345     function_tests++;
17346 #endif
17347
17348     return(test_ret);
17349 }
17350
17351 #ifdef LIBXML_SCHEMAS_ENABLED
17352
17353 #define gen_nb_xmlRelaxNGParserCtxtPtr 1
17354 static xmlRelaxNGParserCtxtPtr gen_xmlRelaxNGParserCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17355     return(NULL);
17356 }
17357 static void des_xmlRelaxNGParserCtxtPtr(int no ATTRIBUTE_UNUSED, xmlRelaxNGParserCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17358 }
17359 #endif
17360
17361 #ifdef LIBXML_SCHEMAS_ENABLED
17362
17363 #define gen_nb_xmlRelaxNGValidityErrorFunc_ptr 1
17364 static xmlRelaxNGValidityErrorFunc * gen_xmlRelaxNGValidityErrorFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17365     return(NULL);
17366 }
17367 static void des_xmlRelaxNGValidityErrorFunc_ptr(int no ATTRIBUTE_UNUSED, xmlRelaxNGValidityErrorFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17368 }
17369 #endif
17370
17371 #ifdef LIBXML_SCHEMAS_ENABLED
17372
17373 #define gen_nb_xmlRelaxNGValidityWarningFunc_ptr 1
17374 static xmlRelaxNGValidityWarningFunc * gen_xmlRelaxNGValidityWarningFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17375     return(NULL);
17376 }
17377 static void des_xmlRelaxNGValidityWarningFunc_ptr(int no ATTRIBUTE_UNUSED, xmlRelaxNGValidityWarningFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17378 }
17379 #endif
17380
17381
17382 static int
17383 test_xmlRelaxNGGetParserErrors(void) {
17384     int test_ret = 0;
17385
17386 #if defined(LIBXML_SCHEMAS_ENABLED)
17387     int mem_base;
17388     int ret_val;
17389     xmlRelaxNGParserCtxtPtr ctxt; /* a Relax-NG validation context */
17390     int n_ctxt;
17391     xmlRelaxNGValidityErrorFunc * err; /* the error callback result */
17392     int n_err;
17393     xmlRelaxNGValidityWarningFunc * warn; /* the warning callback result */
17394     int n_warn;
17395     void ** ctx; /* contextual data for the callbacks result */
17396     int n_ctx;
17397
17398     for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGParserCtxtPtr;n_ctxt++) {
17399     for (n_err = 0;n_err < gen_nb_xmlRelaxNGValidityErrorFunc_ptr;n_err++) {
17400     for (n_warn = 0;n_warn < gen_nb_xmlRelaxNGValidityWarningFunc_ptr;n_warn++) {
17401     for (n_ctx = 0;n_ctx < gen_nb_void_ptr_ptr;n_ctx++) {
17402         mem_base = xmlMemBlocks();
17403         ctxt = gen_xmlRelaxNGParserCtxtPtr(n_ctxt, 0);
17404         err = gen_xmlRelaxNGValidityErrorFunc_ptr(n_err, 1);
17405         warn = gen_xmlRelaxNGValidityWarningFunc_ptr(n_warn, 2);
17406         ctx = gen_void_ptr_ptr(n_ctx, 3);
17407
17408         ret_val = xmlRelaxNGGetParserErrors(ctxt, err, warn, ctx);
17409         desret_int(ret_val);
17410         call_tests++;
17411         des_xmlRelaxNGParserCtxtPtr(n_ctxt, ctxt, 0);
17412         des_xmlRelaxNGValidityErrorFunc_ptr(n_err, err, 1);
17413         des_xmlRelaxNGValidityWarningFunc_ptr(n_warn, warn, 2);
17414         des_void_ptr_ptr(n_ctx, ctx, 3);
17415         xmlResetLastError();
17416         if (mem_base != xmlMemBlocks()) {
17417             printf("Leak of %d blocks found in xmlRelaxNGGetParserErrors",
17418                    xmlMemBlocks() - mem_base);
17419             test_ret++;
17420             printf(" %d", n_ctxt);
17421             printf(" %d", n_err);
17422             printf(" %d", n_warn);
17423             printf(" %d", n_ctx);
17424             printf("\n");
17425         }
17426     }
17427     }
17428     }
17429     }
17430     function_tests++;
17431 #endif
17432
17433     return(test_ret);
17434 }
17435
17436 #ifdef LIBXML_SCHEMAS_ENABLED
17437
17438 #define gen_nb_xmlRelaxNGValidCtxtPtr 1
17439 static xmlRelaxNGValidCtxtPtr gen_xmlRelaxNGValidCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17440     return(NULL);
17441 }
17442 static void des_xmlRelaxNGValidCtxtPtr(int no ATTRIBUTE_UNUSED, xmlRelaxNGValidCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
17443 }
17444 #endif
17445
17446
17447 static int
17448 test_xmlRelaxNGGetValidErrors(void) {
17449     int test_ret = 0;
17450
17451 #if defined(LIBXML_SCHEMAS_ENABLED)
17452     int mem_base;
17453     int ret_val;
17454     xmlRelaxNGValidCtxtPtr ctxt; /* a Relax-NG validation context */
17455     int n_ctxt;
17456     xmlRelaxNGValidityErrorFunc * err; /* the error function result */
17457     int n_err;
17458     xmlRelaxNGValidityWarningFunc * warn; /* the warning function result */
17459     int n_warn;
17460     void ** ctx; /* the functions context result */
17461     int n_ctx;
17462
17463     for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
17464     for (n_err = 0;n_err < gen_nb_xmlRelaxNGValidityErrorFunc_ptr;n_err++) {
17465     for (n_warn = 0;n_warn < gen_nb_xmlRelaxNGValidityWarningFunc_ptr;n_warn++) {
17466     for (n_ctx = 0;n_ctx < gen_nb_void_ptr_ptr;n_ctx++) {
17467         mem_base = xmlMemBlocks();
17468         ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
17469         err = gen_xmlRelaxNGValidityErrorFunc_ptr(n_err, 1);
17470         warn = gen_xmlRelaxNGValidityWarningFunc_ptr(n_warn, 2);
17471         ctx = gen_void_ptr_ptr(n_ctx, 3);
17472
17473         ret_val = xmlRelaxNGGetValidErrors(ctxt, err, warn, ctx);
17474         desret_int(ret_val);
17475         call_tests++;
17476         des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
17477         des_xmlRelaxNGValidityErrorFunc_ptr(n_err, err, 1);
17478         des_xmlRelaxNGValidityWarningFunc_ptr(n_warn, warn, 2);
17479         des_void_ptr_ptr(n_ctx, ctx, 3);
17480         xmlResetLastError();
17481         if (mem_base != xmlMemBlocks()) {
17482             printf("Leak of %d blocks found in xmlRelaxNGGetValidErrors",
17483                    xmlMemBlocks() - mem_base);
17484             test_ret++;
17485             printf(" %d", n_ctxt);
17486             printf(" %d", n_err);
17487             printf(" %d", n_warn);
17488             printf(" %d", n_ctx);
17489             printf("\n");
17490         }
17491     }
17492     }
17493     }
17494     }
17495     function_tests++;
17496 #endif
17497
17498     return(test_ret);
17499 }
17500
17501
17502 static int
17503 test_xmlRelaxNGInitTypes(void) {
17504     int test_ret = 0;
17505
17506 #if defined(LIBXML_SCHEMAS_ENABLED)
17507     int mem_base;
17508     int ret_val;
17509
17510         mem_base = xmlMemBlocks();
17511
17512         ret_val = xmlRelaxNGInitTypes();
17513         desret_int(ret_val);
17514         call_tests++;
17515         xmlResetLastError();
17516         if (mem_base != xmlMemBlocks()) {
17517             printf("Leak of %d blocks found in xmlRelaxNGInitTypes",
17518                    xmlMemBlocks() - mem_base);
17519             test_ret++;
17520             printf("\n");
17521         }
17522     function_tests++;
17523 #endif
17524
17525     return(test_ret);
17526 }
17527
17528
17529 static int
17530 test_xmlRelaxNGNewDocParserCtxt(void) {
17531     int test_ret = 0;
17532
17533 #if defined(LIBXML_SCHEMAS_ENABLED)
17534     int mem_base;
17535     xmlRelaxNGParserCtxtPtr ret_val;
17536     xmlDocPtr doc; /* a preparsed document tree */
17537     int n_doc;
17538
17539     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
17540         mem_base = xmlMemBlocks();
17541         doc = gen_xmlDocPtr(n_doc, 0);
17542
17543         ret_val = xmlRelaxNGNewDocParserCtxt(doc);
17544         desret_xmlRelaxNGParserCtxtPtr(ret_val);
17545         call_tests++;
17546         des_xmlDocPtr(n_doc, doc, 0);
17547         xmlResetLastError();
17548         if (mem_base != xmlMemBlocks()) {
17549             printf("Leak of %d blocks found in xmlRelaxNGNewDocParserCtxt",
17550                    xmlMemBlocks() - mem_base);
17551             test_ret++;
17552             printf(" %d", n_doc);
17553             printf("\n");
17554         }
17555     }
17556     function_tests++;
17557 #endif
17558
17559     return(test_ret);
17560 }
17561
17562
17563 static int
17564 test_xmlRelaxNGNewMemParserCtxt(void) {
17565     int test_ret = 0;
17566
17567 #if defined(LIBXML_SCHEMAS_ENABLED)
17568     int mem_base;
17569     xmlRelaxNGParserCtxtPtr ret_val;
17570     char * buffer; /* a pointer to a char array containing the schemas */
17571     int n_buffer;
17572     int size; /* the size of the array */
17573     int n_size;
17574
17575     for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
17576     for (n_size = 0;n_size < gen_nb_int;n_size++) {
17577         mem_base = xmlMemBlocks();
17578         buffer = gen_const_char_ptr(n_buffer, 0);
17579         size = gen_int(n_size, 1);
17580
17581         ret_val = xmlRelaxNGNewMemParserCtxt((const char *)buffer, size);
17582         desret_xmlRelaxNGParserCtxtPtr(ret_val);
17583         call_tests++;
17584         des_const_char_ptr(n_buffer, (const char *)buffer, 0);
17585         des_int(n_size, size, 1);
17586         xmlResetLastError();
17587         if (mem_base != xmlMemBlocks()) {
17588             printf("Leak of %d blocks found in xmlRelaxNGNewMemParserCtxt",
17589                    xmlMemBlocks() - mem_base);
17590             test_ret++;
17591             printf(" %d", n_buffer);
17592             printf(" %d", n_size);
17593             printf("\n");
17594         }
17595     }
17596     }
17597     function_tests++;
17598 #endif
17599
17600     return(test_ret);
17601 }
17602
17603
17604 static int
17605 test_xmlRelaxNGNewParserCtxt(void) {
17606     int test_ret = 0;
17607
17608 #if defined(LIBXML_SCHEMAS_ENABLED)
17609     int mem_base;
17610     xmlRelaxNGParserCtxtPtr ret_val;
17611     char * URL; /* the location of the schema */
17612     int n_URL;
17613
17614     for (n_URL = 0;n_URL < gen_nb_const_char_ptr;n_URL++) {
17615         mem_base = xmlMemBlocks();
17616         URL = gen_const_char_ptr(n_URL, 0);
17617
17618         ret_val = xmlRelaxNGNewParserCtxt((const char *)URL);
17619         desret_xmlRelaxNGParserCtxtPtr(ret_val);
17620         call_tests++;
17621         des_const_char_ptr(n_URL, (const char *)URL, 0);
17622         xmlResetLastError();
17623         if (mem_base != xmlMemBlocks()) {
17624             printf("Leak of %d blocks found in xmlRelaxNGNewParserCtxt",
17625                    xmlMemBlocks() - mem_base);
17626             test_ret++;
17627             printf(" %d", n_URL);
17628             printf("\n");
17629         }
17630     }
17631     function_tests++;
17632 #endif
17633
17634     return(test_ret);
17635 }
17636
17637
17638 static int
17639 test_xmlRelaxNGNewValidCtxt(void) {
17640     int test_ret = 0;
17641
17642
17643     /* missing type support */
17644     return(test_ret);
17645 }
17646
17647
17648 static int
17649 test_xmlRelaxNGParse(void) {
17650     int test_ret = 0;
17651
17652
17653     /* missing type support */
17654     return(test_ret);
17655 }
17656
17657
17658 static int
17659 test_xmlRelaxNGSetParserErrors(void) {
17660     int test_ret = 0;
17661
17662
17663     /* missing type support */
17664     return(test_ret);
17665 }
17666
17667
17668 static int
17669 test_xmlRelaxNGSetParserStructuredErrors(void) {
17670     int test_ret = 0;
17671
17672
17673     /* missing type support */
17674     return(test_ret);
17675 }
17676
17677
17678 static int
17679 test_xmlRelaxNGSetValidErrors(void) {
17680     int test_ret = 0;
17681
17682
17683     /* missing type support */
17684     return(test_ret);
17685 }
17686
17687
17688 static int
17689 test_xmlRelaxNGSetValidStructuredErrors(void) {
17690     int test_ret = 0;
17691
17692
17693     /* missing type support */
17694     return(test_ret);
17695 }
17696
17697
17698 static int
17699 test_xmlRelaxNGValidateDoc(void) {
17700     int test_ret = 0;
17701
17702 #if defined(LIBXML_SCHEMAS_ENABLED)
17703     int mem_base;
17704     int ret_val;
17705     xmlRelaxNGValidCtxtPtr ctxt; /* a Relax-NG validation context */
17706     int n_ctxt;
17707     xmlDocPtr doc; /* a parsed document tree */
17708     int n_doc;
17709
17710     for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
17711     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
17712         mem_base = xmlMemBlocks();
17713         ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
17714         doc = gen_xmlDocPtr(n_doc, 1);
17715
17716         ret_val = xmlRelaxNGValidateDoc(ctxt, doc);
17717         desret_int(ret_val);
17718         call_tests++;
17719         des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
17720         des_xmlDocPtr(n_doc, doc, 1);
17721         xmlResetLastError();
17722         if (mem_base != xmlMemBlocks()) {
17723             printf("Leak of %d blocks found in xmlRelaxNGValidateDoc",
17724                    xmlMemBlocks() - mem_base);
17725             test_ret++;
17726             printf(" %d", n_ctxt);
17727             printf(" %d", n_doc);
17728             printf("\n");
17729         }
17730     }
17731     }
17732     function_tests++;
17733 #endif
17734
17735     return(test_ret);
17736 }
17737
17738
17739 static int
17740 test_xmlRelaxNGValidateFullElement(void) {
17741     int test_ret = 0;
17742
17743 #if defined(LIBXML_SCHEMAS_ENABLED)
17744     int mem_base;
17745     int ret_val;
17746     xmlRelaxNGValidCtxtPtr ctxt; /* the validation context */
17747     int n_ctxt;
17748     xmlDocPtr doc; /* a document instance */
17749     int n_doc;
17750     xmlNodePtr elem; /* an element instance */
17751     int n_elem;
17752
17753     for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
17754     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
17755     for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
17756         mem_base = xmlMemBlocks();
17757         ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
17758         doc = gen_xmlDocPtr(n_doc, 1);
17759         elem = gen_xmlNodePtr(n_elem, 2);
17760
17761         ret_val = xmlRelaxNGValidateFullElement(ctxt, doc, elem);
17762         desret_int(ret_val);
17763         call_tests++;
17764         des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
17765         des_xmlDocPtr(n_doc, doc, 1);
17766         des_xmlNodePtr(n_elem, elem, 2);
17767         xmlResetLastError();
17768         if (mem_base != xmlMemBlocks()) {
17769             printf("Leak of %d blocks found in xmlRelaxNGValidateFullElement",
17770                    xmlMemBlocks() - mem_base);
17771             test_ret++;
17772             printf(" %d", n_ctxt);
17773             printf(" %d", n_doc);
17774             printf(" %d", n_elem);
17775             printf("\n");
17776         }
17777     }
17778     }
17779     }
17780     function_tests++;
17781 #endif
17782
17783     return(test_ret);
17784 }
17785
17786
17787 static int
17788 test_xmlRelaxNGValidatePopElement(void) {
17789     int test_ret = 0;
17790
17791 #if defined(LIBXML_SCHEMAS_ENABLED)
17792     int mem_base;
17793     int ret_val;
17794     xmlRelaxNGValidCtxtPtr ctxt; /* the RelaxNG validation context */
17795     int n_ctxt;
17796     xmlDocPtr doc; /* a document instance */
17797     int n_doc;
17798     xmlNodePtr elem; /* an element instance */
17799     int n_elem;
17800
17801     for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
17802     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
17803     for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
17804         mem_base = xmlMemBlocks();
17805         ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
17806         doc = gen_xmlDocPtr(n_doc, 1);
17807         elem = gen_xmlNodePtr(n_elem, 2);
17808
17809         ret_val = xmlRelaxNGValidatePopElement(ctxt, doc, elem);
17810         desret_int(ret_val);
17811         call_tests++;
17812         des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
17813         des_xmlDocPtr(n_doc, doc, 1);
17814         des_xmlNodePtr(n_elem, elem, 2);
17815         xmlResetLastError();
17816         if (mem_base != xmlMemBlocks()) {
17817             printf("Leak of %d blocks found in xmlRelaxNGValidatePopElement",
17818                    xmlMemBlocks() - mem_base);
17819             test_ret++;
17820             printf(" %d", n_ctxt);
17821             printf(" %d", n_doc);
17822             printf(" %d", n_elem);
17823             printf("\n");
17824         }
17825     }
17826     }
17827     }
17828     function_tests++;
17829 #endif
17830
17831     return(test_ret);
17832 }
17833
17834
17835 static int
17836 test_xmlRelaxNGValidatePushCData(void) {
17837     int test_ret = 0;
17838
17839 #if defined(LIBXML_SCHEMAS_ENABLED)
17840     int mem_base;
17841     int ret_val;
17842     xmlRelaxNGValidCtxtPtr ctxt; /* the RelaxNG validation context */
17843     int n_ctxt;
17844     xmlChar * data; /* some character data read */
17845     int n_data;
17846     int len; /* the lenght of the data */
17847     int n_len;
17848
17849     for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
17850     for (n_data = 0;n_data < gen_nb_const_xmlChar_ptr;n_data++) {
17851     for (n_len = 0;n_len < gen_nb_int;n_len++) {
17852         mem_base = xmlMemBlocks();
17853         ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
17854         data = gen_const_xmlChar_ptr(n_data, 1);
17855         len = gen_int(n_len, 2);
17856
17857         ret_val = xmlRelaxNGValidatePushCData(ctxt, (const xmlChar *)data, len);
17858         desret_int(ret_val);
17859         call_tests++;
17860         des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
17861         des_const_xmlChar_ptr(n_data, (const xmlChar *)data, 1);
17862         des_int(n_len, len, 2);
17863         xmlResetLastError();
17864         if (mem_base != xmlMemBlocks()) {
17865             printf("Leak of %d blocks found in xmlRelaxNGValidatePushCData",
17866                    xmlMemBlocks() - mem_base);
17867             test_ret++;
17868             printf(" %d", n_ctxt);
17869             printf(" %d", n_data);
17870             printf(" %d", n_len);
17871             printf("\n");
17872         }
17873     }
17874     }
17875     }
17876     function_tests++;
17877 #endif
17878
17879     return(test_ret);
17880 }
17881
17882
17883 static int
17884 test_xmlRelaxNGValidatePushElement(void) {
17885     int test_ret = 0;
17886
17887 #if defined(LIBXML_SCHEMAS_ENABLED)
17888     int mem_base;
17889     int ret_val;
17890     xmlRelaxNGValidCtxtPtr ctxt; /* the validation context */
17891     int n_ctxt;
17892     xmlDocPtr doc; /* a document instance */
17893     int n_doc;
17894     xmlNodePtr elem; /* an element instance */
17895     int n_elem;
17896
17897     for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGValidCtxtPtr;n_ctxt++) {
17898     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
17899     for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
17900         mem_base = xmlMemBlocks();
17901         ctxt = gen_xmlRelaxNGValidCtxtPtr(n_ctxt, 0);
17902         doc = gen_xmlDocPtr(n_doc, 1);
17903         elem = gen_xmlNodePtr(n_elem, 2);
17904
17905         ret_val = xmlRelaxNGValidatePushElement(ctxt, doc, elem);
17906         desret_int(ret_val);
17907         call_tests++;
17908         des_xmlRelaxNGValidCtxtPtr(n_ctxt, ctxt, 0);
17909         des_xmlDocPtr(n_doc, doc, 1);
17910         des_xmlNodePtr(n_elem, elem, 2);
17911         xmlResetLastError();
17912         if (mem_base != xmlMemBlocks()) {
17913             printf("Leak of %d blocks found in xmlRelaxNGValidatePushElement",
17914                    xmlMemBlocks() - mem_base);
17915             test_ret++;
17916             printf(" %d", n_ctxt);
17917             printf(" %d", n_doc);
17918             printf(" %d", n_elem);
17919             printf("\n");
17920         }
17921     }
17922     }
17923     }
17924     function_tests++;
17925 #endif
17926
17927     return(test_ret);
17928 }
17929
17930
17931 static int
17932 test_xmlRelaxParserSetFlag(void) {
17933     int test_ret = 0;
17934
17935 #if defined(LIBXML_SCHEMAS_ENABLED)
17936     int mem_base;
17937     int ret_val;
17938     xmlRelaxNGParserCtxtPtr ctxt; /* a RelaxNG parser context */
17939     int n_ctxt;
17940     int flags; /* a set of flags values */
17941     int n_flags;
17942
17943     for (n_ctxt = 0;n_ctxt < gen_nb_xmlRelaxNGParserCtxtPtr;n_ctxt++) {
17944     for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
17945         mem_base = xmlMemBlocks();
17946         ctxt = gen_xmlRelaxNGParserCtxtPtr(n_ctxt, 0);
17947         flags = gen_int(n_flags, 1);
17948
17949         ret_val = xmlRelaxParserSetFlag(ctxt, flags);
17950         desret_int(ret_val);
17951         call_tests++;
17952         des_xmlRelaxNGParserCtxtPtr(n_ctxt, ctxt, 0);
17953         des_int(n_flags, flags, 1);
17954         xmlResetLastError();
17955         if (mem_base != xmlMemBlocks()) {
17956             printf("Leak of %d blocks found in xmlRelaxParserSetFlag",
17957                    xmlMemBlocks() - mem_base);
17958             test_ret++;
17959             printf(" %d", n_ctxt);
17960             printf(" %d", n_flags);
17961             printf("\n");
17962         }
17963     }
17964     }
17965     function_tests++;
17966 #endif
17967
17968     return(test_ret);
17969 }
17970
17971 static int
17972 test_relaxng(void) {
17973     int test_ret = 0;
17974
17975     if (quiet == 0) printf("Testing relaxng : 14 of 24 functions ...\n");
17976     test_ret += test_xmlRelaxNGDump();
17977     test_ret += test_xmlRelaxNGDumpTree();
17978     test_ret += test_xmlRelaxNGGetParserErrors();
17979     test_ret += test_xmlRelaxNGGetValidErrors();
17980     test_ret += test_xmlRelaxNGInitTypes();
17981     test_ret += test_xmlRelaxNGNewDocParserCtxt();
17982     test_ret += test_xmlRelaxNGNewMemParserCtxt();
17983     test_ret += test_xmlRelaxNGNewParserCtxt();
17984     test_ret += test_xmlRelaxNGNewValidCtxt();
17985     test_ret += test_xmlRelaxNGParse();
17986     test_ret += test_xmlRelaxNGSetParserErrors();
17987     test_ret += test_xmlRelaxNGSetParserStructuredErrors();
17988     test_ret += test_xmlRelaxNGSetValidErrors();
17989     test_ret += test_xmlRelaxNGSetValidStructuredErrors();
17990     test_ret += test_xmlRelaxNGValidateDoc();
17991     test_ret += test_xmlRelaxNGValidateFullElement();
17992     test_ret += test_xmlRelaxNGValidatePopElement();
17993     test_ret += test_xmlRelaxNGValidatePushCData();
17994     test_ret += test_xmlRelaxNGValidatePushElement();
17995     test_ret += test_xmlRelaxParserSetFlag();
17996
17997     if (test_ret != 0)
17998         printf("Module relaxng: %d errors\n", test_ret);
17999     return(test_ret);
18000 }
18001 static int
18002 test_schemasInternals(void) {
18003     int test_ret = 0;
18004
18005     if (quiet == 0) printf("Testing schemasInternals : 0 of 2 functions ...\n");
18006
18007     if (test_ret != 0)
18008         printf("Module schemasInternals: %d errors\n", test_ret);
18009     return(test_ret);
18010 }
18011
18012 static int
18013 test_xmlSchematronNewDocParserCtxt(void) {
18014     int test_ret = 0;
18015
18016
18017     /* missing type support */
18018     return(test_ret);
18019 }
18020
18021
18022 static int
18023 test_xmlSchematronNewMemParserCtxt(void) {
18024     int test_ret = 0;
18025
18026
18027     /* missing type support */
18028     return(test_ret);
18029 }
18030
18031
18032 static int
18033 test_xmlSchematronNewParserCtxt(void) {
18034     int test_ret = 0;
18035
18036
18037     /* missing type support */
18038     return(test_ret);
18039 }
18040
18041 #ifdef LIBXML_SCHEMATRON_ENABLED
18042
18043 #define gen_nb_xmlSchematronPtr 1
18044 static xmlSchematronPtr gen_xmlSchematronPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
18045     return(NULL);
18046 }
18047 static void des_xmlSchematronPtr(int no ATTRIBUTE_UNUSED, xmlSchematronPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
18048 }
18049 #endif
18050
18051
18052 static int
18053 test_xmlSchematronNewValidCtxt(void) {
18054     int test_ret = 0;
18055
18056
18057     /* missing type support */
18058     return(test_ret);
18059 }
18060
18061 #ifdef LIBXML_SCHEMATRON_ENABLED
18062
18063 #define gen_nb_xmlSchematronParserCtxtPtr 1
18064 static xmlSchematronParserCtxtPtr gen_xmlSchematronParserCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
18065     return(NULL);
18066 }
18067 static void des_xmlSchematronParserCtxtPtr(int no ATTRIBUTE_UNUSED, xmlSchematronParserCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
18068 }
18069 #endif
18070
18071
18072 static int
18073 test_xmlSchematronParse(void) {
18074     int test_ret = 0;
18075
18076
18077     /* missing type support */
18078     return(test_ret);
18079 }
18080
18081 #ifdef LIBXML_SCHEMATRON_ENABLED
18082
18083 #define gen_nb_xmlSchematronValidCtxtPtr 1
18084 static xmlSchematronValidCtxtPtr gen_xmlSchematronValidCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
18085     return(NULL);
18086 }
18087 static void des_xmlSchematronValidCtxtPtr(int no ATTRIBUTE_UNUSED, xmlSchematronValidCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
18088 }
18089 #endif
18090
18091
18092 static int
18093 test_xmlSchematronSetValidStructuredErrors(void) {
18094     int test_ret = 0;
18095
18096
18097     /* missing type support */
18098     return(test_ret);
18099 }
18100
18101
18102 static int
18103 test_xmlSchematronValidateDoc(void) {
18104     int test_ret = 0;
18105
18106 #if defined(LIBXML_SCHEMATRON_ENABLED)
18107     int mem_base;
18108     int ret_val;
18109     xmlSchematronValidCtxtPtr ctxt; /* the schema validation context */
18110     int n_ctxt;
18111     xmlDocPtr instance; /* the document instace tree */
18112     int n_instance;
18113
18114     for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchematronValidCtxtPtr;n_ctxt++) {
18115     for (n_instance = 0;n_instance < gen_nb_xmlDocPtr;n_instance++) {
18116         mem_base = xmlMemBlocks();
18117         ctxt = gen_xmlSchematronValidCtxtPtr(n_ctxt, 0);
18118         instance = gen_xmlDocPtr(n_instance, 1);
18119
18120         ret_val = xmlSchematronValidateDoc(ctxt, instance);
18121         desret_int(ret_val);
18122         call_tests++;
18123         des_xmlSchematronValidCtxtPtr(n_ctxt, ctxt, 0);
18124         des_xmlDocPtr(n_instance, instance, 1);
18125         xmlResetLastError();
18126         if (mem_base != xmlMemBlocks()) {
18127             printf("Leak of %d blocks found in xmlSchematronValidateDoc",
18128                    xmlMemBlocks() - mem_base);
18129             test_ret++;
18130             printf(" %d", n_ctxt);
18131             printf(" %d", n_instance);
18132             printf("\n");
18133         }
18134     }
18135     }
18136     function_tests++;
18137 #endif
18138
18139     return(test_ret);
18140 }
18141
18142 static int
18143 test_schematron(void) {
18144     int test_ret = 0;
18145
18146     if (quiet == 0) printf("Testing schematron : 1 of 10 functions ...\n");
18147     test_ret += test_xmlSchematronNewDocParserCtxt();
18148     test_ret += test_xmlSchematronNewMemParserCtxt();
18149     test_ret += test_xmlSchematronNewParserCtxt();
18150     test_ret += test_xmlSchematronNewValidCtxt();
18151     test_ret += test_xmlSchematronParse();
18152     test_ret += test_xmlSchematronSetValidStructuredErrors();
18153     test_ret += test_xmlSchematronValidateDoc();
18154
18155     if (test_ret != 0)
18156         printf("Module schematron: %d errors\n", test_ret);
18157     return(test_ret);
18158 }
18159
18160 static int
18161 test_xmlAddChild(void) {
18162     int test_ret = 0;
18163
18164     int mem_base;
18165     xmlNodePtr ret_val;
18166     xmlNodePtr parent; /* the parent node */
18167     int n_parent;
18168     xmlNodePtr cur; /* the child node */
18169     int n_cur;
18170
18171     for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
18172     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr_in;n_cur++) {
18173         mem_base = xmlMemBlocks();
18174         parent = gen_xmlNodePtr(n_parent, 0);
18175         cur = gen_xmlNodePtr_in(n_cur, 1);
18176
18177         ret_val = xmlAddChild(parent, cur);
18178         if (ret_val == NULL) { xmlFreeNode(cur) ; cur = NULL ; }
18179         desret_xmlNodePtr(ret_val);
18180         call_tests++;
18181         des_xmlNodePtr(n_parent, parent, 0);
18182         des_xmlNodePtr_in(n_cur, cur, 1);
18183         xmlResetLastError();
18184         if (mem_base != xmlMemBlocks()) {
18185             printf("Leak of %d blocks found in xmlAddChild",
18186                    xmlMemBlocks() - mem_base);
18187             test_ret++;
18188             printf(" %d", n_parent);
18189             printf(" %d", n_cur);
18190             printf("\n");
18191         }
18192     }
18193     }
18194     function_tests++;
18195
18196     return(test_ret);
18197 }
18198
18199
18200 static int
18201 test_xmlAddChildList(void) {
18202     int test_ret = 0;
18203
18204     int mem_base;
18205     xmlNodePtr ret_val;
18206     xmlNodePtr parent; /* the parent node */
18207     int n_parent;
18208     xmlNodePtr cur; /* the first node in the list */
18209     int n_cur;
18210
18211     for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
18212     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr_in;n_cur++) {
18213         mem_base = xmlMemBlocks();
18214         parent = gen_xmlNodePtr(n_parent, 0);
18215         cur = gen_xmlNodePtr_in(n_cur, 1);
18216
18217         ret_val = xmlAddChildList(parent, cur);
18218         if (ret_val == NULL) { xmlFreeNodeList(cur) ; cur = NULL ; }
18219         desret_xmlNodePtr(ret_val);
18220         call_tests++;
18221         des_xmlNodePtr(n_parent, parent, 0);
18222         des_xmlNodePtr_in(n_cur, cur, 1);
18223         xmlResetLastError();
18224         if (mem_base != xmlMemBlocks()) {
18225             printf("Leak of %d blocks found in xmlAddChildList",
18226                    xmlMemBlocks() - mem_base);
18227             test_ret++;
18228             printf(" %d", n_parent);
18229             printf(" %d", n_cur);
18230             printf("\n");
18231         }
18232     }
18233     }
18234     function_tests++;
18235
18236     return(test_ret);
18237 }
18238
18239
18240 static int
18241 test_xmlAddNextSibling(void) {
18242     int test_ret = 0;
18243
18244     int mem_base;
18245     xmlNodePtr ret_val;
18246     xmlNodePtr cur; /* the child node */
18247     int n_cur;
18248     xmlNodePtr elem; /* the new node */
18249     int n_elem;
18250
18251     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
18252     for (n_elem = 0;n_elem < gen_nb_xmlNodePtr_in;n_elem++) {
18253         mem_base = xmlMemBlocks();
18254         cur = gen_xmlNodePtr(n_cur, 0);
18255         elem = gen_xmlNodePtr_in(n_elem, 1);
18256
18257         ret_val = xmlAddNextSibling(cur, elem);
18258         if (ret_val == NULL) { xmlFreeNode(elem) ; elem = NULL ; }
18259         desret_xmlNodePtr(ret_val);
18260         call_tests++;
18261         des_xmlNodePtr(n_cur, cur, 0);
18262         des_xmlNodePtr_in(n_elem, elem, 1);
18263         xmlResetLastError();
18264         if (mem_base != xmlMemBlocks()) {
18265             printf("Leak of %d blocks found in xmlAddNextSibling",
18266                    xmlMemBlocks() - mem_base);
18267             test_ret++;
18268             printf(" %d", n_cur);
18269             printf(" %d", n_elem);
18270             printf("\n");
18271         }
18272     }
18273     }
18274     function_tests++;
18275
18276     return(test_ret);
18277 }
18278
18279
18280 static int
18281 test_xmlAddPrevSibling(void) {
18282     int test_ret = 0;
18283
18284 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
18285     int mem_base;
18286     xmlNodePtr ret_val;
18287     xmlNodePtr cur; /* the child node */
18288     int n_cur;
18289     xmlNodePtr elem; /* the new node */
18290     int n_elem;
18291
18292     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
18293     for (n_elem = 0;n_elem < gen_nb_xmlNodePtr_in;n_elem++) {
18294         mem_base = xmlMemBlocks();
18295         cur = gen_xmlNodePtr(n_cur, 0);
18296         elem = gen_xmlNodePtr_in(n_elem, 1);
18297
18298         ret_val = xmlAddPrevSibling(cur, elem);
18299         if (ret_val == NULL) { xmlFreeNode(elem) ; elem = NULL ; }
18300         desret_xmlNodePtr(ret_val);
18301         call_tests++;
18302         des_xmlNodePtr(n_cur, cur, 0);
18303         des_xmlNodePtr_in(n_elem, elem, 1);
18304         xmlResetLastError();
18305         if (mem_base != xmlMemBlocks()) {
18306             printf("Leak of %d blocks found in xmlAddPrevSibling",
18307                    xmlMemBlocks() - mem_base);
18308             test_ret++;
18309             printf(" %d", n_cur);
18310             printf(" %d", n_elem);
18311             printf("\n");
18312         }
18313     }
18314     }
18315     function_tests++;
18316 #endif
18317
18318     return(test_ret);
18319 }
18320
18321
18322 static int
18323 test_xmlAddSibling(void) {
18324     int test_ret = 0;
18325
18326     int mem_base;
18327     xmlNodePtr ret_val;
18328     xmlNodePtr cur; /* the child node */
18329     int n_cur;
18330     xmlNodePtr elem; /* the new node */
18331     int n_elem;
18332
18333     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
18334     for (n_elem = 0;n_elem < gen_nb_xmlNodePtr_in;n_elem++) {
18335         mem_base = xmlMemBlocks();
18336         cur = gen_xmlNodePtr(n_cur, 0);
18337         elem = gen_xmlNodePtr_in(n_elem, 1);
18338
18339         ret_val = xmlAddSibling(cur, elem);
18340         if (ret_val == NULL) { xmlFreeNode(elem) ; elem = NULL ; }
18341         desret_xmlNodePtr(ret_val);
18342         call_tests++;
18343         des_xmlNodePtr(n_cur, cur, 0);
18344         des_xmlNodePtr_in(n_elem, elem, 1);
18345         xmlResetLastError();
18346         if (mem_base != xmlMemBlocks()) {
18347             printf("Leak of %d blocks found in xmlAddSibling",
18348                    xmlMemBlocks() - mem_base);
18349             test_ret++;
18350             printf(" %d", n_cur);
18351             printf(" %d", n_elem);
18352             printf("\n");
18353         }
18354     }
18355     }
18356     function_tests++;
18357
18358     return(test_ret);
18359 }
18360
18361
18362 static int
18363 test_xmlAttrSerializeTxtContent(void) {
18364     int test_ret = 0;
18365
18366 #if defined(LIBXML_OUTPUT_ENABLED)
18367 #ifdef LIBXML_OUTPUT_ENABLED
18368     int mem_base;
18369     xmlBufferPtr buf; /* the XML buffer output */
18370     int n_buf;
18371     xmlDocPtr doc; /* the document */
18372     int n_doc;
18373     xmlAttrPtr attr; /* the attribute node */
18374     int n_attr;
18375     xmlChar * string; /* the text content */
18376     int n_string;
18377
18378     for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18379     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
18380     for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
18381     for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) {
18382         mem_base = xmlMemBlocks();
18383         buf = gen_xmlBufferPtr(n_buf, 0);
18384         doc = gen_xmlDocPtr(n_doc, 1);
18385         attr = gen_xmlAttrPtr(n_attr, 2);
18386         string = gen_const_xmlChar_ptr(n_string, 3);
18387
18388         xmlAttrSerializeTxtContent(buf, doc, attr, (const xmlChar *)string);
18389         call_tests++;
18390         des_xmlBufferPtr(n_buf, buf, 0);
18391         des_xmlDocPtr(n_doc, doc, 1);
18392         des_xmlAttrPtr(n_attr, attr, 2);
18393         des_const_xmlChar_ptr(n_string, (const xmlChar *)string, 3);
18394         xmlResetLastError();
18395         if (mem_base != xmlMemBlocks()) {
18396             printf("Leak of %d blocks found in xmlAttrSerializeTxtContent",
18397                    xmlMemBlocks() - mem_base);
18398             test_ret++;
18399             printf(" %d", n_buf);
18400             printf(" %d", n_doc);
18401             printf(" %d", n_attr);
18402             printf(" %d", n_string);
18403             printf("\n");
18404         }
18405     }
18406     }
18407     }
18408     }
18409     function_tests++;
18410 #endif
18411 #endif
18412
18413     return(test_ret);
18414 }
18415
18416
18417 static int
18418 test_xmlBufferAdd(void) {
18419     int test_ret = 0;
18420
18421     int mem_base;
18422     int ret_val;
18423     xmlBufferPtr buf; /* the buffer to dump */
18424     int n_buf;
18425     xmlChar * str; /* the #xmlChar string */
18426     int n_str;
18427     int len; /* the number of #xmlChar to add */
18428     int n_len;
18429
18430     for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18431     for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
18432     for (n_len = 0;n_len < gen_nb_int;n_len++) {
18433         mem_base = xmlMemBlocks();
18434         buf = gen_xmlBufferPtr(n_buf, 0);
18435         str = gen_const_xmlChar_ptr(n_str, 1);
18436         len = gen_int(n_len, 2);
18437
18438         ret_val = xmlBufferAdd(buf, (const xmlChar *)str, len);
18439         desret_int(ret_val);
18440         call_tests++;
18441         des_xmlBufferPtr(n_buf, buf, 0);
18442         des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
18443         des_int(n_len, len, 2);
18444         xmlResetLastError();
18445         if (mem_base != xmlMemBlocks()) {
18446             printf("Leak of %d blocks found in xmlBufferAdd",
18447                    xmlMemBlocks() - mem_base);
18448             test_ret++;
18449             printf(" %d", n_buf);
18450             printf(" %d", n_str);
18451             printf(" %d", n_len);
18452             printf("\n");
18453         }
18454     }
18455     }
18456     }
18457     function_tests++;
18458
18459     return(test_ret);
18460 }
18461
18462
18463 static int
18464 test_xmlBufferAddHead(void) {
18465     int test_ret = 0;
18466
18467     int mem_base;
18468     int ret_val;
18469     xmlBufferPtr buf; /* the buffer */
18470     int n_buf;
18471     xmlChar * str; /* the #xmlChar string */
18472     int n_str;
18473     int len; /* the number of #xmlChar to add */
18474     int n_len;
18475
18476     for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18477     for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
18478     for (n_len = 0;n_len < gen_nb_int;n_len++) {
18479         mem_base = xmlMemBlocks();
18480         buf = gen_xmlBufferPtr(n_buf, 0);
18481         str = gen_const_xmlChar_ptr(n_str, 1);
18482         len = gen_int(n_len, 2);
18483
18484         ret_val = xmlBufferAddHead(buf, (const xmlChar *)str, len);
18485         desret_int(ret_val);
18486         call_tests++;
18487         des_xmlBufferPtr(n_buf, buf, 0);
18488         des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
18489         des_int(n_len, len, 2);
18490         xmlResetLastError();
18491         if (mem_base != xmlMemBlocks()) {
18492             printf("Leak of %d blocks found in xmlBufferAddHead",
18493                    xmlMemBlocks() - mem_base);
18494             test_ret++;
18495             printf(" %d", n_buf);
18496             printf(" %d", n_str);
18497             printf(" %d", n_len);
18498             printf("\n");
18499         }
18500     }
18501     }
18502     }
18503     function_tests++;
18504
18505     return(test_ret);
18506 }
18507
18508
18509 static int
18510 test_xmlBufferCCat(void) {
18511     int test_ret = 0;
18512
18513     int mem_base;
18514     int ret_val;
18515     xmlBufferPtr buf; /* the buffer to dump */
18516     int n_buf;
18517     char * str; /* the C char string */
18518     int n_str;
18519
18520     for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18521     for (n_str = 0;n_str < gen_nb_const_char_ptr;n_str++) {
18522         mem_base = xmlMemBlocks();
18523         buf = gen_xmlBufferPtr(n_buf, 0);
18524         str = gen_const_char_ptr(n_str, 1);
18525
18526         ret_val = xmlBufferCCat(buf, (const char *)str);
18527         desret_int(ret_val);
18528         call_tests++;
18529         des_xmlBufferPtr(n_buf, buf, 0);
18530         des_const_char_ptr(n_str, (const char *)str, 1);
18531         xmlResetLastError();
18532         if (mem_base != xmlMemBlocks()) {
18533             printf("Leak of %d blocks found in xmlBufferCCat",
18534                    xmlMemBlocks() - mem_base);
18535             test_ret++;
18536             printf(" %d", n_buf);
18537             printf(" %d", n_str);
18538             printf("\n");
18539         }
18540     }
18541     }
18542     function_tests++;
18543
18544     return(test_ret);
18545 }
18546
18547
18548 static int
18549 test_xmlBufferCat(void) {
18550     int test_ret = 0;
18551
18552     int mem_base;
18553     int ret_val;
18554     xmlBufferPtr buf; /* the buffer to add to */
18555     int n_buf;
18556     xmlChar * str; /* the #xmlChar string */
18557     int n_str;
18558
18559     for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18560     for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
18561         mem_base = xmlMemBlocks();
18562         buf = gen_xmlBufferPtr(n_buf, 0);
18563         str = gen_const_xmlChar_ptr(n_str, 1);
18564
18565         ret_val = xmlBufferCat(buf, (const xmlChar *)str);
18566         desret_int(ret_val);
18567         call_tests++;
18568         des_xmlBufferPtr(n_buf, buf, 0);
18569         des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
18570         xmlResetLastError();
18571         if (mem_base != xmlMemBlocks()) {
18572             printf("Leak of %d blocks found in xmlBufferCat",
18573                    xmlMemBlocks() - mem_base);
18574             test_ret++;
18575             printf(" %d", n_buf);
18576             printf(" %d", n_str);
18577             printf("\n");
18578         }
18579     }
18580     }
18581     function_tests++;
18582
18583     return(test_ret);
18584 }
18585
18586
18587 #define gen_nb_const_xmlBufferPtr 1
18588 static xmlBufferPtr gen_const_xmlBufferPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
18589     return(NULL);
18590 }
18591 static void des_const_xmlBufferPtr(int no ATTRIBUTE_UNUSED, const xmlBufferPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
18592 }
18593
18594 static int
18595 test_xmlBufferContent(void) {
18596     int test_ret = 0;
18597
18598     int mem_base;
18599     const xmlChar * ret_val;
18600     xmlBufferPtr buf; /* the buffer */
18601     int n_buf;
18602
18603     for (n_buf = 0;n_buf < gen_nb_const_xmlBufferPtr;n_buf++) {
18604         mem_base = xmlMemBlocks();
18605         buf = gen_const_xmlBufferPtr(n_buf, 0);
18606
18607         ret_val = xmlBufferContent((const xmlBufferPtr)buf);
18608         desret_const_xmlChar_ptr(ret_val);
18609         call_tests++;
18610         des_const_xmlBufferPtr(n_buf, (const xmlBufferPtr)buf, 0);
18611         xmlResetLastError();
18612         if (mem_base != xmlMemBlocks()) {
18613             printf("Leak of %d blocks found in xmlBufferContent",
18614                    xmlMemBlocks() - mem_base);
18615             test_ret++;
18616             printf(" %d", n_buf);
18617             printf("\n");
18618         }
18619     }
18620     function_tests++;
18621
18622     return(test_ret);
18623 }
18624
18625
18626 static int
18627 test_xmlBufferCreate(void) {
18628     int test_ret = 0;
18629
18630     int mem_base;
18631     xmlBufferPtr ret_val;
18632
18633         mem_base = xmlMemBlocks();
18634
18635         ret_val = xmlBufferCreate();
18636         desret_xmlBufferPtr(ret_val);
18637         call_tests++;
18638         xmlResetLastError();
18639         if (mem_base != xmlMemBlocks()) {
18640             printf("Leak of %d blocks found in xmlBufferCreate",
18641                    xmlMemBlocks() - mem_base);
18642             test_ret++;
18643             printf("\n");
18644         }
18645     function_tests++;
18646
18647     return(test_ret);
18648 }
18649
18650
18651 static int
18652 test_xmlBufferCreateSize(void) {
18653     int test_ret = 0;
18654
18655
18656     /* missing type support */
18657     return(test_ret);
18658 }
18659
18660
18661 static int
18662 test_xmlBufferCreateStatic(void) {
18663     int test_ret = 0;
18664
18665
18666     /* missing type support */
18667     return(test_ret);
18668 }
18669
18670
18671 static int
18672 test_xmlBufferEmpty(void) {
18673     int test_ret = 0;
18674
18675     int mem_base;
18676     xmlBufferPtr buf; /* the buffer */
18677     int n_buf;
18678
18679     for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18680         mem_base = xmlMemBlocks();
18681         buf = gen_xmlBufferPtr(n_buf, 0);
18682
18683         xmlBufferEmpty(buf);
18684         call_tests++;
18685         des_xmlBufferPtr(n_buf, buf, 0);
18686         xmlResetLastError();
18687         if (mem_base != xmlMemBlocks()) {
18688             printf("Leak of %d blocks found in xmlBufferEmpty",
18689                    xmlMemBlocks() - mem_base);
18690             test_ret++;
18691             printf(" %d", n_buf);
18692             printf("\n");
18693         }
18694     }
18695     function_tests++;
18696
18697     return(test_ret);
18698 }
18699
18700
18701 static int
18702 test_xmlBufferGrow(void) {
18703     int test_ret = 0;
18704
18705     int mem_base;
18706     int ret_val;
18707     xmlBufferPtr buf; /* the buffer */
18708     int n_buf;
18709     unsigned int len; /* the minimum free size to allocate */
18710     int n_len;
18711
18712     for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18713     for (n_len = 0;n_len < gen_nb_unsigned_int;n_len++) {
18714         mem_base = xmlMemBlocks();
18715         buf = gen_xmlBufferPtr(n_buf, 0);
18716         len = gen_unsigned_int(n_len, 1);
18717
18718         ret_val = xmlBufferGrow(buf, len);
18719         desret_int(ret_val);
18720         call_tests++;
18721         des_xmlBufferPtr(n_buf, buf, 0);
18722         des_unsigned_int(n_len, len, 1);
18723         xmlResetLastError();
18724         if (mem_base != xmlMemBlocks()) {
18725             printf("Leak of %d blocks found in xmlBufferGrow",
18726                    xmlMemBlocks() - mem_base);
18727             test_ret++;
18728             printf(" %d", n_buf);
18729             printf(" %d", n_len);
18730             printf("\n");
18731         }
18732     }
18733     }
18734     function_tests++;
18735
18736     return(test_ret);
18737 }
18738
18739
18740 static int
18741 test_xmlBufferLength(void) {
18742     int test_ret = 0;
18743
18744     int mem_base;
18745     int ret_val;
18746     xmlBufferPtr buf; /* the buffer */
18747     int n_buf;
18748
18749     for (n_buf = 0;n_buf < gen_nb_const_xmlBufferPtr;n_buf++) {
18750         mem_base = xmlMemBlocks();
18751         buf = gen_const_xmlBufferPtr(n_buf, 0);
18752
18753         ret_val = xmlBufferLength((const xmlBufferPtr)buf);
18754         desret_int(ret_val);
18755         call_tests++;
18756         des_const_xmlBufferPtr(n_buf, (const xmlBufferPtr)buf, 0);
18757         xmlResetLastError();
18758         if (mem_base != xmlMemBlocks()) {
18759             printf("Leak of %d blocks found in xmlBufferLength",
18760                    xmlMemBlocks() - mem_base);
18761             test_ret++;
18762             printf(" %d", n_buf);
18763             printf("\n");
18764         }
18765     }
18766     function_tests++;
18767
18768     return(test_ret);
18769 }
18770
18771
18772 static int
18773 test_xmlBufferResize(void) {
18774     int test_ret = 0;
18775
18776     int mem_base;
18777     int ret_val;
18778     xmlBufferPtr buf; /* the buffer to resize */
18779     int n_buf;
18780     unsigned int size; /* the desired size */
18781     int n_size;
18782
18783     for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18784     for (n_size = 0;n_size < gen_nb_unsigned_int;n_size++) {
18785         mem_base = xmlMemBlocks();
18786         buf = gen_xmlBufferPtr(n_buf, 0);
18787         size = gen_unsigned_int(n_size, 1);
18788
18789         ret_val = xmlBufferResize(buf, size);
18790         desret_int(ret_val);
18791         call_tests++;
18792         des_xmlBufferPtr(n_buf, buf, 0);
18793         des_unsigned_int(n_size, size, 1);
18794         xmlResetLastError();
18795         if (mem_base != xmlMemBlocks()) {
18796             printf("Leak of %d blocks found in xmlBufferResize",
18797                    xmlMemBlocks() - mem_base);
18798             test_ret++;
18799             printf(" %d", n_buf);
18800             printf(" %d", n_size);
18801             printf("\n");
18802         }
18803     }
18804     }
18805     function_tests++;
18806
18807     return(test_ret);
18808 }
18809
18810
18811 static int
18812 test_xmlBufferSetAllocationScheme(void) {
18813     int test_ret = 0;
18814
18815     int mem_base;
18816     xmlBufferPtr buf; /* the buffer to tune */
18817     int n_buf;
18818     xmlBufferAllocationScheme scheme; /* allocation scheme to use */
18819     int n_scheme;
18820
18821     for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18822     for (n_scheme = 0;n_scheme < gen_nb_xmlBufferAllocationScheme;n_scheme++) {
18823         mem_base = xmlMemBlocks();
18824         buf = gen_xmlBufferPtr(n_buf, 0);
18825         scheme = gen_xmlBufferAllocationScheme(n_scheme, 1);
18826
18827         xmlBufferSetAllocationScheme(buf, scheme);
18828         if ((buf != NULL) && (scheme == XML_BUFFER_ALLOC_IMMUTABLE) && (buf->content != NULL) && (buf->content != static_buf_content)) { xmlFree(buf->content); buf->content = NULL;}
18829         call_tests++;
18830         des_xmlBufferPtr(n_buf, buf, 0);
18831         des_xmlBufferAllocationScheme(n_scheme, scheme, 1);
18832         xmlResetLastError();
18833         if (mem_base != xmlMemBlocks()) {
18834             printf("Leak of %d blocks found in xmlBufferSetAllocationScheme",
18835                    xmlMemBlocks() - mem_base);
18836             test_ret++;
18837             printf(" %d", n_buf);
18838             printf(" %d", n_scheme);
18839             printf("\n");
18840         }
18841     }
18842     }
18843     function_tests++;
18844
18845     return(test_ret);
18846 }
18847
18848
18849 static int
18850 test_xmlBufferShrink(void) {
18851     int test_ret = 0;
18852
18853     int mem_base;
18854     int ret_val;
18855     xmlBufferPtr buf; /* the buffer to dump */
18856     int n_buf;
18857     unsigned int len; /* the number of xmlChar to remove */
18858     int n_len;
18859
18860     for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18861     for (n_len = 0;n_len < gen_nb_unsigned_int;n_len++) {
18862         mem_base = xmlMemBlocks();
18863         buf = gen_xmlBufferPtr(n_buf, 0);
18864         len = gen_unsigned_int(n_len, 1);
18865
18866         ret_val = xmlBufferShrink(buf, len);
18867         desret_int(ret_val);
18868         call_tests++;
18869         des_xmlBufferPtr(n_buf, buf, 0);
18870         des_unsigned_int(n_len, len, 1);
18871         xmlResetLastError();
18872         if (mem_base != xmlMemBlocks()) {
18873             printf("Leak of %d blocks found in xmlBufferShrink",
18874                    xmlMemBlocks() - mem_base);
18875             test_ret++;
18876             printf(" %d", n_buf);
18877             printf(" %d", n_len);
18878             printf("\n");
18879         }
18880     }
18881     }
18882     function_tests++;
18883
18884     return(test_ret);
18885 }
18886
18887
18888 static int
18889 test_xmlBufferWriteCHAR(void) {
18890     int test_ret = 0;
18891
18892     int mem_base;
18893     xmlBufferPtr buf; /* the XML buffer */
18894     int n_buf;
18895     xmlChar * string; /* the string to add */
18896     int n_string;
18897
18898     for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18899     for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) {
18900         mem_base = xmlMemBlocks();
18901         buf = gen_xmlBufferPtr(n_buf, 0);
18902         string = gen_const_xmlChar_ptr(n_string, 1);
18903
18904         xmlBufferWriteCHAR(buf, (const xmlChar *)string);
18905         call_tests++;
18906         des_xmlBufferPtr(n_buf, buf, 0);
18907         des_const_xmlChar_ptr(n_string, (const xmlChar *)string, 1);
18908         xmlResetLastError();
18909         if (mem_base != xmlMemBlocks()) {
18910             printf("Leak of %d blocks found in xmlBufferWriteCHAR",
18911                    xmlMemBlocks() - mem_base);
18912             test_ret++;
18913             printf(" %d", n_buf);
18914             printf(" %d", n_string);
18915             printf("\n");
18916         }
18917     }
18918     }
18919     function_tests++;
18920
18921     return(test_ret);
18922 }
18923
18924
18925 static int
18926 test_xmlBufferWriteChar(void) {
18927     int test_ret = 0;
18928
18929     int mem_base;
18930     xmlBufferPtr buf; /* the XML buffer output */
18931     int n_buf;
18932     char * string; /* the string to add */
18933     int n_string;
18934
18935     for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18936     for (n_string = 0;n_string < gen_nb_const_char_ptr;n_string++) {
18937         mem_base = xmlMemBlocks();
18938         buf = gen_xmlBufferPtr(n_buf, 0);
18939         string = gen_const_char_ptr(n_string, 1);
18940
18941         xmlBufferWriteChar(buf, (const char *)string);
18942         call_tests++;
18943         des_xmlBufferPtr(n_buf, buf, 0);
18944         des_const_char_ptr(n_string, (const char *)string, 1);
18945         xmlResetLastError();
18946         if (mem_base != xmlMemBlocks()) {
18947             printf("Leak of %d blocks found in xmlBufferWriteChar",
18948                    xmlMemBlocks() - mem_base);
18949             test_ret++;
18950             printf(" %d", n_buf);
18951             printf(" %d", n_string);
18952             printf("\n");
18953         }
18954     }
18955     }
18956     function_tests++;
18957
18958     return(test_ret);
18959 }
18960
18961
18962 static int
18963 test_xmlBufferWriteQuotedString(void) {
18964     int test_ret = 0;
18965
18966     int mem_base;
18967     xmlBufferPtr buf; /* the XML buffer output */
18968     int n_buf;
18969     xmlChar * string; /* the string to add */
18970     int n_string;
18971
18972     for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
18973     for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr;n_string++) {
18974         mem_base = xmlMemBlocks();
18975         buf = gen_xmlBufferPtr(n_buf, 0);
18976         string = gen_const_xmlChar_ptr(n_string, 1);
18977
18978         xmlBufferWriteQuotedString(buf, (const xmlChar *)string);
18979         call_tests++;
18980         des_xmlBufferPtr(n_buf, buf, 0);
18981         des_const_xmlChar_ptr(n_string, (const xmlChar *)string, 1);
18982         xmlResetLastError();
18983         if (mem_base != xmlMemBlocks()) {
18984             printf("Leak of %d blocks found in xmlBufferWriteQuotedString",
18985                    xmlMemBlocks() - mem_base);
18986             test_ret++;
18987             printf(" %d", n_buf);
18988             printf(" %d", n_string);
18989             printf("\n");
18990         }
18991     }
18992     }
18993     function_tests++;
18994
18995     return(test_ret);
18996 }
18997
18998
18999 static int
19000 test_xmlBuildQName(void) {
19001     int test_ret = 0;
19002
19003     int mem_base;
19004     xmlChar * ret_val;
19005     xmlChar * ncname; /* the Name */
19006     int n_ncname;
19007     xmlChar * prefix; /* the prefix */
19008     int n_prefix;
19009     xmlChar * memory; /* preallocated memory */
19010     int n_memory;
19011     int len; /* preallocated memory length */
19012     int n_len;
19013
19014     for (n_ncname = 0;n_ncname < gen_nb_const_xmlChar_ptr;n_ncname++) {
19015     for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
19016     for (n_memory = 0;n_memory < gen_nb_xmlChar_ptr;n_memory++) {
19017     for (n_len = 0;n_len < gen_nb_int;n_len++) {
19018         mem_base = xmlMemBlocks();
19019         ncname = gen_const_xmlChar_ptr(n_ncname, 0);
19020         prefix = gen_const_xmlChar_ptr(n_prefix, 1);
19021         memory = gen_xmlChar_ptr(n_memory, 2);
19022         len = gen_int(n_len, 3);
19023
19024         ret_val = xmlBuildQName((const xmlChar *)ncname, (const xmlChar *)prefix, memory, len);
19025         if ((ret_val != NULL) && (ret_val != ncname) &&
19026               (ret_val != prefix) && (ret_val != memory))
19027               xmlFree(ret_val);
19028           ret_val = NULL;
19029         desret_xmlChar_ptr(ret_val);
19030         call_tests++;
19031         des_const_xmlChar_ptr(n_ncname, (const xmlChar *)ncname, 0);
19032         des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
19033         des_xmlChar_ptr(n_memory, memory, 2);
19034         des_int(n_len, len, 3);
19035         xmlResetLastError();
19036         if (mem_base != xmlMemBlocks()) {
19037             printf("Leak of %d blocks found in xmlBuildQName",
19038                    xmlMemBlocks() - mem_base);
19039             test_ret++;
19040             printf(" %d", n_ncname);
19041             printf(" %d", n_prefix);
19042             printf(" %d", n_memory);
19043             printf(" %d", n_len);
19044             printf("\n");
19045         }
19046     }
19047     }
19048     }
19049     }
19050     function_tests++;
19051
19052     return(test_ret);
19053 }
19054
19055
19056 static int
19057 test_xmlChildElementCount(void) {
19058     int test_ret = 0;
19059
19060 #if defined(LIBXML_TREE_ENABLED)
19061     int mem_base;
19062     unsigned long ret_val;
19063     xmlNodePtr parent; /* the parent node */
19064     int n_parent;
19065
19066     for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
19067         mem_base = xmlMemBlocks();
19068         parent = gen_xmlNodePtr(n_parent, 0);
19069
19070         ret_val = xmlChildElementCount(parent);
19071         desret_unsigned_long(ret_val);
19072         call_tests++;
19073         des_xmlNodePtr(n_parent, parent, 0);
19074         xmlResetLastError();
19075         if (mem_base != xmlMemBlocks()) {
19076             printf("Leak of %d blocks found in xmlChildElementCount",
19077                    xmlMemBlocks() - mem_base);
19078             test_ret++;
19079             printf(" %d", n_parent);
19080             printf("\n");
19081         }
19082     }
19083     function_tests++;
19084 #endif
19085
19086     return(test_ret);
19087 }
19088
19089
19090 static int
19091 test_xmlCopyDoc(void) {
19092     int test_ret = 0;
19093
19094 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
19095     int mem_base;
19096     xmlDocPtr ret_val;
19097     xmlDocPtr doc; /* the document */
19098     int n_doc;
19099     int recursive; /* if not zero do a recursive copy. */
19100     int n_recursive;
19101
19102     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
19103     for (n_recursive = 0;n_recursive < gen_nb_int;n_recursive++) {
19104         mem_base = xmlMemBlocks();
19105         doc = gen_xmlDocPtr(n_doc, 0);
19106         recursive = gen_int(n_recursive, 1);
19107
19108         ret_val = xmlCopyDoc(doc, recursive);
19109         desret_xmlDocPtr(ret_val);
19110         call_tests++;
19111         des_xmlDocPtr(n_doc, doc, 0);
19112         des_int(n_recursive, recursive, 1);
19113         xmlResetLastError();
19114         if (mem_base != xmlMemBlocks()) {
19115             printf("Leak of %d blocks found in xmlCopyDoc",
19116                    xmlMemBlocks() - mem_base);
19117             test_ret++;
19118             printf(" %d", n_doc);
19119             printf(" %d", n_recursive);
19120             printf("\n");
19121         }
19122     }
19123     }
19124     function_tests++;
19125 #endif
19126
19127     return(test_ret);
19128 }
19129
19130
19131 static int
19132 test_xmlCopyDtd(void) {
19133     int test_ret = 0;
19134
19135 #if defined(LIBXML_TREE_ENABLED)
19136     int mem_base;
19137     xmlDtdPtr ret_val;
19138     xmlDtdPtr dtd; /* the dtd */
19139     int n_dtd;
19140
19141     for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
19142         mem_base = xmlMemBlocks();
19143         dtd = gen_xmlDtdPtr(n_dtd, 0);
19144
19145         ret_val = xmlCopyDtd(dtd);
19146         desret_xmlDtdPtr(ret_val);
19147         call_tests++;
19148         des_xmlDtdPtr(n_dtd, dtd, 0);
19149         xmlResetLastError();
19150         if (mem_base != xmlMemBlocks()) {
19151             printf("Leak of %d blocks found in xmlCopyDtd",
19152                    xmlMemBlocks() - mem_base);
19153             test_ret++;
19154             printf(" %d", n_dtd);
19155             printf("\n");
19156         }
19157     }
19158     function_tests++;
19159 #endif
19160
19161     return(test_ret);
19162 }
19163
19164
19165 static int
19166 test_xmlCopyNamespace(void) {
19167     int test_ret = 0;
19168
19169     int mem_base;
19170     xmlNsPtr ret_val;
19171     xmlNsPtr cur; /* the namespace */
19172     int n_cur;
19173
19174     for (n_cur = 0;n_cur < gen_nb_xmlNsPtr;n_cur++) {
19175         mem_base = xmlMemBlocks();
19176         cur = gen_xmlNsPtr(n_cur, 0);
19177
19178         ret_val = xmlCopyNamespace(cur);
19179         if (ret_val != NULL) xmlFreeNs(ret_val);
19180         desret_xmlNsPtr(ret_val);
19181         call_tests++;
19182         des_xmlNsPtr(n_cur, cur, 0);
19183         xmlResetLastError();
19184         if (mem_base != xmlMemBlocks()) {
19185             printf("Leak of %d blocks found in xmlCopyNamespace",
19186                    xmlMemBlocks() - mem_base);
19187             test_ret++;
19188             printf(" %d", n_cur);
19189             printf("\n");
19190         }
19191     }
19192     function_tests++;
19193
19194     return(test_ret);
19195 }
19196
19197
19198 static int
19199 test_xmlCopyNamespaceList(void) {
19200     int test_ret = 0;
19201
19202     int mem_base;
19203     xmlNsPtr ret_val;
19204     xmlNsPtr cur; /* the first namespace */
19205     int n_cur;
19206
19207     for (n_cur = 0;n_cur < gen_nb_xmlNsPtr;n_cur++) {
19208         mem_base = xmlMemBlocks();
19209         cur = gen_xmlNsPtr(n_cur, 0);
19210
19211         ret_val = xmlCopyNamespaceList(cur);
19212         if (ret_val != NULL) xmlFreeNsList(ret_val);
19213         desret_xmlNsPtr(ret_val);
19214         call_tests++;
19215         des_xmlNsPtr(n_cur, cur, 0);
19216         xmlResetLastError();
19217         if (mem_base != xmlMemBlocks()) {
19218             printf("Leak of %d blocks found in xmlCopyNamespaceList",
19219                    xmlMemBlocks() - mem_base);
19220             test_ret++;
19221             printf(" %d", n_cur);
19222             printf("\n");
19223         }
19224     }
19225     function_tests++;
19226
19227     return(test_ret);
19228 }
19229
19230
19231 static int
19232 test_xmlCopyNode(void) {
19233     int test_ret = 0;
19234
19235     int mem_base;
19236     xmlNodePtr ret_val;
19237     xmlNodePtr node; /* the node */
19238     int n_node;
19239     int extended; /* if 1 do a recursive copy (properties, namespaces and children when applicable) if 2 copy properties and namespaces (when applicable) */
19240     int n_extended;
19241
19242     for (n_node = 0;n_node < gen_nb_const_xmlNodePtr;n_node++) {
19243     for (n_extended = 0;n_extended < gen_nb_int;n_extended++) {
19244         mem_base = xmlMemBlocks();
19245         node = gen_const_xmlNodePtr(n_node, 0);
19246         extended = gen_int(n_extended, 1);
19247
19248         ret_val = xmlCopyNode((const xmlNodePtr)node, extended);
19249         desret_xmlNodePtr(ret_val);
19250         call_tests++;
19251         des_const_xmlNodePtr(n_node, (const xmlNodePtr)node, 0);
19252         des_int(n_extended, extended, 1);
19253         xmlResetLastError();
19254         if (mem_base != xmlMemBlocks()) {
19255             printf("Leak of %d blocks found in xmlCopyNode",
19256                    xmlMemBlocks() - mem_base);
19257             test_ret++;
19258             printf(" %d", n_node);
19259             printf(" %d", n_extended);
19260             printf("\n");
19261         }
19262     }
19263     }
19264     function_tests++;
19265
19266     return(test_ret);
19267 }
19268
19269
19270 static int
19271 test_xmlCopyNodeList(void) {
19272     int test_ret = 0;
19273
19274     int mem_base;
19275     xmlNodePtr ret_val;
19276     xmlNodePtr node; /* the first node in the list. */
19277     int n_node;
19278
19279     for (n_node = 0;n_node < gen_nb_const_xmlNodePtr;n_node++) {
19280         mem_base = xmlMemBlocks();
19281         node = gen_const_xmlNodePtr(n_node, 0);
19282
19283         ret_val = xmlCopyNodeList((const xmlNodePtr)node);
19284         desret_xmlNodePtr(ret_val);
19285         call_tests++;
19286         des_const_xmlNodePtr(n_node, (const xmlNodePtr)node, 0);
19287         xmlResetLastError();
19288         if (mem_base != xmlMemBlocks()) {
19289             printf("Leak of %d blocks found in xmlCopyNodeList",
19290                    xmlMemBlocks() - mem_base);
19291             test_ret++;
19292             printf(" %d", n_node);
19293             printf("\n");
19294         }
19295     }
19296     function_tests++;
19297
19298     return(test_ret);
19299 }
19300
19301
19302 static int
19303 test_xmlCopyProp(void) {
19304     int test_ret = 0;
19305
19306     int mem_base;
19307     xmlAttrPtr ret_val;
19308     xmlNodePtr target; /* the element where the attribute will be grafted */
19309     int n_target;
19310     xmlAttrPtr cur; /* the attribute */
19311     int n_cur;
19312
19313     for (n_target = 0;n_target < gen_nb_xmlNodePtr;n_target++) {
19314     for (n_cur = 0;n_cur < gen_nb_xmlAttrPtr;n_cur++) {
19315         mem_base = xmlMemBlocks();
19316         target = gen_xmlNodePtr(n_target, 0);
19317         cur = gen_xmlAttrPtr(n_cur, 1);
19318
19319         ret_val = xmlCopyProp(target, cur);
19320         desret_xmlAttrPtr(ret_val);
19321         call_tests++;
19322         des_xmlNodePtr(n_target, target, 0);
19323         des_xmlAttrPtr(n_cur, cur, 1);
19324         xmlResetLastError();
19325         if (mem_base != xmlMemBlocks()) {
19326             printf("Leak of %d blocks found in xmlCopyProp",
19327                    xmlMemBlocks() - mem_base);
19328             test_ret++;
19329             printf(" %d", n_target);
19330             printf(" %d", n_cur);
19331             printf("\n");
19332         }
19333     }
19334     }
19335     function_tests++;
19336
19337     return(test_ret);
19338 }
19339
19340
19341 static int
19342 test_xmlCopyPropList(void) {
19343     int test_ret = 0;
19344
19345     int mem_base;
19346     xmlAttrPtr ret_val;
19347     xmlNodePtr target; /* the element where the attributes will be grafted */
19348     int n_target;
19349     xmlAttrPtr cur; /* the first attribute */
19350     int n_cur;
19351
19352     for (n_target = 0;n_target < gen_nb_xmlNodePtr;n_target++) {
19353     for (n_cur = 0;n_cur < gen_nb_xmlAttrPtr;n_cur++) {
19354         mem_base = xmlMemBlocks();
19355         target = gen_xmlNodePtr(n_target, 0);
19356         cur = gen_xmlAttrPtr(n_cur, 1);
19357
19358         ret_val = xmlCopyPropList(target, cur);
19359         desret_xmlAttrPtr(ret_val);
19360         call_tests++;
19361         des_xmlNodePtr(n_target, target, 0);
19362         des_xmlAttrPtr(n_cur, cur, 1);
19363         xmlResetLastError();
19364         if (mem_base != xmlMemBlocks()) {
19365             printf("Leak of %d blocks found in xmlCopyPropList",
19366                    xmlMemBlocks() - mem_base);
19367             test_ret++;
19368             printf(" %d", n_target);
19369             printf(" %d", n_cur);
19370             printf("\n");
19371         }
19372     }
19373     }
19374     function_tests++;
19375
19376     return(test_ret);
19377 }
19378
19379
19380 static int
19381 test_xmlCreateIntSubset(void) {
19382     int test_ret = 0;
19383
19384     int mem_base;
19385     xmlDtdPtr ret_val;
19386     xmlDocPtr doc; /* the document pointer */
19387     int n_doc;
19388     xmlChar * name; /* the DTD name */
19389     int n_name;
19390     xmlChar * ExternalID; /* the external (PUBLIC) ID */
19391     int n_ExternalID;
19392     xmlChar * SystemID; /* the system ID */
19393     int n_SystemID;
19394
19395     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
19396     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
19397     for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
19398     for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
19399         mem_base = xmlMemBlocks();
19400         doc = gen_xmlDocPtr(n_doc, 0);
19401         name = gen_const_xmlChar_ptr(n_name, 1);
19402         ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 2);
19403         SystemID = gen_const_xmlChar_ptr(n_SystemID, 3);
19404
19405         ret_val = xmlCreateIntSubset(doc, (const xmlChar *)name, (const xmlChar *)ExternalID, (const xmlChar *)SystemID);
19406         desret_xmlDtdPtr(ret_val);
19407         call_tests++;
19408         des_xmlDocPtr(n_doc, doc, 0);
19409         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
19410         des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 2);
19411         des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 3);
19412         xmlResetLastError();
19413         if (mem_base != xmlMemBlocks()) {
19414             printf("Leak of %d blocks found in xmlCreateIntSubset",
19415                    xmlMemBlocks() - mem_base);
19416             test_ret++;
19417             printf(" %d", n_doc);
19418             printf(" %d", n_name);
19419             printf(" %d", n_ExternalID);
19420             printf(" %d", n_SystemID);
19421             printf("\n");
19422         }
19423     }
19424     }
19425     }
19426     }
19427     function_tests++;
19428
19429     return(test_ret);
19430 }
19431
19432
19433 #define gen_nb_xmlDOMWrapCtxtPtr 1
19434 static xmlDOMWrapCtxtPtr gen_xmlDOMWrapCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
19435     return(NULL);
19436 }
19437 static void des_xmlDOMWrapCtxtPtr(int no ATTRIBUTE_UNUSED, xmlDOMWrapCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
19438 }
19439
19440 static int
19441 test_xmlDOMWrapAdoptNode(void) {
19442     int test_ret = 0;
19443
19444     int mem_base;
19445     int ret_val;
19446     xmlDOMWrapCtxtPtr ctxt; /* the optional context for custom processing */
19447     int n_ctxt;
19448     xmlDocPtr sourceDoc; /* the optional sourceDoc */
19449     int n_sourceDoc;
19450     xmlNodePtr node; /* the node to start with */
19451     int n_node;
19452     xmlDocPtr destDoc; /* the destination doc */
19453     int n_destDoc;
19454     xmlNodePtr destParent; /* the optional new parent of @node in @destDoc */
19455     int n_destParent;
19456     int options; /* option flags */
19457     int n_options;
19458
19459     for (n_ctxt = 0;n_ctxt < gen_nb_xmlDOMWrapCtxtPtr;n_ctxt++) {
19460     for (n_sourceDoc = 0;n_sourceDoc < gen_nb_xmlDocPtr;n_sourceDoc++) {
19461     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
19462     for (n_destDoc = 0;n_destDoc < gen_nb_xmlDocPtr;n_destDoc++) {
19463     for (n_destParent = 0;n_destParent < gen_nb_xmlNodePtr;n_destParent++) {
19464     for (n_options = 0;n_options < gen_nb_int;n_options++) {
19465         mem_base = xmlMemBlocks();
19466         ctxt = gen_xmlDOMWrapCtxtPtr(n_ctxt, 0);
19467         sourceDoc = gen_xmlDocPtr(n_sourceDoc, 1);
19468         node = gen_xmlNodePtr(n_node, 2);
19469         destDoc = gen_xmlDocPtr(n_destDoc, 3);
19470         destParent = gen_xmlNodePtr(n_destParent, 4);
19471         options = gen_int(n_options, 5);
19472
19473         ret_val = xmlDOMWrapAdoptNode(ctxt, sourceDoc, node, destDoc, destParent, options);
19474         if ((node != NULL) && (node->parent == NULL)) {xmlUnlinkNode(node);xmlFreeNode(node);node = NULL;}
19475         desret_int(ret_val);
19476         call_tests++;
19477         des_xmlDOMWrapCtxtPtr(n_ctxt, ctxt, 0);
19478         des_xmlDocPtr(n_sourceDoc, sourceDoc, 1);
19479         des_xmlNodePtr(n_node, node, 2);
19480         des_xmlDocPtr(n_destDoc, destDoc, 3);
19481         des_xmlNodePtr(n_destParent, destParent, 4);
19482         des_int(n_options, options, 5);
19483         xmlResetLastError();
19484         if (mem_base != xmlMemBlocks()) {
19485             printf("Leak of %d blocks found in xmlDOMWrapAdoptNode",
19486                    xmlMemBlocks() - mem_base);
19487             test_ret++;
19488             printf(" %d", n_ctxt);
19489             printf(" %d", n_sourceDoc);
19490             printf(" %d", n_node);
19491             printf(" %d", n_destDoc);
19492             printf(" %d", n_destParent);
19493             printf(" %d", n_options);
19494             printf("\n");
19495         }
19496     }
19497     }
19498     }
19499     }
19500     }
19501     }
19502     function_tests++;
19503
19504     return(test_ret);
19505 }
19506
19507
19508 static int
19509 test_xmlDOMWrapCloneNode(void) {
19510     int test_ret = 0;
19511
19512     int mem_base;
19513     int ret_val;
19514     xmlDOMWrapCtxtPtr ctxt; /* the optional context for custom processing */
19515     int n_ctxt;
19516     xmlDocPtr sourceDoc; /* the optional sourceDoc */
19517     int n_sourceDoc;
19518     xmlNodePtr node; /* the node to start with */
19519     int n_node;
19520     xmlNodePtr * resNode; /* the clone of the given @node */
19521     int n_resNode;
19522     xmlDocPtr destDoc; /* the destination doc */
19523     int n_destDoc;
19524     xmlNodePtr destParent; /* the optional new parent of @node in @destDoc */
19525     int n_destParent;
19526     int deep; /* descend into child if set */
19527     int n_deep;
19528     int options; /* option flags */
19529     int n_options;
19530
19531     for (n_ctxt = 0;n_ctxt < gen_nb_xmlDOMWrapCtxtPtr;n_ctxt++) {
19532     for (n_sourceDoc = 0;n_sourceDoc < gen_nb_xmlDocPtr;n_sourceDoc++) {
19533     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
19534     for (n_resNode = 0;n_resNode < gen_nb_xmlNodePtr_ptr;n_resNode++) {
19535     for (n_destDoc = 0;n_destDoc < gen_nb_xmlDocPtr;n_destDoc++) {
19536     for (n_destParent = 0;n_destParent < gen_nb_xmlNodePtr;n_destParent++) {
19537     for (n_deep = 0;n_deep < gen_nb_int;n_deep++) {
19538     for (n_options = 0;n_options < gen_nb_int;n_options++) {
19539         mem_base = xmlMemBlocks();
19540         ctxt = gen_xmlDOMWrapCtxtPtr(n_ctxt, 0);
19541         sourceDoc = gen_xmlDocPtr(n_sourceDoc, 1);
19542         node = gen_xmlNodePtr(n_node, 2);
19543         resNode = gen_xmlNodePtr_ptr(n_resNode, 3);
19544         destDoc = gen_xmlDocPtr(n_destDoc, 4);
19545         destParent = gen_xmlNodePtr(n_destParent, 5);
19546         deep = gen_int(n_deep, 6);
19547         options = gen_int(n_options, 7);
19548
19549         ret_val = xmlDOMWrapCloneNode(ctxt, sourceDoc, node, resNode, destDoc, destParent, deep, options);
19550         desret_int(ret_val);
19551         call_tests++;
19552         des_xmlDOMWrapCtxtPtr(n_ctxt, ctxt, 0);
19553         des_xmlDocPtr(n_sourceDoc, sourceDoc, 1);
19554         des_xmlNodePtr(n_node, node, 2);
19555         des_xmlNodePtr_ptr(n_resNode, resNode, 3);
19556         des_xmlDocPtr(n_destDoc, destDoc, 4);
19557         des_xmlNodePtr(n_destParent, destParent, 5);
19558         des_int(n_deep, deep, 6);
19559         des_int(n_options, options, 7);
19560         xmlResetLastError();
19561         if (mem_base != xmlMemBlocks()) {
19562             printf("Leak of %d blocks found in xmlDOMWrapCloneNode",
19563                    xmlMemBlocks() - mem_base);
19564             test_ret++;
19565             printf(" %d", n_ctxt);
19566             printf(" %d", n_sourceDoc);
19567             printf(" %d", n_node);
19568             printf(" %d", n_resNode);
19569             printf(" %d", n_destDoc);
19570             printf(" %d", n_destParent);
19571             printf(" %d", n_deep);
19572             printf(" %d", n_options);
19573             printf("\n");
19574         }
19575     }
19576     }
19577     }
19578     }
19579     }
19580     }
19581     }
19582     }
19583     function_tests++;
19584
19585     return(test_ret);
19586 }
19587
19588
19589 static int
19590 test_xmlDOMWrapNewCtxt(void) {
19591     int test_ret = 0;
19592
19593
19594     /* missing type support */
19595     return(test_ret);
19596 }
19597
19598
19599 static int
19600 test_xmlDOMWrapReconcileNamespaces(void) {
19601     int test_ret = 0;
19602
19603     int mem_base;
19604     int ret_val;
19605     xmlDOMWrapCtxtPtr ctxt; /* DOM wrapper context, unused at the moment */
19606     int n_ctxt;
19607     xmlNodePtr elem; /* the element-node */
19608     int n_elem;
19609     int options; /* option flags */
19610     int n_options;
19611
19612     for (n_ctxt = 0;n_ctxt < gen_nb_xmlDOMWrapCtxtPtr;n_ctxt++) {
19613     for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
19614     for (n_options = 0;n_options < gen_nb_int;n_options++) {
19615         mem_base = xmlMemBlocks();
19616         ctxt = gen_xmlDOMWrapCtxtPtr(n_ctxt, 0);
19617         elem = gen_xmlNodePtr(n_elem, 1);
19618         options = gen_int(n_options, 2);
19619
19620         ret_val = xmlDOMWrapReconcileNamespaces(ctxt, elem, options);
19621         desret_int(ret_val);
19622         call_tests++;
19623         des_xmlDOMWrapCtxtPtr(n_ctxt, ctxt, 0);
19624         des_xmlNodePtr(n_elem, elem, 1);
19625         des_int(n_options, options, 2);
19626         xmlResetLastError();
19627         if (mem_base != xmlMemBlocks()) {
19628             printf("Leak of %d blocks found in xmlDOMWrapReconcileNamespaces",
19629                    xmlMemBlocks() - mem_base);
19630             test_ret++;
19631             printf(" %d", n_ctxt);
19632             printf(" %d", n_elem);
19633             printf(" %d", n_options);
19634             printf("\n");
19635         }
19636     }
19637     }
19638     }
19639     function_tests++;
19640
19641     return(test_ret);
19642 }
19643
19644
19645 static int
19646 test_xmlDOMWrapRemoveNode(void) {
19647     int test_ret = 0;
19648
19649     int mem_base;
19650     int ret_val;
19651     xmlDOMWrapCtxtPtr ctxt; /* a DOM wrapper context */
19652     int n_ctxt;
19653     xmlDocPtr doc; /* the doc */
19654     int n_doc;
19655     xmlNodePtr node; /* the node to be removed. */
19656     int n_node;
19657     int options; /* set of options, unused at the moment */
19658     int n_options;
19659
19660     for (n_ctxt = 0;n_ctxt < gen_nb_xmlDOMWrapCtxtPtr;n_ctxt++) {
19661     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
19662     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
19663     for (n_options = 0;n_options < gen_nb_int;n_options++) {
19664         mem_base = xmlMemBlocks();
19665         ctxt = gen_xmlDOMWrapCtxtPtr(n_ctxt, 0);
19666         doc = gen_xmlDocPtr(n_doc, 1);
19667         node = gen_xmlNodePtr(n_node, 2);
19668         options = gen_int(n_options, 3);
19669
19670         ret_val = xmlDOMWrapRemoveNode(ctxt, doc, node, options);
19671         desret_int(ret_val);
19672         call_tests++;
19673         des_xmlDOMWrapCtxtPtr(n_ctxt, ctxt, 0);
19674         des_xmlDocPtr(n_doc, doc, 1);
19675         des_xmlNodePtr(n_node, node, 2);
19676         des_int(n_options, options, 3);
19677         xmlResetLastError();
19678         if (mem_base != xmlMemBlocks()) {
19679             printf("Leak of %d blocks found in xmlDOMWrapRemoveNode",
19680                    xmlMemBlocks() - mem_base);
19681             test_ret++;
19682             printf(" %d", n_ctxt);
19683             printf(" %d", n_doc);
19684             printf(" %d", n_node);
19685             printf(" %d", n_options);
19686             printf("\n");
19687         }
19688     }
19689     }
19690     }
19691     }
19692     function_tests++;
19693
19694     return(test_ret);
19695 }
19696
19697
19698 static int
19699 test_xmlDocCopyNode(void) {
19700     int test_ret = 0;
19701
19702     int mem_base;
19703     xmlNodePtr ret_val;
19704     xmlNodePtr node; /* the node */
19705     int n_node;
19706     xmlDocPtr doc; /* the document */
19707     int n_doc;
19708     int extended; /* if 1 do a recursive copy (properties, namespaces and children when applicable) if 2 copy properties and namespaces (when applicable) */
19709     int n_extended;
19710
19711     for (n_node = 0;n_node < gen_nb_const_xmlNodePtr;n_node++) {
19712     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
19713     for (n_extended = 0;n_extended < gen_nb_int;n_extended++) {
19714         mem_base = xmlMemBlocks();
19715         node = gen_const_xmlNodePtr(n_node, 0);
19716         doc = gen_xmlDocPtr(n_doc, 1);
19717         extended = gen_int(n_extended, 2);
19718
19719         ret_val = xmlDocCopyNode((const xmlNodePtr)node, doc, extended);
19720         desret_xmlNodePtr(ret_val);
19721         call_tests++;
19722         des_const_xmlNodePtr(n_node, (const xmlNodePtr)node, 0);
19723         des_xmlDocPtr(n_doc, doc, 1);
19724         des_int(n_extended, extended, 2);
19725         xmlResetLastError();
19726         if (mem_base != xmlMemBlocks()) {
19727             printf("Leak of %d blocks found in xmlDocCopyNode",
19728                    xmlMemBlocks() - mem_base);
19729             test_ret++;
19730             printf(" %d", n_node);
19731             printf(" %d", n_doc);
19732             printf(" %d", n_extended);
19733             printf("\n");
19734         }
19735     }
19736     }
19737     }
19738     function_tests++;
19739
19740     return(test_ret);
19741 }
19742
19743
19744 static int
19745 test_xmlDocCopyNodeList(void) {
19746     int test_ret = 0;
19747
19748     int mem_base;
19749     xmlNodePtr ret_val;
19750     xmlDocPtr doc; /* the target document */
19751     int n_doc;
19752     xmlNodePtr node; /* the first node in the list. */
19753     int n_node;
19754
19755     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
19756     for (n_node = 0;n_node < gen_nb_const_xmlNodePtr;n_node++) {
19757         mem_base = xmlMemBlocks();
19758         doc = gen_xmlDocPtr(n_doc, 0);
19759         node = gen_const_xmlNodePtr(n_node, 1);
19760
19761         ret_val = xmlDocCopyNodeList(doc, (const xmlNodePtr)node);
19762         desret_xmlNodePtr(ret_val);
19763         call_tests++;
19764         des_xmlDocPtr(n_doc, doc, 0);
19765         des_const_xmlNodePtr(n_node, (const xmlNodePtr)node, 1);
19766         xmlResetLastError();
19767         if (mem_base != xmlMemBlocks()) {
19768             printf("Leak of %d blocks found in xmlDocCopyNodeList",
19769                    xmlMemBlocks() - mem_base);
19770             test_ret++;
19771             printf(" %d", n_doc);
19772             printf(" %d", n_node);
19773             printf("\n");
19774         }
19775     }
19776     }
19777     function_tests++;
19778
19779     return(test_ret);
19780 }
19781
19782
19783 static int
19784 test_xmlDocDump(void) {
19785     int test_ret = 0;
19786
19787 #if defined(LIBXML_OUTPUT_ENABLED)
19788     int mem_base;
19789     int ret_val;
19790     FILE * f; /* the FILE* */
19791     int n_f;
19792     xmlDocPtr cur; /* the document */
19793     int n_cur;
19794
19795     for (n_f = 0;n_f < gen_nb_FILE_ptr;n_f++) {
19796     for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
19797         mem_base = xmlMemBlocks();
19798         f = gen_FILE_ptr(n_f, 0);
19799         cur = gen_xmlDocPtr(n_cur, 1);
19800
19801         ret_val = xmlDocDump(f, cur);
19802         desret_int(ret_val);
19803         call_tests++;
19804         des_FILE_ptr(n_f, f, 0);
19805         des_xmlDocPtr(n_cur, cur, 1);
19806         xmlResetLastError();
19807         if (mem_base != xmlMemBlocks()) {
19808             printf("Leak of %d blocks found in xmlDocDump",
19809                    xmlMemBlocks() - mem_base);
19810             test_ret++;
19811             printf(" %d", n_f);
19812             printf(" %d", n_cur);
19813             printf("\n");
19814         }
19815     }
19816     }
19817     function_tests++;
19818 #endif
19819
19820     return(test_ret);
19821 }
19822
19823
19824 static int
19825 test_xmlDocDumpFormatMemory(void) {
19826     int test_ret = 0;
19827
19828 #if defined(LIBXML_OUTPUT_ENABLED)
19829     int mem_base;
19830     xmlDocPtr cur; /* the document */
19831     int n_cur;
19832     xmlChar ** mem; /* OUT: the memory pointer */
19833     int n_mem;
19834     int * size; /* OUT: the memory length */
19835     int n_size;
19836     int format; /* should formatting spaces been added */
19837     int n_format;
19838
19839     for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
19840     for (n_mem = 0;n_mem < gen_nb_xmlChar_ptr_ptr;n_mem++) {
19841     for (n_size = 0;n_size < gen_nb_int_ptr;n_size++) {
19842     for (n_format = 0;n_format < gen_nb_int;n_format++) {
19843         mem_base = xmlMemBlocks();
19844         cur = gen_xmlDocPtr(n_cur, 0);
19845         mem = gen_xmlChar_ptr_ptr(n_mem, 1);
19846         size = gen_int_ptr(n_size, 2);
19847         format = gen_int(n_format, 3);
19848
19849         xmlDocDumpFormatMemory(cur, mem, size, format);
19850         call_tests++;
19851         des_xmlDocPtr(n_cur, cur, 0);
19852         des_xmlChar_ptr_ptr(n_mem, mem, 1);
19853         des_int_ptr(n_size, size, 2);
19854         des_int(n_format, format, 3);
19855         xmlResetLastError();
19856         if (mem_base != xmlMemBlocks()) {
19857             printf("Leak of %d blocks found in xmlDocDumpFormatMemory",
19858                    xmlMemBlocks() - mem_base);
19859             test_ret++;
19860             printf(" %d", n_cur);
19861             printf(" %d", n_mem);
19862             printf(" %d", n_size);
19863             printf(" %d", n_format);
19864             printf("\n");
19865         }
19866     }
19867     }
19868     }
19869     }
19870     function_tests++;
19871 #endif
19872
19873     return(test_ret);
19874 }
19875
19876
19877 static int
19878 test_xmlDocDumpFormatMemoryEnc(void) {
19879     int test_ret = 0;
19880
19881 #if defined(LIBXML_OUTPUT_ENABLED)
19882     int mem_base;
19883     xmlDocPtr out_doc; /* Document to generate XML text from */
19884     int n_out_doc;
19885     xmlChar ** doc_txt_ptr; /* Memory pointer for allocated XML text */
19886     int n_doc_txt_ptr;
19887     int * doc_txt_len; /* Length of the generated XML text */
19888     int n_doc_txt_len;
19889     char * txt_encoding; /* Character encoding to use when generating XML text */
19890     int n_txt_encoding;
19891     int format; /* should formatting spaces been added */
19892     int n_format;
19893
19894     for (n_out_doc = 0;n_out_doc < gen_nb_xmlDocPtr;n_out_doc++) {
19895     for (n_doc_txt_ptr = 0;n_doc_txt_ptr < gen_nb_xmlChar_ptr_ptr;n_doc_txt_ptr++) {
19896     for (n_doc_txt_len = 0;n_doc_txt_len < gen_nb_int_ptr;n_doc_txt_len++) {
19897     for (n_txt_encoding = 0;n_txt_encoding < gen_nb_const_char_ptr;n_txt_encoding++) {
19898     for (n_format = 0;n_format < gen_nb_int;n_format++) {
19899         mem_base = xmlMemBlocks();
19900         out_doc = gen_xmlDocPtr(n_out_doc, 0);
19901         doc_txt_ptr = gen_xmlChar_ptr_ptr(n_doc_txt_ptr, 1);
19902         doc_txt_len = gen_int_ptr(n_doc_txt_len, 2);
19903         txt_encoding = gen_const_char_ptr(n_txt_encoding, 3);
19904         format = gen_int(n_format, 4);
19905
19906         xmlDocDumpFormatMemoryEnc(out_doc, doc_txt_ptr, doc_txt_len, (const char *)txt_encoding, format);
19907         call_tests++;
19908         des_xmlDocPtr(n_out_doc, out_doc, 0);
19909         des_xmlChar_ptr_ptr(n_doc_txt_ptr, doc_txt_ptr, 1);
19910         des_int_ptr(n_doc_txt_len, doc_txt_len, 2);
19911         des_const_char_ptr(n_txt_encoding, (const char *)txt_encoding, 3);
19912         des_int(n_format, format, 4);
19913         xmlResetLastError();
19914         if (mem_base != xmlMemBlocks()) {
19915             printf("Leak of %d blocks found in xmlDocDumpFormatMemoryEnc",
19916                    xmlMemBlocks() - mem_base);
19917             test_ret++;
19918             printf(" %d", n_out_doc);
19919             printf(" %d", n_doc_txt_ptr);
19920             printf(" %d", n_doc_txt_len);
19921             printf(" %d", n_txt_encoding);
19922             printf(" %d", n_format);
19923             printf("\n");
19924         }
19925     }
19926     }
19927     }
19928     }
19929     }
19930     function_tests++;
19931 #endif
19932
19933     return(test_ret);
19934 }
19935
19936
19937 static int
19938 test_xmlDocDumpMemory(void) {
19939     int test_ret = 0;
19940
19941 #if defined(LIBXML_OUTPUT_ENABLED)
19942     int mem_base;
19943     xmlDocPtr cur; /* the document */
19944     int n_cur;
19945     xmlChar ** mem; /* OUT: the memory pointer */
19946     int n_mem;
19947     int * size; /* OUT: the memory length */
19948     int n_size;
19949
19950     for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
19951     for (n_mem = 0;n_mem < gen_nb_xmlChar_ptr_ptr;n_mem++) {
19952     for (n_size = 0;n_size < gen_nb_int_ptr;n_size++) {
19953         mem_base = xmlMemBlocks();
19954         cur = gen_xmlDocPtr(n_cur, 0);
19955         mem = gen_xmlChar_ptr_ptr(n_mem, 1);
19956         size = gen_int_ptr(n_size, 2);
19957
19958         xmlDocDumpMemory(cur, mem, size);
19959         call_tests++;
19960         des_xmlDocPtr(n_cur, cur, 0);
19961         des_xmlChar_ptr_ptr(n_mem, mem, 1);
19962         des_int_ptr(n_size, size, 2);
19963         xmlResetLastError();
19964         if (mem_base != xmlMemBlocks()) {
19965             printf("Leak of %d blocks found in xmlDocDumpMemory",
19966                    xmlMemBlocks() - mem_base);
19967             test_ret++;
19968             printf(" %d", n_cur);
19969             printf(" %d", n_mem);
19970             printf(" %d", n_size);
19971             printf("\n");
19972         }
19973     }
19974     }
19975     }
19976     function_tests++;
19977 #endif
19978
19979     return(test_ret);
19980 }
19981
19982
19983 static int
19984 test_xmlDocDumpMemoryEnc(void) {
19985     int test_ret = 0;
19986
19987 #if defined(LIBXML_OUTPUT_ENABLED)
19988     int mem_base;
19989     xmlDocPtr out_doc; /* Document to generate XML text from */
19990     int n_out_doc;
19991     xmlChar ** doc_txt_ptr; /* Memory pointer for allocated XML text */
19992     int n_doc_txt_ptr;
19993     int * doc_txt_len; /* Length of the generated XML text */
19994     int n_doc_txt_len;
19995     char * txt_encoding; /* Character encoding to use when generating XML text */
19996     int n_txt_encoding;
19997
19998     for (n_out_doc = 0;n_out_doc < gen_nb_xmlDocPtr;n_out_doc++) {
19999     for (n_doc_txt_ptr = 0;n_doc_txt_ptr < gen_nb_xmlChar_ptr_ptr;n_doc_txt_ptr++) {
20000     for (n_doc_txt_len = 0;n_doc_txt_len < gen_nb_int_ptr;n_doc_txt_len++) {
20001     for (n_txt_encoding = 0;n_txt_encoding < gen_nb_const_char_ptr;n_txt_encoding++) {
20002         mem_base = xmlMemBlocks();
20003         out_doc = gen_xmlDocPtr(n_out_doc, 0);
20004         doc_txt_ptr = gen_xmlChar_ptr_ptr(n_doc_txt_ptr, 1);
20005         doc_txt_len = gen_int_ptr(n_doc_txt_len, 2);
20006         txt_encoding = gen_const_char_ptr(n_txt_encoding, 3);
20007
20008         xmlDocDumpMemoryEnc(out_doc, doc_txt_ptr, doc_txt_len, (const char *)txt_encoding);
20009         call_tests++;
20010         des_xmlDocPtr(n_out_doc, out_doc, 0);
20011         des_xmlChar_ptr_ptr(n_doc_txt_ptr, doc_txt_ptr, 1);
20012         des_int_ptr(n_doc_txt_len, doc_txt_len, 2);
20013         des_const_char_ptr(n_txt_encoding, (const char *)txt_encoding, 3);
20014         xmlResetLastError();
20015         if (mem_base != xmlMemBlocks()) {
20016             printf("Leak of %d blocks found in xmlDocDumpMemoryEnc",
20017                    xmlMemBlocks() - mem_base);
20018             test_ret++;
20019             printf(" %d", n_out_doc);
20020             printf(" %d", n_doc_txt_ptr);
20021             printf(" %d", n_doc_txt_len);
20022             printf(" %d", n_txt_encoding);
20023             printf("\n");
20024         }
20025     }
20026     }
20027     }
20028     }
20029     function_tests++;
20030 #endif
20031
20032     return(test_ret);
20033 }
20034
20035
20036 static int
20037 test_xmlDocFormatDump(void) {
20038     int test_ret = 0;
20039
20040 #if defined(LIBXML_OUTPUT_ENABLED)
20041     int mem_base;
20042     int ret_val;
20043     FILE * f; /* the FILE* */
20044     int n_f;
20045     xmlDocPtr cur; /* the document */
20046     int n_cur;
20047     int format; /* should formatting spaces been added */
20048     int n_format;
20049
20050     for (n_f = 0;n_f < gen_nb_FILE_ptr;n_f++) {
20051     for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
20052     for (n_format = 0;n_format < gen_nb_int;n_format++) {
20053         mem_base = xmlMemBlocks();
20054         f = gen_FILE_ptr(n_f, 0);
20055         cur = gen_xmlDocPtr(n_cur, 1);
20056         format = gen_int(n_format, 2);
20057
20058         ret_val = xmlDocFormatDump(f, cur, format);
20059         desret_int(ret_val);
20060         call_tests++;
20061         des_FILE_ptr(n_f, f, 0);
20062         des_xmlDocPtr(n_cur, cur, 1);
20063         des_int(n_format, format, 2);
20064         xmlResetLastError();
20065         if (mem_base != xmlMemBlocks()) {
20066             printf("Leak of %d blocks found in xmlDocFormatDump",
20067                    xmlMemBlocks() - mem_base);
20068             test_ret++;
20069             printf(" %d", n_f);
20070             printf(" %d", n_cur);
20071             printf(" %d", n_format);
20072             printf("\n");
20073         }
20074     }
20075     }
20076     }
20077     function_tests++;
20078 #endif
20079
20080     return(test_ret);
20081 }
20082
20083
20084 static int
20085 test_xmlDocGetRootElement(void) {
20086     int test_ret = 0;
20087
20088     int mem_base;
20089     xmlNodePtr ret_val;
20090     xmlDocPtr doc; /* the document */
20091     int n_doc;
20092
20093     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
20094         mem_base = xmlMemBlocks();
20095         doc = gen_xmlDocPtr(n_doc, 0);
20096
20097         ret_val = xmlDocGetRootElement(doc);
20098         desret_xmlNodePtr(ret_val);
20099         call_tests++;
20100         des_xmlDocPtr(n_doc, doc, 0);
20101         xmlResetLastError();
20102         if (mem_base != xmlMemBlocks()) {
20103             printf("Leak of %d blocks found in xmlDocGetRootElement",
20104                    xmlMemBlocks() - mem_base);
20105             test_ret++;
20106             printf(" %d", n_doc);
20107             printf("\n");
20108         }
20109     }
20110     function_tests++;
20111
20112     return(test_ret);
20113 }
20114
20115
20116 static int
20117 test_xmlDocSetRootElement(void) {
20118     int test_ret = 0;
20119
20120 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
20121     int mem_base;
20122     xmlNodePtr ret_val;
20123     xmlDocPtr doc; /* the document */
20124     int n_doc;
20125     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. */
20126     int n_root;
20127
20128     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
20129     for (n_root = 0;n_root < gen_nb_xmlNodePtr_in;n_root++) {
20130         mem_base = xmlMemBlocks();
20131         doc = gen_xmlDocPtr(n_doc, 0);
20132         root = gen_xmlNodePtr_in(n_root, 1);
20133
20134         ret_val = xmlDocSetRootElement(doc, root);
20135         if (doc == NULL) { xmlFreeNode(root) ; root = NULL ; }
20136         desret_xmlNodePtr(ret_val);
20137         call_tests++;
20138         des_xmlDocPtr(n_doc, doc, 0);
20139         des_xmlNodePtr_in(n_root, root, 1);
20140         xmlResetLastError();
20141         if (mem_base != xmlMemBlocks()) {
20142             printf("Leak of %d blocks found in xmlDocSetRootElement",
20143                    xmlMemBlocks() - mem_base);
20144             test_ret++;
20145             printf(" %d", n_doc);
20146             printf(" %d", n_root);
20147             printf("\n");
20148         }
20149     }
20150     }
20151     function_tests++;
20152 #endif
20153
20154     return(test_ret);
20155 }
20156
20157
20158 static int
20159 test_xmlElemDump(void) {
20160     int test_ret = 0;
20161
20162 #if defined(LIBXML_OUTPUT_ENABLED)
20163     int mem_base;
20164     FILE * f; /* the FILE * for the output */
20165     int n_f;
20166     xmlDocPtr doc; /* the document */
20167     int n_doc;
20168     xmlNodePtr cur; /* the current node */
20169     int n_cur;
20170
20171     for (n_f = 0;n_f < gen_nb_FILE_ptr;n_f++) {
20172     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
20173     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
20174         mem_base = xmlMemBlocks();
20175         f = gen_FILE_ptr(n_f, 0);
20176         doc = gen_xmlDocPtr(n_doc, 1);
20177         cur = gen_xmlNodePtr(n_cur, 2);
20178
20179         xmlElemDump(f, doc, cur);
20180         call_tests++;
20181         des_FILE_ptr(n_f, f, 0);
20182         des_xmlDocPtr(n_doc, doc, 1);
20183         des_xmlNodePtr(n_cur, cur, 2);
20184         xmlResetLastError();
20185         if (mem_base != xmlMemBlocks()) {
20186             printf("Leak of %d blocks found in xmlElemDump",
20187                    xmlMemBlocks() - mem_base);
20188             test_ret++;
20189             printf(" %d", n_f);
20190             printf(" %d", n_doc);
20191             printf(" %d", n_cur);
20192             printf("\n");
20193         }
20194     }
20195     }
20196     }
20197     function_tests++;
20198 #endif
20199
20200     return(test_ret);
20201 }
20202
20203
20204 static int
20205 test_xmlFirstElementChild(void) {
20206     int test_ret = 0;
20207
20208 #if defined(LIBXML_TREE_ENABLED)
20209     int mem_base;
20210     xmlNodePtr ret_val;
20211     xmlNodePtr parent; /* the parent node */
20212     int n_parent;
20213
20214     for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
20215         mem_base = xmlMemBlocks();
20216         parent = gen_xmlNodePtr(n_parent, 0);
20217
20218         ret_val = xmlFirstElementChild(parent);
20219         desret_xmlNodePtr(ret_val);
20220         call_tests++;
20221         des_xmlNodePtr(n_parent, parent, 0);
20222         xmlResetLastError();
20223         if (mem_base != xmlMemBlocks()) {
20224             printf("Leak of %d blocks found in xmlFirstElementChild",
20225                    xmlMemBlocks() - mem_base);
20226             test_ret++;
20227             printf(" %d", n_parent);
20228             printf("\n");
20229         }
20230     }
20231     function_tests++;
20232 #endif
20233
20234     return(test_ret);
20235 }
20236
20237
20238 static int
20239 test_xmlGetBufferAllocationScheme(void) {
20240     int test_ret = 0;
20241
20242     int mem_base;
20243     xmlBufferAllocationScheme ret_val;
20244
20245         mem_base = xmlMemBlocks();
20246
20247         ret_val = xmlGetBufferAllocationScheme();
20248         desret_xmlBufferAllocationScheme(ret_val);
20249         call_tests++;
20250         xmlResetLastError();
20251         if (mem_base != xmlMemBlocks()) {
20252             printf("Leak of %d blocks found in xmlGetBufferAllocationScheme",
20253                    xmlMemBlocks() - mem_base);
20254             test_ret++;
20255             printf("\n");
20256         }
20257     function_tests++;
20258
20259     return(test_ret);
20260 }
20261
20262
20263 static int
20264 test_xmlGetCompressMode(void) {
20265     int test_ret = 0;
20266
20267     int mem_base;
20268     int ret_val;
20269
20270         mem_base = xmlMemBlocks();
20271
20272         ret_val = xmlGetCompressMode();
20273         desret_int(ret_val);
20274         call_tests++;
20275         xmlResetLastError();
20276         if (mem_base != xmlMemBlocks()) {
20277             printf("Leak of %d blocks found in xmlGetCompressMode",
20278                    xmlMemBlocks() - mem_base);
20279             test_ret++;
20280             printf("\n");
20281         }
20282     function_tests++;
20283
20284     return(test_ret);
20285 }
20286
20287
20288 static int
20289 test_xmlGetDocCompressMode(void) {
20290     int test_ret = 0;
20291
20292     int mem_base;
20293     int ret_val;
20294     xmlDocPtr doc; /* the document */
20295     int n_doc;
20296
20297     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
20298         mem_base = xmlMemBlocks();
20299         doc = gen_xmlDocPtr(n_doc, 0);
20300
20301         ret_val = xmlGetDocCompressMode(doc);
20302         desret_int(ret_val);
20303         call_tests++;
20304         des_xmlDocPtr(n_doc, doc, 0);
20305         xmlResetLastError();
20306         if (mem_base != xmlMemBlocks()) {
20307             printf("Leak of %d blocks found in xmlGetDocCompressMode",
20308                    xmlMemBlocks() - mem_base);
20309             test_ret++;
20310             printf(" %d", n_doc);
20311             printf("\n");
20312         }
20313     }
20314     function_tests++;
20315
20316     return(test_ret);
20317 }
20318
20319
20320 static int
20321 test_xmlGetIntSubset(void) {
20322     int test_ret = 0;
20323
20324     int mem_base;
20325     xmlDtdPtr ret_val;
20326     xmlDocPtr doc; /* the document pointer */
20327     int n_doc;
20328
20329     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
20330         mem_base = xmlMemBlocks();
20331         doc = gen_xmlDocPtr(n_doc, 0);
20332
20333         ret_val = xmlGetIntSubset(doc);
20334         desret_xmlDtdPtr(ret_val);
20335         call_tests++;
20336         des_xmlDocPtr(n_doc, doc, 0);
20337         xmlResetLastError();
20338         if (mem_base != xmlMemBlocks()) {
20339             printf("Leak of %d blocks found in xmlGetIntSubset",
20340                    xmlMemBlocks() - mem_base);
20341             test_ret++;
20342             printf(" %d", n_doc);
20343             printf("\n");
20344         }
20345     }
20346     function_tests++;
20347
20348     return(test_ret);
20349 }
20350
20351
20352 static int
20353 test_xmlGetLastChild(void) {
20354     int test_ret = 0;
20355
20356     int mem_base;
20357     xmlNodePtr ret_val;
20358     xmlNodePtr parent; /* the parent node */
20359     int n_parent;
20360
20361     for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
20362         mem_base = xmlMemBlocks();
20363         parent = gen_xmlNodePtr(n_parent, 0);
20364
20365         ret_val = xmlGetLastChild(parent);
20366         desret_xmlNodePtr(ret_val);
20367         call_tests++;
20368         des_xmlNodePtr(n_parent, parent, 0);
20369         xmlResetLastError();
20370         if (mem_base != xmlMemBlocks()) {
20371             printf("Leak of %d blocks found in xmlGetLastChild",
20372                    xmlMemBlocks() - mem_base);
20373             test_ret++;
20374             printf(" %d", n_parent);
20375             printf("\n");
20376         }
20377     }
20378     function_tests++;
20379
20380     return(test_ret);
20381 }
20382
20383
20384 static int
20385 test_xmlGetLineNo(void) {
20386     int test_ret = 0;
20387
20388     int mem_base;
20389     long ret_val;
20390     xmlNodePtr node; /* valid node */
20391     int n_node;
20392
20393     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
20394         mem_base = xmlMemBlocks();
20395         node = gen_xmlNodePtr(n_node, 0);
20396
20397         ret_val = xmlGetLineNo(node);
20398         desret_long(ret_val);
20399         call_tests++;
20400         des_xmlNodePtr(n_node, node, 0);
20401         xmlResetLastError();
20402         if (mem_base != xmlMemBlocks()) {
20403             printf("Leak of %d blocks found in xmlGetLineNo",
20404                    xmlMemBlocks() - mem_base);
20405             test_ret++;
20406             printf(" %d", n_node);
20407             printf("\n");
20408         }
20409     }
20410     function_tests++;
20411
20412     return(test_ret);
20413 }
20414
20415
20416 static int
20417 test_xmlGetNoNsProp(void) {
20418     int test_ret = 0;
20419
20420     int mem_base;
20421     xmlChar * ret_val;
20422     xmlNodePtr node; /* the node */
20423     int n_node;
20424     xmlChar * name; /* the attribute name */
20425     int n_name;
20426
20427     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
20428     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
20429         mem_base = xmlMemBlocks();
20430         node = gen_xmlNodePtr(n_node, 0);
20431         name = gen_const_xmlChar_ptr(n_name, 1);
20432
20433         ret_val = xmlGetNoNsProp(node, (const xmlChar *)name);
20434         desret_xmlChar_ptr(ret_val);
20435         call_tests++;
20436         des_xmlNodePtr(n_node, node, 0);
20437         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
20438         xmlResetLastError();
20439         if (mem_base != xmlMemBlocks()) {
20440             printf("Leak of %d blocks found in xmlGetNoNsProp",
20441                    xmlMemBlocks() - mem_base);
20442             test_ret++;
20443             printf(" %d", n_node);
20444             printf(" %d", n_name);
20445             printf("\n");
20446         }
20447     }
20448     }
20449     function_tests++;
20450
20451     return(test_ret);
20452 }
20453
20454
20455 static int
20456 test_xmlGetNodePath(void) {
20457     int test_ret = 0;
20458
20459 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED)
20460     int mem_base;
20461     xmlChar * ret_val;
20462     xmlNodePtr node; /* a node */
20463     int n_node;
20464
20465     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
20466         mem_base = xmlMemBlocks();
20467         node = gen_xmlNodePtr(n_node, 0);
20468
20469         ret_val = xmlGetNodePath(node);
20470         desret_xmlChar_ptr(ret_val);
20471         call_tests++;
20472         des_xmlNodePtr(n_node, node, 0);
20473         xmlResetLastError();
20474         if (mem_base != xmlMemBlocks()) {
20475             printf("Leak of %d blocks found in xmlGetNodePath",
20476                    xmlMemBlocks() - mem_base);
20477             test_ret++;
20478             printf(" %d", n_node);
20479             printf("\n");
20480         }
20481     }
20482     function_tests++;
20483 #endif
20484
20485     return(test_ret);
20486 }
20487
20488
20489 static int
20490 test_xmlGetNsList(void) {
20491     int test_ret = 0;
20492
20493
20494     /* missing type support */
20495     return(test_ret);
20496 }
20497
20498
20499 static int
20500 test_xmlGetNsProp(void) {
20501     int test_ret = 0;
20502
20503     int mem_base;
20504     xmlChar * ret_val;
20505     xmlNodePtr node; /* the node */
20506     int n_node;
20507     xmlChar * name; /* the attribute name */
20508     int n_name;
20509     xmlChar * nameSpace; /* the URI of the namespace */
20510     int n_nameSpace;
20511
20512     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
20513     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
20514     for (n_nameSpace = 0;n_nameSpace < gen_nb_const_xmlChar_ptr;n_nameSpace++) {
20515         mem_base = xmlMemBlocks();
20516         node = gen_xmlNodePtr(n_node, 0);
20517         name = gen_const_xmlChar_ptr(n_name, 1);
20518         nameSpace = gen_const_xmlChar_ptr(n_nameSpace, 2);
20519
20520         ret_val = xmlGetNsProp(node, (const xmlChar *)name, (const xmlChar *)nameSpace);
20521         desret_xmlChar_ptr(ret_val);
20522         call_tests++;
20523         des_xmlNodePtr(n_node, node, 0);
20524         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
20525         des_const_xmlChar_ptr(n_nameSpace, (const xmlChar *)nameSpace, 2);
20526         xmlResetLastError();
20527         if (mem_base != xmlMemBlocks()) {
20528             printf("Leak of %d blocks found in xmlGetNsProp",
20529                    xmlMemBlocks() - mem_base);
20530             test_ret++;
20531             printf(" %d", n_node);
20532             printf(" %d", n_name);
20533             printf(" %d", n_nameSpace);
20534             printf("\n");
20535         }
20536     }
20537     }
20538     }
20539     function_tests++;
20540
20541     return(test_ret);
20542 }
20543
20544
20545 static int
20546 test_xmlGetProp(void) {
20547     int test_ret = 0;
20548
20549     int mem_base;
20550     xmlChar * ret_val;
20551     xmlNodePtr node; /* the node */
20552     int n_node;
20553     xmlChar * name; /* the attribute name */
20554     int n_name;
20555
20556     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
20557     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
20558         mem_base = xmlMemBlocks();
20559         node = gen_xmlNodePtr(n_node, 0);
20560         name = gen_const_xmlChar_ptr(n_name, 1);
20561
20562         ret_val = xmlGetProp(node, (const xmlChar *)name);
20563         desret_xmlChar_ptr(ret_val);
20564         call_tests++;
20565         des_xmlNodePtr(n_node, node, 0);
20566         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
20567         xmlResetLastError();
20568         if (mem_base != xmlMemBlocks()) {
20569             printf("Leak of %d blocks found in xmlGetProp",
20570                    xmlMemBlocks() - mem_base);
20571             test_ret++;
20572             printf(" %d", n_node);
20573             printf(" %d", n_name);
20574             printf("\n");
20575         }
20576     }
20577     }
20578     function_tests++;
20579
20580     return(test_ret);
20581 }
20582
20583
20584 static int
20585 test_xmlHasNsProp(void) {
20586     int test_ret = 0;
20587
20588     int mem_base;
20589     xmlAttrPtr ret_val;
20590     xmlNodePtr node; /* the node */
20591     int n_node;
20592     xmlChar * name; /* the attribute name */
20593     int n_name;
20594     xmlChar * nameSpace; /* the URI of the namespace */
20595     int n_nameSpace;
20596
20597     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
20598     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
20599     for (n_nameSpace = 0;n_nameSpace < gen_nb_const_xmlChar_ptr;n_nameSpace++) {
20600         mem_base = xmlMemBlocks();
20601         node = gen_xmlNodePtr(n_node, 0);
20602         name = gen_const_xmlChar_ptr(n_name, 1);
20603         nameSpace = gen_const_xmlChar_ptr(n_nameSpace, 2);
20604
20605         ret_val = xmlHasNsProp(node, (const xmlChar *)name, (const xmlChar *)nameSpace);
20606         desret_xmlAttrPtr(ret_val);
20607         call_tests++;
20608         des_xmlNodePtr(n_node, node, 0);
20609         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
20610         des_const_xmlChar_ptr(n_nameSpace, (const xmlChar *)nameSpace, 2);
20611         xmlResetLastError();
20612         if (mem_base != xmlMemBlocks()) {
20613             printf("Leak of %d blocks found in xmlHasNsProp",
20614                    xmlMemBlocks() - mem_base);
20615             test_ret++;
20616             printf(" %d", n_node);
20617             printf(" %d", n_name);
20618             printf(" %d", n_nameSpace);
20619             printf("\n");
20620         }
20621     }
20622     }
20623     }
20624     function_tests++;
20625
20626     return(test_ret);
20627 }
20628
20629
20630 static int
20631 test_xmlHasProp(void) {
20632     int test_ret = 0;
20633
20634     int mem_base;
20635     xmlAttrPtr ret_val;
20636     xmlNodePtr node; /* the node */
20637     int n_node;
20638     xmlChar * name; /* the attribute name */
20639     int n_name;
20640
20641     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
20642     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
20643         mem_base = xmlMemBlocks();
20644         node = gen_xmlNodePtr(n_node, 0);
20645         name = gen_const_xmlChar_ptr(n_name, 1);
20646
20647         ret_val = xmlHasProp(node, (const xmlChar *)name);
20648         desret_xmlAttrPtr(ret_val);
20649         call_tests++;
20650         des_xmlNodePtr(n_node, node, 0);
20651         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
20652         xmlResetLastError();
20653         if (mem_base != xmlMemBlocks()) {
20654             printf("Leak of %d blocks found in xmlHasProp",
20655                    xmlMemBlocks() - mem_base);
20656             test_ret++;
20657             printf(" %d", n_node);
20658             printf(" %d", n_name);
20659             printf("\n");
20660         }
20661     }
20662     }
20663     function_tests++;
20664
20665     return(test_ret);
20666 }
20667
20668
20669 static int
20670 test_xmlIsBlankNode(void) {
20671     int test_ret = 0;
20672
20673     int mem_base;
20674     int ret_val;
20675     xmlNodePtr node; /* the node */
20676     int n_node;
20677
20678     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
20679         mem_base = xmlMemBlocks();
20680         node = gen_xmlNodePtr(n_node, 0);
20681
20682         ret_val = xmlIsBlankNode(node);
20683         desret_int(ret_val);
20684         call_tests++;
20685         des_xmlNodePtr(n_node, node, 0);
20686         xmlResetLastError();
20687         if (mem_base != xmlMemBlocks()) {
20688             printf("Leak of %d blocks found in xmlIsBlankNode",
20689                    xmlMemBlocks() - mem_base);
20690             test_ret++;
20691             printf(" %d", n_node);
20692             printf("\n");
20693         }
20694     }
20695     function_tests++;
20696
20697     return(test_ret);
20698 }
20699
20700
20701 static int
20702 test_xmlIsXHTML(void) {
20703     int test_ret = 0;
20704
20705     int mem_base;
20706     int ret_val;
20707     xmlChar * systemID; /* the system identifier */
20708     int n_systemID;
20709     xmlChar * publicID; /* the public identifier */
20710     int n_publicID;
20711
20712     for (n_systemID = 0;n_systemID < gen_nb_const_xmlChar_ptr;n_systemID++) {
20713     for (n_publicID = 0;n_publicID < gen_nb_const_xmlChar_ptr;n_publicID++) {
20714         mem_base = xmlMemBlocks();
20715         systemID = gen_const_xmlChar_ptr(n_systemID, 0);
20716         publicID = gen_const_xmlChar_ptr(n_publicID, 1);
20717
20718         ret_val = xmlIsXHTML((const xmlChar *)systemID, (const xmlChar *)publicID);
20719         desret_int(ret_val);
20720         call_tests++;
20721         des_const_xmlChar_ptr(n_systemID, (const xmlChar *)systemID, 0);
20722         des_const_xmlChar_ptr(n_publicID, (const xmlChar *)publicID, 1);
20723         xmlResetLastError();
20724         if (mem_base != xmlMemBlocks()) {
20725             printf("Leak of %d blocks found in xmlIsXHTML",
20726                    xmlMemBlocks() - mem_base);
20727             test_ret++;
20728             printf(" %d", n_systemID);
20729             printf(" %d", n_publicID);
20730             printf("\n");
20731         }
20732     }
20733     }
20734     function_tests++;
20735
20736     return(test_ret);
20737 }
20738
20739
20740 static int
20741 test_xmlLastElementChild(void) {
20742     int test_ret = 0;
20743
20744 #if defined(LIBXML_TREE_ENABLED)
20745     int mem_base;
20746     xmlNodePtr ret_val;
20747     xmlNodePtr parent; /* the parent node */
20748     int n_parent;
20749
20750     for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
20751         mem_base = xmlMemBlocks();
20752         parent = gen_xmlNodePtr(n_parent, 0);
20753
20754         ret_val = xmlLastElementChild(parent);
20755         desret_xmlNodePtr(ret_val);
20756         call_tests++;
20757         des_xmlNodePtr(n_parent, parent, 0);
20758         xmlResetLastError();
20759         if (mem_base != xmlMemBlocks()) {
20760             printf("Leak of %d blocks found in xmlLastElementChild",
20761                    xmlMemBlocks() - mem_base);
20762             test_ret++;
20763             printf(" %d", n_parent);
20764             printf("\n");
20765         }
20766     }
20767     function_tests++;
20768 #endif
20769
20770     return(test_ret);
20771 }
20772
20773
20774 static int
20775 test_xmlNewCDataBlock(void) {
20776     int test_ret = 0;
20777
20778     int mem_base;
20779     xmlNodePtr ret_val;
20780     xmlDocPtr doc; /* the document */
20781     int n_doc;
20782     xmlChar * content; /* the CDATA block content content */
20783     int n_content;
20784     int len; /* the length of the block */
20785     int n_len;
20786
20787     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
20788     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
20789     for (n_len = 0;n_len < gen_nb_int;n_len++) {
20790         mem_base = xmlMemBlocks();
20791         doc = gen_xmlDocPtr(n_doc, 0);
20792         content = gen_const_xmlChar_ptr(n_content, 1);
20793         len = gen_int(n_len, 2);
20794
20795         ret_val = xmlNewCDataBlock(doc, (const xmlChar *)content, len);
20796         desret_xmlNodePtr(ret_val);
20797         call_tests++;
20798         des_xmlDocPtr(n_doc, doc, 0);
20799         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
20800         des_int(n_len, len, 2);
20801         xmlResetLastError();
20802         if (mem_base != xmlMemBlocks()) {
20803             printf("Leak of %d blocks found in xmlNewCDataBlock",
20804                    xmlMemBlocks() - mem_base);
20805             test_ret++;
20806             printf(" %d", n_doc);
20807             printf(" %d", n_content);
20808             printf(" %d", n_len);
20809             printf("\n");
20810         }
20811     }
20812     }
20813     }
20814     function_tests++;
20815
20816     return(test_ret);
20817 }
20818
20819
20820 static int
20821 test_xmlNewCharRef(void) {
20822     int test_ret = 0;
20823
20824     int mem_base;
20825     xmlNodePtr ret_val;
20826     xmlDocPtr doc; /* the document */
20827     int n_doc;
20828     xmlChar * name; /* the char ref string, starting with # or "&# ... ;" */
20829     int n_name;
20830
20831     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
20832     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
20833         mem_base = xmlMemBlocks();
20834         doc = gen_xmlDocPtr(n_doc, 0);
20835         name = gen_const_xmlChar_ptr(n_name, 1);
20836
20837         ret_val = xmlNewCharRef(doc, (const xmlChar *)name);
20838         desret_xmlNodePtr(ret_val);
20839         call_tests++;
20840         des_xmlDocPtr(n_doc, doc, 0);
20841         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
20842         xmlResetLastError();
20843         if (mem_base != xmlMemBlocks()) {
20844             printf("Leak of %d blocks found in xmlNewCharRef",
20845                    xmlMemBlocks() - mem_base);
20846             test_ret++;
20847             printf(" %d", n_doc);
20848             printf(" %d", n_name);
20849             printf("\n");
20850         }
20851     }
20852     }
20853     function_tests++;
20854
20855     return(test_ret);
20856 }
20857
20858
20859 static int
20860 test_xmlNewChild(void) {
20861     int test_ret = 0;
20862
20863 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
20864 #ifdef LIBXML_TREE_ENABLED
20865     int mem_base;
20866     xmlNodePtr ret_val;
20867     xmlNodePtr parent; /* the parent node */
20868     int n_parent;
20869     xmlNsPtr ns; /* a namespace if any */
20870     int n_ns;
20871     xmlChar * name; /* the name of the child */
20872     int n_name;
20873     xmlChar * content; /* the XML content of the child if any. */
20874     int n_content;
20875
20876     for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
20877     for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
20878     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
20879     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
20880         mem_base = xmlMemBlocks();
20881         parent = gen_xmlNodePtr(n_parent, 0);
20882         ns = gen_xmlNsPtr(n_ns, 1);
20883         name = gen_const_xmlChar_ptr(n_name, 2);
20884         content = gen_const_xmlChar_ptr(n_content, 3);
20885
20886         ret_val = xmlNewChild(parent, ns, (const xmlChar *)name, (const xmlChar *)content);
20887         desret_xmlNodePtr(ret_val);
20888         call_tests++;
20889         des_xmlNodePtr(n_parent, parent, 0);
20890         des_xmlNsPtr(n_ns, ns, 1);
20891         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
20892         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3);
20893         xmlResetLastError();
20894         if (mem_base != xmlMemBlocks()) {
20895             printf("Leak of %d blocks found in xmlNewChild",
20896                    xmlMemBlocks() - mem_base);
20897             test_ret++;
20898             printf(" %d", n_parent);
20899             printf(" %d", n_ns);
20900             printf(" %d", n_name);
20901             printf(" %d", n_content);
20902             printf("\n");
20903         }
20904     }
20905     }
20906     }
20907     }
20908     function_tests++;
20909 #endif
20910 #endif
20911
20912     return(test_ret);
20913 }
20914
20915
20916 static int
20917 test_xmlNewComment(void) {
20918     int test_ret = 0;
20919
20920     int mem_base;
20921     xmlNodePtr ret_val;
20922     xmlChar * content; /* the comment content */
20923     int n_content;
20924
20925     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
20926         mem_base = xmlMemBlocks();
20927         content = gen_const_xmlChar_ptr(n_content, 0);
20928
20929         ret_val = xmlNewComment((const xmlChar *)content);
20930         desret_xmlNodePtr(ret_val);
20931         call_tests++;
20932         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 0);
20933         xmlResetLastError();
20934         if (mem_base != xmlMemBlocks()) {
20935             printf("Leak of %d blocks found in xmlNewComment",
20936                    xmlMemBlocks() - mem_base);
20937             test_ret++;
20938             printf(" %d", n_content);
20939             printf("\n");
20940         }
20941     }
20942     function_tests++;
20943
20944     return(test_ret);
20945 }
20946
20947
20948 static int
20949 test_xmlNewDoc(void) {
20950     int test_ret = 0;
20951
20952     int mem_base;
20953     xmlDocPtr ret_val;
20954     xmlChar * version; /* xmlChar string giving the version of XML "1.0" */
20955     int n_version;
20956
20957     for (n_version = 0;n_version < gen_nb_const_xmlChar_ptr;n_version++) {
20958         mem_base = xmlMemBlocks();
20959         version = gen_const_xmlChar_ptr(n_version, 0);
20960
20961         ret_val = xmlNewDoc((const xmlChar *)version);
20962         desret_xmlDocPtr(ret_val);
20963         call_tests++;
20964         des_const_xmlChar_ptr(n_version, (const xmlChar *)version, 0);
20965         xmlResetLastError();
20966         if (mem_base != xmlMemBlocks()) {
20967             printf("Leak of %d blocks found in xmlNewDoc",
20968                    xmlMemBlocks() - mem_base);
20969             test_ret++;
20970             printf(" %d", n_version);
20971             printf("\n");
20972         }
20973     }
20974     function_tests++;
20975
20976     return(test_ret);
20977 }
20978
20979
20980 static int
20981 test_xmlNewDocComment(void) {
20982     int test_ret = 0;
20983
20984     int mem_base;
20985     xmlNodePtr ret_val;
20986     xmlDocPtr doc; /* the document */
20987     int n_doc;
20988     xmlChar * content; /* the comment content */
20989     int n_content;
20990
20991     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
20992     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
20993         mem_base = xmlMemBlocks();
20994         doc = gen_xmlDocPtr(n_doc, 0);
20995         content = gen_const_xmlChar_ptr(n_content, 1);
20996
20997         ret_val = xmlNewDocComment(doc, (const xmlChar *)content);
20998         desret_xmlNodePtr(ret_val);
20999         call_tests++;
21000         des_xmlDocPtr(n_doc, doc, 0);
21001         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
21002         xmlResetLastError();
21003         if (mem_base != xmlMemBlocks()) {
21004             printf("Leak of %d blocks found in xmlNewDocComment",
21005                    xmlMemBlocks() - mem_base);
21006             test_ret++;
21007             printf(" %d", n_doc);
21008             printf(" %d", n_content);
21009             printf("\n");
21010         }
21011     }
21012     }
21013     function_tests++;
21014
21015     return(test_ret);
21016 }
21017
21018
21019 static int
21020 test_xmlNewDocFragment(void) {
21021     int test_ret = 0;
21022
21023 #if defined(LIBXML_TREE_ENABLED)
21024     int mem_base;
21025     xmlNodePtr ret_val;
21026     xmlDocPtr doc; /* the document owning the fragment */
21027     int n_doc;
21028
21029     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21030         mem_base = xmlMemBlocks();
21031         doc = gen_xmlDocPtr(n_doc, 0);
21032
21033         ret_val = xmlNewDocFragment(doc);
21034         desret_xmlNodePtr(ret_val);
21035         call_tests++;
21036         des_xmlDocPtr(n_doc, doc, 0);
21037         xmlResetLastError();
21038         if (mem_base != xmlMemBlocks()) {
21039             printf("Leak of %d blocks found in xmlNewDocFragment",
21040                    xmlMemBlocks() - mem_base);
21041             test_ret++;
21042             printf(" %d", n_doc);
21043             printf("\n");
21044         }
21045     }
21046     function_tests++;
21047 #endif
21048
21049     return(test_ret);
21050 }
21051
21052
21053 static int
21054 test_xmlNewDocNode(void) {
21055     int test_ret = 0;
21056
21057     int mem_base;
21058     xmlNodePtr ret_val;
21059     xmlDocPtr doc; /* the document */
21060     int n_doc;
21061     xmlNsPtr ns; /* namespace if any */
21062     int n_ns;
21063     xmlChar * name; /* the node name */
21064     int n_name;
21065     xmlChar * content; /* the XML text content if any */
21066     int n_content;
21067
21068     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21069     for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
21070     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21071     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21072         mem_base = xmlMemBlocks();
21073         doc = gen_xmlDocPtr(n_doc, 0);
21074         ns = gen_xmlNsPtr(n_ns, 1);
21075         name = gen_const_xmlChar_ptr(n_name, 2);
21076         content = gen_const_xmlChar_ptr(n_content, 3);
21077
21078         ret_val = xmlNewDocNode(doc, ns, (const xmlChar *)name, (const xmlChar *)content);
21079         desret_xmlNodePtr(ret_val);
21080         call_tests++;
21081         des_xmlDocPtr(n_doc, doc, 0);
21082         des_xmlNsPtr(n_ns, ns, 1);
21083         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
21084         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3);
21085         xmlResetLastError();
21086         if (mem_base != xmlMemBlocks()) {
21087             printf("Leak of %d blocks found in xmlNewDocNode",
21088                    xmlMemBlocks() - mem_base);
21089             test_ret++;
21090             printf(" %d", n_doc);
21091             printf(" %d", n_ns);
21092             printf(" %d", n_name);
21093             printf(" %d", n_content);
21094             printf("\n");
21095         }
21096     }
21097     }
21098     }
21099     }
21100     function_tests++;
21101
21102     return(test_ret);
21103 }
21104
21105
21106 static int
21107 test_xmlNewDocNodeEatName(void) {
21108     int test_ret = 0;
21109
21110     int mem_base;
21111     xmlNodePtr ret_val;
21112     xmlDocPtr doc; /* the document */
21113     int n_doc;
21114     xmlNsPtr ns; /* namespace if any */
21115     int n_ns;
21116     xmlChar * name; /* the node name */
21117     int n_name;
21118     xmlChar * content; /* the XML text content if any */
21119     int n_content;
21120
21121     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21122     for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
21123     for (n_name = 0;n_name < gen_nb_eaten_name;n_name++) {
21124     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21125         mem_base = xmlMemBlocks();
21126         doc = gen_xmlDocPtr(n_doc, 0);
21127         ns = gen_xmlNsPtr(n_ns, 1);
21128         name = gen_eaten_name(n_name, 2);
21129         content = gen_const_xmlChar_ptr(n_content, 3);
21130
21131         ret_val = xmlNewDocNodeEatName(doc, ns, name, (const xmlChar *)content);
21132         desret_xmlNodePtr(ret_val);
21133         call_tests++;
21134         des_xmlDocPtr(n_doc, doc, 0);
21135         des_xmlNsPtr(n_ns, ns, 1);
21136         des_eaten_name(n_name, name, 2);
21137         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3);
21138         xmlResetLastError();
21139         if (mem_base != xmlMemBlocks()) {
21140             printf("Leak of %d blocks found in xmlNewDocNodeEatName",
21141                    xmlMemBlocks() - mem_base);
21142             test_ret++;
21143             printf(" %d", n_doc);
21144             printf(" %d", n_ns);
21145             printf(" %d", n_name);
21146             printf(" %d", n_content);
21147             printf("\n");
21148         }
21149     }
21150     }
21151     }
21152     }
21153     function_tests++;
21154
21155     return(test_ret);
21156 }
21157
21158
21159 static int
21160 test_xmlNewDocPI(void) {
21161     int test_ret = 0;
21162
21163     int mem_base;
21164     xmlNodePtr ret_val;
21165     xmlDocPtr doc; /* the target document */
21166     int n_doc;
21167     xmlChar * name; /* the processing instruction name */
21168     int n_name;
21169     xmlChar * content; /* the PI content */
21170     int n_content;
21171
21172     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21173     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21174     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21175         mem_base = xmlMemBlocks();
21176         doc = gen_xmlDocPtr(n_doc, 0);
21177         name = gen_const_xmlChar_ptr(n_name, 1);
21178         content = gen_const_xmlChar_ptr(n_content, 2);
21179
21180         ret_val = xmlNewDocPI(doc, (const xmlChar *)name, (const xmlChar *)content);
21181         desret_xmlNodePtr(ret_val);
21182         call_tests++;
21183         des_xmlDocPtr(n_doc, doc, 0);
21184         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
21185         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2);
21186         xmlResetLastError();
21187         if (mem_base != xmlMemBlocks()) {
21188             printf("Leak of %d blocks found in xmlNewDocPI",
21189                    xmlMemBlocks() - mem_base);
21190             test_ret++;
21191             printf(" %d", n_doc);
21192             printf(" %d", n_name);
21193             printf(" %d", n_content);
21194             printf("\n");
21195         }
21196     }
21197     }
21198     }
21199     function_tests++;
21200
21201     return(test_ret);
21202 }
21203
21204
21205 static int
21206 test_xmlNewDocProp(void) {
21207     int test_ret = 0;
21208
21209     int mem_base;
21210     xmlAttrPtr ret_val;
21211     xmlDocPtr doc; /* the document */
21212     int n_doc;
21213     xmlChar * name; /* the name of the attribute */
21214     int n_name;
21215     xmlChar * value; /* the value of the attribute */
21216     int n_value;
21217
21218     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21219     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21220     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
21221         mem_base = xmlMemBlocks();
21222         doc = gen_xmlDocPtr(n_doc, 0);
21223         name = gen_const_xmlChar_ptr(n_name, 1);
21224         value = gen_const_xmlChar_ptr(n_value, 2);
21225
21226         ret_val = xmlNewDocProp(doc, (const xmlChar *)name, (const xmlChar *)value);
21227         desret_xmlAttrPtr(ret_val);
21228         call_tests++;
21229         des_xmlDocPtr(n_doc, doc, 0);
21230         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
21231         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2);
21232         xmlResetLastError();
21233         if (mem_base != xmlMemBlocks()) {
21234             printf("Leak of %d blocks found in xmlNewDocProp",
21235                    xmlMemBlocks() - mem_base);
21236             test_ret++;
21237             printf(" %d", n_doc);
21238             printf(" %d", n_name);
21239             printf(" %d", n_value);
21240             printf("\n");
21241         }
21242     }
21243     }
21244     }
21245     function_tests++;
21246
21247     return(test_ret);
21248 }
21249
21250
21251 static int
21252 test_xmlNewDocRawNode(void) {
21253     int test_ret = 0;
21254
21255 #if defined(LIBXML_TREE_ENABLED)
21256 #ifdef LIBXML_TREE_ENABLED
21257     int mem_base;
21258     xmlNodePtr ret_val;
21259     xmlDocPtr doc; /* the document */
21260     int n_doc;
21261     xmlNsPtr ns; /* namespace if any */
21262     int n_ns;
21263     xmlChar * name; /* the node name */
21264     int n_name;
21265     xmlChar * content; /* the text content if any */
21266     int n_content;
21267
21268     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21269     for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
21270     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21271     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21272         mem_base = xmlMemBlocks();
21273         doc = gen_xmlDocPtr(n_doc, 0);
21274         ns = gen_xmlNsPtr(n_ns, 1);
21275         name = gen_const_xmlChar_ptr(n_name, 2);
21276         content = gen_const_xmlChar_ptr(n_content, 3);
21277
21278         ret_val = xmlNewDocRawNode(doc, ns, (const xmlChar *)name, (const xmlChar *)content);
21279         desret_xmlNodePtr(ret_val);
21280         call_tests++;
21281         des_xmlDocPtr(n_doc, doc, 0);
21282         des_xmlNsPtr(n_ns, ns, 1);
21283         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
21284         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3);
21285         xmlResetLastError();
21286         if (mem_base != xmlMemBlocks()) {
21287             printf("Leak of %d blocks found in xmlNewDocRawNode",
21288                    xmlMemBlocks() - mem_base);
21289             test_ret++;
21290             printf(" %d", n_doc);
21291             printf(" %d", n_ns);
21292             printf(" %d", n_name);
21293             printf(" %d", n_content);
21294             printf("\n");
21295         }
21296     }
21297     }
21298     }
21299     }
21300     function_tests++;
21301 #endif
21302 #endif
21303
21304     return(test_ret);
21305 }
21306
21307
21308 static int
21309 test_xmlNewDocText(void) {
21310     int test_ret = 0;
21311
21312     int mem_base;
21313     xmlNodePtr ret_val;
21314     xmlDocPtr doc; /* the document */
21315     int n_doc;
21316     xmlChar * content; /* the text content */
21317     int n_content;
21318
21319     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21320     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21321         mem_base = xmlMemBlocks();
21322         doc = gen_xmlDocPtr(n_doc, 0);
21323         content = gen_const_xmlChar_ptr(n_content, 1);
21324
21325         ret_val = xmlNewDocText(doc, (const xmlChar *)content);
21326         desret_xmlNodePtr(ret_val);
21327         call_tests++;
21328         des_xmlDocPtr(n_doc, doc, 0);
21329         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
21330         xmlResetLastError();
21331         if (mem_base != xmlMemBlocks()) {
21332             printf("Leak of %d blocks found in xmlNewDocText",
21333                    xmlMemBlocks() - mem_base);
21334             test_ret++;
21335             printf(" %d", n_doc);
21336             printf(" %d", n_content);
21337             printf("\n");
21338         }
21339     }
21340     }
21341     function_tests++;
21342
21343     return(test_ret);
21344 }
21345
21346
21347 static int
21348 test_xmlNewDocTextLen(void) {
21349     int test_ret = 0;
21350
21351     int mem_base;
21352     xmlNodePtr ret_val;
21353     xmlDocPtr doc; /* the document */
21354     int n_doc;
21355     xmlChar * content; /* the text content */
21356     int n_content;
21357     int len; /* the text len. */
21358     int n_len;
21359
21360     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21361     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21362     for (n_len = 0;n_len < gen_nb_int;n_len++) {
21363         mem_base = xmlMemBlocks();
21364         doc = gen_xmlDocPtr(n_doc, 0);
21365         content = gen_const_xmlChar_ptr(n_content, 1);
21366         len = gen_int(n_len, 2);
21367
21368         ret_val = xmlNewDocTextLen(doc, (const xmlChar *)content, len);
21369         desret_xmlNodePtr(ret_val);
21370         call_tests++;
21371         des_xmlDocPtr(n_doc, doc, 0);
21372         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
21373         des_int(n_len, len, 2);
21374         xmlResetLastError();
21375         if (mem_base != xmlMemBlocks()) {
21376             printf("Leak of %d blocks found in xmlNewDocTextLen",
21377                    xmlMemBlocks() - mem_base);
21378             test_ret++;
21379             printf(" %d", n_doc);
21380             printf(" %d", n_content);
21381             printf(" %d", n_len);
21382             printf("\n");
21383         }
21384     }
21385     }
21386     }
21387     function_tests++;
21388
21389     return(test_ret);
21390 }
21391
21392
21393 static int
21394 test_xmlNewDtd(void) {
21395     int test_ret = 0;
21396
21397     int mem_base;
21398     xmlDtdPtr ret_val;
21399     xmlDocPtr doc; /* the document pointer */
21400     int n_doc;
21401     xmlChar * name; /* the DTD name */
21402     int n_name;
21403     xmlChar * ExternalID; /* the external ID */
21404     int n_ExternalID;
21405     xmlChar * SystemID; /* the system ID */
21406     int n_SystemID;
21407
21408     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21409     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21410     for (n_ExternalID = 0;n_ExternalID < gen_nb_const_xmlChar_ptr;n_ExternalID++) {
21411     for (n_SystemID = 0;n_SystemID < gen_nb_const_xmlChar_ptr;n_SystemID++) {
21412         mem_base = xmlMemBlocks();
21413         doc = gen_xmlDocPtr(n_doc, 0);
21414         name = gen_const_xmlChar_ptr(n_name, 1);
21415         ExternalID = gen_const_xmlChar_ptr(n_ExternalID, 2);
21416         SystemID = gen_const_xmlChar_ptr(n_SystemID, 3);
21417
21418         ret_val = xmlNewDtd(doc, (const xmlChar *)name, (const xmlChar *)ExternalID, (const xmlChar *)SystemID);
21419         desret_xmlDtdPtr(ret_val);
21420         call_tests++;
21421         des_xmlDocPtr(n_doc, doc, 0);
21422         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
21423         des_const_xmlChar_ptr(n_ExternalID, (const xmlChar *)ExternalID, 2);
21424         des_const_xmlChar_ptr(n_SystemID, (const xmlChar *)SystemID, 3);
21425         xmlResetLastError();
21426         if (mem_base != xmlMemBlocks()) {
21427             printf("Leak of %d blocks found in xmlNewDtd",
21428                    xmlMemBlocks() - mem_base);
21429             test_ret++;
21430             printf(" %d", n_doc);
21431             printf(" %d", n_name);
21432             printf(" %d", n_ExternalID);
21433             printf(" %d", n_SystemID);
21434             printf("\n");
21435         }
21436     }
21437     }
21438     }
21439     }
21440     function_tests++;
21441
21442     return(test_ret);
21443 }
21444
21445
21446 static int
21447 test_xmlNewNode(void) {
21448     int test_ret = 0;
21449
21450     int mem_base;
21451     xmlNodePtr ret_val;
21452     xmlNsPtr ns; /* namespace if any */
21453     int n_ns;
21454     xmlChar * name; /* the node name */
21455     int n_name;
21456
21457     for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
21458     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21459         mem_base = xmlMemBlocks();
21460         ns = gen_xmlNsPtr(n_ns, 0);
21461         name = gen_const_xmlChar_ptr(n_name, 1);
21462
21463         ret_val = xmlNewNode(ns, (const xmlChar *)name);
21464         desret_xmlNodePtr(ret_val);
21465         call_tests++;
21466         des_xmlNsPtr(n_ns, ns, 0);
21467         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
21468         xmlResetLastError();
21469         if (mem_base != xmlMemBlocks()) {
21470             printf("Leak of %d blocks found in xmlNewNode",
21471                    xmlMemBlocks() - mem_base);
21472             test_ret++;
21473             printf(" %d", n_ns);
21474             printf(" %d", n_name);
21475             printf("\n");
21476         }
21477     }
21478     }
21479     function_tests++;
21480
21481     return(test_ret);
21482 }
21483
21484
21485 static int
21486 test_xmlNewNodeEatName(void) {
21487     int test_ret = 0;
21488
21489     int mem_base;
21490     xmlNodePtr ret_val;
21491     xmlNsPtr ns; /* namespace if any */
21492     int n_ns;
21493     xmlChar * name; /* the node name */
21494     int n_name;
21495
21496     for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
21497     for (n_name = 0;n_name < gen_nb_eaten_name;n_name++) {
21498         mem_base = xmlMemBlocks();
21499         ns = gen_xmlNsPtr(n_ns, 0);
21500         name = gen_eaten_name(n_name, 1);
21501
21502         ret_val = xmlNewNodeEatName(ns, name);
21503         desret_xmlNodePtr(ret_val);
21504         call_tests++;
21505         des_xmlNsPtr(n_ns, ns, 0);
21506         des_eaten_name(n_name, name, 1);
21507         xmlResetLastError();
21508         if (mem_base != xmlMemBlocks()) {
21509             printf("Leak of %d blocks found in xmlNewNodeEatName",
21510                    xmlMemBlocks() - mem_base);
21511             test_ret++;
21512             printf(" %d", n_ns);
21513             printf(" %d", n_name);
21514             printf("\n");
21515         }
21516     }
21517     }
21518     function_tests++;
21519
21520     return(test_ret);
21521 }
21522
21523
21524 static int
21525 test_xmlNewNs(void) {
21526     int test_ret = 0;
21527
21528     int mem_base;
21529     xmlNsPtr ret_val;
21530     xmlNodePtr node; /* the element carrying the namespace */
21531     int n_node;
21532     xmlChar * href; /* the URI associated */
21533     int n_href;
21534     xmlChar * prefix; /* the prefix for the namespace */
21535     int n_prefix;
21536
21537     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
21538     for (n_href = 0;n_href < gen_nb_const_xmlChar_ptr;n_href++) {
21539     for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
21540         mem_base = xmlMemBlocks();
21541         node = gen_xmlNodePtr(n_node, 0);
21542         href = gen_const_xmlChar_ptr(n_href, 1);
21543         prefix = gen_const_xmlChar_ptr(n_prefix, 2);
21544
21545         ret_val = xmlNewNs(node, (const xmlChar *)href, (const xmlChar *)prefix);
21546         if ((node == NULL) && (ret_val != NULL)) xmlFreeNs(ret_val);
21547         desret_xmlNsPtr(ret_val);
21548         call_tests++;
21549         des_xmlNodePtr(n_node, node, 0);
21550         des_const_xmlChar_ptr(n_href, (const xmlChar *)href, 1);
21551         des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 2);
21552         xmlResetLastError();
21553         if (mem_base != xmlMemBlocks()) {
21554             printf("Leak of %d blocks found in xmlNewNs",
21555                    xmlMemBlocks() - mem_base);
21556             test_ret++;
21557             printf(" %d", n_node);
21558             printf(" %d", n_href);
21559             printf(" %d", n_prefix);
21560             printf("\n");
21561         }
21562     }
21563     }
21564     }
21565     function_tests++;
21566
21567     return(test_ret);
21568 }
21569
21570
21571 static int
21572 test_xmlNewNsProp(void) {
21573     int test_ret = 0;
21574
21575     int mem_base;
21576     xmlAttrPtr ret_val;
21577     xmlNodePtr node; /* the holding node */
21578     int n_node;
21579     xmlNsPtr ns; /* the namespace */
21580     int n_ns;
21581     xmlChar * name; /* the name of the attribute */
21582     int n_name;
21583     xmlChar * value; /* the value of the attribute */
21584     int n_value;
21585
21586     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
21587     for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
21588     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21589     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
21590         mem_base = xmlMemBlocks();
21591         node = gen_xmlNodePtr(n_node, 0);
21592         ns = gen_xmlNsPtr(n_ns, 1);
21593         name = gen_const_xmlChar_ptr(n_name, 2);
21594         value = gen_const_xmlChar_ptr(n_value, 3);
21595
21596         ret_val = xmlNewNsProp(node, ns, (const xmlChar *)name, (const xmlChar *)value);
21597         desret_xmlAttrPtr(ret_val);
21598         call_tests++;
21599         des_xmlNodePtr(n_node, node, 0);
21600         des_xmlNsPtr(n_ns, ns, 1);
21601         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
21602         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 3);
21603         xmlResetLastError();
21604         if (mem_base != xmlMemBlocks()) {
21605             printf("Leak of %d blocks found in xmlNewNsProp",
21606                    xmlMemBlocks() - mem_base);
21607             test_ret++;
21608             printf(" %d", n_node);
21609             printf(" %d", n_ns);
21610             printf(" %d", n_name);
21611             printf(" %d", n_value);
21612             printf("\n");
21613         }
21614     }
21615     }
21616     }
21617     }
21618     function_tests++;
21619
21620     return(test_ret);
21621 }
21622
21623
21624 static int
21625 test_xmlNewNsPropEatName(void) {
21626     int test_ret = 0;
21627
21628     int mem_base;
21629     xmlAttrPtr ret_val;
21630     xmlNodePtr node; /* the holding node */
21631     int n_node;
21632     xmlNsPtr ns; /* the namespace */
21633     int n_ns;
21634     xmlChar * name; /* the name of the attribute */
21635     int n_name;
21636     xmlChar * value; /* the value of the attribute */
21637     int n_value;
21638
21639     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
21640     for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
21641     for (n_name = 0;n_name < gen_nb_eaten_name;n_name++) {
21642     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
21643         mem_base = xmlMemBlocks();
21644         node = gen_xmlNodePtr(n_node, 0);
21645         ns = gen_xmlNsPtr(n_ns, 1);
21646         name = gen_eaten_name(n_name, 2);
21647         value = gen_const_xmlChar_ptr(n_value, 3);
21648
21649         ret_val = xmlNewNsPropEatName(node, ns, name, (const xmlChar *)value);
21650         desret_xmlAttrPtr(ret_val);
21651         call_tests++;
21652         des_xmlNodePtr(n_node, node, 0);
21653         des_xmlNsPtr(n_ns, ns, 1);
21654         des_eaten_name(n_name, name, 2);
21655         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 3);
21656         xmlResetLastError();
21657         if (mem_base != xmlMemBlocks()) {
21658             printf("Leak of %d blocks found in xmlNewNsPropEatName",
21659                    xmlMemBlocks() - mem_base);
21660             test_ret++;
21661             printf(" %d", n_node);
21662             printf(" %d", n_ns);
21663             printf(" %d", n_name);
21664             printf(" %d", n_value);
21665             printf("\n");
21666         }
21667     }
21668     }
21669     }
21670     }
21671     function_tests++;
21672
21673     return(test_ret);
21674 }
21675
21676
21677 static int
21678 test_xmlNewPI(void) {
21679     int test_ret = 0;
21680
21681     int mem_base;
21682     xmlNodePtr ret_val;
21683     xmlChar * name; /* the processing instruction name */
21684     int n_name;
21685     xmlChar * content; /* the PI content */
21686     int n_content;
21687
21688     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21689     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21690         mem_base = xmlMemBlocks();
21691         name = gen_const_xmlChar_ptr(n_name, 0);
21692         content = gen_const_xmlChar_ptr(n_content, 1);
21693
21694         ret_val = xmlNewPI((const xmlChar *)name, (const xmlChar *)content);
21695         desret_xmlNodePtr(ret_val);
21696         call_tests++;
21697         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
21698         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
21699         xmlResetLastError();
21700         if (mem_base != xmlMemBlocks()) {
21701             printf("Leak of %d blocks found in xmlNewPI",
21702                    xmlMemBlocks() - mem_base);
21703             test_ret++;
21704             printf(" %d", n_name);
21705             printf(" %d", n_content);
21706             printf("\n");
21707         }
21708     }
21709     }
21710     function_tests++;
21711
21712     return(test_ret);
21713 }
21714
21715
21716 static int
21717 test_xmlNewProp(void) {
21718     int test_ret = 0;
21719
21720 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
21721 #ifdef LIBXML_TREE_ENABLED
21722     int mem_base;
21723     xmlAttrPtr ret_val;
21724     xmlNodePtr node; /* the holding node */
21725     int n_node;
21726     xmlChar * name; /* the name of the attribute */
21727     int n_name;
21728     xmlChar * value; /* the value of the attribute */
21729     int n_value;
21730
21731     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
21732     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21733     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
21734         mem_base = xmlMemBlocks();
21735         node = gen_xmlNodePtr(n_node, 0);
21736         name = gen_const_xmlChar_ptr(n_name, 1);
21737         value = gen_const_xmlChar_ptr(n_value, 2);
21738
21739         ret_val = xmlNewProp(node, (const xmlChar *)name, (const xmlChar *)value);
21740         desret_xmlAttrPtr(ret_val);
21741         call_tests++;
21742         des_xmlNodePtr(n_node, node, 0);
21743         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
21744         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2);
21745         xmlResetLastError();
21746         if (mem_base != xmlMemBlocks()) {
21747             printf("Leak of %d blocks found in xmlNewProp",
21748                    xmlMemBlocks() - mem_base);
21749             test_ret++;
21750             printf(" %d", n_node);
21751             printf(" %d", n_name);
21752             printf(" %d", n_value);
21753             printf("\n");
21754         }
21755     }
21756     }
21757     }
21758     function_tests++;
21759 #endif
21760 #endif
21761
21762     return(test_ret);
21763 }
21764
21765
21766 static int
21767 test_xmlNewReference(void) {
21768     int test_ret = 0;
21769
21770     int mem_base;
21771     xmlNodePtr ret_val;
21772     xmlDocPtr doc; /* the document */
21773     int n_doc;
21774     xmlChar * name; /* the reference name, or the reference string with & and ; */
21775     int n_name;
21776
21777     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
21778     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
21779         mem_base = xmlMemBlocks();
21780         doc = gen_xmlDocPtr(n_doc, 0);
21781         name = gen_const_xmlChar_ptr(n_name, 1);
21782
21783         ret_val = xmlNewReference(doc, (const xmlChar *)name);
21784         desret_xmlNodePtr(ret_val);
21785         call_tests++;
21786         des_xmlDocPtr(n_doc, doc, 0);
21787         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
21788         xmlResetLastError();
21789         if (mem_base != xmlMemBlocks()) {
21790             printf("Leak of %d blocks found in xmlNewReference",
21791                    xmlMemBlocks() - mem_base);
21792             test_ret++;
21793             printf(" %d", n_doc);
21794             printf(" %d", n_name);
21795             printf("\n");
21796         }
21797     }
21798     }
21799     function_tests++;
21800
21801     return(test_ret);
21802 }
21803
21804
21805 static int
21806 test_xmlNewText(void) {
21807     int test_ret = 0;
21808
21809     int mem_base;
21810     xmlNodePtr ret_val;
21811     xmlChar * content; /* the text content */
21812     int n_content;
21813
21814     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21815         mem_base = xmlMemBlocks();
21816         content = gen_const_xmlChar_ptr(n_content, 0);
21817
21818         ret_val = xmlNewText((const xmlChar *)content);
21819         desret_xmlNodePtr(ret_val);
21820         call_tests++;
21821         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 0);
21822         xmlResetLastError();
21823         if (mem_base != xmlMemBlocks()) {
21824             printf("Leak of %d blocks found in xmlNewText",
21825                    xmlMemBlocks() - mem_base);
21826             test_ret++;
21827             printf(" %d", n_content);
21828             printf("\n");
21829         }
21830     }
21831     function_tests++;
21832
21833     return(test_ret);
21834 }
21835
21836
21837 static int
21838 test_xmlNewTextChild(void) {
21839     int test_ret = 0;
21840
21841 #if defined(LIBXML_TREE_ENABLED)
21842 #ifdef LIBXML_TREE_ENABLED
21843     int mem_base;
21844     xmlNodePtr ret_val;
21845     xmlNodePtr parent; /* the parent node */
21846     int n_parent;
21847     xmlNsPtr ns; /* a namespace if any */
21848     int n_ns;
21849     xmlChar * name; /* the name of the child */
21850     int n_name;
21851     xmlChar * content; /* the text content of the child if any. */
21852     int n_content;
21853
21854     for (n_parent = 0;n_parent < gen_nb_xmlNodePtr;n_parent++) {
21855     for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
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         parent = gen_xmlNodePtr(n_parent, 0);
21860         ns = gen_xmlNsPtr(n_ns, 1);
21861         name = gen_const_xmlChar_ptr(n_name, 2);
21862         content = gen_const_xmlChar_ptr(n_content, 3);
21863
21864         ret_val = xmlNewTextChild(parent, ns, (const xmlChar *)name, (const xmlChar *)content);
21865         desret_xmlNodePtr(ret_val);
21866         call_tests++;
21867         des_xmlNodePtr(n_parent, parent, 0);
21868         des_xmlNsPtr(n_ns, ns, 1);
21869         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
21870         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3);
21871         xmlResetLastError();
21872         if (mem_base != xmlMemBlocks()) {
21873             printf("Leak of %d blocks found in xmlNewTextChild",
21874                    xmlMemBlocks() - mem_base);
21875             test_ret++;
21876             printf(" %d", n_parent);
21877             printf(" %d", n_ns);
21878             printf(" %d", n_name);
21879             printf(" %d", n_content);
21880             printf("\n");
21881         }
21882     }
21883     }
21884     }
21885     }
21886     function_tests++;
21887 #endif
21888 #endif
21889
21890     return(test_ret);
21891 }
21892
21893
21894 static int
21895 test_xmlNewTextLen(void) {
21896     int test_ret = 0;
21897
21898     int mem_base;
21899     xmlNodePtr ret_val;
21900     xmlChar * content; /* the text content */
21901     int n_content;
21902     int len; /* the text len. */
21903     int n_len;
21904
21905     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21906     for (n_len = 0;n_len < gen_nb_int;n_len++) {
21907         mem_base = xmlMemBlocks();
21908         content = gen_const_xmlChar_ptr(n_content, 0);
21909         len = gen_int(n_len, 1);
21910
21911         ret_val = xmlNewTextLen((const xmlChar *)content, len);
21912         desret_xmlNodePtr(ret_val);
21913         call_tests++;
21914         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 0);
21915         des_int(n_len, len, 1);
21916         xmlResetLastError();
21917         if (mem_base != xmlMemBlocks()) {
21918             printf("Leak of %d blocks found in xmlNewTextLen",
21919                    xmlMemBlocks() - mem_base);
21920             test_ret++;
21921             printf(" %d", n_content);
21922             printf(" %d", n_len);
21923             printf("\n");
21924         }
21925     }
21926     }
21927     function_tests++;
21928
21929     return(test_ret);
21930 }
21931
21932
21933 static int
21934 test_xmlNextElementSibling(void) {
21935     int test_ret = 0;
21936
21937 #if defined(LIBXML_TREE_ENABLED)
21938     int mem_base;
21939     xmlNodePtr ret_val;
21940     xmlNodePtr node; /* the current node */
21941     int n_node;
21942
21943     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
21944         mem_base = xmlMemBlocks();
21945         node = gen_xmlNodePtr(n_node, 0);
21946
21947         ret_val = xmlNextElementSibling(node);
21948         desret_xmlNodePtr(ret_val);
21949         call_tests++;
21950         des_xmlNodePtr(n_node, node, 0);
21951         xmlResetLastError();
21952         if (mem_base != xmlMemBlocks()) {
21953             printf("Leak of %d blocks found in xmlNextElementSibling",
21954                    xmlMemBlocks() - mem_base);
21955             test_ret++;
21956             printf(" %d", n_node);
21957             printf("\n");
21958         }
21959     }
21960     function_tests++;
21961 #endif
21962
21963     return(test_ret);
21964 }
21965
21966
21967 static int
21968 test_xmlNodeAddContent(void) {
21969     int test_ret = 0;
21970
21971     int mem_base;
21972     xmlNodePtr cur; /* the node being modified */
21973     int n_cur;
21974     xmlChar * content; /* extra content */
21975     int n_content;
21976
21977     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
21978     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
21979         mem_base = xmlMemBlocks();
21980         cur = gen_xmlNodePtr(n_cur, 0);
21981         content = gen_const_xmlChar_ptr(n_content, 1);
21982
21983         xmlNodeAddContent(cur, (const xmlChar *)content);
21984         call_tests++;
21985         des_xmlNodePtr(n_cur, cur, 0);
21986         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
21987         xmlResetLastError();
21988         if (mem_base != xmlMemBlocks()) {
21989             printf("Leak of %d blocks found in xmlNodeAddContent",
21990                    xmlMemBlocks() - mem_base);
21991             test_ret++;
21992             printf(" %d", n_cur);
21993             printf(" %d", n_content);
21994             printf("\n");
21995         }
21996     }
21997     }
21998     function_tests++;
21999
22000     return(test_ret);
22001 }
22002
22003
22004 static int
22005 test_xmlNodeAddContentLen(void) {
22006     int test_ret = 0;
22007
22008     int mem_base;
22009     xmlNodePtr cur; /* the node being modified */
22010     int n_cur;
22011     xmlChar * content; /* extra content */
22012     int n_content;
22013     int len; /* the size of @content */
22014     int n_len;
22015
22016     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22017     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
22018     for (n_len = 0;n_len < gen_nb_int;n_len++) {
22019         mem_base = xmlMemBlocks();
22020         cur = gen_xmlNodePtr(n_cur, 0);
22021         content = gen_const_xmlChar_ptr(n_content, 1);
22022         len = gen_int(n_len, 2);
22023
22024         xmlNodeAddContentLen(cur, (const xmlChar *)content, len);
22025         call_tests++;
22026         des_xmlNodePtr(n_cur, cur, 0);
22027         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
22028         des_int(n_len, len, 2);
22029         xmlResetLastError();
22030         if (mem_base != xmlMemBlocks()) {
22031             printf("Leak of %d blocks found in xmlNodeAddContentLen",
22032                    xmlMemBlocks() - mem_base);
22033             test_ret++;
22034             printf(" %d", n_cur);
22035             printf(" %d", n_content);
22036             printf(" %d", n_len);
22037             printf("\n");
22038         }
22039     }
22040     }
22041     }
22042     function_tests++;
22043
22044     return(test_ret);
22045 }
22046
22047
22048 static int
22049 test_xmlNodeBufGetContent(void) {
22050     int test_ret = 0;
22051
22052     int mem_base;
22053     int ret_val;
22054     xmlBufferPtr buffer; /* a buffer */
22055     int n_buffer;
22056     xmlNodePtr cur; /* the node being read */
22057     int n_cur;
22058
22059     for (n_buffer = 0;n_buffer < gen_nb_xmlBufferPtr;n_buffer++) {
22060     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22061         mem_base = xmlMemBlocks();
22062         buffer = gen_xmlBufferPtr(n_buffer, 0);
22063         cur = gen_xmlNodePtr(n_cur, 1);
22064
22065         ret_val = xmlNodeBufGetContent(buffer, cur);
22066         desret_int(ret_val);
22067         call_tests++;
22068         des_xmlBufferPtr(n_buffer, buffer, 0);
22069         des_xmlNodePtr(n_cur, cur, 1);
22070         xmlResetLastError();
22071         if (mem_base != xmlMemBlocks()) {
22072             printf("Leak of %d blocks found in xmlNodeBufGetContent",
22073                    xmlMemBlocks() - mem_base);
22074             test_ret++;
22075             printf(" %d", n_buffer);
22076             printf(" %d", n_cur);
22077             printf("\n");
22078         }
22079     }
22080     }
22081     function_tests++;
22082
22083     return(test_ret);
22084 }
22085
22086
22087 static int
22088 test_xmlNodeDump(void) {
22089     int test_ret = 0;
22090
22091 #if defined(LIBXML_OUTPUT_ENABLED)
22092     int mem_base;
22093     int ret_val;
22094     xmlBufferPtr buf; /* the XML buffer output */
22095     int n_buf;
22096     xmlDocPtr doc; /* the document */
22097     int n_doc;
22098     xmlNodePtr cur; /* the current node */
22099     int n_cur;
22100     int level; /* the imbrication level for indenting */
22101     int n_level;
22102     int format; /* is formatting allowed */
22103     int n_format;
22104
22105     for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
22106     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
22107     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22108     for (n_level = 0;n_level < gen_nb_int;n_level++) {
22109     for (n_format = 0;n_format < gen_nb_int;n_format++) {
22110         mem_base = xmlMemBlocks();
22111         buf = gen_xmlBufferPtr(n_buf, 0);
22112         doc = gen_xmlDocPtr(n_doc, 1);
22113         cur = gen_xmlNodePtr(n_cur, 2);
22114         level = gen_int(n_level, 3);
22115         format = gen_int(n_format, 4);
22116
22117         ret_val = xmlNodeDump(buf, doc, cur, level, format);
22118         desret_int(ret_val);
22119         call_tests++;
22120         des_xmlBufferPtr(n_buf, buf, 0);
22121         des_xmlDocPtr(n_doc, doc, 1);
22122         des_xmlNodePtr(n_cur, cur, 2);
22123         des_int(n_level, level, 3);
22124         des_int(n_format, format, 4);
22125         xmlResetLastError();
22126         if (mem_base != xmlMemBlocks()) {
22127             printf("Leak of %d blocks found in xmlNodeDump",
22128                    xmlMemBlocks() - mem_base);
22129             test_ret++;
22130             printf(" %d", n_buf);
22131             printf(" %d", n_doc);
22132             printf(" %d", n_cur);
22133             printf(" %d", n_level);
22134             printf(" %d", n_format);
22135             printf("\n");
22136         }
22137     }
22138     }
22139     }
22140     }
22141     }
22142     function_tests++;
22143 #endif
22144
22145     return(test_ret);
22146 }
22147
22148
22149 static int
22150 test_xmlNodeDumpOutput(void) {
22151     int test_ret = 0;
22152
22153 #if defined(LIBXML_OUTPUT_ENABLED)
22154     int mem_base;
22155     xmlOutputBufferPtr buf; /* the XML buffer output */
22156     int n_buf;
22157     xmlDocPtr doc; /* the document */
22158     int n_doc;
22159     xmlNodePtr cur; /* the current node */
22160     int n_cur;
22161     int level; /* the imbrication level for indenting */
22162     int n_level;
22163     int format; /* is formatting allowed */
22164     int n_format;
22165     char * encoding; /* an optional encoding string */
22166     int n_encoding;
22167
22168     for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
22169     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
22170     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22171     for (n_level = 0;n_level < gen_nb_int;n_level++) {
22172     for (n_format = 0;n_format < gen_nb_int;n_format++) {
22173     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
22174         mem_base = xmlMemBlocks();
22175         buf = gen_xmlOutputBufferPtr(n_buf, 0);
22176         doc = gen_xmlDocPtr(n_doc, 1);
22177         cur = gen_xmlNodePtr(n_cur, 2);
22178         level = gen_int(n_level, 3);
22179         format = gen_int(n_format, 4);
22180         encoding = gen_const_char_ptr(n_encoding, 5);
22181
22182         xmlNodeDumpOutput(buf, doc, cur, level, format, (const char *)encoding);
22183         call_tests++;
22184         des_xmlOutputBufferPtr(n_buf, buf, 0);
22185         des_xmlDocPtr(n_doc, doc, 1);
22186         des_xmlNodePtr(n_cur, cur, 2);
22187         des_int(n_level, level, 3);
22188         des_int(n_format, format, 4);
22189         des_const_char_ptr(n_encoding, (const char *)encoding, 5);
22190         xmlResetLastError();
22191         if (mem_base != xmlMemBlocks()) {
22192             printf("Leak of %d blocks found in xmlNodeDumpOutput",
22193                    xmlMemBlocks() - mem_base);
22194             test_ret++;
22195             printf(" %d", n_buf);
22196             printf(" %d", n_doc);
22197             printf(" %d", n_cur);
22198             printf(" %d", n_level);
22199             printf(" %d", n_format);
22200             printf(" %d", n_encoding);
22201             printf("\n");
22202         }
22203     }
22204     }
22205     }
22206     }
22207     }
22208     }
22209     function_tests++;
22210 #endif
22211
22212     return(test_ret);
22213 }
22214
22215
22216 static int
22217 test_xmlNodeGetBase(void) {
22218     int test_ret = 0;
22219
22220     int mem_base;
22221     xmlChar * ret_val;
22222     xmlDocPtr doc; /* the document the node pertains to */
22223     int n_doc;
22224     xmlNodePtr cur; /* the node being checked */
22225     int n_cur;
22226
22227     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
22228     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22229         mem_base = xmlMemBlocks();
22230         doc = gen_xmlDocPtr(n_doc, 0);
22231         cur = gen_xmlNodePtr(n_cur, 1);
22232
22233         ret_val = xmlNodeGetBase(doc, cur);
22234         desret_xmlChar_ptr(ret_val);
22235         call_tests++;
22236         des_xmlDocPtr(n_doc, doc, 0);
22237         des_xmlNodePtr(n_cur, cur, 1);
22238         xmlResetLastError();
22239         if (mem_base != xmlMemBlocks()) {
22240             printf("Leak of %d blocks found in xmlNodeGetBase",
22241                    xmlMemBlocks() - mem_base);
22242             test_ret++;
22243             printf(" %d", n_doc);
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_xmlNodeGetContent(void) {
22257     int test_ret = 0;
22258
22259     int mem_base;
22260     xmlChar * ret_val;
22261     xmlNodePtr cur; /* the node being read */
22262     int n_cur;
22263
22264     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22265         mem_base = xmlMemBlocks();
22266         cur = gen_xmlNodePtr(n_cur, 0);
22267
22268         ret_val = xmlNodeGetContent(cur);
22269         desret_xmlChar_ptr(ret_val);
22270         call_tests++;
22271         des_xmlNodePtr(n_cur, cur, 0);
22272         xmlResetLastError();
22273         if (mem_base != xmlMemBlocks()) {
22274             printf("Leak of %d blocks found in xmlNodeGetContent",
22275                    xmlMemBlocks() - mem_base);
22276             test_ret++;
22277             printf(" %d", n_cur);
22278             printf("\n");
22279         }
22280     }
22281     function_tests++;
22282
22283     return(test_ret);
22284 }
22285
22286
22287 static int
22288 test_xmlNodeGetLang(void) {
22289     int test_ret = 0;
22290
22291     int mem_base;
22292     xmlChar * ret_val;
22293     xmlNodePtr cur; /* the node being checked */
22294     int n_cur;
22295
22296     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22297         mem_base = xmlMemBlocks();
22298         cur = gen_xmlNodePtr(n_cur, 0);
22299
22300         ret_val = xmlNodeGetLang(cur);
22301         desret_xmlChar_ptr(ret_val);
22302         call_tests++;
22303         des_xmlNodePtr(n_cur, cur, 0);
22304         xmlResetLastError();
22305         if (mem_base != xmlMemBlocks()) {
22306             printf("Leak of %d blocks found in xmlNodeGetLang",
22307                    xmlMemBlocks() - mem_base);
22308             test_ret++;
22309             printf(" %d", n_cur);
22310             printf("\n");
22311         }
22312     }
22313     function_tests++;
22314
22315     return(test_ret);
22316 }
22317
22318
22319 static int
22320 test_xmlNodeGetSpacePreserve(void) {
22321     int test_ret = 0;
22322
22323     int mem_base;
22324     int ret_val;
22325     xmlNodePtr cur; /* the node being checked */
22326     int n_cur;
22327
22328     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22329         mem_base = xmlMemBlocks();
22330         cur = gen_xmlNodePtr(n_cur, 0);
22331
22332         ret_val = xmlNodeGetSpacePreserve(cur);
22333         desret_int(ret_val);
22334         call_tests++;
22335         des_xmlNodePtr(n_cur, cur, 0);
22336         xmlResetLastError();
22337         if (mem_base != xmlMemBlocks()) {
22338             printf("Leak of %d blocks found in xmlNodeGetSpacePreserve",
22339                    xmlMemBlocks() - mem_base);
22340             test_ret++;
22341             printf(" %d", n_cur);
22342             printf("\n");
22343         }
22344     }
22345     function_tests++;
22346
22347     return(test_ret);
22348 }
22349
22350
22351 static int
22352 test_xmlNodeIsText(void) {
22353     int test_ret = 0;
22354
22355     int mem_base;
22356     int ret_val;
22357     xmlNodePtr node; /* the node */
22358     int n_node;
22359
22360     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
22361         mem_base = xmlMemBlocks();
22362         node = gen_xmlNodePtr(n_node, 0);
22363
22364         ret_val = xmlNodeIsText(node);
22365         desret_int(ret_val);
22366         call_tests++;
22367         des_xmlNodePtr(n_node, node, 0);
22368         xmlResetLastError();
22369         if (mem_base != xmlMemBlocks()) {
22370             printf("Leak of %d blocks found in xmlNodeIsText",
22371                    xmlMemBlocks() - mem_base);
22372             test_ret++;
22373             printf(" %d", n_node);
22374             printf("\n");
22375         }
22376     }
22377     function_tests++;
22378
22379     return(test_ret);
22380 }
22381
22382
22383 static int
22384 test_xmlNodeListGetRawString(void) {
22385     int test_ret = 0;
22386
22387 #if defined(LIBXML_TREE_ENABLED)
22388     int mem_base;
22389     xmlChar * ret_val;
22390     xmlDocPtr doc; /* the document */
22391     int n_doc;
22392     xmlNodePtr list; /* a Node list */
22393     int n_list;
22394     int inLine; /* should we replace entity contents or show their external form */
22395     int n_inLine;
22396
22397     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
22398     for (n_list = 0;n_list < gen_nb_xmlNodePtr;n_list++) {
22399     for (n_inLine = 0;n_inLine < gen_nb_int;n_inLine++) {
22400         mem_base = xmlMemBlocks();
22401         doc = gen_xmlDocPtr(n_doc, 0);
22402         list = gen_xmlNodePtr(n_list, 1);
22403         inLine = gen_int(n_inLine, 2);
22404
22405         ret_val = xmlNodeListGetRawString(doc, list, inLine);
22406         desret_xmlChar_ptr(ret_val);
22407         call_tests++;
22408         des_xmlDocPtr(n_doc, doc, 0);
22409         des_xmlNodePtr(n_list, list, 1);
22410         des_int(n_inLine, inLine, 2);
22411         xmlResetLastError();
22412         if (mem_base != xmlMemBlocks()) {
22413             printf("Leak of %d blocks found in xmlNodeListGetRawString",
22414                    xmlMemBlocks() - mem_base);
22415             test_ret++;
22416             printf(" %d", n_doc);
22417             printf(" %d", n_list);
22418             printf(" %d", n_inLine);
22419             printf("\n");
22420         }
22421     }
22422     }
22423     }
22424     function_tests++;
22425 #endif
22426
22427     return(test_ret);
22428 }
22429
22430
22431 static int
22432 test_xmlNodeListGetString(void) {
22433     int test_ret = 0;
22434
22435     int mem_base;
22436     xmlChar * ret_val;
22437     xmlDocPtr doc; /* the document */
22438     int n_doc;
22439     xmlNodePtr list; /* a Node list */
22440     int n_list;
22441     int inLine; /* should we replace entity contents or show their external form */
22442     int n_inLine;
22443
22444     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
22445     for (n_list = 0;n_list < gen_nb_xmlNodePtr;n_list++) {
22446     for (n_inLine = 0;n_inLine < gen_nb_int;n_inLine++) {
22447         mem_base = xmlMemBlocks();
22448         doc = gen_xmlDocPtr(n_doc, 0);
22449         list = gen_xmlNodePtr(n_list, 1);
22450         inLine = gen_int(n_inLine, 2);
22451
22452         ret_val = xmlNodeListGetString(doc, list, inLine);
22453         desret_xmlChar_ptr(ret_val);
22454         call_tests++;
22455         des_xmlDocPtr(n_doc, doc, 0);
22456         des_xmlNodePtr(n_list, list, 1);
22457         des_int(n_inLine, inLine, 2);
22458         xmlResetLastError();
22459         if (mem_base != xmlMemBlocks()) {
22460             printf("Leak of %d blocks found in xmlNodeListGetString",
22461                    xmlMemBlocks() - mem_base);
22462             test_ret++;
22463             printf(" %d", n_doc);
22464             printf(" %d", n_list);
22465             printf(" %d", n_inLine);
22466             printf("\n");
22467         }
22468     }
22469     }
22470     }
22471     function_tests++;
22472
22473     return(test_ret);
22474 }
22475
22476
22477 static int
22478 test_xmlNodeSetBase(void) {
22479     int test_ret = 0;
22480
22481 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED)
22482     int mem_base;
22483     xmlNodePtr cur; /* the node being changed */
22484     int n_cur;
22485     xmlChar * uri; /* the new base URI */
22486     int n_uri;
22487
22488     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22489     for (n_uri = 0;n_uri < gen_nb_const_xmlChar_ptr;n_uri++) {
22490         mem_base = xmlMemBlocks();
22491         cur = gen_xmlNodePtr(n_cur, 0);
22492         uri = gen_const_xmlChar_ptr(n_uri, 1);
22493
22494         xmlNodeSetBase(cur, (const xmlChar *)uri);
22495         call_tests++;
22496         des_xmlNodePtr(n_cur, cur, 0);
22497         des_const_xmlChar_ptr(n_uri, (const xmlChar *)uri, 1);
22498         xmlResetLastError();
22499         if (mem_base != xmlMemBlocks()) {
22500             printf("Leak of %d blocks found in xmlNodeSetBase",
22501                    xmlMemBlocks() - mem_base);
22502             test_ret++;
22503             printf(" %d", n_cur);
22504             printf(" %d", n_uri);
22505             printf("\n");
22506         }
22507     }
22508     }
22509     function_tests++;
22510 #endif
22511
22512     return(test_ret);
22513 }
22514
22515
22516 static int
22517 test_xmlNodeSetContent(void) {
22518     int test_ret = 0;
22519
22520     int mem_base;
22521     xmlNodePtr cur; /* the node being modified */
22522     int n_cur;
22523     xmlChar * content; /* the new value of the content */
22524     int n_content;
22525
22526     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22527     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
22528         mem_base = xmlMemBlocks();
22529         cur = gen_xmlNodePtr(n_cur, 0);
22530         content = gen_const_xmlChar_ptr(n_content, 1);
22531
22532         xmlNodeSetContent(cur, (const xmlChar *)content);
22533         call_tests++;
22534         des_xmlNodePtr(n_cur, cur, 0);
22535         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
22536         xmlResetLastError();
22537         if (mem_base != xmlMemBlocks()) {
22538             printf("Leak of %d blocks found in xmlNodeSetContent",
22539                    xmlMemBlocks() - mem_base);
22540             test_ret++;
22541             printf(" %d", n_cur);
22542             printf(" %d", n_content);
22543             printf("\n");
22544         }
22545     }
22546     }
22547     function_tests++;
22548
22549     return(test_ret);
22550 }
22551
22552
22553 static int
22554 test_xmlNodeSetContentLen(void) {
22555     int test_ret = 0;
22556
22557 #if defined(LIBXML_TREE_ENABLED)
22558     int mem_base;
22559     xmlNodePtr cur; /* the node being modified */
22560     int n_cur;
22561     xmlChar * content; /* the new value of the content */
22562     int n_content;
22563     int len; /* the size of @content */
22564     int n_len;
22565
22566     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22567     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
22568     for (n_len = 0;n_len < gen_nb_int;n_len++) {
22569         mem_base = xmlMemBlocks();
22570         cur = gen_xmlNodePtr(n_cur, 0);
22571         content = gen_const_xmlChar_ptr(n_content, 1);
22572         len = gen_int(n_len, 2);
22573
22574         xmlNodeSetContentLen(cur, (const xmlChar *)content, len);
22575         call_tests++;
22576         des_xmlNodePtr(n_cur, cur, 0);
22577         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
22578         des_int(n_len, len, 2);
22579         xmlResetLastError();
22580         if (mem_base != xmlMemBlocks()) {
22581             printf("Leak of %d blocks found in xmlNodeSetContentLen",
22582                    xmlMemBlocks() - mem_base);
22583             test_ret++;
22584             printf(" %d", n_cur);
22585             printf(" %d", n_content);
22586             printf(" %d", n_len);
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_xmlNodeSetLang(void) {
22601     int test_ret = 0;
22602
22603 #if defined(LIBXML_TREE_ENABLED)
22604     int mem_base;
22605     xmlNodePtr cur; /* the node being changed */
22606     int n_cur;
22607     xmlChar * lang; /* the language description */
22608     int n_lang;
22609
22610     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22611     for (n_lang = 0;n_lang < gen_nb_const_xmlChar_ptr;n_lang++) {
22612         mem_base = xmlMemBlocks();
22613         cur = gen_xmlNodePtr(n_cur, 0);
22614         lang = gen_const_xmlChar_ptr(n_lang, 1);
22615
22616         xmlNodeSetLang(cur, (const xmlChar *)lang);
22617         call_tests++;
22618         des_xmlNodePtr(n_cur, cur, 0);
22619         des_const_xmlChar_ptr(n_lang, (const xmlChar *)lang, 1);
22620         xmlResetLastError();
22621         if (mem_base != xmlMemBlocks()) {
22622             printf("Leak of %d blocks found in xmlNodeSetLang",
22623                    xmlMemBlocks() - mem_base);
22624             test_ret++;
22625             printf(" %d", n_cur);
22626             printf(" %d", n_lang);
22627             printf("\n");
22628         }
22629     }
22630     }
22631     function_tests++;
22632 #endif
22633
22634     return(test_ret);
22635 }
22636
22637
22638 static int
22639 test_xmlNodeSetName(void) {
22640     int test_ret = 0;
22641
22642 #if defined(LIBXML_TREE_ENABLED)
22643     int mem_base;
22644     xmlNodePtr cur; /* the node being changed */
22645     int n_cur;
22646     xmlChar * name; /* the new tag name */
22647     int n_name;
22648
22649     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22650     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
22651         mem_base = xmlMemBlocks();
22652         cur = gen_xmlNodePtr(n_cur, 0);
22653         name = gen_const_xmlChar_ptr(n_name, 1);
22654
22655         xmlNodeSetName(cur, (const xmlChar *)name);
22656         call_tests++;
22657         des_xmlNodePtr(n_cur, cur, 0);
22658         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
22659         xmlResetLastError();
22660         if (mem_base != xmlMemBlocks()) {
22661             printf("Leak of %d blocks found in xmlNodeSetName",
22662                    xmlMemBlocks() - mem_base);
22663             test_ret++;
22664             printf(" %d", n_cur);
22665             printf(" %d", n_name);
22666             printf("\n");
22667         }
22668     }
22669     }
22670     function_tests++;
22671 #endif
22672
22673     return(test_ret);
22674 }
22675
22676
22677 static int
22678 test_xmlNodeSetSpacePreserve(void) {
22679     int test_ret = 0;
22680
22681 #if defined(LIBXML_TREE_ENABLED)
22682     int mem_base;
22683     xmlNodePtr cur; /* the node being changed */
22684     int n_cur;
22685     int val; /* the xml:space value ("0": default, 1: "preserve") */
22686     int n_val;
22687
22688     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
22689     for (n_val = 0;n_val < gen_nb_int;n_val++) {
22690         mem_base = xmlMemBlocks();
22691         cur = gen_xmlNodePtr(n_cur, 0);
22692         val = gen_int(n_val, 1);
22693
22694         xmlNodeSetSpacePreserve(cur, val);
22695         call_tests++;
22696         des_xmlNodePtr(n_cur, cur, 0);
22697         des_int(n_val, val, 1);
22698         xmlResetLastError();
22699         if (mem_base != xmlMemBlocks()) {
22700             printf("Leak of %d blocks found in xmlNodeSetSpacePreserve",
22701                    xmlMemBlocks() - mem_base);
22702             test_ret++;
22703             printf(" %d", n_cur);
22704             printf(" %d", n_val);
22705             printf("\n");
22706         }
22707     }
22708     }
22709     function_tests++;
22710 #endif
22711
22712     return(test_ret);
22713 }
22714
22715
22716 static int
22717 test_xmlPreviousElementSibling(void) {
22718     int test_ret = 0;
22719
22720 #if defined(LIBXML_TREE_ENABLED)
22721     int mem_base;
22722     xmlNodePtr ret_val;
22723     xmlNodePtr node; /* the current node */
22724     int n_node;
22725
22726     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
22727         mem_base = xmlMemBlocks();
22728         node = gen_xmlNodePtr(n_node, 0);
22729
22730         ret_val = xmlPreviousElementSibling(node);
22731         desret_xmlNodePtr(ret_val);
22732         call_tests++;
22733         des_xmlNodePtr(n_node, node, 0);
22734         xmlResetLastError();
22735         if (mem_base != xmlMemBlocks()) {
22736             printf("Leak of %d blocks found in xmlPreviousElementSibling",
22737                    xmlMemBlocks() - mem_base);
22738             test_ret++;
22739             printf(" %d", n_node);
22740             printf("\n");
22741         }
22742     }
22743     function_tests++;
22744 #endif
22745
22746     return(test_ret);
22747 }
22748
22749
22750 static int
22751 test_xmlReconciliateNs(void) {
22752     int test_ret = 0;
22753
22754 #if defined(LIBXML_TREE_ENABLED)
22755 #ifdef LIBXML_TREE_ENABLED
22756     int mem_base;
22757     int ret_val;
22758     xmlDocPtr doc; /* the document */
22759     int n_doc;
22760     xmlNodePtr tree; /* a node defining the subtree to reconciliate */
22761     int n_tree;
22762
22763     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
22764     for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) {
22765         mem_base = xmlMemBlocks();
22766         doc = gen_xmlDocPtr(n_doc, 0);
22767         tree = gen_xmlNodePtr(n_tree, 1);
22768
22769         ret_val = xmlReconciliateNs(doc, tree);
22770         desret_int(ret_val);
22771         call_tests++;
22772         des_xmlDocPtr(n_doc, doc, 0);
22773         des_xmlNodePtr(n_tree, tree, 1);
22774         xmlResetLastError();
22775         if (mem_base != xmlMemBlocks()) {
22776             printf("Leak of %d blocks found in xmlReconciliateNs",
22777                    xmlMemBlocks() - mem_base);
22778             test_ret++;
22779             printf(" %d", n_doc);
22780             printf(" %d", n_tree);
22781             printf("\n");
22782         }
22783     }
22784     }
22785     function_tests++;
22786 #endif
22787 #endif
22788
22789     return(test_ret);
22790 }
22791
22792
22793 static int
22794 test_xmlRemoveProp(void) {
22795     int test_ret = 0;
22796
22797     int mem_base;
22798     int ret_val;
22799     xmlAttrPtr cur; /* an attribute */
22800     int n_cur;
22801
22802     for (n_cur = 0;n_cur < gen_nb_xmlAttrPtr;n_cur++) {
22803         mem_base = xmlMemBlocks();
22804         cur = gen_xmlAttrPtr(n_cur, 0);
22805
22806         ret_val = xmlRemoveProp(cur);
22807         cur = NULL;
22808         desret_int(ret_val);
22809         call_tests++;
22810         des_xmlAttrPtr(n_cur, cur, 0);
22811         xmlResetLastError();
22812         if (mem_base != xmlMemBlocks()) {
22813             printf("Leak of %d blocks found in xmlRemoveProp",
22814                    xmlMemBlocks() - mem_base);
22815             test_ret++;
22816             printf(" %d", n_cur);
22817             printf("\n");
22818         }
22819     }
22820     function_tests++;
22821
22822     return(test_ret);
22823 }
22824
22825
22826 static int
22827 test_xmlReplaceNode(void) {
22828     int test_ret = 0;
22829
22830 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
22831     int mem_base;
22832     xmlNodePtr ret_val;
22833     xmlNodePtr old; /* the old node */
22834     int n_old;
22835     xmlNodePtr cur; /* the node */
22836     int n_cur;
22837
22838     for (n_old = 0;n_old < gen_nb_xmlNodePtr;n_old++) {
22839     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr_in;n_cur++) {
22840         mem_base = xmlMemBlocks();
22841         old = gen_xmlNodePtr(n_old, 0);
22842         cur = gen_xmlNodePtr_in(n_cur, 1);
22843
22844         ret_val = xmlReplaceNode(old, cur);
22845         if (cur != NULL) {
22846               xmlUnlinkNode(cur);
22847               xmlFreeNode(cur) ; cur = NULL ; }
22848           if (old != NULL) {
22849               xmlUnlinkNode(old);
22850               xmlFreeNode(old) ; old = NULL ; }
22851           ret_val = NULL;
22852         desret_xmlNodePtr(ret_val);
22853         call_tests++;
22854         des_xmlNodePtr(n_old, old, 0);
22855         des_xmlNodePtr_in(n_cur, cur, 1);
22856         xmlResetLastError();
22857         if (mem_base != xmlMemBlocks()) {
22858             printf("Leak of %d blocks found in xmlReplaceNode",
22859                    xmlMemBlocks() - mem_base);
22860             test_ret++;
22861             printf(" %d", n_old);
22862             printf(" %d", n_cur);
22863             printf("\n");
22864         }
22865     }
22866     }
22867     function_tests++;
22868 #endif
22869
22870     return(test_ret);
22871 }
22872
22873
22874 static int
22875 test_xmlSaveFile(void) {
22876     int test_ret = 0;
22877
22878 #if defined(LIBXML_OUTPUT_ENABLED)
22879     int mem_base;
22880     int ret_val;
22881     const char * filename; /* the filename (or URL) */
22882     int n_filename;
22883     xmlDocPtr cur; /* the document */
22884     int n_cur;
22885
22886     for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
22887     for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
22888         mem_base = xmlMemBlocks();
22889         filename = gen_fileoutput(n_filename, 0);
22890         cur = gen_xmlDocPtr(n_cur, 1);
22891
22892         ret_val = xmlSaveFile(filename, cur);
22893         desret_int(ret_val);
22894         call_tests++;
22895         des_fileoutput(n_filename, filename, 0);
22896         des_xmlDocPtr(n_cur, cur, 1);
22897         xmlResetLastError();
22898         if (mem_base != xmlMemBlocks()) {
22899             printf("Leak of %d blocks found in xmlSaveFile",
22900                    xmlMemBlocks() - mem_base);
22901             test_ret++;
22902             printf(" %d", n_filename);
22903             printf(" %d", n_cur);
22904             printf("\n");
22905         }
22906     }
22907     }
22908     function_tests++;
22909 #endif
22910
22911     return(test_ret);
22912 }
22913
22914
22915 static int
22916 test_xmlSaveFileEnc(void) {
22917     int test_ret = 0;
22918
22919 #if defined(LIBXML_OUTPUT_ENABLED)
22920     int mem_base;
22921     int ret_val;
22922     const char * filename; /* the filename (or URL) */
22923     int n_filename;
22924     xmlDocPtr cur; /* the document */
22925     int n_cur;
22926     char * encoding; /* the name of an encoding (or NULL) */
22927     int n_encoding;
22928
22929     for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
22930     for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
22931     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
22932         mem_base = xmlMemBlocks();
22933         filename = gen_fileoutput(n_filename, 0);
22934         cur = gen_xmlDocPtr(n_cur, 1);
22935         encoding = gen_const_char_ptr(n_encoding, 2);
22936
22937         ret_val = xmlSaveFileEnc(filename, cur, (const char *)encoding);
22938         desret_int(ret_val);
22939         call_tests++;
22940         des_fileoutput(n_filename, filename, 0);
22941         des_xmlDocPtr(n_cur, cur, 1);
22942         des_const_char_ptr(n_encoding, (const char *)encoding, 2);
22943         xmlResetLastError();
22944         if (mem_base != xmlMemBlocks()) {
22945             printf("Leak of %d blocks found in xmlSaveFileEnc",
22946                    xmlMemBlocks() - mem_base);
22947             test_ret++;
22948             printf(" %d", n_filename);
22949             printf(" %d", n_cur);
22950             printf(" %d", n_encoding);
22951             printf("\n");
22952         }
22953     }
22954     }
22955     }
22956     function_tests++;
22957 #endif
22958
22959     return(test_ret);
22960 }
22961
22962
22963 static int
22964 test_xmlSaveFileTo(void) {
22965     int test_ret = 0;
22966
22967 #if defined(LIBXML_OUTPUT_ENABLED)
22968     int mem_base;
22969     int ret_val;
22970     xmlOutputBufferPtr buf; /* an output I/O buffer */
22971     int n_buf;
22972     xmlDocPtr cur; /* the document */
22973     int n_cur;
22974     char * encoding; /* the encoding if any assuming the I/O layer handles the trancoding */
22975     int n_encoding;
22976
22977     for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
22978     for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
22979     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
22980         mem_base = xmlMemBlocks();
22981         buf = gen_xmlOutputBufferPtr(n_buf, 0);
22982         cur = gen_xmlDocPtr(n_cur, 1);
22983         encoding = gen_const_char_ptr(n_encoding, 2);
22984
22985         ret_val = xmlSaveFileTo(buf, cur, (const char *)encoding);
22986         buf = NULL;
22987         desret_int(ret_val);
22988         call_tests++;
22989         des_xmlOutputBufferPtr(n_buf, buf, 0);
22990         des_xmlDocPtr(n_cur, cur, 1);
22991         des_const_char_ptr(n_encoding, (const char *)encoding, 2);
22992         xmlResetLastError();
22993         if (mem_base != xmlMemBlocks()) {
22994             printf("Leak of %d blocks found in xmlSaveFileTo",
22995                    xmlMemBlocks() - mem_base);
22996             test_ret++;
22997             printf(" %d", n_buf);
22998             printf(" %d", n_cur);
22999             printf(" %d", n_encoding);
23000             printf("\n");
23001         }
23002     }
23003     }
23004     }
23005     function_tests++;
23006 #endif
23007
23008     return(test_ret);
23009 }
23010
23011
23012 static int
23013 test_xmlSaveFormatFile(void) {
23014     int test_ret = 0;
23015
23016 #if defined(LIBXML_OUTPUT_ENABLED)
23017     int mem_base;
23018     int ret_val;
23019     const char * filename; /* the filename (or URL) */
23020     int n_filename;
23021     xmlDocPtr cur; /* the document */
23022     int n_cur;
23023     int format; /* should formatting spaces been added */
23024     int n_format;
23025
23026     for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
23027     for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
23028     for (n_format = 0;n_format < gen_nb_int;n_format++) {
23029         mem_base = xmlMemBlocks();
23030         filename = gen_fileoutput(n_filename, 0);
23031         cur = gen_xmlDocPtr(n_cur, 1);
23032         format = gen_int(n_format, 2);
23033
23034         ret_val = xmlSaveFormatFile(filename, cur, format);
23035         desret_int(ret_val);
23036         call_tests++;
23037         des_fileoutput(n_filename, filename, 0);
23038         des_xmlDocPtr(n_cur, cur, 1);
23039         des_int(n_format, format, 2);
23040         xmlResetLastError();
23041         if (mem_base != xmlMemBlocks()) {
23042             printf("Leak of %d blocks found in xmlSaveFormatFile",
23043                    xmlMemBlocks() - mem_base);
23044             test_ret++;
23045             printf(" %d", n_filename);
23046             printf(" %d", n_cur);
23047             printf(" %d", n_format);
23048             printf("\n");
23049         }
23050     }
23051     }
23052     }
23053     function_tests++;
23054 #endif
23055
23056     return(test_ret);
23057 }
23058
23059
23060 static int
23061 test_xmlSaveFormatFileEnc(void) {
23062     int test_ret = 0;
23063
23064 #if defined(LIBXML_OUTPUT_ENABLED)
23065     int mem_base;
23066     int ret_val;
23067     const char * filename; /* the filename or URL to output */
23068     int n_filename;
23069     xmlDocPtr cur; /* the document being saved */
23070     int n_cur;
23071     char * encoding; /* the name of the encoding to use or NULL. */
23072     int n_encoding;
23073     int format; /* should formatting spaces be added. */
23074     int n_format;
23075
23076     for (n_filename = 0;n_filename < gen_nb_fileoutput;n_filename++) {
23077     for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
23078     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
23079     for (n_format = 0;n_format < gen_nb_int;n_format++) {
23080         mem_base = xmlMemBlocks();
23081         filename = gen_fileoutput(n_filename, 0);
23082         cur = gen_xmlDocPtr(n_cur, 1);
23083         encoding = gen_const_char_ptr(n_encoding, 2);
23084         format = gen_int(n_format, 3);
23085
23086         ret_val = xmlSaveFormatFileEnc(filename, cur, (const char *)encoding, format);
23087         desret_int(ret_val);
23088         call_tests++;
23089         des_fileoutput(n_filename, filename, 0);
23090         des_xmlDocPtr(n_cur, cur, 1);
23091         des_const_char_ptr(n_encoding, (const char *)encoding, 2);
23092         des_int(n_format, format, 3);
23093         xmlResetLastError();
23094         if (mem_base != xmlMemBlocks()) {
23095             printf("Leak of %d blocks found in xmlSaveFormatFileEnc",
23096                    xmlMemBlocks() - mem_base);
23097             test_ret++;
23098             printf(" %d", n_filename);
23099             printf(" %d", n_cur);
23100             printf(" %d", n_encoding);
23101             printf(" %d", n_format);
23102             printf("\n");
23103         }
23104     }
23105     }
23106     }
23107     }
23108     function_tests++;
23109 #endif
23110
23111     return(test_ret);
23112 }
23113
23114
23115 static int
23116 test_xmlSaveFormatFileTo(void) {
23117     int test_ret = 0;
23118
23119 #if defined(LIBXML_OUTPUT_ENABLED)
23120     int mem_base;
23121     int ret_val;
23122     xmlOutputBufferPtr buf; /* an output I/O buffer */
23123     int n_buf;
23124     xmlDocPtr cur; /* the document */
23125     int n_cur;
23126     char * encoding; /* the encoding if any assuming the I/O layer handles the trancoding */
23127     int n_encoding;
23128     int format; /* should formatting spaces been added */
23129     int n_format;
23130
23131     for (n_buf = 0;n_buf < gen_nb_xmlOutputBufferPtr;n_buf++) {
23132     for (n_cur = 0;n_cur < gen_nb_xmlDocPtr;n_cur++) {
23133     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
23134     for (n_format = 0;n_format < gen_nb_int;n_format++) {
23135         mem_base = xmlMemBlocks();
23136         buf = gen_xmlOutputBufferPtr(n_buf, 0);
23137         cur = gen_xmlDocPtr(n_cur, 1);
23138         encoding = gen_const_char_ptr(n_encoding, 2);
23139         format = gen_int(n_format, 3);
23140
23141         ret_val = xmlSaveFormatFileTo(buf, cur, (const char *)encoding, format);
23142         buf = NULL;
23143         desret_int(ret_val);
23144         call_tests++;
23145         des_xmlOutputBufferPtr(n_buf, buf, 0);
23146         des_xmlDocPtr(n_cur, cur, 1);
23147         des_const_char_ptr(n_encoding, (const char *)encoding, 2);
23148         des_int(n_format, format, 3);
23149         xmlResetLastError();
23150         if (mem_base != xmlMemBlocks()) {
23151             printf("Leak of %d blocks found in xmlSaveFormatFileTo",
23152                    xmlMemBlocks() - mem_base);
23153             test_ret++;
23154             printf(" %d", n_buf);
23155             printf(" %d", n_cur);
23156             printf(" %d", n_encoding);
23157             printf(" %d", n_format);
23158             printf("\n");
23159         }
23160     }
23161     }
23162     }
23163     }
23164     function_tests++;
23165 #endif
23166
23167     return(test_ret);
23168 }
23169
23170
23171 static int
23172 test_xmlSearchNs(void) {
23173     int test_ret = 0;
23174
23175     int mem_base;
23176     xmlNsPtr ret_val;
23177     xmlDocPtr doc; /* the document */
23178     int n_doc;
23179     xmlNodePtr node; /* the current node */
23180     int n_node;
23181     xmlChar * nameSpace; /* the namespace prefix */
23182     int n_nameSpace;
23183
23184     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
23185     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
23186     for (n_nameSpace = 0;n_nameSpace < gen_nb_const_xmlChar_ptr;n_nameSpace++) {
23187         mem_base = xmlMemBlocks();
23188         doc = gen_xmlDocPtr(n_doc, 0);
23189         node = gen_xmlNodePtr(n_node, 1);
23190         nameSpace = gen_const_xmlChar_ptr(n_nameSpace, 2);
23191
23192         ret_val = xmlSearchNs(doc, node, (const xmlChar *)nameSpace);
23193         desret_xmlNsPtr(ret_val);
23194         call_tests++;
23195         des_xmlDocPtr(n_doc, doc, 0);
23196         des_xmlNodePtr(n_node, node, 1);
23197         des_const_xmlChar_ptr(n_nameSpace, (const xmlChar *)nameSpace, 2);
23198         xmlResetLastError();
23199         if (mem_base != xmlMemBlocks()) {
23200             printf("Leak of %d blocks found in xmlSearchNs",
23201                    xmlMemBlocks() - mem_base);
23202             test_ret++;
23203             printf(" %d", n_doc);
23204             printf(" %d", n_node);
23205             printf(" %d", n_nameSpace);
23206             printf("\n");
23207         }
23208     }
23209     }
23210     }
23211     function_tests++;
23212
23213     return(test_ret);
23214 }
23215
23216
23217 static int
23218 test_xmlSearchNsByHref(void) {
23219     int test_ret = 0;
23220
23221     int mem_base;
23222     xmlNsPtr ret_val;
23223     xmlDocPtr doc; /* the document */
23224     int n_doc;
23225     xmlNodePtr node; /* the current node */
23226     int n_node;
23227     xmlChar * href; /* the namespace value */
23228     int n_href;
23229
23230     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
23231     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
23232     for (n_href = 0;n_href < gen_nb_const_xmlChar_ptr;n_href++) {
23233         mem_base = xmlMemBlocks();
23234         doc = gen_xmlDocPtr(n_doc, 0);
23235         node = gen_xmlNodePtr(n_node, 1);
23236         href = gen_const_xmlChar_ptr(n_href, 2);
23237
23238         ret_val = xmlSearchNsByHref(doc, node, (const xmlChar *)href);
23239         desret_xmlNsPtr(ret_val);
23240         call_tests++;
23241         des_xmlDocPtr(n_doc, doc, 0);
23242         des_xmlNodePtr(n_node, node, 1);
23243         des_const_xmlChar_ptr(n_href, (const xmlChar *)href, 2);
23244         xmlResetLastError();
23245         if (mem_base != xmlMemBlocks()) {
23246             printf("Leak of %d blocks found in xmlSearchNsByHref",
23247                    xmlMemBlocks() - mem_base);
23248             test_ret++;
23249             printf(" %d", n_doc);
23250             printf(" %d", n_node);
23251             printf(" %d", n_href);
23252             printf("\n");
23253         }
23254     }
23255     }
23256     }
23257     function_tests++;
23258
23259     return(test_ret);
23260 }
23261
23262
23263 static int
23264 test_xmlSetBufferAllocationScheme(void) {
23265     int test_ret = 0;
23266
23267     int mem_base;
23268     xmlBufferAllocationScheme scheme; /* allocation method to use */
23269     int n_scheme;
23270
23271     for (n_scheme = 0;n_scheme < gen_nb_xmlBufferAllocationScheme;n_scheme++) {
23272         mem_base = xmlMemBlocks();
23273         scheme = gen_xmlBufferAllocationScheme(n_scheme, 0);
23274
23275         xmlSetBufferAllocationScheme(scheme);
23276         call_tests++;
23277         des_xmlBufferAllocationScheme(n_scheme, scheme, 0);
23278         xmlResetLastError();
23279         if (mem_base != xmlMemBlocks()) {
23280             printf("Leak of %d blocks found in xmlSetBufferAllocationScheme",
23281                    xmlMemBlocks() - mem_base);
23282             test_ret++;
23283             printf(" %d", n_scheme);
23284             printf("\n");
23285         }
23286     }
23287     function_tests++;
23288
23289     return(test_ret);
23290 }
23291
23292
23293 static int
23294 test_xmlSetCompressMode(void) {
23295     int test_ret = 0;
23296
23297     int mem_base;
23298     int mode; /* the compression ratio */
23299     int n_mode;
23300
23301     for (n_mode = 0;n_mode < gen_nb_int;n_mode++) {
23302         mem_base = xmlMemBlocks();
23303         mode = gen_int(n_mode, 0);
23304
23305         xmlSetCompressMode(mode);
23306         call_tests++;
23307         des_int(n_mode, mode, 0);
23308         xmlResetLastError();
23309         if (mem_base != xmlMemBlocks()) {
23310             printf("Leak of %d blocks found in xmlSetCompressMode",
23311                    xmlMemBlocks() - mem_base);
23312             test_ret++;
23313             printf(" %d", n_mode);
23314             printf("\n");
23315         }
23316     }
23317     function_tests++;
23318
23319     return(test_ret);
23320 }
23321
23322
23323 static int
23324 test_xmlSetDocCompressMode(void) {
23325     int test_ret = 0;
23326
23327     int mem_base;
23328     xmlDocPtr doc; /* the document */
23329     int n_doc;
23330     int mode; /* the compression ratio */
23331     int n_mode;
23332
23333     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
23334     for (n_mode = 0;n_mode < gen_nb_int;n_mode++) {
23335         mem_base = xmlMemBlocks();
23336         doc = gen_xmlDocPtr(n_doc, 0);
23337         mode = gen_int(n_mode, 1);
23338
23339         xmlSetDocCompressMode(doc, mode);
23340         call_tests++;
23341         des_xmlDocPtr(n_doc, doc, 0);
23342         des_int(n_mode, mode, 1);
23343         xmlResetLastError();
23344         if (mem_base != xmlMemBlocks()) {
23345             printf("Leak of %d blocks found in xmlSetDocCompressMode",
23346                    xmlMemBlocks() - mem_base);
23347             test_ret++;
23348             printf(" %d", n_doc);
23349             printf(" %d", n_mode);
23350             printf("\n");
23351         }
23352     }
23353     }
23354     function_tests++;
23355
23356     return(test_ret);
23357 }
23358
23359
23360 static int
23361 test_xmlSetNs(void) {
23362     int test_ret = 0;
23363
23364     int mem_base;
23365     xmlNodePtr node; /* a node in the document */
23366     int n_node;
23367     xmlNsPtr ns; /* a namespace pointer */
23368     int n_ns;
23369
23370     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
23371     for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
23372         mem_base = xmlMemBlocks();
23373         node = gen_xmlNodePtr(n_node, 0);
23374         ns = gen_xmlNsPtr(n_ns, 1);
23375
23376         xmlSetNs(node, ns);
23377         call_tests++;
23378         des_xmlNodePtr(n_node, node, 0);
23379         des_xmlNsPtr(n_ns, ns, 1);
23380         xmlResetLastError();
23381         if (mem_base != xmlMemBlocks()) {
23382             printf("Leak of %d blocks found in xmlSetNs",
23383                    xmlMemBlocks() - mem_base);
23384             test_ret++;
23385             printf(" %d", n_node);
23386             printf(" %d", n_ns);
23387             printf("\n");
23388         }
23389     }
23390     }
23391     function_tests++;
23392
23393     return(test_ret);
23394 }
23395
23396
23397 static int
23398 test_xmlSetNsProp(void) {
23399     int test_ret = 0;
23400
23401 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
23402     int mem_base;
23403     xmlAttrPtr ret_val;
23404     xmlNodePtr node; /* the node */
23405     int n_node;
23406     xmlNsPtr ns; /* the namespace definition */
23407     int n_ns;
23408     xmlChar * name; /* the attribute name */
23409     int n_name;
23410     xmlChar * value; /* the attribute value */
23411     int n_value;
23412
23413     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
23414     for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
23415     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
23416     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
23417         mem_base = xmlMemBlocks();
23418         node = gen_xmlNodePtr(n_node, 0);
23419         ns = gen_xmlNsPtr(n_ns, 1);
23420         name = gen_const_xmlChar_ptr(n_name, 2);
23421         value = gen_const_xmlChar_ptr(n_value, 3);
23422
23423         ret_val = xmlSetNsProp(node, ns, (const xmlChar *)name, (const xmlChar *)value);
23424         desret_xmlAttrPtr(ret_val);
23425         call_tests++;
23426         des_xmlNodePtr(n_node, node, 0);
23427         des_xmlNsPtr(n_ns, ns, 1);
23428         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
23429         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 3);
23430         xmlResetLastError();
23431         if (mem_base != xmlMemBlocks()) {
23432             printf("Leak of %d blocks found in xmlSetNsProp",
23433                    xmlMemBlocks() - mem_base);
23434             test_ret++;
23435             printf(" %d", n_node);
23436             printf(" %d", n_ns);
23437             printf(" %d", n_name);
23438             printf(" %d", n_value);
23439             printf("\n");
23440         }
23441     }
23442     }
23443     }
23444     }
23445     function_tests++;
23446 #endif
23447
23448     return(test_ret);
23449 }
23450
23451
23452 static int
23453 test_xmlSetProp(void) {
23454     int test_ret = 0;
23455
23456 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
23457     int mem_base;
23458     xmlAttrPtr ret_val;
23459     xmlNodePtr node; /* the node */
23460     int n_node;
23461     xmlChar * name; /* the attribute name (a QName) */
23462     int n_name;
23463     xmlChar * value; /* the attribute value */
23464     int n_value;
23465
23466     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
23467     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
23468     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
23469         mem_base = xmlMemBlocks();
23470         node = gen_xmlNodePtr(n_node, 0);
23471         name = gen_const_xmlChar_ptr(n_name, 1);
23472         value = gen_const_xmlChar_ptr(n_value, 2);
23473
23474         ret_val = xmlSetProp(node, (const xmlChar *)name, (const xmlChar *)value);
23475         desret_xmlAttrPtr(ret_val);
23476         call_tests++;
23477         des_xmlNodePtr(n_node, node, 0);
23478         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
23479         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2);
23480         xmlResetLastError();
23481         if (mem_base != xmlMemBlocks()) {
23482             printf("Leak of %d blocks found in xmlSetProp",
23483                    xmlMemBlocks() - mem_base);
23484             test_ret++;
23485             printf(" %d", n_node);
23486             printf(" %d", n_name);
23487             printf(" %d", n_value);
23488             printf("\n");
23489         }
23490     }
23491     }
23492     }
23493     function_tests++;
23494 #endif
23495
23496     return(test_ret);
23497 }
23498
23499
23500 static int
23501 test_xmlSplitQName2(void) {
23502     int test_ret = 0;
23503
23504     int mem_base;
23505     xmlChar * ret_val;
23506     xmlChar * name; /* the full QName */
23507     int n_name;
23508     xmlChar ** prefix; /* a xmlChar ** */
23509     int n_prefix;
23510
23511     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
23512     for (n_prefix = 0;n_prefix < gen_nb_xmlChar_ptr_ptr;n_prefix++) {
23513         mem_base = xmlMemBlocks();
23514         name = gen_const_xmlChar_ptr(n_name, 0);
23515         prefix = gen_xmlChar_ptr_ptr(n_prefix, 1);
23516
23517         ret_val = xmlSplitQName2((const xmlChar *)name, prefix);
23518         desret_xmlChar_ptr(ret_val);
23519         call_tests++;
23520         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
23521         des_xmlChar_ptr_ptr(n_prefix, prefix, 1);
23522         xmlResetLastError();
23523         if (mem_base != xmlMemBlocks()) {
23524             printf("Leak of %d blocks found in xmlSplitQName2",
23525                    xmlMemBlocks() - mem_base);
23526             test_ret++;
23527             printf(" %d", n_name);
23528             printf(" %d", n_prefix);
23529             printf("\n");
23530         }
23531     }
23532     }
23533     function_tests++;
23534
23535     return(test_ret);
23536 }
23537
23538
23539 static int
23540 test_xmlSplitQName3(void) {
23541     int test_ret = 0;
23542
23543     int mem_base;
23544     const xmlChar * ret_val;
23545     xmlChar * name; /* the full QName */
23546     int n_name;
23547     int * len; /* an int * */
23548     int n_len;
23549
23550     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
23551     for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
23552         mem_base = xmlMemBlocks();
23553         name = gen_const_xmlChar_ptr(n_name, 0);
23554         len = gen_int_ptr(n_len, 1);
23555
23556         ret_val = xmlSplitQName3((const xmlChar *)name, len);
23557         desret_const_xmlChar_ptr(ret_val);
23558         call_tests++;
23559         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
23560         des_int_ptr(n_len, len, 1);
23561         xmlResetLastError();
23562         if (mem_base != xmlMemBlocks()) {
23563             printf("Leak of %d blocks found in xmlSplitQName3",
23564                    xmlMemBlocks() - mem_base);
23565             test_ret++;
23566             printf(" %d", n_name);
23567             printf(" %d", n_len);
23568             printf("\n");
23569         }
23570     }
23571     }
23572     function_tests++;
23573
23574     return(test_ret);
23575 }
23576
23577
23578 static int
23579 test_xmlStringGetNodeList(void) {
23580     int test_ret = 0;
23581
23582     int mem_base;
23583     xmlNodePtr ret_val;
23584     xmlDocPtr doc; /* the document */
23585     int n_doc;
23586     xmlChar * value; /* the value of the attribute */
23587     int n_value;
23588
23589     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
23590     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
23591         mem_base = xmlMemBlocks();
23592         doc = gen_xmlDocPtr(n_doc, 0);
23593         value = gen_const_xmlChar_ptr(n_value, 1);
23594
23595         ret_val = xmlStringGetNodeList(doc, (const xmlChar *)value);
23596         desret_xmlNodePtr(ret_val);
23597         call_tests++;
23598         des_xmlDocPtr(n_doc, doc, 0);
23599         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
23600         xmlResetLastError();
23601         if (mem_base != xmlMemBlocks()) {
23602             printf("Leak of %d blocks found in xmlStringGetNodeList",
23603                    xmlMemBlocks() - mem_base);
23604             test_ret++;
23605             printf(" %d", n_doc);
23606             printf(" %d", n_value);
23607             printf("\n");
23608         }
23609     }
23610     }
23611     function_tests++;
23612
23613     return(test_ret);
23614 }
23615
23616
23617 static int
23618 test_xmlStringLenGetNodeList(void) {
23619     int test_ret = 0;
23620
23621     int mem_base;
23622     xmlNodePtr ret_val;
23623     xmlDocPtr doc; /* the document */
23624     int n_doc;
23625     xmlChar * value; /* the value of the text */
23626     int n_value;
23627     int len; /* the length of the string value */
23628     int n_len;
23629
23630     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
23631     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
23632     for (n_len = 0;n_len < gen_nb_int;n_len++) {
23633         mem_base = xmlMemBlocks();
23634         doc = gen_xmlDocPtr(n_doc, 0);
23635         value = gen_const_xmlChar_ptr(n_value, 1);
23636         len = gen_int(n_len, 2);
23637
23638         ret_val = xmlStringLenGetNodeList(doc, (const xmlChar *)value, len);
23639         desret_xmlNodePtr(ret_val);
23640         call_tests++;
23641         des_xmlDocPtr(n_doc, doc, 0);
23642         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
23643         des_int(n_len, len, 2);
23644         xmlResetLastError();
23645         if (mem_base != xmlMemBlocks()) {
23646             printf("Leak of %d blocks found in xmlStringLenGetNodeList",
23647                    xmlMemBlocks() - mem_base);
23648             test_ret++;
23649             printf(" %d", n_doc);
23650             printf(" %d", n_value);
23651             printf(" %d", n_len);
23652             printf("\n");
23653         }
23654     }
23655     }
23656     }
23657     function_tests++;
23658
23659     return(test_ret);
23660 }
23661
23662
23663 static int
23664 test_xmlTextConcat(void) {
23665     int test_ret = 0;
23666
23667     int mem_base;
23668     int ret_val;
23669     xmlNodePtr node; /* the node */
23670     int n_node;
23671     xmlChar * content; /* the content */
23672     int n_content;
23673     int len; /* @content length */
23674     int n_len;
23675
23676     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
23677     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
23678     for (n_len = 0;n_len < gen_nb_int;n_len++) {
23679         mem_base = xmlMemBlocks();
23680         node = gen_xmlNodePtr(n_node, 0);
23681         content = gen_const_xmlChar_ptr(n_content, 1);
23682         len = gen_int(n_len, 2);
23683
23684         ret_val = xmlTextConcat(node, (const xmlChar *)content, len);
23685         desret_int(ret_val);
23686         call_tests++;
23687         des_xmlNodePtr(n_node, node, 0);
23688         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
23689         des_int(n_len, len, 2);
23690         xmlResetLastError();
23691         if (mem_base != xmlMemBlocks()) {
23692             printf("Leak of %d blocks found in xmlTextConcat",
23693                    xmlMemBlocks() - mem_base);
23694             test_ret++;
23695             printf(" %d", n_node);
23696             printf(" %d", n_content);
23697             printf(" %d", n_len);
23698             printf("\n");
23699         }
23700     }
23701     }
23702     }
23703     function_tests++;
23704
23705     return(test_ret);
23706 }
23707
23708
23709 static int
23710 test_xmlTextMerge(void) {
23711     int test_ret = 0;
23712
23713     int mem_base;
23714     xmlNodePtr ret_val;
23715     xmlNodePtr first; /* the first text node */
23716     int n_first;
23717     xmlNodePtr second; /* the second text node being merged */
23718     int n_second;
23719
23720     for (n_first = 0;n_first < gen_nb_xmlNodePtr_in;n_first++) {
23721     for (n_second = 0;n_second < gen_nb_xmlNodePtr_in;n_second++) {
23722         mem_base = xmlMemBlocks();
23723         first = gen_xmlNodePtr_in(n_first, 0);
23724         second = gen_xmlNodePtr_in(n_second, 1);
23725
23726         ret_val = xmlTextMerge(first, second);
23727         if ((first != NULL) && (first->type != XML_TEXT_NODE)) {
23728               xmlUnlinkNode(second);
23729               xmlFreeNode(second) ; second = NULL ; }
23730         desret_xmlNodePtr(ret_val);
23731         call_tests++;
23732         des_xmlNodePtr_in(n_first, first, 0);
23733         des_xmlNodePtr_in(n_second, second, 1);
23734         xmlResetLastError();
23735         if (mem_base != xmlMemBlocks()) {
23736             printf("Leak of %d blocks found in xmlTextMerge",
23737                    xmlMemBlocks() - mem_base);
23738             test_ret++;
23739             printf(" %d", n_first);
23740             printf(" %d", n_second);
23741             printf("\n");
23742         }
23743     }
23744     }
23745     function_tests++;
23746
23747     return(test_ret);
23748 }
23749
23750
23751 static int
23752 test_xmlUnsetNsProp(void) {
23753     int test_ret = 0;
23754
23755 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
23756     int mem_base;
23757     int ret_val;
23758     xmlNodePtr node; /* the node */
23759     int n_node;
23760     xmlNsPtr ns; /* the namespace definition */
23761     int n_ns;
23762     xmlChar * name; /* the attribute name */
23763     int n_name;
23764
23765     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
23766     for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
23767     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
23768         mem_base = xmlMemBlocks();
23769         node = gen_xmlNodePtr(n_node, 0);
23770         ns = gen_xmlNsPtr(n_ns, 1);
23771         name = gen_const_xmlChar_ptr(n_name, 2);
23772
23773         ret_val = xmlUnsetNsProp(node, ns, (const xmlChar *)name);
23774         desret_int(ret_val);
23775         call_tests++;
23776         des_xmlNodePtr(n_node, node, 0);
23777         des_xmlNsPtr(n_ns, ns, 1);
23778         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
23779         xmlResetLastError();
23780         if (mem_base != xmlMemBlocks()) {
23781             printf("Leak of %d blocks found in xmlUnsetNsProp",
23782                    xmlMemBlocks() - mem_base);
23783             test_ret++;
23784             printf(" %d", n_node);
23785             printf(" %d", n_ns);
23786             printf(" %d", n_name);
23787             printf("\n");
23788         }
23789     }
23790     }
23791     }
23792     function_tests++;
23793 #endif
23794
23795     return(test_ret);
23796 }
23797
23798
23799 static int
23800 test_xmlUnsetProp(void) {
23801     int test_ret = 0;
23802
23803 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
23804     int mem_base;
23805     int ret_val;
23806     xmlNodePtr node; /* the node */
23807     int n_node;
23808     xmlChar * name; /* the attribute name */
23809     int n_name;
23810
23811     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
23812     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
23813         mem_base = xmlMemBlocks();
23814         node = gen_xmlNodePtr(n_node, 0);
23815         name = gen_const_xmlChar_ptr(n_name, 1);
23816
23817         ret_val = xmlUnsetProp(node, (const xmlChar *)name);
23818         desret_int(ret_val);
23819         call_tests++;
23820         des_xmlNodePtr(n_node, node, 0);
23821         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
23822         xmlResetLastError();
23823         if (mem_base != xmlMemBlocks()) {
23824             printf("Leak of %d blocks found in xmlUnsetProp",
23825                    xmlMemBlocks() - mem_base);
23826             test_ret++;
23827             printf(" %d", n_node);
23828             printf(" %d", n_name);
23829             printf("\n");
23830         }
23831     }
23832     }
23833     function_tests++;
23834 #endif
23835
23836     return(test_ret);
23837 }
23838
23839
23840 static int
23841 test_xmlValidateNCName(void) {
23842     int test_ret = 0;
23843
23844 #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)
23845 #ifdef LIBXML_TREE_ENABLED
23846     int mem_base;
23847     int ret_val;
23848     xmlChar * value; /* the value to check */
23849     int n_value;
23850     int space; /* allow spaces in front and end of the string */
23851     int n_space;
23852
23853     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
23854     for (n_space = 0;n_space < gen_nb_int;n_space++) {
23855         mem_base = xmlMemBlocks();
23856         value = gen_const_xmlChar_ptr(n_value, 0);
23857         space = gen_int(n_space, 1);
23858
23859         ret_val = xmlValidateNCName((const xmlChar *)value, space);
23860         desret_int(ret_val);
23861         call_tests++;
23862         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
23863         des_int(n_space, space, 1);
23864         xmlResetLastError();
23865         if (mem_base != xmlMemBlocks()) {
23866             printf("Leak of %d blocks found in xmlValidateNCName",
23867                    xmlMemBlocks() - mem_base);
23868             test_ret++;
23869             printf(" %d", n_value);
23870             printf(" %d", n_space);
23871             printf("\n");
23872         }
23873     }
23874     }
23875     function_tests++;
23876 #endif
23877 #endif
23878
23879     return(test_ret);
23880 }
23881
23882
23883 static int
23884 test_xmlValidateNMToken(void) {
23885     int test_ret = 0;
23886
23887 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
23888 #ifdef LIBXML_TREE_ENABLED
23889     int mem_base;
23890     int ret_val;
23891     xmlChar * value; /* the value to check */
23892     int n_value;
23893     int space; /* allow spaces in front and end of the string */
23894     int n_space;
23895
23896     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
23897     for (n_space = 0;n_space < gen_nb_int;n_space++) {
23898         mem_base = xmlMemBlocks();
23899         value = gen_const_xmlChar_ptr(n_value, 0);
23900         space = gen_int(n_space, 1);
23901
23902         ret_val = xmlValidateNMToken((const xmlChar *)value, space);
23903         desret_int(ret_val);
23904         call_tests++;
23905         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
23906         des_int(n_space, space, 1);
23907         xmlResetLastError();
23908         if (mem_base != xmlMemBlocks()) {
23909             printf("Leak of %d blocks found in xmlValidateNMToken",
23910                    xmlMemBlocks() - mem_base);
23911             test_ret++;
23912             printf(" %d", n_value);
23913             printf(" %d", n_space);
23914             printf("\n");
23915         }
23916     }
23917     }
23918     function_tests++;
23919 #endif
23920 #endif
23921
23922     return(test_ret);
23923 }
23924
23925
23926 static int
23927 test_xmlValidateName(void) {
23928     int test_ret = 0;
23929
23930 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
23931 #ifdef LIBXML_TREE_ENABLED
23932     int mem_base;
23933     int ret_val;
23934     xmlChar * value; /* the value to check */
23935     int n_value;
23936     int space; /* allow spaces in front and end of the string */
23937     int n_space;
23938
23939     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
23940     for (n_space = 0;n_space < gen_nb_int;n_space++) {
23941         mem_base = xmlMemBlocks();
23942         value = gen_const_xmlChar_ptr(n_value, 0);
23943         space = gen_int(n_space, 1);
23944
23945         ret_val = xmlValidateName((const xmlChar *)value, space);
23946         desret_int(ret_val);
23947         call_tests++;
23948         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
23949         des_int(n_space, space, 1);
23950         xmlResetLastError();
23951         if (mem_base != xmlMemBlocks()) {
23952             printf("Leak of %d blocks found in xmlValidateName",
23953                    xmlMemBlocks() - mem_base);
23954             test_ret++;
23955             printf(" %d", n_value);
23956             printf(" %d", n_space);
23957             printf("\n");
23958         }
23959     }
23960     }
23961     function_tests++;
23962 #endif
23963 #endif
23964
23965     return(test_ret);
23966 }
23967
23968
23969 static int
23970 test_xmlValidateQName(void) {
23971     int test_ret = 0;
23972
23973 #if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
23974 #ifdef LIBXML_TREE_ENABLED
23975     int mem_base;
23976     int ret_val;
23977     xmlChar * value; /* the value to check */
23978     int n_value;
23979     int space; /* allow spaces in front and end of the string */
23980     int n_space;
23981
23982     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
23983     for (n_space = 0;n_space < gen_nb_int;n_space++) {
23984         mem_base = xmlMemBlocks();
23985         value = gen_const_xmlChar_ptr(n_value, 0);
23986         space = gen_int(n_space, 1);
23987
23988         ret_val = xmlValidateQName((const xmlChar *)value, space);
23989         desret_int(ret_val);
23990         call_tests++;
23991         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
23992         des_int(n_space, space, 1);
23993         xmlResetLastError();
23994         if (mem_base != xmlMemBlocks()) {
23995             printf("Leak of %d blocks found in xmlValidateQName",
23996                    xmlMemBlocks() - mem_base);
23997             test_ret++;
23998             printf(" %d", n_value);
23999             printf(" %d", n_space);
24000             printf("\n");
24001         }
24002     }
24003     }
24004     function_tests++;
24005 #endif
24006 #endif
24007
24008     return(test_ret);
24009 }
24010
24011 static int
24012 test_tree(void) {
24013     int test_ret = 0;
24014
24015     if (quiet == 0) printf("Testing tree : 138 of 157 functions ...\n");
24016     test_ret += test_xmlAddChild();
24017     test_ret += test_xmlAddChildList();
24018     test_ret += test_xmlAddNextSibling();
24019     test_ret += test_xmlAddPrevSibling();
24020     test_ret += test_xmlAddSibling();
24021     test_ret += test_xmlAttrSerializeTxtContent();
24022     test_ret += test_xmlBufferAdd();
24023     test_ret += test_xmlBufferAddHead();
24024     test_ret += test_xmlBufferCCat();
24025     test_ret += test_xmlBufferCat();
24026     test_ret += test_xmlBufferContent();
24027     test_ret += test_xmlBufferCreate();
24028     test_ret += test_xmlBufferCreateSize();
24029     test_ret += test_xmlBufferCreateStatic();
24030     test_ret += test_xmlBufferEmpty();
24031     test_ret += test_xmlBufferGrow();
24032     test_ret += test_xmlBufferLength();
24033     test_ret += test_xmlBufferResize();
24034     test_ret += test_xmlBufferSetAllocationScheme();
24035     test_ret += test_xmlBufferShrink();
24036     test_ret += test_xmlBufferWriteCHAR();
24037     test_ret += test_xmlBufferWriteChar();
24038     test_ret += test_xmlBufferWriteQuotedString();
24039     test_ret += test_xmlBuildQName();
24040     test_ret += test_xmlChildElementCount();
24041     test_ret += test_xmlCopyDoc();
24042     test_ret += test_xmlCopyDtd();
24043     test_ret += test_xmlCopyNamespace();
24044     test_ret += test_xmlCopyNamespaceList();
24045     test_ret += test_xmlCopyNode();
24046     test_ret += test_xmlCopyNodeList();
24047     test_ret += test_xmlCopyProp();
24048     test_ret += test_xmlCopyPropList();
24049     test_ret += test_xmlCreateIntSubset();
24050     test_ret += test_xmlDOMWrapAdoptNode();
24051     test_ret += test_xmlDOMWrapCloneNode();
24052     test_ret += test_xmlDOMWrapNewCtxt();
24053     test_ret += test_xmlDOMWrapReconcileNamespaces();
24054     test_ret += test_xmlDOMWrapRemoveNode();
24055     test_ret += test_xmlDocCopyNode();
24056     test_ret += test_xmlDocCopyNodeList();
24057     test_ret += test_xmlDocDump();
24058     test_ret += test_xmlDocDumpFormatMemory();
24059     test_ret += test_xmlDocDumpFormatMemoryEnc();
24060     test_ret += test_xmlDocDumpMemory();
24061     test_ret += test_xmlDocDumpMemoryEnc();
24062     test_ret += test_xmlDocFormatDump();
24063     test_ret += test_xmlDocGetRootElement();
24064     test_ret += test_xmlDocSetRootElement();
24065     test_ret += test_xmlElemDump();
24066     test_ret += test_xmlFirstElementChild();
24067     test_ret += test_xmlGetBufferAllocationScheme();
24068     test_ret += test_xmlGetCompressMode();
24069     test_ret += test_xmlGetDocCompressMode();
24070     test_ret += test_xmlGetIntSubset();
24071     test_ret += test_xmlGetLastChild();
24072     test_ret += test_xmlGetLineNo();
24073     test_ret += test_xmlGetNoNsProp();
24074     test_ret += test_xmlGetNodePath();
24075     test_ret += test_xmlGetNsList();
24076     test_ret += test_xmlGetNsProp();
24077     test_ret += test_xmlGetProp();
24078     test_ret += test_xmlHasNsProp();
24079     test_ret += test_xmlHasProp();
24080     test_ret += test_xmlIsBlankNode();
24081     test_ret += test_xmlIsXHTML();
24082     test_ret += test_xmlLastElementChild();
24083     test_ret += test_xmlNewCDataBlock();
24084     test_ret += test_xmlNewCharRef();
24085     test_ret += test_xmlNewChild();
24086     test_ret += test_xmlNewComment();
24087     test_ret += test_xmlNewDoc();
24088     test_ret += test_xmlNewDocComment();
24089     test_ret += test_xmlNewDocFragment();
24090     test_ret += test_xmlNewDocNode();
24091     test_ret += test_xmlNewDocNodeEatName();
24092     test_ret += test_xmlNewDocPI();
24093     test_ret += test_xmlNewDocProp();
24094     test_ret += test_xmlNewDocRawNode();
24095     test_ret += test_xmlNewDocText();
24096     test_ret += test_xmlNewDocTextLen();
24097     test_ret += test_xmlNewDtd();
24098     test_ret += test_xmlNewNode();
24099     test_ret += test_xmlNewNodeEatName();
24100     test_ret += test_xmlNewNs();
24101     test_ret += test_xmlNewNsProp();
24102     test_ret += test_xmlNewNsPropEatName();
24103     test_ret += test_xmlNewPI();
24104     test_ret += test_xmlNewProp();
24105     test_ret += test_xmlNewReference();
24106     test_ret += test_xmlNewText();
24107     test_ret += test_xmlNewTextChild();
24108     test_ret += test_xmlNewTextLen();
24109     test_ret += test_xmlNextElementSibling();
24110     test_ret += test_xmlNodeAddContent();
24111     test_ret += test_xmlNodeAddContentLen();
24112     test_ret += test_xmlNodeBufGetContent();
24113     test_ret += test_xmlNodeDump();
24114     test_ret += test_xmlNodeDumpOutput();
24115     test_ret += test_xmlNodeGetBase();
24116     test_ret += test_xmlNodeGetContent();
24117     test_ret += test_xmlNodeGetLang();
24118     test_ret += test_xmlNodeGetSpacePreserve();
24119     test_ret += test_xmlNodeIsText();
24120     test_ret += test_xmlNodeListGetRawString();
24121     test_ret += test_xmlNodeListGetString();
24122     test_ret += test_xmlNodeSetBase();
24123     test_ret += test_xmlNodeSetContent();
24124     test_ret += test_xmlNodeSetContentLen();
24125     test_ret += test_xmlNodeSetLang();
24126     test_ret += test_xmlNodeSetName();
24127     test_ret += test_xmlNodeSetSpacePreserve();
24128     test_ret += test_xmlPreviousElementSibling();
24129     test_ret += test_xmlReconciliateNs();
24130     test_ret += test_xmlRemoveProp();
24131     test_ret += test_xmlReplaceNode();
24132     test_ret += test_xmlSaveFile();
24133     test_ret += test_xmlSaveFileEnc();
24134     test_ret += test_xmlSaveFileTo();
24135     test_ret += test_xmlSaveFormatFile();
24136     test_ret += test_xmlSaveFormatFileEnc();
24137     test_ret += test_xmlSaveFormatFileTo();
24138     test_ret += test_xmlSearchNs();
24139     test_ret += test_xmlSearchNsByHref();
24140     test_ret += test_xmlSetBufferAllocationScheme();
24141     test_ret += test_xmlSetCompressMode();
24142     test_ret += test_xmlSetDocCompressMode();
24143     test_ret += test_xmlSetNs();
24144     test_ret += test_xmlSetNsProp();
24145     test_ret += test_xmlSetProp();
24146     test_ret += test_xmlSplitQName2();
24147     test_ret += test_xmlSplitQName3();
24148     test_ret += test_xmlStringGetNodeList();
24149     test_ret += test_xmlStringLenGetNodeList();
24150     test_ret += test_xmlTextConcat();
24151     test_ret += test_xmlTextMerge();
24152     test_ret += test_xmlUnsetNsProp();
24153     test_ret += test_xmlUnsetProp();
24154     test_ret += test_xmlValidateNCName();
24155     test_ret += test_xmlValidateNMToken();
24156     test_ret += test_xmlValidateName();
24157     test_ret += test_xmlValidateQName();
24158
24159     if (test_ret != 0)
24160         printf("Module tree: %d errors\n", test_ret);
24161     return(test_ret);
24162 }
24163
24164 static int
24165 test_xmlBuildRelativeURI(void) {
24166     int test_ret = 0;
24167
24168     int mem_base;
24169     xmlChar * ret_val;
24170     xmlChar * URI; /* the URI reference under consideration */
24171     int n_URI;
24172     xmlChar * base; /* the base value */
24173     int n_base;
24174
24175     for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
24176     for (n_base = 0;n_base < gen_nb_const_xmlChar_ptr;n_base++) {
24177         mem_base = xmlMemBlocks();
24178         URI = gen_const_xmlChar_ptr(n_URI, 0);
24179         base = gen_const_xmlChar_ptr(n_base, 1);
24180
24181         ret_val = xmlBuildRelativeURI((const xmlChar *)URI, (const xmlChar *)base);
24182         desret_xmlChar_ptr(ret_val);
24183         call_tests++;
24184         des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 0);
24185         des_const_xmlChar_ptr(n_base, (const xmlChar *)base, 1);
24186         xmlResetLastError();
24187         if (mem_base != xmlMemBlocks()) {
24188             printf("Leak of %d blocks found in xmlBuildRelativeURI",
24189                    xmlMemBlocks() - mem_base);
24190             test_ret++;
24191             printf(" %d", n_URI);
24192             printf(" %d", n_base);
24193             printf("\n");
24194         }
24195     }
24196     }
24197     function_tests++;
24198
24199     return(test_ret);
24200 }
24201
24202
24203 static int
24204 test_xmlBuildURI(void) {
24205     int test_ret = 0;
24206
24207     int mem_base;
24208     xmlChar * ret_val;
24209     xmlChar * URI; /* the URI instance found in the document */
24210     int n_URI;
24211     xmlChar * base; /* the base value */
24212     int n_base;
24213
24214     for (n_URI = 0;n_URI < gen_nb_const_xmlChar_ptr;n_URI++) {
24215     for (n_base = 0;n_base < gen_nb_const_xmlChar_ptr;n_base++) {
24216         mem_base = xmlMemBlocks();
24217         URI = gen_const_xmlChar_ptr(n_URI, 0);
24218         base = gen_const_xmlChar_ptr(n_base, 1);
24219
24220         ret_val = xmlBuildURI((const xmlChar *)URI, (const xmlChar *)base);
24221         desret_xmlChar_ptr(ret_val);
24222         call_tests++;
24223         des_const_xmlChar_ptr(n_URI, (const xmlChar *)URI, 0);
24224         des_const_xmlChar_ptr(n_base, (const xmlChar *)base, 1);
24225         xmlResetLastError();
24226         if (mem_base != xmlMemBlocks()) {
24227             printf("Leak of %d blocks found in xmlBuildURI",
24228                    xmlMemBlocks() - mem_base);
24229             test_ret++;
24230             printf(" %d", n_URI);
24231             printf(" %d", n_base);
24232             printf("\n");
24233         }
24234     }
24235     }
24236     function_tests++;
24237
24238     return(test_ret);
24239 }
24240
24241
24242 static int
24243 test_xmlCanonicPath(void) {
24244     int test_ret = 0;
24245
24246     int mem_base;
24247     xmlChar * ret_val;
24248     xmlChar * path; /* the resource locator in a filesystem notation */
24249     int n_path;
24250
24251     for (n_path = 0;n_path < gen_nb_const_xmlChar_ptr;n_path++) {
24252         mem_base = xmlMemBlocks();
24253         path = gen_const_xmlChar_ptr(n_path, 0);
24254
24255         ret_val = xmlCanonicPath((const xmlChar *)path);
24256         desret_xmlChar_ptr(ret_val);
24257         call_tests++;
24258         des_const_xmlChar_ptr(n_path, (const xmlChar *)path, 0);
24259         xmlResetLastError();
24260         if (mem_base != xmlMemBlocks()) {
24261             printf("Leak of %d blocks found in xmlCanonicPath",
24262                    xmlMemBlocks() - mem_base);
24263             test_ret++;
24264             printf(" %d", n_path);
24265             printf("\n");
24266         }
24267     }
24268     function_tests++;
24269
24270     return(test_ret);
24271 }
24272
24273
24274 static int
24275 test_xmlCreateURI(void) {
24276     int test_ret = 0;
24277
24278
24279     /* missing type support */
24280     return(test_ret);
24281 }
24282
24283
24284 static int
24285 test_xmlNormalizeURIPath(void) {
24286     int test_ret = 0;
24287
24288     int mem_base;
24289     int ret_val;
24290     char * path; /* pointer to the path string */
24291     int n_path;
24292
24293     for (n_path = 0;n_path < gen_nb_char_ptr;n_path++) {
24294         mem_base = xmlMemBlocks();
24295         path = gen_char_ptr(n_path, 0);
24296
24297         ret_val = xmlNormalizeURIPath(path);
24298         desret_int(ret_val);
24299         call_tests++;
24300         des_char_ptr(n_path, path, 0);
24301         xmlResetLastError();
24302         if (mem_base != xmlMemBlocks()) {
24303             printf("Leak of %d blocks found in xmlNormalizeURIPath",
24304                    xmlMemBlocks() - mem_base);
24305             test_ret++;
24306             printf(" %d", n_path);
24307             printf("\n");
24308         }
24309     }
24310     function_tests++;
24311
24312     return(test_ret);
24313 }
24314
24315
24316 static int
24317 test_xmlParseURI(void) {
24318     int test_ret = 0;
24319
24320
24321     /* missing type support */
24322     return(test_ret);
24323 }
24324
24325
24326 static int
24327 test_xmlParseURIRaw(void) {
24328     int test_ret = 0;
24329
24330
24331     /* missing type support */
24332     return(test_ret);
24333 }
24334
24335
24336 #define gen_nb_xmlURIPtr 1
24337 static xmlURIPtr gen_xmlURIPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24338     return(NULL);
24339 }
24340 static void des_xmlURIPtr(int no ATTRIBUTE_UNUSED, xmlURIPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24341 }
24342
24343 static int
24344 test_xmlParseURIReference(void) {
24345     int test_ret = 0;
24346
24347     int mem_base;
24348     int ret_val;
24349     xmlURIPtr uri; /* pointer to an URI structure */
24350     int n_uri;
24351     char * str; /* the string to analyze */
24352     int n_str;
24353
24354     for (n_uri = 0;n_uri < gen_nb_xmlURIPtr;n_uri++) {
24355     for (n_str = 0;n_str < gen_nb_const_char_ptr;n_str++) {
24356         mem_base = xmlMemBlocks();
24357         uri = gen_xmlURIPtr(n_uri, 0);
24358         str = gen_const_char_ptr(n_str, 1);
24359
24360         ret_val = xmlParseURIReference(uri, (const char *)str);
24361         desret_int(ret_val);
24362         call_tests++;
24363         des_xmlURIPtr(n_uri, uri, 0);
24364         des_const_char_ptr(n_str, (const char *)str, 1);
24365         xmlResetLastError();
24366         if (mem_base != xmlMemBlocks()) {
24367             printf("Leak of %d blocks found in xmlParseURIReference",
24368                    xmlMemBlocks() - mem_base);
24369             test_ret++;
24370             printf(" %d", n_uri);
24371             printf(" %d", n_str);
24372             printf("\n");
24373         }
24374     }
24375     }
24376     function_tests++;
24377
24378     return(test_ret);
24379 }
24380
24381
24382 static int
24383 test_xmlPathToURI(void) {
24384     int test_ret = 0;
24385
24386     int mem_base;
24387     xmlChar * ret_val;
24388     xmlChar * path; /* the resource locator in a filesystem notation */
24389     int n_path;
24390
24391     for (n_path = 0;n_path < gen_nb_const_xmlChar_ptr;n_path++) {
24392         mem_base = xmlMemBlocks();
24393         path = gen_const_xmlChar_ptr(n_path, 0);
24394
24395         ret_val = xmlPathToURI((const xmlChar *)path);
24396         desret_xmlChar_ptr(ret_val);
24397         call_tests++;
24398         des_const_xmlChar_ptr(n_path, (const xmlChar *)path, 0);
24399         xmlResetLastError();
24400         if (mem_base != xmlMemBlocks()) {
24401             printf("Leak of %d blocks found in xmlPathToURI",
24402                    xmlMemBlocks() - mem_base);
24403             test_ret++;
24404             printf(" %d", n_path);
24405             printf("\n");
24406         }
24407     }
24408     function_tests++;
24409
24410     return(test_ret);
24411 }
24412
24413
24414 static int
24415 test_xmlPrintURI(void) {
24416     int test_ret = 0;
24417
24418     int mem_base;
24419     FILE * stream; /* a FILE* for the output */
24420     int n_stream;
24421     xmlURIPtr uri; /* pointer to an xmlURI */
24422     int n_uri;
24423
24424     for (n_stream = 0;n_stream < gen_nb_FILE_ptr;n_stream++) {
24425     for (n_uri = 0;n_uri < gen_nb_xmlURIPtr;n_uri++) {
24426         mem_base = xmlMemBlocks();
24427         stream = gen_FILE_ptr(n_stream, 0);
24428         uri = gen_xmlURIPtr(n_uri, 1);
24429
24430         xmlPrintURI(stream, uri);
24431         call_tests++;
24432         des_FILE_ptr(n_stream, stream, 0);
24433         des_xmlURIPtr(n_uri, uri, 1);
24434         xmlResetLastError();
24435         if (mem_base != xmlMemBlocks()) {
24436             printf("Leak of %d blocks found in xmlPrintURI",
24437                    xmlMemBlocks() - mem_base);
24438             test_ret++;
24439             printf(" %d", n_stream);
24440             printf(" %d", n_uri);
24441             printf("\n");
24442         }
24443     }
24444     }
24445     function_tests++;
24446
24447     return(test_ret);
24448 }
24449
24450
24451 static int
24452 test_xmlSaveUri(void) {
24453     int test_ret = 0;
24454
24455     int mem_base;
24456     xmlChar * ret_val;
24457     xmlURIPtr uri; /* pointer to an xmlURI */
24458     int n_uri;
24459
24460     for (n_uri = 0;n_uri < gen_nb_xmlURIPtr;n_uri++) {
24461         mem_base = xmlMemBlocks();
24462         uri = gen_xmlURIPtr(n_uri, 0);
24463
24464         ret_val = xmlSaveUri(uri);
24465         desret_xmlChar_ptr(ret_val);
24466         call_tests++;
24467         des_xmlURIPtr(n_uri, uri, 0);
24468         xmlResetLastError();
24469         if (mem_base != xmlMemBlocks()) {
24470             printf("Leak of %d blocks found in xmlSaveUri",
24471                    xmlMemBlocks() - mem_base);
24472             test_ret++;
24473             printf(" %d", n_uri);
24474             printf("\n");
24475         }
24476     }
24477     function_tests++;
24478
24479     return(test_ret);
24480 }
24481
24482
24483 static int
24484 test_xmlURIEscape(void) {
24485     int test_ret = 0;
24486
24487     int mem_base;
24488     xmlChar * ret_val;
24489     xmlChar * str; /* the string of the URI to escape */
24490     int n_str;
24491
24492     for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
24493         mem_base = xmlMemBlocks();
24494         str = gen_const_xmlChar_ptr(n_str, 0);
24495
24496         ret_val = xmlURIEscape((const xmlChar *)str);
24497         desret_xmlChar_ptr(ret_val);
24498         call_tests++;
24499         des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
24500         xmlResetLastError();
24501         if (mem_base != xmlMemBlocks()) {
24502             printf("Leak of %d blocks found in xmlURIEscape",
24503                    xmlMemBlocks() - mem_base);
24504             test_ret++;
24505             printf(" %d", n_str);
24506             printf("\n");
24507         }
24508     }
24509     function_tests++;
24510
24511     return(test_ret);
24512 }
24513
24514
24515 static int
24516 test_xmlURIEscapeStr(void) {
24517     int test_ret = 0;
24518
24519     int mem_base;
24520     xmlChar * ret_val;
24521     xmlChar * str; /* string to escape */
24522     int n_str;
24523     xmlChar * list; /* exception list string of chars not to escape */
24524     int n_list;
24525
24526     for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
24527     for (n_list = 0;n_list < gen_nb_const_xmlChar_ptr;n_list++) {
24528         mem_base = xmlMemBlocks();
24529         str = gen_const_xmlChar_ptr(n_str, 0);
24530         list = gen_const_xmlChar_ptr(n_list, 1);
24531
24532         ret_val = xmlURIEscapeStr((const xmlChar *)str, (const xmlChar *)list);
24533         desret_xmlChar_ptr(ret_val);
24534         call_tests++;
24535         des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
24536         des_const_xmlChar_ptr(n_list, (const xmlChar *)list, 1);
24537         xmlResetLastError();
24538         if (mem_base != xmlMemBlocks()) {
24539             printf("Leak of %d blocks found in xmlURIEscapeStr",
24540                    xmlMemBlocks() - mem_base);
24541             test_ret++;
24542             printf(" %d", n_str);
24543             printf(" %d", n_list);
24544             printf("\n");
24545         }
24546     }
24547     }
24548     function_tests++;
24549
24550     return(test_ret);
24551 }
24552
24553
24554 static int
24555 test_xmlURIUnescapeString(void) {
24556     int test_ret = 0;
24557
24558
24559     /* missing type support */
24560     return(test_ret);
24561 }
24562
24563 static int
24564 test_uri(void) {
24565     int test_ret = 0;
24566
24567     if (quiet == 0) printf("Testing uri : 10 of 15 functions ...\n");
24568     test_ret += test_xmlBuildRelativeURI();
24569     test_ret += test_xmlBuildURI();
24570     test_ret += test_xmlCanonicPath();
24571     test_ret += test_xmlCreateURI();
24572     test_ret += test_xmlNormalizeURIPath();
24573     test_ret += test_xmlParseURI();
24574     test_ret += test_xmlParseURIRaw();
24575     test_ret += test_xmlParseURIReference();
24576     test_ret += test_xmlPathToURI();
24577     test_ret += test_xmlPrintURI();
24578     test_ret += test_xmlSaveUri();
24579     test_ret += test_xmlURIEscape();
24580     test_ret += test_xmlURIEscapeStr();
24581     test_ret += test_xmlURIUnescapeString();
24582
24583     if (test_ret != 0)
24584         printf("Module uri: %d errors\n", test_ret);
24585     return(test_ret);
24586 }
24587
24588 static int
24589 test_xmlAddAttributeDecl(void) {
24590     int test_ret = 0;
24591
24592     int mem_base;
24593     xmlAttributePtr ret_val;
24594     xmlValidCtxtPtr ctxt; /* the validation context */
24595     int n_ctxt;
24596     xmlDtdPtr dtd; /* pointer to the DTD */
24597     int n_dtd;
24598     xmlChar * elem; /* the element name */
24599     int n_elem;
24600     xmlChar * name; /* the attribute name */
24601     int n_name;
24602     xmlChar * ns; /* the attribute namespace prefix */
24603     int n_ns;
24604     xmlAttributeType type; /* the attribute type */
24605     int n_type;
24606     xmlAttributeDefault def; /* the attribute default type */
24607     int n_def;
24608     xmlChar * defaultValue; /* the attribute default value */
24609     int n_defaultValue;
24610     xmlEnumerationPtr tree; /* if it's an enumeration, the associated list */
24611     int n_tree;
24612
24613     for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
24614     for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
24615     for (n_elem = 0;n_elem < gen_nb_const_xmlChar_ptr;n_elem++) {
24616     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
24617     for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) {
24618     for (n_type = 0;n_type < gen_nb_xmlAttributeType;n_type++) {
24619     for (n_def = 0;n_def < gen_nb_xmlAttributeDefault;n_def++) {
24620     for (n_defaultValue = 0;n_defaultValue < gen_nb_const_xmlChar_ptr;n_defaultValue++) {
24621     for (n_tree = 0;n_tree < gen_nb_xmlEnumerationPtr;n_tree++) {
24622         mem_base = xmlMemBlocks();
24623         ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
24624         dtd = gen_xmlDtdPtr(n_dtd, 1);
24625         elem = gen_const_xmlChar_ptr(n_elem, 2);
24626         name = gen_const_xmlChar_ptr(n_name, 3);
24627         ns = gen_const_xmlChar_ptr(n_ns, 4);
24628         type = gen_xmlAttributeType(n_type, 5);
24629         def = gen_xmlAttributeDefault(n_def, 6);
24630         defaultValue = gen_const_xmlChar_ptr(n_defaultValue, 7);
24631         tree = gen_xmlEnumerationPtr(n_tree, 8);
24632
24633         ret_val = xmlAddAttributeDecl(ctxt, dtd, (const xmlChar *)elem, (const xmlChar *)name, (const xmlChar *)ns, type, def, (const xmlChar *)defaultValue, tree);
24634         desret_xmlAttributePtr(ret_val);
24635         call_tests++;
24636         des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
24637         des_xmlDtdPtr(n_dtd, dtd, 1);
24638         des_const_xmlChar_ptr(n_elem, (const xmlChar *)elem, 2);
24639         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 3);
24640         des_const_xmlChar_ptr(n_ns, (const xmlChar *)ns, 4);
24641         des_xmlAttributeType(n_type, type, 5);
24642         des_xmlAttributeDefault(n_def, def, 6);
24643         des_const_xmlChar_ptr(n_defaultValue, (const xmlChar *)defaultValue, 7);
24644         des_xmlEnumerationPtr(n_tree, tree, 8);
24645         xmlResetLastError();
24646         if (mem_base != xmlMemBlocks()) {
24647             printf("Leak of %d blocks found in xmlAddAttributeDecl",
24648                    xmlMemBlocks() - mem_base);
24649             test_ret++;
24650             printf(" %d", n_ctxt);
24651             printf(" %d", n_dtd);
24652             printf(" %d", n_elem);
24653             printf(" %d", n_name);
24654             printf(" %d", n_ns);
24655             printf(" %d", n_type);
24656             printf(" %d", n_def);
24657             printf(" %d", n_defaultValue);
24658             printf(" %d", n_tree);
24659             printf("\n");
24660         }
24661     }
24662     }
24663     }
24664     }
24665     }
24666     }
24667     }
24668     }
24669     }
24670     function_tests++;
24671
24672     return(test_ret);
24673 }
24674
24675
24676 static int
24677 test_xmlAddElementDecl(void) {
24678     int test_ret = 0;
24679
24680     int mem_base;
24681     xmlElementPtr ret_val;
24682     xmlValidCtxtPtr ctxt; /* the validation context */
24683     int n_ctxt;
24684     xmlDtdPtr dtd; /* pointer to the DTD */
24685     int n_dtd;
24686     xmlChar * name; /* the entity name */
24687     int n_name;
24688     xmlElementTypeVal type; /* the element type */
24689     int n_type;
24690     xmlElementContentPtr content; /* the element content tree or NULL */
24691     int n_content;
24692
24693     for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
24694     for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
24695     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
24696     for (n_type = 0;n_type < gen_nb_xmlElementTypeVal;n_type++) {
24697     for (n_content = 0;n_content < gen_nb_xmlElementContentPtr;n_content++) {
24698         mem_base = xmlMemBlocks();
24699         ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
24700         dtd = gen_xmlDtdPtr(n_dtd, 1);
24701         name = gen_const_xmlChar_ptr(n_name, 2);
24702         type = gen_xmlElementTypeVal(n_type, 3);
24703         content = gen_xmlElementContentPtr(n_content, 4);
24704
24705         ret_val = xmlAddElementDecl(ctxt, dtd, (const xmlChar *)name, type, content);
24706         desret_xmlElementPtr(ret_val);
24707         call_tests++;
24708         des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
24709         des_xmlDtdPtr(n_dtd, dtd, 1);
24710         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
24711         des_xmlElementTypeVal(n_type, type, 3);
24712         des_xmlElementContentPtr(n_content, content, 4);
24713         xmlResetLastError();
24714         if (mem_base != xmlMemBlocks()) {
24715             printf("Leak of %d blocks found in xmlAddElementDecl",
24716                    xmlMemBlocks() - mem_base);
24717             test_ret++;
24718             printf(" %d", n_ctxt);
24719             printf(" %d", n_dtd);
24720             printf(" %d", n_name);
24721             printf(" %d", n_type);
24722             printf(" %d", n_content);
24723             printf("\n");
24724         }
24725     }
24726     }
24727     }
24728     }
24729     }
24730     function_tests++;
24731
24732     return(test_ret);
24733 }
24734
24735
24736 static int
24737 test_xmlAddID(void) {
24738     int test_ret = 0;
24739
24740
24741     /* missing type support */
24742     return(test_ret);
24743 }
24744
24745
24746 static int
24747 test_xmlAddNotationDecl(void) {
24748     int test_ret = 0;
24749
24750
24751     /* missing type support */
24752     return(test_ret);
24753 }
24754
24755
24756 static int
24757 test_xmlAddRef(void) {
24758     int test_ret = 0;
24759
24760
24761     /* missing type support */
24762     return(test_ret);
24763 }
24764
24765
24766 #define gen_nb_xmlAttributeTablePtr 1
24767 static xmlAttributeTablePtr gen_xmlAttributeTablePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24768     return(NULL);
24769 }
24770 static void des_xmlAttributeTablePtr(int no ATTRIBUTE_UNUSED, xmlAttributeTablePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24771 }
24772
24773 static int
24774 test_xmlCopyAttributeTable(void) {
24775     int test_ret = 0;
24776
24777
24778     /* missing type support */
24779     return(test_ret);
24780 }
24781
24782
24783 static int
24784 test_xmlCopyDocElementContent(void) {
24785     int test_ret = 0;
24786
24787     int mem_base;
24788     xmlElementContentPtr ret_val;
24789     xmlDocPtr doc; /* the document owning the element declaration */
24790     int n_doc;
24791     xmlElementContentPtr cur; /* An element content pointer. */
24792     int n_cur;
24793
24794     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
24795     for (n_cur = 0;n_cur < gen_nb_xmlElementContentPtr;n_cur++) {
24796         mem_base = xmlMemBlocks();
24797         doc = gen_xmlDocPtr(n_doc, 0);
24798         cur = gen_xmlElementContentPtr(n_cur, 1);
24799
24800         ret_val = xmlCopyDocElementContent(doc, cur);
24801         desret_xmlElementContentPtr(ret_val);
24802         call_tests++;
24803         des_xmlDocPtr(n_doc, doc, 0);
24804         des_xmlElementContentPtr(n_cur, cur, 1);
24805         xmlResetLastError();
24806         if (mem_base != xmlMemBlocks()) {
24807             printf("Leak of %d blocks found in xmlCopyDocElementContent",
24808                    xmlMemBlocks() - mem_base);
24809             test_ret++;
24810             printf(" %d", n_doc);
24811             printf(" %d", n_cur);
24812             printf("\n");
24813         }
24814     }
24815     }
24816     function_tests++;
24817
24818     return(test_ret);
24819 }
24820
24821
24822 static int
24823 test_xmlCopyElementContent(void) {
24824     int test_ret = 0;
24825
24826     int mem_base;
24827     xmlElementContentPtr ret_val;
24828     xmlElementContentPtr cur; /* An element content pointer. */
24829     int n_cur;
24830
24831     for (n_cur = 0;n_cur < gen_nb_xmlElementContentPtr;n_cur++) {
24832         mem_base = xmlMemBlocks();
24833         cur = gen_xmlElementContentPtr(n_cur, 0);
24834
24835         ret_val = xmlCopyElementContent(cur);
24836         desret_xmlElementContentPtr(ret_val);
24837         call_tests++;
24838         des_xmlElementContentPtr(n_cur, cur, 0);
24839         xmlResetLastError();
24840         if (mem_base != xmlMemBlocks()) {
24841             printf("Leak of %d blocks found in xmlCopyElementContent",
24842                    xmlMemBlocks() - mem_base);
24843             test_ret++;
24844             printf(" %d", n_cur);
24845             printf("\n");
24846         }
24847     }
24848     function_tests++;
24849
24850     return(test_ret);
24851 }
24852
24853
24854 #define gen_nb_xmlElementTablePtr 1
24855 static xmlElementTablePtr gen_xmlElementTablePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24856     return(NULL);
24857 }
24858 static void des_xmlElementTablePtr(int no ATTRIBUTE_UNUSED, xmlElementTablePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24859 }
24860
24861 static int
24862 test_xmlCopyElementTable(void) {
24863     int test_ret = 0;
24864
24865
24866     /* missing type support */
24867     return(test_ret);
24868 }
24869
24870
24871 static int
24872 test_xmlCopyEnumeration(void) {
24873     int test_ret = 0;
24874
24875
24876     /* missing type support */
24877     return(test_ret);
24878 }
24879
24880
24881 #define gen_nb_xmlNotationTablePtr 1
24882 static xmlNotationTablePtr gen_xmlNotationTablePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24883     return(NULL);
24884 }
24885 static void des_xmlNotationTablePtr(int no ATTRIBUTE_UNUSED, xmlNotationTablePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24886 }
24887
24888 static int
24889 test_xmlCopyNotationTable(void) {
24890     int test_ret = 0;
24891
24892
24893     /* missing type support */
24894     return(test_ret);
24895 }
24896
24897
24898 static int
24899 test_xmlCreateEnumeration(void) {
24900     int test_ret = 0;
24901
24902
24903     /* missing type support */
24904     return(test_ret);
24905 }
24906
24907
24908 #define gen_nb_xmlAttributePtr 1
24909 static xmlAttributePtr gen_xmlAttributePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24910     return(NULL);
24911 }
24912 static void des_xmlAttributePtr(int no ATTRIBUTE_UNUSED, xmlAttributePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24913 }
24914
24915 static int
24916 test_xmlDumpAttributeDecl(void) {
24917     int test_ret = 0;
24918
24919 #if defined(LIBXML_OUTPUT_ENABLED)
24920     int mem_base;
24921     xmlBufferPtr buf; /* the XML buffer output */
24922     int n_buf;
24923     xmlAttributePtr attr; /* An attribute declaration */
24924     int n_attr;
24925
24926     for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
24927     for (n_attr = 0;n_attr < gen_nb_xmlAttributePtr;n_attr++) {
24928         mem_base = xmlMemBlocks();
24929         buf = gen_xmlBufferPtr(n_buf, 0);
24930         attr = gen_xmlAttributePtr(n_attr, 1);
24931
24932         xmlDumpAttributeDecl(buf, attr);
24933         call_tests++;
24934         des_xmlBufferPtr(n_buf, buf, 0);
24935         des_xmlAttributePtr(n_attr, attr, 1);
24936         xmlResetLastError();
24937         if (mem_base != xmlMemBlocks()) {
24938             printf("Leak of %d blocks found in xmlDumpAttributeDecl",
24939                    xmlMemBlocks() - mem_base);
24940             test_ret++;
24941             printf(" %d", n_buf);
24942             printf(" %d", n_attr);
24943             printf("\n");
24944         }
24945     }
24946     }
24947     function_tests++;
24948 #endif
24949
24950     return(test_ret);
24951 }
24952
24953
24954 static int
24955 test_xmlDumpAttributeTable(void) {
24956     int test_ret = 0;
24957
24958 #if defined(LIBXML_OUTPUT_ENABLED)
24959     int mem_base;
24960     xmlBufferPtr buf; /* the XML buffer output */
24961     int n_buf;
24962     xmlAttributeTablePtr table; /* An attribute table */
24963     int n_table;
24964
24965     for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
24966     for (n_table = 0;n_table < gen_nb_xmlAttributeTablePtr;n_table++) {
24967         mem_base = xmlMemBlocks();
24968         buf = gen_xmlBufferPtr(n_buf, 0);
24969         table = gen_xmlAttributeTablePtr(n_table, 1);
24970
24971         xmlDumpAttributeTable(buf, table);
24972         call_tests++;
24973         des_xmlBufferPtr(n_buf, buf, 0);
24974         des_xmlAttributeTablePtr(n_table, table, 1);
24975         xmlResetLastError();
24976         if (mem_base != xmlMemBlocks()) {
24977             printf("Leak of %d blocks found in xmlDumpAttributeTable",
24978                    xmlMemBlocks() - mem_base);
24979             test_ret++;
24980             printf(" %d", n_buf);
24981             printf(" %d", n_table);
24982             printf("\n");
24983         }
24984     }
24985     }
24986     function_tests++;
24987 #endif
24988
24989     return(test_ret);
24990 }
24991
24992
24993 #define gen_nb_xmlElementPtr 1
24994 static xmlElementPtr gen_xmlElementPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24995     return(NULL);
24996 }
24997 static void des_xmlElementPtr(int no ATTRIBUTE_UNUSED, xmlElementPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
24998 }
24999
25000 static int
25001 test_xmlDumpElementDecl(void) {
25002     int test_ret = 0;
25003
25004 #if defined(LIBXML_OUTPUT_ENABLED)
25005     int mem_base;
25006     xmlBufferPtr buf; /* the XML buffer output */
25007     int n_buf;
25008     xmlElementPtr elem; /* An element table */
25009     int n_elem;
25010
25011     for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
25012     for (n_elem = 0;n_elem < gen_nb_xmlElementPtr;n_elem++) {
25013         mem_base = xmlMemBlocks();
25014         buf = gen_xmlBufferPtr(n_buf, 0);
25015         elem = gen_xmlElementPtr(n_elem, 1);
25016
25017         xmlDumpElementDecl(buf, elem);
25018         call_tests++;
25019         des_xmlBufferPtr(n_buf, buf, 0);
25020         des_xmlElementPtr(n_elem, elem, 1);
25021         xmlResetLastError();
25022         if (mem_base != xmlMemBlocks()) {
25023             printf("Leak of %d blocks found in xmlDumpElementDecl",
25024                    xmlMemBlocks() - mem_base);
25025             test_ret++;
25026             printf(" %d", n_buf);
25027             printf(" %d", n_elem);
25028             printf("\n");
25029         }
25030     }
25031     }
25032     function_tests++;
25033 #endif
25034
25035     return(test_ret);
25036 }
25037
25038
25039 static int
25040 test_xmlDumpElementTable(void) {
25041     int test_ret = 0;
25042
25043 #if defined(LIBXML_OUTPUT_ENABLED)
25044     int mem_base;
25045     xmlBufferPtr buf; /* the XML buffer output */
25046     int n_buf;
25047     xmlElementTablePtr table; /* An element table */
25048     int n_table;
25049
25050     for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
25051     for (n_table = 0;n_table < gen_nb_xmlElementTablePtr;n_table++) {
25052         mem_base = xmlMemBlocks();
25053         buf = gen_xmlBufferPtr(n_buf, 0);
25054         table = gen_xmlElementTablePtr(n_table, 1);
25055
25056         xmlDumpElementTable(buf, table);
25057         call_tests++;
25058         des_xmlBufferPtr(n_buf, buf, 0);
25059         des_xmlElementTablePtr(n_table, table, 1);
25060         xmlResetLastError();
25061         if (mem_base != xmlMemBlocks()) {
25062             printf("Leak of %d blocks found in xmlDumpElementTable",
25063                    xmlMemBlocks() - mem_base);
25064             test_ret++;
25065             printf(" %d", n_buf);
25066             printf(" %d", n_table);
25067             printf("\n");
25068         }
25069     }
25070     }
25071     function_tests++;
25072 #endif
25073
25074     return(test_ret);
25075 }
25076
25077
25078 #define gen_nb_xmlNotationPtr 1
25079 static xmlNotationPtr gen_xmlNotationPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
25080     return(NULL);
25081 }
25082 static void des_xmlNotationPtr(int no ATTRIBUTE_UNUSED, xmlNotationPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
25083 }
25084
25085 static int
25086 test_xmlDumpNotationDecl(void) {
25087     int test_ret = 0;
25088
25089 #if defined(LIBXML_OUTPUT_ENABLED)
25090     int mem_base;
25091     xmlBufferPtr buf; /* the XML buffer output */
25092     int n_buf;
25093     xmlNotationPtr nota; /* A notation declaration */
25094     int n_nota;
25095
25096     for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
25097     for (n_nota = 0;n_nota < gen_nb_xmlNotationPtr;n_nota++) {
25098         mem_base = xmlMemBlocks();
25099         buf = gen_xmlBufferPtr(n_buf, 0);
25100         nota = gen_xmlNotationPtr(n_nota, 1);
25101
25102         xmlDumpNotationDecl(buf, nota);
25103         call_tests++;
25104         des_xmlBufferPtr(n_buf, buf, 0);
25105         des_xmlNotationPtr(n_nota, nota, 1);
25106         xmlResetLastError();
25107         if (mem_base != xmlMemBlocks()) {
25108             printf("Leak of %d blocks found in xmlDumpNotationDecl",
25109                    xmlMemBlocks() - mem_base);
25110             test_ret++;
25111             printf(" %d", n_buf);
25112             printf(" %d", n_nota);
25113             printf("\n");
25114         }
25115     }
25116     }
25117     function_tests++;
25118 #endif
25119
25120     return(test_ret);
25121 }
25122
25123
25124 static int
25125 test_xmlDumpNotationTable(void) {
25126     int test_ret = 0;
25127
25128 #if defined(LIBXML_OUTPUT_ENABLED)
25129     int mem_base;
25130     xmlBufferPtr buf; /* the XML buffer output */
25131     int n_buf;
25132     xmlNotationTablePtr table; /* A notation table */
25133     int n_table;
25134
25135     for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
25136     for (n_table = 0;n_table < gen_nb_xmlNotationTablePtr;n_table++) {
25137         mem_base = xmlMemBlocks();
25138         buf = gen_xmlBufferPtr(n_buf, 0);
25139         table = gen_xmlNotationTablePtr(n_table, 1);
25140
25141         xmlDumpNotationTable(buf, table);
25142         call_tests++;
25143         des_xmlBufferPtr(n_buf, buf, 0);
25144         des_xmlNotationTablePtr(n_table, table, 1);
25145         xmlResetLastError();
25146         if (mem_base != xmlMemBlocks()) {
25147             printf("Leak of %d blocks found in xmlDumpNotationTable",
25148                    xmlMemBlocks() - mem_base);
25149             test_ret++;
25150             printf(" %d", n_buf);
25151             printf(" %d", n_table);
25152             printf("\n");
25153         }
25154     }
25155     }
25156     function_tests++;
25157 #endif
25158
25159     return(test_ret);
25160 }
25161
25162
25163 static int
25164 test_xmlGetDtdAttrDesc(void) {
25165     int test_ret = 0;
25166
25167     int mem_base;
25168     xmlAttributePtr ret_val;
25169     xmlDtdPtr dtd; /* a pointer to the DtD to search */
25170     int n_dtd;
25171     xmlChar * elem; /* the element name */
25172     int n_elem;
25173     xmlChar * name; /* the attribute name */
25174     int n_name;
25175
25176     for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
25177     for (n_elem = 0;n_elem < gen_nb_const_xmlChar_ptr;n_elem++) {
25178     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
25179         mem_base = xmlMemBlocks();
25180         dtd = gen_xmlDtdPtr(n_dtd, 0);
25181         elem = gen_const_xmlChar_ptr(n_elem, 1);
25182         name = gen_const_xmlChar_ptr(n_name, 2);
25183
25184         ret_val = xmlGetDtdAttrDesc(dtd, (const xmlChar *)elem, (const xmlChar *)name);
25185         desret_xmlAttributePtr(ret_val);
25186         call_tests++;
25187         des_xmlDtdPtr(n_dtd, dtd, 0);
25188         des_const_xmlChar_ptr(n_elem, (const xmlChar *)elem, 1);
25189         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
25190         xmlResetLastError();
25191         if (mem_base != xmlMemBlocks()) {
25192             printf("Leak of %d blocks found in xmlGetDtdAttrDesc",
25193                    xmlMemBlocks() - mem_base);
25194             test_ret++;
25195             printf(" %d", n_dtd);
25196             printf(" %d", n_elem);
25197             printf(" %d", n_name);
25198             printf("\n");
25199         }
25200     }
25201     }
25202     }
25203     function_tests++;
25204
25205     return(test_ret);
25206 }
25207
25208
25209 static int
25210 test_xmlGetDtdElementDesc(void) {
25211     int test_ret = 0;
25212
25213     int mem_base;
25214     xmlElementPtr ret_val;
25215     xmlDtdPtr dtd; /* a pointer to the DtD to search */
25216     int n_dtd;
25217     xmlChar * name; /* the element name */
25218     int n_name;
25219
25220     for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
25221     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
25222         mem_base = xmlMemBlocks();
25223         dtd = gen_xmlDtdPtr(n_dtd, 0);
25224         name = gen_const_xmlChar_ptr(n_name, 1);
25225
25226         ret_val = xmlGetDtdElementDesc(dtd, (const xmlChar *)name);
25227         desret_xmlElementPtr(ret_val);
25228         call_tests++;
25229         des_xmlDtdPtr(n_dtd, dtd, 0);
25230         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
25231         xmlResetLastError();
25232         if (mem_base != xmlMemBlocks()) {
25233             printf("Leak of %d blocks found in xmlGetDtdElementDesc",
25234                    xmlMemBlocks() - mem_base);
25235             test_ret++;
25236             printf(" %d", n_dtd);
25237             printf(" %d", n_name);
25238             printf("\n");
25239         }
25240     }
25241     }
25242     function_tests++;
25243
25244     return(test_ret);
25245 }
25246
25247
25248 static int
25249 test_xmlGetDtdNotationDesc(void) {
25250     int test_ret = 0;
25251
25252
25253     /* missing type support */
25254     return(test_ret);
25255 }
25256
25257
25258 static int
25259 test_xmlGetDtdQAttrDesc(void) {
25260     int test_ret = 0;
25261
25262     int mem_base;
25263     xmlAttributePtr ret_val;
25264     xmlDtdPtr dtd; /* a pointer to the DtD to search */
25265     int n_dtd;
25266     xmlChar * elem; /* the element name */
25267     int n_elem;
25268     xmlChar * name; /* the attribute name */
25269     int n_name;
25270     xmlChar * prefix; /* the attribute namespace prefix */
25271     int n_prefix;
25272
25273     for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
25274     for (n_elem = 0;n_elem < gen_nb_const_xmlChar_ptr;n_elem++) {
25275     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
25276     for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
25277         mem_base = xmlMemBlocks();
25278         dtd = gen_xmlDtdPtr(n_dtd, 0);
25279         elem = gen_const_xmlChar_ptr(n_elem, 1);
25280         name = gen_const_xmlChar_ptr(n_name, 2);
25281         prefix = gen_const_xmlChar_ptr(n_prefix, 3);
25282
25283         ret_val = xmlGetDtdQAttrDesc(dtd, (const xmlChar *)elem, (const xmlChar *)name, (const xmlChar *)prefix);
25284         desret_xmlAttributePtr(ret_val);
25285         call_tests++;
25286         des_xmlDtdPtr(n_dtd, dtd, 0);
25287         des_const_xmlChar_ptr(n_elem, (const xmlChar *)elem, 1);
25288         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
25289         des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 3);
25290         xmlResetLastError();
25291         if (mem_base != xmlMemBlocks()) {
25292             printf("Leak of %d blocks found in xmlGetDtdQAttrDesc",
25293                    xmlMemBlocks() - mem_base);
25294             test_ret++;
25295             printf(" %d", n_dtd);
25296             printf(" %d", n_elem);
25297             printf(" %d", n_name);
25298             printf(" %d", n_prefix);
25299             printf("\n");
25300         }
25301     }
25302     }
25303     }
25304     }
25305     function_tests++;
25306
25307     return(test_ret);
25308 }
25309
25310
25311 static int
25312 test_xmlGetDtdQElementDesc(void) {
25313     int test_ret = 0;
25314
25315     int mem_base;
25316     xmlElementPtr ret_val;
25317     xmlDtdPtr dtd; /* a pointer to the DtD to search */
25318     int n_dtd;
25319     xmlChar * name; /* the element name */
25320     int n_name;
25321     xmlChar * prefix; /* the element namespace prefix */
25322     int n_prefix;
25323
25324     for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
25325     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
25326     for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
25327         mem_base = xmlMemBlocks();
25328         dtd = gen_xmlDtdPtr(n_dtd, 0);
25329         name = gen_const_xmlChar_ptr(n_name, 1);
25330         prefix = gen_const_xmlChar_ptr(n_prefix, 2);
25331
25332         ret_val = xmlGetDtdQElementDesc(dtd, (const xmlChar *)name, (const xmlChar *)prefix);
25333         desret_xmlElementPtr(ret_val);
25334         call_tests++;
25335         des_xmlDtdPtr(n_dtd, dtd, 0);
25336         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
25337         des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 2);
25338         xmlResetLastError();
25339         if (mem_base != xmlMemBlocks()) {
25340             printf("Leak of %d blocks found in xmlGetDtdQElementDesc",
25341                    xmlMemBlocks() - mem_base);
25342             test_ret++;
25343             printf(" %d", n_dtd);
25344             printf(" %d", n_name);
25345             printf(" %d", n_prefix);
25346             printf("\n");
25347         }
25348     }
25349     }
25350     }
25351     function_tests++;
25352
25353     return(test_ret);
25354 }
25355
25356
25357 static int
25358 test_xmlGetID(void) {
25359     int test_ret = 0;
25360
25361     int mem_base;
25362     xmlAttrPtr ret_val;
25363     xmlDocPtr doc; /* pointer to the document */
25364     int n_doc;
25365     xmlChar * ID; /* the ID value */
25366     int n_ID;
25367
25368     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
25369     for (n_ID = 0;n_ID < gen_nb_const_xmlChar_ptr;n_ID++) {
25370         mem_base = xmlMemBlocks();
25371         doc = gen_xmlDocPtr(n_doc, 0);
25372         ID = gen_const_xmlChar_ptr(n_ID, 1);
25373
25374         ret_val = xmlGetID(doc, (const xmlChar *)ID);
25375         desret_xmlAttrPtr(ret_val);
25376         call_tests++;
25377         des_xmlDocPtr(n_doc, doc, 0);
25378         des_const_xmlChar_ptr(n_ID, (const xmlChar *)ID, 1);
25379         xmlResetLastError();
25380         if (mem_base != xmlMemBlocks()) {
25381             printf("Leak of %d blocks found in xmlGetID",
25382                    xmlMemBlocks() - mem_base);
25383             test_ret++;
25384             printf(" %d", n_doc);
25385             printf(" %d", n_ID);
25386             printf("\n");
25387         }
25388     }
25389     }
25390     function_tests++;
25391
25392     return(test_ret);
25393 }
25394
25395
25396 static int
25397 test_xmlGetRefs(void) {
25398     int test_ret = 0;
25399
25400
25401     /* missing type support */
25402     return(test_ret);
25403 }
25404
25405
25406 static int
25407 test_xmlIsID(void) {
25408     int test_ret = 0;
25409
25410     int mem_base;
25411     int ret_val;
25412     xmlDocPtr doc; /* the document */
25413     int n_doc;
25414     xmlNodePtr elem; /* the element carrying the attribute */
25415     int n_elem;
25416     xmlAttrPtr attr; /* the attribute */
25417     int n_attr;
25418
25419     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
25420     for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
25421     for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
25422         mem_base = xmlMemBlocks();
25423         doc = gen_xmlDocPtr(n_doc, 0);
25424         elem = gen_xmlNodePtr(n_elem, 1);
25425         attr = gen_xmlAttrPtr(n_attr, 2);
25426
25427         ret_val = xmlIsID(doc, elem, attr);
25428         desret_int(ret_val);
25429         call_tests++;
25430         des_xmlDocPtr(n_doc, doc, 0);
25431         des_xmlNodePtr(n_elem, elem, 1);
25432         des_xmlAttrPtr(n_attr, attr, 2);
25433         xmlResetLastError();
25434         if (mem_base != xmlMemBlocks()) {
25435             printf("Leak of %d blocks found in xmlIsID",
25436                    xmlMemBlocks() - mem_base);
25437             test_ret++;
25438             printf(" %d", n_doc);
25439             printf(" %d", n_elem);
25440             printf(" %d", n_attr);
25441             printf("\n");
25442         }
25443     }
25444     }
25445     }
25446     function_tests++;
25447
25448     return(test_ret);
25449 }
25450
25451
25452 static int
25453 test_xmlIsMixedElement(void) {
25454     int test_ret = 0;
25455
25456     int mem_base;
25457     int ret_val;
25458     xmlDocPtr doc; /* the document */
25459     int n_doc;
25460     xmlChar * name; /* the element name */
25461     int n_name;
25462
25463     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
25464     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
25465         mem_base = xmlMemBlocks();
25466         doc = gen_xmlDocPtr(n_doc, 0);
25467         name = gen_const_xmlChar_ptr(n_name, 1);
25468
25469         ret_val = xmlIsMixedElement(doc, (const xmlChar *)name);
25470         desret_int(ret_val);
25471         call_tests++;
25472         des_xmlDocPtr(n_doc, doc, 0);
25473         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
25474         xmlResetLastError();
25475         if (mem_base != xmlMemBlocks()) {
25476             printf("Leak of %d blocks found in xmlIsMixedElement",
25477                    xmlMemBlocks() - mem_base);
25478             test_ret++;
25479             printf(" %d", n_doc);
25480             printf(" %d", n_name);
25481             printf("\n");
25482         }
25483     }
25484     }
25485     function_tests++;
25486
25487     return(test_ret);
25488 }
25489
25490
25491 static int
25492 test_xmlIsRef(void) {
25493     int test_ret = 0;
25494
25495     int mem_base;
25496     int ret_val;
25497     xmlDocPtr doc; /* the document */
25498     int n_doc;
25499     xmlNodePtr elem; /* the element carrying the attribute */
25500     int n_elem;
25501     xmlAttrPtr attr; /* the attribute */
25502     int n_attr;
25503
25504     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
25505     for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
25506     for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
25507         mem_base = xmlMemBlocks();
25508         doc = gen_xmlDocPtr(n_doc, 0);
25509         elem = gen_xmlNodePtr(n_elem, 1);
25510         attr = gen_xmlAttrPtr(n_attr, 2);
25511
25512         ret_val = xmlIsRef(doc, elem, attr);
25513         desret_int(ret_val);
25514         call_tests++;
25515         des_xmlDocPtr(n_doc, doc, 0);
25516         des_xmlNodePtr(n_elem, elem, 1);
25517         des_xmlAttrPtr(n_attr, attr, 2);
25518         xmlResetLastError();
25519         if (mem_base != xmlMemBlocks()) {
25520             printf("Leak of %d blocks found in xmlIsRef",
25521                    xmlMemBlocks() - mem_base);
25522             test_ret++;
25523             printf(" %d", n_doc);
25524             printf(" %d", n_elem);
25525             printf(" %d", n_attr);
25526             printf("\n");
25527         }
25528     }
25529     }
25530     }
25531     function_tests++;
25532
25533     return(test_ret);
25534 }
25535
25536
25537 static int
25538 test_xmlNewDocElementContent(void) {
25539     int test_ret = 0;
25540
25541     int mem_base;
25542     xmlElementContentPtr ret_val;
25543     xmlDocPtr doc; /* the document */
25544     int n_doc;
25545     xmlChar * name; /* the subelement name or NULL */
25546     int n_name;
25547     xmlElementContentType type; /* the type of element content decl */
25548     int n_type;
25549
25550     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
25551     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
25552     for (n_type = 0;n_type < gen_nb_xmlElementContentType;n_type++) {
25553         mem_base = xmlMemBlocks();
25554         doc = gen_xmlDocPtr(n_doc, 0);
25555         name = gen_const_xmlChar_ptr(n_name, 1);
25556         type = gen_xmlElementContentType(n_type, 2);
25557
25558         ret_val = xmlNewDocElementContent(doc, (const xmlChar *)name, type);
25559         xmlFreeDocElementContent(doc, ret_val); ret_val = NULL;
25560         desret_xmlElementContentPtr(ret_val);
25561         call_tests++;
25562         des_xmlDocPtr(n_doc, doc, 0);
25563         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
25564         des_xmlElementContentType(n_type, type, 2);
25565         xmlResetLastError();
25566         if (mem_base != xmlMemBlocks()) {
25567             printf("Leak of %d blocks found in xmlNewDocElementContent",
25568                    xmlMemBlocks() - mem_base);
25569             test_ret++;
25570             printf(" %d", n_doc);
25571             printf(" %d", n_name);
25572             printf(" %d", n_type);
25573             printf("\n");
25574         }
25575     }
25576     }
25577     }
25578     function_tests++;
25579
25580     return(test_ret);
25581 }
25582
25583
25584 static int
25585 test_xmlNewElementContent(void) {
25586     int test_ret = 0;
25587
25588     int mem_base;
25589     xmlElementContentPtr ret_val;
25590     xmlChar * name; /* the subelement name or NULL */
25591     int n_name;
25592     xmlElementContentType type; /* the type of element content decl */
25593     int n_type;
25594
25595     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
25596     for (n_type = 0;n_type < gen_nb_xmlElementContentType;n_type++) {
25597         mem_base = xmlMemBlocks();
25598         name = gen_const_xmlChar_ptr(n_name, 0);
25599         type = gen_xmlElementContentType(n_type, 1);
25600
25601         ret_val = xmlNewElementContent((const xmlChar *)name, type);
25602         desret_xmlElementContentPtr(ret_val);
25603         call_tests++;
25604         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
25605         des_xmlElementContentType(n_type, type, 1);
25606         xmlResetLastError();
25607         if (mem_base != xmlMemBlocks()) {
25608             printf("Leak of %d blocks found in xmlNewElementContent",
25609                    xmlMemBlocks() - mem_base);
25610             test_ret++;
25611             printf(" %d", n_name);
25612             printf(" %d", n_type);
25613             printf("\n");
25614         }
25615     }
25616     }
25617     function_tests++;
25618
25619     return(test_ret);
25620 }
25621
25622
25623 static int
25624 test_xmlNewValidCtxt(void) {
25625     int test_ret = 0;
25626
25627
25628     /* missing type support */
25629     return(test_ret);
25630 }
25631
25632
25633 static int
25634 test_xmlRemoveID(void) {
25635     int test_ret = 0;
25636
25637     int mem_base;
25638     int ret_val;
25639     xmlDocPtr doc; /* the document */
25640     int n_doc;
25641     xmlAttrPtr attr; /* the attribute */
25642     int n_attr;
25643
25644     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
25645     for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
25646         mem_base = xmlMemBlocks();
25647         doc = gen_xmlDocPtr(n_doc, 0);
25648         attr = gen_xmlAttrPtr(n_attr, 1);
25649
25650         ret_val = xmlRemoveID(doc, attr);
25651         desret_int(ret_val);
25652         call_tests++;
25653         des_xmlDocPtr(n_doc, doc, 0);
25654         des_xmlAttrPtr(n_attr, attr, 1);
25655         xmlResetLastError();
25656         if (mem_base != xmlMemBlocks()) {
25657             printf("Leak of %d blocks found in xmlRemoveID",
25658                    xmlMemBlocks() - mem_base);
25659             test_ret++;
25660             printf(" %d", n_doc);
25661             printf(" %d", n_attr);
25662             printf("\n");
25663         }
25664     }
25665     }
25666     function_tests++;
25667
25668     return(test_ret);
25669 }
25670
25671
25672 static int
25673 test_xmlRemoveRef(void) {
25674     int test_ret = 0;
25675
25676     int mem_base;
25677     int ret_val;
25678     xmlDocPtr doc; /* the document */
25679     int n_doc;
25680     xmlAttrPtr attr; /* the attribute */
25681     int n_attr;
25682
25683     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
25684     for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
25685         mem_base = xmlMemBlocks();
25686         doc = gen_xmlDocPtr(n_doc, 0);
25687         attr = gen_xmlAttrPtr(n_attr, 1);
25688
25689         ret_val = xmlRemoveRef(doc, attr);
25690         desret_int(ret_val);
25691         call_tests++;
25692         des_xmlDocPtr(n_doc, doc, 0);
25693         des_xmlAttrPtr(n_attr, attr, 1);
25694         xmlResetLastError();
25695         if (mem_base != xmlMemBlocks()) {
25696             printf("Leak of %d blocks found in xmlRemoveRef",
25697                    xmlMemBlocks() - mem_base);
25698             test_ret++;
25699             printf(" %d", n_doc);
25700             printf(" %d", n_attr);
25701             printf("\n");
25702         }
25703     }
25704     }
25705     function_tests++;
25706
25707     return(test_ret);
25708 }
25709
25710
25711 static int
25712 test_xmlSnprintfElementContent(void) {
25713     int test_ret = 0;
25714
25715     int mem_base;
25716     char * buf; /* an output buffer */
25717     int n_buf;
25718     int size; /* the buffer size */
25719     int n_size;
25720     xmlElementContentPtr content; /* An element table */
25721     int n_content;
25722     int englob; /* 1 if one must print the englobing parenthesis, 0 otherwise */
25723     int n_englob;
25724
25725     for (n_buf = 0;n_buf < gen_nb_char_ptr;n_buf++) {
25726     for (n_size = 0;n_size < gen_nb_int;n_size++) {
25727     for (n_content = 0;n_content < gen_nb_xmlElementContentPtr;n_content++) {
25728     for (n_englob = 0;n_englob < gen_nb_int;n_englob++) {
25729         mem_base = xmlMemBlocks();
25730         buf = gen_char_ptr(n_buf, 0);
25731         size = gen_int(n_size, 1);
25732         content = gen_xmlElementContentPtr(n_content, 2);
25733         englob = gen_int(n_englob, 3);
25734
25735         xmlSnprintfElementContent(buf, size, content, englob);
25736         call_tests++;
25737         des_char_ptr(n_buf, buf, 0);
25738         des_int(n_size, size, 1);
25739         des_xmlElementContentPtr(n_content, content, 2);
25740         des_int(n_englob, englob, 3);
25741         xmlResetLastError();
25742         if (mem_base != xmlMemBlocks()) {
25743             printf("Leak of %d blocks found in xmlSnprintfElementContent",
25744                    xmlMemBlocks() - mem_base);
25745             test_ret++;
25746             printf(" %d", n_buf);
25747             printf(" %d", n_size);
25748             printf(" %d", n_content);
25749             printf(" %d", n_englob);
25750             printf("\n");
25751         }
25752     }
25753     }
25754     }
25755     }
25756     function_tests++;
25757
25758     return(test_ret);
25759 }
25760
25761
25762 static int
25763 test_xmlSprintfElementContent(void) {
25764     int test_ret = 0;
25765
25766 #if defined(LIBXML_OUTPUT_ENABLED)
25767 #ifdef LIBXML_OUTPUT_ENABLED
25768     int mem_base;
25769     char * buf; /* an output buffer */
25770     int n_buf;
25771     xmlElementContentPtr content; /* An element table */
25772     int n_content;
25773     int englob; /* 1 if one must print the englobing parenthesis, 0 otherwise */
25774     int n_englob;
25775
25776     for (n_buf = 0;n_buf < gen_nb_char_ptr;n_buf++) {
25777     for (n_content = 0;n_content < gen_nb_xmlElementContentPtr;n_content++) {
25778     for (n_englob = 0;n_englob < gen_nb_int;n_englob++) {
25779         mem_base = xmlMemBlocks();
25780         buf = gen_char_ptr(n_buf, 0);
25781         content = gen_xmlElementContentPtr(n_content, 1);
25782         englob = gen_int(n_englob, 2);
25783
25784         xmlSprintfElementContent(buf, content, englob);
25785         call_tests++;
25786         des_char_ptr(n_buf, buf, 0);
25787         des_xmlElementContentPtr(n_content, content, 1);
25788         des_int(n_englob, englob, 2);
25789         xmlResetLastError();
25790         if (mem_base != xmlMemBlocks()) {
25791             printf("Leak of %d blocks found in xmlSprintfElementContent",
25792                    xmlMemBlocks() - mem_base);
25793             test_ret++;
25794             printf(" %d", n_buf);
25795             printf(" %d", n_content);
25796             printf(" %d", n_englob);
25797             printf("\n");
25798         }
25799     }
25800     }
25801     }
25802     function_tests++;
25803 #endif
25804 #endif
25805
25806     return(test_ret);
25807 }
25808
25809
25810 static int
25811 test_xmlValidBuildContentModel(void) {
25812     int test_ret = 0;
25813
25814 #if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED)
25815     int mem_base;
25816     int ret_val;
25817     xmlValidCtxtPtr ctxt; /* a validation context */
25818     int n_ctxt;
25819     xmlElementPtr elem; /* an element declaration node */
25820     int n_elem;
25821
25822     for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
25823     for (n_elem = 0;n_elem < gen_nb_xmlElementPtr;n_elem++) {
25824         mem_base = xmlMemBlocks();
25825         ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
25826         elem = gen_xmlElementPtr(n_elem, 1);
25827
25828         ret_val = xmlValidBuildContentModel(ctxt, elem);
25829         desret_int(ret_val);
25830         call_tests++;
25831         des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
25832         des_xmlElementPtr(n_elem, elem, 1);
25833         xmlResetLastError();
25834         if (mem_base != xmlMemBlocks()) {
25835             printf("Leak of %d blocks found in xmlValidBuildContentModel",
25836                    xmlMemBlocks() - mem_base);
25837             test_ret++;
25838             printf(" %d", n_ctxt);
25839             printf(" %d", n_elem);
25840             printf("\n");
25841         }
25842     }
25843     }
25844     function_tests++;
25845 #endif
25846
25847     return(test_ret);
25848 }
25849
25850
25851 static int
25852 test_xmlValidCtxtNormalizeAttributeValue(void) {
25853     int test_ret = 0;
25854
25855 #if defined(LIBXML_VALID_ENABLED)
25856     int mem_base;
25857     xmlChar * ret_val;
25858     xmlValidCtxtPtr ctxt; /* the validation context or NULL */
25859     int n_ctxt;
25860     xmlDocPtr doc; /* the document */
25861     int n_doc;
25862     xmlNodePtr elem; /* the parent */
25863     int n_elem;
25864     xmlChar * name; /* the attribute name */
25865     int n_name;
25866     xmlChar * value; /* the attribute value */
25867     int n_value;
25868
25869     for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
25870     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
25871     for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
25872     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
25873     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
25874         mem_base = xmlMemBlocks();
25875         ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
25876         doc = gen_xmlDocPtr(n_doc, 1);
25877         elem = gen_xmlNodePtr(n_elem, 2);
25878         name = gen_const_xmlChar_ptr(n_name, 3);
25879         value = gen_const_xmlChar_ptr(n_value, 4);
25880
25881         ret_val = xmlValidCtxtNormalizeAttributeValue(ctxt, doc, elem, (const xmlChar *)name, (const xmlChar *)value);
25882         desret_xmlChar_ptr(ret_val);
25883         call_tests++;
25884         des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
25885         des_xmlDocPtr(n_doc, doc, 1);
25886         des_xmlNodePtr(n_elem, elem, 2);
25887         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 3);
25888         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 4);
25889         xmlResetLastError();
25890         if (mem_base != xmlMemBlocks()) {
25891             printf("Leak of %d blocks found in xmlValidCtxtNormalizeAttributeValue",
25892                    xmlMemBlocks() - mem_base);
25893             test_ret++;
25894             printf(" %d", n_ctxt);
25895             printf(" %d", n_doc);
25896             printf(" %d", n_elem);
25897             printf(" %d", n_name);
25898             printf(" %d", n_value);
25899             printf("\n");
25900         }
25901     }
25902     }
25903     }
25904     }
25905     }
25906     function_tests++;
25907 #endif
25908
25909     return(test_ret);
25910 }
25911
25912
25913 #define gen_nb_xmlElementContent_ptr 1
25914 static xmlElementContent * gen_xmlElementContent_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
25915     return(NULL);
25916 }
25917 static void des_xmlElementContent_ptr(int no ATTRIBUTE_UNUSED, xmlElementContent * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
25918 }
25919
25920 static int
25921 test_xmlValidGetPotentialChildren(void) {
25922     int test_ret = 0;
25923
25924 #if defined(LIBXML_VALID_ENABLED)
25925 #ifdef LIBXML_VALID_ENABLED
25926     int mem_base;
25927     int ret_val;
25928     xmlElementContent * ctree; /* an element content tree */
25929     int n_ctree;
25930     xmlChar ** names; /* an array to store the list of child names */
25931     int n_names;
25932     int * len; /* a pointer to the number of element in the list */
25933     int n_len;
25934     int max; /* the size of the array */
25935     int n_max;
25936
25937     for (n_ctree = 0;n_ctree < gen_nb_xmlElementContent_ptr;n_ctree++) {
25938     for (n_names = 0;n_names < gen_nb_const_xmlChar_ptr_ptr;n_names++) {
25939     for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
25940     for (n_max = 0;n_max < gen_nb_int;n_max++) {
25941         mem_base = xmlMemBlocks();
25942         ctree = gen_xmlElementContent_ptr(n_ctree, 0);
25943         names = gen_const_xmlChar_ptr_ptr(n_names, 1);
25944         len = gen_int_ptr(n_len, 2);
25945         max = gen_int(n_max, 3);
25946
25947         ret_val = xmlValidGetPotentialChildren(ctree, (const xmlChar **)names, len, max);
25948         desret_int(ret_val);
25949         call_tests++;
25950         des_xmlElementContent_ptr(n_ctree, ctree, 0);
25951         des_const_xmlChar_ptr_ptr(n_names, (const xmlChar **)names, 1);
25952         des_int_ptr(n_len, len, 2);
25953         des_int(n_max, max, 3);
25954         xmlResetLastError();
25955         if (mem_base != xmlMemBlocks()) {
25956             printf("Leak of %d blocks found in xmlValidGetPotentialChildren",
25957                    xmlMemBlocks() - mem_base);
25958             test_ret++;
25959             printf(" %d", n_ctree);
25960             printf(" %d", n_names);
25961             printf(" %d", n_len);
25962             printf(" %d", n_max);
25963             printf("\n");
25964         }
25965     }
25966     }
25967     }
25968     }
25969     function_tests++;
25970 #endif
25971 #endif
25972
25973     return(test_ret);
25974 }
25975
25976
25977 static int
25978 test_xmlValidGetValidElements(void) {
25979     int test_ret = 0;
25980
25981 #if defined(LIBXML_VALID_ENABLED)
25982 #ifdef LIBXML_VALID_ENABLED
25983     int mem_base;
25984     int ret_val;
25985     xmlNode * prev; /* an element to insert after */
25986     int n_prev;
25987     xmlNode * next; /* an element to insert next */
25988     int n_next;
25989     xmlChar ** names; /* an array to store the list of child names */
25990     int n_names;
25991     int max; /* the size of the array */
25992     int n_max;
25993
25994     for (n_prev = 0;n_prev < gen_nb_xmlNodePtr;n_prev++) {
25995     for (n_next = 0;n_next < gen_nb_xmlNodePtr;n_next++) {
25996     for (n_names = 0;n_names < gen_nb_const_xmlChar_ptr_ptr;n_names++) {
25997     for (n_max = 0;n_max < gen_nb_int;n_max++) {
25998         mem_base = xmlMemBlocks();
25999         prev = gen_xmlNodePtr(n_prev, 0);
26000         next = gen_xmlNodePtr(n_next, 1);
26001         names = gen_const_xmlChar_ptr_ptr(n_names, 2);
26002         max = gen_int(n_max, 3);
26003
26004         ret_val = xmlValidGetValidElements(prev, next, (const xmlChar **)names, max);
26005         desret_int(ret_val);
26006         call_tests++;
26007         des_xmlNodePtr(n_prev, prev, 0);
26008         des_xmlNodePtr(n_next, next, 1);
26009         des_const_xmlChar_ptr_ptr(n_names, (const xmlChar **)names, 2);
26010         des_int(n_max, max, 3);
26011         xmlResetLastError();
26012         if (mem_base != xmlMemBlocks()) {
26013             printf("Leak of %d blocks found in xmlValidGetValidElements",
26014                    xmlMemBlocks() - mem_base);
26015             test_ret++;
26016             printf(" %d", n_prev);
26017             printf(" %d", n_next);
26018             printf(" %d", n_names);
26019             printf(" %d", n_max);
26020             printf("\n");
26021         }
26022     }
26023     }
26024     }
26025     }
26026     function_tests++;
26027 #endif
26028 #endif
26029
26030     return(test_ret);
26031 }
26032
26033
26034 static int
26035 test_xmlValidNormalizeAttributeValue(void) {
26036     int test_ret = 0;
26037
26038 #if defined(LIBXML_VALID_ENABLED)
26039     int mem_base;
26040     xmlChar * ret_val;
26041     xmlDocPtr doc; /* the document */
26042     int n_doc;
26043     xmlNodePtr elem; /* the parent */
26044     int n_elem;
26045     xmlChar * name; /* the attribute name */
26046     int n_name;
26047     xmlChar * value; /* the attribute value */
26048     int n_value;
26049
26050     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26051     for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
26052     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
26053     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
26054         mem_base = xmlMemBlocks();
26055         doc = gen_xmlDocPtr(n_doc, 0);
26056         elem = gen_xmlNodePtr(n_elem, 1);
26057         name = gen_const_xmlChar_ptr(n_name, 2);
26058         value = gen_const_xmlChar_ptr(n_value, 3);
26059
26060         ret_val = xmlValidNormalizeAttributeValue(doc, elem, (const xmlChar *)name, (const xmlChar *)value);
26061         desret_xmlChar_ptr(ret_val);
26062         call_tests++;
26063         des_xmlDocPtr(n_doc, doc, 0);
26064         des_xmlNodePtr(n_elem, elem, 1);
26065         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
26066         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 3);
26067         xmlResetLastError();
26068         if (mem_base != xmlMemBlocks()) {
26069             printf("Leak of %d blocks found in xmlValidNormalizeAttributeValue",
26070                    xmlMemBlocks() - mem_base);
26071             test_ret++;
26072             printf(" %d", n_doc);
26073             printf(" %d", n_elem);
26074             printf(" %d", n_name);
26075             printf(" %d", n_value);
26076             printf("\n");
26077         }
26078     }
26079     }
26080     }
26081     }
26082     function_tests++;
26083 #endif
26084
26085     return(test_ret);
26086 }
26087
26088
26089 static int
26090 test_xmlValidateAttributeDecl(void) {
26091     int test_ret = 0;
26092
26093 #if defined(LIBXML_VALID_ENABLED)
26094     int mem_base;
26095     int ret_val;
26096     xmlValidCtxtPtr ctxt; /* the validation context */
26097     int n_ctxt;
26098     xmlDocPtr doc; /* a document instance */
26099     int n_doc;
26100     xmlAttributePtr attr; /* an attribute definition */
26101     int n_attr;
26102
26103     for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26104     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26105     for (n_attr = 0;n_attr < gen_nb_xmlAttributePtr;n_attr++) {
26106         mem_base = xmlMemBlocks();
26107         ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26108         doc = gen_xmlDocPtr(n_doc, 1);
26109         attr = gen_xmlAttributePtr(n_attr, 2);
26110
26111         ret_val = xmlValidateAttributeDecl(ctxt, doc, attr);
26112         desret_int(ret_val);
26113         call_tests++;
26114         des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26115         des_xmlDocPtr(n_doc, doc, 1);
26116         des_xmlAttributePtr(n_attr, attr, 2);
26117         xmlResetLastError();
26118         if (mem_base != xmlMemBlocks()) {
26119             printf("Leak of %d blocks found in xmlValidateAttributeDecl",
26120                    xmlMemBlocks() - mem_base);
26121             test_ret++;
26122             printf(" %d", n_ctxt);
26123             printf(" %d", n_doc);
26124             printf(" %d", n_attr);
26125             printf("\n");
26126         }
26127     }
26128     }
26129     }
26130     function_tests++;
26131 #endif
26132
26133     return(test_ret);
26134 }
26135
26136
26137 static int
26138 test_xmlValidateAttributeValue(void) {
26139     int test_ret = 0;
26140
26141 #if defined(LIBXML_VALID_ENABLED)
26142     int mem_base;
26143     int ret_val;
26144     xmlAttributeType type; /* an attribute type */
26145     int n_type;
26146     xmlChar * value; /* an attribute value */
26147     int n_value;
26148
26149     for (n_type = 0;n_type < gen_nb_xmlAttributeType;n_type++) {
26150     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
26151         mem_base = xmlMemBlocks();
26152         type = gen_xmlAttributeType(n_type, 0);
26153         value = gen_const_xmlChar_ptr(n_value, 1);
26154
26155         ret_val = xmlValidateAttributeValue(type, (const xmlChar *)value);
26156         desret_int(ret_val);
26157         call_tests++;
26158         des_xmlAttributeType(n_type, type, 0);
26159         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
26160         xmlResetLastError();
26161         if (mem_base != xmlMemBlocks()) {
26162             printf("Leak of %d blocks found in xmlValidateAttributeValue",
26163                    xmlMemBlocks() - mem_base);
26164             test_ret++;
26165             printf(" %d", n_type);
26166             printf(" %d", n_value);
26167             printf("\n");
26168         }
26169     }
26170     }
26171     function_tests++;
26172 #endif
26173
26174     return(test_ret);
26175 }
26176
26177
26178 static int
26179 test_xmlValidateDocument(void) {
26180     int test_ret = 0;
26181
26182 #if defined(LIBXML_VALID_ENABLED)
26183     int mem_base;
26184     int ret_val;
26185     xmlValidCtxtPtr ctxt; /* the validation context */
26186     int n_ctxt;
26187     xmlDocPtr doc; /* a document instance */
26188     int n_doc;
26189
26190     for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26191     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26192         mem_base = xmlMemBlocks();
26193         ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26194         doc = gen_xmlDocPtr(n_doc, 1);
26195
26196         ret_val = xmlValidateDocument(ctxt, doc);
26197         desret_int(ret_val);
26198         call_tests++;
26199         des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26200         des_xmlDocPtr(n_doc, doc, 1);
26201         xmlResetLastError();
26202         if (mem_base != xmlMemBlocks()) {
26203             printf("Leak of %d blocks found in xmlValidateDocument",
26204                    xmlMemBlocks() - mem_base);
26205             test_ret++;
26206             printf(" %d", n_ctxt);
26207             printf(" %d", n_doc);
26208             printf("\n");
26209         }
26210     }
26211     }
26212     function_tests++;
26213 #endif
26214
26215     return(test_ret);
26216 }
26217
26218
26219 static int
26220 test_xmlValidateDocumentFinal(void) {
26221     int test_ret = 0;
26222
26223 #if defined(LIBXML_VALID_ENABLED)
26224     int mem_base;
26225     int ret_val;
26226     xmlValidCtxtPtr ctxt; /* the validation context */
26227     int n_ctxt;
26228     xmlDocPtr doc; /* a document instance */
26229     int n_doc;
26230
26231     for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26232     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26233         mem_base = xmlMemBlocks();
26234         ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26235         doc = gen_xmlDocPtr(n_doc, 1);
26236
26237         ret_val = xmlValidateDocumentFinal(ctxt, doc);
26238         desret_int(ret_val);
26239         call_tests++;
26240         des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26241         des_xmlDocPtr(n_doc, doc, 1);
26242         xmlResetLastError();
26243         if (mem_base != xmlMemBlocks()) {
26244             printf("Leak of %d blocks found in xmlValidateDocumentFinal",
26245                    xmlMemBlocks() - mem_base);
26246             test_ret++;
26247             printf(" %d", n_ctxt);
26248             printf(" %d", n_doc);
26249             printf("\n");
26250         }
26251     }
26252     }
26253     function_tests++;
26254 #endif
26255
26256     return(test_ret);
26257 }
26258
26259
26260 static int
26261 test_xmlValidateDtd(void) {
26262     int test_ret = 0;
26263
26264 #if defined(LIBXML_VALID_ENABLED)
26265     int mem_base;
26266     int ret_val;
26267     xmlValidCtxtPtr ctxt; /* the validation context */
26268     int n_ctxt;
26269     xmlDocPtr doc; /* a document instance */
26270     int n_doc;
26271     xmlDtdPtr dtd; /* a dtd instance */
26272     int n_dtd;
26273
26274     for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26275     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26276     for (n_dtd = 0;n_dtd < gen_nb_xmlDtdPtr;n_dtd++) {
26277         mem_base = xmlMemBlocks();
26278         ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26279         doc = gen_xmlDocPtr(n_doc, 1);
26280         dtd = gen_xmlDtdPtr(n_dtd, 2);
26281
26282         ret_val = xmlValidateDtd(ctxt, doc, dtd);
26283         desret_int(ret_val);
26284         call_tests++;
26285         des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26286         des_xmlDocPtr(n_doc, doc, 1);
26287         des_xmlDtdPtr(n_dtd, dtd, 2);
26288         xmlResetLastError();
26289         if (mem_base != xmlMemBlocks()) {
26290             printf("Leak of %d blocks found in xmlValidateDtd",
26291                    xmlMemBlocks() - mem_base);
26292             test_ret++;
26293             printf(" %d", n_ctxt);
26294             printf(" %d", n_doc);
26295             printf(" %d", n_dtd);
26296             printf("\n");
26297         }
26298     }
26299     }
26300     }
26301     function_tests++;
26302 #endif
26303
26304     return(test_ret);
26305 }
26306
26307
26308 static int
26309 test_xmlValidateDtdFinal(void) {
26310     int test_ret = 0;
26311
26312 #if defined(LIBXML_VALID_ENABLED)
26313     int mem_base;
26314     int ret_val;
26315     xmlValidCtxtPtr ctxt; /* the validation context */
26316     int n_ctxt;
26317     xmlDocPtr doc; /* a document instance */
26318     int n_doc;
26319
26320     for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26321     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26322         mem_base = xmlMemBlocks();
26323         ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26324         doc = gen_xmlDocPtr(n_doc, 1);
26325
26326         ret_val = xmlValidateDtdFinal(ctxt, doc);
26327         desret_int(ret_val);
26328         call_tests++;
26329         des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26330         des_xmlDocPtr(n_doc, doc, 1);
26331         xmlResetLastError();
26332         if (mem_base != xmlMemBlocks()) {
26333             printf("Leak of %d blocks found in xmlValidateDtdFinal",
26334                    xmlMemBlocks() - mem_base);
26335             test_ret++;
26336             printf(" %d", n_ctxt);
26337             printf(" %d", n_doc);
26338             printf("\n");
26339         }
26340     }
26341     }
26342     function_tests++;
26343 #endif
26344
26345     return(test_ret);
26346 }
26347
26348
26349 static int
26350 test_xmlValidateElement(void) {
26351     int test_ret = 0;
26352
26353 #if defined(LIBXML_VALID_ENABLED)
26354     int mem_base;
26355     int ret_val;
26356     xmlValidCtxtPtr ctxt; /* the validation context */
26357     int n_ctxt;
26358     xmlDocPtr doc; /* a document instance */
26359     int n_doc;
26360     xmlNodePtr elem; /* an element instance */
26361     int n_elem;
26362
26363     for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26364     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26365     for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
26366         mem_base = xmlMemBlocks();
26367         ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26368         doc = gen_xmlDocPtr(n_doc, 1);
26369         elem = gen_xmlNodePtr(n_elem, 2);
26370
26371         ret_val = xmlValidateElement(ctxt, doc, elem);
26372         desret_int(ret_val);
26373         call_tests++;
26374         des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26375         des_xmlDocPtr(n_doc, doc, 1);
26376         des_xmlNodePtr(n_elem, elem, 2);
26377         xmlResetLastError();
26378         if (mem_base != xmlMemBlocks()) {
26379             printf("Leak of %d blocks found in xmlValidateElement",
26380                    xmlMemBlocks() - mem_base);
26381             test_ret++;
26382             printf(" %d", n_ctxt);
26383             printf(" %d", n_doc);
26384             printf(" %d", n_elem);
26385             printf("\n");
26386         }
26387     }
26388     }
26389     }
26390     function_tests++;
26391 #endif
26392
26393     return(test_ret);
26394 }
26395
26396
26397 static int
26398 test_xmlValidateElementDecl(void) {
26399     int test_ret = 0;
26400
26401 #if defined(LIBXML_VALID_ENABLED)
26402     int mem_base;
26403     int ret_val;
26404     xmlValidCtxtPtr ctxt; /* the validation context */
26405     int n_ctxt;
26406     xmlDocPtr doc; /* a document instance */
26407     int n_doc;
26408     xmlElementPtr elem; /* an element definition */
26409     int n_elem;
26410
26411     for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26412     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26413     for (n_elem = 0;n_elem < gen_nb_xmlElementPtr;n_elem++) {
26414         mem_base = xmlMemBlocks();
26415         ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26416         doc = gen_xmlDocPtr(n_doc, 1);
26417         elem = gen_xmlElementPtr(n_elem, 2);
26418
26419         ret_val = xmlValidateElementDecl(ctxt, doc, elem);
26420         desret_int(ret_val);
26421         call_tests++;
26422         des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26423         des_xmlDocPtr(n_doc, doc, 1);
26424         des_xmlElementPtr(n_elem, elem, 2);
26425         xmlResetLastError();
26426         if (mem_base != xmlMemBlocks()) {
26427             printf("Leak of %d blocks found in xmlValidateElementDecl",
26428                    xmlMemBlocks() - mem_base);
26429             test_ret++;
26430             printf(" %d", n_ctxt);
26431             printf(" %d", n_doc);
26432             printf(" %d", n_elem);
26433             printf("\n");
26434         }
26435     }
26436     }
26437     }
26438     function_tests++;
26439 #endif
26440
26441     return(test_ret);
26442 }
26443
26444
26445 static int
26446 test_xmlValidateNameValue(void) {
26447     int test_ret = 0;
26448
26449 #if defined(LIBXML_VALID_ENABLED)
26450     int mem_base;
26451     int ret_val;
26452     xmlChar * value; /* an Name value */
26453     int n_value;
26454
26455     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
26456         mem_base = xmlMemBlocks();
26457         value = gen_const_xmlChar_ptr(n_value, 0);
26458
26459         ret_val = xmlValidateNameValue((const xmlChar *)value);
26460         desret_int(ret_val);
26461         call_tests++;
26462         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
26463         xmlResetLastError();
26464         if (mem_base != xmlMemBlocks()) {
26465             printf("Leak of %d blocks found in xmlValidateNameValue",
26466                    xmlMemBlocks() - mem_base);
26467             test_ret++;
26468             printf(" %d", n_value);
26469             printf("\n");
26470         }
26471     }
26472     function_tests++;
26473 #endif
26474
26475     return(test_ret);
26476 }
26477
26478
26479 static int
26480 test_xmlValidateNamesValue(void) {
26481     int test_ret = 0;
26482
26483 #if defined(LIBXML_VALID_ENABLED)
26484     int mem_base;
26485     int ret_val;
26486     xmlChar * value; /* an Names value */
26487     int n_value;
26488
26489     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
26490         mem_base = xmlMemBlocks();
26491         value = gen_const_xmlChar_ptr(n_value, 0);
26492
26493         ret_val = xmlValidateNamesValue((const xmlChar *)value);
26494         desret_int(ret_val);
26495         call_tests++;
26496         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
26497         xmlResetLastError();
26498         if (mem_base != xmlMemBlocks()) {
26499             printf("Leak of %d blocks found in xmlValidateNamesValue",
26500                    xmlMemBlocks() - mem_base);
26501             test_ret++;
26502             printf(" %d", n_value);
26503             printf("\n");
26504         }
26505     }
26506     function_tests++;
26507 #endif
26508
26509     return(test_ret);
26510 }
26511
26512
26513 static int
26514 test_xmlValidateNmtokenValue(void) {
26515     int test_ret = 0;
26516
26517 #if defined(LIBXML_VALID_ENABLED)
26518     int mem_base;
26519     int ret_val;
26520     xmlChar * value; /* an Nmtoken value */
26521     int n_value;
26522
26523     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
26524         mem_base = xmlMemBlocks();
26525         value = gen_const_xmlChar_ptr(n_value, 0);
26526
26527         ret_val = xmlValidateNmtokenValue((const xmlChar *)value);
26528         desret_int(ret_val);
26529         call_tests++;
26530         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
26531         xmlResetLastError();
26532         if (mem_base != xmlMemBlocks()) {
26533             printf("Leak of %d blocks found in xmlValidateNmtokenValue",
26534                    xmlMemBlocks() - mem_base);
26535             test_ret++;
26536             printf(" %d", n_value);
26537             printf("\n");
26538         }
26539     }
26540     function_tests++;
26541 #endif
26542
26543     return(test_ret);
26544 }
26545
26546
26547 static int
26548 test_xmlValidateNmtokensValue(void) {
26549     int test_ret = 0;
26550
26551 #if defined(LIBXML_VALID_ENABLED)
26552     int mem_base;
26553     int ret_val;
26554     xmlChar * value; /* an Nmtokens value */
26555     int n_value;
26556
26557     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
26558         mem_base = xmlMemBlocks();
26559         value = gen_const_xmlChar_ptr(n_value, 0);
26560
26561         ret_val = xmlValidateNmtokensValue((const xmlChar *)value);
26562         desret_int(ret_val);
26563         call_tests++;
26564         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
26565         xmlResetLastError();
26566         if (mem_base != xmlMemBlocks()) {
26567             printf("Leak of %d blocks found in xmlValidateNmtokensValue",
26568                    xmlMemBlocks() - mem_base);
26569             test_ret++;
26570             printf(" %d", n_value);
26571             printf("\n");
26572         }
26573     }
26574     function_tests++;
26575 #endif
26576
26577     return(test_ret);
26578 }
26579
26580
26581 static int
26582 test_xmlValidateNotationDecl(void) {
26583     int test_ret = 0;
26584
26585 #if defined(LIBXML_VALID_ENABLED)
26586     int mem_base;
26587     int ret_val;
26588     xmlValidCtxtPtr ctxt; /* the validation context */
26589     int n_ctxt;
26590     xmlDocPtr doc; /* a document instance */
26591     int n_doc;
26592     xmlNotationPtr nota; /* a notation definition */
26593     int n_nota;
26594
26595     for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26596     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26597     for (n_nota = 0;n_nota < gen_nb_xmlNotationPtr;n_nota++) {
26598         mem_base = xmlMemBlocks();
26599         ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26600         doc = gen_xmlDocPtr(n_doc, 1);
26601         nota = gen_xmlNotationPtr(n_nota, 2);
26602
26603         ret_val = xmlValidateNotationDecl(ctxt, doc, nota);
26604         desret_int(ret_val);
26605         call_tests++;
26606         des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26607         des_xmlDocPtr(n_doc, doc, 1);
26608         des_xmlNotationPtr(n_nota, nota, 2);
26609         xmlResetLastError();
26610         if (mem_base != xmlMemBlocks()) {
26611             printf("Leak of %d blocks found in xmlValidateNotationDecl",
26612                    xmlMemBlocks() - mem_base);
26613             test_ret++;
26614             printf(" %d", n_ctxt);
26615             printf(" %d", n_doc);
26616             printf(" %d", n_nota);
26617             printf("\n");
26618         }
26619     }
26620     }
26621     }
26622     function_tests++;
26623 #endif
26624
26625     return(test_ret);
26626 }
26627
26628
26629 static int
26630 test_xmlValidateNotationUse(void) {
26631     int test_ret = 0;
26632
26633 #if defined(LIBXML_VALID_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
26634     int mem_base;
26635     int ret_val;
26636     xmlValidCtxtPtr ctxt; /* the validation context */
26637     int n_ctxt;
26638     xmlDocPtr doc; /* the document */
26639     int n_doc;
26640     xmlChar * notationName; /* the notation name to check */
26641     int n_notationName;
26642
26643     for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26644     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26645     for (n_notationName = 0;n_notationName < gen_nb_const_xmlChar_ptr;n_notationName++) {
26646         mem_base = xmlMemBlocks();
26647         ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26648         doc = gen_xmlDocPtr(n_doc, 1);
26649         notationName = gen_const_xmlChar_ptr(n_notationName, 2);
26650
26651         ret_val = xmlValidateNotationUse(ctxt, doc, (const xmlChar *)notationName);
26652         desret_int(ret_val);
26653         call_tests++;
26654         des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26655         des_xmlDocPtr(n_doc, doc, 1);
26656         des_const_xmlChar_ptr(n_notationName, (const xmlChar *)notationName, 2);
26657         xmlResetLastError();
26658         if (mem_base != xmlMemBlocks()) {
26659             printf("Leak of %d blocks found in xmlValidateNotationUse",
26660                    xmlMemBlocks() - mem_base);
26661             test_ret++;
26662             printf(" %d", n_ctxt);
26663             printf(" %d", n_doc);
26664             printf(" %d", n_notationName);
26665             printf("\n");
26666         }
26667     }
26668     }
26669     }
26670     function_tests++;
26671 #endif
26672
26673     return(test_ret);
26674 }
26675
26676
26677 static int
26678 test_xmlValidateOneAttribute(void) {
26679     int test_ret = 0;
26680
26681 #if defined(LIBXML_VALID_ENABLED)
26682     int mem_base;
26683     int ret_val;
26684     xmlValidCtxtPtr ctxt; /* the validation context */
26685     int n_ctxt;
26686     xmlDocPtr doc; /* a document instance */
26687     int n_doc;
26688     xmlNodePtr elem; /* an element instance */
26689     int n_elem;
26690     xmlAttrPtr attr; /* an attribute instance */
26691     int n_attr;
26692     xmlChar * value; /* the attribute value (without entities processing) */
26693     int n_value;
26694
26695     for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26696     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26697     for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
26698     for (n_attr = 0;n_attr < gen_nb_xmlAttrPtr;n_attr++) {
26699     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
26700         mem_base = xmlMemBlocks();
26701         ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26702         doc = gen_xmlDocPtr(n_doc, 1);
26703         elem = gen_xmlNodePtr(n_elem, 2);
26704         attr = gen_xmlAttrPtr(n_attr, 3);
26705         value = gen_const_xmlChar_ptr(n_value, 4);
26706
26707         ret_val = xmlValidateOneAttribute(ctxt, doc, elem, attr, (const xmlChar *)value);
26708         desret_int(ret_val);
26709         call_tests++;
26710         des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26711         des_xmlDocPtr(n_doc, doc, 1);
26712         des_xmlNodePtr(n_elem, elem, 2);
26713         des_xmlAttrPtr(n_attr, attr, 3);
26714         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 4);
26715         xmlResetLastError();
26716         if (mem_base != xmlMemBlocks()) {
26717             printf("Leak of %d blocks found in xmlValidateOneAttribute",
26718                    xmlMemBlocks() - mem_base);
26719             test_ret++;
26720             printf(" %d", n_ctxt);
26721             printf(" %d", n_doc);
26722             printf(" %d", n_elem);
26723             printf(" %d", n_attr);
26724             printf(" %d", n_value);
26725             printf("\n");
26726         }
26727     }
26728     }
26729     }
26730     }
26731     }
26732     function_tests++;
26733 #endif
26734
26735     return(test_ret);
26736 }
26737
26738
26739 static int
26740 test_xmlValidateOneElement(void) {
26741     int test_ret = 0;
26742
26743 #if defined(LIBXML_VALID_ENABLED)
26744     int mem_base;
26745     int ret_val;
26746     xmlValidCtxtPtr ctxt; /* the validation context */
26747     int n_ctxt;
26748     xmlDocPtr doc; /* a document instance */
26749     int n_doc;
26750     xmlNodePtr elem; /* an element instance */
26751     int n_elem;
26752
26753     for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26754     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26755     for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
26756         mem_base = xmlMemBlocks();
26757         ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26758         doc = gen_xmlDocPtr(n_doc, 1);
26759         elem = gen_xmlNodePtr(n_elem, 2);
26760
26761         ret_val = xmlValidateOneElement(ctxt, doc, elem);
26762         desret_int(ret_val);
26763         call_tests++;
26764         des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26765         des_xmlDocPtr(n_doc, doc, 1);
26766         des_xmlNodePtr(n_elem, elem, 2);
26767         xmlResetLastError();
26768         if (mem_base != xmlMemBlocks()) {
26769             printf("Leak of %d blocks found in xmlValidateOneElement",
26770                    xmlMemBlocks() - mem_base);
26771             test_ret++;
26772             printf(" %d", n_ctxt);
26773             printf(" %d", n_doc);
26774             printf(" %d", n_elem);
26775             printf("\n");
26776         }
26777     }
26778     }
26779     }
26780     function_tests++;
26781 #endif
26782
26783     return(test_ret);
26784 }
26785
26786
26787 static int
26788 test_xmlValidateOneNamespace(void) {
26789     int test_ret = 0;
26790
26791 #if defined(LIBXML_VALID_ENABLED)
26792     int mem_base;
26793     int ret_val;
26794     xmlValidCtxtPtr ctxt; /* the validation context */
26795     int n_ctxt;
26796     xmlDocPtr doc; /* a document instance */
26797     int n_doc;
26798     xmlNodePtr elem; /* an element instance */
26799     int n_elem;
26800     xmlChar * prefix; /* the namespace prefix */
26801     int n_prefix;
26802     xmlNsPtr ns; /* an namespace declaration instance */
26803     int n_ns;
26804     xmlChar * value; /* the attribute value (without entities processing) */
26805     int n_value;
26806
26807     for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26808     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26809     for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
26810     for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
26811     for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
26812     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
26813         mem_base = xmlMemBlocks();
26814         ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26815         doc = gen_xmlDocPtr(n_doc, 1);
26816         elem = gen_xmlNodePtr(n_elem, 2);
26817         prefix = gen_const_xmlChar_ptr(n_prefix, 3);
26818         ns = gen_xmlNsPtr(n_ns, 4);
26819         value = gen_const_xmlChar_ptr(n_value, 5);
26820
26821         ret_val = xmlValidateOneNamespace(ctxt, doc, elem, (const xmlChar *)prefix, ns, (const xmlChar *)value);
26822         desret_int(ret_val);
26823         call_tests++;
26824         des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26825         des_xmlDocPtr(n_doc, doc, 1);
26826         des_xmlNodePtr(n_elem, elem, 2);
26827         des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 3);
26828         des_xmlNsPtr(n_ns, ns, 4);
26829         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 5);
26830         xmlResetLastError();
26831         if (mem_base != xmlMemBlocks()) {
26832             printf("Leak of %d blocks found in xmlValidateOneNamespace",
26833                    xmlMemBlocks() - mem_base);
26834             test_ret++;
26835             printf(" %d", n_ctxt);
26836             printf(" %d", n_doc);
26837             printf(" %d", n_elem);
26838             printf(" %d", n_prefix);
26839             printf(" %d", n_ns);
26840             printf(" %d", n_value);
26841             printf("\n");
26842         }
26843     }
26844     }
26845     }
26846     }
26847     }
26848     }
26849     function_tests++;
26850 #endif
26851
26852     return(test_ret);
26853 }
26854
26855
26856 static int
26857 test_xmlValidatePopElement(void) {
26858     int test_ret = 0;
26859
26860 #if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED)
26861     int mem_base;
26862     int ret_val;
26863     xmlValidCtxtPtr ctxt; /* the validation context */
26864     int n_ctxt;
26865     xmlDocPtr doc; /* a document instance */
26866     int n_doc;
26867     xmlNodePtr elem; /* an element instance */
26868     int n_elem;
26869     xmlChar * qname; /* the qualified name as appearing in the serialization */
26870     int n_qname;
26871
26872     for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26873     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26874     for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
26875     for (n_qname = 0;n_qname < gen_nb_const_xmlChar_ptr;n_qname++) {
26876         mem_base = xmlMemBlocks();
26877         ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26878         doc = gen_xmlDocPtr(n_doc, 1);
26879         elem = gen_xmlNodePtr(n_elem, 2);
26880         qname = gen_const_xmlChar_ptr(n_qname, 3);
26881
26882         ret_val = xmlValidatePopElement(ctxt, doc, elem, (const xmlChar *)qname);
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_const_xmlChar_ptr(n_qname, (const xmlChar *)qname, 3);
26889         xmlResetLastError();
26890         if (mem_base != xmlMemBlocks()) {
26891             printf("Leak of %d blocks found in xmlValidatePopElement",
26892                    xmlMemBlocks() - mem_base);
26893             test_ret++;
26894             printf(" %d", n_ctxt);
26895             printf(" %d", n_doc);
26896             printf(" %d", n_elem);
26897             printf(" %d", n_qname);
26898             printf("\n");
26899         }
26900     }
26901     }
26902     }
26903     }
26904     function_tests++;
26905 #endif
26906
26907     return(test_ret);
26908 }
26909
26910
26911 static int
26912 test_xmlValidatePushCData(void) {
26913     int test_ret = 0;
26914
26915 #if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED)
26916     int mem_base;
26917     int ret_val;
26918     xmlValidCtxtPtr ctxt; /* the validation context */
26919     int n_ctxt;
26920     xmlChar * data; /* some character data read */
26921     int n_data;
26922     int len; /* the lenght of the data */
26923     int n_len;
26924
26925     for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26926     for (n_data = 0;n_data < gen_nb_const_xmlChar_ptr;n_data++) {
26927     for (n_len = 0;n_len < gen_nb_int;n_len++) {
26928         mem_base = xmlMemBlocks();
26929         ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26930         data = gen_const_xmlChar_ptr(n_data, 1);
26931         len = gen_int(n_len, 2);
26932
26933         ret_val = xmlValidatePushCData(ctxt, (const xmlChar *)data, len);
26934         desret_int(ret_val);
26935         call_tests++;
26936         des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26937         des_const_xmlChar_ptr(n_data, (const xmlChar *)data, 1);
26938         des_int(n_len, len, 2);
26939         xmlResetLastError();
26940         if (mem_base != xmlMemBlocks()) {
26941             printf("Leak of %d blocks found in xmlValidatePushCData",
26942                    xmlMemBlocks() - mem_base);
26943             test_ret++;
26944             printf(" %d", n_ctxt);
26945             printf(" %d", n_data);
26946             printf(" %d", n_len);
26947             printf("\n");
26948         }
26949     }
26950     }
26951     }
26952     function_tests++;
26953 #endif
26954
26955     return(test_ret);
26956 }
26957
26958
26959 static int
26960 test_xmlValidatePushElement(void) {
26961     int test_ret = 0;
26962
26963 #if defined(LIBXML_VALID_ENABLED) && defined(LIBXML_REGEXP_ENABLED)
26964     int mem_base;
26965     int ret_val;
26966     xmlValidCtxtPtr ctxt; /* the validation context */
26967     int n_ctxt;
26968     xmlDocPtr doc; /* a document instance */
26969     int n_doc;
26970     xmlNodePtr elem; /* an element instance */
26971     int n_elem;
26972     xmlChar * qname; /* the qualified name as appearing in the serialization */
26973     int n_qname;
26974
26975     for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
26976     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
26977     for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
26978     for (n_qname = 0;n_qname < gen_nb_const_xmlChar_ptr;n_qname++) {
26979         mem_base = xmlMemBlocks();
26980         ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
26981         doc = gen_xmlDocPtr(n_doc, 1);
26982         elem = gen_xmlNodePtr(n_elem, 2);
26983         qname = gen_const_xmlChar_ptr(n_qname, 3);
26984
26985         ret_val = xmlValidatePushElement(ctxt, doc, elem, (const xmlChar *)qname);
26986         desret_int(ret_val);
26987         call_tests++;
26988         des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
26989         des_xmlDocPtr(n_doc, doc, 1);
26990         des_xmlNodePtr(n_elem, elem, 2);
26991         des_const_xmlChar_ptr(n_qname, (const xmlChar *)qname, 3);
26992         xmlResetLastError();
26993         if (mem_base != xmlMemBlocks()) {
26994             printf("Leak of %d blocks found in xmlValidatePushElement",
26995                    xmlMemBlocks() - mem_base);
26996             test_ret++;
26997             printf(" %d", n_ctxt);
26998             printf(" %d", n_doc);
26999             printf(" %d", n_elem);
27000             printf(" %d", n_qname);
27001             printf("\n");
27002         }
27003     }
27004     }
27005     }
27006     }
27007     function_tests++;
27008 #endif
27009
27010     return(test_ret);
27011 }
27012
27013
27014 static int
27015 test_xmlValidateRoot(void) {
27016     int test_ret = 0;
27017
27018 #if defined(LIBXML_VALID_ENABLED)
27019     int mem_base;
27020     int ret_val;
27021     xmlValidCtxtPtr ctxt; /* the validation context */
27022     int n_ctxt;
27023     xmlDocPtr doc; /* a document instance */
27024     int n_doc;
27025
27026     for (n_ctxt = 0;n_ctxt < gen_nb_xmlValidCtxtPtr;n_ctxt++) {
27027     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
27028         mem_base = xmlMemBlocks();
27029         ctxt = gen_xmlValidCtxtPtr(n_ctxt, 0);
27030         doc = gen_xmlDocPtr(n_doc, 1);
27031
27032         ret_val = xmlValidateRoot(ctxt, doc);
27033         desret_int(ret_val);
27034         call_tests++;
27035         des_xmlValidCtxtPtr(n_ctxt, ctxt, 0);
27036         des_xmlDocPtr(n_doc, doc, 1);
27037         xmlResetLastError();
27038         if (mem_base != xmlMemBlocks()) {
27039             printf("Leak of %d blocks found in xmlValidateRoot",
27040                    xmlMemBlocks() - mem_base);
27041             test_ret++;
27042             printf(" %d", n_ctxt);
27043             printf(" %d", n_doc);
27044             printf("\n");
27045         }
27046     }
27047     }
27048     function_tests++;
27049 #endif
27050
27051     return(test_ret);
27052 }
27053
27054 static int
27055 test_valid(void) {
27056     int test_ret = 0;
27057
27058     if (quiet == 0) printf("Testing valid : 50 of 70 functions ...\n");
27059     test_ret += test_xmlAddAttributeDecl();
27060     test_ret += test_xmlAddElementDecl();
27061     test_ret += test_xmlAddID();
27062     test_ret += test_xmlAddNotationDecl();
27063     test_ret += test_xmlAddRef();
27064     test_ret += test_xmlCopyAttributeTable();
27065     test_ret += test_xmlCopyDocElementContent();
27066     test_ret += test_xmlCopyElementContent();
27067     test_ret += test_xmlCopyElementTable();
27068     test_ret += test_xmlCopyEnumeration();
27069     test_ret += test_xmlCopyNotationTable();
27070     test_ret += test_xmlCreateEnumeration();
27071     test_ret += test_xmlDumpAttributeDecl();
27072     test_ret += test_xmlDumpAttributeTable();
27073     test_ret += test_xmlDumpElementDecl();
27074     test_ret += test_xmlDumpElementTable();
27075     test_ret += test_xmlDumpNotationDecl();
27076     test_ret += test_xmlDumpNotationTable();
27077     test_ret += test_xmlGetDtdAttrDesc();
27078     test_ret += test_xmlGetDtdElementDesc();
27079     test_ret += test_xmlGetDtdNotationDesc();
27080     test_ret += test_xmlGetDtdQAttrDesc();
27081     test_ret += test_xmlGetDtdQElementDesc();
27082     test_ret += test_xmlGetID();
27083     test_ret += test_xmlGetRefs();
27084     test_ret += test_xmlIsID();
27085     test_ret += test_xmlIsMixedElement();
27086     test_ret += test_xmlIsRef();
27087     test_ret += test_xmlNewDocElementContent();
27088     test_ret += test_xmlNewElementContent();
27089     test_ret += test_xmlNewValidCtxt();
27090     test_ret += test_xmlRemoveID();
27091     test_ret += test_xmlRemoveRef();
27092     test_ret += test_xmlSnprintfElementContent();
27093     test_ret += test_xmlSprintfElementContent();
27094     test_ret += test_xmlValidBuildContentModel();
27095     test_ret += test_xmlValidCtxtNormalizeAttributeValue();
27096     test_ret += test_xmlValidGetPotentialChildren();
27097     test_ret += test_xmlValidGetValidElements();
27098     test_ret += test_xmlValidNormalizeAttributeValue();
27099     test_ret += test_xmlValidateAttributeDecl();
27100     test_ret += test_xmlValidateAttributeValue();
27101     test_ret += test_xmlValidateDocument();
27102     test_ret += test_xmlValidateDocumentFinal();
27103     test_ret += test_xmlValidateDtd();
27104     test_ret += test_xmlValidateDtdFinal();
27105     test_ret += test_xmlValidateElement();
27106     test_ret += test_xmlValidateElementDecl();
27107     test_ret += test_xmlValidateNameValue();
27108     test_ret += test_xmlValidateNamesValue();
27109     test_ret += test_xmlValidateNmtokenValue();
27110     test_ret += test_xmlValidateNmtokensValue();
27111     test_ret += test_xmlValidateNotationDecl();
27112     test_ret += test_xmlValidateNotationUse();
27113     test_ret += test_xmlValidateOneAttribute();
27114     test_ret += test_xmlValidateOneElement();
27115     test_ret += test_xmlValidateOneNamespace();
27116     test_ret += test_xmlValidatePopElement();
27117     test_ret += test_xmlValidatePushCData();
27118     test_ret += test_xmlValidatePushElement();
27119     test_ret += test_xmlValidateRoot();
27120
27121     if (test_ret != 0)
27122         printf("Module valid: %d errors\n", test_ret);
27123     return(test_ret);
27124 }
27125
27126 static int
27127 test_xmlXIncludeNewContext(void) {
27128     int test_ret = 0;
27129
27130
27131     /* missing type support */
27132     return(test_ret);
27133 }
27134
27135
27136 static int
27137 test_xmlXIncludeProcess(void) {
27138     int test_ret = 0;
27139
27140 #if defined(LIBXML_XINCLUDE_ENABLED)
27141     int mem_base;
27142     int ret_val;
27143     xmlDocPtr doc; /* an XML document */
27144     int n_doc;
27145
27146     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
27147         mem_base = xmlMemBlocks();
27148         doc = gen_xmlDocPtr(n_doc, 0);
27149
27150         ret_val = xmlXIncludeProcess(doc);
27151         desret_int(ret_val);
27152         call_tests++;
27153         des_xmlDocPtr(n_doc, doc, 0);
27154         xmlResetLastError();
27155         if (mem_base != xmlMemBlocks()) {
27156             printf("Leak of %d blocks found in xmlXIncludeProcess",
27157                    xmlMemBlocks() - mem_base);
27158             test_ret++;
27159             printf(" %d", n_doc);
27160             printf("\n");
27161         }
27162     }
27163     function_tests++;
27164 #endif
27165
27166     return(test_ret);
27167 }
27168
27169
27170 static int
27171 test_xmlXIncludeProcessFlags(void) {
27172     int test_ret = 0;
27173
27174 #if defined(LIBXML_XINCLUDE_ENABLED)
27175     int mem_base;
27176     int ret_val;
27177     xmlDocPtr doc; /* an XML document */
27178     int n_doc;
27179     int flags; /* a set of xmlParserOption used for parsing XML includes */
27180     int n_flags;
27181
27182     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
27183     for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
27184         mem_base = xmlMemBlocks();
27185         doc = gen_xmlDocPtr(n_doc, 0);
27186         flags = gen_int(n_flags, 1);
27187
27188         ret_val = xmlXIncludeProcessFlags(doc, flags);
27189         desret_int(ret_val);
27190         call_tests++;
27191         des_xmlDocPtr(n_doc, doc, 0);
27192         des_int(n_flags, flags, 1);
27193         xmlResetLastError();
27194         if (mem_base != xmlMemBlocks()) {
27195             printf("Leak of %d blocks found in xmlXIncludeProcessFlags",
27196                    xmlMemBlocks() - mem_base);
27197             test_ret++;
27198             printf(" %d", n_doc);
27199             printf(" %d", n_flags);
27200             printf("\n");
27201         }
27202     }
27203     }
27204     function_tests++;
27205 #endif
27206
27207     return(test_ret);
27208 }
27209
27210
27211 static int
27212 test_xmlXIncludeProcessFlagsData(void) {
27213     int test_ret = 0;
27214
27215 #if defined(LIBXML_XINCLUDE_ENABLED)
27216     int mem_base;
27217     int ret_val;
27218     xmlDocPtr doc; /* an XML document */
27219     int n_doc;
27220     int flags; /* a set of xmlParserOption used for parsing XML includes */
27221     int n_flags;
27222     void * data; /* application data that will be passed to the parser context in the _private field of the parser context(s) */
27223     int n_data;
27224
27225     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
27226     for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
27227     for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
27228         mem_base = xmlMemBlocks();
27229         doc = gen_xmlDocPtr(n_doc, 0);
27230         flags = gen_int(n_flags, 1);
27231         data = gen_userdata(n_data, 2);
27232
27233         ret_val = xmlXIncludeProcessFlagsData(doc, flags, data);
27234         desret_int(ret_val);
27235         call_tests++;
27236         des_xmlDocPtr(n_doc, doc, 0);
27237         des_int(n_flags, flags, 1);
27238         des_userdata(n_data, data, 2);
27239         xmlResetLastError();
27240         if (mem_base != xmlMemBlocks()) {
27241             printf("Leak of %d blocks found in xmlXIncludeProcessFlagsData",
27242                    xmlMemBlocks() - mem_base);
27243             test_ret++;
27244             printf(" %d", n_doc);
27245             printf(" %d", n_flags);
27246             printf(" %d", n_data);
27247             printf("\n");
27248         }
27249     }
27250     }
27251     }
27252     function_tests++;
27253 #endif
27254
27255     return(test_ret);
27256 }
27257
27258 #ifdef LIBXML_XINCLUDE_ENABLED
27259
27260 #define gen_nb_xmlXIncludeCtxtPtr 1
27261 static xmlXIncludeCtxtPtr gen_xmlXIncludeCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
27262     return(NULL);
27263 }
27264 static void des_xmlXIncludeCtxtPtr(int no ATTRIBUTE_UNUSED, xmlXIncludeCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
27265 }
27266 #endif
27267
27268
27269 static int
27270 test_xmlXIncludeProcessNode(void) {
27271     int test_ret = 0;
27272
27273 #if defined(LIBXML_XINCLUDE_ENABLED)
27274     int mem_base;
27275     int ret_val;
27276     xmlXIncludeCtxtPtr ctxt; /* an existing XInclude context */
27277     int n_ctxt;
27278     xmlNodePtr node; /* a node in an XML document */
27279     int n_node;
27280
27281     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXIncludeCtxtPtr;n_ctxt++) {
27282     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
27283         mem_base = xmlMemBlocks();
27284         ctxt = gen_xmlXIncludeCtxtPtr(n_ctxt, 0);
27285         node = gen_xmlNodePtr(n_node, 1);
27286
27287         ret_val = xmlXIncludeProcessNode(ctxt, node);
27288         desret_int(ret_val);
27289         call_tests++;
27290         des_xmlXIncludeCtxtPtr(n_ctxt, ctxt, 0);
27291         des_xmlNodePtr(n_node, node, 1);
27292         xmlResetLastError();
27293         if (mem_base != xmlMemBlocks()) {
27294             printf("Leak of %d blocks found in xmlXIncludeProcessNode",
27295                    xmlMemBlocks() - mem_base);
27296             test_ret++;
27297             printf(" %d", n_ctxt);
27298             printf(" %d", n_node);
27299             printf("\n");
27300         }
27301     }
27302     }
27303     function_tests++;
27304 #endif
27305
27306     return(test_ret);
27307 }
27308
27309
27310 static int
27311 test_xmlXIncludeProcessTree(void) {
27312     int test_ret = 0;
27313
27314 #if defined(LIBXML_XINCLUDE_ENABLED)
27315     int mem_base;
27316     int ret_val;
27317     xmlNodePtr tree; /* a node in an XML document */
27318     int n_tree;
27319
27320     for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) {
27321         mem_base = xmlMemBlocks();
27322         tree = gen_xmlNodePtr(n_tree, 0);
27323
27324         ret_val = xmlXIncludeProcessTree(tree);
27325         desret_int(ret_val);
27326         call_tests++;
27327         des_xmlNodePtr(n_tree, tree, 0);
27328         xmlResetLastError();
27329         if (mem_base != xmlMemBlocks()) {
27330             printf("Leak of %d blocks found in xmlXIncludeProcessTree",
27331                    xmlMemBlocks() - mem_base);
27332             test_ret++;
27333             printf(" %d", n_tree);
27334             printf("\n");
27335         }
27336     }
27337     function_tests++;
27338 #endif
27339
27340     return(test_ret);
27341 }
27342
27343
27344 static int
27345 test_xmlXIncludeProcessTreeFlags(void) {
27346     int test_ret = 0;
27347
27348 #if defined(LIBXML_XINCLUDE_ENABLED)
27349     int mem_base;
27350     int ret_val;
27351     xmlNodePtr tree; /* a node in an XML document */
27352     int n_tree;
27353     int flags; /* a set of xmlParserOption used for parsing XML includes */
27354     int n_flags;
27355
27356     for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) {
27357     for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
27358         mem_base = xmlMemBlocks();
27359         tree = gen_xmlNodePtr(n_tree, 0);
27360         flags = gen_int(n_flags, 1);
27361
27362         ret_val = xmlXIncludeProcessTreeFlags(tree, flags);
27363         desret_int(ret_val);
27364         call_tests++;
27365         des_xmlNodePtr(n_tree, tree, 0);
27366         des_int(n_flags, flags, 1);
27367         xmlResetLastError();
27368         if (mem_base != xmlMemBlocks()) {
27369             printf("Leak of %d blocks found in xmlXIncludeProcessTreeFlags",
27370                    xmlMemBlocks() - mem_base);
27371             test_ret++;
27372             printf(" %d", n_tree);
27373             printf(" %d", n_flags);
27374             printf("\n");
27375         }
27376     }
27377     }
27378     function_tests++;
27379 #endif
27380
27381     return(test_ret);
27382 }
27383
27384
27385 static int
27386 test_xmlXIncludeProcessTreeFlagsData(void) {
27387     int test_ret = 0;
27388
27389 #if defined(LIBXML_XINCLUDE_ENABLED)
27390     int mem_base;
27391     int ret_val;
27392     xmlNodePtr tree; /* an XML node */
27393     int n_tree;
27394     int flags; /* a set of xmlParserOption used for parsing XML includes */
27395     int n_flags;
27396     void * data; /* application data that will be passed to the parser context in the _private field of the parser context(s) */
27397     int n_data;
27398
27399     for (n_tree = 0;n_tree < gen_nb_xmlNodePtr;n_tree++) {
27400     for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
27401     for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
27402         mem_base = xmlMemBlocks();
27403         tree = gen_xmlNodePtr(n_tree, 0);
27404         flags = gen_int(n_flags, 1);
27405         data = gen_userdata(n_data, 2);
27406
27407         ret_val = xmlXIncludeProcessTreeFlagsData(tree, flags, data);
27408         desret_int(ret_val);
27409         call_tests++;
27410         des_xmlNodePtr(n_tree, tree, 0);
27411         des_int(n_flags, flags, 1);
27412         des_userdata(n_data, data, 2);
27413         xmlResetLastError();
27414         if (mem_base != xmlMemBlocks()) {
27415             printf("Leak of %d blocks found in xmlXIncludeProcessTreeFlagsData",
27416                    xmlMemBlocks() - mem_base);
27417             test_ret++;
27418             printf(" %d", n_tree);
27419             printf(" %d", n_flags);
27420             printf(" %d", n_data);
27421             printf("\n");
27422         }
27423     }
27424     }
27425     }
27426     function_tests++;
27427 #endif
27428
27429     return(test_ret);
27430 }
27431
27432
27433 static int
27434 test_xmlXIncludeSetFlags(void) {
27435     int test_ret = 0;
27436
27437 #if defined(LIBXML_XINCLUDE_ENABLED)
27438     int mem_base;
27439     int ret_val;
27440     xmlXIncludeCtxtPtr ctxt; /* an XInclude processing context */
27441     int n_ctxt;
27442     int flags; /* a set of xmlParserOption used for parsing XML includes */
27443     int n_flags;
27444
27445     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXIncludeCtxtPtr;n_ctxt++) {
27446     for (n_flags = 0;n_flags < gen_nb_int;n_flags++) {
27447         mem_base = xmlMemBlocks();
27448         ctxt = gen_xmlXIncludeCtxtPtr(n_ctxt, 0);
27449         flags = gen_int(n_flags, 1);
27450
27451         ret_val = xmlXIncludeSetFlags(ctxt, flags);
27452         desret_int(ret_val);
27453         call_tests++;
27454         des_xmlXIncludeCtxtPtr(n_ctxt, ctxt, 0);
27455         des_int(n_flags, flags, 1);
27456         xmlResetLastError();
27457         if (mem_base != xmlMemBlocks()) {
27458             printf("Leak of %d blocks found in xmlXIncludeSetFlags",
27459                    xmlMemBlocks() - mem_base);
27460             test_ret++;
27461             printf(" %d", n_ctxt);
27462             printf(" %d", n_flags);
27463             printf("\n");
27464         }
27465     }
27466     }
27467     function_tests++;
27468 #endif
27469
27470     return(test_ret);
27471 }
27472
27473 static int
27474 test_xinclude(void) {
27475     int test_ret = 0;
27476
27477     if (quiet == 0) printf("Testing xinclude : 8 of 10 functions ...\n");
27478     test_ret += test_xmlXIncludeNewContext();
27479     test_ret += test_xmlXIncludeProcess();
27480     test_ret += test_xmlXIncludeProcessFlags();
27481     test_ret += test_xmlXIncludeProcessFlagsData();
27482     test_ret += test_xmlXIncludeProcessNode();
27483     test_ret += test_xmlXIncludeProcessTree();
27484     test_ret += test_xmlXIncludeProcessTreeFlags();
27485     test_ret += test_xmlXIncludeProcessTreeFlagsData();
27486     test_ret += test_xmlXIncludeSetFlags();
27487
27488     if (test_ret != 0)
27489         printf("Module xinclude: %d errors\n", test_ret);
27490     return(test_ret);
27491 }
27492
27493 static int
27494 test_xmlAllocOutputBuffer(void) {
27495     int test_ret = 0;
27496
27497 #if defined(LIBXML_OUTPUT_ENABLED)
27498     int mem_base;
27499     xmlOutputBufferPtr ret_val;
27500     xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */
27501     int n_encoder;
27502
27503     for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) {
27504         mem_base = xmlMemBlocks();
27505         encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 0);
27506
27507         ret_val = xmlAllocOutputBuffer(encoder);
27508         desret_xmlOutputBufferPtr(ret_val);
27509         call_tests++;
27510         des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 0);
27511         xmlResetLastError();
27512         if (mem_base != xmlMemBlocks()) {
27513             printf("Leak of %d blocks found in xmlAllocOutputBuffer",
27514                    xmlMemBlocks() - mem_base);
27515             test_ret++;
27516             printf(" %d", n_encoder);
27517             printf("\n");
27518         }
27519     }
27520     function_tests++;
27521 #endif
27522
27523     return(test_ret);
27524 }
27525
27526
27527 static int
27528 test_xmlAllocParserInputBuffer(void) {
27529     int test_ret = 0;
27530
27531     int mem_base;
27532     xmlParserInputBufferPtr ret_val;
27533     xmlCharEncoding enc; /* the charset encoding if known */
27534     int n_enc;
27535
27536     for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
27537         mem_base = xmlMemBlocks();
27538         enc = gen_xmlCharEncoding(n_enc, 0);
27539
27540         ret_val = xmlAllocParserInputBuffer(enc);
27541         desret_xmlParserInputBufferPtr(ret_val);
27542         call_tests++;
27543         des_xmlCharEncoding(n_enc, enc, 0);
27544         xmlResetLastError();
27545         if (mem_base != xmlMemBlocks()) {
27546             printf("Leak of %d blocks found in xmlAllocParserInputBuffer",
27547                    xmlMemBlocks() - mem_base);
27548             test_ret++;
27549             printf(" %d", n_enc);
27550             printf("\n");
27551         }
27552     }
27553     function_tests++;
27554
27555     return(test_ret);
27556 }
27557
27558
27559 static int
27560 test_xmlCheckFilename(void) {
27561     int test_ret = 0;
27562
27563     int mem_base;
27564     int ret_val;
27565     char * path; /* the path to check */
27566     int n_path;
27567
27568     for (n_path = 0;n_path < gen_nb_const_char_ptr;n_path++) {
27569         mem_base = xmlMemBlocks();
27570         path = gen_const_char_ptr(n_path, 0);
27571
27572         ret_val = xmlCheckFilename((const char *)path);
27573         desret_int(ret_val);
27574         call_tests++;
27575         des_const_char_ptr(n_path, (const char *)path, 0);
27576         xmlResetLastError();
27577         if (mem_base != xmlMemBlocks()) {
27578             printf("Leak of %d blocks found in xmlCheckFilename",
27579                    xmlMemBlocks() - mem_base);
27580             test_ret++;
27581             printf(" %d", n_path);
27582             printf("\n");
27583         }
27584     }
27585     function_tests++;
27586
27587     return(test_ret);
27588 }
27589
27590
27591 static int
27592 test_xmlCheckHTTPInput(void) {
27593     int test_ret = 0;
27594
27595     int mem_base;
27596     xmlParserInputPtr ret_val;
27597     xmlParserCtxtPtr ctxt; /* an XML parser context */
27598     int n_ctxt;
27599     xmlParserInputPtr ret; /* an XML parser input */
27600     int n_ret;
27601
27602     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
27603     for (n_ret = 0;n_ret < gen_nb_xmlParserInputPtr;n_ret++) {
27604         mem_base = xmlMemBlocks();
27605         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
27606         ret = gen_xmlParserInputPtr(n_ret, 1);
27607
27608         ret_val = xmlCheckHTTPInput(ctxt, ret);
27609         desret_xmlParserInputPtr(ret_val);
27610         call_tests++;
27611         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
27612         des_xmlParserInputPtr(n_ret, ret, 1);
27613         xmlResetLastError();
27614         if (mem_base != xmlMemBlocks()) {
27615             printf("Leak of %d blocks found in xmlCheckHTTPInput",
27616                    xmlMemBlocks() - mem_base);
27617             test_ret++;
27618             printf(" %d", n_ctxt);
27619             printf(" %d", n_ret);
27620             printf("\n");
27621         }
27622     }
27623     }
27624     function_tests++;
27625
27626     return(test_ret);
27627 }
27628
27629
27630 static int
27631 test_xmlCleanupInputCallbacks(void) {
27632     int test_ret = 0;
27633
27634     int mem_base;
27635
27636         mem_base = xmlMemBlocks();
27637
27638         xmlCleanupInputCallbacks();
27639         call_tests++;
27640         xmlResetLastError();
27641         if (mem_base != xmlMemBlocks()) {
27642             printf("Leak of %d blocks found in xmlCleanupInputCallbacks",
27643                    xmlMemBlocks() - mem_base);
27644             test_ret++;
27645             printf("\n");
27646         }
27647     function_tests++;
27648
27649     return(test_ret);
27650 }
27651
27652
27653 static int
27654 test_xmlCleanupOutputCallbacks(void) {
27655     int test_ret = 0;
27656
27657 #if defined(LIBXML_OUTPUT_ENABLED)
27658     int mem_base;
27659
27660         mem_base = xmlMemBlocks();
27661
27662         xmlCleanupOutputCallbacks();
27663         call_tests++;
27664         xmlResetLastError();
27665         if (mem_base != xmlMemBlocks()) {
27666             printf("Leak of %d blocks found in xmlCleanupOutputCallbacks",
27667                    xmlMemBlocks() - mem_base);
27668             test_ret++;
27669             printf("\n");
27670         }
27671     function_tests++;
27672 #endif
27673
27674     return(test_ret);
27675 }
27676
27677
27678 static int
27679 test_xmlFileClose(void) {
27680     int test_ret = 0;
27681
27682     int mem_base;
27683     int ret_val;
27684     void * context; /* the I/O context */
27685     int n_context;
27686
27687     for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
27688         mem_base = xmlMemBlocks();
27689         context = gen_void_ptr(n_context, 0);
27690
27691         ret_val = xmlFileClose(context);
27692         desret_int(ret_val);
27693         call_tests++;
27694         des_void_ptr(n_context, context, 0);
27695         xmlResetLastError();
27696         if (mem_base != xmlMemBlocks()) {
27697             printf("Leak of %d blocks found in xmlFileClose",
27698                    xmlMemBlocks() - mem_base);
27699             test_ret++;
27700             printf(" %d", n_context);
27701             printf("\n");
27702         }
27703     }
27704     function_tests++;
27705
27706     return(test_ret);
27707 }
27708
27709
27710 static int
27711 test_xmlFileMatch(void) {
27712     int test_ret = 0;
27713
27714     int mem_base;
27715     int ret_val;
27716     const char * filename; /* the URI for matching */
27717     int n_filename;
27718
27719     for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
27720         mem_base = xmlMemBlocks();
27721         filename = gen_filepath(n_filename, 0);
27722
27723         ret_val = xmlFileMatch(filename);
27724         desret_int(ret_val);
27725         call_tests++;
27726         des_filepath(n_filename, filename, 0);
27727         xmlResetLastError();
27728         if (mem_base != xmlMemBlocks()) {
27729             printf("Leak of %d blocks found in xmlFileMatch",
27730                    xmlMemBlocks() - mem_base);
27731             test_ret++;
27732             printf(" %d", n_filename);
27733             printf("\n");
27734         }
27735     }
27736     function_tests++;
27737
27738     return(test_ret);
27739 }
27740
27741
27742 static int
27743 test_xmlFileOpen(void) {
27744     int test_ret = 0;
27745
27746     int mem_base;
27747     void * ret_val;
27748     const char * filename; /* the URI for matching */
27749     int n_filename;
27750
27751     for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
27752         mem_base = xmlMemBlocks();
27753         filename = gen_filepath(n_filename, 0);
27754
27755         ret_val = xmlFileOpen(filename);
27756         desret_void_ptr(ret_val);
27757         call_tests++;
27758         des_filepath(n_filename, filename, 0);
27759         xmlResetLastError();
27760         if (mem_base != xmlMemBlocks()) {
27761             printf("Leak of %d blocks found in xmlFileOpen",
27762                    xmlMemBlocks() - mem_base);
27763             test_ret++;
27764             printf(" %d", n_filename);
27765             printf("\n");
27766         }
27767     }
27768     function_tests++;
27769
27770     return(test_ret);
27771 }
27772
27773
27774 static int
27775 test_xmlFileRead(void) {
27776     int test_ret = 0;
27777
27778     int mem_base;
27779     int ret_val;
27780     void * context; /* the I/O context */
27781     int n_context;
27782     char * buffer; /* where to drop data */
27783     int n_buffer;
27784     int len; /* number of bytes to write */
27785     int n_len;
27786
27787     for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
27788     for (n_buffer = 0;n_buffer < gen_nb_char_ptr;n_buffer++) {
27789     for (n_len = 0;n_len < gen_nb_int;n_len++) {
27790         mem_base = xmlMemBlocks();
27791         context = gen_void_ptr(n_context, 0);
27792         buffer = gen_char_ptr(n_buffer, 1);
27793         len = gen_int(n_len, 2);
27794
27795         ret_val = xmlFileRead(context, buffer, len);
27796         desret_int(ret_val);
27797         call_tests++;
27798         des_void_ptr(n_context, context, 0);
27799         des_char_ptr(n_buffer, buffer, 1);
27800         des_int(n_len, len, 2);
27801         xmlResetLastError();
27802         if (mem_base != xmlMemBlocks()) {
27803             printf("Leak of %d blocks found in xmlFileRead",
27804                    xmlMemBlocks() - mem_base);
27805             test_ret++;
27806             printf(" %d", n_context);
27807             printf(" %d", n_buffer);
27808             printf(" %d", n_len);
27809             printf("\n");
27810         }
27811     }
27812     }
27813     }
27814     function_tests++;
27815
27816     return(test_ret);
27817 }
27818
27819
27820 static int
27821 test_xmlIOFTPClose(void) {
27822     int test_ret = 0;
27823
27824 #if defined(LIBXML_FTP_ENABLED)
27825     int mem_base;
27826     int ret_val;
27827     void * context; /* the I/O context */
27828     int n_context;
27829
27830     for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
27831         mem_base = xmlMemBlocks();
27832         context = gen_void_ptr(n_context, 0);
27833
27834         ret_val = xmlIOFTPClose(context);
27835         desret_int(ret_val);
27836         call_tests++;
27837         des_void_ptr(n_context, context, 0);
27838         xmlResetLastError();
27839         if (mem_base != xmlMemBlocks()) {
27840             printf("Leak of %d blocks found in xmlIOFTPClose",
27841                    xmlMemBlocks() - mem_base);
27842             test_ret++;
27843             printf(" %d", n_context);
27844             printf("\n");
27845         }
27846     }
27847     function_tests++;
27848 #endif
27849
27850     return(test_ret);
27851 }
27852
27853
27854 static int
27855 test_xmlIOFTPMatch(void) {
27856     int test_ret = 0;
27857
27858 #if defined(LIBXML_FTP_ENABLED)
27859     int mem_base;
27860     int ret_val;
27861     const char * filename; /* the URI for matching */
27862     int n_filename;
27863
27864     for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
27865         mem_base = xmlMemBlocks();
27866         filename = gen_filepath(n_filename, 0);
27867
27868         ret_val = xmlIOFTPMatch(filename);
27869         desret_int(ret_val);
27870         call_tests++;
27871         des_filepath(n_filename, filename, 0);
27872         xmlResetLastError();
27873         if (mem_base != xmlMemBlocks()) {
27874             printf("Leak of %d blocks found in xmlIOFTPMatch",
27875                    xmlMemBlocks() - mem_base);
27876             test_ret++;
27877             printf(" %d", n_filename);
27878             printf("\n");
27879         }
27880     }
27881     function_tests++;
27882 #endif
27883
27884     return(test_ret);
27885 }
27886
27887
27888 static int
27889 test_xmlIOFTPOpen(void) {
27890     int test_ret = 0;
27891
27892 #if defined(LIBXML_FTP_ENABLED)
27893     int mem_base;
27894     void * ret_val;
27895     const char * filename; /* the URI for matching */
27896     int n_filename;
27897
27898     for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
27899         mem_base = xmlMemBlocks();
27900         filename = gen_filepath(n_filename, 0);
27901
27902         ret_val = xmlIOFTPOpen(filename);
27903         desret_void_ptr(ret_val);
27904         call_tests++;
27905         des_filepath(n_filename, filename, 0);
27906         xmlResetLastError();
27907         if (mem_base != xmlMemBlocks()) {
27908             printf("Leak of %d blocks found in xmlIOFTPOpen",
27909                    xmlMemBlocks() - mem_base);
27910             test_ret++;
27911             printf(" %d", n_filename);
27912             printf("\n");
27913         }
27914     }
27915     function_tests++;
27916 #endif
27917
27918     return(test_ret);
27919 }
27920
27921
27922 static int
27923 test_xmlIOFTPRead(void) {
27924     int test_ret = 0;
27925
27926 #if defined(LIBXML_FTP_ENABLED)
27927     int mem_base;
27928     int ret_val;
27929     void * context; /* the I/O context */
27930     int n_context;
27931     char * buffer; /* where to drop data */
27932     int n_buffer;
27933     int len; /* number of bytes to write */
27934     int n_len;
27935
27936     for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
27937     for (n_buffer = 0;n_buffer < gen_nb_char_ptr;n_buffer++) {
27938     for (n_len = 0;n_len < gen_nb_int;n_len++) {
27939         mem_base = xmlMemBlocks();
27940         context = gen_void_ptr(n_context, 0);
27941         buffer = gen_char_ptr(n_buffer, 1);
27942         len = gen_int(n_len, 2);
27943
27944         ret_val = xmlIOFTPRead(context, buffer, len);
27945         desret_int(ret_val);
27946         call_tests++;
27947         des_void_ptr(n_context, context, 0);
27948         des_char_ptr(n_buffer, buffer, 1);
27949         des_int(n_len, len, 2);
27950         xmlResetLastError();
27951         if (mem_base != xmlMemBlocks()) {
27952             printf("Leak of %d blocks found in xmlIOFTPRead",
27953                    xmlMemBlocks() - mem_base);
27954             test_ret++;
27955             printf(" %d", n_context);
27956             printf(" %d", n_buffer);
27957             printf(" %d", n_len);
27958             printf("\n");
27959         }
27960     }
27961     }
27962     }
27963     function_tests++;
27964 #endif
27965
27966     return(test_ret);
27967 }
27968
27969
27970 static int
27971 test_xmlIOHTTPClose(void) {
27972     int test_ret = 0;
27973
27974 #if defined(LIBXML_HTTP_ENABLED)
27975     int mem_base;
27976     int ret_val;
27977     void * context; /* the I/O context */
27978     int n_context;
27979
27980     for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
27981         mem_base = xmlMemBlocks();
27982         context = gen_void_ptr(n_context, 0);
27983
27984         ret_val = xmlIOHTTPClose(context);
27985         desret_int(ret_val);
27986         call_tests++;
27987         des_void_ptr(n_context, context, 0);
27988         xmlResetLastError();
27989         if (mem_base != xmlMemBlocks()) {
27990             printf("Leak of %d blocks found in xmlIOHTTPClose",
27991                    xmlMemBlocks() - mem_base);
27992             test_ret++;
27993             printf(" %d", n_context);
27994             printf("\n");
27995         }
27996     }
27997     function_tests++;
27998 #endif
27999
28000     return(test_ret);
28001 }
28002
28003
28004 static int
28005 test_xmlIOHTTPMatch(void) {
28006     int test_ret = 0;
28007
28008 #if defined(LIBXML_HTTP_ENABLED)
28009     int mem_base;
28010     int ret_val;
28011     const char * filename; /* the URI for matching */
28012     int n_filename;
28013
28014     for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
28015         mem_base = xmlMemBlocks();
28016         filename = gen_filepath(n_filename, 0);
28017
28018         ret_val = xmlIOHTTPMatch(filename);
28019         desret_int(ret_val);
28020         call_tests++;
28021         des_filepath(n_filename, filename, 0);
28022         xmlResetLastError();
28023         if (mem_base != xmlMemBlocks()) {
28024             printf("Leak of %d blocks found in xmlIOHTTPMatch",
28025                    xmlMemBlocks() - mem_base);
28026             test_ret++;
28027             printf(" %d", n_filename);
28028             printf("\n");
28029         }
28030     }
28031     function_tests++;
28032 #endif
28033
28034     return(test_ret);
28035 }
28036
28037
28038 static int
28039 test_xmlIOHTTPOpen(void) {
28040     int test_ret = 0;
28041
28042 #if defined(LIBXML_HTTP_ENABLED)
28043     int mem_base;
28044     void * ret_val;
28045     const char * filename; /* the URI for matching */
28046     int n_filename;
28047
28048     for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
28049         mem_base = xmlMemBlocks();
28050         filename = gen_filepath(n_filename, 0);
28051
28052         ret_val = xmlIOHTTPOpen(filename);
28053         desret_xmlNanoHTTPCtxtPtr(ret_val);
28054         call_tests++;
28055         des_filepath(n_filename, filename, 0);
28056         xmlResetLastError();
28057         if (mem_base != xmlMemBlocks()) {
28058             printf("Leak of %d blocks found in xmlIOHTTPOpen",
28059                    xmlMemBlocks() - mem_base);
28060             test_ret++;
28061             printf(" %d", n_filename);
28062             printf("\n");
28063         }
28064     }
28065     function_tests++;
28066 #endif
28067
28068     return(test_ret);
28069 }
28070
28071
28072 static int
28073 test_xmlIOHTTPRead(void) {
28074     int test_ret = 0;
28075
28076 #if defined(LIBXML_HTTP_ENABLED)
28077     int mem_base;
28078     int ret_val;
28079     void * context; /* the I/O context */
28080     int n_context;
28081     char * buffer; /* where to drop data */
28082     int n_buffer;
28083     int len; /* number of bytes to write */
28084     int n_len;
28085
28086     for (n_context = 0;n_context < gen_nb_void_ptr;n_context++) {
28087     for (n_buffer = 0;n_buffer < gen_nb_char_ptr;n_buffer++) {
28088     for (n_len = 0;n_len < gen_nb_int;n_len++) {
28089         mem_base = xmlMemBlocks();
28090         context = gen_void_ptr(n_context, 0);
28091         buffer = gen_char_ptr(n_buffer, 1);
28092         len = gen_int(n_len, 2);
28093
28094         ret_val = xmlIOHTTPRead(context, buffer, len);
28095         desret_int(ret_val);
28096         call_tests++;
28097         des_void_ptr(n_context, context, 0);
28098         des_char_ptr(n_buffer, buffer, 1);
28099         des_int(n_len, len, 2);
28100         xmlResetLastError();
28101         if (mem_base != xmlMemBlocks()) {
28102             printf("Leak of %d blocks found in xmlIOHTTPRead",
28103                    xmlMemBlocks() - mem_base);
28104             test_ret++;
28105             printf(" %d", n_context);
28106             printf(" %d", n_buffer);
28107             printf(" %d", n_len);
28108             printf("\n");
28109         }
28110     }
28111     }
28112     }
28113     function_tests++;
28114 #endif
28115
28116     return(test_ret);
28117 }
28118
28119
28120 static int
28121 test_xmlNoNetExternalEntityLoader(void) {
28122     int test_ret = 0;
28123
28124     int mem_base;
28125     xmlParserInputPtr ret_val;
28126     const char * URL; /* the URL for the entity to load */
28127     int n_URL;
28128     char * ID; /* the System ID for the entity to load */
28129     int n_ID;
28130     xmlParserCtxtPtr ctxt; /* the context in which the entity is called or NULL */
28131     int n_ctxt;
28132
28133     for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
28134     for (n_ID = 0;n_ID < gen_nb_const_char_ptr;n_ID++) {
28135     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
28136         mem_base = xmlMemBlocks();
28137         URL = gen_filepath(n_URL, 0);
28138         ID = gen_const_char_ptr(n_ID, 1);
28139         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 2);
28140
28141         ret_val = xmlNoNetExternalEntityLoader(URL, (const char *)ID, ctxt);
28142         desret_xmlParserInputPtr(ret_val);
28143         call_tests++;
28144         des_filepath(n_URL, URL, 0);
28145         des_const_char_ptr(n_ID, (const char *)ID, 1);
28146         des_xmlParserCtxtPtr(n_ctxt, ctxt, 2);
28147         xmlResetLastError();
28148         if (mem_base != xmlMemBlocks()) {
28149             printf("Leak of %d blocks found in xmlNoNetExternalEntityLoader",
28150                    xmlMemBlocks() - mem_base);
28151             test_ret++;
28152             printf(" %d", n_URL);
28153             printf(" %d", n_ID);
28154             printf(" %d", n_ctxt);
28155             printf("\n");
28156         }
28157     }
28158     }
28159     }
28160     function_tests++;
28161
28162     return(test_ret);
28163 }
28164
28165
28166 static int
28167 test_xmlNormalizeWindowsPath(void) {
28168     int test_ret = 0;
28169
28170     int mem_base;
28171     xmlChar * ret_val;
28172     xmlChar * path; /* the input file path */
28173     int n_path;
28174
28175     for (n_path = 0;n_path < gen_nb_const_xmlChar_ptr;n_path++) {
28176         mem_base = xmlMemBlocks();
28177         path = gen_const_xmlChar_ptr(n_path, 0);
28178
28179         ret_val = xmlNormalizeWindowsPath((const xmlChar *)path);
28180         desret_xmlChar_ptr(ret_val);
28181         call_tests++;
28182         des_const_xmlChar_ptr(n_path, (const xmlChar *)path, 0);
28183         xmlResetLastError();
28184         if (mem_base != xmlMemBlocks()) {
28185             printf("Leak of %d blocks found in xmlNormalizeWindowsPath",
28186                    xmlMemBlocks() - mem_base);
28187             test_ret++;
28188             printf(" %d", n_path);
28189             printf("\n");
28190         }
28191     }
28192     function_tests++;
28193
28194     return(test_ret);
28195 }
28196
28197
28198 static int
28199 test_xmlOutputBufferCreateBuffer(void) {
28200     int test_ret = 0;
28201
28202 #if defined(LIBXML_OUTPUT_ENABLED)
28203     int mem_base;
28204     xmlOutputBufferPtr ret_val;
28205     xmlBufferPtr buffer; /* a xmlBufferPtr */
28206     int n_buffer;
28207     xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */
28208     int n_encoder;
28209
28210     for (n_buffer = 0;n_buffer < gen_nb_xmlBufferPtr;n_buffer++) {
28211     for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) {
28212         mem_base = xmlMemBlocks();
28213         buffer = gen_xmlBufferPtr(n_buffer, 0);
28214         encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 1);
28215
28216         ret_val = xmlOutputBufferCreateBuffer(buffer, encoder);
28217         desret_xmlOutputBufferPtr(ret_val);
28218         call_tests++;
28219         des_xmlBufferPtr(n_buffer, buffer, 0);
28220         des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 1);
28221         xmlResetLastError();
28222         if (mem_base != xmlMemBlocks()) {
28223             printf("Leak of %d blocks found in xmlOutputBufferCreateBuffer",
28224                    xmlMemBlocks() - mem_base);
28225             test_ret++;
28226             printf(" %d", n_buffer);
28227             printf(" %d", n_encoder);
28228             printf("\n");
28229         }
28230     }
28231     }
28232     function_tests++;
28233 #endif
28234
28235     return(test_ret);
28236 }
28237
28238
28239 static int
28240 test_xmlOutputBufferCreateFd(void) {
28241     int test_ret = 0;
28242
28243 #if defined(LIBXML_OUTPUT_ENABLED)
28244     int mem_base;
28245     xmlOutputBufferPtr ret_val;
28246     int fd; /* a file descriptor number */
28247     int n_fd;
28248     xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */
28249     int n_encoder;
28250
28251     for (n_fd = 0;n_fd < gen_nb_int;n_fd++) {
28252     for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) {
28253         mem_base = xmlMemBlocks();
28254         fd = gen_int(n_fd, 0);
28255         encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 1);
28256
28257         ret_val = xmlOutputBufferCreateFd(fd, encoder);
28258         desret_xmlOutputBufferPtr(ret_val);
28259         call_tests++;
28260         des_int(n_fd, fd, 0);
28261         des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 1);
28262         xmlResetLastError();
28263         if (mem_base != xmlMemBlocks()) {
28264             printf("Leak of %d blocks found in xmlOutputBufferCreateFd",
28265                    xmlMemBlocks() - mem_base);
28266             test_ret++;
28267             printf(" %d", n_fd);
28268             printf(" %d", n_encoder);
28269             printf("\n");
28270         }
28271     }
28272     }
28273     function_tests++;
28274 #endif
28275
28276     return(test_ret);
28277 }
28278
28279
28280 static int
28281 test_xmlOutputBufferCreateFile(void) {
28282     int test_ret = 0;
28283
28284 #if defined(LIBXML_OUTPUT_ENABLED)
28285     int mem_base;
28286     xmlOutputBufferPtr ret_val;
28287     FILE * file; /* a FILE* */
28288     int n_file;
28289     xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */
28290     int n_encoder;
28291
28292     for (n_file = 0;n_file < gen_nb_FILE_ptr;n_file++) {
28293     for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) {
28294         mem_base = xmlMemBlocks();
28295         file = gen_FILE_ptr(n_file, 0);
28296         encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 1);
28297
28298         ret_val = xmlOutputBufferCreateFile(file, encoder);
28299         desret_xmlOutputBufferPtr(ret_val);
28300         call_tests++;
28301         des_FILE_ptr(n_file, file, 0);
28302         des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 1);
28303         xmlResetLastError();
28304         if (mem_base != xmlMemBlocks()) {
28305             printf("Leak of %d blocks found in xmlOutputBufferCreateFile",
28306                    xmlMemBlocks() - mem_base);
28307             test_ret++;
28308             printf(" %d", n_file);
28309             printf(" %d", n_encoder);
28310             printf("\n");
28311         }
28312     }
28313     }
28314     function_tests++;
28315 #endif
28316
28317     return(test_ret);
28318 }
28319
28320
28321 static int
28322 test_xmlOutputBufferCreateFilename(void) {
28323     int test_ret = 0;
28324
28325 #if defined(LIBXML_OUTPUT_ENABLED)
28326     int mem_base;
28327     xmlOutputBufferPtr ret_val;
28328     const char * URI; /* a C string containing the URI or filename */
28329     int n_URI;
28330     xmlCharEncodingHandlerPtr encoder; /* the encoding converter or NULL */
28331     int n_encoder;
28332     int compression; /* the compression ration (0 none, 9 max). */
28333     int n_compression;
28334
28335     for (n_URI = 0;n_URI < gen_nb_fileoutput;n_URI++) {
28336     for (n_encoder = 0;n_encoder < gen_nb_xmlCharEncodingHandlerPtr;n_encoder++) {
28337     for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
28338         mem_base = xmlMemBlocks();
28339         URI = gen_fileoutput(n_URI, 0);
28340         encoder = gen_xmlCharEncodingHandlerPtr(n_encoder, 1);
28341         compression = gen_int(n_compression, 2);
28342
28343         ret_val = xmlOutputBufferCreateFilename(URI, encoder, compression);
28344         desret_xmlOutputBufferPtr(ret_val);
28345         call_tests++;
28346         des_fileoutput(n_URI, URI, 0);
28347         des_xmlCharEncodingHandlerPtr(n_encoder, encoder, 1);
28348         des_int(n_compression, compression, 2);
28349         xmlResetLastError();
28350         if (mem_base != xmlMemBlocks()) {
28351             printf("Leak of %d blocks found in xmlOutputBufferCreateFilename",
28352                    xmlMemBlocks() - mem_base);
28353             test_ret++;
28354             printf(" %d", n_URI);
28355             printf(" %d", n_encoder);
28356             printf(" %d", n_compression);
28357             printf("\n");
28358         }
28359     }
28360     }
28361     }
28362     function_tests++;
28363 #endif
28364
28365     return(test_ret);
28366 }
28367
28368
28369 static int
28370 test_xmlOutputBufferFlush(void) {
28371     int test_ret = 0;
28372
28373 #if defined(LIBXML_OUTPUT_ENABLED)
28374     int mem_base;
28375     int ret_val;
28376     xmlOutputBufferPtr out; /* a buffered output */
28377     int n_out;
28378
28379     for (n_out = 0;n_out < gen_nb_xmlOutputBufferPtr;n_out++) {
28380         mem_base = xmlMemBlocks();
28381         out = gen_xmlOutputBufferPtr(n_out, 0);
28382
28383         ret_val = xmlOutputBufferFlush(out);
28384         desret_int(ret_val);
28385         call_tests++;
28386         des_xmlOutputBufferPtr(n_out, out, 0);
28387         xmlResetLastError();
28388         if (mem_base != xmlMemBlocks()) {
28389             printf("Leak of %d blocks found in xmlOutputBufferFlush",
28390                    xmlMemBlocks() - mem_base);
28391             test_ret++;
28392             printf(" %d", n_out);
28393             printf("\n");
28394         }
28395     }
28396     function_tests++;
28397 #endif
28398
28399     return(test_ret);
28400 }
28401
28402
28403 static int
28404 test_xmlOutputBufferWrite(void) {
28405     int test_ret = 0;
28406
28407 #if defined(LIBXML_OUTPUT_ENABLED)
28408     int mem_base;
28409     int ret_val;
28410     xmlOutputBufferPtr out; /* a buffered parser output */
28411     int n_out;
28412     int len; /* the size in bytes of the array. */
28413     int n_len;
28414     char * buf; /* an char array */
28415     int n_buf;
28416
28417     for (n_out = 0;n_out < gen_nb_xmlOutputBufferPtr;n_out++) {
28418     for (n_len = 0;n_len < gen_nb_int;n_len++) {
28419     for (n_buf = 0;n_buf < gen_nb_const_char_ptr;n_buf++) {
28420         mem_base = xmlMemBlocks();
28421         out = gen_xmlOutputBufferPtr(n_out, 0);
28422         len = gen_int(n_len, 1);
28423         buf = gen_const_char_ptr(n_buf, 2);
28424
28425         ret_val = xmlOutputBufferWrite(out, len, (const char *)buf);
28426         desret_int(ret_val);
28427         call_tests++;
28428         des_xmlOutputBufferPtr(n_out, out, 0);
28429         des_int(n_len, len, 1);
28430         des_const_char_ptr(n_buf, (const char *)buf, 2);
28431         xmlResetLastError();
28432         if (mem_base != xmlMemBlocks()) {
28433             printf("Leak of %d blocks found in xmlOutputBufferWrite",
28434                    xmlMemBlocks() - mem_base);
28435             test_ret++;
28436             printf(" %d", n_out);
28437             printf(" %d", n_len);
28438             printf(" %d", n_buf);
28439             printf("\n");
28440         }
28441     }
28442     }
28443     }
28444     function_tests++;
28445 #endif
28446
28447     return(test_ret);
28448 }
28449
28450
28451 static int
28452 test_xmlOutputBufferWriteEscape(void) {
28453     int test_ret = 0;
28454
28455
28456     /* missing type support */
28457     return(test_ret);
28458 }
28459
28460
28461 static int
28462 test_xmlOutputBufferWriteString(void) {
28463     int test_ret = 0;
28464
28465 #if defined(LIBXML_OUTPUT_ENABLED)
28466     int mem_base;
28467     int ret_val;
28468     xmlOutputBufferPtr out; /* a buffered parser output */
28469     int n_out;
28470     char * str; /* a zero terminated C string */
28471     int n_str;
28472
28473     for (n_out = 0;n_out < gen_nb_xmlOutputBufferPtr;n_out++) {
28474     for (n_str = 0;n_str < gen_nb_const_char_ptr;n_str++) {
28475         mem_base = xmlMemBlocks();
28476         out = gen_xmlOutputBufferPtr(n_out, 0);
28477         str = gen_const_char_ptr(n_str, 1);
28478
28479         ret_val = xmlOutputBufferWriteString(out, (const char *)str);
28480         desret_int(ret_val);
28481         call_tests++;
28482         des_xmlOutputBufferPtr(n_out, out, 0);
28483         des_const_char_ptr(n_str, (const char *)str, 1);
28484         xmlResetLastError();
28485         if (mem_base != xmlMemBlocks()) {
28486             printf("Leak of %d blocks found in xmlOutputBufferWriteString",
28487                    xmlMemBlocks() - mem_base);
28488             test_ret++;
28489             printf(" %d", n_out);
28490             printf(" %d", n_str);
28491             printf("\n");
28492         }
28493     }
28494     }
28495     function_tests++;
28496 #endif
28497
28498     return(test_ret);
28499 }
28500
28501
28502 static int
28503 test_xmlParserGetDirectory(void) {
28504     int test_ret = 0;
28505
28506
28507     /* missing type support */
28508     return(test_ret);
28509 }
28510
28511
28512 static int
28513 test_xmlParserInputBufferCreateFd(void) {
28514     int test_ret = 0;
28515
28516     int mem_base;
28517     xmlParserInputBufferPtr ret_val;
28518     int fd; /* a file descriptor number */
28519     int n_fd;
28520     xmlCharEncoding enc; /* the charset encoding if known */
28521     int n_enc;
28522
28523     for (n_fd = 0;n_fd < gen_nb_int;n_fd++) {
28524     for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
28525         mem_base = xmlMemBlocks();
28526         fd = gen_int(n_fd, 0);
28527         enc = gen_xmlCharEncoding(n_enc, 1);
28528         if (fd >= 0) fd = -1;
28529
28530         ret_val = xmlParserInputBufferCreateFd(fd, enc);
28531         desret_xmlParserInputBufferPtr(ret_val);
28532         call_tests++;
28533         des_int(n_fd, fd, 0);
28534         des_xmlCharEncoding(n_enc, enc, 1);
28535         xmlResetLastError();
28536         if (mem_base != xmlMemBlocks()) {
28537             printf("Leak of %d blocks found in xmlParserInputBufferCreateFd",
28538                    xmlMemBlocks() - mem_base);
28539             test_ret++;
28540             printf(" %d", n_fd);
28541             printf(" %d", n_enc);
28542             printf("\n");
28543         }
28544     }
28545     }
28546     function_tests++;
28547
28548     return(test_ret);
28549 }
28550
28551
28552 static int
28553 test_xmlParserInputBufferCreateFile(void) {
28554     int test_ret = 0;
28555
28556     int mem_base;
28557     xmlParserInputBufferPtr ret_val;
28558     FILE * file; /* a FILE* */
28559     int n_file;
28560     xmlCharEncoding enc; /* the charset encoding if known */
28561     int n_enc;
28562
28563     for (n_file = 0;n_file < gen_nb_FILE_ptr;n_file++) {
28564     for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
28565         mem_base = xmlMemBlocks();
28566         file = gen_FILE_ptr(n_file, 0);
28567         enc = gen_xmlCharEncoding(n_enc, 1);
28568
28569         ret_val = xmlParserInputBufferCreateFile(file, enc);
28570         desret_xmlParserInputBufferPtr(ret_val);
28571         call_tests++;
28572         des_FILE_ptr(n_file, file, 0);
28573         des_xmlCharEncoding(n_enc, enc, 1);
28574         xmlResetLastError();
28575         if (mem_base != xmlMemBlocks()) {
28576             printf("Leak of %d blocks found in xmlParserInputBufferCreateFile",
28577                    xmlMemBlocks() - mem_base);
28578             test_ret++;
28579             printf(" %d", n_file);
28580             printf(" %d", n_enc);
28581             printf("\n");
28582         }
28583     }
28584     }
28585     function_tests++;
28586
28587     return(test_ret);
28588 }
28589
28590
28591 static int
28592 test_xmlParserInputBufferCreateFilename(void) {
28593     int test_ret = 0;
28594
28595     int mem_base;
28596     xmlParserInputBufferPtr ret_val;
28597     const char * URI; /* a C string containing the URI or filename */
28598     int n_URI;
28599     xmlCharEncoding enc; /* the charset encoding if known */
28600     int n_enc;
28601
28602     for (n_URI = 0;n_URI < gen_nb_fileoutput;n_URI++) {
28603     for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
28604         mem_base = xmlMemBlocks();
28605         URI = gen_fileoutput(n_URI, 0);
28606         enc = gen_xmlCharEncoding(n_enc, 1);
28607
28608         ret_val = xmlParserInputBufferCreateFilename(URI, enc);
28609         desret_xmlParserInputBufferPtr(ret_val);
28610         call_tests++;
28611         des_fileoutput(n_URI, URI, 0);
28612         des_xmlCharEncoding(n_enc, enc, 1);
28613         xmlResetLastError();
28614         if (mem_base != xmlMemBlocks()) {
28615             printf("Leak of %d blocks found in xmlParserInputBufferCreateFilename",
28616                    xmlMemBlocks() - mem_base);
28617             test_ret++;
28618             printf(" %d", n_URI);
28619             printf(" %d", n_enc);
28620             printf("\n");
28621         }
28622     }
28623     }
28624     function_tests++;
28625
28626     return(test_ret);
28627 }
28628
28629
28630 static int
28631 test_xmlParserInputBufferCreateMem(void) {
28632     int test_ret = 0;
28633
28634     int mem_base;
28635     xmlParserInputBufferPtr ret_val;
28636     char * mem; /* the memory input */
28637     int n_mem;
28638     int size; /* the length of the memory block */
28639     int n_size;
28640     xmlCharEncoding enc; /* the charset encoding if known */
28641     int n_enc;
28642
28643     for (n_mem = 0;n_mem < gen_nb_const_char_ptr;n_mem++) {
28644     for (n_size = 0;n_size < gen_nb_int;n_size++) {
28645     for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
28646         mem_base = xmlMemBlocks();
28647         mem = gen_const_char_ptr(n_mem, 0);
28648         size = gen_int(n_size, 1);
28649         enc = gen_xmlCharEncoding(n_enc, 2);
28650
28651         ret_val = xmlParserInputBufferCreateMem((const char *)mem, size, enc);
28652         desret_xmlParserInputBufferPtr(ret_val);
28653         call_tests++;
28654         des_const_char_ptr(n_mem, (const char *)mem, 0);
28655         des_int(n_size, size, 1);
28656         des_xmlCharEncoding(n_enc, enc, 2);
28657         xmlResetLastError();
28658         if (mem_base != xmlMemBlocks()) {
28659             printf("Leak of %d blocks found in xmlParserInputBufferCreateMem",
28660                    xmlMemBlocks() - mem_base);
28661             test_ret++;
28662             printf(" %d", n_mem);
28663             printf(" %d", n_size);
28664             printf(" %d", n_enc);
28665             printf("\n");
28666         }
28667     }
28668     }
28669     }
28670     function_tests++;
28671
28672     return(test_ret);
28673 }
28674
28675
28676 static int
28677 test_xmlParserInputBufferCreateStatic(void) {
28678     int test_ret = 0;
28679
28680     int mem_base;
28681     xmlParserInputBufferPtr ret_val;
28682     char * mem; /* the memory input */
28683     int n_mem;
28684     int size; /* the length of the memory block */
28685     int n_size;
28686     xmlCharEncoding enc; /* the charset encoding if known */
28687     int n_enc;
28688
28689     for (n_mem = 0;n_mem < gen_nb_const_char_ptr;n_mem++) {
28690     for (n_size = 0;n_size < gen_nb_int;n_size++) {
28691     for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
28692         mem_base = xmlMemBlocks();
28693         mem = gen_const_char_ptr(n_mem, 0);
28694         size = gen_int(n_size, 1);
28695         enc = gen_xmlCharEncoding(n_enc, 2);
28696
28697         ret_val = xmlParserInputBufferCreateStatic((const char *)mem, size, enc);
28698         desret_xmlParserInputBufferPtr(ret_val);
28699         call_tests++;
28700         des_const_char_ptr(n_mem, (const char *)mem, 0);
28701         des_int(n_size, size, 1);
28702         des_xmlCharEncoding(n_enc, enc, 2);
28703         xmlResetLastError();
28704         if (mem_base != xmlMemBlocks()) {
28705             printf("Leak of %d blocks found in xmlParserInputBufferCreateStatic",
28706                    xmlMemBlocks() - mem_base);
28707             test_ret++;
28708             printf(" %d", n_mem);
28709             printf(" %d", n_size);
28710             printf(" %d", n_enc);
28711             printf("\n");
28712         }
28713     }
28714     }
28715     }
28716     function_tests++;
28717
28718     return(test_ret);
28719 }
28720
28721
28722 static int
28723 test_xmlParserInputBufferGrow(void) {
28724     int test_ret = 0;
28725
28726     int mem_base;
28727     int ret_val;
28728     xmlParserInputBufferPtr in; /* a buffered parser input */
28729     int n_in;
28730     int len; /* indicative value of the amount of chars to read */
28731     int n_len;
28732
28733     for (n_in = 0;n_in < gen_nb_xmlParserInputBufferPtr;n_in++) {
28734     for (n_len = 0;n_len < gen_nb_int;n_len++) {
28735         mem_base = xmlMemBlocks();
28736         in = gen_xmlParserInputBufferPtr(n_in, 0);
28737         len = gen_int(n_len, 1);
28738
28739         ret_val = xmlParserInputBufferGrow(in, len);
28740         desret_int(ret_val);
28741         call_tests++;
28742         des_xmlParserInputBufferPtr(n_in, in, 0);
28743         des_int(n_len, len, 1);
28744         xmlResetLastError();
28745         if (mem_base != xmlMemBlocks()) {
28746             printf("Leak of %d blocks found in xmlParserInputBufferGrow",
28747                    xmlMemBlocks() - mem_base);
28748             test_ret++;
28749             printf(" %d", n_in);
28750             printf(" %d", n_len);
28751             printf("\n");
28752         }
28753     }
28754     }
28755     function_tests++;
28756
28757     return(test_ret);
28758 }
28759
28760
28761 static int
28762 test_xmlParserInputBufferPush(void) {
28763     int test_ret = 0;
28764
28765     int mem_base;
28766     int ret_val;
28767     xmlParserInputBufferPtr in; /* a buffered parser input */
28768     int n_in;
28769     int len; /* the size in bytes of the array. */
28770     int n_len;
28771     char * buf; /* an char array */
28772     int n_buf;
28773
28774     for (n_in = 0;n_in < gen_nb_xmlParserInputBufferPtr;n_in++) {
28775     for (n_len = 0;n_len < gen_nb_int;n_len++) {
28776     for (n_buf = 0;n_buf < gen_nb_const_char_ptr;n_buf++) {
28777         mem_base = xmlMemBlocks();
28778         in = gen_xmlParserInputBufferPtr(n_in, 0);
28779         len = gen_int(n_len, 1);
28780         buf = gen_const_char_ptr(n_buf, 2);
28781
28782         ret_val = xmlParserInputBufferPush(in, len, (const char *)buf);
28783         desret_int(ret_val);
28784         call_tests++;
28785         des_xmlParserInputBufferPtr(n_in, in, 0);
28786         des_int(n_len, len, 1);
28787         des_const_char_ptr(n_buf, (const char *)buf, 2);
28788         xmlResetLastError();
28789         if (mem_base != xmlMemBlocks()) {
28790             printf("Leak of %d blocks found in xmlParserInputBufferPush",
28791                    xmlMemBlocks() - mem_base);
28792             test_ret++;
28793             printf(" %d", n_in);
28794             printf(" %d", n_len);
28795             printf(" %d", n_buf);
28796             printf("\n");
28797         }
28798     }
28799     }
28800     }
28801     function_tests++;
28802
28803     return(test_ret);
28804 }
28805
28806
28807 static int
28808 test_xmlParserInputBufferRead(void) {
28809     int test_ret = 0;
28810
28811     int mem_base;
28812     int ret_val;
28813     xmlParserInputBufferPtr in; /* a buffered parser input */
28814     int n_in;
28815     int len; /* indicative value of the amount of chars to read */
28816     int n_len;
28817
28818     for (n_in = 0;n_in < gen_nb_xmlParserInputBufferPtr;n_in++) {
28819     for (n_len = 0;n_len < gen_nb_int;n_len++) {
28820         mem_base = xmlMemBlocks();
28821         in = gen_xmlParserInputBufferPtr(n_in, 0);
28822         len = gen_int(n_len, 1);
28823
28824         ret_val = xmlParserInputBufferRead(in, len);
28825         desret_int(ret_val);
28826         call_tests++;
28827         des_xmlParserInputBufferPtr(n_in, in, 0);
28828         des_int(n_len, len, 1);
28829         xmlResetLastError();
28830         if (mem_base != xmlMemBlocks()) {
28831             printf("Leak of %d blocks found in xmlParserInputBufferRead",
28832                    xmlMemBlocks() - mem_base);
28833             test_ret++;
28834             printf(" %d", n_in);
28835             printf(" %d", n_len);
28836             printf("\n");
28837         }
28838     }
28839     }
28840     function_tests++;
28841
28842     return(test_ret);
28843 }
28844
28845
28846 static int
28847 test_xmlPopInputCallbacks(void) {
28848     int test_ret = 0;
28849
28850     int mem_base;
28851     int ret_val;
28852
28853         mem_base = xmlMemBlocks();
28854
28855         ret_val = xmlPopInputCallbacks();
28856         desret_int(ret_val);
28857         call_tests++;
28858         xmlResetLastError();
28859         if (mem_base != xmlMemBlocks()) {
28860             printf("Leak of %d blocks found in xmlPopInputCallbacks",
28861                    xmlMemBlocks() - mem_base);
28862             test_ret++;
28863             printf("\n");
28864         }
28865     function_tests++;
28866
28867     return(test_ret);
28868 }
28869
28870
28871 static int
28872 test_xmlRegisterDefaultInputCallbacks(void) {
28873     int test_ret = 0;
28874
28875     int mem_base;
28876
28877         mem_base = xmlMemBlocks();
28878
28879         xmlRegisterDefaultInputCallbacks();
28880         call_tests++;
28881         xmlResetLastError();
28882         if (mem_base != xmlMemBlocks()) {
28883             printf("Leak of %d blocks found in xmlRegisterDefaultInputCallbacks",
28884                    xmlMemBlocks() - mem_base);
28885             test_ret++;
28886             printf("\n");
28887         }
28888     function_tests++;
28889
28890     return(test_ret);
28891 }
28892
28893
28894 static int
28895 test_xmlRegisterDefaultOutputCallbacks(void) {
28896     int test_ret = 0;
28897
28898 #if defined(LIBXML_OUTPUT_ENABLED)
28899     int mem_base;
28900
28901         mem_base = xmlMemBlocks();
28902
28903         xmlRegisterDefaultOutputCallbacks();
28904         call_tests++;
28905         xmlResetLastError();
28906         if (mem_base != xmlMemBlocks()) {
28907             printf("Leak of %d blocks found in xmlRegisterDefaultOutputCallbacks",
28908                    xmlMemBlocks() - mem_base);
28909             test_ret++;
28910             printf("\n");
28911         }
28912     function_tests++;
28913 #endif
28914
28915     return(test_ret);
28916 }
28917
28918
28919 static int
28920 test_xmlRegisterHTTPPostCallbacks(void) {
28921     int test_ret = 0;
28922
28923 #if defined(LIBXML_OUTPUT_ENABLED) && defined(LIBXML_HTTP_ENABLED)
28924     int mem_base;
28925
28926         mem_base = xmlMemBlocks();
28927
28928         xmlRegisterHTTPPostCallbacks();
28929         call_tests++;
28930         xmlResetLastError();
28931         if (mem_base != xmlMemBlocks()) {
28932             printf("Leak of %d blocks found in xmlRegisterHTTPPostCallbacks",
28933                    xmlMemBlocks() - mem_base);
28934             test_ret++;
28935             printf("\n");
28936         }
28937     function_tests++;
28938 #endif
28939
28940     return(test_ret);
28941 }
28942
28943 static int
28944 test_xmlIO(void) {
28945     int test_ret = 0;
28946
28947     if (quiet == 0) printf("Testing xmlIO : 39 of 48 functions ...\n");
28948     test_ret += test_xmlAllocOutputBuffer();
28949     test_ret += test_xmlAllocParserInputBuffer();
28950     test_ret += test_xmlCheckFilename();
28951     test_ret += test_xmlCheckHTTPInput();
28952     test_ret += test_xmlCleanupInputCallbacks();
28953     test_ret += test_xmlCleanupOutputCallbacks();
28954     test_ret += test_xmlFileClose();
28955     test_ret += test_xmlFileMatch();
28956     test_ret += test_xmlFileOpen();
28957     test_ret += test_xmlFileRead();
28958     test_ret += test_xmlIOFTPClose();
28959     test_ret += test_xmlIOFTPMatch();
28960     test_ret += test_xmlIOFTPOpen();
28961     test_ret += test_xmlIOFTPRead();
28962     test_ret += test_xmlIOHTTPClose();
28963     test_ret += test_xmlIOHTTPMatch();
28964     test_ret += test_xmlIOHTTPOpen();
28965     test_ret += test_xmlIOHTTPRead();
28966     test_ret += test_xmlNoNetExternalEntityLoader();
28967     test_ret += test_xmlNormalizeWindowsPath();
28968     test_ret += test_xmlOutputBufferCreateBuffer();
28969     test_ret += test_xmlOutputBufferCreateFd();
28970     test_ret += test_xmlOutputBufferCreateFile();
28971     test_ret += test_xmlOutputBufferCreateFilename();
28972     test_ret += test_xmlOutputBufferFlush();
28973     test_ret += test_xmlOutputBufferWrite();
28974     test_ret += test_xmlOutputBufferWriteEscape();
28975     test_ret += test_xmlOutputBufferWriteString();
28976     test_ret += test_xmlParserGetDirectory();
28977     test_ret += test_xmlParserInputBufferCreateFd();
28978     test_ret += test_xmlParserInputBufferCreateFile();
28979     test_ret += test_xmlParserInputBufferCreateFilename();
28980     test_ret += test_xmlParserInputBufferCreateMem();
28981     test_ret += test_xmlParserInputBufferCreateStatic();
28982     test_ret += test_xmlParserInputBufferGrow();
28983     test_ret += test_xmlParserInputBufferPush();
28984     test_ret += test_xmlParserInputBufferRead();
28985     test_ret += test_xmlPopInputCallbacks();
28986     test_ret += test_xmlRegisterDefaultInputCallbacks();
28987     test_ret += test_xmlRegisterDefaultOutputCallbacks();
28988     test_ret += test_xmlRegisterHTTPPostCallbacks();
28989
28990     if (test_ret != 0)
28991         printf("Module xmlIO: %d errors\n", test_ret);
28992     return(test_ret);
28993 }
28994 #ifdef LIBXML_AUTOMATA_ENABLED
28995
28996 #define gen_nb_xmlAutomataPtr 1
28997 static xmlAutomataPtr gen_xmlAutomataPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
28998     return(NULL);
28999 }
29000 static void des_xmlAutomataPtr(int no ATTRIBUTE_UNUSED, xmlAutomataPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29001 }
29002 #endif
29003
29004
29005 static int
29006 test_xmlAutomataCompile(void) {
29007     int test_ret = 0;
29008
29009
29010     /* missing type support */
29011     return(test_ret);
29012 }
29013
29014
29015 static int
29016 test_xmlAutomataGetInitState(void) {
29017     int test_ret = 0;
29018
29019
29020     /* missing type support */
29021     return(test_ret);
29022 }
29023
29024
29025 static int
29026 test_xmlAutomataIsDeterminist(void) {
29027     int test_ret = 0;
29028
29029 #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_AUTOMATA_ENABLED)
29030     int mem_base;
29031     int ret_val;
29032     xmlAutomataPtr am; /* an automata */
29033     int n_am;
29034
29035     for (n_am = 0;n_am < gen_nb_xmlAutomataPtr;n_am++) {
29036         mem_base = xmlMemBlocks();
29037         am = gen_xmlAutomataPtr(n_am, 0);
29038
29039         ret_val = xmlAutomataIsDeterminist(am);
29040         desret_int(ret_val);
29041         call_tests++;
29042         des_xmlAutomataPtr(n_am, am, 0);
29043         xmlResetLastError();
29044         if (mem_base != xmlMemBlocks()) {
29045             printf("Leak of %d blocks found in xmlAutomataIsDeterminist",
29046                    xmlMemBlocks() - mem_base);
29047             test_ret++;
29048             printf(" %d", n_am);
29049             printf("\n");
29050         }
29051     }
29052     function_tests++;
29053 #endif
29054
29055     return(test_ret);
29056 }
29057
29058 #ifdef LIBXML_AUTOMATA_ENABLED
29059
29060 #define gen_nb_xmlAutomataStatePtr 1
29061 static xmlAutomataStatePtr gen_xmlAutomataStatePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29062     return(NULL);
29063 }
29064 static void des_xmlAutomataStatePtr(int no ATTRIBUTE_UNUSED, xmlAutomataStatePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29065 }
29066 #endif
29067
29068
29069 static int
29070 test_xmlAutomataNewAllTrans(void) {
29071     int test_ret = 0;
29072
29073
29074     /* missing type support */
29075     return(test_ret);
29076 }
29077
29078
29079 static int
29080 test_xmlAutomataNewCountTrans(void) {
29081     int test_ret = 0;
29082
29083
29084     /* missing type support */
29085     return(test_ret);
29086 }
29087
29088
29089 static int
29090 test_xmlAutomataNewCountTrans2(void) {
29091     int test_ret = 0;
29092
29093
29094     /* missing type support */
29095     return(test_ret);
29096 }
29097
29098
29099 static int
29100 test_xmlAutomataNewCountedTrans(void) {
29101     int test_ret = 0;
29102
29103
29104     /* missing type support */
29105     return(test_ret);
29106 }
29107
29108
29109 static int
29110 test_xmlAutomataNewCounter(void) {
29111     int test_ret = 0;
29112
29113 #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_AUTOMATA_ENABLED)
29114     int mem_base;
29115     int ret_val;
29116     xmlAutomataPtr am; /* an automata */
29117     int n_am;
29118     int min; /* the minimal value on the counter */
29119     int n_min;
29120     int max; /* the maximal value on the counter */
29121     int n_max;
29122
29123     for (n_am = 0;n_am < gen_nb_xmlAutomataPtr;n_am++) {
29124     for (n_min = 0;n_min < gen_nb_int;n_min++) {
29125     for (n_max = 0;n_max < gen_nb_int;n_max++) {
29126         mem_base = xmlMemBlocks();
29127         am = gen_xmlAutomataPtr(n_am, 0);
29128         min = gen_int(n_min, 1);
29129         max = gen_int(n_max, 2);
29130
29131         ret_val = xmlAutomataNewCounter(am, min, max);
29132         desret_int(ret_val);
29133         call_tests++;
29134         des_xmlAutomataPtr(n_am, am, 0);
29135         des_int(n_min, min, 1);
29136         des_int(n_max, max, 2);
29137         xmlResetLastError();
29138         if (mem_base != xmlMemBlocks()) {
29139             printf("Leak of %d blocks found in xmlAutomataNewCounter",
29140                    xmlMemBlocks() - mem_base);
29141             test_ret++;
29142             printf(" %d", n_am);
29143             printf(" %d", n_min);
29144             printf(" %d", n_max);
29145             printf("\n");
29146         }
29147     }
29148     }
29149     }
29150     function_tests++;
29151 #endif
29152
29153     return(test_ret);
29154 }
29155
29156
29157 static int
29158 test_xmlAutomataNewCounterTrans(void) {
29159     int test_ret = 0;
29160
29161
29162     /* missing type support */
29163     return(test_ret);
29164 }
29165
29166
29167 static int
29168 test_xmlAutomataNewEpsilon(void) {
29169     int test_ret = 0;
29170
29171
29172     /* missing type support */
29173     return(test_ret);
29174 }
29175
29176
29177 static int
29178 test_xmlAutomataNewNegTrans(void) {
29179     int test_ret = 0;
29180
29181
29182     /* missing type support */
29183     return(test_ret);
29184 }
29185
29186
29187 static int
29188 test_xmlAutomataNewOnceTrans(void) {
29189     int test_ret = 0;
29190
29191
29192     /* missing type support */
29193     return(test_ret);
29194 }
29195
29196
29197 static int
29198 test_xmlAutomataNewOnceTrans2(void) {
29199     int test_ret = 0;
29200
29201
29202     /* missing type support */
29203     return(test_ret);
29204 }
29205
29206
29207 static int
29208 test_xmlAutomataNewState(void) {
29209     int test_ret = 0;
29210
29211
29212     /* missing type support */
29213     return(test_ret);
29214 }
29215
29216
29217 static int
29218 test_xmlAutomataNewTransition(void) {
29219     int test_ret = 0;
29220
29221
29222     /* missing type support */
29223     return(test_ret);
29224 }
29225
29226
29227 static int
29228 test_xmlAutomataNewTransition2(void) {
29229     int test_ret = 0;
29230
29231
29232     /* missing type support */
29233     return(test_ret);
29234 }
29235
29236
29237 static int
29238 test_xmlAutomataSetFinalState(void) {
29239     int test_ret = 0;
29240
29241 #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_AUTOMATA_ENABLED)
29242     int mem_base;
29243     int ret_val;
29244     xmlAutomataPtr am; /* an automata */
29245     int n_am;
29246     xmlAutomataStatePtr state; /* a state in this automata */
29247     int n_state;
29248
29249     for (n_am = 0;n_am < gen_nb_xmlAutomataPtr;n_am++) {
29250     for (n_state = 0;n_state < gen_nb_xmlAutomataStatePtr;n_state++) {
29251         mem_base = xmlMemBlocks();
29252         am = gen_xmlAutomataPtr(n_am, 0);
29253         state = gen_xmlAutomataStatePtr(n_state, 1);
29254
29255         ret_val = xmlAutomataSetFinalState(am, state);
29256         desret_int(ret_val);
29257         call_tests++;
29258         des_xmlAutomataPtr(n_am, am, 0);
29259         des_xmlAutomataStatePtr(n_state, state, 1);
29260         xmlResetLastError();
29261         if (mem_base != xmlMemBlocks()) {
29262             printf("Leak of %d blocks found in xmlAutomataSetFinalState",
29263                    xmlMemBlocks() - mem_base);
29264             test_ret++;
29265             printf(" %d", n_am);
29266             printf(" %d", n_state);
29267             printf("\n");
29268         }
29269     }
29270     }
29271     function_tests++;
29272 #endif
29273
29274     return(test_ret);
29275 }
29276
29277
29278 static int
29279 test_xmlNewAutomata(void) {
29280     int test_ret = 0;
29281
29282
29283     /* missing type support */
29284     return(test_ret);
29285 }
29286
29287 static int
29288 test_xmlautomata(void) {
29289     int test_ret = 0;
29290
29291     if (quiet == 0) printf("Testing xmlautomata : 3 of 19 functions ...\n");
29292     test_ret += test_xmlAutomataCompile();
29293     test_ret += test_xmlAutomataGetInitState();
29294     test_ret += test_xmlAutomataIsDeterminist();
29295     test_ret += test_xmlAutomataNewAllTrans();
29296     test_ret += test_xmlAutomataNewCountTrans();
29297     test_ret += test_xmlAutomataNewCountTrans2();
29298     test_ret += test_xmlAutomataNewCountedTrans();
29299     test_ret += test_xmlAutomataNewCounter();
29300     test_ret += test_xmlAutomataNewCounterTrans();
29301     test_ret += test_xmlAutomataNewEpsilon();
29302     test_ret += test_xmlAutomataNewNegTrans();
29303     test_ret += test_xmlAutomataNewOnceTrans();
29304     test_ret += test_xmlAutomataNewOnceTrans2();
29305     test_ret += test_xmlAutomataNewState();
29306     test_ret += test_xmlAutomataNewTransition();
29307     test_ret += test_xmlAutomataNewTransition2();
29308     test_ret += test_xmlAutomataSetFinalState();
29309     test_ret += test_xmlNewAutomata();
29310
29311     if (test_ret != 0)
29312         printf("Module xmlautomata: %d errors\n", test_ret);
29313     return(test_ret);
29314 }
29315
29316 #define gen_nb_xmlGenericErrorFunc_ptr 1
29317 static xmlGenericErrorFunc * gen_xmlGenericErrorFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29318     return(NULL);
29319 }
29320 static void des_xmlGenericErrorFunc_ptr(int no ATTRIBUTE_UNUSED, xmlGenericErrorFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29321 }
29322
29323 static int
29324 test_initGenericErrorDefaultFunc(void) {
29325     int test_ret = 0;
29326
29327     int mem_base;
29328     xmlGenericErrorFunc * handler; /* the handler */
29329     int n_handler;
29330
29331     for (n_handler = 0;n_handler < gen_nb_xmlGenericErrorFunc_ptr;n_handler++) {
29332         mem_base = xmlMemBlocks();
29333         handler = gen_xmlGenericErrorFunc_ptr(n_handler, 0);
29334
29335         initGenericErrorDefaultFunc(handler);
29336         call_tests++;
29337         des_xmlGenericErrorFunc_ptr(n_handler, handler, 0);
29338         xmlResetLastError();
29339         if (mem_base != xmlMemBlocks()) {
29340             printf("Leak of %d blocks found in initGenericErrorDefaultFunc",
29341                    xmlMemBlocks() - mem_base);
29342             test_ret++;
29343             printf(" %d", n_handler);
29344             printf("\n");
29345         }
29346     }
29347     function_tests++;
29348
29349     return(test_ret);
29350 }
29351
29352
29353 #define gen_nb_xmlErrorPtr 1
29354 static xmlErrorPtr gen_xmlErrorPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29355     return(NULL);
29356 }
29357 static void des_xmlErrorPtr(int no ATTRIBUTE_UNUSED, xmlErrorPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29358 }
29359
29360 static int
29361 test_xmlCopyError(void) {
29362     int test_ret = 0;
29363
29364     int mem_base;
29365     int ret_val;
29366     xmlErrorPtr from; /* a source error */
29367     int n_from;
29368     xmlErrorPtr to; /* a target error */
29369     int n_to;
29370
29371     for (n_from = 0;n_from < gen_nb_xmlErrorPtr;n_from++) {
29372     for (n_to = 0;n_to < gen_nb_xmlErrorPtr;n_to++) {
29373         mem_base = xmlMemBlocks();
29374         from = gen_xmlErrorPtr(n_from, 0);
29375         to = gen_xmlErrorPtr(n_to, 1);
29376
29377         ret_val = xmlCopyError(from, to);
29378         desret_int(ret_val);
29379         call_tests++;
29380         des_xmlErrorPtr(n_from, from, 0);
29381         des_xmlErrorPtr(n_to, to, 1);
29382         xmlResetLastError();
29383         if (mem_base != xmlMemBlocks()) {
29384             printf("Leak of %d blocks found in xmlCopyError",
29385                    xmlMemBlocks() - mem_base);
29386             test_ret++;
29387             printf(" %d", n_from);
29388             printf(" %d", n_to);
29389             printf("\n");
29390         }
29391     }
29392     }
29393     function_tests++;
29394
29395     return(test_ret);
29396 }
29397
29398
29399 static int
29400 test_xmlCtxtGetLastError(void) {
29401     int test_ret = 0;
29402
29403
29404     /* missing type support */
29405     return(test_ret);
29406 }
29407
29408
29409 static int
29410 test_xmlCtxtResetLastError(void) {
29411     int test_ret = 0;
29412
29413     int mem_base;
29414     void * ctx; /* an XML parser context */
29415     int n_ctx;
29416
29417     for (n_ctx = 0;n_ctx < gen_nb_void_ptr;n_ctx++) {
29418         mem_base = xmlMemBlocks();
29419         ctx = gen_void_ptr(n_ctx, 0);
29420
29421         xmlCtxtResetLastError(ctx);
29422         call_tests++;
29423         des_void_ptr(n_ctx, ctx, 0);
29424         xmlResetLastError();
29425         if (mem_base != xmlMemBlocks()) {
29426             printf("Leak of %d blocks found in xmlCtxtResetLastError",
29427                    xmlMemBlocks() - mem_base);
29428             test_ret++;
29429             printf(" %d", n_ctx);
29430             printf("\n");
29431         }
29432     }
29433     function_tests++;
29434
29435     return(test_ret);
29436 }
29437
29438
29439 static int
29440 test_xmlGetLastError(void) {
29441     int test_ret = 0;
29442
29443
29444     /* missing type support */
29445     return(test_ret);
29446 }
29447
29448
29449 static int
29450 test_xmlParserError(void) {
29451     int test_ret = 0;
29452
29453
29454     /* missing type support */
29455     return(test_ret);
29456 }
29457
29458
29459 static int
29460 test_xmlParserPrintFileContext(void) {
29461     int test_ret = 0;
29462
29463     int mem_base;
29464     xmlParserInputPtr input; /* an xmlParserInputPtr input */
29465     int n_input;
29466
29467     for (n_input = 0;n_input < gen_nb_xmlParserInputPtr;n_input++) {
29468         mem_base = xmlMemBlocks();
29469         input = gen_xmlParserInputPtr(n_input, 0);
29470
29471         xmlParserPrintFileContext(input);
29472         call_tests++;
29473         des_xmlParserInputPtr(n_input, input, 0);
29474         xmlResetLastError();
29475         if (mem_base != xmlMemBlocks()) {
29476             printf("Leak of %d blocks found in xmlParserPrintFileContext",
29477                    xmlMemBlocks() - mem_base);
29478             test_ret++;
29479             printf(" %d", n_input);
29480             printf("\n");
29481         }
29482     }
29483     function_tests++;
29484
29485     return(test_ret);
29486 }
29487
29488
29489 static int
29490 test_xmlParserPrintFileInfo(void) {
29491     int test_ret = 0;
29492
29493     int mem_base;
29494     xmlParserInputPtr input; /* an xmlParserInputPtr input */
29495     int n_input;
29496
29497     for (n_input = 0;n_input < gen_nb_xmlParserInputPtr;n_input++) {
29498         mem_base = xmlMemBlocks();
29499         input = gen_xmlParserInputPtr(n_input, 0);
29500
29501         xmlParserPrintFileInfo(input);
29502         call_tests++;
29503         des_xmlParserInputPtr(n_input, input, 0);
29504         xmlResetLastError();
29505         if (mem_base != xmlMemBlocks()) {
29506             printf("Leak of %d blocks found in xmlParserPrintFileInfo",
29507                    xmlMemBlocks() - mem_base);
29508             test_ret++;
29509             printf(" %d", n_input);
29510             printf("\n");
29511         }
29512     }
29513     function_tests++;
29514
29515     return(test_ret);
29516 }
29517
29518
29519 static int
29520 test_xmlParserValidityError(void) {
29521     int test_ret = 0;
29522
29523
29524     /* missing type support */
29525     return(test_ret);
29526 }
29527
29528
29529 static int
29530 test_xmlParserValidityWarning(void) {
29531     int test_ret = 0;
29532
29533
29534     /* missing type support */
29535     return(test_ret);
29536 }
29537
29538
29539 static int
29540 test_xmlParserWarning(void) {
29541     int test_ret = 0;
29542
29543
29544     /* missing type support */
29545     return(test_ret);
29546 }
29547
29548
29549 static int
29550 test_xmlResetError(void) {
29551     int test_ret = 0;
29552
29553     int mem_base;
29554     xmlErrorPtr err; /* pointer to the error. */
29555     int n_err;
29556
29557     for (n_err = 0;n_err < gen_nb_xmlErrorPtr;n_err++) {
29558         mem_base = xmlMemBlocks();
29559         err = gen_xmlErrorPtr(n_err, 0);
29560
29561         xmlResetError(err);
29562         call_tests++;
29563         des_xmlErrorPtr(n_err, err, 0);
29564         xmlResetLastError();
29565         if (mem_base != xmlMemBlocks()) {
29566             printf("Leak of %d blocks found in xmlResetError",
29567                    xmlMemBlocks() - mem_base);
29568             test_ret++;
29569             printf(" %d", n_err);
29570             printf("\n");
29571         }
29572     }
29573     function_tests++;
29574
29575     return(test_ret);
29576 }
29577
29578
29579 static int
29580 test_xmlResetLastError(void) {
29581     int test_ret = 0;
29582
29583
29584
29585         xmlResetLastError();
29586         call_tests++;
29587         xmlResetLastError();
29588     function_tests++;
29589
29590     return(test_ret);
29591 }
29592
29593
29594 static int
29595 test_xmlSetGenericErrorFunc(void) {
29596     int test_ret = 0;
29597
29598
29599     /* missing type support */
29600     return(test_ret);
29601 }
29602
29603
29604 static int
29605 test_xmlSetStructuredErrorFunc(void) {
29606     int test_ret = 0;
29607
29608
29609     /* missing type support */
29610     return(test_ret);
29611 }
29612
29613 static int
29614 test_xmlerror(void) {
29615     int test_ret = 0;
29616
29617     if (quiet == 0) printf("Testing xmlerror : 7 of 15 functions ...\n");
29618     test_ret += test_initGenericErrorDefaultFunc();
29619     test_ret += test_xmlCopyError();
29620     test_ret += test_xmlCtxtGetLastError();
29621     test_ret += test_xmlCtxtResetLastError();
29622     test_ret += test_xmlGetLastError();
29623     test_ret += test_xmlParserError();
29624     test_ret += test_xmlParserPrintFileContext();
29625     test_ret += test_xmlParserPrintFileInfo();
29626     test_ret += test_xmlParserValidityError();
29627     test_ret += test_xmlParserValidityWarning();
29628     test_ret += test_xmlParserWarning();
29629     test_ret += test_xmlResetError();
29630     test_ret += test_xmlResetLastError();
29631     test_ret += test_xmlSetGenericErrorFunc();
29632     test_ret += test_xmlSetStructuredErrorFunc();
29633
29634     if (test_ret != 0)
29635         printf("Module xmlerror: %d errors\n", test_ret);
29636     return(test_ret);
29637 }
29638 #ifdef LIBXML_MODULES_ENABLED
29639
29640 #define gen_nb_xmlModulePtr 1
29641 static xmlModulePtr gen_xmlModulePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29642     return(NULL);
29643 }
29644 static void des_xmlModulePtr(int no ATTRIBUTE_UNUSED, xmlModulePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
29645 }
29646 #endif
29647
29648
29649 static int
29650 test_xmlModuleClose(void) {
29651     int test_ret = 0;
29652
29653 #if defined(LIBXML_MODULES_ENABLED)
29654     int mem_base;
29655     int ret_val;
29656     xmlModulePtr module; /* the module handle */
29657     int n_module;
29658
29659     for (n_module = 0;n_module < gen_nb_xmlModulePtr;n_module++) {
29660         mem_base = xmlMemBlocks();
29661         module = gen_xmlModulePtr(n_module, 0);
29662
29663         ret_val = xmlModuleClose(module);
29664         desret_int(ret_val);
29665         call_tests++;
29666         des_xmlModulePtr(n_module, module, 0);
29667         xmlResetLastError();
29668         if (mem_base != xmlMemBlocks()) {
29669             printf("Leak of %d blocks found in xmlModuleClose",
29670                    xmlMemBlocks() - mem_base);
29671             test_ret++;
29672             printf(" %d", n_module);
29673             printf("\n");
29674         }
29675     }
29676     function_tests++;
29677 #endif
29678
29679     return(test_ret);
29680 }
29681
29682
29683 static int
29684 test_xmlModuleOpen(void) {
29685     int test_ret = 0;
29686
29687
29688     /* missing type support */
29689     return(test_ret);
29690 }
29691
29692
29693 static int
29694 test_xmlModuleSymbol(void) {
29695     int test_ret = 0;
29696
29697 #if defined(LIBXML_MODULES_ENABLED)
29698     int mem_base;
29699     int ret_val;
29700     xmlModulePtr module; /* the module */
29701     int n_module;
29702     char * name; /* the name of the symbol */
29703     int n_name;
29704     void ** symbol; /* the resulting symbol address */
29705     int n_symbol;
29706
29707     for (n_module = 0;n_module < gen_nb_xmlModulePtr;n_module++) {
29708     for (n_name = 0;n_name < gen_nb_const_char_ptr;n_name++) {
29709     for (n_symbol = 0;n_symbol < gen_nb_void_ptr_ptr;n_symbol++) {
29710         mem_base = xmlMemBlocks();
29711         module = gen_xmlModulePtr(n_module, 0);
29712         name = gen_const_char_ptr(n_name, 1);
29713         symbol = gen_void_ptr_ptr(n_symbol, 2);
29714
29715         ret_val = xmlModuleSymbol(module, (const char *)name, symbol);
29716         desret_int(ret_val);
29717         call_tests++;
29718         des_xmlModulePtr(n_module, module, 0);
29719         des_const_char_ptr(n_name, (const char *)name, 1);
29720         des_void_ptr_ptr(n_symbol, symbol, 2);
29721         xmlResetLastError();
29722         if (mem_base != xmlMemBlocks()) {
29723             printf("Leak of %d blocks found in xmlModuleSymbol",
29724                    xmlMemBlocks() - mem_base);
29725             test_ret++;
29726             printf(" %d", n_module);
29727             printf(" %d", n_name);
29728             printf(" %d", n_symbol);
29729             printf("\n");
29730         }
29731     }
29732     }
29733     }
29734     function_tests++;
29735 #endif
29736
29737     return(test_ret);
29738 }
29739
29740 static int
29741 test_xmlmodule(void) {
29742     int test_ret = 0;
29743
29744     if (quiet == 0) printf("Testing xmlmodule : 2 of 4 functions ...\n");
29745     test_ret += test_xmlModuleClose();
29746     test_ret += test_xmlModuleOpen();
29747     test_ret += test_xmlModuleSymbol();
29748
29749     if (test_ret != 0)
29750         printf("Module xmlmodule: %d errors\n", test_ret);
29751     return(test_ret);
29752 }
29753
29754 static int
29755 test_xmlNewTextReader(void) {
29756     int test_ret = 0;
29757
29758 #if defined(LIBXML_READER_ENABLED)
29759     int mem_base;
29760     xmlTextReaderPtr ret_val;
29761     xmlParserInputBufferPtr input; /* the xmlParserInputBufferPtr used to read data */
29762     int n_input;
29763     const char * URI; /* the URI information for the source if available */
29764     int n_URI;
29765
29766     for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) {
29767     for (n_URI = 0;n_URI < gen_nb_filepath;n_URI++) {
29768         mem_base = xmlMemBlocks();
29769         input = gen_xmlParserInputBufferPtr(n_input, 0);
29770         URI = gen_filepath(n_URI, 1);
29771
29772         ret_val = xmlNewTextReader(input, URI);
29773         desret_xmlTextReaderPtr(ret_val);
29774         call_tests++;
29775         des_xmlParserInputBufferPtr(n_input, input, 0);
29776         des_filepath(n_URI, URI, 1);
29777         xmlResetLastError();
29778         if (mem_base != xmlMemBlocks()) {
29779             printf("Leak of %d blocks found in xmlNewTextReader",
29780                    xmlMemBlocks() - mem_base);
29781             test_ret++;
29782             printf(" %d", n_input);
29783             printf(" %d", n_URI);
29784             printf("\n");
29785         }
29786     }
29787     }
29788     function_tests++;
29789 #endif
29790
29791     return(test_ret);
29792 }
29793
29794
29795 static int
29796 test_xmlNewTextReaderFilename(void) {
29797     int test_ret = 0;
29798
29799 #if defined(LIBXML_READER_ENABLED)
29800     int mem_base;
29801     xmlTextReaderPtr ret_val;
29802     const char * URI; /* the URI of the resource to process */
29803     int n_URI;
29804
29805     for (n_URI = 0;n_URI < gen_nb_filepath;n_URI++) {
29806         mem_base = xmlMemBlocks();
29807         URI = gen_filepath(n_URI, 0);
29808
29809         ret_val = xmlNewTextReaderFilename(URI);
29810         desret_xmlTextReaderPtr(ret_val);
29811         call_tests++;
29812         des_filepath(n_URI, URI, 0);
29813         xmlResetLastError();
29814         if (mem_base != xmlMemBlocks()) {
29815             printf("Leak of %d blocks found in xmlNewTextReaderFilename",
29816                    xmlMemBlocks() - mem_base);
29817             test_ret++;
29818             printf(" %d", n_URI);
29819             printf("\n");
29820         }
29821     }
29822     function_tests++;
29823 #endif
29824
29825     return(test_ret);
29826 }
29827
29828
29829 static int
29830 test_xmlReaderForDoc(void) {
29831     int test_ret = 0;
29832
29833 #if defined(LIBXML_READER_ENABLED)
29834     int mem_base;
29835     xmlTextReaderPtr ret_val;
29836     xmlChar * cur; /* a pointer to a zero terminated string */
29837     int n_cur;
29838     const char * URL; /* the base URL to use for the document */
29839     int n_URL;
29840     char * encoding; /* the document encoding, or NULL */
29841     int n_encoding;
29842     int options; /* a combination of xmlParserOption */
29843     int n_options;
29844
29845     for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
29846     for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
29847     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
29848     for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
29849         mem_base = xmlMemBlocks();
29850         cur = gen_const_xmlChar_ptr(n_cur, 0);
29851         URL = gen_filepath(n_URL, 1);
29852         encoding = gen_const_char_ptr(n_encoding, 2);
29853         options = gen_parseroptions(n_options, 3);
29854
29855         ret_val = xmlReaderForDoc((const xmlChar *)cur, URL, (const char *)encoding, options);
29856         desret_xmlTextReaderPtr(ret_val);
29857         call_tests++;
29858         des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
29859         des_filepath(n_URL, URL, 1);
29860         des_const_char_ptr(n_encoding, (const char *)encoding, 2);
29861         des_parseroptions(n_options, options, 3);
29862         xmlResetLastError();
29863         if (mem_base != xmlMemBlocks()) {
29864             printf("Leak of %d blocks found in xmlReaderForDoc",
29865                    xmlMemBlocks() - mem_base);
29866             test_ret++;
29867             printf(" %d", n_cur);
29868             printf(" %d", n_URL);
29869             printf(" %d", n_encoding);
29870             printf(" %d", n_options);
29871             printf("\n");
29872         }
29873     }
29874     }
29875     }
29876     }
29877     function_tests++;
29878 #endif
29879
29880     return(test_ret);
29881 }
29882
29883
29884 static int
29885 test_xmlReaderForFile(void) {
29886     int test_ret = 0;
29887
29888 #if defined(LIBXML_READER_ENABLED)
29889     int mem_base;
29890     xmlTextReaderPtr ret_val;
29891     const char * filename; /* a file or URL */
29892     int n_filename;
29893     char * encoding; /* the document encoding, or NULL */
29894     int n_encoding;
29895     int options; /* a combination of xmlParserOption */
29896     int n_options;
29897
29898     for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
29899     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
29900     for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
29901         mem_base = xmlMemBlocks();
29902         filename = gen_filepath(n_filename, 0);
29903         encoding = gen_const_char_ptr(n_encoding, 1);
29904         options = gen_parseroptions(n_options, 2);
29905
29906         ret_val = xmlReaderForFile(filename, (const char *)encoding, options);
29907         desret_xmlTextReaderPtr(ret_val);
29908         call_tests++;
29909         des_filepath(n_filename, filename, 0);
29910         des_const_char_ptr(n_encoding, (const char *)encoding, 1);
29911         des_parseroptions(n_options, options, 2);
29912         xmlResetLastError();
29913         if (mem_base != xmlMemBlocks()) {
29914             printf("Leak of %d blocks found in xmlReaderForFile",
29915                    xmlMemBlocks() - mem_base);
29916             test_ret++;
29917             printf(" %d", n_filename);
29918             printf(" %d", n_encoding);
29919             printf(" %d", n_options);
29920             printf("\n");
29921         }
29922     }
29923     }
29924     }
29925     function_tests++;
29926 #endif
29927
29928     return(test_ret);
29929 }
29930
29931
29932 static int
29933 test_xmlReaderForMemory(void) {
29934     int test_ret = 0;
29935
29936 #if defined(LIBXML_READER_ENABLED)
29937     int mem_base;
29938     xmlTextReaderPtr ret_val;
29939     char * buffer; /* a pointer to a char array */
29940     int n_buffer;
29941     int size; /* the size of the array */
29942     int n_size;
29943     const char * URL; /* the base URL to use for the document */
29944     int n_URL;
29945     char * encoding; /* the document encoding, or NULL */
29946     int n_encoding;
29947     int options; /* a combination of xmlParserOption */
29948     int n_options;
29949
29950     for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
29951     for (n_size = 0;n_size < gen_nb_int;n_size++) {
29952     for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
29953     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
29954     for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
29955         mem_base = xmlMemBlocks();
29956         buffer = gen_const_char_ptr(n_buffer, 0);
29957         size = gen_int(n_size, 1);
29958         URL = gen_filepath(n_URL, 2);
29959         encoding = gen_const_char_ptr(n_encoding, 3);
29960         options = gen_parseroptions(n_options, 4);
29961
29962         ret_val = xmlReaderForMemory((const char *)buffer, size, URL, (const char *)encoding, options);
29963         desret_xmlTextReaderPtr(ret_val);
29964         call_tests++;
29965         des_const_char_ptr(n_buffer, (const char *)buffer, 0);
29966         des_int(n_size, size, 1);
29967         des_filepath(n_URL, URL, 2);
29968         des_const_char_ptr(n_encoding, (const char *)encoding, 3);
29969         des_parseroptions(n_options, options, 4);
29970         xmlResetLastError();
29971         if (mem_base != xmlMemBlocks()) {
29972             printf("Leak of %d blocks found in xmlReaderForMemory",
29973                    xmlMemBlocks() - mem_base);
29974             test_ret++;
29975             printf(" %d", n_buffer);
29976             printf(" %d", n_size);
29977             printf(" %d", n_URL);
29978             printf(" %d", n_encoding);
29979             printf(" %d", n_options);
29980             printf("\n");
29981         }
29982     }
29983     }
29984     }
29985     }
29986     }
29987     function_tests++;
29988 #endif
29989
29990     return(test_ret);
29991 }
29992
29993
29994 static int
29995 test_xmlReaderNewDoc(void) {
29996     int test_ret = 0;
29997
29998 #if defined(LIBXML_READER_ENABLED)
29999     int mem_base;
30000     int ret_val;
30001     xmlTextReaderPtr reader; /* an XML reader */
30002     int n_reader;
30003     xmlChar * cur; /* a pointer to a zero terminated string */
30004     int n_cur;
30005     const char * URL; /* the base URL to use for the document */
30006     int n_URL;
30007     char * encoding; /* the document encoding, or NULL */
30008     int n_encoding;
30009     int options; /* a combination of xmlParserOption */
30010     int n_options;
30011
30012     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30013     for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
30014     for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
30015     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
30016     for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
30017         mem_base = xmlMemBlocks();
30018         reader = gen_xmlTextReaderPtr(n_reader, 0);
30019         cur = gen_const_xmlChar_ptr(n_cur, 1);
30020         URL = gen_filepath(n_URL, 2);
30021         encoding = gen_const_char_ptr(n_encoding, 3);
30022         options = gen_parseroptions(n_options, 4);
30023
30024         ret_val = xmlReaderNewDoc(reader, (const xmlChar *)cur, URL, (const char *)encoding, options);
30025         desret_int(ret_val);
30026         call_tests++;
30027         des_xmlTextReaderPtr(n_reader, reader, 0);
30028         des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 1);
30029         des_filepath(n_URL, URL, 2);
30030         des_const_char_ptr(n_encoding, (const char *)encoding, 3);
30031         des_parseroptions(n_options, options, 4);
30032         xmlResetLastError();
30033         if (mem_base != xmlMemBlocks()) {
30034             printf("Leak of %d blocks found in xmlReaderNewDoc",
30035                    xmlMemBlocks() - mem_base);
30036             test_ret++;
30037             printf(" %d", n_reader);
30038             printf(" %d", n_cur);
30039             printf(" %d", n_URL);
30040             printf(" %d", n_encoding);
30041             printf(" %d", n_options);
30042             printf("\n");
30043         }
30044     }
30045     }
30046     }
30047     }
30048     }
30049     function_tests++;
30050 #endif
30051
30052     return(test_ret);
30053 }
30054
30055
30056 static int
30057 test_xmlReaderNewFile(void) {
30058     int test_ret = 0;
30059
30060 #if defined(LIBXML_READER_ENABLED)
30061     int mem_base;
30062     int ret_val;
30063     xmlTextReaderPtr reader; /* an XML reader */
30064     int n_reader;
30065     const char * filename; /* a file or URL */
30066     int n_filename;
30067     char * encoding; /* the document encoding, or NULL */
30068     int n_encoding;
30069     int options; /* a combination of xmlParserOption */
30070     int n_options;
30071
30072     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30073     for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
30074     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
30075     for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
30076         mem_base = xmlMemBlocks();
30077         reader = gen_xmlTextReaderPtr(n_reader, 0);
30078         filename = gen_filepath(n_filename, 1);
30079         encoding = gen_const_char_ptr(n_encoding, 2);
30080         options = gen_parseroptions(n_options, 3);
30081
30082         ret_val = xmlReaderNewFile(reader, filename, (const char *)encoding, options);
30083         desret_int(ret_val);
30084         call_tests++;
30085         des_xmlTextReaderPtr(n_reader, reader, 0);
30086         des_filepath(n_filename, filename, 1);
30087         des_const_char_ptr(n_encoding, (const char *)encoding, 2);
30088         des_parseroptions(n_options, options, 3);
30089         xmlResetLastError();
30090         if (mem_base != xmlMemBlocks()) {
30091             printf("Leak of %d blocks found in xmlReaderNewFile",
30092                    xmlMemBlocks() - mem_base);
30093             test_ret++;
30094             printf(" %d", n_reader);
30095             printf(" %d", n_filename);
30096             printf(" %d", n_encoding);
30097             printf(" %d", n_options);
30098             printf("\n");
30099         }
30100     }
30101     }
30102     }
30103     }
30104     function_tests++;
30105 #endif
30106
30107     return(test_ret);
30108 }
30109
30110
30111 static int
30112 test_xmlReaderNewMemory(void) {
30113     int test_ret = 0;
30114
30115 #if defined(LIBXML_READER_ENABLED)
30116     int mem_base;
30117     int ret_val;
30118     xmlTextReaderPtr reader; /* an XML reader */
30119     int n_reader;
30120     char * buffer; /* a pointer to a char array */
30121     int n_buffer;
30122     int size; /* the size of the array */
30123     int n_size;
30124     const char * URL; /* the base URL to use for the document */
30125     int n_URL;
30126     char * encoding; /* the document encoding, or NULL */
30127     int n_encoding;
30128     int options; /* a combination of xmlParserOption */
30129     int n_options;
30130
30131     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30132     for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
30133     for (n_size = 0;n_size < gen_nb_int;n_size++) {
30134     for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
30135     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
30136     for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
30137         mem_base = xmlMemBlocks();
30138         reader = gen_xmlTextReaderPtr(n_reader, 0);
30139         buffer = gen_const_char_ptr(n_buffer, 1);
30140         size = gen_int(n_size, 2);
30141         URL = gen_filepath(n_URL, 3);
30142         encoding = gen_const_char_ptr(n_encoding, 4);
30143         options = gen_parseroptions(n_options, 5);
30144
30145         ret_val = xmlReaderNewMemory(reader, (const char *)buffer, size, URL, (const char *)encoding, options);
30146         desret_int(ret_val);
30147         call_tests++;
30148         des_xmlTextReaderPtr(n_reader, reader, 0);
30149         des_const_char_ptr(n_buffer, (const char *)buffer, 1);
30150         des_int(n_size, size, 2);
30151         des_filepath(n_URL, URL, 3);
30152         des_const_char_ptr(n_encoding, (const char *)encoding, 4);
30153         des_parseroptions(n_options, options, 5);
30154         xmlResetLastError();
30155         if (mem_base != xmlMemBlocks()) {
30156             printf("Leak of %d blocks found in xmlReaderNewMemory",
30157                    xmlMemBlocks() - mem_base);
30158             test_ret++;
30159             printf(" %d", n_reader);
30160             printf(" %d", n_buffer);
30161             printf(" %d", n_size);
30162             printf(" %d", n_URL);
30163             printf(" %d", n_encoding);
30164             printf(" %d", n_options);
30165             printf("\n");
30166         }
30167     }
30168     }
30169     }
30170     }
30171     }
30172     }
30173     function_tests++;
30174 #endif
30175
30176     return(test_ret);
30177 }
30178
30179
30180 static int
30181 test_xmlReaderNewWalker(void) {
30182     int test_ret = 0;
30183
30184 #if defined(LIBXML_READER_ENABLED)
30185     int mem_base;
30186     int ret_val;
30187     xmlTextReaderPtr reader; /* an XML reader */
30188     int n_reader;
30189     xmlDocPtr doc; /* a preparsed document */
30190     int n_doc;
30191
30192     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30193     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
30194         mem_base = xmlMemBlocks();
30195         reader = gen_xmlTextReaderPtr(n_reader, 0);
30196         doc = gen_xmlDocPtr(n_doc, 1);
30197
30198         ret_val = xmlReaderNewWalker(reader, doc);
30199         desret_int(ret_val);
30200         call_tests++;
30201         des_xmlTextReaderPtr(n_reader, reader, 0);
30202         des_xmlDocPtr(n_doc, doc, 1);
30203         xmlResetLastError();
30204         if (mem_base != xmlMemBlocks()) {
30205             printf("Leak of %d blocks found in xmlReaderNewWalker",
30206                    xmlMemBlocks() - mem_base);
30207             test_ret++;
30208             printf(" %d", n_reader);
30209             printf(" %d", n_doc);
30210             printf("\n");
30211         }
30212     }
30213     }
30214     function_tests++;
30215 #endif
30216
30217     return(test_ret);
30218 }
30219
30220
30221 static int
30222 test_xmlReaderWalker(void) {
30223     int test_ret = 0;
30224
30225 #if defined(LIBXML_READER_ENABLED)
30226     int mem_base;
30227     xmlTextReaderPtr ret_val;
30228     xmlDocPtr doc; /* a preparsed document */
30229     int n_doc;
30230
30231     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
30232         mem_base = xmlMemBlocks();
30233         doc = gen_xmlDocPtr(n_doc, 0);
30234
30235         ret_val = xmlReaderWalker(doc);
30236         desret_xmlTextReaderPtr(ret_val);
30237         call_tests++;
30238         des_xmlDocPtr(n_doc, doc, 0);
30239         xmlResetLastError();
30240         if (mem_base != xmlMemBlocks()) {
30241             printf("Leak of %d blocks found in xmlReaderWalker",
30242                    xmlMemBlocks() - mem_base);
30243             test_ret++;
30244             printf(" %d", n_doc);
30245             printf("\n");
30246         }
30247     }
30248     function_tests++;
30249 #endif
30250
30251     return(test_ret);
30252 }
30253
30254
30255 static int
30256 test_xmlTextReaderAttributeCount(void) {
30257     int test_ret = 0;
30258
30259 #if defined(LIBXML_READER_ENABLED)
30260     int mem_base;
30261     int ret_val;
30262     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30263     int n_reader;
30264
30265     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30266         mem_base = xmlMemBlocks();
30267         reader = gen_xmlTextReaderPtr(n_reader, 0);
30268
30269         ret_val = xmlTextReaderAttributeCount(reader);
30270         desret_int(ret_val);
30271         call_tests++;
30272         des_xmlTextReaderPtr(n_reader, reader, 0);
30273         xmlResetLastError();
30274         if (mem_base != xmlMemBlocks()) {
30275             printf("Leak of %d blocks found in xmlTextReaderAttributeCount",
30276                    xmlMemBlocks() - mem_base);
30277             test_ret++;
30278             printf(" %d", n_reader);
30279             printf("\n");
30280         }
30281     }
30282     function_tests++;
30283 #endif
30284
30285     return(test_ret);
30286 }
30287
30288
30289 static int
30290 test_xmlTextReaderBaseUri(void) {
30291     int test_ret = 0;
30292
30293 #if defined(LIBXML_READER_ENABLED)
30294     int mem_base;
30295     xmlChar * ret_val;
30296     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30297     int n_reader;
30298
30299     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30300         mem_base = xmlMemBlocks();
30301         reader = gen_xmlTextReaderPtr(n_reader, 0);
30302
30303         ret_val = xmlTextReaderBaseUri(reader);
30304         desret_xmlChar_ptr(ret_val);
30305         call_tests++;
30306         des_xmlTextReaderPtr(n_reader, reader, 0);
30307         xmlResetLastError();
30308         if (mem_base != xmlMemBlocks()) {
30309             printf("Leak of %d blocks found in xmlTextReaderBaseUri",
30310                    xmlMemBlocks() - mem_base);
30311             test_ret++;
30312             printf(" %d", n_reader);
30313             printf("\n");
30314         }
30315     }
30316     function_tests++;
30317 #endif
30318
30319     return(test_ret);
30320 }
30321
30322
30323 static int
30324 test_xmlTextReaderByteConsumed(void) {
30325     int test_ret = 0;
30326
30327 #if defined(LIBXML_READER_ENABLED)
30328     int mem_base;
30329     long ret_val;
30330     xmlTextReaderPtr reader; /* an XML reader */
30331     int n_reader;
30332
30333     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30334         mem_base = xmlMemBlocks();
30335         reader = gen_xmlTextReaderPtr(n_reader, 0);
30336
30337         ret_val = xmlTextReaderByteConsumed(reader);
30338         desret_long(ret_val);
30339         call_tests++;
30340         des_xmlTextReaderPtr(n_reader, reader, 0);
30341         xmlResetLastError();
30342         if (mem_base != xmlMemBlocks()) {
30343             printf("Leak of %d blocks found in xmlTextReaderByteConsumed",
30344                    xmlMemBlocks() - mem_base);
30345             test_ret++;
30346             printf(" %d", n_reader);
30347             printf("\n");
30348         }
30349     }
30350     function_tests++;
30351 #endif
30352
30353     return(test_ret);
30354 }
30355
30356
30357 static int
30358 test_xmlTextReaderClose(void) {
30359     int test_ret = 0;
30360
30361 #if defined(LIBXML_READER_ENABLED)
30362     int mem_base;
30363     int ret_val;
30364     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30365     int n_reader;
30366
30367     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30368         mem_base = xmlMemBlocks();
30369         reader = gen_xmlTextReaderPtr(n_reader, 0);
30370
30371         ret_val = xmlTextReaderClose(reader);
30372         desret_int(ret_val);
30373         call_tests++;
30374         des_xmlTextReaderPtr(n_reader, reader, 0);
30375         xmlResetLastError();
30376         if (mem_base != xmlMemBlocks()) {
30377             printf("Leak of %d blocks found in xmlTextReaderClose",
30378                    xmlMemBlocks() - mem_base);
30379             test_ret++;
30380             printf(" %d", n_reader);
30381             printf("\n");
30382         }
30383     }
30384     function_tests++;
30385 #endif
30386
30387     return(test_ret);
30388 }
30389
30390
30391 static int
30392 test_xmlTextReaderConstBaseUri(void) {
30393     int test_ret = 0;
30394
30395 #if defined(LIBXML_READER_ENABLED)
30396     int mem_base;
30397     const xmlChar * ret_val;
30398     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30399     int n_reader;
30400
30401     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30402         mem_base = xmlMemBlocks();
30403         reader = gen_xmlTextReaderPtr(n_reader, 0);
30404
30405         ret_val = xmlTextReaderConstBaseUri(reader);
30406         desret_const_xmlChar_ptr(ret_val);
30407         call_tests++;
30408         des_xmlTextReaderPtr(n_reader, reader, 0);
30409         xmlResetLastError();
30410         if (mem_base != xmlMemBlocks()) {
30411             printf("Leak of %d blocks found in xmlTextReaderConstBaseUri",
30412                    xmlMemBlocks() - mem_base);
30413             test_ret++;
30414             printf(" %d", n_reader);
30415             printf("\n");
30416         }
30417     }
30418     function_tests++;
30419 #endif
30420
30421     return(test_ret);
30422 }
30423
30424
30425 static int
30426 test_xmlTextReaderConstEncoding(void) {
30427     int test_ret = 0;
30428
30429 #if defined(LIBXML_READER_ENABLED)
30430     int mem_base;
30431     const xmlChar * ret_val;
30432     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30433     int n_reader;
30434
30435     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30436         mem_base = xmlMemBlocks();
30437         reader = gen_xmlTextReaderPtr(n_reader, 0);
30438
30439         ret_val = xmlTextReaderConstEncoding(reader);
30440         desret_const_xmlChar_ptr(ret_val);
30441         call_tests++;
30442         des_xmlTextReaderPtr(n_reader, reader, 0);
30443         xmlResetLastError();
30444         if (mem_base != xmlMemBlocks()) {
30445             printf("Leak of %d blocks found in xmlTextReaderConstEncoding",
30446                    xmlMemBlocks() - mem_base);
30447             test_ret++;
30448             printf(" %d", n_reader);
30449             printf("\n");
30450         }
30451     }
30452     function_tests++;
30453 #endif
30454
30455     return(test_ret);
30456 }
30457
30458
30459 static int
30460 test_xmlTextReaderConstLocalName(void) {
30461     int test_ret = 0;
30462
30463 #if defined(LIBXML_READER_ENABLED)
30464     int mem_base;
30465     const xmlChar * ret_val;
30466     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30467     int n_reader;
30468
30469     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30470         mem_base = xmlMemBlocks();
30471         reader = gen_xmlTextReaderPtr(n_reader, 0);
30472
30473         ret_val = xmlTextReaderConstLocalName(reader);
30474         desret_const_xmlChar_ptr(ret_val);
30475         call_tests++;
30476         des_xmlTextReaderPtr(n_reader, reader, 0);
30477         xmlResetLastError();
30478         if (mem_base != xmlMemBlocks()) {
30479             printf("Leak of %d blocks found in xmlTextReaderConstLocalName",
30480                    xmlMemBlocks() - mem_base);
30481             test_ret++;
30482             printf(" %d", n_reader);
30483             printf("\n");
30484         }
30485     }
30486     function_tests++;
30487 #endif
30488
30489     return(test_ret);
30490 }
30491
30492
30493 static int
30494 test_xmlTextReaderConstName(void) {
30495     int test_ret = 0;
30496
30497 #if defined(LIBXML_READER_ENABLED)
30498     int mem_base;
30499     const xmlChar * ret_val;
30500     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30501     int n_reader;
30502
30503     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30504         mem_base = xmlMemBlocks();
30505         reader = gen_xmlTextReaderPtr(n_reader, 0);
30506
30507         ret_val = xmlTextReaderConstName(reader);
30508         desret_const_xmlChar_ptr(ret_val);
30509         call_tests++;
30510         des_xmlTextReaderPtr(n_reader, reader, 0);
30511         xmlResetLastError();
30512         if (mem_base != xmlMemBlocks()) {
30513             printf("Leak of %d blocks found in xmlTextReaderConstName",
30514                    xmlMemBlocks() - mem_base);
30515             test_ret++;
30516             printf(" %d", n_reader);
30517             printf("\n");
30518         }
30519     }
30520     function_tests++;
30521 #endif
30522
30523     return(test_ret);
30524 }
30525
30526
30527 static int
30528 test_xmlTextReaderConstNamespaceUri(void) {
30529     int test_ret = 0;
30530
30531 #if defined(LIBXML_READER_ENABLED)
30532     int mem_base;
30533     const xmlChar * ret_val;
30534     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30535     int n_reader;
30536
30537     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30538         mem_base = xmlMemBlocks();
30539         reader = gen_xmlTextReaderPtr(n_reader, 0);
30540
30541         ret_val = xmlTextReaderConstNamespaceUri(reader);
30542         desret_const_xmlChar_ptr(ret_val);
30543         call_tests++;
30544         des_xmlTextReaderPtr(n_reader, reader, 0);
30545         xmlResetLastError();
30546         if (mem_base != xmlMemBlocks()) {
30547             printf("Leak of %d blocks found in xmlTextReaderConstNamespaceUri",
30548                    xmlMemBlocks() - mem_base);
30549             test_ret++;
30550             printf(" %d", n_reader);
30551             printf("\n");
30552         }
30553     }
30554     function_tests++;
30555 #endif
30556
30557     return(test_ret);
30558 }
30559
30560
30561 static int
30562 test_xmlTextReaderConstPrefix(void) {
30563     int test_ret = 0;
30564
30565 #if defined(LIBXML_READER_ENABLED)
30566     int mem_base;
30567     const xmlChar * ret_val;
30568     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30569     int n_reader;
30570
30571     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30572         mem_base = xmlMemBlocks();
30573         reader = gen_xmlTextReaderPtr(n_reader, 0);
30574
30575         ret_val = xmlTextReaderConstPrefix(reader);
30576         desret_const_xmlChar_ptr(ret_val);
30577         call_tests++;
30578         des_xmlTextReaderPtr(n_reader, reader, 0);
30579         xmlResetLastError();
30580         if (mem_base != xmlMemBlocks()) {
30581             printf("Leak of %d blocks found in xmlTextReaderConstPrefix",
30582                    xmlMemBlocks() - mem_base);
30583             test_ret++;
30584             printf(" %d", n_reader);
30585             printf("\n");
30586         }
30587     }
30588     function_tests++;
30589 #endif
30590
30591     return(test_ret);
30592 }
30593
30594
30595 static int
30596 test_xmlTextReaderConstString(void) {
30597     int test_ret = 0;
30598
30599 #if defined(LIBXML_READER_ENABLED)
30600     int mem_base;
30601     const xmlChar * ret_val;
30602     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30603     int n_reader;
30604     xmlChar * str; /* the string to intern. */
30605     int n_str;
30606
30607     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30608     for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
30609         mem_base = xmlMemBlocks();
30610         reader = gen_xmlTextReaderPtr(n_reader, 0);
30611         str = gen_const_xmlChar_ptr(n_str, 1);
30612
30613         ret_val = xmlTextReaderConstString(reader, (const xmlChar *)str);
30614         desret_const_xmlChar_ptr(ret_val);
30615         call_tests++;
30616         des_xmlTextReaderPtr(n_reader, reader, 0);
30617         des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
30618         xmlResetLastError();
30619         if (mem_base != xmlMemBlocks()) {
30620             printf("Leak of %d blocks found in xmlTextReaderConstString",
30621                    xmlMemBlocks() - mem_base);
30622             test_ret++;
30623             printf(" %d", n_reader);
30624             printf(" %d", n_str);
30625             printf("\n");
30626         }
30627     }
30628     }
30629     function_tests++;
30630 #endif
30631
30632     return(test_ret);
30633 }
30634
30635
30636 static int
30637 test_xmlTextReaderConstValue(void) {
30638     int test_ret = 0;
30639
30640 #if defined(LIBXML_READER_ENABLED)
30641     int mem_base;
30642     const xmlChar * ret_val;
30643     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30644     int n_reader;
30645
30646     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30647         mem_base = xmlMemBlocks();
30648         reader = gen_xmlTextReaderPtr(n_reader, 0);
30649
30650         ret_val = xmlTextReaderConstValue(reader);
30651         desret_const_xmlChar_ptr(ret_val);
30652         call_tests++;
30653         des_xmlTextReaderPtr(n_reader, reader, 0);
30654         xmlResetLastError();
30655         if (mem_base != xmlMemBlocks()) {
30656             printf("Leak of %d blocks found in xmlTextReaderConstValue",
30657                    xmlMemBlocks() - mem_base);
30658             test_ret++;
30659             printf(" %d", n_reader);
30660             printf("\n");
30661         }
30662     }
30663     function_tests++;
30664 #endif
30665
30666     return(test_ret);
30667 }
30668
30669
30670 static int
30671 test_xmlTextReaderConstXmlLang(void) {
30672     int test_ret = 0;
30673
30674 #if defined(LIBXML_READER_ENABLED)
30675     int mem_base;
30676     const xmlChar * ret_val;
30677     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30678     int n_reader;
30679
30680     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30681         mem_base = xmlMemBlocks();
30682         reader = gen_xmlTextReaderPtr(n_reader, 0);
30683
30684         ret_val = xmlTextReaderConstXmlLang(reader);
30685         desret_const_xmlChar_ptr(ret_val);
30686         call_tests++;
30687         des_xmlTextReaderPtr(n_reader, reader, 0);
30688         xmlResetLastError();
30689         if (mem_base != xmlMemBlocks()) {
30690             printf("Leak of %d blocks found in xmlTextReaderConstXmlLang",
30691                    xmlMemBlocks() - mem_base);
30692             test_ret++;
30693             printf(" %d", n_reader);
30694             printf("\n");
30695         }
30696     }
30697     function_tests++;
30698 #endif
30699
30700     return(test_ret);
30701 }
30702
30703
30704 static int
30705 test_xmlTextReaderConstXmlVersion(void) {
30706     int test_ret = 0;
30707
30708 #if defined(LIBXML_READER_ENABLED)
30709     int mem_base;
30710     const xmlChar * ret_val;
30711     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30712     int n_reader;
30713
30714     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30715         mem_base = xmlMemBlocks();
30716         reader = gen_xmlTextReaderPtr(n_reader, 0);
30717
30718         ret_val = xmlTextReaderConstXmlVersion(reader);
30719         desret_const_xmlChar_ptr(ret_val);
30720         call_tests++;
30721         des_xmlTextReaderPtr(n_reader, reader, 0);
30722         xmlResetLastError();
30723         if (mem_base != xmlMemBlocks()) {
30724             printf("Leak of %d blocks found in xmlTextReaderConstXmlVersion",
30725                    xmlMemBlocks() - mem_base);
30726             test_ret++;
30727             printf(" %d", n_reader);
30728             printf("\n");
30729         }
30730     }
30731     function_tests++;
30732 #endif
30733
30734     return(test_ret);
30735 }
30736
30737
30738 static int
30739 test_xmlTextReaderCurrentDoc(void) {
30740     int test_ret = 0;
30741
30742 #if defined(LIBXML_READER_ENABLED)
30743     int mem_base;
30744     xmlDocPtr ret_val;
30745     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30746     int n_reader;
30747
30748     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30749         mem_base = xmlMemBlocks();
30750         reader = gen_xmlTextReaderPtr(n_reader, 0);
30751
30752         ret_val = xmlTextReaderCurrentDoc(reader);
30753         desret_xmlDocPtr(ret_val);
30754         call_tests++;
30755         des_xmlTextReaderPtr(n_reader, reader, 0);
30756         xmlResetLastError();
30757         if (mem_base != xmlMemBlocks()) {
30758             printf("Leak of %d blocks found in xmlTextReaderCurrentDoc",
30759                    xmlMemBlocks() - mem_base);
30760             test_ret++;
30761             printf(" %d", n_reader);
30762             printf("\n");
30763         }
30764     }
30765     function_tests++;
30766 #endif
30767
30768     return(test_ret);
30769 }
30770
30771
30772 static int
30773 test_xmlTextReaderCurrentNode(void) {
30774     int test_ret = 0;
30775
30776 #if defined(LIBXML_READER_ENABLED)
30777     int mem_base;
30778     xmlNodePtr ret_val;
30779     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30780     int n_reader;
30781
30782     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30783         mem_base = xmlMemBlocks();
30784         reader = gen_xmlTextReaderPtr(n_reader, 0);
30785
30786         ret_val = xmlTextReaderCurrentNode(reader);
30787         desret_xmlNodePtr(ret_val);
30788         call_tests++;
30789         des_xmlTextReaderPtr(n_reader, reader, 0);
30790         xmlResetLastError();
30791         if (mem_base != xmlMemBlocks()) {
30792             printf("Leak of %d blocks found in xmlTextReaderCurrentNode",
30793                    xmlMemBlocks() - mem_base);
30794             test_ret++;
30795             printf(" %d", n_reader);
30796             printf("\n");
30797         }
30798     }
30799     function_tests++;
30800 #endif
30801
30802     return(test_ret);
30803 }
30804
30805
30806 static int
30807 test_xmlTextReaderDepth(void) {
30808     int test_ret = 0;
30809
30810 #if defined(LIBXML_READER_ENABLED)
30811     int mem_base;
30812     int ret_val;
30813     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30814     int n_reader;
30815
30816     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30817         mem_base = xmlMemBlocks();
30818         reader = gen_xmlTextReaderPtr(n_reader, 0);
30819
30820         ret_val = xmlTextReaderDepth(reader);
30821         desret_int(ret_val);
30822         call_tests++;
30823         des_xmlTextReaderPtr(n_reader, reader, 0);
30824         xmlResetLastError();
30825         if (mem_base != xmlMemBlocks()) {
30826             printf("Leak of %d blocks found in xmlTextReaderDepth",
30827                    xmlMemBlocks() - mem_base);
30828             test_ret++;
30829             printf(" %d", n_reader);
30830             printf("\n");
30831         }
30832     }
30833     function_tests++;
30834 #endif
30835
30836     return(test_ret);
30837 }
30838
30839
30840 static int
30841 test_xmlTextReaderExpand(void) {
30842     int test_ret = 0;
30843
30844 #if defined(LIBXML_READER_ENABLED)
30845     int mem_base;
30846     xmlNodePtr ret_val;
30847     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30848     int n_reader;
30849
30850     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30851         mem_base = xmlMemBlocks();
30852         reader = gen_xmlTextReaderPtr(n_reader, 0);
30853
30854         ret_val = xmlTextReaderExpand(reader);
30855         desret_xmlNodePtr(ret_val);
30856         call_tests++;
30857         des_xmlTextReaderPtr(n_reader, reader, 0);
30858         xmlResetLastError();
30859         if (mem_base != xmlMemBlocks()) {
30860             printf("Leak of %d blocks found in xmlTextReaderExpand",
30861                    xmlMemBlocks() - mem_base);
30862             test_ret++;
30863             printf(" %d", n_reader);
30864             printf("\n");
30865         }
30866     }
30867     function_tests++;
30868 #endif
30869
30870     return(test_ret);
30871 }
30872
30873
30874 static int
30875 test_xmlTextReaderGetAttribute(void) {
30876     int test_ret = 0;
30877
30878 #if defined(LIBXML_READER_ENABLED)
30879     int mem_base;
30880     xmlChar * ret_val;
30881     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30882     int n_reader;
30883     xmlChar * name; /* the qualified name of the attribute. */
30884     int n_name;
30885
30886     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30887     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
30888         mem_base = xmlMemBlocks();
30889         reader = gen_xmlTextReaderPtr(n_reader, 0);
30890         name = gen_const_xmlChar_ptr(n_name, 1);
30891
30892         ret_val = xmlTextReaderGetAttribute(reader, (const xmlChar *)name);
30893         desret_xmlChar_ptr(ret_val);
30894         call_tests++;
30895         des_xmlTextReaderPtr(n_reader, reader, 0);
30896         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
30897         xmlResetLastError();
30898         if (mem_base != xmlMemBlocks()) {
30899             printf("Leak of %d blocks found in xmlTextReaderGetAttribute",
30900                    xmlMemBlocks() - mem_base);
30901             test_ret++;
30902             printf(" %d", n_reader);
30903             printf(" %d", n_name);
30904             printf("\n");
30905         }
30906     }
30907     }
30908     function_tests++;
30909 #endif
30910
30911     return(test_ret);
30912 }
30913
30914
30915 static int
30916 test_xmlTextReaderGetAttributeNo(void) {
30917     int test_ret = 0;
30918
30919 #if defined(LIBXML_READER_ENABLED)
30920     int mem_base;
30921     xmlChar * ret_val;
30922     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30923     int n_reader;
30924     int no; /* the zero-based index of the attribute relative to the containing element */
30925     int n_no;
30926
30927     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30928     for (n_no = 0;n_no < gen_nb_int;n_no++) {
30929         mem_base = xmlMemBlocks();
30930         reader = gen_xmlTextReaderPtr(n_reader, 0);
30931         no = gen_int(n_no, 1);
30932
30933         ret_val = xmlTextReaderGetAttributeNo(reader, no);
30934         desret_xmlChar_ptr(ret_val);
30935         call_tests++;
30936         des_xmlTextReaderPtr(n_reader, reader, 0);
30937         des_int(n_no, no, 1);
30938         xmlResetLastError();
30939         if (mem_base != xmlMemBlocks()) {
30940             printf("Leak of %d blocks found in xmlTextReaderGetAttributeNo",
30941                    xmlMemBlocks() - mem_base);
30942             test_ret++;
30943             printf(" %d", n_reader);
30944             printf(" %d", n_no);
30945             printf("\n");
30946         }
30947     }
30948     }
30949     function_tests++;
30950 #endif
30951
30952     return(test_ret);
30953 }
30954
30955
30956 static int
30957 test_xmlTextReaderGetAttributeNs(void) {
30958     int test_ret = 0;
30959
30960 #if defined(LIBXML_READER_ENABLED)
30961     int mem_base;
30962     xmlChar * ret_val;
30963     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
30964     int n_reader;
30965     xmlChar * localName; /* the local name of the attribute. */
30966     int n_localName;
30967     xmlChar * namespaceURI; /* the namespace URI of the attribute. */
30968     int n_namespaceURI;
30969
30970     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
30971     for (n_localName = 0;n_localName < gen_nb_const_xmlChar_ptr;n_localName++) {
30972     for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
30973         mem_base = xmlMemBlocks();
30974         reader = gen_xmlTextReaderPtr(n_reader, 0);
30975         localName = gen_const_xmlChar_ptr(n_localName, 1);
30976         namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 2);
30977
30978         ret_val = xmlTextReaderGetAttributeNs(reader, (const xmlChar *)localName, (const xmlChar *)namespaceURI);
30979         desret_xmlChar_ptr(ret_val);
30980         call_tests++;
30981         des_xmlTextReaderPtr(n_reader, reader, 0);
30982         des_const_xmlChar_ptr(n_localName, (const xmlChar *)localName, 1);
30983         des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 2);
30984         xmlResetLastError();
30985         if (mem_base != xmlMemBlocks()) {
30986             printf("Leak of %d blocks found in xmlTextReaderGetAttributeNs",
30987                    xmlMemBlocks() - mem_base);
30988             test_ret++;
30989             printf(" %d", n_reader);
30990             printf(" %d", n_localName);
30991             printf(" %d", n_namespaceURI);
30992             printf("\n");
30993         }
30994     }
30995     }
30996     }
30997     function_tests++;
30998 #endif
30999
31000     return(test_ret);
31001 }
31002
31003 #ifdef LIBXML_READER_ENABLED
31004
31005 #define gen_nb_xmlTextReaderErrorFunc_ptr 1
31006 static xmlTextReaderErrorFunc * gen_xmlTextReaderErrorFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
31007     return(NULL);
31008 }
31009 static void des_xmlTextReaderErrorFunc_ptr(int no ATTRIBUTE_UNUSED, xmlTextReaderErrorFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
31010 }
31011 #endif
31012
31013
31014 static int
31015 test_xmlTextReaderGetErrorHandler(void) {
31016     int test_ret = 0;
31017
31018 #if defined(LIBXML_READER_ENABLED)
31019     int mem_base;
31020     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31021     int n_reader;
31022     xmlTextReaderErrorFunc * f; /* the callback function or NULL is no callback has been registered */
31023     int n_f;
31024     void ** arg; /* a user argument */
31025     int n_arg;
31026
31027     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31028     for (n_f = 0;n_f < gen_nb_xmlTextReaderErrorFunc_ptr;n_f++) {
31029     for (n_arg = 0;n_arg < gen_nb_void_ptr_ptr;n_arg++) {
31030         mem_base = xmlMemBlocks();
31031         reader = gen_xmlTextReaderPtr(n_reader, 0);
31032         f = gen_xmlTextReaderErrorFunc_ptr(n_f, 1);
31033         arg = gen_void_ptr_ptr(n_arg, 2);
31034
31035         xmlTextReaderGetErrorHandler(reader, f, arg);
31036         call_tests++;
31037         des_xmlTextReaderPtr(n_reader, reader, 0);
31038         des_xmlTextReaderErrorFunc_ptr(n_f, f, 1);
31039         des_void_ptr_ptr(n_arg, arg, 2);
31040         xmlResetLastError();
31041         if (mem_base != xmlMemBlocks()) {
31042             printf("Leak of %d blocks found in xmlTextReaderGetErrorHandler",
31043                    xmlMemBlocks() - mem_base);
31044             test_ret++;
31045             printf(" %d", n_reader);
31046             printf(" %d", n_f);
31047             printf(" %d", n_arg);
31048             printf("\n");
31049         }
31050     }
31051     }
31052     }
31053     function_tests++;
31054 #endif
31055
31056     return(test_ret);
31057 }
31058
31059
31060 static int
31061 test_xmlTextReaderGetParserColumnNumber(void) {
31062     int test_ret = 0;
31063
31064 #if defined(LIBXML_READER_ENABLED)
31065     int mem_base;
31066     int ret_val;
31067     xmlTextReaderPtr reader; /* the user data (XML reader context) */
31068     int n_reader;
31069
31070     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31071         mem_base = xmlMemBlocks();
31072         reader = gen_xmlTextReaderPtr(n_reader, 0);
31073
31074         ret_val = xmlTextReaderGetParserColumnNumber(reader);
31075         desret_int(ret_val);
31076         call_tests++;
31077         des_xmlTextReaderPtr(n_reader, reader, 0);
31078         xmlResetLastError();
31079         if (mem_base != xmlMemBlocks()) {
31080             printf("Leak of %d blocks found in xmlTextReaderGetParserColumnNumber",
31081                    xmlMemBlocks() - mem_base);
31082             test_ret++;
31083             printf(" %d", n_reader);
31084             printf("\n");
31085         }
31086     }
31087     function_tests++;
31088 #endif
31089
31090     return(test_ret);
31091 }
31092
31093
31094 static int
31095 test_xmlTextReaderGetParserLineNumber(void) {
31096     int test_ret = 0;
31097
31098 #if defined(LIBXML_READER_ENABLED)
31099     int mem_base;
31100     int ret_val;
31101     xmlTextReaderPtr reader; /* the user data (XML reader context) */
31102     int n_reader;
31103
31104     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31105         mem_base = xmlMemBlocks();
31106         reader = gen_xmlTextReaderPtr(n_reader, 0);
31107
31108         ret_val = xmlTextReaderGetParserLineNumber(reader);
31109         desret_int(ret_val);
31110         call_tests++;
31111         des_xmlTextReaderPtr(n_reader, reader, 0);
31112         xmlResetLastError();
31113         if (mem_base != xmlMemBlocks()) {
31114             printf("Leak of %d blocks found in xmlTextReaderGetParserLineNumber",
31115                    xmlMemBlocks() - mem_base);
31116             test_ret++;
31117             printf(" %d", n_reader);
31118             printf("\n");
31119         }
31120     }
31121     function_tests++;
31122 #endif
31123
31124     return(test_ret);
31125 }
31126
31127
31128 static int
31129 test_xmlTextReaderGetParserProp(void) {
31130     int test_ret = 0;
31131
31132 #if defined(LIBXML_READER_ENABLED)
31133     int mem_base;
31134     int ret_val;
31135     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31136     int n_reader;
31137     int prop; /* the xmlParserProperties to get */
31138     int n_prop;
31139
31140     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31141     for (n_prop = 0;n_prop < gen_nb_int;n_prop++) {
31142         mem_base = xmlMemBlocks();
31143         reader = gen_xmlTextReaderPtr(n_reader, 0);
31144         prop = gen_int(n_prop, 1);
31145
31146         ret_val = xmlTextReaderGetParserProp(reader, prop);
31147         desret_int(ret_val);
31148         call_tests++;
31149         des_xmlTextReaderPtr(n_reader, reader, 0);
31150         des_int(n_prop, prop, 1);
31151         xmlResetLastError();
31152         if (mem_base != xmlMemBlocks()) {
31153             printf("Leak of %d blocks found in xmlTextReaderGetParserProp",
31154                    xmlMemBlocks() - mem_base);
31155             test_ret++;
31156             printf(" %d", n_reader);
31157             printf(" %d", n_prop);
31158             printf("\n");
31159         }
31160     }
31161     }
31162     function_tests++;
31163 #endif
31164
31165     return(test_ret);
31166 }
31167
31168
31169 static int
31170 test_xmlTextReaderGetRemainder(void) {
31171     int test_ret = 0;
31172
31173 #if defined(LIBXML_READER_ENABLED)
31174     int mem_base;
31175     xmlParserInputBufferPtr ret_val;
31176     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31177     int n_reader;
31178
31179     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31180         mem_base = xmlMemBlocks();
31181         reader = gen_xmlTextReaderPtr(n_reader, 0);
31182
31183         ret_val = xmlTextReaderGetRemainder(reader);
31184         desret_xmlParserInputBufferPtr(ret_val);
31185         call_tests++;
31186         des_xmlTextReaderPtr(n_reader, reader, 0);
31187         xmlResetLastError();
31188         if (mem_base != xmlMemBlocks()) {
31189             printf("Leak of %d blocks found in xmlTextReaderGetRemainder",
31190                    xmlMemBlocks() - mem_base);
31191             test_ret++;
31192             printf(" %d", n_reader);
31193             printf("\n");
31194         }
31195     }
31196     function_tests++;
31197 #endif
31198
31199     return(test_ret);
31200 }
31201
31202
31203 static int
31204 test_xmlTextReaderHasAttributes(void) {
31205     int test_ret = 0;
31206
31207 #if defined(LIBXML_READER_ENABLED)
31208     int mem_base;
31209     int ret_val;
31210     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31211     int n_reader;
31212
31213     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31214         mem_base = xmlMemBlocks();
31215         reader = gen_xmlTextReaderPtr(n_reader, 0);
31216
31217         ret_val = xmlTextReaderHasAttributes(reader);
31218         desret_int(ret_val);
31219         call_tests++;
31220         des_xmlTextReaderPtr(n_reader, reader, 0);
31221         xmlResetLastError();
31222         if (mem_base != xmlMemBlocks()) {
31223             printf("Leak of %d blocks found in xmlTextReaderHasAttributes",
31224                    xmlMemBlocks() - mem_base);
31225             test_ret++;
31226             printf(" %d", n_reader);
31227             printf("\n");
31228         }
31229     }
31230     function_tests++;
31231 #endif
31232
31233     return(test_ret);
31234 }
31235
31236
31237 static int
31238 test_xmlTextReaderHasValue(void) {
31239     int test_ret = 0;
31240
31241 #if defined(LIBXML_READER_ENABLED)
31242     int mem_base;
31243     int ret_val;
31244     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31245     int n_reader;
31246
31247     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31248         mem_base = xmlMemBlocks();
31249         reader = gen_xmlTextReaderPtr(n_reader, 0);
31250
31251         ret_val = xmlTextReaderHasValue(reader);
31252         desret_int(ret_val);
31253         call_tests++;
31254         des_xmlTextReaderPtr(n_reader, reader, 0);
31255         xmlResetLastError();
31256         if (mem_base != xmlMemBlocks()) {
31257             printf("Leak of %d blocks found in xmlTextReaderHasValue",
31258                    xmlMemBlocks() - mem_base);
31259             test_ret++;
31260             printf(" %d", n_reader);
31261             printf("\n");
31262         }
31263     }
31264     function_tests++;
31265 #endif
31266
31267     return(test_ret);
31268 }
31269
31270
31271 static int
31272 test_xmlTextReaderIsDefault(void) {
31273     int test_ret = 0;
31274
31275 #if defined(LIBXML_READER_ENABLED)
31276     int mem_base;
31277     int ret_val;
31278     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31279     int n_reader;
31280
31281     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31282         mem_base = xmlMemBlocks();
31283         reader = gen_xmlTextReaderPtr(n_reader, 0);
31284
31285         ret_val = xmlTextReaderIsDefault(reader);
31286         desret_int(ret_val);
31287         call_tests++;
31288         des_xmlTextReaderPtr(n_reader, reader, 0);
31289         xmlResetLastError();
31290         if (mem_base != xmlMemBlocks()) {
31291             printf("Leak of %d blocks found in xmlTextReaderIsDefault",
31292                    xmlMemBlocks() - mem_base);
31293             test_ret++;
31294             printf(" %d", n_reader);
31295             printf("\n");
31296         }
31297     }
31298     function_tests++;
31299 #endif
31300
31301     return(test_ret);
31302 }
31303
31304
31305 static int
31306 test_xmlTextReaderIsEmptyElement(void) {
31307     int test_ret = 0;
31308
31309 #if defined(LIBXML_READER_ENABLED)
31310     int mem_base;
31311     int ret_val;
31312     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31313     int n_reader;
31314
31315     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31316         mem_base = xmlMemBlocks();
31317         reader = gen_xmlTextReaderPtr(n_reader, 0);
31318
31319         ret_val = xmlTextReaderIsEmptyElement(reader);
31320         desret_int(ret_val);
31321         call_tests++;
31322         des_xmlTextReaderPtr(n_reader, reader, 0);
31323         xmlResetLastError();
31324         if (mem_base != xmlMemBlocks()) {
31325             printf("Leak of %d blocks found in xmlTextReaderIsEmptyElement",
31326                    xmlMemBlocks() - mem_base);
31327             test_ret++;
31328             printf(" %d", n_reader);
31329             printf("\n");
31330         }
31331     }
31332     function_tests++;
31333 #endif
31334
31335     return(test_ret);
31336 }
31337
31338
31339 static int
31340 test_xmlTextReaderIsNamespaceDecl(void) {
31341     int test_ret = 0;
31342
31343 #if defined(LIBXML_READER_ENABLED)
31344     int mem_base;
31345     int ret_val;
31346     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31347     int n_reader;
31348
31349     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31350         mem_base = xmlMemBlocks();
31351         reader = gen_xmlTextReaderPtr(n_reader, 0);
31352
31353         ret_val = xmlTextReaderIsNamespaceDecl(reader);
31354         desret_int(ret_val);
31355         call_tests++;
31356         des_xmlTextReaderPtr(n_reader, reader, 0);
31357         xmlResetLastError();
31358         if (mem_base != xmlMemBlocks()) {
31359             printf("Leak of %d blocks found in xmlTextReaderIsNamespaceDecl",
31360                    xmlMemBlocks() - mem_base);
31361             test_ret++;
31362             printf(" %d", n_reader);
31363             printf("\n");
31364         }
31365     }
31366     function_tests++;
31367 #endif
31368
31369     return(test_ret);
31370 }
31371
31372
31373 static int
31374 test_xmlTextReaderIsValid(void) {
31375     int test_ret = 0;
31376
31377 #if defined(LIBXML_READER_ENABLED)
31378     int mem_base;
31379     int ret_val;
31380     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31381     int n_reader;
31382
31383     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31384         mem_base = xmlMemBlocks();
31385         reader = gen_xmlTextReaderPtr(n_reader, 0);
31386
31387         ret_val = xmlTextReaderIsValid(reader);
31388         desret_int(ret_val);
31389         call_tests++;
31390         des_xmlTextReaderPtr(n_reader, reader, 0);
31391         xmlResetLastError();
31392         if (mem_base != xmlMemBlocks()) {
31393             printf("Leak of %d blocks found in xmlTextReaderIsValid",
31394                    xmlMemBlocks() - mem_base);
31395             test_ret++;
31396             printf(" %d", n_reader);
31397             printf("\n");
31398         }
31399     }
31400     function_tests++;
31401 #endif
31402
31403     return(test_ret);
31404 }
31405
31406
31407 static int
31408 test_xmlTextReaderLocalName(void) {
31409     int test_ret = 0;
31410
31411 #if defined(LIBXML_READER_ENABLED)
31412     int mem_base;
31413     xmlChar * ret_val;
31414     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31415     int n_reader;
31416
31417     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31418         mem_base = xmlMemBlocks();
31419         reader = gen_xmlTextReaderPtr(n_reader, 0);
31420
31421         ret_val = xmlTextReaderLocalName(reader);
31422         desret_xmlChar_ptr(ret_val);
31423         call_tests++;
31424         des_xmlTextReaderPtr(n_reader, reader, 0);
31425         xmlResetLastError();
31426         if (mem_base != xmlMemBlocks()) {
31427             printf("Leak of %d blocks found in xmlTextReaderLocalName",
31428                    xmlMemBlocks() - mem_base);
31429             test_ret++;
31430             printf(" %d", n_reader);
31431             printf("\n");
31432         }
31433     }
31434     function_tests++;
31435 #endif
31436
31437     return(test_ret);
31438 }
31439
31440 #ifdef LIBXML_READER_ENABLED
31441
31442 #define gen_nb_xmlTextReaderLocatorPtr 1
31443 static xmlTextReaderLocatorPtr gen_xmlTextReaderLocatorPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
31444     return(NULL);
31445 }
31446 static void des_xmlTextReaderLocatorPtr(int no ATTRIBUTE_UNUSED, xmlTextReaderLocatorPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
31447 }
31448 #endif
31449
31450
31451 static int
31452 test_xmlTextReaderLocatorBaseURI(void) {
31453     int test_ret = 0;
31454
31455 #if defined(LIBXML_READER_ENABLED)
31456     int mem_base;
31457     xmlChar * ret_val;
31458     xmlTextReaderLocatorPtr locator; /* the xmlTextReaderLocatorPtr used */
31459     int n_locator;
31460
31461     for (n_locator = 0;n_locator < gen_nb_xmlTextReaderLocatorPtr;n_locator++) {
31462         mem_base = xmlMemBlocks();
31463         locator = gen_xmlTextReaderLocatorPtr(n_locator, 0);
31464
31465         ret_val = xmlTextReaderLocatorBaseURI(locator);
31466         desret_xmlChar_ptr(ret_val);
31467         call_tests++;
31468         des_xmlTextReaderLocatorPtr(n_locator, locator, 0);
31469         xmlResetLastError();
31470         if (mem_base != xmlMemBlocks()) {
31471             printf("Leak of %d blocks found in xmlTextReaderLocatorBaseURI",
31472                    xmlMemBlocks() - mem_base);
31473             test_ret++;
31474             printf(" %d", n_locator);
31475             printf("\n");
31476         }
31477     }
31478     function_tests++;
31479 #endif
31480
31481     return(test_ret);
31482 }
31483
31484
31485 static int
31486 test_xmlTextReaderLocatorLineNumber(void) {
31487     int test_ret = 0;
31488
31489 #if defined(LIBXML_READER_ENABLED)
31490     int mem_base;
31491     int ret_val;
31492     xmlTextReaderLocatorPtr locator; /* the xmlTextReaderLocatorPtr used */
31493     int n_locator;
31494
31495     for (n_locator = 0;n_locator < gen_nb_xmlTextReaderLocatorPtr;n_locator++) {
31496         mem_base = xmlMemBlocks();
31497         locator = gen_xmlTextReaderLocatorPtr(n_locator, 0);
31498
31499         ret_val = xmlTextReaderLocatorLineNumber(locator);
31500         desret_int(ret_val);
31501         call_tests++;
31502         des_xmlTextReaderLocatorPtr(n_locator, locator, 0);
31503         xmlResetLastError();
31504         if (mem_base != xmlMemBlocks()) {
31505             printf("Leak of %d blocks found in xmlTextReaderLocatorLineNumber",
31506                    xmlMemBlocks() - mem_base);
31507             test_ret++;
31508             printf(" %d", n_locator);
31509             printf("\n");
31510         }
31511     }
31512     function_tests++;
31513 #endif
31514
31515     return(test_ret);
31516 }
31517
31518
31519 static int
31520 test_xmlTextReaderLookupNamespace(void) {
31521     int test_ret = 0;
31522
31523 #if defined(LIBXML_READER_ENABLED)
31524     int mem_base;
31525     xmlChar * ret_val;
31526     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31527     int n_reader;
31528     xmlChar * prefix; /* the prefix whose namespace URI is to be resolved. To return the default namespace, specify NULL */
31529     int n_prefix;
31530
31531     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31532     for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
31533         mem_base = xmlMemBlocks();
31534         reader = gen_xmlTextReaderPtr(n_reader, 0);
31535         prefix = gen_const_xmlChar_ptr(n_prefix, 1);
31536
31537         ret_val = xmlTextReaderLookupNamespace(reader, (const xmlChar *)prefix);
31538         desret_xmlChar_ptr(ret_val);
31539         call_tests++;
31540         des_xmlTextReaderPtr(n_reader, reader, 0);
31541         des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
31542         xmlResetLastError();
31543         if (mem_base != xmlMemBlocks()) {
31544             printf("Leak of %d blocks found in xmlTextReaderLookupNamespace",
31545                    xmlMemBlocks() - mem_base);
31546             test_ret++;
31547             printf(" %d", n_reader);
31548             printf(" %d", n_prefix);
31549             printf("\n");
31550         }
31551     }
31552     }
31553     function_tests++;
31554 #endif
31555
31556     return(test_ret);
31557 }
31558
31559
31560 static int
31561 test_xmlTextReaderMoveToAttribute(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     xmlChar * name; /* the qualified name of the attribute. */
31570     int n_name;
31571
31572     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31573     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
31574         mem_base = xmlMemBlocks();
31575         reader = gen_xmlTextReaderPtr(n_reader, 0);
31576         name = gen_const_xmlChar_ptr(n_name, 1);
31577
31578         ret_val = xmlTextReaderMoveToAttribute(reader, (const xmlChar *)name);
31579         desret_int(ret_val);
31580         call_tests++;
31581         des_xmlTextReaderPtr(n_reader, reader, 0);
31582         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
31583         xmlResetLastError();
31584         if (mem_base != xmlMemBlocks()) {
31585             printf("Leak of %d blocks found in xmlTextReaderMoveToAttribute",
31586                    xmlMemBlocks() - mem_base);
31587             test_ret++;
31588             printf(" %d", n_reader);
31589             printf(" %d", n_name);
31590             printf("\n");
31591         }
31592     }
31593     }
31594     function_tests++;
31595 #endif
31596
31597     return(test_ret);
31598 }
31599
31600
31601 static int
31602 test_xmlTextReaderMoveToAttributeNo(void) {
31603     int test_ret = 0;
31604
31605 #if defined(LIBXML_READER_ENABLED)
31606     int mem_base;
31607     int ret_val;
31608     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31609     int n_reader;
31610     int no; /* the zero-based index of the attribute relative to the containing element. */
31611     int n_no;
31612
31613     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31614     for (n_no = 0;n_no < gen_nb_int;n_no++) {
31615         mem_base = xmlMemBlocks();
31616         reader = gen_xmlTextReaderPtr(n_reader, 0);
31617         no = gen_int(n_no, 1);
31618
31619         ret_val = xmlTextReaderMoveToAttributeNo(reader, no);
31620         desret_int(ret_val);
31621         call_tests++;
31622         des_xmlTextReaderPtr(n_reader, reader, 0);
31623         des_int(n_no, no, 1);
31624         xmlResetLastError();
31625         if (mem_base != xmlMemBlocks()) {
31626             printf("Leak of %d blocks found in xmlTextReaderMoveToAttributeNo",
31627                    xmlMemBlocks() - mem_base);
31628             test_ret++;
31629             printf(" %d", n_reader);
31630             printf(" %d", n_no);
31631             printf("\n");
31632         }
31633     }
31634     }
31635     function_tests++;
31636 #endif
31637
31638     return(test_ret);
31639 }
31640
31641
31642 static int
31643 test_xmlTextReaderMoveToAttributeNs(void) {
31644     int test_ret = 0;
31645
31646 #if defined(LIBXML_READER_ENABLED)
31647     int mem_base;
31648     int ret_val;
31649     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31650     int n_reader;
31651     xmlChar * localName; /* the local name of the attribute. */
31652     int n_localName;
31653     xmlChar * namespaceURI; /* the namespace URI of the attribute. */
31654     int n_namespaceURI;
31655
31656     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31657     for (n_localName = 0;n_localName < gen_nb_const_xmlChar_ptr;n_localName++) {
31658     for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
31659         mem_base = xmlMemBlocks();
31660         reader = gen_xmlTextReaderPtr(n_reader, 0);
31661         localName = gen_const_xmlChar_ptr(n_localName, 1);
31662         namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 2);
31663
31664         ret_val = xmlTextReaderMoveToAttributeNs(reader, (const xmlChar *)localName, (const xmlChar *)namespaceURI);
31665         desret_int(ret_val);
31666         call_tests++;
31667         des_xmlTextReaderPtr(n_reader, reader, 0);
31668         des_const_xmlChar_ptr(n_localName, (const xmlChar *)localName, 1);
31669         des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 2);
31670         xmlResetLastError();
31671         if (mem_base != xmlMemBlocks()) {
31672             printf("Leak of %d blocks found in xmlTextReaderMoveToAttributeNs",
31673                    xmlMemBlocks() - mem_base);
31674             test_ret++;
31675             printf(" %d", n_reader);
31676             printf(" %d", n_localName);
31677             printf(" %d", n_namespaceURI);
31678             printf("\n");
31679         }
31680     }
31681     }
31682     }
31683     function_tests++;
31684 #endif
31685
31686     return(test_ret);
31687 }
31688
31689
31690 static int
31691 test_xmlTextReaderMoveToElement(void) {
31692     int test_ret = 0;
31693
31694 #if defined(LIBXML_READER_ENABLED)
31695     int mem_base;
31696     int ret_val;
31697     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31698     int n_reader;
31699
31700     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31701         mem_base = xmlMemBlocks();
31702         reader = gen_xmlTextReaderPtr(n_reader, 0);
31703
31704         ret_val = xmlTextReaderMoveToElement(reader);
31705         desret_int(ret_val);
31706         call_tests++;
31707         des_xmlTextReaderPtr(n_reader, reader, 0);
31708         xmlResetLastError();
31709         if (mem_base != xmlMemBlocks()) {
31710             printf("Leak of %d blocks found in xmlTextReaderMoveToElement",
31711                    xmlMemBlocks() - mem_base);
31712             test_ret++;
31713             printf(" %d", n_reader);
31714             printf("\n");
31715         }
31716     }
31717     function_tests++;
31718 #endif
31719
31720     return(test_ret);
31721 }
31722
31723
31724 static int
31725 test_xmlTextReaderMoveToFirstAttribute(void) {
31726     int test_ret = 0;
31727
31728 #if defined(LIBXML_READER_ENABLED)
31729     int mem_base;
31730     int ret_val;
31731     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31732     int n_reader;
31733
31734     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31735         mem_base = xmlMemBlocks();
31736         reader = gen_xmlTextReaderPtr(n_reader, 0);
31737
31738         ret_val = xmlTextReaderMoveToFirstAttribute(reader);
31739         desret_int(ret_val);
31740         call_tests++;
31741         des_xmlTextReaderPtr(n_reader, reader, 0);
31742         xmlResetLastError();
31743         if (mem_base != xmlMemBlocks()) {
31744             printf("Leak of %d blocks found in xmlTextReaderMoveToFirstAttribute",
31745                    xmlMemBlocks() - mem_base);
31746             test_ret++;
31747             printf(" %d", n_reader);
31748             printf("\n");
31749         }
31750     }
31751     function_tests++;
31752 #endif
31753
31754     return(test_ret);
31755 }
31756
31757
31758 static int
31759 test_xmlTextReaderMoveToNextAttribute(void) {
31760     int test_ret = 0;
31761
31762 #if defined(LIBXML_READER_ENABLED)
31763     int mem_base;
31764     int ret_val;
31765     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31766     int n_reader;
31767
31768     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31769         mem_base = xmlMemBlocks();
31770         reader = gen_xmlTextReaderPtr(n_reader, 0);
31771
31772         ret_val = xmlTextReaderMoveToNextAttribute(reader);
31773         desret_int(ret_val);
31774         call_tests++;
31775         des_xmlTextReaderPtr(n_reader, reader, 0);
31776         xmlResetLastError();
31777         if (mem_base != xmlMemBlocks()) {
31778             printf("Leak of %d blocks found in xmlTextReaderMoveToNextAttribute",
31779                    xmlMemBlocks() - mem_base);
31780             test_ret++;
31781             printf(" %d", n_reader);
31782             printf("\n");
31783         }
31784     }
31785     function_tests++;
31786 #endif
31787
31788     return(test_ret);
31789 }
31790
31791
31792 static int
31793 test_xmlTextReaderName(void) {
31794     int test_ret = 0;
31795
31796 #if defined(LIBXML_READER_ENABLED)
31797     int mem_base;
31798     xmlChar * ret_val;
31799     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31800     int n_reader;
31801
31802     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31803         mem_base = xmlMemBlocks();
31804         reader = gen_xmlTextReaderPtr(n_reader, 0);
31805
31806         ret_val = xmlTextReaderName(reader);
31807         desret_xmlChar_ptr(ret_val);
31808         call_tests++;
31809         des_xmlTextReaderPtr(n_reader, reader, 0);
31810         xmlResetLastError();
31811         if (mem_base != xmlMemBlocks()) {
31812             printf("Leak of %d blocks found in xmlTextReaderName",
31813                    xmlMemBlocks() - mem_base);
31814             test_ret++;
31815             printf(" %d", n_reader);
31816             printf("\n");
31817         }
31818     }
31819     function_tests++;
31820 #endif
31821
31822     return(test_ret);
31823 }
31824
31825
31826 static int
31827 test_xmlTextReaderNamespaceUri(void) {
31828     int test_ret = 0;
31829
31830 #if defined(LIBXML_READER_ENABLED)
31831     int mem_base;
31832     xmlChar * ret_val;
31833     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31834     int n_reader;
31835
31836     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31837         mem_base = xmlMemBlocks();
31838         reader = gen_xmlTextReaderPtr(n_reader, 0);
31839
31840         ret_val = xmlTextReaderNamespaceUri(reader);
31841         desret_xmlChar_ptr(ret_val);
31842         call_tests++;
31843         des_xmlTextReaderPtr(n_reader, reader, 0);
31844         xmlResetLastError();
31845         if (mem_base != xmlMemBlocks()) {
31846             printf("Leak of %d blocks found in xmlTextReaderNamespaceUri",
31847                    xmlMemBlocks() - mem_base);
31848             test_ret++;
31849             printf(" %d", n_reader);
31850             printf("\n");
31851         }
31852     }
31853     function_tests++;
31854 #endif
31855
31856     return(test_ret);
31857 }
31858
31859
31860 static int
31861 test_xmlTextReaderNext(void) {
31862     int test_ret = 0;
31863
31864 #if defined(LIBXML_READER_ENABLED)
31865     int mem_base;
31866     int ret_val;
31867     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31868     int n_reader;
31869
31870     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31871         mem_base = xmlMemBlocks();
31872         reader = gen_xmlTextReaderPtr(n_reader, 0);
31873
31874         ret_val = xmlTextReaderNext(reader);
31875         desret_int(ret_val);
31876         call_tests++;
31877         des_xmlTextReaderPtr(n_reader, reader, 0);
31878         xmlResetLastError();
31879         if (mem_base != xmlMemBlocks()) {
31880             printf("Leak of %d blocks found in xmlTextReaderNext",
31881                    xmlMemBlocks() - mem_base);
31882             test_ret++;
31883             printf(" %d", n_reader);
31884             printf("\n");
31885         }
31886     }
31887     function_tests++;
31888 #endif
31889
31890     return(test_ret);
31891 }
31892
31893
31894 static int
31895 test_xmlTextReaderNextSibling(void) {
31896     int test_ret = 0;
31897
31898 #if defined(LIBXML_READER_ENABLED)
31899     int mem_base;
31900     int ret_val;
31901     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31902     int n_reader;
31903
31904     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31905         mem_base = xmlMemBlocks();
31906         reader = gen_xmlTextReaderPtr(n_reader, 0);
31907
31908         ret_val = xmlTextReaderNextSibling(reader);
31909         desret_int(ret_val);
31910         call_tests++;
31911         des_xmlTextReaderPtr(n_reader, reader, 0);
31912         xmlResetLastError();
31913         if (mem_base != xmlMemBlocks()) {
31914             printf("Leak of %d blocks found in xmlTextReaderNextSibling",
31915                    xmlMemBlocks() - mem_base);
31916             test_ret++;
31917             printf(" %d", n_reader);
31918             printf("\n");
31919         }
31920     }
31921     function_tests++;
31922 #endif
31923
31924     return(test_ret);
31925 }
31926
31927
31928 static int
31929 test_xmlTextReaderNodeType(void) {
31930     int test_ret = 0;
31931
31932 #if defined(LIBXML_READER_ENABLED)
31933     int mem_base;
31934     int ret_val;
31935     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31936     int n_reader;
31937
31938     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31939         mem_base = xmlMemBlocks();
31940         reader = gen_xmlTextReaderPtr(n_reader, 0);
31941
31942         ret_val = xmlTextReaderNodeType(reader);
31943         desret_int(ret_val);
31944         call_tests++;
31945         des_xmlTextReaderPtr(n_reader, reader, 0);
31946         xmlResetLastError();
31947         if (mem_base != xmlMemBlocks()) {
31948             printf("Leak of %d blocks found in xmlTextReaderNodeType",
31949                    xmlMemBlocks() - mem_base);
31950             test_ret++;
31951             printf(" %d", n_reader);
31952             printf("\n");
31953         }
31954     }
31955     function_tests++;
31956 #endif
31957
31958     return(test_ret);
31959 }
31960
31961
31962 static int
31963 test_xmlTextReaderNormalization(void) {
31964     int test_ret = 0;
31965
31966 #if defined(LIBXML_READER_ENABLED)
31967     int mem_base;
31968     int ret_val;
31969     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
31970     int n_reader;
31971
31972     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
31973         mem_base = xmlMemBlocks();
31974         reader = gen_xmlTextReaderPtr(n_reader, 0);
31975
31976         ret_val = xmlTextReaderNormalization(reader);
31977         desret_int(ret_val);
31978         call_tests++;
31979         des_xmlTextReaderPtr(n_reader, reader, 0);
31980         xmlResetLastError();
31981         if (mem_base != xmlMemBlocks()) {
31982             printf("Leak of %d blocks found in xmlTextReaderNormalization",
31983                    xmlMemBlocks() - mem_base);
31984             test_ret++;
31985             printf(" %d", n_reader);
31986             printf("\n");
31987         }
31988     }
31989     function_tests++;
31990 #endif
31991
31992     return(test_ret);
31993 }
31994
31995
31996 static int
31997 test_xmlTextReaderPrefix(void) {
31998     int test_ret = 0;
31999
32000 #if defined(LIBXML_READER_ENABLED)
32001     int mem_base;
32002     xmlChar * ret_val;
32003     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32004     int n_reader;
32005
32006     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32007         mem_base = xmlMemBlocks();
32008         reader = gen_xmlTextReaderPtr(n_reader, 0);
32009
32010         ret_val = xmlTextReaderPrefix(reader);
32011         desret_xmlChar_ptr(ret_val);
32012         call_tests++;
32013         des_xmlTextReaderPtr(n_reader, reader, 0);
32014         xmlResetLastError();
32015         if (mem_base != xmlMemBlocks()) {
32016             printf("Leak of %d blocks found in xmlTextReaderPrefix",
32017                    xmlMemBlocks() - mem_base);
32018             test_ret++;
32019             printf(" %d", n_reader);
32020             printf("\n");
32021         }
32022     }
32023     function_tests++;
32024 #endif
32025
32026     return(test_ret);
32027 }
32028
32029
32030 static int
32031 test_xmlTextReaderPreserve(void) {
32032     int test_ret = 0;
32033
32034 #if defined(LIBXML_READER_ENABLED)
32035     int mem_base;
32036     xmlNodePtr ret_val;
32037     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32038     int n_reader;
32039
32040     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32041         mem_base = xmlMemBlocks();
32042         reader = gen_xmlTextReaderPtr(n_reader, 0);
32043
32044         ret_val = xmlTextReaderPreserve(reader);
32045         desret_xmlNodePtr(ret_val);
32046         call_tests++;
32047         des_xmlTextReaderPtr(n_reader, reader, 0);
32048         xmlResetLastError();
32049         if (mem_base != xmlMemBlocks()) {
32050             printf("Leak of %d blocks found in xmlTextReaderPreserve",
32051                    xmlMemBlocks() - mem_base);
32052             test_ret++;
32053             printf(" %d", n_reader);
32054             printf("\n");
32055         }
32056     }
32057     function_tests++;
32058 #endif
32059
32060     return(test_ret);
32061 }
32062
32063
32064 static int
32065 test_xmlTextReaderPreservePattern(void) {
32066     int test_ret = 0;
32067
32068 #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_PATTERN_ENABLED)
32069 #ifdef LIBXML_PATTERN_ENABLED
32070     int mem_base;
32071     int ret_val;
32072     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32073     int n_reader;
32074     xmlChar * pattern; /* an XPath subset pattern */
32075     int n_pattern;
32076     xmlChar ** namespaces; /* the prefix definitions, array of [URI, prefix] or NULL */
32077     int n_namespaces;
32078
32079     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32080     for (n_pattern = 0;n_pattern < gen_nb_const_xmlChar_ptr;n_pattern++) {
32081     for (n_namespaces = 0;n_namespaces < gen_nb_const_xmlChar_ptr_ptr;n_namespaces++) {
32082         mem_base = xmlMemBlocks();
32083         reader = gen_xmlTextReaderPtr(n_reader, 0);
32084         pattern = gen_const_xmlChar_ptr(n_pattern, 1);
32085         namespaces = gen_const_xmlChar_ptr_ptr(n_namespaces, 2);
32086
32087         ret_val = xmlTextReaderPreservePattern(reader, (const xmlChar *)pattern, (const xmlChar **)namespaces);
32088         desret_int(ret_val);
32089         call_tests++;
32090         des_xmlTextReaderPtr(n_reader, reader, 0);
32091         des_const_xmlChar_ptr(n_pattern, (const xmlChar *)pattern, 1);
32092         des_const_xmlChar_ptr_ptr(n_namespaces, (const xmlChar **)namespaces, 2);
32093         xmlResetLastError();
32094         if (mem_base != xmlMemBlocks()) {
32095             printf("Leak of %d blocks found in xmlTextReaderPreservePattern",
32096                    xmlMemBlocks() - mem_base);
32097             test_ret++;
32098             printf(" %d", n_reader);
32099             printf(" %d", n_pattern);
32100             printf(" %d", n_namespaces);
32101             printf("\n");
32102         }
32103     }
32104     }
32105     }
32106     function_tests++;
32107 #endif
32108 #endif
32109
32110     return(test_ret);
32111 }
32112
32113
32114 static int
32115 test_xmlTextReaderQuoteChar(void) {
32116     int test_ret = 0;
32117
32118 #if defined(LIBXML_READER_ENABLED)
32119     int mem_base;
32120     int ret_val;
32121     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32122     int n_reader;
32123
32124     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32125         mem_base = xmlMemBlocks();
32126         reader = gen_xmlTextReaderPtr(n_reader, 0);
32127
32128         ret_val = xmlTextReaderQuoteChar(reader);
32129         desret_int(ret_val);
32130         call_tests++;
32131         des_xmlTextReaderPtr(n_reader, reader, 0);
32132         xmlResetLastError();
32133         if (mem_base != xmlMemBlocks()) {
32134             printf("Leak of %d blocks found in xmlTextReaderQuoteChar",
32135                    xmlMemBlocks() - mem_base);
32136             test_ret++;
32137             printf(" %d", n_reader);
32138             printf("\n");
32139         }
32140     }
32141     function_tests++;
32142 #endif
32143
32144     return(test_ret);
32145 }
32146
32147
32148 static int
32149 test_xmlTextReaderRead(void) {
32150     int test_ret = 0;
32151
32152 #if defined(LIBXML_READER_ENABLED)
32153     int mem_base;
32154     int ret_val;
32155     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32156     int n_reader;
32157
32158     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32159         mem_base = xmlMemBlocks();
32160         reader = gen_xmlTextReaderPtr(n_reader, 0);
32161
32162         ret_val = xmlTextReaderRead(reader);
32163         desret_int(ret_val);
32164         call_tests++;
32165         des_xmlTextReaderPtr(n_reader, reader, 0);
32166         xmlResetLastError();
32167         if (mem_base != xmlMemBlocks()) {
32168             printf("Leak of %d blocks found in xmlTextReaderRead",
32169                    xmlMemBlocks() - mem_base);
32170             test_ret++;
32171             printf(" %d", n_reader);
32172             printf("\n");
32173         }
32174     }
32175     function_tests++;
32176 #endif
32177
32178     return(test_ret);
32179 }
32180
32181
32182 static int
32183 test_xmlTextReaderReadAttributeValue(void) {
32184     int test_ret = 0;
32185
32186 #if defined(LIBXML_READER_ENABLED)
32187     int mem_base;
32188     int ret_val;
32189     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32190     int n_reader;
32191
32192     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32193         mem_base = xmlMemBlocks();
32194         reader = gen_xmlTextReaderPtr(n_reader, 0);
32195
32196         ret_val = xmlTextReaderReadAttributeValue(reader);
32197         desret_int(ret_val);
32198         call_tests++;
32199         des_xmlTextReaderPtr(n_reader, reader, 0);
32200         xmlResetLastError();
32201         if (mem_base != xmlMemBlocks()) {
32202             printf("Leak of %d blocks found in xmlTextReaderReadAttributeValue",
32203                    xmlMemBlocks() - mem_base);
32204             test_ret++;
32205             printf(" %d", n_reader);
32206             printf("\n");
32207         }
32208     }
32209     function_tests++;
32210 #endif
32211
32212     return(test_ret);
32213 }
32214
32215
32216 static int
32217 test_xmlTextReaderReadState(void) {
32218     int test_ret = 0;
32219
32220 #if defined(LIBXML_READER_ENABLED)
32221     int mem_base;
32222     int ret_val;
32223     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32224     int n_reader;
32225
32226     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32227         mem_base = xmlMemBlocks();
32228         reader = gen_xmlTextReaderPtr(n_reader, 0);
32229
32230         ret_val = xmlTextReaderReadState(reader);
32231         desret_int(ret_val);
32232         call_tests++;
32233         des_xmlTextReaderPtr(n_reader, reader, 0);
32234         xmlResetLastError();
32235         if (mem_base != xmlMemBlocks()) {
32236             printf("Leak of %d blocks found in xmlTextReaderReadState",
32237                    xmlMemBlocks() - mem_base);
32238             test_ret++;
32239             printf(" %d", n_reader);
32240             printf("\n");
32241         }
32242     }
32243     function_tests++;
32244 #endif
32245
32246     return(test_ret);
32247 }
32248
32249
32250 static int
32251 test_xmlTextReaderRelaxNGSetSchema(void) {
32252     int test_ret = 0;
32253
32254 #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
32255     int mem_base;
32256     int ret_val;
32257     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32258     int n_reader;
32259     xmlRelaxNGPtr schema; /* a precompiled RelaxNG schema */
32260     int n_schema;
32261
32262     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32263     for (n_schema = 0;n_schema < gen_nb_xmlRelaxNGPtr;n_schema++) {
32264         mem_base = xmlMemBlocks();
32265         reader = gen_xmlTextReaderPtr(n_reader, 0);
32266         schema = gen_xmlRelaxNGPtr(n_schema, 1);
32267
32268         ret_val = xmlTextReaderRelaxNGSetSchema(reader, schema);
32269         desret_int(ret_val);
32270         call_tests++;
32271         des_xmlTextReaderPtr(n_reader, reader, 0);
32272         des_xmlRelaxNGPtr(n_schema, schema, 1);
32273         xmlResetLastError();
32274         if (mem_base != xmlMemBlocks()) {
32275             printf("Leak of %d blocks found in xmlTextReaderRelaxNGSetSchema",
32276                    xmlMemBlocks() - mem_base);
32277             test_ret++;
32278             printf(" %d", n_reader);
32279             printf(" %d", n_schema);
32280             printf("\n");
32281         }
32282     }
32283     }
32284     function_tests++;
32285 #endif
32286
32287     return(test_ret);
32288 }
32289
32290
32291 static int
32292 test_xmlTextReaderRelaxNGValidate(void) {
32293     int test_ret = 0;
32294
32295 #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
32296     int mem_base;
32297     int ret_val;
32298     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32299     int n_reader;
32300     char * rng; /* the path to a RelaxNG schema or NULL */
32301     int n_rng;
32302
32303     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32304     for (n_rng = 0;n_rng < gen_nb_const_char_ptr;n_rng++) {
32305         mem_base = xmlMemBlocks();
32306         reader = gen_xmlTextReaderPtr(n_reader, 0);
32307         rng = gen_const_char_ptr(n_rng, 1);
32308
32309         ret_val = xmlTextReaderRelaxNGValidate(reader, (const char *)rng);
32310         desret_int(ret_val);
32311         call_tests++;
32312         des_xmlTextReaderPtr(n_reader, reader, 0);
32313         des_const_char_ptr(n_rng, (const char *)rng, 1);
32314         xmlResetLastError();
32315         if (mem_base != xmlMemBlocks()) {
32316             printf("Leak of %d blocks found in xmlTextReaderRelaxNGValidate",
32317                    xmlMemBlocks() - mem_base);
32318             test_ret++;
32319             printf(" %d", n_reader);
32320             printf(" %d", n_rng);
32321             printf("\n");
32322         }
32323     }
32324     }
32325     function_tests++;
32326 #endif
32327
32328     return(test_ret);
32329 }
32330
32331
32332 static int
32333 test_xmlTextReaderSchemaValidate(void) {
32334     int test_ret = 0;
32335
32336 #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
32337     int ret_val;
32338     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32339     int n_reader;
32340     char * xsd; /* the path to a W3C XSD schema or NULL */
32341     int n_xsd;
32342
32343     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32344     for (n_xsd = 0;n_xsd < gen_nb_const_char_ptr;n_xsd++) {
32345         reader = gen_xmlTextReaderPtr(n_reader, 0);
32346         xsd = gen_const_char_ptr(n_xsd, 1);
32347
32348         ret_val = xmlTextReaderSchemaValidate(reader, (const char *)xsd);
32349         desret_int(ret_val);
32350         call_tests++;
32351         des_xmlTextReaderPtr(n_reader, reader, 0);
32352         des_const_char_ptr(n_xsd, (const char *)xsd, 1);
32353         xmlResetLastError();
32354     }
32355     }
32356     function_tests++;
32357 #endif
32358
32359     return(test_ret);
32360 }
32361
32362
32363 static int
32364 test_xmlTextReaderSchemaValidateCtxt(void) {
32365     int test_ret = 0;
32366
32367 #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
32368     int mem_base;
32369     int ret_val;
32370     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32371     int n_reader;
32372     xmlSchemaValidCtxtPtr ctxt; /* the XML Schema validation context or NULL */
32373     int n_ctxt;
32374     int options; /* options (not used yet) */
32375     int n_options;
32376
32377     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32378     for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
32379     for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
32380         mem_base = xmlMemBlocks();
32381         reader = gen_xmlTextReaderPtr(n_reader, 0);
32382         ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 1);
32383         options = gen_parseroptions(n_options, 2);
32384
32385         ret_val = xmlTextReaderSchemaValidateCtxt(reader, ctxt, options);
32386         desret_int(ret_val);
32387         call_tests++;
32388         des_xmlTextReaderPtr(n_reader, reader, 0);
32389         des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 1);
32390         des_parseroptions(n_options, options, 2);
32391         xmlResetLastError();
32392         if (mem_base != xmlMemBlocks()) {
32393             printf("Leak of %d blocks found in xmlTextReaderSchemaValidateCtxt",
32394                    xmlMemBlocks() - mem_base);
32395             test_ret++;
32396             printf(" %d", n_reader);
32397             printf(" %d", n_ctxt);
32398             printf(" %d", n_options);
32399             printf("\n");
32400         }
32401     }
32402     }
32403     }
32404     function_tests++;
32405 #endif
32406
32407     return(test_ret);
32408 }
32409
32410
32411 static int
32412 test_xmlTextReaderSetErrorHandler(void) {
32413     int test_ret = 0;
32414
32415
32416     /* missing type support */
32417     return(test_ret);
32418 }
32419
32420
32421 static int
32422 test_xmlTextReaderSetParserProp(void) {
32423     int test_ret = 0;
32424
32425 #if defined(LIBXML_READER_ENABLED)
32426     int mem_base;
32427     int ret_val;
32428     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32429     int n_reader;
32430     int prop; /* the xmlParserProperties to set */
32431     int n_prop;
32432     int value; /* usually 0 or 1 to (de)activate it */
32433     int n_value;
32434
32435     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32436     for (n_prop = 0;n_prop < gen_nb_int;n_prop++) {
32437     for (n_value = 0;n_value < gen_nb_int;n_value++) {
32438         mem_base = xmlMemBlocks();
32439         reader = gen_xmlTextReaderPtr(n_reader, 0);
32440         prop = gen_int(n_prop, 1);
32441         value = gen_int(n_value, 2);
32442
32443         ret_val = xmlTextReaderSetParserProp(reader, prop, value);
32444         desret_int(ret_val);
32445         call_tests++;
32446         des_xmlTextReaderPtr(n_reader, reader, 0);
32447         des_int(n_prop, prop, 1);
32448         des_int(n_value, value, 2);
32449         xmlResetLastError();
32450         if (mem_base != xmlMemBlocks()) {
32451             printf("Leak of %d blocks found in xmlTextReaderSetParserProp",
32452                    xmlMemBlocks() - mem_base);
32453             test_ret++;
32454             printf(" %d", n_reader);
32455             printf(" %d", n_prop);
32456             printf(" %d", n_value);
32457             printf("\n");
32458         }
32459     }
32460     }
32461     }
32462     function_tests++;
32463 #endif
32464
32465     return(test_ret);
32466 }
32467
32468
32469 static int
32470 test_xmlTextReaderSetSchema(void) {
32471     int test_ret = 0;
32472
32473 #if defined(LIBXML_READER_ENABLED) && defined(LIBXML_SCHEMAS_ENABLED)
32474     int mem_base;
32475     int ret_val;
32476     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32477     int n_reader;
32478     xmlSchemaPtr schema; /* a precompiled Schema schema */
32479     int n_schema;
32480
32481     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32482     for (n_schema = 0;n_schema < gen_nb_xmlSchemaPtr;n_schema++) {
32483         mem_base = xmlMemBlocks();
32484         reader = gen_xmlTextReaderPtr(n_reader, 0);
32485         schema = gen_xmlSchemaPtr(n_schema, 1);
32486
32487         ret_val = xmlTextReaderSetSchema(reader, schema);
32488         desret_int(ret_val);
32489         call_tests++;
32490         des_xmlTextReaderPtr(n_reader, reader, 0);
32491         des_xmlSchemaPtr(n_schema, schema, 1);
32492         xmlResetLastError();
32493         if (mem_base != xmlMemBlocks()) {
32494             printf("Leak of %d blocks found in xmlTextReaderSetSchema",
32495                    xmlMemBlocks() - mem_base);
32496             test_ret++;
32497             printf(" %d", n_reader);
32498             printf(" %d", n_schema);
32499             printf("\n");
32500         }
32501     }
32502     }
32503     function_tests++;
32504 #endif
32505
32506     return(test_ret);
32507 }
32508
32509
32510 static int
32511 test_xmlTextReaderSetStructuredErrorHandler(void) {
32512     int test_ret = 0;
32513
32514
32515     /* missing type support */
32516     return(test_ret);
32517 }
32518
32519
32520 static int
32521 test_xmlTextReaderSetup(void) {
32522     int test_ret = 0;
32523
32524 #if defined(LIBXML_READER_ENABLED)
32525     int mem_base;
32526     int ret_val;
32527     xmlTextReaderPtr reader; /* an XML reader */
32528     int n_reader;
32529     xmlParserInputBufferPtr input; /* xmlParserInputBufferPtr used to feed the reader, will be destroyed with it. */
32530     int n_input;
32531     const char * URL; /* the base URL to use for the document */
32532     int n_URL;
32533     char * encoding; /* the document encoding, or NULL */
32534     int n_encoding;
32535     int options; /* a combination of xmlParserOption */
32536     int n_options;
32537
32538     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32539     for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) {
32540     for (n_URL = 0;n_URL < gen_nb_filepath;n_URL++) {
32541     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
32542     for (n_options = 0;n_options < gen_nb_parseroptions;n_options++) {
32543         mem_base = xmlMemBlocks();
32544         reader = gen_xmlTextReaderPtr(n_reader, 0);
32545         input = gen_xmlParserInputBufferPtr(n_input, 1);
32546         URL = gen_filepath(n_URL, 2);
32547         encoding = gen_const_char_ptr(n_encoding, 3);
32548         options = gen_parseroptions(n_options, 4);
32549
32550         ret_val = xmlTextReaderSetup(reader, input, URL, (const char *)encoding, options);
32551         desret_int(ret_val);
32552         call_tests++;
32553         des_xmlTextReaderPtr(n_reader, reader, 0);
32554         des_filepath(n_URL, URL, 2);
32555         des_const_char_ptr(n_encoding, (const char *)encoding, 3);
32556         des_parseroptions(n_options, options, 4);
32557         xmlResetLastError();
32558         if (mem_base != xmlMemBlocks()) {
32559             printf("Leak of %d blocks found in xmlTextReaderSetup",
32560                    xmlMemBlocks() - mem_base);
32561             test_ret++;
32562             printf(" %d", n_reader);
32563             printf(" %d", n_input);
32564             printf(" %d", n_URL);
32565             printf(" %d", n_encoding);
32566             printf(" %d", n_options);
32567             printf("\n");
32568         }
32569     }
32570     }
32571     }
32572     }
32573     }
32574     function_tests++;
32575 #endif
32576
32577     return(test_ret);
32578 }
32579
32580
32581 static int
32582 test_xmlTextReaderStandalone(void) {
32583     int test_ret = 0;
32584
32585 #if defined(LIBXML_READER_ENABLED)
32586     int mem_base;
32587     int ret_val;
32588     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32589     int n_reader;
32590
32591     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32592         mem_base = xmlMemBlocks();
32593         reader = gen_xmlTextReaderPtr(n_reader, 0);
32594
32595         ret_val = xmlTextReaderStandalone(reader);
32596         desret_int(ret_val);
32597         call_tests++;
32598         des_xmlTextReaderPtr(n_reader, reader, 0);
32599         xmlResetLastError();
32600         if (mem_base != xmlMemBlocks()) {
32601             printf("Leak of %d blocks found in xmlTextReaderStandalone",
32602                    xmlMemBlocks() - mem_base);
32603             test_ret++;
32604             printf(" %d", n_reader);
32605             printf("\n");
32606         }
32607     }
32608     function_tests++;
32609 #endif
32610
32611     return(test_ret);
32612 }
32613
32614
32615 static int
32616 test_xmlTextReaderValue(void) {
32617     int test_ret = 0;
32618
32619 #if defined(LIBXML_READER_ENABLED)
32620     int mem_base;
32621     xmlChar * ret_val;
32622     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32623     int n_reader;
32624
32625     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32626         mem_base = xmlMemBlocks();
32627         reader = gen_xmlTextReaderPtr(n_reader, 0);
32628
32629         ret_val = xmlTextReaderValue(reader);
32630         desret_xmlChar_ptr(ret_val);
32631         call_tests++;
32632         des_xmlTextReaderPtr(n_reader, reader, 0);
32633         xmlResetLastError();
32634         if (mem_base != xmlMemBlocks()) {
32635             printf("Leak of %d blocks found in xmlTextReaderValue",
32636                    xmlMemBlocks() - mem_base);
32637             test_ret++;
32638             printf(" %d", n_reader);
32639             printf("\n");
32640         }
32641     }
32642     function_tests++;
32643 #endif
32644
32645     return(test_ret);
32646 }
32647
32648
32649 static int
32650 test_xmlTextReaderXmlLang(void) {
32651     int test_ret = 0;
32652
32653 #if defined(LIBXML_READER_ENABLED)
32654     int mem_base;
32655     xmlChar * ret_val;
32656     xmlTextReaderPtr reader; /* the xmlTextReaderPtr used */
32657     int n_reader;
32658
32659     for (n_reader = 0;n_reader < gen_nb_xmlTextReaderPtr;n_reader++) {
32660         mem_base = xmlMemBlocks();
32661         reader = gen_xmlTextReaderPtr(n_reader, 0);
32662
32663         ret_val = xmlTextReaderXmlLang(reader);
32664         desret_xmlChar_ptr(ret_val);
32665         call_tests++;
32666         des_xmlTextReaderPtr(n_reader, reader, 0);
32667         xmlResetLastError();
32668         if (mem_base != xmlMemBlocks()) {
32669             printf("Leak of %d blocks found in xmlTextReaderXmlLang",
32670                    xmlMemBlocks() - mem_base);
32671             test_ret++;
32672             printf(" %d", n_reader);
32673             printf("\n");
32674         }
32675     }
32676     function_tests++;
32677 #endif
32678
32679     return(test_ret);
32680 }
32681
32682 static int
32683 test_xmlreader(void) {
32684     int test_ret = 0;
32685
32686     if (quiet == 0) printf("Testing xmlreader : 75 of 85 functions ...\n");
32687     test_ret += test_xmlNewTextReader();
32688     test_ret += test_xmlNewTextReaderFilename();
32689     test_ret += test_xmlReaderForDoc();
32690     test_ret += test_xmlReaderForFile();
32691     test_ret += test_xmlReaderForMemory();
32692     test_ret += test_xmlReaderNewDoc();
32693     test_ret += test_xmlReaderNewFile();
32694     test_ret += test_xmlReaderNewMemory();
32695     test_ret += test_xmlReaderNewWalker();
32696     test_ret += test_xmlReaderWalker();
32697     test_ret += test_xmlTextReaderAttributeCount();
32698     test_ret += test_xmlTextReaderBaseUri();
32699     test_ret += test_xmlTextReaderByteConsumed();
32700     test_ret += test_xmlTextReaderClose();
32701     test_ret += test_xmlTextReaderConstBaseUri();
32702     test_ret += test_xmlTextReaderConstEncoding();
32703     test_ret += test_xmlTextReaderConstLocalName();
32704     test_ret += test_xmlTextReaderConstName();
32705     test_ret += test_xmlTextReaderConstNamespaceUri();
32706     test_ret += test_xmlTextReaderConstPrefix();
32707     test_ret += test_xmlTextReaderConstString();
32708     test_ret += test_xmlTextReaderConstValue();
32709     test_ret += test_xmlTextReaderConstXmlLang();
32710     test_ret += test_xmlTextReaderConstXmlVersion();
32711     test_ret += test_xmlTextReaderCurrentDoc();
32712     test_ret += test_xmlTextReaderCurrentNode();
32713     test_ret += test_xmlTextReaderDepth();
32714     test_ret += test_xmlTextReaderExpand();
32715     test_ret += test_xmlTextReaderGetAttribute();
32716     test_ret += test_xmlTextReaderGetAttributeNo();
32717     test_ret += test_xmlTextReaderGetAttributeNs();
32718     test_ret += test_xmlTextReaderGetErrorHandler();
32719     test_ret += test_xmlTextReaderGetParserColumnNumber();
32720     test_ret += test_xmlTextReaderGetParserLineNumber();
32721     test_ret += test_xmlTextReaderGetParserProp();
32722     test_ret += test_xmlTextReaderGetRemainder();
32723     test_ret += test_xmlTextReaderHasAttributes();
32724     test_ret += test_xmlTextReaderHasValue();
32725     test_ret += test_xmlTextReaderIsDefault();
32726     test_ret += test_xmlTextReaderIsEmptyElement();
32727     test_ret += test_xmlTextReaderIsNamespaceDecl();
32728     test_ret += test_xmlTextReaderIsValid();
32729     test_ret += test_xmlTextReaderLocalName();
32730     test_ret += test_xmlTextReaderLocatorBaseURI();
32731     test_ret += test_xmlTextReaderLocatorLineNumber();
32732     test_ret += test_xmlTextReaderLookupNamespace();
32733     test_ret += test_xmlTextReaderMoveToAttribute();
32734     test_ret += test_xmlTextReaderMoveToAttributeNo();
32735     test_ret += test_xmlTextReaderMoveToAttributeNs();
32736     test_ret += test_xmlTextReaderMoveToElement();
32737     test_ret += test_xmlTextReaderMoveToFirstAttribute();
32738     test_ret += test_xmlTextReaderMoveToNextAttribute();
32739     test_ret += test_xmlTextReaderName();
32740     test_ret += test_xmlTextReaderNamespaceUri();
32741     test_ret += test_xmlTextReaderNext();
32742     test_ret += test_xmlTextReaderNextSibling();
32743     test_ret += test_xmlTextReaderNodeType();
32744     test_ret += test_xmlTextReaderNormalization();
32745     test_ret += test_xmlTextReaderPrefix();
32746     test_ret += test_xmlTextReaderPreserve();
32747     test_ret += test_xmlTextReaderPreservePattern();
32748     test_ret += test_xmlTextReaderQuoteChar();
32749     test_ret += test_xmlTextReaderRead();
32750     test_ret += test_xmlTextReaderReadAttributeValue();
32751     test_ret += test_xmlTextReaderReadState();
32752     test_ret += test_xmlTextReaderRelaxNGSetSchema();
32753     test_ret += test_xmlTextReaderRelaxNGValidate();
32754     test_ret += test_xmlTextReaderSchemaValidate();
32755     test_ret += test_xmlTextReaderSchemaValidateCtxt();
32756     test_ret += test_xmlTextReaderSetErrorHandler();
32757     test_ret += test_xmlTextReaderSetParserProp();
32758     test_ret += test_xmlTextReaderSetSchema();
32759     test_ret += test_xmlTextReaderSetStructuredErrorHandler();
32760     test_ret += test_xmlTextReaderSetup();
32761     test_ret += test_xmlTextReaderStandalone();
32762     test_ret += test_xmlTextReaderValue();
32763     test_ret += test_xmlTextReaderXmlLang();
32764
32765     if (test_ret != 0)
32766         printf("Module xmlreader: %d errors\n", test_ret);
32767     return(test_ret);
32768 }
32769
32770 static int
32771 test_xmlExpCtxtNbCons(void) {
32772     int test_ret = 0;
32773
32774 #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
32775     int mem_base;
32776     int ret_val;
32777     xmlExpCtxtPtr ctxt; /* an expression context */
32778     int n_ctxt;
32779
32780     for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) {
32781         mem_base = xmlMemBlocks();
32782         ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0);
32783
32784         ret_val = xmlExpCtxtNbCons(ctxt);
32785         desret_int(ret_val);
32786         call_tests++;
32787         des_xmlExpCtxtPtr(n_ctxt, ctxt, 0);
32788         xmlResetLastError();
32789         if (mem_base != xmlMemBlocks()) {
32790             printf("Leak of %d blocks found in xmlExpCtxtNbCons",
32791                    xmlMemBlocks() - mem_base);
32792             test_ret++;
32793             printf(" %d", n_ctxt);
32794             printf("\n");
32795         }
32796     }
32797     function_tests++;
32798 #endif
32799
32800     return(test_ret);
32801 }
32802
32803
32804 static int
32805 test_xmlExpCtxtNbNodes(void) {
32806     int test_ret = 0;
32807
32808 #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
32809     int mem_base;
32810     int ret_val;
32811     xmlExpCtxtPtr ctxt; /* an expression context */
32812     int n_ctxt;
32813
32814     for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) {
32815         mem_base = xmlMemBlocks();
32816         ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0);
32817
32818         ret_val = xmlExpCtxtNbNodes(ctxt);
32819         desret_int(ret_val);
32820         call_tests++;
32821         des_xmlExpCtxtPtr(n_ctxt, ctxt, 0);
32822         xmlResetLastError();
32823         if (mem_base != xmlMemBlocks()) {
32824             printf("Leak of %d blocks found in xmlExpCtxtNbNodes",
32825                    xmlMemBlocks() - mem_base);
32826             test_ret++;
32827             printf(" %d", n_ctxt);
32828             printf("\n");
32829         }
32830     }
32831     function_tests++;
32832 #endif
32833
32834     return(test_ret);
32835 }
32836
32837
32838 static int
32839 test_xmlExpDump(void) {
32840     int test_ret = 0;
32841
32842 #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
32843     int mem_base;
32844     xmlBufferPtr buf; /* a buffer to receive the output */
32845     int n_buf;
32846     xmlExpNodePtr expr; /* the compiled expression */
32847     int n_expr;
32848
32849     for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
32850     for (n_expr = 0;n_expr < gen_nb_xmlExpNodePtr;n_expr++) {
32851         mem_base = xmlMemBlocks();
32852         buf = gen_xmlBufferPtr(n_buf, 0);
32853         expr = gen_xmlExpNodePtr(n_expr, 1);
32854
32855         xmlExpDump(buf, expr);
32856         call_tests++;
32857         des_xmlBufferPtr(n_buf, buf, 0);
32858         des_xmlExpNodePtr(n_expr, expr, 1);
32859         xmlResetLastError();
32860         if (mem_base != xmlMemBlocks()) {
32861             printf("Leak of %d blocks found in xmlExpDump",
32862                    xmlMemBlocks() - mem_base);
32863             test_ret++;
32864             printf(" %d", n_buf);
32865             printf(" %d", n_expr);
32866             printf("\n");
32867         }
32868     }
32869     }
32870     function_tests++;
32871 #endif
32872
32873     return(test_ret);
32874 }
32875
32876
32877 static int
32878 test_xmlExpExpDerive(void) {
32879     int test_ret = 0;
32880
32881
32882     /* missing type support */
32883     return(test_ret);
32884 }
32885
32886
32887 static int
32888 test_xmlExpGetLanguage(void) {
32889     int test_ret = 0;
32890
32891 #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
32892     int mem_base;
32893     int ret_val;
32894     xmlExpCtxtPtr ctxt; /* the expression context */
32895     int n_ctxt;
32896     xmlExpNodePtr exp; /* the expression */
32897     int n_exp;
32898     xmlChar ** langList; /* where to store the tokens */
32899     int n_langList;
32900     int len; /* the allocated lenght of @list */
32901     int n_len;
32902
32903     for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) {
32904     for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) {
32905     for (n_langList = 0;n_langList < gen_nb_const_xmlChar_ptr_ptr;n_langList++) {
32906     for (n_len = 0;n_len < gen_nb_int;n_len++) {
32907         mem_base = xmlMemBlocks();
32908         ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0);
32909         exp = gen_xmlExpNodePtr(n_exp, 1);
32910         langList = gen_const_xmlChar_ptr_ptr(n_langList, 2);
32911         len = gen_int(n_len, 3);
32912
32913         ret_val = xmlExpGetLanguage(ctxt, exp, (const xmlChar **)langList, len);
32914         desret_int(ret_val);
32915         call_tests++;
32916         des_xmlExpCtxtPtr(n_ctxt, ctxt, 0);
32917         des_xmlExpNodePtr(n_exp, exp, 1);
32918         des_const_xmlChar_ptr_ptr(n_langList, (const xmlChar **)langList, 2);
32919         des_int(n_len, len, 3);
32920         xmlResetLastError();
32921         if (mem_base != xmlMemBlocks()) {
32922             printf("Leak of %d blocks found in xmlExpGetLanguage",
32923                    xmlMemBlocks() - mem_base);
32924             test_ret++;
32925             printf(" %d", n_ctxt);
32926             printf(" %d", n_exp);
32927             printf(" %d", n_langList);
32928             printf(" %d", n_len);
32929             printf("\n");
32930         }
32931     }
32932     }
32933     }
32934     }
32935     function_tests++;
32936 #endif
32937
32938     return(test_ret);
32939 }
32940
32941
32942 static int
32943 test_xmlExpGetStart(void) {
32944     int test_ret = 0;
32945
32946 #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
32947     int mem_base;
32948     int ret_val;
32949     xmlExpCtxtPtr ctxt; /* the expression context */
32950     int n_ctxt;
32951     xmlExpNodePtr exp; /* the expression */
32952     int n_exp;
32953     xmlChar ** tokList; /* where to store the tokens */
32954     int n_tokList;
32955     int len; /* the allocated lenght of @list */
32956     int n_len;
32957
32958     for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) {
32959     for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) {
32960     for (n_tokList = 0;n_tokList < gen_nb_const_xmlChar_ptr_ptr;n_tokList++) {
32961     for (n_len = 0;n_len < gen_nb_int;n_len++) {
32962         mem_base = xmlMemBlocks();
32963         ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0);
32964         exp = gen_xmlExpNodePtr(n_exp, 1);
32965         tokList = gen_const_xmlChar_ptr_ptr(n_tokList, 2);
32966         len = gen_int(n_len, 3);
32967
32968         ret_val = xmlExpGetStart(ctxt, exp, (const xmlChar **)tokList, len);
32969         desret_int(ret_val);
32970         call_tests++;
32971         des_xmlExpCtxtPtr(n_ctxt, ctxt, 0);
32972         des_xmlExpNodePtr(n_exp, exp, 1);
32973         des_const_xmlChar_ptr_ptr(n_tokList, (const xmlChar **)tokList, 2);
32974         des_int(n_len, len, 3);
32975         xmlResetLastError();
32976         if (mem_base != xmlMemBlocks()) {
32977             printf("Leak of %d blocks found in xmlExpGetStart",
32978                    xmlMemBlocks() - mem_base);
32979             test_ret++;
32980             printf(" %d", n_ctxt);
32981             printf(" %d", n_exp);
32982             printf(" %d", n_tokList);
32983             printf(" %d", n_len);
32984             printf("\n");
32985         }
32986     }
32987     }
32988     }
32989     }
32990     function_tests++;
32991 #endif
32992
32993     return(test_ret);
32994 }
32995
32996
32997 static int
32998 test_xmlExpIsNillable(void) {
32999     int test_ret = 0;
33000
33001 #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
33002     int mem_base;
33003     int ret_val;
33004     xmlExpNodePtr exp; /* the expression */
33005     int n_exp;
33006
33007     for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) {
33008         mem_base = xmlMemBlocks();
33009         exp = gen_xmlExpNodePtr(n_exp, 0);
33010
33011         ret_val = xmlExpIsNillable(exp);
33012         desret_int(ret_val);
33013         call_tests++;
33014         des_xmlExpNodePtr(n_exp, exp, 0);
33015         xmlResetLastError();
33016         if (mem_base != xmlMemBlocks()) {
33017             printf("Leak of %d blocks found in xmlExpIsNillable",
33018                    xmlMemBlocks() - mem_base);
33019             test_ret++;
33020             printf(" %d", n_exp);
33021             printf("\n");
33022         }
33023     }
33024     function_tests++;
33025 #endif
33026
33027     return(test_ret);
33028 }
33029
33030
33031 static int
33032 test_xmlExpMaxToken(void) {
33033     int test_ret = 0;
33034
33035 #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
33036     int mem_base;
33037     int ret_val;
33038     xmlExpNodePtr expr; /* a compiled expression */
33039     int n_expr;
33040
33041     for (n_expr = 0;n_expr < gen_nb_xmlExpNodePtr;n_expr++) {
33042         mem_base = xmlMemBlocks();
33043         expr = gen_xmlExpNodePtr(n_expr, 0);
33044
33045         ret_val = xmlExpMaxToken(expr);
33046         desret_int(ret_val);
33047         call_tests++;
33048         des_xmlExpNodePtr(n_expr, expr, 0);
33049         xmlResetLastError();
33050         if (mem_base != xmlMemBlocks()) {
33051             printf("Leak of %d blocks found in xmlExpMaxToken",
33052                    xmlMemBlocks() - mem_base);
33053             test_ret++;
33054             printf(" %d", n_expr);
33055             printf("\n");
33056         }
33057     }
33058     function_tests++;
33059 #endif
33060
33061     return(test_ret);
33062 }
33063
33064
33065 static int
33066 test_xmlExpNewAtom(void) {
33067     int test_ret = 0;
33068
33069
33070     /* missing type support */
33071     return(test_ret);
33072 }
33073
33074
33075 static int
33076 test_xmlExpNewCtxt(void) {
33077     int test_ret = 0;
33078
33079
33080     /* missing type support */
33081     return(test_ret);
33082 }
33083
33084
33085 static int
33086 test_xmlExpNewOr(void) {
33087     int test_ret = 0;
33088
33089
33090     /* missing type support */
33091     return(test_ret);
33092 }
33093
33094
33095 static int
33096 test_xmlExpNewRange(void) {
33097     int test_ret = 0;
33098
33099
33100     /* missing type support */
33101     return(test_ret);
33102 }
33103
33104
33105 static int
33106 test_xmlExpNewSeq(void) {
33107     int test_ret = 0;
33108
33109
33110     /* missing type support */
33111     return(test_ret);
33112 }
33113
33114
33115 static int
33116 test_xmlExpParse(void) {
33117     int test_ret = 0;
33118
33119
33120     /* missing type support */
33121     return(test_ret);
33122 }
33123
33124
33125 static int
33126 test_xmlExpRef(void) {
33127     int test_ret = 0;
33128
33129 #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
33130     int mem_base;
33131     xmlExpNodePtr exp; /* the expression */
33132     int n_exp;
33133
33134     for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) {
33135         mem_base = xmlMemBlocks();
33136         exp = gen_xmlExpNodePtr(n_exp, 0);
33137
33138         xmlExpRef(exp);
33139         call_tests++;
33140         des_xmlExpNodePtr(n_exp, exp, 0);
33141         xmlResetLastError();
33142         if (mem_base != xmlMemBlocks()) {
33143             printf("Leak of %d blocks found in xmlExpRef",
33144                    xmlMemBlocks() - mem_base);
33145             test_ret++;
33146             printf(" %d", n_exp);
33147             printf("\n");
33148         }
33149     }
33150     function_tests++;
33151 #endif
33152
33153     return(test_ret);
33154 }
33155
33156
33157 static int
33158 test_xmlExpStringDerive(void) {
33159     int test_ret = 0;
33160
33161
33162     /* missing type support */
33163     return(test_ret);
33164 }
33165
33166
33167 static int
33168 test_xmlExpSubsume(void) {
33169     int test_ret = 0;
33170
33171 #if defined(LIBXML_REGEXP_ENABLED) && defined(LIBXML_EXPR_ENABLED)
33172     int mem_base;
33173     int ret_val;
33174     xmlExpCtxtPtr ctxt; /* the expressions context */
33175     int n_ctxt;
33176     xmlExpNodePtr exp; /* the englobing expression */
33177     int n_exp;
33178     xmlExpNodePtr sub; /* the subexpression */
33179     int n_sub;
33180
33181     for (n_ctxt = 0;n_ctxt < gen_nb_xmlExpCtxtPtr;n_ctxt++) {
33182     for (n_exp = 0;n_exp < gen_nb_xmlExpNodePtr;n_exp++) {
33183     for (n_sub = 0;n_sub < gen_nb_xmlExpNodePtr;n_sub++) {
33184         mem_base = xmlMemBlocks();
33185         ctxt = gen_xmlExpCtxtPtr(n_ctxt, 0);
33186         exp = gen_xmlExpNodePtr(n_exp, 1);
33187         sub = gen_xmlExpNodePtr(n_sub, 2);
33188
33189         ret_val = xmlExpSubsume(ctxt, exp, sub);
33190         desret_int(ret_val);
33191         call_tests++;
33192         des_xmlExpCtxtPtr(n_ctxt, ctxt, 0);
33193         des_xmlExpNodePtr(n_exp, exp, 1);
33194         des_xmlExpNodePtr(n_sub, sub, 2);
33195         xmlResetLastError();
33196         if (mem_base != xmlMemBlocks()) {
33197             printf("Leak of %d blocks found in xmlExpSubsume",
33198                    xmlMemBlocks() - mem_base);
33199             test_ret++;
33200             printf(" %d", n_ctxt);
33201             printf(" %d", n_exp);
33202             printf(" %d", n_sub);
33203             printf("\n");
33204         }
33205     }
33206     }
33207     }
33208     function_tests++;
33209 #endif
33210
33211     return(test_ret);
33212 }
33213
33214 #ifdef LIBXML_REGEXP_ENABLED
33215
33216 #define gen_nb_xmlRegExecCtxtPtr 1
33217 static xmlRegExecCtxtPtr gen_xmlRegExecCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33218     return(NULL);
33219 }
33220 static void des_xmlRegExecCtxtPtr(int no ATTRIBUTE_UNUSED, xmlRegExecCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33221 }
33222 #endif
33223
33224
33225 static int
33226 test_xmlRegExecErrInfo(void) {
33227     int test_ret = 0;
33228
33229 #if defined(LIBXML_REGEXP_ENABLED)
33230     int mem_base;
33231     int ret_val;
33232     xmlRegExecCtxtPtr exec; /* a regexp execution context generating an error */
33233     int n_exec;
33234     xmlChar ** string; /* return value for the error string */
33235     int n_string;
33236     int * nbval; /* pointer to the number of accepted values IN/OUT */
33237     int n_nbval;
33238     int * nbneg; /* return number of negative transitions */
33239     int n_nbneg;
33240     xmlChar ** values; /* pointer to the array of acceptable values */
33241     int n_values;
33242     int * terminal; /* return value if this was a terminal state */
33243     int n_terminal;
33244
33245     for (n_exec = 0;n_exec < gen_nb_xmlRegExecCtxtPtr;n_exec++) {
33246     for (n_string = 0;n_string < gen_nb_const_xmlChar_ptr_ptr;n_string++) {
33247     for (n_nbval = 0;n_nbval < gen_nb_int_ptr;n_nbval++) {
33248     for (n_nbneg = 0;n_nbneg < gen_nb_int_ptr;n_nbneg++) {
33249     for (n_values = 0;n_values < gen_nb_xmlChar_ptr_ptr;n_values++) {
33250     for (n_terminal = 0;n_terminal < gen_nb_int_ptr;n_terminal++) {
33251         mem_base = xmlMemBlocks();
33252         exec = gen_xmlRegExecCtxtPtr(n_exec, 0);
33253         string = gen_const_xmlChar_ptr_ptr(n_string, 1);
33254         nbval = gen_int_ptr(n_nbval, 2);
33255         nbneg = gen_int_ptr(n_nbneg, 3);
33256         values = gen_xmlChar_ptr_ptr(n_values, 4);
33257         terminal = gen_int_ptr(n_terminal, 5);
33258
33259         ret_val = xmlRegExecErrInfo(exec, (const xmlChar **)string, nbval, nbneg, values, terminal);
33260         desret_int(ret_val);
33261         call_tests++;
33262         des_xmlRegExecCtxtPtr(n_exec, exec, 0);
33263         des_const_xmlChar_ptr_ptr(n_string, (const xmlChar **)string, 1);
33264         des_int_ptr(n_nbval, nbval, 2);
33265         des_int_ptr(n_nbneg, nbneg, 3);
33266         des_xmlChar_ptr_ptr(n_values, values, 4);
33267         des_int_ptr(n_terminal, terminal, 5);
33268         xmlResetLastError();
33269         if (mem_base != xmlMemBlocks()) {
33270             printf("Leak of %d blocks found in xmlRegExecErrInfo",
33271                    xmlMemBlocks() - mem_base);
33272             test_ret++;
33273             printf(" %d", n_exec);
33274             printf(" %d", n_string);
33275             printf(" %d", n_nbval);
33276             printf(" %d", n_nbneg);
33277             printf(" %d", n_values);
33278             printf(" %d", n_terminal);
33279             printf("\n");
33280         }
33281     }
33282     }
33283     }
33284     }
33285     }
33286     }
33287     function_tests++;
33288 #endif
33289
33290     return(test_ret);
33291 }
33292
33293
33294 static int
33295 test_xmlRegExecNextValues(void) {
33296     int test_ret = 0;
33297
33298 #if defined(LIBXML_REGEXP_ENABLED)
33299     int mem_base;
33300     int ret_val;
33301     xmlRegExecCtxtPtr exec; /* a regexp execution context */
33302     int n_exec;
33303     int * nbval; /* pointer to the number of accepted values IN/OUT */
33304     int n_nbval;
33305     int * nbneg; /* return number of negative transitions */
33306     int n_nbneg;
33307     xmlChar ** values; /* pointer to the array of acceptable values */
33308     int n_values;
33309     int * terminal; /* return value if this was a terminal state */
33310     int n_terminal;
33311
33312     for (n_exec = 0;n_exec < gen_nb_xmlRegExecCtxtPtr;n_exec++) {
33313     for (n_nbval = 0;n_nbval < gen_nb_int_ptr;n_nbval++) {
33314     for (n_nbneg = 0;n_nbneg < gen_nb_int_ptr;n_nbneg++) {
33315     for (n_values = 0;n_values < gen_nb_xmlChar_ptr_ptr;n_values++) {
33316     for (n_terminal = 0;n_terminal < gen_nb_int_ptr;n_terminal++) {
33317         mem_base = xmlMemBlocks();
33318         exec = gen_xmlRegExecCtxtPtr(n_exec, 0);
33319         nbval = gen_int_ptr(n_nbval, 1);
33320         nbneg = gen_int_ptr(n_nbneg, 2);
33321         values = gen_xmlChar_ptr_ptr(n_values, 3);
33322         terminal = gen_int_ptr(n_terminal, 4);
33323
33324         ret_val = xmlRegExecNextValues(exec, nbval, nbneg, values, terminal);
33325         desret_int(ret_val);
33326         call_tests++;
33327         des_xmlRegExecCtxtPtr(n_exec, exec, 0);
33328         des_int_ptr(n_nbval, nbval, 1);
33329         des_int_ptr(n_nbneg, nbneg, 2);
33330         des_xmlChar_ptr_ptr(n_values, values, 3);
33331         des_int_ptr(n_terminal, terminal, 4);
33332         xmlResetLastError();
33333         if (mem_base != xmlMemBlocks()) {
33334             printf("Leak of %d blocks found in xmlRegExecNextValues",
33335                    xmlMemBlocks() - mem_base);
33336             test_ret++;
33337             printf(" %d", n_exec);
33338             printf(" %d", n_nbval);
33339             printf(" %d", n_nbneg);
33340             printf(" %d", n_values);
33341             printf(" %d", n_terminal);
33342             printf("\n");
33343         }
33344     }
33345     }
33346     }
33347     }
33348     }
33349     function_tests++;
33350 #endif
33351
33352     return(test_ret);
33353 }
33354
33355
33356 static int
33357 test_xmlRegExecPushString(void) {
33358     int test_ret = 0;
33359
33360 #if defined(LIBXML_REGEXP_ENABLED)
33361     int mem_base;
33362     int ret_val;
33363     xmlRegExecCtxtPtr exec; /* a regexp execution context or NULL to indicate the end */
33364     int n_exec;
33365     xmlChar * value; /* a string token input */
33366     int n_value;
33367     void * data; /* data associated to the token to reuse in callbacks */
33368     int n_data;
33369
33370     for (n_exec = 0;n_exec < gen_nb_xmlRegExecCtxtPtr;n_exec++) {
33371     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
33372     for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
33373         mem_base = xmlMemBlocks();
33374         exec = gen_xmlRegExecCtxtPtr(n_exec, 0);
33375         value = gen_const_xmlChar_ptr(n_value, 1);
33376         data = gen_userdata(n_data, 2);
33377
33378         ret_val = xmlRegExecPushString(exec, (const xmlChar *)value, data);
33379         desret_int(ret_val);
33380         call_tests++;
33381         des_xmlRegExecCtxtPtr(n_exec, exec, 0);
33382         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
33383         des_userdata(n_data, data, 2);
33384         xmlResetLastError();
33385         if (mem_base != xmlMemBlocks()) {
33386             printf("Leak of %d blocks found in xmlRegExecPushString",
33387                    xmlMemBlocks() - mem_base);
33388             test_ret++;
33389             printf(" %d", n_exec);
33390             printf(" %d", n_value);
33391             printf(" %d", n_data);
33392             printf("\n");
33393         }
33394     }
33395     }
33396     }
33397     function_tests++;
33398 #endif
33399
33400     return(test_ret);
33401 }
33402
33403
33404 static int
33405 test_xmlRegExecPushString2(void) {
33406     int test_ret = 0;
33407
33408 #if defined(LIBXML_REGEXP_ENABLED)
33409     int mem_base;
33410     int ret_val;
33411     xmlRegExecCtxtPtr exec; /* a regexp execution context or NULL to indicate the end */
33412     int n_exec;
33413     xmlChar * value; /* the first string token input */
33414     int n_value;
33415     xmlChar * value2; /* the second string token input */
33416     int n_value2;
33417     void * data; /* data associated to the token to reuse in callbacks */
33418     int n_data;
33419
33420     for (n_exec = 0;n_exec < gen_nb_xmlRegExecCtxtPtr;n_exec++) {
33421     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
33422     for (n_value2 = 0;n_value2 < gen_nb_const_xmlChar_ptr;n_value2++) {
33423     for (n_data = 0;n_data < gen_nb_userdata;n_data++) {
33424         mem_base = xmlMemBlocks();
33425         exec = gen_xmlRegExecCtxtPtr(n_exec, 0);
33426         value = gen_const_xmlChar_ptr(n_value, 1);
33427         value2 = gen_const_xmlChar_ptr(n_value2, 2);
33428         data = gen_userdata(n_data, 3);
33429
33430         ret_val = xmlRegExecPushString2(exec, (const xmlChar *)value, (const xmlChar *)value2, data);
33431         desret_int(ret_val);
33432         call_tests++;
33433         des_xmlRegExecCtxtPtr(n_exec, exec, 0);
33434         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
33435         des_const_xmlChar_ptr(n_value2, (const xmlChar *)value2, 2);
33436         des_userdata(n_data, data, 3);
33437         xmlResetLastError();
33438         if (mem_base != xmlMemBlocks()) {
33439             printf("Leak of %d blocks found in xmlRegExecPushString2",
33440                    xmlMemBlocks() - mem_base);
33441             test_ret++;
33442             printf(" %d", n_exec);
33443             printf(" %d", n_value);
33444             printf(" %d", n_value2);
33445             printf(" %d", n_data);
33446             printf("\n");
33447         }
33448     }
33449     }
33450     }
33451     }
33452     function_tests++;
33453 #endif
33454
33455     return(test_ret);
33456 }
33457
33458 #ifdef LIBXML_REGEXP_ENABLED
33459
33460 #define gen_nb_xmlRegexpPtr 1
33461 static xmlRegexpPtr gen_xmlRegexpPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33462     return(NULL);
33463 }
33464 static void des_xmlRegexpPtr(int no ATTRIBUTE_UNUSED, xmlRegexpPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33465 }
33466 #endif
33467
33468
33469 static int
33470 test_xmlRegNewExecCtxt(void) {
33471     int test_ret = 0;
33472
33473
33474     /* missing type support */
33475     return(test_ret);
33476 }
33477
33478
33479 static int
33480 test_xmlRegexpCompile(void) {
33481     int test_ret = 0;
33482
33483
33484     /* missing type support */
33485     return(test_ret);
33486 }
33487
33488
33489 static int
33490 test_xmlRegexpExec(void) {
33491     int test_ret = 0;
33492
33493 #if defined(LIBXML_REGEXP_ENABLED)
33494     int mem_base;
33495     int ret_val;
33496     xmlRegexpPtr comp; /* the compiled regular expression */
33497     int n_comp;
33498     xmlChar * content; /* the value to check against the regular expression */
33499     int n_content;
33500
33501     for (n_comp = 0;n_comp < gen_nb_xmlRegexpPtr;n_comp++) {
33502     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
33503         mem_base = xmlMemBlocks();
33504         comp = gen_xmlRegexpPtr(n_comp, 0);
33505         content = gen_const_xmlChar_ptr(n_content, 1);
33506
33507         ret_val = xmlRegexpExec(comp, (const xmlChar *)content);
33508         desret_int(ret_val);
33509         call_tests++;
33510         des_xmlRegexpPtr(n_comp, comp, 0);
33511         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
33512         xmlResetLastError();
33513         if (mem_base != xmlMemBlocks()) {
33514             printf("Leak of %d blocks found in xmlRegexpExec",
33515                    xmlMemBlocks() - mem_base);
33516             test_ret++;
33517             printf(" %d", n_comp);
33518             printf(" %d", n_content);
33519             printf("\n");
33520         }
33521     }
33522     }
33523     function_tests++;
33524 #endif
33525
33526     return(test_ret);
33527 }
33528
33529
33530 static int
33531 test_xmlRegexpIsDeterminist(void) {
33532     int test_ret = 0;
33533
33534 #if defined(LIBXML_REGEXP_ENABLED)
33535     int mem_base;
33536     int ret_val;
33537     xmlRegexpPtr comp; /* the compiled regular expression */
33538     int n_comp;
33539
33540     for (n_comp = 0;n_comp < gen_nb_xmlRegexpPtr;n_comp++) {
33541         mem_base = xmlMemBlocks();
33542         comp = gen_xmlRegexpPtr(n_comp, 0);
33543
33544         ret_val = xmlRegexpIsDeterminist(comp);
33545         desret_int(ret_val);
33546         call_tests++;
33547         des_xmlRegexpPtr(n_comp, comp, 0);
33548         xmlResetLastError();
33549         if (mem_base != xmlMemBlocks()) {
33550             printf("Leak of %d blocks found in xmlRegexpIsDeterminist",
33551                    xmlMemBlocks() - mem_base);
33552             test_ret++;
33553             printf(" %d", n_comp);
33554             printf("\n");
33555         }
33556     }
33557     function_tests++;
33558 #endif
33559
33560     return(test_ret);
33561 }
33562
33563
33564 static int
33565 test_xmlRegexpPrint(void) {
33566     int test_ret = 0;
33567
33568 #if defined(LIBXML_REGEXP_ENABLED)
33569     int mem_base;
33570     FILE * output; /* the file for the output debug */
33571     int n_output;
33572     xmlRegexpPtr regexp; /* the compiled regexp */
33573     int n_regexp;
33574
33575     for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
33576     for (n_regexp = 0;n_regexp < gen_nb_xmlRegexpPtr;n_regexp++) {
33577         mem_base = xmlMemBlocks();
33578         output = gen_FILE_ptr(n_output, 0);
33579         regexp = gen_xmlRegexpPtr(n_regexp, 1);
33580
33581         xmlRegexpPrint(output, regexp);
33582         call_tests++;
33583         des_FILE_ptr(n_output, output, 0);
33584         des_xmlRegexpPtr(n_regexp, regexp, 1);
33585         xmlResetLastError();
33586         if (mem_base != xmlMemBlocks()) {
33587             printf("Leak of %d blocks found in xmlRegexpPrint",
33588                    xmlMemBlocks() - mem_base);
33589             test_ret++;
33590             printf(" %d", n_output);
33591             printf(" %d", n_regexp);
33592             printf("\n");
33593         }
33594     }
33595     }
33596     function_tests++;
33597 #endif
33598
33599     return(test_ret);
33600 }
33601
33602 static int
33603 test_xmlregexp(void) {
33604     int test_ret = 0;
33605
33606     if (quiet == 0) printf("Testing xmlregexp : 16 of 30 functions ...\n");
33607     test_ret += test_xmlExpCtxtNbCons();
33608     test_ret += test_xmlExpCtxtNbNodes();
33609     test_ret += test_xmlExpDump();
33610     test_ret += test_xmlExpExpDerive();
33611     test_ret += test_xmlExpGetLanguage();
33612     test_ret += test_xmlExpGetStart();
33613     test_ret += test_xmlExpIsNillable();
33614     test_ret += test_xmlExpMaxToken();
33615     test_ret += test_xmlExpNewAtom();
33616     test_ret += test_xmlExpNewCtxt();
33617     test_ret += test_xmlExpNewOr();
33618     test_ret += test_xmlExpNewRange();
33619     test_ret += test_xmlExpNewSeq();
33620     test_ret += test_xmlExpParse();
33621     test_ret += test_xmlExpRef();
33622     test_ret += test_xmlExpStringDerive();
33623     test_ret += test_xmlExpSubsume();
33624     test_ret += test_xmlRegExecErrInfo();
33625     test_ret += test_xmlRegExecNextValues();
33626     test_ret += test_xmlRegExecPushString();
33627     test_ret += test_xmlRegExecPushString2();
33628     test_ret += test_xmlRegNewExecCtxt();
33629     test_ret += test_xmlRegexpCompile();
33630     test_ret += test_xmlRegexpExec();
33631     test_ret += test_xmlRegexpIsDeterminist();
33632     test_ret += test_xmlRegexpPrint();
33633
33634     if (test_ret != 0)
33635         printf("Module xmlregexp: %d errors\n", test_ret);
33636     return(test_ret);
33637 }
33638 #ifdef LIBXML_OUTPUT_ENABLED
33639
33640 #define gen_nb_xmlSaveCtxtPtr 1
33641 static xmlSaveCtxtPtr gen_xmlSaveCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33642     return(NULL);
33643 }
33644 static void des_xmlSaveCtxtPtr(int no ATTRIBUTE_UNUSED, xmlSaveCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33645 }
33646 #endif
33647
33648
33649 static int
33650 test_xmlSaveClose(void) {
33651     int test_ret = 0;
33652
33653 #if defined(LIBXML_OUTPUT_ENABLED)
33654     int mem_base;
33655     int ret_val;
33656     xmlSaveCtxtPtr ctxt; /* a document saving context */
33657     int n_ctxt;
33658
33659     for (n_ctxt = 0;n_ctxt < gen_nb_xmlSaveCtxtPtr;n_ctxt++) {
33660         mem_base = xmlMemBlocks();
33661         ctxt = gen_xmlSaveCtxtPtr(n_ctxt, 0);
33662
33663         ret_val = xmlSaveClose(ctxt);
33664         desret_int(ret_val);
33665         call_tests++;
33666         des_xmlSaveCtxtPtr(n_ctxt, ctxt, 0);
33667         xmlResetLastError();
33668         if (mem_base != xmlMemBlocks()) {
33669             printf("Leak of %d blocks found in xmlSaveClose",
33670                    xmlMemBlocks() - mem_base);
33671             test_ret++;
33672             printf(" %d", n_ctxt);
33673             printf("\n");
33674         }
33675     }
33676     function_tests++;
33677 #endif
33678
33679     return(test_ret);
33680 }
33681
33682
33683 static int
33684 test_xmlSaveDoc(void) {
33685     int test_ret = 0;
33686
33687 #if defined(LIBXML_OUTPUT_ENABLED)
33688     int mem_base;
33689     long ret_val;
33690     xmlSaveCtxtPtr ctxt; /* a document saving context */
33691     int n_ctxt;
33692     xmlDocPtr doc; /* a document */
33693     int n_doc;
33694
33695     for (n_ctxt = 0;n_ctxt < gen_nb_xmlSaveCtxtPtr;n_ctxt++) {
33696     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
33697         mem_base = xmlMemBlocks();
33698         ctxt = gen_xmlSaveCtxtPtr(n_ctxt, 0);
33699         doc = gen_xmlDocPtr(n_doc, 1);
33700
33701         ret_val = xmlSaveDoc(ctxt, doc);
33702         desret_long(ret_val);
33703         call_tests++;
33704         des_xmlSaveCtxtPtr(n_ctxt, ctxt, 0);
33705         des_xmlDocPtr(n_doc, doc, 1);
33706         xmlResetLastError();
33707         if (mem_base != xmlMemBlocks()) {
33708             printf("Leak of %d blocks found in xmlSaveDoc",
33709                    xmlMemBlocks() - mem_base);
33710             test_ret++;
33711             printf(" %d", n_ctxt);
33712             printf(" %d", n_doc);
33713             printf("\n");
33714         }
33715     }
33716     }
33717     function_tests++;
33718 #endif
33719
33720     return(test_ret);
33721 }
33722
33723
33724 static int
33725 test_xmlSaveFlush(void) {
33726     int test_ret = 0;
33727
33728 #if defined(LIBXML_OUTPUT_ENABLED)
33729     int mem_base;
33730     int ret_val;
33731     xmlSaveCtxtPtr ctxt; /* a document saving context */
33732     int n_ctxt;
33733
33734     for (n_ctxt = 0;n_ctxt < gen_nb_xmlSaveCtxtPtr;n_ctxt++) {
33735         mem_base = xmlMemBlocks();
33736         ctxt = gen_xmlSaveCtxtPtr(n_ctxt, 0);
33737
33738         ret_val = xmlSaveFlush(ctxt);
33739         desret_int(ret_val);
33740         call_tests++;
33741         des_xmlSaveCtxtPtr(n_ctxt, ctxt, 0);
33742         xmlResetLastError();
33743         if (mem_base != xmlMemBlocks()) {
33744             printf("Leak of %d blocks found in xmlSaveFlush",
33745                    xmlMemBlocks() - mem_base);
33746             test_ret++;
33747             printf(" %d", n_ctxt);
33748             printf("\n");
33749         }
33750     }
33751     function_tests++;
33752 #endif
33753
33754     return(test_ret);
33755 }
33756
33757
33758 static int
33759 test_xmlSaveSetAttrEscape(void) {
33760     int test_ret = 0;
33761
33762
33763     /* missing type support */
33764     return(test_ret);
33765 }
33766
33767
33768 static int
33769 test_xmlSaveSetEscape(void) {
33770     int test_ret = 0;
33771
33772
33773     /* missing type support */
33774     return(test_ret);
33775 }
33776
33777
33778 static int
33779 test_xmlSaveToBuffer(void) {
33780     int test_ret = 0;
33781
33782
33783     /* missing type support */
33784     return(test_ret);
33785 }
33786
33787
33788 static int
33789 test_xmlSaveToFd(void) {
33790     int test_ret = 0;
33791
33792
33793     /* missing type support */
33794     return(test_ret);
33795 }
33796
33797
33798 static int
33799 test_xmlSaveToFilename(void) {
33800     int test_ret = 0;
33801
33802
33803     /* missing type support */
33804     return(test_ret);
33805 }
33806
33807
33808 static int
33809 test_xmlSaveTree(void) {
33810     int test_ret = 0;
33811
33812 #if defined(LIBXML_OUTPUT_ENABLED)
33813     int mem_base;
33814     long ret_val;
33815     xmlSaveCtxtPtr ctxt; /* a document saving context */
33816     int n_ctxt;
33817     xmlNodePtr node; /* the top node of the subtree to save */
33818     int n_node;
33819
33820     for (n_ctxt = 0;n_ctxt < gen_nb_xmlSaveCtxtPtr;n_ctxt++) {
33821     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
33822         mem_base = xmlMemBlocks();
33823         ctxt = gen_xmlSaveCtxtPtr(n_ctxt, 0);
33824         node = gen_xmlNodePtr(n_node, 1);
33825
33826         ret_val = xmlSaveTree(ctxt, node);
33827         desret_long(ret_val);
33828         call_tests++;
33829         des_xmlSaveCtxtPtr(n_ctxt, ctxt, 0);
33830         des_xmlNodePtr(n_node, node, 1);
33831         xmlResetLastError();
33832         if (mem_base != xmlMemBlocks()) {
33833             printf("Leak of %d blocks found in xmlSaveTree",
33834                    xmlMemBlocks() - mem_base);
33835             test_ret++;
33836             printf(" %d", n_ctxt);
33837             printf(" %d", n_node);
33838             printf("\n");
33839         }
33840     }
33841     }
33842     function_tests++;
33843 #endif
33844
33845     return(test_ret);
33846 }
33847
33848 static int
33849 test_xmlsave(void) {
33850     int test_ret = 0;
33851
33852     if (quiet == 0) printf("Testing xmlsave : 4 of 10 functions ...\n");
33853     test_ret += test_xmlSaveClose();
33854     test_ret += test_xmlSaveDoc();
33855     test_ret += test_xmlSaveFlush();
33856     test_ret += test_xmlSaveSetAttrEscape();
33857     test_ret += test_xmlSaveSetEscape();
33858     test_ret += test_xmlSaveToBuffer();
33859     test_ret += test_xmlSaveToFd();
33860     test_ret += test_xmlSaveToFilename();
33861     test_ret += test_xmlSaveTree();
33862
33863     if (test_ret != 0)
33864         printf("Module xmlsave: %d errors\n", test_ret);
33865     return(test_ret);
33866 }
33867
33868 static int
33869 test_xmlSchemaDump(void) {
33870     int test_ret = 0;
33871
33872 #if defined(LIBXML_SCHEMAS_ENABLED) && defined(LIBXML_OUTPUT_ENABLED)
33873     int mem_base;
33874     FILE * output; /* the file output */
33875     int n_output;
33876     xmlSchemaPtr schema; /* a schema structure */
33877     int n_schema;
33878
33879     for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
33880     for (n_schema = 0;n_schema < gen_nb_xmlSchemaPtr;n_schema++) {
33881         mem_base = xmlMemBlocks();
33882         output = gen_FILE_ptr(n_output, 0);
33883         schema = gen_xmlSchemaPtr(n_schema, 1);
33884
33885         xmlSchemaDump(output, schema);
33886         call_tests++;
33887         des_FILE_ptr(n_output, output, 0);
33888         des_xmlSchemaPtr(n_schema, schema, 1);
33889         xmlResetLastError();
33890         if (mem_base != xmlMemBlocks()) {
33891             printf("Leak of %d blocks found in xmlSchemaDump",
33892                    xmlMemBlocks() - mem_base);
33893             test_ret++;
33894             printf(" %d", n_output);
33895             printf(" %d", n_schema);
33896             printf("\n");
33897         }
33898     }
33899     }
33900     function_tests++;
33901 #endif
33902
33903     return(test_ret);
33904 }
33905
33906 #ifdef LIBXML_SCHEMAS_ENABLED
33907
33908 #define gen_nb_xmlSchemaParserCtxtPtr 1
33909 static xmlSchemaParserCtxtPtr gen_xmlSchemaParserCtxtPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33910     return(NULL);
33911 }
33912 static void des_xmlSchemaParserCtxtPtr(int no ATTRIBUTE_UNUSED, xmlSchemaParserCtxtPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33913 }
33914 #endif
33915
33916 #ifdef LIBXML_SCHEMAS_ENABLED
33917
33918 #define gen_nb_xmlSchemaValidityErrorFunc_ptr 1
33919 static xmlSchemaValidityErrorFunc * gen_xmlSchemaValidityErrorFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33920     return(NULL);
33921 }
33922 static void des_xmlSchemaValidityErrorFunc_ptr(int no ATTRIBUTE_UNUSED, xmlSchemaValidityErrorFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33923 }
33924 #endif
33925
33926 #ifdef LIBXML_SCHEMAS_ENABLED
33927
33928 #define gen_nb_xmlSchemaValidityWarningFunc_ptr 1
33929 static xmlSchemaValidityWarningFunc * gen_xmlSchemaValidityWarningFunc_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33930     return(NULL);
33931 }
33932 static void des_xmlSchemaValidityWarningFunc_ptr(int no ATTRIBUTE_UNUSED, xmlSchemaValidityWarningFunc * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
33933 }
33934 #endif
33935
33936
33937 static int
33938 test_xmlSchemaGetParserErrors(void) {
33939     int test_ret = 0;
33940
33941 #if defined(LIBXML_SCHEMAS_ENABLED)
33942     int mem_base;
33943     int ret_val;
33944     xmlSchemaParserCtxtPtr ctxt; /* a XMl-Schema parser context */
33945     int n_ctxt;
33946     xmlSchemaValidityErrorFunc * err; /* the error callback result */
33947     int n_err;
33948     xmlSchemaValidityWarningFunc * warn; /* the warning callback result */
33949     int n_warn;
33950     void ** ctx; /* contextual data for the callbacks result */
33951     int n_ctx;
33952
33953     for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaParserCtxtPtr;n_ctxt++) {
33954     for (n_err = 0;n_err < gen_nb_xmlSchemaValidityErrorFunc_ptr;n_err++) {
33955     for (n_warn = 0;n_warn < gen_nb_xmlSchemaValidityWarningFunc_ptr;n_warn++) {
33956     for (n_ctx = 0;n_ctx < gen_nb_void_ptr_ptr;n_ctx++) {
33957         mem_base = xmlMemBlocks();
33958         ctxt = gen_xmlSchemaParserCtxtPtr(n_ctxt, 0);
33959         err = gen_xmlSchemaValidityErrorFunc_ptr(n_err, 1);
33960         warn = gen_xmlSchemaValidityWarningFunc_ptr(n_warn, 2);
33961         ctx = gen_void_ptr_ptr(n_ctx, 3);
33962
33963         ret_val = xmlSchemaGetParserErrors(ctxt, err, warn, ctx);
33964         desret_int(ret_val);
33965         call_tests++;
33966         des_xmlSchemaParserCtxtPtr(n_ctxt, ctxt, 0);
33967         des_xmlSchemaValidityErrorFunc_ptr(n_err, err, 1);
33968         des_xmlSchemaValidityWarningFunc_ptr(n_warn, warn, 2);
33969         des_void_ptr_ptr(n_ctx, ctx, 3);
33970         xmlResetLastError();
33971         if (mem_base != xmlMemBlocks()) {
33972             printf("Leak of %d blocks found in xmlSchemaGetParserErrors",
33973                    xmlMemBlocks() - mem_base);
33974             test_ret++;
33975             printf(" %d", n_ctxt);
33976             printf(" %d", n_err);
33977             printf(" %d", n_warn);
33978             printf(" %d", n_ctx);
33979             printf("\n");
33980         }
33981     }
33982     }
33983     }
33984     }
33985     function_tests++;
33986 #endif
33987
33988     return(test_ret);
33989 }
33990
33991
33992 static int
33993 test_xmlSchemaGetValidErrors(void) {
33994     int test_ret = 0;
33995
33996 #if defined(LIBXML_SCHEMAS_ENABLED)
33997     int mem_base;
33998     int ret_val;
33999     xmlSchemaValidCtxtPtr ctxt; /* a XML-Schema validation context */
34000     int n_ctxt;
34001     xmlSchemaValidityErrorFunc * err; /* the error function result */
34002     int n_err;
34003     xmlSchemaValidityWarningFunc * warn; /* the warning function result */
34004     int n_warn;
34005     void ** ctx; /* the functions context result */
34006     int n_ctx;
34007
34008     for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34009     for (n_err = 0;n_err < gen_nb_xmlSchemaValidityErrorFunc_ptr;n_err++) {
34010     for (n_warn = 0;n_warn < gen_nb_xmlSchemaValidityWarningFunc_ptr;n_warn++) {
34011     for (n_ctx = 0;n_ctx < gen_nb_void_ptr_ptr;n_ctx++) {
34012         mem_base = xmlMemBlocks();
34013         ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34014         err = gen_xmlSchemaValidityErrorFunc_ptr(n_err, 1);
34015         warn = gen_xmlSchemaValidityWarningFunc_ptr(n_warn, 2);
34016         ctx = gen_void_ptr_ptr(n_ctx, 3);
34017
34018         ret_val = xmlSchemaGetValidErrors(ctxt, err, warn, ctx);
34019         desret_int(ret_val);
34020         call_tests++;
34021         des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34022         des_xmlSchemaValidityErrorFunc_ptr(n_err, err, 1);
34023         des_xmlSchemaValidityWarningFunc_ptr(n_warn, warn, 2);
34024         des_void_ptr_ptr(n_ctx, ctx, 3);
34025         xmlResetLastError();
34026         if (mem_base != xmlMemBlocks()) {
34027             printf("Leak of %d blocks found in xmlSchemaGetValidErrors",
34028                    xmlMemBlocks() - mem_base);
34029             test_ret++;
34030             printf(" %d", n_ctxt);
34031             printf(" %d", n_err);
34032             printf(" %d", n_warn);
34033             printf(" %d", n_ctx);
34034             printf("\n");
34035         }
34036     }
34037     }
34038     }
34039     }
34040     function_tests++;
34041 #endif
34042
34043     return(test_ret);
34044 }
34045
34046
34047 static int
34048 test_xmlSchemaIsValid(void) {
34049     int test_ret = 0;
34050
34051 #if defined(LIBXML_SCHEMAS_ENABLED)
34052     int mem_base;
34053     int ret_val;
34054     xmlSchemaValidCtxtPtr ctxt; /* the schema validation context */
34055     int n_ctxt;
34056
34057     for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34058         mem_base = xmlMemBlocks();
34059         ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34060
34061         ret_val = xmlSchemaIsValid(ctxt);
34062         desret_int(ret_val);
34063         call_tests++;
34064         des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34065         xmlResetLastError();
34066         if (mem_base != xmlMemBlocks()) {
34067             printf("Leak of %d blocks found in xmlSchemaIsValid",
34068                    xmlMemBlocks() - mem_base);
34069             test_ret++;
34070             printf(" %d", n_ctxt);
34071             printf("\n");
34072         }
34073     }
34074     function_tests++;
34075 #endif
34076
34077     return(test_ret);
34078 }
34079
34080
34081 static int
34082 test_xmlSchemaNewDocParserCtxt(void) {
34083     int test_ret = 0;
34084
34085 #if defined(LIBXML_SCHEMAS_ENABLED)
34086     int mem_base;
34087     xmlSchemaParserCtxtPtr ret_val;
34088     xmlDocPtr doc; /* a preparsed document tree */
34089     int n_doc;
34090
34091     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
34092         mem_base = xmlMemBlocks();
34093         doc = gen_xmlDocPtr(n_doc, 0);
34094
34095         ret_val = xmlSchemaNewDocParserCtxt(doc);
34096         desret_xmlSchemaParserCtxtPtr(ret_val);
34097         call_tests++;
34098         des_xmlDocPtr(n_doc, doc, 0);
34099         xmlResetLastError();
34100         if (mem_base != xmlMemBlocks()) {
34101             printf("Leak of %d blocks found in xmlSchemaNewDocParserCtxt",
34102                    xmlMemBlocks() - mem_base);
34103             test_ret++;
34104             printf(" %d", n_doc);
34105             printf("\n");
34106         }
34107     }
34108     function_tests++;
34109 #endif
34110
34111     return(test_ret);
34112 }
34113
34114
34115 static int
34116 test_xmlSchemaNewMemParserCtxt(void) {
34117     int test_ret = 0;
34118
34119 #if defined(LIBXML_SCHEMAS_ENABLED)
34120     int mem_base;
34121     xmlSchemaParserCtxtPtr ret_val;
34122     char * buffer; /* a pointer to a char array containing the schemas */
34123     int n_buffer;
34124     int size; /* the size of the array */
34125     int n_size;
34126
34127     for (n_buffer = 0;n_buffer < gen_nb_const_char_ptr;n_buffer++) {
34128     for (n_size = 0;n_size < gen_nb_int;n_size++) {
34129         mem_base = xmlMemBlocks();
34130         buffer = gen_const_char_ptr(n_buffer, 0);
34131         size = gen_int(n_size, 1);
34132
34133         ret_val = xmlSchemaNewMemParserCtxt((const char *)buffer, size);
34134         desret_xmlSchemaParserCtxtPtr(ret_val);
34135         call_tests++;
34136         des_const_char_ptr(n_buffer, (const char *)buffer, 0);
34137         des_int(n_size, size, 1);
34138         xmlResetLastError();
34139         if (mem_base != xmlMemBlocks()) {
34140             printf("Leak of %d blocks found in xmlSchemaNewMemParserCtxt",
34141                    xmlMemBlocks() - mem_base);
34142             test_ret++;
34143             printf(" %d", n_buffer);
34144             printf(" %d", n_size);
34145             printf("\n");
34146         }
34147     }
34148     }
34149     function_tests++;
34150 #endif
34151
34152     return(test_ret);
34153 }
34154
34155
34156 static int
34157 test_xmlSchemaNewParserCtxt(void) {
34158     int test_ret = 0;
34159
34160 #if defined(LIBXML_SCHEMAS_ENABLED)
34161     int mem_base;
34162     xmlSchemaParserCtxtPtr ret_val;
34163     char * URL; /* the location of the schema */
34164     int n_URL;
34165
34166     for (n_URL = 0;n_URL < gen_nb_const_char_ptr;n_URL++) {
34167         mem_base = xmlMemBlocks();
34168         URL = gen_const_char_ptr(n_URL, 0);
34169
34170         ret_val = xmlSchemaNewParserCtxt((const char *)URL);
34171         desret_xmlSchemaParserCtxtPtr(ret_val);
34172         call_tests++;
34173         des_const_char_ptr(n_URL, (const char *)URL, 0);
34174         xmlResetLastError();
34175         if (mem_base != xmlMemBlocks()) {
34176             printf("Leak of %d blocks found in xmlSchemaNewParserCtxt",
34177                    xmlMemBlocks() - mem_base);
34178             test_ret++;
34179             printf(" %d", n_URL);
34180             printf("\n");
34181         }
34182     }
34183     function_tests++;
34184 #endif
34185
34186     return(test_ret);
34187 }
34188
34189
34190 static int
34191 test_xmlSchemaNewValidCtxt(void) {
34192     int test_ret = 0;
34193
34194
34195     /* missing type support */
34196     return(test_ret);
34197 }
34198
34199
34200 static int
34201 test_xmlSchemaParse(void) {
34202     int test_ret = 0;
34203
34204
34205     /* missing type support */
34206     return(test_ret);
34207 }
34208
34209 #ifdef LIBXML_SCHEMAS_ENABLED
34210
34211 #define gen_nb_xmlSAXHandlerPtr_ptr 1
34212 static xmlSAXHandlerPtr * gen_xmlSAXHandlerPtr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34213     return(NULL);
34214 }
34215 static void des_xmlSAXHandlerPtr_ptr(int no ATTRIBUTE_UNUSED, xmlSAXHandlerPtr * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34216 }
34217 #endif
34218
34219
34220 static int
34221 test_xmlSchemaSAXPlug(void) {
34222     int test_ret = 0;
34223
34224
34225     /* missing type support */
34226     return(test_ret);
34227 }
34228
34229 #ifdef LIBXML_SCHEMAS_ENABLED
34230
34231 #define gen_nb_xmlSchemaSAXPlugPtr 1
34232 static xmlSchemaSAXPlugPtr gen_xmlSchemaSAXPlugPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34233     return(NULL);
34234 }
34235 static void des_xmlSchemaSAXPlugPtr(int no ATTRIBUTE_UNUSED, xmlSchemaSAXPlugPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34236 }
34237 #endif
34238
34239
34240 static int
34241 test_xmlSchemaSAXUnplug(void) {
34242     int test_ret = 0;
34243
34244 #if defined(LIBXML_SCHEMAS_ENABLED)
34245     int mem_base;
34246     int ret_val;
34247     xmlSchemaSAXPlugPtr plug; /* a data structure returned by xmlSchemaSAXPlug */
34248     int n_plug;
34249
34250     for (n_plug = 0;n_plug < gen_nb_xmlSchemaSAXPlugPtr;n_plug++) {
34251         mem_base = xmlMemBlocks();
34252         plug = gen_xmlSchemaSAXPlugPtr(n_plug, 0);
34253
34254         ret_val = xmlSchemaSAXUnplug(plug);
34255         desret_int(ret_val);
34256         call_tests++;
34257         des_xmlSchemaSAXPlugPtr(n_plug, plug, 0);
34258         xmlResetLastError();
34259         if (mem_base != xmlMemBlocks()) {
34260             printf("Leak of %d blocks found in xmlSchemaSAXUnplug",
34261                    xmlMemBlocks() - mem_base);
34262             test_ret++;
34263             printf(" %d", n_plug);
34264             printf("\n");
34265         }
34266     }
34267     function_tests++;
34268 #endif
34269
34270     return(test_ret);
34271 }
34272
34273
34274 static int
34275 test_xmlSchemaSetParserErrors(void) {
34276     int test_ret = 0;
34277
34278
34279     /* missing type support */
34280     return(test_ret);
34281 }
34282
34283
34284 static int
34285 test_xmlSchemaSetParserStructuredErrors(void) {
34286     int test_ret = 0;
34287
34288
34289     /* missing type support */
34290     return(test_ret);
34291 }
34292
34293
34294 static int
34295 test_xmlSchemaSetValidErrors(void) {
34296     int test_ret = 0;
34297
34298
34299     /* missing type support */
34300     return(test_ret);
34301 }
34302
34303
34304 static int
34305 test_xmlSchemaSetValidOptions(void) {
34306     int test_ret = 0;
34307
34308 #if defined(LIBXML_SCHEMAS_ENABLED)
34309     int mem_base;
34310     int ret_val;
34311     xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
34312     int n_ctxt;
34313     int options; /* a combination of xmlSchemaValidOption */
34314     int n_options;
34315
34316     for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34317     for (n_options = 0;n_options < gen_nb_int;n_options++) {
34318         mem_base = xmlMemBlocks();
34319         ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34320         options = gen_int(n_options, 1);
34321
34322         ret_val = xmlSchemaSetValidOptions(ctxt, options);
34323         desret_int(ret_val);
34324         call_tests++;
34325         des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34326         des_int(n_options, options, 1);
34327         xmlResetLastError();
34328         if (mem_base != xmlMemBlocks()) {
34329             printf("Leak of %d blocks found in xmlSchemaSetValidOptions",
34330                    xmlMemBlocks() - mem_base);
34331             test_ret++;
34332             printf(" %d", n_ctxt);
34333             printf(" %d", n_options);
34334             printf("\n");
34335         }
34336     }
34337     }
34338     function_tests++;
34339 #endif
34340
34341     return(test_ret);
34342 }
34343
34344
34345 static int
34346 test_xmlSchemaSetValidStructuredErrors(void) {
34347     int test_ret = 0;
34348
34349
34350     /* missing type support */
34351     return(test_ret);
34352 }
34353
34354
34355 static int
34356 test_xmlSchemaValidCtxtGetOptions(void) {
34357     int test_ret = 0;
34358
34359 #if defined(LIBXML_SCHEMAS_ENABLED)
34360     int mem_base;
34361     int ret_val;
34362     xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
34363     int n_ctxt;
34364
34365     for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34366         mem_base = xmlMemBlocks();
34367         ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34368
34369         ret_val = xmlSchemaValidCtxtGetOptions(ctxt);
34370         desret_int(ret_val);
34371         call_tests++;
34372         des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34373         xmlResetLastError();
34374         if (mem_base != xmlMemBlocks()) {
34375             printf("Leak of %d blocks found in xmlSchemaValidCtxtGetOptions",
34376                    xmlMemBlocks() - mem_base);
34377             test_ret++;
34378             printf(" %d", n_ctxt);
34379             printf("\n");
34380         }
34381     }
34382     function_tests++;
34383 #endif
34384
34385     return(test_ret);
34386 }
34387
34388
34389 static int
34390 test_xmlSchemaValidCtxtGetParserCtxt(void) {
34391     int test_ret = 0;
34392
34393 #if defined(LIBXML_SCHEMAS_ENABLED)
34394     int mem_base;
34395     xmlParserCtxtPtr ret_val;
34396     xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
34397     int n_ctxt;
34398
34399     for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34400         mem_base = xmlMemBlocks();
34401         ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34402
34403         ret_val = xmlSchemaValidCtxtGetParserCtxt(ctxt);
34404         desret_xmlParserCtxtPtr(ret_val);
34405         call_tests++;
34406         des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34407         xmlResetLastError();
34408         if (mem_base != xmlMemBlocks()) {
34409             printf("Leak of %d blocks found in xmlSchemaValidCtxtGetParserCtxt",
34410                    xmlMemBlocks() - mem_base);
34411             test_ret++;
34412             printf(" %d", n_ctxt);
34413             printf("\n");
34414         }
34415     }
34416     function_tests++;
34417 #endif
34418
34419     return(test_ret);
34420 }
34421
34422
34423 static int
34424 test_xmlSchemaValidateDoc(void) {
34425     int test_ret = 0;
34426
34427 #if defined(LIBXML_SCHEMAS_ENABLED)
34428     int mem_base;
34429     int ret_val;
34430     xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
34431     int n_ctxt;
34432     xmlDocPtr doc; /* a parsed document tree */
34433     int n_doc;
34434
34435     for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34436     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
34437         mem_base = xmlMemBlocks();
34438         ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34439         doc = gen_xmlDocPtr(n_doc, 1);
34440
34441         ret_val = xmlSchemaValidateDoc(ctxt, doc);
34442         desret_int(ret_val);
34443         call_tests++;
34444         des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34445         des_xmlDocPtr(n_doc, doc, 1);
34446         xmlResetLastError();
34447         if (mem_base != xmlMemBlocks()) {
34448             printf("Leak of %d blocks found in xmlSchemaValidateDoc",
34449                    xmlMemBlocks() - mem_base);
34450             test_ret++;
34451             printf(" %d", n_ctxt);
34452             printf(" %d", n_doc);
34453             printf("\n");
34454         }
34455     }
34456     }
34457     function_tests++;
34458 #endif
34459
34460     return(test_ret);
34461 }
34462
34463
34464 static int
34465 test_xmlSchemaValidateFile(void) {
34466     int test_ret = 0;
34467
34468 #if defined(LIBXML_SCHEMAS_ENABLED)
34469     int mem_base;
34470     int ret_val;
34471     xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
34472     int n_ctxt;
34473     const char * filename; /* the URI of the instance */
34474     int n_filename;
34475     int options; /* a future set of options, currently unused */
34476     int n_options;
34477
34478     for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34479     for (n_filename = 0;n_filename < gen_nb_filepath;n_filename++) {
34480     for (n_options = 0;n_options < gen_nb_int;n_options++) {
34481         mem_base = xmlMemBlocks();
34482         ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34483         filename = gen_filepath(n_filename, 1);
34484         options = gen_int(n_options, 2);
34485
34486         ret_val = xmlSchemaValidateFile(ctxt, filename, options);
34487         desret_int(ret_val);
34488         call_tests++;
34489         des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34490         des_filepath(n_filename, filename, 1);
34491         des_int(n_options, options, 2);
34492         xmlResetLastError();
34493         if (mem_base != xmlMemBlocks()) {
34494             printf("Leak of %d blocks found in xmlSchemaValidateFile",
34495                    xmlMemBlocks() - mem_base);
34496             test_ret++;
34497             printf(" %d", n_ctxt);
34498             printf(" %d", n_filename);
34499             printf(" %d", n_options);
34500             printf("\n");
34501         }
34502     }
34503     }
34504     }
34505     function_tests++;
34506 #endif
34507
34508     return(test_ret);
34509 }
34510
34511
34512 static int
34513 test_xmlSchemaValidateOneElement(void) {
34514     int test_ret = 0;
34515
34516 #if defined(LIBXML_SCHEMAS_ENABLED)
34517     int mem_base;
34518     int ret_val;
34519     xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
34520     int n_ctxt;
34521     xmlNodePtr elem; /* an element node */
34522     int n_elem;
34523
34524     for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34525     for (n_elem = 0;n_elem < gen_nb_xmlNodePtr;n_elem++) {
34526         mem_base = xmlMemBlocks();
34527         ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34528         elem = gen_xmlNodePtr(n_elem, 1);
34529
34530         ret_val = xmlSchemaValidateOneElement(ctxt, elem);
34531         desret_int(ret_val);
34532         call_tests++;
34533         des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34534         des_xmlNodePtr(n_elem, elem, 1);
34535         xmlResetLastError();
34536         if (mem_base != xmlMemBlocks()) {
34537             printf("Leak of %d blocks found in xmlSchemaValidateOneElement",
34538                    xmlMemBlocks() - mem_base);
34539             test_ret++;
34540             printf(" %d", n_ctxt);
34541             printf(" %d", n_elem);
34542             printf("\n");
34543         }
34544     }
34545     }
34546     function_tests++;
34547 #endif
34548
34549     return(test_ret);
34550 }
34551
34552
34553 static int
34554 test_xmlSchemaValidateStream(void) {
34555     int test_ret = 0;
34556
34557 #if defined(LIBXML_SCHEMAS_ENABLED)
34558     int mem_base;
34559     int ret_val;
34560     xmlSchemaValidCtxtPtr ctxt; /* a schema validation context */
34561     int n_ctxt;
34562     xmlParserInputBufferPtr input; /* the input to use for reading the data */
34563     int n_input;
34564     xmlCharEncoding enc; /* an optional encoding information */
34565     int n_enc;
34566     xmlSAXHandlerPtr sax; /* a SAX handler for the resulting events */
34567     int n_sax;
34568     void * user_data; /* the context to provide to the SAX handler. */
34569     int n_user_data;
34570
34571     for (n_ctxt = 0;n_ctxt < gen_nb_xmlSchemaValidCtxtPtr;n_ctxt++) {
34572     for (n_input = 0;n_input < gen_nb_xmlParserInputBufferPtr;n_input++) {
34573     for (n_enc = 0;n_enc < gen_nb_xmlCharEncoding;n_enc++) {
34574     for (n_sax = 0;n_sax < gen_nb_xmlSAXHandlerPtr;n_sax++) {
34575     for (n_user_data = 0;n_user_data < gen_nb_userdata;n_user_data++) {
34576         mem_base = xmlMemBlocks();
34577         ctxt = gen_xmlSchemaValidCtxtPtr(n_ctxt, 0);
34578         input = gen_xmlParserInputBufferPtr(n_input, 1);
34579         enc = gen_xmlCharEncoding(n_enc, 2);
34580         sax = gen_xmlSAXHandlerPtr(n_sax, 3);
34581         user_data = gen_userdata(n_user_data, 4);
34582
34583         ret_val = xmlSchemaValidateStream(ctxt, input, enc, sax, user_data);
34584         desret_int(ret_val);
34585         call_tests++;
34586         des_xmlSchemaValidCtxtPtr(n_ctxt, ctxt, 0);
34587         des_xmlParserInputBufferPtr(n_input, input, 1);
34588         des_xmlCharEncoding(n_enc, enc, 2);
34589         des_xmlSAXHandlerPtr(n_sax, sax, 3);
34590         des_userdata(n_user_data, user_data, 4);
34591         xmlResetLastError();
34592         if (mem_base != xmlMemBlocks()) {
34593             printf("Leak of %d blocks found in xmlSchemaValidateStream",
34594                    xmlMemBlocks() - mem_base);
34595             test_ret++;
34596             printf(" %d", n_ctxt);
34597             printf(" %d", n_input);
34598             printf(" %d", n_enc);
34599             printf(" %d", n_sax);
34600             printf(" %d", n_user_data);
34601             printf("\n");
34602         }
34603     }
34604     }
34605     }
34606     }
34607     }
34608     function_tests++;
34609 #endif
34610
34611     return(test_ret);
34612 }
34613
34614 static int
34615 test_xmlschemas(void) {
34616     int test_ret = 0;
34617
34618     if (quiet == 0) printf("Testing xmlschemas : 15 of 25 functions ...\n");
34619     test_ret += test_xmlSchemaDump();
34620     test_ret += test_xmlSchemaGetParserErrors();
34621     test_ret += test_xmlSchemaGetValidErrors();
34622     test_ret += test_xmlSchemaIsValid();
34623     test_ret += test_xmlSchemaNewDocParserCtxt();
34624     test_ret += test_xmlSchemaNewMemParserCtxt();
34625     test_ret += test_xmlSchemaNewParserCtxt();
34626     test_ret += test_xmlSchemaNewValidCtxt();
34627     test_ret += test_xmlSchemaParse();
34628     test_ret += test_xmlSchemaSAXPlug();
34629     test_ret += test_xmlSchemaSAXUnplug();
34630     test_ret += test_xmlSchemaSetParserErrors();
34631     test_ret += test_xmlSchemaSetParserStructuredErrors();
34632     test_ret += test_xmlSchemaSetValidErrors();
34633     test_ret += test_xmlSchemaSetValidOptions();
34634     test_ret += test_xmlSchemaSetValidStructuredErrors();
34635     test_ret += test_xmlSchemaValidCtxtGetOptions();
34636     test_ret += test_xmlSchemaValidCtxtGetParserCtxt();
34637     test_ret += test_xmlSchemaValidateDoc();
34638     test_ret += test_xmlSchemaValidateFile();
34639     test_ret += test_xmlSchemaValidateOneElement();
34640     test_ret += test_xmlSchemaValidateStream();
34641
34642     if (test_ret != 0)
34643         printf("Module xmlschemas: %d errors\n", test_ret);
34644     return(test_ret);
34645 }
34646 #ifdef LIBXML_SCHEMAS_ENABLED
34647
34648 #define gen_nb_xmlSchemaFacetPtr 1
34649 static xmlSchemaFacetPtr gen_xmlSchemaFacetPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34650     return(NULL);
34651 }
34652 static void des_xmlSchemaFacetPtr(int no ATTRIBUTE_UNUSED, xmlSchemaFacetPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34653 }
34654 #endif
34655
34656 #ifdef LIBXML_SCHEMAS_ENABLED
34657
34658 #define gen_nb_xmlSchemaTypePtr 1
34659 static xmlSchemaTypePtr gen_xmlSchemaTypePtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34660     return(NULL);
34661 }
34662 static void des_xmlSchemaTypePtr(int no ATTRIBUTE_UNUSED, xmlSchemaTypePtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34663 }
34664 #endif
34665
34666
34667 static int
34668 test_xmlSchemaCheckFacet(void) {
34669     int test_ret = 0;
34670
34671 #if defined(LIBXML_SCHEMAS_ENABLED)
34672     int mem_base;
34673     int ret_val;
34674     xmlSchemaFacetPtr facet; /* the facet */
34675     int n_facet;
34676     xmlSchemaTypePtr typeDecl; /* the schema type definition */
34677     int n_typeDecl;
34678     xmlSchemaParserCtxtPtr pctxt; /* the schema parser context or NULL */
34679     int n_pctxt;
34680     xmlChar * name; /* the optional name of the type */
34681     int n_name;
34682
34683     for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
34684     for (n_typeDecl = 0;n_typeDecl < gen_nb_xmlSchemaTypePtr;n_typeDecl++) {
34685     for (n_pctxt = 0;n_pctxt < gen_nb_xmlSchemaParserCtxtPtr;n_pctxt++) {
34686     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
34687         mem_base = xmlMemBlocks();
34688         facet = gen_xmlSchemaFacetPtr(n_facet, 0);
34689         typeDecl = gen_xmlSchemaTypePtr(n_typeDecl, 1);
34690         pctxt = gen_xmlSchemaParserCtxtPtr(n_pctxt, 2);
34691         name = gen_const_xmlChar_ptr(n_name, 3);
34692
34693         ret_val = xmlSchemaCheckFacet(facet, typeDecl, pctxt, (const xmlChar *)name);
34694         desret_int(ret_val);
34695         call_tests++;
34696         des_xmlSchemaFacetPtr(n_facet, facet, 0);
34697         des_xmlSchemaTypePtr(n_typeDecl, typeDecl, 1);
34698         des_xmlSchemaParserCtxtPtr(n_pctxt, pctxt, 2);
34699         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 3);
34700         xmlResetLastError();
34701         if (mem_base != xmlMemBlocks()) {
34702             printf("Leak of %d blocks found in xmlSchemaCheckFacet",
34703                    xmlMemBlocks() - mem_base);
34704             test_ret++;
34705             printf(" %d", n_facet);
34706             printf(" %d", n_typeDecl);
34707             printf(" %d", n_pctxt);
34708             printf(" %d", n_name);
34709             printf("\n");
34710         }
34711     }
34712     }
34713     }
34714     }
34715     function_tests++;
34716 #endif
34717
34718     return(test_ret);
34719 }
34720
34721
34722 static int
34723 test_xmlSchemaCleanupTypes(void) {
34724     int test_ret = 0;
34725
34726 #if defined(LIBXML_SCHEMAS_ENABLED)
34727
34728
34729         xmlSchemaCleanupTypes();
34730         call_tests++;
34731         xmlResetLastError();
34732     function_tests++;
34733 #endif
34734
34735     return(test_ret);
34736 }
34737
34738
34739 static int
34740 test_xmlSchemaCollapseString(void) {
34741     int test_ret = 0;
34742
34743 #if defined(LIBXML_SCHEMAS_ENABLED)
34744     int mem_base;
34745     xmlChar * ret_val;
34746     xmlChar * value; /* a value */
34747     int n_value;
34748
34749     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
34750         mem_base = xmlMemBlocks();
34751         value = gen_const_xmlChar_ptr(n_value, 0);
34752
34753         ret_val = xmlSchemaCollapseString((const xmlChar *)value);
34754         desret_xmlChar_ptr(ret_val);
34755         call_tests++;
34756         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
34757         xmlResetLastError();
34758         if (mem_base != xmlMemBlocks()) {
34759             printf("Leak of %d blocks found in xmlSchemaCollapseString",
34760                    xmlMemBlocks() - mem_base);
34761             test_ret++;
34762             printf(" %d", n_value);
34763             printf("\n");
34764         }
34765     }
34766     function_tests++;
34767 #endif
34768
34769     return(test_ret);
34770 }
34771
34772 #ifdef LIBXML_SCHEMAS_ENABLED
34773
34774 #define gen_nb_xmlSchemaValPtr 1
34775 static xmlSchemaValPtr gen_xmlSchemaValPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34776     return(NULL);
34777 }
34778 static void des_xmlSchemaValPtr(int no ATTRIBUTE_UNUSED, xmlSchemaValPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
34779 }
34780 #endif
34781
34782
34783 static int
34784 test_xmlSchemaCompareValues(void) {
34785     int test_ret = 0;
34786
34787 #if defined(LIBXML_SCHEMAS_ENABLED)
34788     int mem_base;
34789     int ret_val;
34790     xmlSchemaValPtr x; /* a first value */
34791     int n_x;
34792     xmlSchemaValPtr y; /* a second value */
34793     int n_y;
34794
34795     for (n_x = 0;n_x < gen_nb_xmlSchemaValPtr;n_x++) {
34796     for (n_y = 0;n_y < gen_nb_xmlSchemaValPtr;n_y++) {
34797         mem_base = xmlMemBlocks();
34798         x = gen_xmlSchemaValPtr(n_x, 0);
34799         y = gen_xmlSchemaValPtr(n_y, 1);
34800
34801         ret_val = xmlSchemaCompareValues(x, y);
34802         desret_int(ret_val);
34803         call_tests++;
34804         des_xmlSchemaValPtr(n_x, x, 0);
34805         des_xmlSchemaValPtr(n_y, y, 1);
34806         xmlResetLastError();
34807         if (mem_base != xmlMemBlocks()) {
34808             printf("Leak of %d blocks found in xmlSchemaCompareValues",
34809                    xmlMemBlocks() - mem_base);
34810             test_ret++;
34811             printf(" %d", n_x);
34812             printf(" %d", n_y);
34813             printf("\n");
34814         }
34815     }
34816     }
34817     function_tests++;
34818 #endif
34819
34820     return(test_ret);
34821 }
34822
34823
34824 static int
34825 test_xmlSchemaCompareValuesWhtsp(void) {
34826     int test_ret = 0;
34827
34828 #if defined(LIBXML_SCHEMAS_ENABLED)
34829     int mem_base;
34830     int ret_val;
34831     xmlSchemaValPtr x; /* a first value */
34832     int n_x;
34833     xmlSchemaWhitespaceValueType xws; /* the whitespace value of x */
34834     int n_xws;
34835     xmlSchemaValPtr y; /* a second value */
34836     int n_y;
34837     xmlSchemaWhitespaceValueType yws; /* the whitespace value of y */
34838     int n_yws;
34839
34840     for (n_x = 0;n_x < gen_nb_xmlSchemaValPtr;n_x++) {
34841     for (n_xws = 0;n_xws < gen_nb_xmlSchemaWhitespaceValueType;n_xws++) {
34842     for (n_y = 0;n_y < gen_nb_xmlSchemaValPtr;n_y++) {
34843     for (n_yws = 0;n_yws < gen_nb_xmlSchemaWhitespaceValueType;n_yws++) {
34844         mem_base = xmlMemBlocks();
34845         x = gen_xmlSchemaValPtr(n_x, 0);
34846         xws = gen_xmlSchemaWhitespaceValueType(n_xws, 1);
34847         y = gen_xmlSchemaValPtr(n_y, 2);
34848         yws = gen_xmlSchemaWhitespaceValueType(n_yws, 3);
34849
34850         ret_val = xmlSchemaCompareValuesWhtsp(x, xws, y, yws);
34851         desret_int(ret_val);
34852         call_tests++;
34853         des_xmlSchemaValPtr(n_x, x, 0);
34854         des_xmlSchemaWhitespaceValueType(n_xws, xws, 1);
34855         des_xmlSchemaValPtr(n_y, y, 2);
34856         des_xmlSchemaWhitespaceValueType(n_yws, yws, 3);
34857         xmlResetLastError();
34858         if (mem_base != xmlMemBlocks()) {
34859             printf("Leak of %d blocks found in xmlSchemaCompareValuesWhtsp",
34860                    xmlMemBlocks() - mem_base);
34861             test_ret++;
34862             printf(" %d", n_x);
34863             printf(" %d", n_xws);
34864             printf(" %d", n_y);
34865             printf(" %d", n_yws);
34866             printf("\n");
34867         }
34868     }
34869     }
34870     }
34871     }
34872     function_tests++;
34873 #endif
34874
34875     return(test_ret);
34876 }
34877
34878
34879 static int
34880 test_xmlSchemaCopyValue(void) {
34881     int test_ret = 0;
34882
34883
34884     /* missing type support */
34885     return(test_ret);
34886 }
34887
34888
34889 static int
34890 test_xmlSchemaGetBuiltInListSimpleTypeItemType(void) {
34891     int test_ret = 0;
34892
34893 #if defined(LIBXML_SCHEMAS_ENABLED)
34894     int mem_base;
34895     xmlSchemaTypePtr ret_val;
34896     xmlSchemaTypePtr type; /* the built-in simple type. */
34897     int n_type;
34898
34899     for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
34900         mem_base = xmlMemBlocks();
34901         type = gen_xmlSchemaTypePtr(n_type, 0);
34902
34903         ret_val = xmlSchemaGetBuiltInListSimpleTypeItemType(type);
34904         desret_xmlSchemaTypePtr(ret_val);
34905         call_tests++;
34906         des_xmlSchemaTypePtr(n_type, type, 0);
34907         xmlResetLastError();
34908         if (mem_base != xmlMemBlocks()) {
34909             printf("Leak of %d blocks found in xmlSchemaGetBuiltInListSimpleTypeItemType",
34910                    xmlMemBlocks() - mem_base);
34911             test_ret++;
34912             printf(" %d", n_type);
34913             printf("\n");
34914         }
34915     }
34916     function_tests++;
34917 #endif
34918
34919     return(test_ret);
34920 }
34921
34922
34923 static int
34924 test_xmlSchemaGetBuiltInType(void) {
34925     int test_ret = 0;
34926
34927 #if defined(LIBXML_SCHEMAS_ENABLED)
34928     xmlSchemaTypePtr ret_val;
34929     xmlSchemaValType type; /* the type of the built in type */
34930     int n_type;
34931
34932     for (n_type = 0;n_type < gen_nb_xmlSchemaValType;n_type++) {
34933         type = gen_xmlSchemaValType(n_type, 0);
34934
34935         ret_val = xmlSchemaGetBuiltInType(type);
34936         desret_xmlSchemaTypePtr(ret_val);
34937         call_tests++;
34938         des_xmlSchemaValType(n_type, type, 0);
34939         xmlResetLastError();
34940     }
34941     function_tests++;
34942 #endif
34943
34944     return(test_ret);
34945 }
34946
34947
34948 static int
34949 test_xmlSchemaGetCanonValue(void) {
34950     int test_ret = 0;
34951
34952 #if defined(LIBXML_SCHEMAS_ENABLED)
34953     int mem_base;
34954     int ret_val;
34955     xmlSchemaValPtr val; /* the precomputed value */
34956     int n_val;
34957     xmlChar ** retValue; /* the returned value */
34958     int n_retValue;
34959
34960     for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
34961     for (n_retValue = 0;n_retValue < gen_nb_const_xmlChar_ptr_ptr;n_retValue++) {
34962         mem_base = xmlMemBlocks();
34963         val = gen_xmlSchemaValPtr(n_val, 0);
34964         retValue = gen_const_xmlChar_ptr_ptr(n_retValue, 1);
34965
34966         ret_val = xmlSchemaGetCanonValue(val, (const xmlChar **)retValue);
34967         desret_int(ret_val);
34968         call_tests++;
34969         des_xmlSchemaValPtr(n_val, val, 0);
34970         des_const_xmlChar_ptr_ptr(n_retValue, (const xmlChar **)retValue, 1);
34971         xmlResetLastError();
34972         if (mem_base != xmlMemBlocks()) {
34973             printf("Leak of %d blocks found in xmlSchemaGetCanonValue",
34974                    xmlMemBlocks() - mem_base);
34975             test_ret++;
34976             printf(" %d", n_val);
34977             printf(" %d", n_retValue);
34978             printf("\n");
34979         }
34980     }
34981     }
34982     function_tests++;
34983 #endif
34984
34985     return(test_ret);
34986 }
34987
34988
34989 static int
34990 test_xmlSchemaGetCanonValueWhtsp(void) {
34991     int test_ret = 0;
34992
34993 #if defined(LIBXML_SCHEMAS_ENABLED)
34994     int mem_base;
34995     int ret_val;
34996     xmlSchemaValPtr val; /* the precomputed value */
34997     int n_val;
34998     xmlChar ** retValue; /* the returned value */
34999     int n_retValue;
35000     xmlSchemaWhitespaceValueType ws; /* the whitespace type of the value */
35001     int n_ws;
35002
35003     for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
35004     for (n_retValue = 0;n_retValue < gen_nb_const_xmlChar_ptr_ptr;n_retValue++) {
35005     for (n_ws = 0;n_ws < gen_nb_xmlSchemaWhitespaceValueType;n_ws++) {
35006         mem_base = xmlMemBlocks();
35007         val = gen_xmlSchemaValPtr(n_val, 0);
35008         retValue = gen_const_xmlChar_ptr_ptr(n_retValue, 1);
35009         ws = gen_xmlSchemaWhitespaceValueType(n_ws, 2);
35010
35011         ret_val = xmlSchemaGetCanonValueWhtsp(val, (const xmlChar **)retValue, ws);
35012         desret_int(ret_val);
35013         call_tests++;
35014         des_xmlSchemaValPtr(n_val, val, 0);
35015         des_const_xmlChar_ptr_ptr(n_retValue, (const xmlChar **)retValue, 1);
35016         des_xmlSchemaWhitespaceValueType(n_ws, ws, 2);
35017         xmlResetLastError();
35018         if (mem_base != xmlMemBlocks()) {
35019             printf("Leak of %d blocks found in xmlSchemaGetCanonValueWhtsp",
35020                    xmlMemBlocks() - mem_base);
35021             test_ret++;
35022             printf(" %d", n_val);
35023             printf(" %d", n_retValue);
35024             printf(" %d", n_ws);
35025             printf("\n");
35026         }
35027     }
35028     }
35029     }
35030     function_tests++;
35031 #endif
35032
35033     return(test_ret);
35034 }
35035
35036
35037 static int
35038 test_xmlSchemaGetFacetValueAsULong(void) {
35039     int test_ret = 0;
35040
35041 #if defined(LIBXML_SCHEMAS_ENABLED)
35042     int mem_base;
35043     unsigned long ret_val;
35044     xmlSchemaFacetPtr facet; /* an schemas type facet */
35045     int n_facet;
35046
35047     for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
35048         mem_base = xmlMemBlocks();
35049         facet = gen_xmlSchemaFacetPtr(n_facet, 0);
35050
35051         ret_val = xmlSchemaGetFacetValueAsULong(facet);
35052         desret_unsigned_long(ret_val);
35053         call_tests++;
35054         des_xmlSchemaFacetPtr(n_facet, facet, 0);
35055         xmlResetLastError();
35056         if (mem_base != xmlMemBlocks()) {
35057             printf("Leak of %d blocks found in xmlSchemaGetFacetValueAsULong",
35058                    xmlMemBlocks() - mem_base);
35059             test_ret++;
35060             printf(" %d", n_facet);
35061             printf("\n");
35062         }
35063     }
35064     function_tests++;
35065 #endif
35066
35067     return(test_ret);
35068 }
35069
35070
35071 static int
35072 test_xmlSchemaGetPredefinedType(void) {
35073     int test_ret = 0;
35074
35075 #if defined(LIBXML_SCHEMAS_ENABLED)
35076     int mem_base;
35077     xmlSchemaTypePtr ret_val;
35078     xmlChar * name; /* the type name */
35079     int n_name;
35080     xmlChar * ns; /* the URI of the namespace usually "http://www.w3.org/2001/XMLSchema" */
35081     int n_ns;
35082
35083     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
35084     for (n_ns = 0;n_ns < gen_nb_const_xmlChar_ptr;n_ns++) {
35085         mem_base = xmlMemBlocks();
35086         name = gen_const_xmlChar_ptr(n_name, 0);
35087         ns = gen_const_xmlChar_ptr(n_ns, 1);
35088
35089         ret_val = xmlSchemaGetPredefinedType((const xmlChar *)name, (const xmlChar *)ns);
35090         desret_xmlSchemaTypePtr(ret_val);
35091         call_tests++;
35092         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
35093         des_const_xmlChar_ptr(n_ns, (const xmlChar *)ns, 1);
35094         xmlResetLastError();
35095         if (mem_base != xmlMemBlocks()) {
35096             printf("Leak of %d blocks found in xmlSchemaGetPredefinedType",
35097                    xmlMemBlocks() - mem_base);
35098             test_ret++;
35099             printf(" %d", n_name);
35100             printf(" %d", n_ns);
35101             printf("\n");
35102         }
35103     }
35104     }
35105     function_tests++;
35106 #endif
35107
35108     return(test_ret);
35109 }
35110
35111
35112 static int
35113 test_xmlSchemaGetValType(void) {
35114     int test_ret = 0;
35115
35116 #if defined(LIBXML_SCHEMAS_ENABLED)
35117     int mem_base;
35118     xmlSchemaValType ret_val;
35119     xmlSchemaValPtr val; /* a schemas value */
35120     int n_val;
35121
35122     for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
35123         mem_base = xmlMemBlocks();
35124         val = gen_xmlSchemaValPtr(n_val, 0);
35125
35126         ret_val = xmlSchemaGetValType(val);
35127         desret_xmlSchemaValType(ret_val);
35128         call_tests++;
35129         des_xmlSchemaValPtr(n_val, val, 0);
35130         xmlResetLastError();
35131         if (mem_base != xmlMemBlocks()) {
35132             printf("Leak of %d blocks found in xmlSchemaGetValType",
35133                    xmlMemBlocks() - mem_base);
35134             test_ret++;
35135             printf(" %d", n_val);
35136             printf("\n");
35137         }
35138     }
35139     function_tests++;
35140 #endif
35141
35142     return(test_ret);
35143 }
35144
35145
35146 static int
35147 test_xmlSchemaInitTypes(void) {
35148     int test_ret = 0;
35149
35150 #if defined(LIBXML_SCHEMAS_ENABLED)
35151
35152
35153         xmlSchemaInitTypes();
35154         call_tests++;
35155         xmlResetLastError();
35156     function_tests++;
35157 #endif
35158
35159     return(test_ret);
35160 }
35161
35162
35163 static int
35164 test_xmlSchemaIsBuiltInTypeFacet(void) {
35165     int test_ret = 0;
35166
35167 #if defined(LIBXML_SCHEMAS_ENABLED)
35168     int mem_base;
35169     int ret_val;
35170     xmlSchemaTypePtr type; /* the built-in type */
35171     int n_type;
35172     int facetType; /* the facet type */
35173     int n_facetType;
35174
35175     for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
35176     for (n_facetType = 0;n_facetType < gen_nb_int;n_facetType++) {
35177         mem_base = xmlMemBlocks();
35178         type = gen_xmlSchemaTypePtr(n_type, 0);
35179         facetType = gen_int(n_facetType, 1);
35180
35181         ret_val = xmlSchemaIsBuiltInTypeFacet(type, facetType);
35182         desret_int(ret_val);
35183         call_tests++;
35184         des_xmlSchemaTypePtr(n_type, type, 0);
35185         des_int(n_facetType, facetType, 1);
35186         xmlResetLastError();
35187         if (mem_base != xmlMemBlocks()) {
35188             printf("Leak of %d blocks found in xmlSchemaIsBuiltInTypeFacet",
35189                    xmlMemBlocks() - mem_base);
35190             test_ret++;
35191             printf(" %d", n_type);
35192             printf(" %d", n_facetType);
35193             printf("\n");
35194         }
35195     }
35196     }
35197     function_tests++;
35198 #endif
35199
35200     return(test_ret);
35201 }
35202
35203
35204 static int
35205 test_xmlSchemaNewFacet(void) {
35206     int test_ret = 0;
35207
35208
35209     /* missing type support */
35210     return(test_ret);
35211 }
35212
35213
35214 static int
35215 test_xmlSchemaNewNOTATIONValue(void) {
35216     int test_ret = 0;
35217
35218
35219     /* missing type support */
35220     return(test_ret);
35221 }
35222
35223
35224 static int
35225 test_xmlSchemaNewQNameValue(void) {
35226     int test_ret = 0;
35227
35228
35229     /* missing type support */
35230     return(test_ret);
35231 }
35232
35233
35234 static int
35235 test_xmlSchemaNewStringValue(void) {
35236     int test_ret = 0;
35237
35238
35239     /* missing type support */
35240     return(test_ret);
35241 }
35242
35243 #ifdef LIBXML_SCHEMAS_ENABLED
35244
35245 #define gen_nb_xmlSchemaValPtr_ptr 1
35246 static xmlSchemaValPtr * gen_xmlSchemaValPtr_ptr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
35247     return(NULL);
35248 }
35249 static void des_xmlSchemaValPtr_ptr(int no ATTRIBUTE_UNUSED, xmlSchemaValPtr * val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
35250 }
35251 #endif
35252
35253
35254 static int
35255 test_xmlSchemaValPredefTypeNode(void) {
35256     int test_ret = 0;
35257
35258 #if defined(LIBXML_SCHEMAS_ENABLED)
35259     int mem_base;
35260     int ret_val;
35261     xmlSchemaTypePtr type; /* the predefined type */
35262     int n_type;
35263     xmlChar * value; /* the value to check */
35264     int n_value;
35265     xmlSchemaValPtr * val; /* the return computed value */
35266     int n_val;
35267     xmlNodePtr node; /* the node containing the value */
35268     int n_node;
35269
35270     for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
35271     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35272     for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr_ptr;n_val++) {
35273     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
35274         mem_base = xmlMemBlocks();
35275         type = gen_xmlSchemaTypePtr(n_type, 0);
35276         value = gen_const_xmlChar_ptr(n_value, 1);
35277         val = gen_xmlSchemaValPtr_ptr(n_val, 2);
35278         node = gen_xmlNodePtr(n_node, 3);
35279
35280         ret_val = xmlSchemaValPredefTypeNode(type, (const xmlChar *)value, val, node);
35281         desret_int(ret_val);
35282         call_tests++;
35283         des_xmlSchemaTypePtr(n_type, type, 0);
35284         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
35285         des_xmlSchemaValPtr_ptr(n_val, val, 2);
35286         des_xmlNodePtr(n_node, node, 3);
35287         xmlResetLastError();
35288         if (mem_base != xmlMemBlocks()) {
35289             printf("Leak of %d blocks found in xmlSchemaValPredefTypeNode",
35290                    xmlMemBlocks() - mem_base);
35291             test_ret++;
35292             printf(" %d", n_type);
35293             printf(" %d", n_value);
35294             printf(" %d", n_val);
35295             printf(" %d", n_node);
35296             printf("\n");
35297         }
35298     }
35299     }
35300     }
35301     }
35302     function_tests++;
35303 #endif
35304
35305     return(test_ret);
35306 }
35307
35308
35309 static int
35310 test_xmlSchemaValPredefTypeNodeNoNorm(void) {
35311     int test_ret = 0;
35312
35313 #if defined(LIBXML_SCHEMAS_ENABLED)
35314     int mem_base;
35315     int ret_val;
35316     xmlSchemaTypePtr type; /* the predefined type */
35317     int n_type;
35318     xmlChar * value; /* the value to check */
35319     int n_value;
35320     xmlSchemaValPtr * val; /* the return computed value */
35321     int n_val;
35322     xmlNodePtr node; /* the node containing the value */
35323     int n_node;
35324
35325     for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
35326     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35327     for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr_ptr;n_val++) {
35328     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
35329         mem_base = xmlMemBlocks();
35330         type = gen_xmlSchemaTypePtr(n_type, 0);
35331         value = gen_const_xmlChar_ptr(n_value, 1);
35332         val = gen_xmlSchemaValPtr_ptr(n_val, 2);
35333         node = gen_xmlNodePtr(n_node, 3);
35334
35335         ret_val = xmlSchemaValPredefTypeNodeNoNorm(type, (const xmlChar *)value, val, node);
35336         desret_int(ret_val);
35337         call_tests++;
35338         des_xmlSchemaTypePtr(n_type, type, 0);
35339         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
35340         des_xmlSchemaValPtr_ptr(n_val, val, 2);
35341         des_xmlNodePtr(n_node, node, 3);
35342         xmlResetLastError();
35343         if (mem_base != xmlMemBlocks()) {
35344             printf("Leak of %d blocks found in xmlSchemaValPredefTypeNodeNoNorm",
35345                    xmlMemBlocks() - mem_base);
35346             test_ret++;
35347             printf(" %d", n_type);
35348             printf(" %d", n_value);
35349             printf(" %d", n_val);
35350             printf(" %d", n_node);
35351             printf("\n");
35352         }
35353     }
35354     }
35355     }
35356     }
35357     function_tests++;
35358 #endif
35359
35360     return(test_ret);
35361 }
35362
35363
35364 static int
35365 test_xmlSchemaValidateFacet(void) {
35366     int test_ret = 0;
35367
35368 #if defined(LIBXML_SCHEMAS_ENABLED)
35369     int mem_base;
35370     int ret_val;
35371     xmlSchemaTypePtr base; /* the base type */
35372     int n_base;
35373     xmlSchemaFacetPtr facet; /* the facet to check */
35374     int n_facet;
35375     xmlChar * value; /* the lexical repr of the value to validate */
35376     int n_value;
35377     xmlSchemaValPtr val; /* the precomputed value */
35378     int n_val;
35379
35380     for (n_base = 0;n_base < gen_nb_xmlSchemaTypePtr;n_base++) {
35381     for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
35382     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35383     for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
35384         mem_base = xmlMemBlocks();
35385         base = gen_xmlSchemaTypePtr(n_base, 0);
35386         facet = gen_xmlSchemaFacetPtr(n_facet, 1);
35387         value = gen_const_xmlChar_ptr(n_value, 2);
35388         val = gen_xmlSchemaValPtr(n_val, 3);
35389
35390         ret_val = xmlSchemaValidateFacet(base, facet, (const xmlChar *)value, val);
35391         desret_int(ret_val);
35392         call_tests++;
35393         des_xmlSchemaTypePtr(n_base, base, 0);
35394         des_xmlSchemaFacetPtr(n_facet, facet, 1);
35395         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2);
35396         des_xmlSchemaValPtr(n_val, val, 3);
35397         xmlResetLastError();
35398         if (mem_base != xmlMemBlocks()) {
35399             printf("Leak of %d blocks found in xmlSchemaValidateFacet",
35400                    xmlMemBlocks() - mem_base);
35401             test_ret++;
35402             printf(" %d", n_base);
35403             printf(" %d", n_facet);
35404             printf(" %d", n_value);
35405             printf(" %d", n_val);
35406             printf("\n");
35407         }
35408     }
35409     }
35410     }
35411     }
35412     function_tests++;
35413 #endif
35414
35415     return(test_ret);
35416 }
35417
35418
35419 static int
35420 test_xmlSchemaValidateFacetWhtsp(void) {
35421     int test_ret = 0;
35422
35423 #if defined(LIBXML_SCHEMAS_ENABLED)
35424     int mem_base;
35425     int ret_val;
35426     xmlSchemaFacetPtr facet; /* the facet to check */
35427     int n_facet;
35428     xmlSchemaWhitespaceValueType fws; /* the whitespace type of the facet's value */
35429     int n_fws;
35430     xmlSchemaValType valType; /* the built-in type of the value */
35431     int n_valType;
35432     xmlChar * value; /* the lexical (or normalized for pattern) repr of the value to validate */
35433     int n_value;
35434     xmlSchemaValPtr val; /* the precomputed value */
35435     int n_val;
35436     xmlSchemaWhitespaceValueType ws; /* the whitespace type of the value */
35437     int n_ws;
35438
35439     for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
35440     for (n_fws = 0;n_fws < gen_nb_xmlSchemaWhitespaceValueType;n_fws++) {
35441     for (n_valType = 0;n_valType < gen_nb_xmlSchemaValType;n_valType++) {
35442     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35443     for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
35444     for (n_ws = 0;n_ws < gen_nb_xmlSchemaWhitespaceValueType;n_ws++) {
35445         mem_base = xmlMemBlocks();
35446         facet = gen_xmlSchemaFacetPtr(n_facet, 0);
35447         fws = gen_xmlSchemaWhitespaceValueType(n_fws, 1);
35448         valType = gen_xmlSchemaValType(n_valType, 2);
35449         value = gen_const_xmlChar_ptr(n_value, 3);
35450         val = gen_xmlSchemaValPtr(n_val, 4);
35451         ws = gen_xmlSchemaWhitespaceValueType(n_ws, 5);
35452
35453         ret_val = xmlSchemaValidateFacetWhtsp(facet, fws, valType, (const xmlChar *)value, val, ws);
35454         desret_int(ret_val);
35455         call_tests++;
35456         des_xmlSchemaFacetPtr(n_facet, facet, 0);
35457         des_xmlSchemaWhitespaceValueType(n_fws, fws, 1);
35458         des_xmlSchemaValType(n_valType, valType, 2);
35459         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 3);
35460         des_xmlSchemaValPtr(n_val, val, 4);
35461         des_xmlSchemaWhitespaceValueType(n_ws, ws, 5);
35462         xmlResetLastError();
35463         if (mem_base != xmlMemBlocks()) {
35464             printf("Leak of %d blocks found in xmlSchemaValidateFacetWhtsp",
35465                    xmlMemBlocks() - mem_base);
35466             test_ret++;
35467             printf(" %d", n_facet);
35468             printf(" %d", n_fws);
35469             printf(" %d", n_valType);
35470             printf(" %d", n_value);
35471             printf(" %d", n_val);
35472             printf(" %d", n_ws);
35473             printf("\n");
35474         }
35475     }
35476     }
35477     }
35478     }
35479     }
35480     }
35481     function_tests++;
35482 #endif
35483
35484     return(test_ret);
35485 }
35486
35487
35488 static int
35489 test_xmlSchemaValidateLengthFacet(void) {
35490     int test_ret = 0;
35491
35492 #if defined(LIBXML_SCHEMAS_ENABLED)
35493     int mem_base;
35494     int ret_val;
35495     xmlSchemaTypePtr type; /* the built-in type */
35496     int n_type;
35497     xmlSchemaFacetPtr facet; /* the facet to check */
35498     int n_facet;
35499     xmlChar * value; /* the lexical repr. of the value to be validated */
35500     int n_value;
35501     xmlSchemaValPtr val; /* the precomputed value */
35502     int n_val;
35503     unsigned long * length; /* the actual length of the value */
35504     int n_length;
35505
35506     for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
35507     for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
35508     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35509     for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
35510     for (n_length = 0;n_length < gen_nb_unsigned_long_ptr;n_length++) {
35511         mem_base = xmlMemBlocks();
35512         type = gen_xmlSchemaTypePtr(n_type, 0);
35513         facet = gen_xmlSchemaFacetPtr(n_facet, 1);
35514         value = gen_const_xmlChar_ptr(n_value, 2);
35515         val = gen_xmlSchemaValPtr(n_val, 3);
35516         length = gen_unsigned_long_ptr(n_length, 4);
35517
35518         ret_val = xmlSchemaValidateLengthFacet(type, facet, (const xmlChar *)value, val, length);
35519         desret_int(ret_val);
35520         call_tests++;
35521         des_xmlSchemaTypePtr(n_type, type, 0);
35522         des_xmlSchemaFacetPtr(n_facet, facet, 1);
35523         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2);
35524         des_xmlSchemaValPtr(n_val, val, 3);
35525         des_unsigned_long_ptr(n_length, length, 4);
35526         xmlResetLastError();
35527         if (mem_base != xmlMemBlocks()) {
35528             printf("Leak of %d blocks found in xmlSchemaValidateLengthFacet",
35529                    xmlMemBlocks() - mem_base);
35530             test_ret++;
35531             printf(" %d", n_type);
35532             printf(" %d", n_facet);
35533             printf(" %d", n_value);
35534             printf(" %d", n_val);
35535             printf(" %d", n_length);
35536             printf("\n");
35537         }
35538     }
35539     }
35540     }
35541     }
35542     }
35543     function_tests++;
35544 #endif
35545
35546     return(test_ret);
35547 }
35548
35549
35550 static int
35551 test_xmlSchemaValidateLengthFacetWhtsp(void) {
35552     int test_ret = 0;
35553
35554 #if defined(LIBXML_SCHEMAS_ENABLED)
35555     int mem_base;
35556     int ret_val;
35557     xmlSchemaFacetPtr facet; /* the facet to check */
35558     int n_facet;
35559     xmlSchemaValType valType; /* the built-in type */
35560     int n_valType;
35561     xmlChar * value; /* the lexical repr. of the value to be validated */
35562     int n_value;
35563     xmlSchemaValPtr val; /* the precomputed value */
35564     int n_val;
35565     unsigned long * length; /* the actual length of the value */
35566     int n_length;
35567     xmlSchemaWhitespaceValueType ws; /* the whitespace type of the value */
35568     int n_ws;
35569
35570     for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
35571     for (n_valType = 0;n_valType < gen_nb_xmlSchemaValType;n_valType++) {
35572     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35573     for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
35574     for (n_length = 0;n_length < gen_nb_unsigned_long_ptr;n_length++) {
35575     for (n_ws = 0;n_ws < gen_nb_xmlSchemaWhitespaceValueType;n_ws++) {
35576         mem_base = xmlMemBlocks();
35577         facet = gen_xmlSchemaFacetPtr(n_facet, 0);
35578         valType = gen_xmlSchemaValType(n_valType, 1);
35579         value = gen_const_xmlChar_ptr(n_value, 2);
35580         val = gen_xmlSchemaValPtr(n_val, 3);
35581         length = gen_unsigned_long_ptr(n_length, 4);
35582         ws = gen_xmlSchemaWhitespaceValueType(n_ws, 5);
35583
35584         ret_val = xmlSchemaValidateLengthFacetWhtsp(facet, valType, (const xmlChar *)value, val, length, ws);
35585         desret_int(ret_val);
35586         call_tests++;
35587         des_xmlSchemaFacetPtr(n_facet, facet, 0);
35588         des_xmlSchemaValType(n_valType, valType, 1);
35589         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 2);
35590         des_xmlSchemaValPtr(n_val, val, 3);
35591         des_unsigned_long_ptr(n_length, length, 4);
35592         des_xmlSchemaWhitespaceValueType(n_ws, ws, 5);
35593         xmlResetLastError();
35594         if (mem_base != xmlMemBlocks()) {
35595             printf("Leak of %d blocks found in xmlSchemaValidateLengthFacetWhtsp",
35596                    xmlMemBlocks() - mem_base);
35597             test_ret++;
35598             printf(" %d", n_facet);
35599             printf(" %d", n_valType);
35600             printf(" %d", n_value);
35601             printf(" %d", n_val);
35602             printf(" %d", n_length);
35603             printf(" %d", n_ws);
35604             printf("\n");
35605         }
35606     }
35607     }
35608     }
35609     }
35610     }
35611     }
35612     function_tests++;
35613 #endif
35614
35615     return(test_ret);
35616 }
35617
35618
35619 static int
35620 test_xmlSchemaValidateListSimpleTypeFacet(void) {
35621     int test_ret = 0;
35622
35623 #if defined(LIBXML_SCHEMAS_ENABLED)
35624     int mem_base;
35625     int ret_val;
35626     xmlSchemaFacetPtr facet; /* the facet to check */
35627     int n_facet;
35628     xmlChar * value; /* the lexical repr of the value to validate */
35629     int n_value;
35630     unsigned long actualLen; /* the number of list items */
35631     int n_actualLen;
35632     unsigned long * expectedLen; /* the resulting expected number of list items */
35633     int n_expectedLen;
35634
35635     for (n_facet = 0;n_facet < gen_nb_xmlSchemaFacetPtr;n_facet++) {
35636     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35637     for (n_actualLen = 0;n_actualLen < gen_nb_unsigned_long;n_actualLen++) {
35638     for (n_expectedLen = 0;n_expectedLen < gen_nb_unsigned_long_ptr;n_expectedLen++) {
35639         mem_base = xmlMemBlocks();
35640         facet = gen_xmlSchemaFacetPtr(n_facet, 0);
35641         value = gen_const_xmlChar_ptr(n_value, 1);
35642         actualLen = gen_unsigned_long(n_actualLen, 2);
35643         expectedLen = gen_unsigned_long_ptr(n_expectedLen, 3);
35644
35645         ret_val = xmlSchemaValidateListSimpleTypeFacet(facet, (const xmlChar *)value, actualLen, expectedLen);
35646         desret_int(ret_val);
35647         call_tests++;
35648         des_xmlSchemaFacetPtr(n_facet, facet, 0);
35649         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
35650         des_unsigned_long(n_actualLen, actualLen, 2);
35651         des_unsigned_long_ptr(n_expectedLen, expectedLen, 3);
35652         xmlResetLastError();
35653         if (mem_base != xmlMemBlocks()) {
35654             printf("Leak of %d blocks found in xmlSchemaValidateListSimpleTypeFacet",
35655                    xmlMemBlocks() - mem_base);
35656             test_ret++;
35657             printf(" %d", n_facet);
35658             printf(" %d", n_value);
35659             printf(" %d", n_actualLen);
35660             printf(" %d", n_expectedLen);
35661             printf("\n");
35662         }
35663     }
35664     }
35665     }
35666     }
35667     function_tests++;
35668 #endif
35669
35670     return(test_ret);
35671 }
35672
35673
35674 static int
35675 test_xmlSchemaValidatePredefinedType(void) {
35676     int test_ret = 0;
35677
35678 #if defined(LIBXML_SCHEMAS_ENABLED)
35679     int mem_base;
35680     int ret_val;
35681     xmlSchemaTypePtr type; /* the predefined type */
35682     int n_type;
35683     xmlChar * value; /* the value to check */
35684     int n_value;
35685     xmlSchemaValPtr * val; /* the return computed value */
35686     int n_val;
35687
35688     for (n_type = 0;n_type < gen_nb_xmlSchemaTypePtr;n_type++) {
35689     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35690     for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr_ptr;n_val++) {
35691         mem_base = xmlMemBlocks();
35692         type = gen_xmlSchemaTypePtr(n_type, 0);
35693         value = gen_const_xmlChar_ptr(n_value, 1);
35694         val = gen_xmlSchemaValPtr_ptr(n_val, 2);
35695
35696         ret_val = xmlSchemaValidatePredefinedType(type, (const xmlChar *)value, val);
35697         desret_int(ret_val);
35698         call_tests++;
35699         des_xmlSchemaTypePtr(n_type, type, 0);
35700         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 1);
35701         des_xmlSchemaValPtr_ptr(n_val, val, 2);
35702         xmlResetLastError();
35703         if (mem_base != xmlMemBlocks()) {
35704             printf("Leak of %d blocks found in xmlSchemaValidatePredefinedType",
35705                    xmlMemBlocks() - mem_base);
35706             test_ret++;
35707             printf(" %d", n_type);
35708             printf(" %d", n_value);
35709             printf(" %d", n_val);
35710             printf("\n");
35711         }
35712     }
35713     }
35714     }
35715     function_tests++;
35716 #endif
35717
35718     return(test_ret);
35719 }
35720
35721
35722 static int
35723 test_xmlSchemaValueAppend(void) {
35724     int test_ret = 0;
35725
35726 #if defined(LIBXML_SCHEMAS_ENABLED)
35727     int mem_base;
35728     int ret_val;
35729     xmlSchemaValPtr prev; /* the value */
35730     int n_prev;
35731     xmlSchemaValPtr cur; /* the value to be appended */
35732     int n_cur;
35733
35734     for (n_prev = 0;n_prev < gen_nb_xmlSchemaValPtr;n_prev++) {
35735     for (n_cur = 0;n_cur < gen_nb_xmlSchemaValPtr;n_cur++) {
35736         mem_base = xmlMemBlocks();
35737         prev = gen_xmlSchemaValPtr(n_prev, 0);
35738         cur = gen_xmlSchemaValPtr(n_cur, 1);
35739
35740         ret_val = xmlSchemaValueAppend(prev, cur);
35741         desret_int(ret_val);
35742         call_tests++;
35743         des_xmlSchemaValPtr(n_prev, prev, 0);
35744         des_xmlSchemaValPtr(n_cur, cur, 1);
35745         xmlResetLastError();
35746         if (mem_base != xmlMemBlocks()) {
35747             printf("Leak of %d blocks found in xmlSchemaValueAppend",
35748                    xmlMemBlocks() - mem_base);
35749             test_ret++;
35750             printf(" %d", n_prev);
35751             printf(" %d", n_cur);
35752             printf("\n");
35753         }
35754     }
35755     }
35756     function_tests++;
35757 #endif
35758
35759     return(test_ret);
35760 }
35761
35762
35763 static int
35764 test_xmlSchemaValueGetAsBoolean(void) {
35765     int test_ret = 0;
35766
35767 #if defined(LIBXML_SCHEMAS_ENABLED)
35768     int mem_base;
35769     int ret_val;
35770     xmlSchemaValPtr val; /* the value */
35771     int n_val;
35772
35773     for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
35774         mem_base = xmlMemBlocks();
35775         val = gen_xmlSchemaValPtr(n_val, 0);
35776
35777         ret_val = xmlSchemaValueGetAsBoolean(val);
35778         desret_int(ret_val);
35779         call_tests++;
35780         des_xmlSchemaValPtr(n_val, val, 0);
35781         xmlResetLastError();
35782         if (mem_base != xmlMemBlocks()) {
35783             printf("Leak of %d blocks found in xmlSchemaValueGetAsBoolean",
35784                    xmlMemBlocks() - mem_base);
35785             test_ret++;
35786             printf(" %d", n_val);
35787             printf("\n");
35788         }
35789     }
35790     function_tests++;
35791 #endif
35792
35793     return(test_ret);
35794 }
35795
35796
35797 static int
35798 test_xmlSchemaValueGetAsString(void) {
35799     int test_ret = 0;
35800
35801 #if defined(LIBXML_SCHEMAS_ENABLED)
35802     int mem_base;
35803     const xmlChar * ret_val;
35804     xmlSchemaValPtr val; /* the value */
35805     int n_val;
35806
35807     for (n_val = 0;n_val < gen_nb_xmlSchemaValPtr;n_val++) {
35808         mem_base = xmlMemBlocks();
35809         val = gen_xmlSchemaValPtr(n_val, 0);
35810
35811         ret_val = xmlSchemaValueGetAsString(val);
35812         desret_const_xmlChar_ptr(ret_val);
35813         call_tests++;
35814         des_xmlSchemaValPtr(n_val, val, 0);
35815         xmlResetLastError();
35816         if (mem_base != xmlMemBlocks()) {
35817             printf("Leak of %d blocks found in xmlSchemaValueGetAsString",
35818                    xmlMemBlocks() - mem_base);
35819             test_ret++;
35820             printf(" %d", n_val);
35821             printf("\n");
35822         }
35823     }
35824     function_tests++;
35825 #endif
35826
35827     return(test_ret);
35828 }
35829
35830
35831 static int
35832 test_xmlSchemaValueGetNext(void) {
35833     int test_ret = 0;
35834
35835
35836     /* missing type support */
35837     return(test_ret);
35838 }
35839
35840
35841 static int
35842 test_xmlSchemaWhiteSpaceReplace(void) {
35843     int test_ret = 0;
35844
35845 #if defined(LIBXML_SCHEMAS_ENABLED)
35846     int mem_base;
35847     xmlChar * ret_val;
35848     xmlChar * value; /* a value */
35849     int n_value;
35850
35851     for (n_value = 0;n_value < gen_nb_const_xmlChar_ptr;n_value++) {
35852         mem_base = xmlMemBlocks();
35853         value = gen_const_xmlChar_ptr(n_value, 0);
35854
35855         ret_val = xmlSchemaWhiteSpaceReplace((const xmlChar *)value);
35856         desret_xmlChar_ptr(ret_val);
35857         call_tests++;
35858         des_const_xmlChar_ptr(n_value, (const xmlChar *)value, 0);
35859         xmlResetLastError();
35860         if (mem_base != xmlMemBlocks()) {
35861             printf("Leak of %d blocks found in xmlSchemaWhiteSpaceReplace",
35862                    xmlMemBlocks() - mem_base);
35863             test_ret++;
35864             printf(" %d", n_value);
35865             printf("\n");
35866         }
35867     }
35868     function_tests++;
35869 #endif
35870
35871     return(test_ret);
35872 }
35873
35874 static int
35875 test_xmlschemastypes(void) {
35876     int test_ret = 0;
35877
35878     if (quiet == 0) printf("Testing xmlschemastypes : 26 of 34 functions ...\n");
35879     test_ret += test_xmlSchemaCheckFacet();
35880     test_ret += test_xmlSchemaCleanupTypes();
35881     test_ret += test_xmlSchemaCollapseString();
35882     test_ret += test_xmlSchemaCompareValues();
35883     test_ret += test_xmlSchemaCompareValuesWhtsp();
35884     test_ret += test_xmlSchemaCopyValue();
35885     test_ret += test_xmlSchemaGetBuiltInListSimpleTypeItemType();
35886     test_ret += test_xmlSchemaGetBuiltInType();
35887     test_ret += test_xmlSchemaGetCanonValue();
35888     test_ret += test_xmlSchemaGetCanonValueWhtsp();
35889     test_ret += test_xmlSchemaGetFacetValueAsULong();
35890     test_ret += test_xmlSchemaGetPredefinedType();
35891     test_ret += test_xmlSchemaGetValType();
35892     test_ret += test_xmlSchemaInitTypes();
35893     test_ret += test_xmlSchemaIsBuiltInTypeFacet();
35894     test_ret += test_xmlSchemaNewFacet();
35895     test_ret += test_xmlSchemaNewNOTATIONValue();
35896     test_ret += test_xmlSchemaNewQNameValue();
35897     test_ret += test_xmlSchemaNewStringValue();
35898     test_ret += test_xmlSchemaValPredefTypeNode();
35899     test_ret += test_xmlSchemaValPredefTypeNodeNoNorm();
35900     test_ret += test_xmlSchemaValidateFacet();
35901     test_ret += test_xmlSchemaValidateFacetWhtsp();
35902     test_ret += test_xmlSchemaValidateLengthFacet();
35903     test_ret += test_xmlSchemaValidateLengthFacetWhtsp();
35904     test_ret += test_xmlSchemaValidateListSimpleTypeFacet();
35905     test_ret += test_xmlSchemaValidatePredefinedType();
35906     test_ret += test_xmlSchemaValueAppend();
35907     test_ret += test_xmlSchemaValueGetAsBoolean();
35908     test_ret += test_xmlSchemaValueGetAsString();
35909     test_ret += test_xmlSchemaValueGetNext();
35910     test_ret += test_xmlSchemaWhiteSpaceReplace();
35911
35912     if (test_ret != 0)
35913         printf("Module xmlschemastypes: %d errors\n", test_ret);
35914     return(test_ret);
35915 }
35916
35917 static int
35918 test_xmlCharStrdup(void) {
35919     int test_ret = 0;
35920
35921     int mem_base;
35922     xmlChar * ret_val;
35923     char * cur; /* the input char * */
35924     int n_cur;
35925
35926     for (n_cur = 0;n_cur < gen_nb_const_char_ptr;n_cur++) {
35927         mem_base = xmlMemBlocks();
35928         cur = gen_const_char_ptr(n_cur, 0);
35929
35930         ret_val = xmlCharStrdup((const char *)cur);
35931         desret_xmlChar_ptr(ret_val);
35932         call_tests++;
35933         des_const_char_ptr(n_cur, (const char *)cur, 0);
35934         xmlResetLastError();
35935         if (mem_base != xmlMemBlocks()) {
35936             printf("Leak of %d blocks found in xmlCharStrdup",
35937                    xmlMemBlocks() - mem_base);
35938             test_ret++;
35939             printf(" %d", n_cur);
35940             printf("\n");
35941         }
35942     }
35943     function_tests++;
35944
35945     return(test_ret);
35946 }
35947
35948
35949 static int
35950 test_xmlCharStrndup(void) {
35951     int test_ret = 0;
35952
35953     int mem_base;
35954     xmlChar * ret_val;
35955     char * cur; /* the input char * */
35956     int n_cur;
35957     int len; /* the len of @cur */
35958     int n_len;
35959
35960     for (n_cur = 0;n_cur < gen_nb_const_char_ptr;n_cur++) {
35961     for (n_len = 0;n_len < gen_nb_int;n_len++) {
35962         mem_base = xmlMemBlocks();
35963         cur = gen_const_char_ptr(n_cur, 0);
35964         len = gen_int(n_len, 1);
35965
35966         ret_val = xmlCharStrndup((const char *)cur, len);
35967         desret_xmlChar_ptr(ret_val);
35968         call_tests++;
35969         des_const_char_ptr(n_cur, (const char *)cur, 0);
35970         des_int(n_len, len, 1);
35971         xmlResetLastError();
35972         if (mem_base != xmlMemBlocks()) {
35973             printf("Leak of %d blocks found in xmlCharStrndup",
35974                    xmlMemBlocks() - mem_base);
35975             test_ret++;
35976             printf(" %d", n_cur);
35977             printf(" %d", n_len);
35978             printf("\n");
35979         }
35980     }
35981     }
35982     function_tests++;
35983
35984     return(test_ret);
35985 }
35986
35987
35988 static int
35989 test_xmlCheckUTF8(void) {
35990     int test_ret = 0;
35991
35992     int mem_base;
35993     int ret_val;
35994     unsigned char * utf; /* Pointer to putative UTF-8 encoded string. */
35995     int n_utf;
35996
35997     for (n_utf = 0;n_utf < gen_nb_const_unsigned_char_ptr;n_utf++) {
35998         mem_base = xmlMemBlocks();
35999         utf = gen_const_unsigned_char_ptr(n_utf, 0);
36000
36001         ret_val = xmlCheckUTF8((const unsigned char *)utf);
36002         desret_int(ret_val);
36003         call_tests++;
36004         des_const_unsigned_char_ptr(n_utf, (const unsigned char *)utf, 0);
36005         xmlResetLastError();
36006         if (mem_base != xmlMemBlocks()) {
36007             printf("Leak of %d blocks found in xmlCheckUTF8",
36008                    xmlMemBlocks() - mem_base);
36009             test_ret++;
36010             printf(" %d", n_utf);
36011             printf("\n");
36012         }
36013     }
36014     function_tests++;
36015
36016     return(test_ret);
36017 }
36018
36019
36020 static int
36021 test_xmlGetUTF8Char(void) {
36022     int test_ret = 0;
36023
36024     int mem_base;
36025     int ret_val;
36026     unsigned char * utf; /* a sequence of UTF-8 encoded bytes */
36027     int n_utf;
36028     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. */
36029     int n_len;
36030
36031     for (n_utf = 0;n_utf < gen_nb_const_unsigned_char_ptr;n_utf++) {
36032     for (n_len = 0;n_len < gen_nb_int_ptr;n_len++) {
36033         mem_base = xmlMemBlocks();
36034         utf = gen_const_unsigned_char_ptr(n_utf, 0);
36035         len = gen_int_ptr(n_len, 1);
36036
36037         ret_val = xmlGetUTF8Char((const unsigned char *)utf, len);
36038         desret_int(ret_val);
36039         call_tests++;
36040         des_const_unsigned_char_ptr(n_utf, (const unsigned char *)utf, 0);
36041         des_int_ptr(n_len, len, 1);
36042         xmlResetLastError();
36043         if (mem_base != xmlMemBlocks()) {
36044             printf("Leak of %d blocks found in xmlGetUTF8Char",
36045                    xmlMemBlocks() - mem_base);
36046             test_ret++;
36047             printf(" %d", n_utf);
36048             printf(" %d", n_len);
36049             printf("\n");
36050         }
36051     }
36052     }
36053     function_tests++;
36054
36055     return(test_ret);
36056 }
36057
36058
36059 static int
36060 test_xmlStrEqual(void) {
36061     int test_ret = 0;
36062
36063     int mem_base;
36064     int ret_val;
36065     xmlChar * str1; /* the first xmlChar * */
36066     int n_str1;
36067     xmlChar * str2; /* the second xmlChar * */
36068     int n_str2;
36069
36070     for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
36071     for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
36072         mem_base = xmlMemBlocks();
36073         str1 = gen_const_xmlChar_ptr(n_str1, 0);
36074         str2 = gen_const_xmlChar_ptr(n_str2, 1);
36075
36076         ret_val = xmlStrEqual((const xmlChar *)str1, (const xmlChar *)str2);
36077         desret_int(ret_val);
36078         call_tests++;
36079         des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0);
36080         des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1);
36081         xmlResetLastError();
36082         if (mem_base != xmlMemBlocks()) {
36083             printf("Leak of %d blocks found in xmlStrEqual",
36084                    xmlMemBlocks() - mem_base);
36085             test_ret++;
36086             printf(" %d", n_str1);
36087             printf(" %d", n_str2);
36088             printf("\n");
36089         }
36090     }
36091     }
36092     function_tests++;
36093
36094     return(test_ret);
36095 }
36096
36097
36098 static int
36099 test_xmlStrPrintf(void) {
36100     int test_ret = 0;
36101
36102
36103     /* missing type support */
36104     return(test_ret);
36105 }
36106
36107
36108 static int
36109 test_xmlStrQEqual(void) {
36110     int test_ret = 0;
36111
36112     int mem_base;
36113     int ret_val;
36114     xmlChar * pref; /* the prefix of the QName */
36115     int n_pref;
36116     xmlChar * name; /* the localname of the QName */
36117     int n_name;
36118     xmlChar * str; /* the second xmlChar * */
36119     int n_str;
36120
36121     for (n_pref = 0;n_pref < gen_nb_const_xmlChar_ptr;n_pref++) {
36122     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
36123     for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
36124         mem_base = xmlMemBlocks();
36125         pref = gen_const_xmlChar_ptr(n_pref, 0);
36126         name = gen_const_xmlChar_ptr(n_name, 1);
36127         str = gen_const_xmlChar_ptr(n_str, 2);
36128
36129         ret_val = xmlStrQEqual((const xmlChar *)pref, (const xmlChar *)name, (const xmlChar *)str);
36130         desret_int(ret_val);
36131         call_tests++;
36132         des_const_xmlChar_ptr(n_pref, (const xmlChar *)pref, 0);
36133         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
36134         des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 2);
36135         xmlResetLastError();
36136         if (mem_base != xmlMemBlocks()) {
36137             printf("Leak of %d blocks found in xmlStrQEqual",
36138                    xmlMemBlocks() - mem_base);
36139             test_ret++;
36140             printf(" %d", n_pref);
36141             printf(" %d", n_name);
36142             printf(" %d", n_str);
36143             printf("\n");
36144         }
36145     }
36146     }
36147     }
36148     function_tests++;
36149
36150     return(test_ret);
36151 }
36152
36153
36154 static int
36155 test_xmlStrVPrintf(void) {
36156     int test_ret = 0;
36157
36158
36159     /* missing type support */
36160     return(test_ret);
36161 }
36162
36163
36164 static int
36165 test_xmlStrcasecmp(void) {
36166     int test_ret = 0;
36167
36168     int mem_base;
36169     int ret_val;
36170     xmlChar * str1; /* the first xmlChar * */
36171     int n_str1;
36172     xmlChar * str2; /* the second xmlChar * */
36173     int n_str2;
36174
36175     for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
36176     for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
36177         mem_base = xmlMemBlocks();
36178         str1 = gen_const_xmlChar_ptr(n_str1, 0);
36179         str2 = gen_const_xmlChar_ptr(n_str2, 1);
36180
36181         ret_val = xmlStrcasecmp((const xmlChar *)str1, (const xmlChar *)str2);
36182         desret_int(ret_val);
36183         call_tests++;
36184         des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0);
36185         des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1);
36186         xmlResetLastError();
36187         if (mem_base != xmlMemBlocks()) {
36188             printf("Leak of %d blocks found in xmlStrcasecmp",
36189                    xmlMemBlocks() - mem_base);
36190             test_ret++;
36191             printf(" %d", n_str1);
36192             printf(" %d", n_str2);
36193             printf("\n");
36194         }
36195     }
36196     }
36197     function_tests++;
36198
36199     return(test_ret);
36200 }
36201
36202
36203 static int
36204 test_xmlStrcasestr(void) {
36205     int test_ret = 0;
36206
36207     int mem_base;
36208     const xmlChar * ret_val;
36209     xmlChar * str; /* the xmlChar * array (haystack) */
36210     int n_str;
36211     xmlChar * val; /* the xmlChar to search (needle) */
36212     int n_val;
36213
36214     for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
36215     for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) {
36216         mem_base = xmlMemBlocks();
36217         str = gen_const_xmlChar_ptr(n_str, 0);
36218         val = gen_const_xmlChar_ptr(n_val, 1);
36219
36220         ret_val = xmlStrcasestr((const xmlChar *)str, (const xmlChar *)val);
36221         desret_const_xmlChar_ptr(ret_val);
36222         call_tests++;
36223         des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
36224         des_const_xmlChar_ptr(n_val, (const xmlChar *)val, 1);
36225         xmlResetLastError();
36226         if (mem_base != xmlMemBlocks()) {
36227             printf("Leak of %d blocks found in xmlStrcasestr",
36228                    xmlMemBlocks() - mem_base);
36229             test_ret++;
36230             printf(" %d", n_str);
36231             printf(" %d", n_val);
36232             printf("\n");
36233         }
36234     }
36235     }
36236     function_tests++;
36237
36238     return(test_ret);
36239 }
36240
36241
36242 static int
36243 test_xmlStrchr(void) {
36244     int test_ret = 0;
36245
36246     int mem_base;
36247     const xmlChar * ret_val;
36248     xmlChar * str; /* the xmlChar * array */
36249     int n_str;
36250     xmlChar val; /* the xmlChar to search */
36251     int n_val;
36252
36253     for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
36254     for (n_val = 0;n_val < gen_nb_xmlChar;n_val++) {
36255         mem_base = xmlMemBlocks();
36256         str = gen_const_xmlChar_ptr(n_str, 0);
36257         val = gen_xmlChar(n_val, 1);
36258
36259         ret_val = xmlStrchr((const xmlChar *)str, val);
36260         desret_const_xmlChar_ptr(ret_val);
36261         call_tests++;
36262         des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
36263         des_xmlChar(n_val, val, 1);
36264         xmlResetLastError();
36265         if (mem_base != xmlMemBlocks()) {
36266             printf("Leak of %d blocks found in xmlStrchr",
36267                    xmlMemBlocks() - mem_base);
36268             test_ret++;
36269             printf(" %d", n_str);
36270             printf(" %d", n_val);
36271             printf("\n");
36272         }
36273     }
36274     }
36275     function_tests++;
36276
36277     return(test_ret);
36278 }
36279
36280
36281 static int
36282 test_xmlStrcmp(void) {
36283     int test_ret = 0;
36284
36285     int mem_base;
36286     int ret_val;
36287     xmlChar * str1; /* the first xmlChar * */
36288     int n_str1;
36289     xmlChar * str2; /* the second xmlChar * */
36290     int n_str2;
36291
36292     for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
36293     for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
36294         mem_base = xmlMemBlocks();
36295         str1 = gen_const_xmlChar_ptr(n_str1, 0);
36296         str2 = gen_const_xmlChar_ptr(n_str2, 1);
36297
36298         ret_val = xmlStrcmp((const xmlChar *)str1, (const xmlChar *)str2);
36299         desret_int(ret_val);
36300         call_tests++;
36301         des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0);
36302         des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1);
36303         xmlResetLastError();
36304         if (mem_base != xmlMemBlocks()) {
36305             printf("Leak of %d blocks found in xmlStrcmp",
36306                    xmlMemBlocks() - mem_base);
36307             test_ret++;
36308             printf(" %d", n_str1);
36309             printf(" %d", n_str2);
36310             printf("\n");
36311         }
36312     }
36313     }
36314     function_tests++;
36315
36316     return(test_ret);
36317 }
36318
36319
36320 static int
36321 test_xmlStrdup(void) {
36322     int test_ret = 0;
36323
36324     int mem_base;
36325     xmlChar * ret_val;
36326     xmlChar * cur; /* the input xmlChar * */
36327     int n_cur;
36328
36329     for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
36330         mem_base = xmlMemBlocks();
36331         cur = gen_const_xmlChar_ptr(n_cur, 0);
36332
36333         ret_val = xmlStrdup((const xmlChar *)cur);
36334         desret_xmlChar_ptr(ret_val);
36335         call_tests++;
36336         des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
36337         xmlResetLastError();
36338         if (mem_base != xmlMemBlocks()) {
36339             printf("Leak of %d blocks found in xmlStrdup",
36340                    xmlMemBlocks() - mem_base);
36341             test_ret++;
36342             printf(" %d", n_cur);
36343             printf("\n");
36344         }
36345     }
36346     function_tests++;
36347
36348     return(test_ret);
36349 }
36350
36351
36352 static int
36353 test_xmlStrlen(void) {
36354     int test_ret = 0;
36355
36356     int mem_base;
36357     int ret_val;
36358     xmlChar * str; /* the xmlChar * array */
36359     int n_str;
36360
36361     for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
36362         mem_base = xmlMemBlocks();
36363         str = gen_const_xmlChar_ptr(n_str, 0);
36364
36365         ret_val = xmlStrlen((const xmlChar *)str);
36366         desret_int(ret_val);
36367         call_tests++;
36368         des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
36369         xmlResetLastError();
36370         if (mem_base != xmlMemBlocks()) {
36371             printf("Leak of %d blocks found in xmlStrlen",
36372                    xmlMemBlocks() - mem_base);
36373             test_ret++;
36374             printf(" %d", n_str);
36375             printf("\n");
36376         }
36377     }
36378     function_tests++;
36379
36380     return(test_ret);
36381 }
36382
36383
36384 static int
36385 test_xmlStrncasecmp(void) {
36386     int test_ret = 0;
36387
36388     int mem_base;
36389     int ret_val;
36390     xmlChar * str1; /* the first xmlChar * */
36391     int n_str1;
36392     xmlChar * str2; /* the second xmlChar * */
36393     int n_str2;
36394     int len; /* the max comparison length */
36395     int n_len;
36396
36397     for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
36398     for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
36399     for (n_len = 0;n_len < gen_nb_int;n_len++) {
36400         mem_base = xmlMemBlocks();
36401         str1 = gen_const_xmlChar_ptr(n_str1, 0);
36402         str2 = gen_const_xmlChar_ptr(n_str2, 1);
36403         len = gen_int(n_len, 2);
36404
36405         ret_val = xmlStrncasecmp((const xmlChar *)str1, (const xmlChar *)str2, len);
36406         desret_int(ret_val);
36407         call_tests++;
36408         des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0);
36409         des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1);
36410         des_int(n_len, len, 2);
36411         xmlResetLastError();
36412         if (mem_base != xmlMemBlocks()) {
36413             printf("Leak of %d blocks found in xmlStrncasecmp",
36414                    xmlMemBlocks() - mem_base);
36415             test_ret++;
36416             printf(" %d", n_str1);
36417             printf(" %d", n_str2);
36418             printf(" %d", n_len);
36419             printf("\n");
36420         }
36421     }
36422     }
36423     }
36424     function_tests++;
36425
36426     return(test_ret);
36427 }
36428
36429
36430 static int
36431 test_xmlStrncatNew(void) {
36432     int test_ret = 0;
36433
36434     int mem_base;
36435     xmlChar * ret_val;
36436     xmlChar * str1; /* first xmlChar string */
36437     int n_str1;
36438     xmlChar * str2; /* second xmlChar string */
36439     int n_str2;
36440     int len; /* the len of @str2 or < 0 */
36441     int n_len;
36442
36443     for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
36444     for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
36445     for (n_len = 0;n_len < gen_nb_int;n_len++) {
36446         mem_base = xmlMemBlocks();
36447         str1 = gen_const_xmlChar_ptr(n_str1, 0);
36448         str2 = gen_const_xmlChar_ptr(n_str2, 1);
36449         len = gen_int(n_len, 2);
36450
36451         ret_val = xmlStrncatNew((const xmlChar *)str1, (const xmlChar *)str2, len);
36452         desret_xmlChar_ptr(ret_val);
36453         call_tests++;
36454         des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0);
36455         des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1);
36456         des_int(n_len, len, 2);
36457         xmlResetLastError();
36458         if (mem_base != xmlMemBlocks()) {
36459             printf("Leak of %d blocks found in xmlStrncatNew",
36460                    xmlMemBlocks() - mem_base);
36461             test_ret++;
36462             printf(" %d", n_str1);
36463             printf(" %d", n_str2);
36464             printf(" %d", n_len);
36465             printf("\n");
36466         }
36467     }
36468     }
36469     }
36470     function_tests++;
36471
36472     return(test_ret);
36473 }
36474
36475
36476 static int
36477 test_xmlStrncmp(void) {
36478     int test_ret = 0;
36479
36480     int mem_base;
36481     int ret_val;
36482     xmlChar * str1; /* the first xmlChar * */
36483     int n_str1;
36484     xmlChar * str2; /* the second xmlChar * */
36485     int n_str2;
36486     int len; /* the max comparison length */
36487     int n_len;
36488
36489     for (n_str1 = 0;n_str1 < gen_nb_const_xmlChar_ptr;n_str1++) {
36490     for (n_str2 = 0;n_str2 < gen_nb_const_xmlChar_ptr;n_str2++) {
36491     for (n_len = 0;n_len < gen_nb_int;n_len++) {
36492         mem_base = xmlMemBlocks();
36493         str1 = gen_const_xmlChar_ptr(n_str1, 0);
36494         str2 = gen_const_xmlChar_ptr(n_str2, 1);
36495         len = gen_int(n_len, 2);
36496
36497         ret_val = xmlStrncmp((const xmlChar *)str1, (const xmlChar *)str2, len);
36498         desret_int(ret_val);
36499         call_tests++;
36500         des_const_xmlChar_ptr(n_str1, (const xmlChar *)str1, 0);
36501         des_const_xmlChar_ptr(n_str2, (const xmlChar *)str2, 1);
36502         des_int(n_len, len, 2);
36503         xmlResetLastError();
36504         if (mem_base != xmlMemBlocks()) {
36505             printf("Leak of %d blocks found in xmlStrncmp",
36506                    xmlMemBlocks() - mem_base);
36507             test_ret++;
36508             printf(" %d", n_str1);
36509             printf(" %d", n_str2);
36510             printf(" %d", n_len);
36511             printf("\n");
36512         }
36513     }
36514     }
36515     }
36516     function_tests++;
36517
36518     return(test_ret);
36519 }
36520
36521
36522 static int
36523 test_xmlStrndup(void) {
36524     int test_ret = 0;
36525
36526     int mem_base;
36527     xmlChar * ret_val;
36528     xmlChar * cur; /* the input xmlChar * */
36529     int n_cur;
36530     int len; /* the len of @cur */
36531     int n_len;
36532
36533     for (n_cur = 0;n_cur < gen_nb_const_xmlChar_ptr;n_cur++) {
36534     for (n_len = 0;n_len < gen_nb_int;n_len++) {
36535         mem_base = xmlMemBlocks();
36536         cur = gen_const_xmlChar_ptr(n_cur, 0);
36537         len = gen_int(n_len, 1);
36538
36539         ret_val = xmlStrndup((const xmlChar *)cur, len);
36540         desret_xmlChar_ptr(ret_val);
36541         call_tests++;
36542         des_const_xmlChar_ptr(n_cur, (const xmlChar *)cur, 0);
36543         des_int(n_len, len, 1);
36544         xmlResetLastError();
36545         if (mem_base != xmlMemBlocks()) {
36546             printf("Leak of %d blocks found in xmlStrndup",
36547                    xmlMemBlocks() - mem_base);
36548             test_ret++;
36549             printf(" %d", n_cur);
36550             printf(" %d", n_len);
36551             printf("\n");
36552         }
36553     }
36554     }
36555     function_tests++;
36556
36557     return(test_ret);
36558 }
36559
36560
36561 static int
36562 test_xmlStrstr(void) {
36563     int test_ret = 0;
36564
36565     int mem_base;
36566     const xmlChar * ret_val;
36567     xmlChar * str; /* the xmlChar * array (haystack) */
36568     int n_str;
36569     xmlChar * val; /* the xmlChar to search (needle) */
36570     int n_val;
36571
36572     for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
36573     for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) {
36574         mem_base = xmlMemBlocks();
36575         str = gen_const_xmlChar_ptr(n_str, 0);
36576         val = gen_const_xmlChar_ptr(n_val, 1);
36577
36578         ret_val = xmlStrstr((const xmlChar *)str, (const xmlChar *)val);
36579         desret_const_xmlChar_ptr(ret_val);
36580         call_tests++;
36581         des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
36582         des_const_xmlChar_ptr(n_val, (const xmlChar *)val, 1);
36583         xmlResetLastError();
36584         if (mem_base != xmlMemBlocks()) {
36585             printf("Leak of %d blocks found in xmlStrstr",
36586                    xmlMemBlocks() - mem_base);
36587             test_ret++;
36588             printf(" %d", n_str);
36589             printf(" %d", n_val);
36590             printf("\n");
36591         }
36592     }
36593     }
36594     function_tests++;
36595
36596     return(test_ret);
36597 }
36598
36599
36600 static int
36601 test_xmlStrsub(void) {
36602     int test_ret = 0;
36603
36604     int mem_base;
36605     xmlChar * ret_val;
36606     xmlChar * str; /* the xmlChar * array (haystack) */
36607     int n_str;
36608     int start; /* the index of the first char (zero based) */
36609     int n_start;
36610     int len; /* the length of the substring */
36611     int n_len;
36612
36613     for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
36614     for (n_start = 0;n_start < gen_nb_int;n_start++) {
36615     for (n_len = 0;n_len < gen_nb_int;n_len++) {
36616         mem_base = xmlMemBlocks();
36617         str = gen_const_xmlChar_ptr(n_str, 0);
36618         start = gen_int(n_start, 1);
36619         len = gen_int(n_len, 2);
36620
36621         ret_val = xmlStrsub((const xmlChar *)str, start, len);
36622         desret_xmlChar_ptr(ret_val);
36623         call_tests++;
36624         des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
36625         des_int(n_start, start, 1);
36626         des_int(n_len, len, 2);
36627         xmlResetLastError();
36628         if (mem_base != xmlMemBlocks()) {
36629             printf("Leak of %d blocks found in xmlStrsub",
36630                    xmlMemBlocks() - mem_base);
36631             test_ret++;
36632             printf(" %d", n_str);
36633             printf(" %d", n_start);
36634             printf(" %d", n_len);
36635             printf("\n");
36636         }
36637     }
36638     }
36639     }
36640     function_tests++;
36641
36642     return(test_ret);
36643 }
36644
36645
36646 static int
36647 test_xmlUTF8Charcmp(void) {
36648     int test_ret = 0;
36649
36650     int mem_base;
36651     int ret_val;
36652     xmlChar * utf1; /* pointer to first UTF8 char */
36653     int n_utf1;
36654     xmlChar * utf2; /* pointer to second UTF8 char */
36655     int n_utf2;
36656
36657     for (n_utf1 = 0;n_utf1 < gen_nb_const_xmlChar_ptr;n_utf1++) {
36658     for (n_utf2 = 0;n_utf2 < gen_nb_const_xmlChar_ptr;n_utf2++) {
36659         mem_base = xmlMemBlocks();
36660         utf1 = gen_const_xmlChar_ptr(n_utf1, 0);
36661         utf2 = gen_const_xmlChar_ptr(n_utf2, 1);
36662
36663         ret_val = xmlUTF8Charcmp((const xmlChar *)utf1, (const xmlChar *)utf2);
36664         desret_int(ret_val);
36665         call_tests++;
36666         des_const_xmlChar_ptr(n_utf1, (const xmlChar *)utf1, 0);
36667         des_const_xmlChar_ptr(n_utf2, (const xmlChar *)utf2, 1);
36668         xmlResetLastError();
36669         if (mem_base != xmlMemBlocks()) {
36670             printf("Leak of %d blocks found in xmlUTF8Charcmp",
36671                    xmlMemBlocks() - mem_base);
36672             test_ret++;
36673             printf(" %d", n_utf1);
36674             printf(" %d", n_utf2);
36675             printf("\n");
36676         }
36677     }
36678     }
36679     function_tests++;
36680
36681     return(test_ret);
36682 }
36683
36684
36685 static int
36686 test_xmlUTF8Size(void) {
36687     int test_ret = 0;
36688
36689     int mem_base;
36690     int ret_val;
36691     xmlChar * utf; /* pointer to the UTF8 character */
36692     int n_utf;
36693
36694     for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
36695         mem_base = xmlMemBlocks();
36696         utf = gen_const_xmlChar_ptr(n_utf, 0);
36697
36698         ret_val = xmlUTF8Size((const xmlChar *)utf);
36699         desret_int(ret_val);
36700         call_tests++;
36701         des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
36702         xmlResetLastError();
36703         if (mem_base != xmlMemBlocks()) {
36704             printf("Leak of %d blocks found in xmlUTF8Size",
36705                    xmlMemBlocks() - mem_base);
36706             test_ret++;
36707             printf(" %d", n_utf);
36708             printf("\n");
36709         }
36710     }
36711     function_tests++;
36712
36713     return(test_ret);
36714 }
36715
36716
36717 static int
36718 test_xmlUTF8Strlen(void) {
36719     int test_ret = 0;
36720
36721     int mem_base;
36722     int ret_val;
36723     xmlChar * utf; /* a sequence of UTF-8 encoded bytes */
36724     int n_utf;
36725
36726     for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
36727         mem_base = xmlMemBlocks();
36728         utf = gen_const_xmlChar_ptr(n_utf, 0);
36729
36730         ret_val = xmlUTF8Strlen((const xmlChar *)utf);
36731         desret_int(ret_val);
36732         call_tests++;
36733         des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
36734         xmlResetLastError();
36735         if (mem_base != xmlMemBlocks()) {
36736             printf("Leak of %d blocks found in xmlUTF8Strlen",
36737                    xmlMemBlocks() - mem_base);
36738             test_ret++;
36739             printf(" %d", n_utf);
36740             printf("\n");
36741         }
36742     }
36743     function_tests++;
36744
36745     return(test_ret);
36746 }
36747
36748
36749 static int
36750 test_xmlUTF8Strloc(void) {
36751     int test_ret = 0;
36752
36753     int mem_base;
36754     int ret_val;
36755     xmlChar * utf; /* the input UTF8 * */
36756     int n_utf;
36757     xmlChar * utfchar; /* the UTF8 character to be found */
36758     int n_utfchar;
36759
36760     for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
36761     for (n_utfchar = 0;n_utfchar < gen_nb_const_xmlChar_ptr;n_utfchar++) {
36762         mem_base = xmlMemBlocks();
36763         utf = gen_const_xmlChar_ptr(n_utf, 0);
36764         utfchar = gen_const_xmlChar_ptr(n_utfchar, 1);
36765
36766         ret_val = xmlUTF8Strloc((const xmlChar *)utf, (const xmlChar *)utfchar);
36767         desret_int(ret_val);
36768         call_tests++;
36769         des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
36770         des_const_xmlChar_ptr(n_utfchar, (const xmlChar *)utfchar, 1);
36771         xmlResetLastError();
36772         if (mem_base != xmlMemBlocks()) {
36773             printf("Leak of %d blocks found in xmlUTF8Strloc",
36774                    xmlMemBlocks() - mem_base);
36775             test_ret++;
36776             printf(" %d", n_utf);
36777             printf(" %d", n_utfchar);
36778             printf("\n");
36779         }
36780     }
36781     }
36782     function_tests++;
36783
36784     return(test_ret);
36785 }
36786
36787
36788 static int
36789 test_xmlUTF8Strndup(void) {
36790     int test_ret = 0;
36791
36792     int mem_base;
36793     xmlChar * ret_val;
36794     xmlChar * utf; /* the input UTF8 * */
36795     int n_utf;
36796     int len; /* the len of @utf (in chars) */
36797     int n_len;
36798
36799     for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
36800     for (n_len = 0;n_len < gen_nb_int;n_len++) {
36801         mem_base = xmlMemBlocks();
36802         utf = gen_const_xmlChar_ptr(n_utf, 0);
36803         len = gen_int(n_len, 1);
36804
36805         ret_val = xmlUTF8Strndup((const xmlChar *)utf, len);
36806         desret_xmlChar_ptr(ret_val);
36807         call_tests++;
36808         des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
36809         des_int(n_len, len, 1);
36810         xmlResetLastError();
36811         if (mem_base != xmlMemBlocks()) {
36812             printf("Leak of %d blocks found in xmlUTF8Strndup",
36813                    xmlMemBlocks() - mem_base);
36814             test_ret++;
36815             printf(" %d", n_utf);
36816             printf(" %d", n_len);
36817             printf("\n");
36818         }
36819     }
36820     }
36821     function_tests++;
36822
36823     return(test_ret);
36824 }
36825
36826
36827 static int
36828 test_xmlUTF8Strpos(void) {
36829     int test_ret = 0;
36830
36831     int mem_base;
36832     const xmlChar * ret_val;
36833     xmlChar * utf; /* the input UTF8 * */
36834     int n_utf;
36835     int pos; /* the position of the desired UTF8 char (in chars) */
36836     int n_pos;
36837
36838     for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
36839     for (n_pos = 0;n_pos < gen_nb_int;n_pos++) {
36840         mem_base = xmlMemBlocks();
36841         utf = gen_const_xmlChar_ptr(n_utf, 0);
36842         pos = gen_int(n_pos, 1);
36843
36844         ret_val = xmlUTF8Strpos((const xmlChar *)utf, pos);
36845         desret_const_xmlChar_ptr(ret_val);
36846         call_tests++;
36847         des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
36848         des_int(n_pos, pos, 1);
36849         xmlResetLastError();
36850         if (mem_base != xmlMemBlocks()) {
36851             printf("Leak of %d blocks found in xmlUTF8Strpos",
36852                    xmlMemBlocks() - mem_base);
36853             test_ret++;
36854             printf(" %d", n_utf);
36855             printf(" %d", n_pos);
36856             printf("\n");
36857         }
36858     }
36859     }
36860     function_tests++;
36861
36862     return(test_ret);
36863 }
36864
36865
36866 static int
36867 test_xmlUTF8Strsize(void) {
36868     int test_ret = 0;
36869
36870     int mem_base;
36871     int ret_val;
36872     xmlChar * utf; /* a sequence of UTF-8 encoded bytes */
36873     int n_utf;
36874     int len; /* the number of characters in the array */
36875     int n_len;
36876
36877     for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
36878     for (n_len = 0;n_len < gen_nb_int;n_len++) {
36879         mem_base = xmlMemBlocks();
36880         utf = gen_const_xmlChar_ptr(n_utf, 0);
36881         len = gen_int(n_len, 1);
36882
36883         ret_val = xmlUTF8Strsize((const xmlChar *)utf, len);
36884         desret_int(ret_val);
36885         call_tests++;
36886         des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
36887         des_int(n_len, len, 1);
36888         xmlResetLastError();
36889         if (mem_base != xmlMemBlocks()) {
36890             printf("Leak of %d blocks found in xmlUTF8Strsize",
36891                    xmlMemBlocks() - mem_base);
36892             test_ret++;
36893             printf(" %d", n_utf);
36894             printf(" %d", n_len);
36895             printf("\n");
36896         }
36897     }
36898     }
36899     function_tests++;
36900
36901     return(test_ret);
36902 }
36903
36904
36905 static int
36906 test_xmlUTF8Strsub(void) {
36907     int test_ret = 0;
36908
36909     int mem_base;
36910     xmlChar * ret_val;
36911     xmlChar * utf; /* a sequence of UTF-8 encoded bytes */
36912     int n_utf;
36913     int start; /* relative pos of first char */
36914     int n_start;
36915     int len; /* total number to copy */
36916     int n_len;
36917
36918     for (n_utf = 0;n_utf < gen_nb_const_xmlChar_ptr;n_utf++) {
36919     for (n_start = 0;n_start < gen_nb_int;n_start++) {
36920     for (n_len = 0;n_len < gen_nb_int;n_len++) {
36921         mem_base = xmlMemBlocks();
36922         utf = gen_const_xmlChar_ptr(n_utf, 0);
36923         start = gen_int(n_start, 1);
36924         len = gen_int(n_len, 2);
36925
36926         ret_val = xmlUTF8Strsub((const xmlChar *)utf, start, len);
36927         desret_xmlChar_ptr(ret_val);
36928         call_tests++;
36929         des_const_xmlChar_ptr(n_utf, (const xmlChar *)utf, 0);
36930         des_int(n_start, start, 1);
36931         des_int(n_len, len, 2);
36932         xmlResetLastError();
36933         if (mem_base != xmlMemBlocks()) {
36934             printf("Leak of %d blocks found in xmlUTF8Strsub",
36935                    xmlMemBlocks() - mem_base);
36936             test_ret++;
36937             printf(" %d", n_utf);
36938             printf(" %d", n_start);
36939             printf(" %d", n_len);
36940             printf("\n");
36941         }
36942     }
36943     }
36944     }
36945     function_tests++;
36946
36947     return(test_ret);
36948 }
36949
36950 static int
36951 test_xmlstring(void) {
36952     int test_ret = 0;
36953
36954     if (quiet == 0) printf("Testing xmlstring : 26 of 30 functions ...\n");
36955     test_ret += test_xmlCharStrdup();
36956     test_ret += test_xmlCharStrndup();
36957     test_ret += test_xmlCheckUTF8();
36958     test_ret += test_xmlGetUTF8Char();
36959     test_ret += test_xmlStrEqual();
36960     test_ret += test_xmlStrPrintf();
36961     test_ret += test_xmlStrQEqual();
36962     test_ret += test_xmlStrVPrintf();
36963     test_ret += test_xmlStrcasecmp();
36964     test_ret += test_xmlStrcasestr();
36965     test_ret += test_xmlStrchr();
36966     test_ret += test_xmlStrcmp();
36967     test_ret += test_xmlStrdup();
36968     test_ret += test_xmlStrlen();
36969     test_ret += test_xmlStrncasecmp();
36970     test_ret += test_xmlStrncatNew();
36971     test_ret += test_xmlStrncmp();
36972     test_ret += test_xmlStrndup();
36973     test_ret += test_xmlStrstr();
36974     test_ret += test_xmlStrsub();
36975     test_ret += test_xmlUTF8Charcmp();
36976     test_ret += test_xmlUTF8Size();
36977     test_ret += test_xmlUTF8Strlen();
36978     test_ret += test_xmlUTF8Strloc();
36979     test_ret += test_xmlUTF8Strndup();
36980     test_ret += test_xmlUTF8Strpos();
36981     test_ret += test_xmlUTF8Strsize();
36982     test_ret += test_xmlUTF8Strsub();
36983
36984     if (test_ret != 0)
36985         printf("Module xmlstring: %d errors\n", test_ret);
36986     return(test_ret);
36987 }
36988
36989 static int
36990 test_xmlUCSIsAegeanNumbers(void) {
36991     int test_ret = 0;
36992
36993 #if defined(LIBXML_UNICODE_ENABLED)
36994     int mem_base;
36995     int ret_val;
36996     int code; /* UCS code point */
36997     int n_code;
36998
36999     for (n_code = 0;n_code < gen_nb_int;n_code++) {
37000         mem_base = xmlMemBlocks();
37001         code = gen_int(n_code, 0);
37002
37003         ret_val = xmlUCSIsAegeanNumbers(code);
37004         desret_int(ret_val);
37005         call_tests++;
37006         des_int(n_code, code, 0);
37007         xmlResetLastError();
37008         if (mem_base != xmlMemBlocks()) {
37009             printf("Leak of %d blocks found in xmlUCSIsAegeanNumbers",
37010                    xmlMemBlocks() - mem_base);
37011             test_ret++;
37012             printf(" %d", n_code);
37013             printf("\n");
37014         }
37015     }
37016     function_tests++;
37017 #endif
37018
37019     return(test_ret);
37020 }
37021
37022
37023 static int
37024 test_xmlUCSIsAlphabeticPresentationForms(void) {
37025     int test_ret = 0;
37026
37027 #if defined(LIBXML_UNICODE_ENABLED)
37028     int mem_base;
37029     int ret_val;
37030     int code; /* UCS code point */
37031     int n_code;
37032
37033     for (n_code = 0;n_code < gen_nb_int;n_code++) {
37034         mem_base = xmlMemBlocks();
37035         code = gen_int(n_code, 0);
37036
37037         ret_val = xmlUCSIsAlphabeticPresentationForms(code);
37038         desret_int(ret_val);
37039         call_tests++;
37040         des_int(n_code, code, 0);
37041         xmlResetLastError();
37042         if (mem_base != xmlMemBlocks()) {
37043             printf("Leak of %d blocks found in xmlUCSIsAlphabeticPresentationForms",
37044                    xmlMemBlocks() - mem_base);
37045             test_ret++;
37046             printf(" %d", n_code);
37047             printf("\n");
37048         }
37049     }
37050     function_tests++;
37051 #endif
37052
37053     return(test_ret);
37054 }
37055
37056
37057 static int
37058 test_xmlUCSIsArabic(void) {
37059     int test_ret = 0;
37060
37061 #if defined(LIBXML_UNICODE_ENABLED)
37062     int mem_base;
37063     int ret_val;
37064     int code; /* UCS code point */
37065     int n_code;
37066
37067     for (n_code = 0;n_code < gen_nb_int;n_code++) {
37068         mem_base = xmlMemBlocks();
37069         code = gen_int(n_code, 0);
37070
37071         ret_val = xmlUCSIsArabic(code);
37072         desret_int(ret_val);
37073         call_tests++;
37074         des_int(n_code, code, 0);
37075         xmlResetLastError();
37076         if (mem_base != xmlMemBlocks()) {
37077             printf("Leak of %d blocks found in xmlUCSIsArabic",
37078                    xmlMemBlocks() - mem_base);
37079             test_ret++;
37080             printf(" %d", n_code);
37081             printf("\n");
37082         }
37083     }
37084     function_tests++;
37085 #endif
37086
37087     return(test_ret);
37088 }
37089
37090
37091 static int
37092 test_xmlUCSIsArabicPresentationFormsA(void) {
37093     int test_ret = 0;
37094
37095 #if defined(LIBXML_UNICODE_ENABLED)
37096     int mem_base;
37097     int ret_val;
37098     int code; /* UCS code point */
37099     int n_code;
37100
37101     for (n_code = 0;n_code < gen_nb_int;n_code++) {
37102         mem_base = xmlMemBlocks();
37103         code = gen_int(n_code, 0);
37104
37105         ret_val = xmlUCSIsArabicPresentationFormsA(code);
37106         desret_int(ret_val);
37107         call_tests++;
37108         des_int(n_code, code, 0);
37109         xmlResetLastError();
37110         if (mem_base != xmlMemBlocks()) {
37111             printf("Leak of %d blocks found in xmlUCSIsArabicPresentationFormsA",
37112                    xmlMemBlocks() - mem_base);
37113             test_ret++;
37114             printf(" %d", n_code);
37115             printf("\n");
37116         }
37117     }
37118     function_tests++;
37119 #endif
37120
37121     return(test_ret);
37122 }
37123
37124
37125 static int
37126 test_xmlUCSIsArabicPresentationFormsB(void) {
37127     int test_ret = 0;
37128
37129 #if defined(LIBXML_UNICODE_ENABLED)
37130     int mem_base;
37131     int ret_val;
37132     int code; /* UCS code point */
37133     int n_code;
37134
37135     for (n_code = 0;n_code < gen_nb_int;n_code++) {
37136         mem_base = xmlMemBlocks();
37137         code = gen_int(n_code, 0);
37138
37139         ret_val = xmlUCSIsArabicPresentationFormsB(code);
37140         desret_int(ret_val);
37141         call_tests++;
37142         des_int(n_code, code, 0);
37143         xmlResetLastError();
37144         if (mem_base != xmlMemBlocks()) {
37145             printf("Leak of %d blocks found in xmlUCSIsArabicPresentationFormsB",
37146                    xmlMemBlocks() - mem_base);
37147             test_ret++;
37148             printf(" %d", n_code);
37149             printf("\n");
37150         }
37151     }
37152     function_tests++;
37153 #endif
37154
37155     return(test_ret);
37156 }
37157
37158
37159 static int
37160 test_xmlUCSIsArmenian(void) {
37161     int test_ret = 0;
37162
37163 #if defined(LIBXML_UNICODE_ENABLED)
37164     int mem_base;
37165     int ret_val;
37166     int code; /* UCS code point */
37167     int n_code;
37168
37169     for (n_code = 0;n_code < gen_nb_int;n_code++) {
37170         mem_base = xmlMemBlocks();
37171         code = gen_int(n_code, 0);
37172
37173         ret_val = xmlUCSIsArmenian(code);
37174         desret_int(ret_val);
37175         call_tests++;
37176         des_int(n_code, code, 0);
37177         xmlResetLastError();
37178         if (mem_base != xmlMemBlocks()) {
37179             printf("Leak of %d blocks found in xmlUCSIsArmenian",
37180                    xmlMemBlocks() - mem_base);
37181             test_ret++;
37182             printf(" %d", n_code);
37183             printf("\n");
37184         }
37185     }
37186     function_tests++;
37187 #endif
37188
37189     return(test_ret);
37190 }
37191
37192
37193 static int
37194 test_xmlUCSIsArrows(void) {
37195     int test_ret = 0;
37196
37197 #if defined(LIBXML_UNICODE_ENABLED)
37198     int mem_base;
37199     int ret_val;
37200     int code; /* UCS code point */
37201     int n_code;
37202
37203     for (n_code = 0;n_code < gen_nb_int;n_code++) {
37204         mem_base = xmlMemBlocks();
37205         code = gen_int(n_code, 0);
37206
37207         ret_val = xmlUCSIsArrows(code);
37208         desret_int(ret_val);
37209         call_tests++;
37210         des_int(n_code, code, 0);
37211         xmlResetLastError();
37212         if (mem_base != xmlMemBlocks()) {
37213             printf("Leak of %d blocks found in xmlUCSIsArrows",
37214                    xmlMemBlocks() - mem_base);
37215             test_ret++;
37216             printf(" %d", n_code);
37217             printf("\n");
37218         }
37219     }
37220     function_tests++;
37221 #endif
37222
37223     return(test_ret);
37224 }
37225
37226
37227 static int
37228 test_xmlUCSIsBasicLatin(void) {
37229     int test_ret = 0;
37230
37231 #if defined(LIBXML_UNICODE_ENABLED)
37232     int mem_base;
37233     int ret_val;
37234     int code; /* UCS code point */
37235     int n_code;
37236
37237     for (n_code = 0;n_code < gen_nb_int;n_code++) {
37238         mem_base = xmlMemBlocks();
37239         code = gen_int(n_code, 0);
37240
37241         ret_val = xmlUCSIsBasicLatin(code);
37242         desret_int(ret_val);
37243         call_tests++;
37244         des_int(n_code, code, 0);
37245         xmlResetLastError();
37246         if (mem_base != xmlMemBlocks()) {
37247             printf("Leak of %d blocks found in xmlUCSIsBasicLatin",
37248                    xmlMemBlocks() - mem_base);
37249             test_ret++;
37250             printf(" %d", n_code);
37251             printf("\n");
37252         }
37253     }
37254     function_tests++;
37255 #endif
37256
37257     return(test_ret);
37258 }
37259
37260
37261 static int
37262 test_xmlUCSIsBengali(void) {
37263     int test_ret = 0;
37264
37265 #if defined(LIBXML_UNICODE_ENABLED)
37266     int mem_base;
37267     int ret_val;
37268     int code; /* UCS code point */
37269     int n_code;
37270
37271     for (n_code = 0;n_code < gen_nb_int;n_code++) {
37272         mem_base = xmlMemBlocks();
37273         code = gen_int(n_code, 0);
37274
37275         ret_val = xmlUCSIsBengali(code);
37276         desret_int(ret_val);
37277         call_tests++;
37278         des_int(n_code, code, 0);
37279         xmlResetLastError();
37280         if (mem_base != xmlMemBlocks()) {
37281             printf("Leak of %d blocks found in xmlUCSIsBengali",
37282                    xmlMemBlocks() - mem_base);
37283             test_ret++;
37284             printf(" %d", n_code);
37285             printf("\n");
37286         }
37287     }
37288     function_tests++;
37289 #endif
37290
37291     return(test_ret);
37292 }
37293
37294
37295 static int
37296 test_xmlUCSIsBlock(void) {
37297     int test_ret = 0;
37298
37299 #if defined(LIBXML_UNICODE_ENABLED)
37300     int mem_base;
37301     int ret_val;
37302     int code; /* UCS code point */
37303     int n_code;
37304     char * block; /* UCS block name */
37305     int n_block;
37306
37307     for (n_code = 0;n_code < gen_nb_int;n_code++) {
37308     for (n_block = 0;n_block < gen_nb_const_char_ptr;n_block++) {
37309         mem_base = xmlMemBlocks();
37310         code = gen_int(n_code, 0);
37311         block = gen_const_char_ptr(n_block, 1);
37312
37313         ret_val = xmlUCSIsBlock(code, (const char *)block);
37314         desret_int(ret_val);
37315         call_tests++;
37316         des_int(n_code, code, 0);
37317         des_const_char_ptr(n_block, (const char *)block, 1);
37318         xmlResetLastError();
37319         if (mem_base != xmlMemBlocks()) {
37320             printf("Leak of %d blocks found in xmlUCSIsBlock",
37321                    xmlMemBlocks() - mem_base);
37322             test_ret++;
37323             printf(" %d", n_code);
37324             printf(" %d", n_block);
37325             printf("\n");
37326         }
37327     }
37328     }
37329     function_tests++;
37330 #endif
37331
37332     return(test_ret);
37333 }
37334
37335
37336 static int
37337 test_xmlUCSIsBlockElements(void) {
37338     int test_ret = 0;
37339
37340 #if defined(LIBXML_UNICODE_ENABLED)
37341     int mem_base;
37342     int ret_val;
37343     int code; /* UCS code point */
37344     int n_code;
37345
37346     for (n_code = 0;n_code < gen_nb_int;n_code++) {
37347         mem_base = xmlMemBlocks();
37348         code = gen_int(n_code, 0);
37349
37350         ret_val = xmlUCSIsBlockElements(code);
37351         desret_int(ret_val);
37352         call_tests++;
37353         des_int(n_code, code, 0);
37354         xmlResetLastError();
37355         if (mem_base != xmlMemBlocks()) {
37356             printf("Leak of %d blocks found in xmlUCSIsBlockElements",
37357                    xmlMemBlocks() - mem_base);
37358             test_ret++;
37359             printf(" %d", n_code);
37360             printf("\n");
37361         }
37362     }
37363     function_tests++;
37364 #endif
37365
37366     return(test_ret);
37367 }
37368
37369
37370 static int
37371 test_xmlUCSIsBopomofo(void) {
37372     int test_ret = 0;
37373
37374 #if defined(LIBXML_UNICODE_ENABLED)
37375     int mem_base;
37376     int ret_val;
37377     int code; /* UCS code point */
37378     int n_code;
37379
37380     for (n_code = 0;n_code < gen_nb_int;n_code++) {
37381         mem_base = xmlMemBlocks();
37382         code = gen_int(n_code, 0);
37383
37384         ret_val = xmlUCSIsBopomofo(code);
37385         desret_int(ret_val);
37386         call_tests++;
37387         des_int(n_code, code, 0);
37388         xmlResetLastError();
37389         if (mem_base != xmlMemBlocks()) {
37390             printf("Leak of %d blocks found in xmlUCSIsBopomofo",
37391                    xmlMemBlocks() - mem_base);
37392             test_ret++;
37393             printf(" %d", n_code);
37394             printf("\n");
37395         }
37396     }
37397     function_tests++;
37398 #endif
37399
37400     return(test_ret);
37401 }
37402
37403
37404 static int
37405 test_xmlUCSIsBopomofoExtended(void) {
37406     int test_ret = 0;
37407
37408 #if defined(LIBXML_UNICODE_ENABLED)
37409     int mem_base;
37410     int ret_val;
37411     int code; /* UCS code point */
37412     int n_code;
37413
37414     for (n_code = 0;n_code < gen_nb_int;n_code++) {
37415         mem_base = xmlMemBlocks();
37416         code = gen_int(n_code, 0);
37417
37418         ret_val = xmlUCSIsBopomofoExtended(code);
37419         desret_int(ret_val);
37420         call_tests++;
37421         des_int(n_code, code, 0);
37422         xmlResetLastError();
37423         if (mem_base != xmlMemBlocks()) {
37424             printf("Leak of %d blocks found in xmlUCSIsBopomofoExtended",
37425                    xmlMemBlocks() - mem_base);
37426             test_ret++;
37427             printf(" %d", n_code);
37428             printf("\n");
37429         }
37430     }
37431     function_tests++;
37432 #endif
37433
37434     return(test_ret);
37435 }
37436
37437
37438 static int
37439 test_xmlUCSIsBoxDrawing(void) {
37440     int test_ret = 0;
37441
37442 #if defined(LIBXML_UNICODE_ENABLED)
37443     int mem_base;
37444     int ret_val;
37445     int code; /* UCS code point */
37446     int n_code;
37447
37448     for (n_code = 0;n_code < gen_nb_int;n_code++) {
37449         mem_base = xmlMemBlocks();
37450         code = gen_int(n_code, 0);
37451
37452         ret_val = xmlUCSIsBoxDrawing(code);
37453         desret_int(ret_val);
37454         call_tests++;
37455         des_int(n_code, code, 0);
37456         xmlResetLastError();
37457         if (mem_base != xmlMemBlocks()) {
37458             printf("Leak of %d blocks found in xmlUCSIsBoxDrawing",
37459                    xmlMemBlocks() - mem_base);
37460             test_ret++;
37461             printf(" %d", n_code);
37462             printf("\n");
37463         }
37464     }
37465     function_tests++;
37466 #endif
37467
37468     return(test_ret);
37469 }
37470
37471
37472 static int
37473 test_xmlUCSIsBraillePatterns(void) {
37474     int test_ret = 0;
37475
37476 #if defined(LIBXML_UNICODE_ENABLED)
37477     int mem_base;
37478     int ret_val;
37479     int code; /* UCS code point */
37480     int n_code;
37481
37482     for (n_code = 0;n_code < gen_nb_int;n_code++) {
37483         mem_base = xmlMemBlocks();
37484         code = gen_int(n_code, 0);
37485
37486         ret_val = xmlUCSIsBraillePatterns(code);
37487         desret_int(ret_val);
37488         call_tests++;
37489         des_int(n_code, code, 0);
37490         xmlResetLastError();
37491         if (mem_base != xmlMemBlocks()) {
37492             printf("Leak of %d blocks found in xmlUCSIsBraillePatterns",
37493                    xmlMemBlocks() - mem_base);
37494             test_ret++;
37495             printf(" %d", n_code);
37496             printf("\n");
37497         }
37498     }
37499     function_tests++;
37500 #endif
37501
37502     return(test_ret);
37503 }
37504
37505
37506 static int
37507 test_xmlUCSIsBuhid(void) {
37508     int test_ret = 0;
37509
37510 #if defined(LIBXML_UNICODE_ENABLED)
37511     int mem_base;
37512     int ret_val;
37513     int code; /* UCS code point */
37514     int n_code;
37515
37516     for (n_code = 0;n_code < gen_nb_int;n_code++) {
37517         mem_base = xmlMemBlocks();
37518         code = gen_int(n_code, 0);
37519
37520         ret_val = xmlUCSIsBuhid(code);
37521         desret_int(ret_val);
37522         call_tests++;
37523         des_int(n_code, code, 0);
37524         xmlResetLastError();
37525         if (mem_base != xmlMemBlocks()) {
37526             printf("Leak of %d blocks found in xmlUCSIsBuhid",
37527                    xmlMemBlocks() - mem_base);
37528             test_ret++;
37529             printf(" %d", n_code);
37530             printf("\n");
37531         }
37532     }
37533     function_tests++;
37534 #endif
37535
37536     return(test_ret);
37537 }
37538
37539
37540 static int
37541 test_xmlUCSIsByzantineMusicalSymbols(void) {
37542     int test_ret = 0;
37543
37544 #if defined(LIBXML_UNICODE_ENABLED)
37545     int mem_base;
37546     int ret_val;
37547     int code; /* UCS code point */
37548     int n_code;
37549
37550     for (n_code = 0;n_code < gen_nb_int;n_code++) {
37551         mem_base = xmlMemBlocks();
37552         code = gen_int(n_code, 0);
37553
37554         ret_val = xmlUCSIsByzantineMusicalSymbols(code);
37555         desret_int(ret_val);
37556         call_tests++;
37557         des_int(n_code, code, 0);
37558         xmlResetLastError();
37559         if (mem_base != xmlMemBlocks()) {
37560             printf("Leak of %d blocks found in xmlUCSIsByzantineMusicalSymbols",
37561                    xmlMemBlocks() - mem_base);
37562             test_ret++;
37563             printf(" %d", n_code);
37564             printf("\n");
37565         }
37566     }
37567     function_tests++;
37568 #endif
37569
37570     return(test_ret);
37571 }
37572
37573
37574 static int
37575 test_xmlUCSIsCJKCompatibility(void) {
37576     int test_ret = 0;
37577
37578 #if defined(LIBXML_UNICODE_ENABLED)
37579     int mem_base;
37580     int ret_val;
37581     int code; /* UCS code point */
37582     int n_code;
37583
37584     for (n_code = 0;n_code < gen_nb_int;n_code++) {
37585         mem_base = xmlMemBlocks();
37586         code = gen_int(n_code, 0);
37587
37588         ret_val = xmlUCSIsCJKCompatibility(code);
37589         desret_int(ret_val);
37590         call_tests++;
37591         des_int(n_code, code, 0);
37592         xmlResetLastError();
37593         if (mem_base != xmlMemBlocks()) {
37594             printf("Leak of %d blocks found in xmlUCSIsCJKCompatibility",
37595                    xmlMemBlocks() - mem_base);
37596             test_ret++;
37597             printf(" %d", n_code);
37598             printf("\n");
37599         }
37600     }
37601     function_tests++;
37602 #endif
37603
37604     return(test_ret);
37605 }
37606
37607
37608 static int
37609 test_xmlUCSIsCJKCompatibilityForms(void) {
37610     int test_ret = 0;
37611
37612 #if defined(LIBXML_UNICODE_ENABLED)
37613     int mem_base;
37614     int ret_val;
37615     int code; /* UCS code point */
37616     int n_code;
37617
37618     for (n_code = 0;n_code < gen_nb_int;n_code++) {
37619         mem_base = xmlMemBlocks();
37620         code = gen_int(n_code, 0);
37621
37622         ret_val = xmlUCSIsCJKCompatibilityForms(code);
37623         desret_int(ret_val);
37624         call_tests++;
37625         des_int(n_code, code, 0);
37626         xmlResetLastError();
37627         if (mem_base != xmlMemBlocks()) {
37628             printf("Leak of %d blocks found in xmlUCSIsCJKCompatibilityForms",
37629                    xmlMemBlocks() - mem_base);
37630             test_ret++;
37631             printf(" %d", n_code);
37632             printf("\n");
37633         }
37634     }
37635     function_tests++;
37636 #endif
37637
37638     return(test_ret);
37639 }
37640
37641
37642 static int
37643 test_xmlUCSIsCJKCompatibilityIdeographs(void) {
37644     int test_ret = 0;
37645
37646 #if defined(LIBXML_UNICODE_ENABLED)
37647     int mem_base;
37648     int ret_val;
37649     int code; /* UCS code point */
37650     int n_code;
37651
37652     for (n_code = 0;n_code < gen_nb_int;n_code++) {
37653         mem_base = xmlMemBlocks();
37654         code = gen_int(n_code, 0);
37655
37656         ret_val = xmlUCSIsCJKCompatibilityIdeographs(code);
37657         desret_int(ret_val);
37658         call_tests++;
37659         des_int(n_code, code, 0);
37660         xmlResetLastError();
37661         if (mem_base != xmlMemBlocks()) {
37662             printf("Leak of %d blocks found in xmlUCSIsCJKCompatibilityIdeographs",
37663                    xmlMemBlocks() - mem_base);
37664             test_ret++;
37665             printf(" %d", n_code);
37666             printf("\n");
37667         }
37668     }
37669     function_tests++;
37670 #endif
37671
37672     return(test_ret);
37673 }
37674
37675
37676 static int
37677 test_xmlUCSIsCJKCompatibilityIdeographsSupplement(void) {
37678     int test_ret = 0;
37679
37680 #if defined(LIBXML_UNICODE_ENABLED)
37681     int mem_base;
37682     int ret_val;
37683     int code; /* UCS code point */
37684     int n_code;
37685
37686     for (n_code = 0;n_code < gen_nb_int;n_code++) {
37687         mem_base = xmlMemBlocks();
37688         code = gen_int(n_code, 0);
37689
37690         ret_val = xmlUCSIsCJKCompatibilityIdeographsSupplement(code);
37691         desret_int(ret_val);
37692         call_tests++;
37693         des_int(n_code, code, 0);
37694         xmlResetLastError();
37695         if (mem_base != xmlMemBlocks()) {
37696             printf("Leak of %d blocks found in xmlUCSIsCJKCompatibilityIdeographsSupplement",
37697                    xmlMemBlocks() - mem_base);
37698             test_ret++;
37699             printf(" %d", n_code);
37700             printf("\n");
37701         }
37702     }
37703     function_tests++;
37704 #endif
37705
37706     return(test_ret);
37707 }
37708
37709
37710 static int
37711 test_xmlUCSIsCJKRadicalsSupplement(void) {
37712     int test_ret = 0;
37713
37714 #if defined(LIBXML_UNICODE_ENABLED)
37715     int mem_base;
37716     int ret_val;
37717     int code; /* UCS code point */
37718     int n_code;
37719
37720     for (n_code = 0;n_code < gen_nb_int;n_code++) {
37721         mem_base = xmlMemBlocks();
37722         code = gen_int(n_code, 0);
37723
37724         ret_val = xmlUCSIsCJKRadicalsSupplement(code);
37725         desret_int(ret_val);
37726         call_tests++;
37727         des_int(n_code, code, 0);
37728         xmlResetLastError();
37729         if (mem_base != xmlMemBlocks()) {
37730             printf("Leak of %d blocks found in xmlUCSIsCJKRadicalsSupplement",
37731                    xmlMemBlocks() - mem_base);
37732             test_ret++;
37733             printf(" %d", n_code);
37734             printf("\n");
37735         }
37736     }
37737     function_tests++;
37738 #endif
37739
37740     return(test_ret);
37741 }
37742
37743
37744 static int
37745 test_xmlUCSIsCJKSymbolsandPunctuation(void) {
37746     int test_ret = 0;
37747
37748 #if defined(LIBXML_UNICODE_ENABLED)
37749     int mem_base;
37750     int ret_val;
37751     int code; /* UCS code point */
37752     int n_code;
37753
37754     for (n_code = 0;n_code < gen_nb_int;n_code++) {
37755         mem_base = xmlMemBlocks();
37756         code = gen_int(n_code, 0);
37757
37758         ret_val = xmlUCSIsCJKSymbolsandPunctuation(code);
37759         desret_int(ret_val);
37760         call_tests++;
37761         des_int(n_code, code, 0);
37762         xmlResetLastError();
37763         if (mem_base != xmlMemBlocks()) {
37764             printf("Leak of %d blocks found in xmlUCSIsCJKSymbolsandPunctuation",
37765                    xmlMemBlocks() - mem_base);
37766             test_ret++;
37767             printf(" %d", n_code);
37768             printf("\n");
37769         }
37770     }
37771     function_tests++;
37772 #endif
37773
37774     return(test_ret);
37775 }
37776
37777
37778 static int
37779 test_xmlUCSIsCJKUnifiedIdeographs(void) {
37780     int test_ret = 0;
37781
37782 #if defined(LIBXML_UNICODE_ENABLED)
37783     int mem_base;
37784     int ret_val;
37785     int code; /* UCS code point */
37786     int n_code;
37787
37788     for (n_code = 0;n_code < gen_nb_int;n_code++) {
37789         mem_base = xmlMemBlocks();
37790         code = gen_int(n_code, 0);
37791
37792         ret_val = xmlUCSIsCJKUnifiedIdeographs(code);
37793         desret_int(ret_val);
37794         call_tests++;
37795         des_int(n_code, code, 0);
37796         xmlResetLastError();
37797         if (mem_base != xmlMemBlocks()) {
37798             printf("Leak of %d blocks found in xmlUCSIsCJKUnifiedIdeographs",
37799                    xmlMemBlocks() - mem_base);
37800             test_ret++;
37801             printf(" %d", n_code);
37802             printf("\n");
37803         }
37804     }
37805     function_tests++;
37806 #endif
37807
37808     return(test_ret);
37809 }
37810
37811
37812 static int
37813 test_xmlUCSIsCJKUnifiedIdeographsExtensionA(void) {
37814     int test_ret = 0;
37815
37816 #if defined(LIBXML_UNICODE_ENABLED)
37817     int mem_base;
37818     int ret_val;
37819     int code; /* UCS code point */
37820     int n_code;
37821
37822     for (n_code = 0;n_code < gen_nb_int;n_code++) {
37823         mem_base = xmlMemBlocks();
37824         code = gen_int(n_code, 0);
37825
37826         ret_val = xmlUCSIsCJKUnifiedIdeographsExtensionA(code);
37827         desret_int(ret_val);
37828         call_tests++;
37829         des_int(n_code, code, 0);
37830         xmlResetLastError();
37831         if (mem_base != xmlMemBlocks()) {
37832             printf("Leak of %d blocks found in xmlUCSIsCJKUnifiedIdeographsExtensionA",
37833                    xmlMemBlocks() - mem_base);
37834             test_ret++;
37835             printf(" %d", n_code);
37836             printf("\n");
37837         }
37838     }
37839     function_tests++;
37840 #endif
37841
37842     return(test_ret);
37843 }
37844
37845
37846 static int
37847 test_xmlUCSIsCJKUnifiedIdeographsExtensionB(void) {
37848     int test_ret = 0;
37849
37850 #if defined(LIBXML_UNICODE_ENABLED)
37851     int mem_base;
37852     int ret_val;
37853     int code; /* UCS code point */
37854     int n_code;
37855
37856     for (n_code = 0;n_code < gen_nb_int;n_code++) {
37857         mem_base = xmlMemBlocks();
37858         code = gen_int(n_code, 0);
37859
37860         ret_val = xmlUCSIsCJKUnifiedIdeographsExtensionB(code);
37861         desret_int(ret_val);
37862         call_tests++;
37863         des_int(n_code, code, 0);
37864         xmlResetLastError();
37865         if (mem_base != xmlMemBlocks()) {
37866             printf("Leak of %d blocks found in xmlUCSIsCJKUnifiedIdeographsExtensionB",
37867                    xmlMemBlocks() - mem_base);
37868             test_ret++;
37869             printf(" %d", n_code);
37870             printf("\n");
37871         }
37872     }
37873     function_tests++;
37874 #endif
37875
37876     return(test_ret);
37877 }
37878
37879
37880 static int
37881 test_xmlUCSIsCat(void) {
37882     int test_ret = 0;
37883
37884 #if defined(LIBXML_UNICODE_ENABLED)
37885     int mem_base;
37886     int ret_val;
37887     int code; /* UCS code point */
37888     int n_code;
37889     char * cat; /* UCS Category name */
37890     int n_cat;
37891
37892     for (n_code = 0;n_code < gen_nb_int;n_code++) {
37893     for (n_cat = 0;n_cat < gen_nb_const_char_ptr;n_cat++) {
37894         mem_base = xmlMemBlocks();
37895         code = gen_int(n_code, 0);
37896         cat = gen_const_char_ptr(n_cat, 1);
37897
37898         ret_val = xmlUCSIsCat(code, (const char *)cat);
37899         desret_int(ret_val);
37900         call_tests++;
37901         des_int(n_code, code, 0);
37902         des_const_char_ptr(n_cat, (const char *)cat, 1);
37903         xmlResetLastError();
37904         if (mem_base != xmlMemBlocks()) {
37905             printf("Leak of %d blocks found in xmlUCSIsCat",
37906                    xmlMemBlocks() - mem_base);
37907             test_ret++;
37908             printf(" %d", n_code);
37909             printf(" %d", n_cat);
37910             printf("\n");
37911         }
37912     }
37913     }
37914     function_tests++;
37915 #endif
37916
37917     return(test_ret);
37918 }
37919
37920
37921 static int
37922 test_xmlUCSIsCatC(void) {
37923     int test_ret = 0;
37924
37925 #if defined(LIBXML_UNICODE_ENABLED)
37926     int mem_base;
37927     int ret_val;
37928     int code; /* UCS code point */
37929     int n_code;
37930
37931     for (n_code = 0;n_code < gen_nb_int;n_code++) {
37932         mem_base = xmlMemBlocks();
37933         code = gen_int(n_code, 0);
37934
37935         ret_val = xmlUCSIsCatC(code);
37936         desret_int(ret_val);
37937         call_tests++;
37938         des_int(n_code, code, 0);
37939         xmlResetLastError();
37940         if (mem_base != xmlMemBlocks()) {
37941             printf("Leak of %d blocks found in xmlUCSIsCatC",
37942                    xmlMemBlocks() - mem_base);
37943             test_ret++;
37944             printf(" %d", n_code);
37945             printf("\n");
37946         }
37947     }
37948     function_tests++;
37949 #endif
37950
37951     return(test_ret);
37952 }
37953
37954
37955 static int
37956 test_xmlUCSIsCatCc(void) {
37957     int test_ret = 0;
37958
37959 #if defined(LIBXML_UNICODE_ENABLED)
37960     int mem_base;
37961     int ret_val;
37962     int code; /* UCS code point */
37963     int n_code;
37964
37965     for (n_code = 0;n_code < gen_nb_int;n_code++) {
37966         mem_base = xmlMemBlocks();
37967         code = gen_int(n_code, 0);
37968
37969         ret_val = xmlUCSIsCatCc(code);
37970         desret_int(ret_val);
37971         call_tests++;
37972         des_int(n_code, code, 0);
37973         xmlResetLastError();
37974         if (mem_base != xmlMemBlocks()) {
37975             printf("Leak of %d blocks found in xmlUCSIsCatCc",
37976                    xmlMemBlocks() - mem_base);
37977             test_ret++;
37978             printf(" %d", n_code);
37979             printf("\n");
37980         }
37981     }
37982     function_tests++;
37983 #endif
37984
37985     return(test_ret);
37986 }
37987
37988
37989 static int
37990 test_xmlUCSIsCatCf(void) {
37991     int test_ret = 0;
37992
37993 #if defined(LIBXML_UNICODE_ENABLED)
37994     int mem_base;
37995     int ret_val;
37996     int code; /* UCS code point */
37997     int n_code;
37998
37999     for (n_code = 0;n_code < gen_nb_int;n_code++) {
38000         mem_base = xmlMemBlocks();
38001         code = gen_int(n_code, 0);
38002
38003         ret_val = xmlUCSIsCatCf(code);
38004         desret_int(ret_val);
38005         call_tests++;
38006         des_int(n_code, code, 0);
38007         xmlResetLastError();
38008         if (mem_base != xmlMemBlocks()) {
38009             printf("Leak of %d blocks found in xmlUCSIsCatCf",
38010                    xmlMemBlocks() - mem_base);
38011             test_ret++;
38012             printf(" %d", n_code);
38013             printf("\n");
38014         }
38015     }
38016     function_tests++;
38017 #endif
38018
38019     return(test_ret);
38020 }
38021
38022
38023 static int
38024 test_xmlUCSIsCatCo(void) {
38025     int test_ret = 0;
38026
38027 #if defined(LIBXML_UNICODE_ENABLED)
38028     int mem_base;
38029     int ret_val;
38030     int code; /* UCS code point */
38031     int n_code;
38032
38033     for (n_code = 0;n_code < gen_nb_int;n_code++) {
38034         mem_base = xmlMemBlocks();
38035         code = gen_int(n_code, 0);
38036
38037         ret_val = xmlUCSIsCatCo(code);
38038         desret_int(ret_val);
38039         call_tests++;
38040         des_int(n_code, code, 0);
38041         xmlResetLastError();
38042         if (mem_base != xmlMemBlocks()) {
38043             printf("Leak of %d blocks found in xmlUCSIsCatCo",
38044                    xmlMemBlocks() - mem_base);
38045             test_ret++;
38046             printf(" %d", n_code);
38047             printf("\n");
38048         }
38049     }
38050     function_tests++;
38051 #endif
38052
38053     return(test_ret);
38054 }
38055
38056
38057 static int
38058 test_xmlUCSIsCatCs(void) {
38059     int test_ret = 0;
38060
38061 #if defined(LIBXML_UNICODE_ENABLED)
38062     int mem_base;
38063     int ret_val;
38064     int code; /* UCS code point */
38065     int n_code;
38066
38067     for (n_code = 0;n_code < gen_nb_int;n_code++) {
38068         mem_base = xmlMemBlocks();
38069         code = gen_int(n_code, 0);
38070
38071         ret_val = xmlUCSIsCatCs(code);
38072         desret_int(ret_val);
38073         call_tests++;
38074         des_int(n_code, code, 0);
38075         xmlResetLastError();
38076         if (mem_base != xmlMemBlocks()) {
38077             printf("Leak of %d blocks found in xmlUCSIsCatCs",
38078                    xmlMemBlocks() - mem_base);
38079             test_ret++;
38080             printf(" %d", n_code);
38081             printf("\n");
38082         }
38083     }
38084     function_tests++;
38085 #endif
38086
38087     return(test_ret);
38088 }
38089
38090
38091 static int
38092 test_xmlUCSIsCatL(void) {
38093     int test_ret = 0;
38094
38095 #if defined(LIBXML_UNICODE_ENABLED)
38096     int mem_base;
38097     int ret_val;
38098     int code; /* UCS code point */
38099     int n_code;
38100
38101     for (n_code = 0;n_code < gen_nb_int;n_code++) {
38102         mem_base = xmlMemBlocks();
38103         code = gen_int(n_code, 0);
38104
38105         ret_val = xmlUCSIsCatL(code);
38106         desret_int(ret_val);
38107         call_tests++;
38108         des_int(n_code, code, 0);
38109         xmlResetLastError();
38110         if (mem_base != xmlMemBlocks()) {
38111             printf("Leak of %d blocks found in xmlUCSIsCatL",
38112                    xmlMemBlocks() - mem_base);
38113             test_ret++;
38114             printf(" %d", n_code);
38115             printf("\n");
38116         }
38117     }
38118     function_tests++;
38119 #endif
38120
38121     return(test_ret);
38122 }
38123
38124
38125 static int
38126 test_xmlUCSIsCatLl(void) {
38127     int test_ret = 0;
38128
38129 #if defined(LIBXML_UNICODE_ENABLED)
38130     int mem_base;
38131     int ret_val;
38132     int code; /* UCS code point */
38133     int n_code;
38134
38135     for (n_code = 0;n_code < gen_nb_int;n_code++) {
38136         mem_base = xmlMemBlocks();
38137         code = gen_int(n_code, 0);
38138
38139         ret_val = xmlUCSIsCatLl(code);
38140         desret_int(ret_val);
38141         call_tests++;
38142         des_int(n_code, code, 0);
38143         xmlResetLastError();
38144         if (mem_base != xmlMemBlocks()) {
38145             printf("Leak of %d blocks found in xmlUCSIsCatLl",
38146                    xmlMemBlocks() - mem_base);
38147             test_ret++;
38148             printf(" %d", n_code);
38149             printf("\n");
38150         }
38151     }
38152     function_tests++;
38153 #endif
38154
38155     return(test_ret);
38156 }
38157
38158
38159 static int
38160 test_xmlUCSIsCatLm(void) {
38161     int test_ret = 0;
38162
38163 #if defined(LIBXML_UNICODE_ENABLED)
38164     int mem_base;
38165     int ret_val;
38166     int code; /* UCS code point */
38167     int n_code;
38168
38169     for (n_code = 0;n_code < gen_nb_int;n_code++) {
38170         mem_base = xmlMemBlocks();
38171         code = gen_int(n_code, 0);
38172
38173         ret_val = xmlUCSIsCatLm(code);
38174         desret_int(ret_val);
38175         call_tests++;
38176         des_int(n_code, code, 0);
38177         xmlResetLastError();
38178         if (mem_base != xmlMemBlocks()) {
38179             printf("Leak of %d blocks found in xmlUCSIsCatLm",
38180                    xmlMemBlocks() - mem_base);
38181             test_ret++;
38182             printf(" %d", n_code);
38183             printf("\n");
38184         }
38185     }
38186     function_tests++;
38187 #endif
38188
38189     return(test_ret);
38190 }
38191
38192
38193 static int
38194 test_xmlUCSIsCatLo(void) {
38195     int test_ret = 0;
38196
38197 #if defined(LIBXML_UNICODE_ENABLED)
38198     int mem_base;
38199     int ret_val;
38200     int code; /* UCS code point */
38201     int n_code;
38202
38203     for (n_code = 0;n_code < gen_nb_int;n_code++) {
38204         mem_base = xmlMemBlocks();
38205         code = gen_int(n_code, 0);
38206
38207         ret_val = xmlUCSIsCatLo(code);
38208         desret_int(ret_val);
38209         call_tests++;
38210         des_int(n_code, code, 0);
38211         xmlResetLastError();
38212         if (mem_base != xmlMemBlocks()) {
38213             printf("Leak of %d blocks found in xmlUCSIsCatLo",
38214                    xmlMemBlocks() - mem_base);
38215             test_ret++;
38216             printf(" %d", n_code);
38217             printf("\n");
38218         }
38219     }
38220     function_tests++;
38221 #endif
38222
38223     return(test_ret);
38224 }
38225
38226
38227 static int
38228 test_xmlUCSIsCatLt(void) {
38229     int test_ret = 0;
38230
38231 #if defined(LIBXML_UNICODE_ENABLED)
38232     int mem_base;
38233     int ret_val;
38234     int code; /* UCS code point */
38235     int n_code;
38236
38237     for (n_code = 0;n_code < gen_nb_int;n_code++) {
38238         mem_base = xmlMemBlocks();
38239         code = gen_int(n_code, 0);
38240
38241         ret_val = xmlUCSIsCatLt(code);
38242         desret_int(ret_val);
38243         call_tests++;
38244         des_int(n_code, code, 0);
38245         xmlResetLastError();
38246         if (mem_base != xmlMemBlocks()) {
38247             printf("Leak of %d blocks found in xmlUCSIsCatLt",
38248                    xmlMemBlocks() - mem_base);
38249             test_ret++;
38250             printf(" %d", n_code);
38251             printf("\n");
38252         }
38253     }
38254     function_tests++;
38255 #endif
38256
38257     return(test_ret);
38258 }
38259
38260
38261 static int
38262 test_xmlUCSIsCatLu(void) {
38263     int test_ret = 0;
38264
38265 #if defined(LIBXML_UNICODE_ENABLED)
38266     int mem_base;
38267     int ret_val;
38268     int code; /* UCS code point */
38269     int n_code;
38270
38271     for (n_code = 0;n_code < gen_nb_int;n_code++) {
38272         mem_base = xmlMemBlocks();
38273         code = gen_int(n_code, 0);
38274
38275         ret_val = xmlUCSIsCatLu(code);
38276         desret_int(ret_val);
38277         call_tests++;
38278         des_int(n_code, code, 0);
38279         xmlResetLastError();
38280         if (mem_base != xmlMemBlocks()) {
38281             printf("Leak of %d blocks found in xmlUCSIsCatLu",
38282                    xmlMemBlocks() - mem_base);
38283             test_ret++;
38284             printf(" %d", n_code);
38285             printf("\n");
38286         }
38287     }
38288     function_tests++;
38289 #endif
38290
38291     return(test_ret);
38292 }
38293
38294
38295 static int
38296 test_xmlUCSIsCatM(void) {
38297     int test_ret = 0;
38298
38299 #if defined(LIBXML_UNICODE_ENABLED)
38300     int mem_base;
38301     int ret_val;
38302     int code; /* UCS code point */
38303     int n_code;
38304
38305     for (n_code = 0;n_code < gen_nb_int;n_code++) {
38306         mem_base = xmlMemBlocks();
38307         code = gen_int(n_code, 0);
38308
38309         ret_val = xmlUCSIsCatM(code);
38310         desret_int(ret_val);
38311         call_tests++;
38312         des_int(n_code, code, 0);
38313         xmlResetLastError();
38314         if (mem_base != xmlMemBlocks()) {
38315             printf("Leak of %d blocks found in xmlUCSIsCatM",
38316                    xmlMemBlocks() - mem_base);
38317             test_ret++;
38318             printf(" %d", n_code);
38319             printf("\n");
38320         }
38321     }
38322     function_tests++;
38323 #endif
38324
38325     return(test_ret);
38326 }
38327
38328
38329 static int
38330 test_xmlUCSIsCatMc(void) {
38331     int test_ret = 0;
38332
38333 #if defined(LIBXML_UNICODE_ENABLED)
38334     int mem_base;
38335     int ret_val;
38336     int code; /* UCS code point */
38337     int n_code;
38338
38339     for (n_code = 0;n_code < gen_nb_int;n_code++) {
38340         mem_base = xmlMemBlocks();
38341         code = gen_int(n_code, 0);
38342
38343         ret_val = xmlUCSIsCatMc(code);
38344         desret_int(ret_val);
38345         call_tests++;
38346         des_int(n_code, code, 0);
38347         xmlResetLastError();
38348         if (mem_base != xmlMemBlocks()) {
38349             printf("Leak of %d blocks found in xmlUCSIsCatMc",
38350                    xmlMemBlocks() - mem_base);
38351             test_ret++;
38352             printf(" %d", n_code);
38353             printf("\n");
38354         }
38355     }
38356     function_tests++;
38357 #endif
38358
38359     return(test_ret);
38360 }
38361
38362
38363 static int
38364 test_xmlUCSIsCatMe(void) {
38365     int test_ret = 0;
38366
38367 #if defined(LIBXML_UNICODE_ENABLED)
38368     int mem_base;
38369     int ret_val;
38370     int code; /* UCS code point */
38371     int n_code;
38372
38373     for (n_code = 0;n_code < gen_nb_int;n_code++) {
38374         mem_base = xmlMemBlocks();
38375         code = gen_int(n_code, 0);
38376
38377         ret_val = xmlUCSIsCatMe(code);
38378         desret_int(ret_val);
38379         call_tests++;
38380         des_int(n_code, code, 0);
38381         xmlResetLastError();
38382         if (mem_base != xmlMemBlocks()) {
38383             printf("Leak of %d blocks found in xmlUCSIsCatMe",
38384                    xmlMemBlocks() - mem_base);
38385             test_ret++;
38386             printf(" %d", n_code);
38387             printf("\n");
38388         }
38389     }
38390     function_tests++;
38391 #endif
38392
38393     return(test_ret);
38394 }
38395
38396
38397 static int
38398 test_xmlUCSIsCatMn(void) {
38399     int test_ret = 0;
38400
38401 #if defined(LIBXML_UNICODE_ENABLED)
38402     int mem_base;
38403     int ret_val;
38404     int code; /* UCS code point */
38405     int n_code;
38406
38407     for (n_code = 0;n_code < gen_nb_int;n_code++) {
38408         mem_base = xmlMemBlocks();
38409         code = gen_int(n_code, 0);
38410
38411         ret_val = xmlUCSIsCatMn(code);
38412         desret_int(ret_val);
38413         call_tests++;
38414         des_int(n_code, code, 0);
38415         xmlResetLastError();
38416         if (mem_base != xmlMemBlocks()) {
38417             printf("Leak of %d blocks found in xmlUCSIsCatMn",
38418                    xmlMemBlocks() - mem_base);
38419             test_ret++;
38420             printf(" %d", n_code);
38421             printf("\n");
38422         }
38423     }
38424     function_tests++;
38425 #endif
38426
38427     return(test_ret);
38428 }
38429
38430
38431 static int
38432 test_xmlUCSIsCatN(void) {
38433     int test_ret = 0;
38434
38435 #if defined(LIBXML_UNICODE_ENABLED)
38436     int mem_base;
38437     int ret_val;
38438     int code; /* UCS code point */
38439     int n_code;
38440
38441     for (n_code = 0;n_code < gen_nb_int;n_code++) {
38442         mem_base = xmlMemBlocks();
38443         code = gen_int(n_code, 0);
38444
38445         ret_val = xmlUCSIsCatN(code);
38446         desret_int(ret_val);
38447         call_tests++;
38448         des_int(n_code, code, 0);
38449         xmlResetLastError();
38450         if (mem_base != xmlMemBlocks()) {
38451             printf("Leak of %d blocks found in xmlUCSIsCatN",
38452                    xmlMemBlocks() - mem_base);
38453             test_ret++;
38454             printf(" %d", n_code);
38455             printf("\n");
38456         }
38457     }
38458     function_tests++;
38459 #endif
38460
38461     return(test_ret);
38462 }
38463
38464
38465 static int
38466 test_xmlUCSIsCatNd(void) {
38467     int test_ret = 0;
38468
38469 #if defined(LIBXML_UNICODE_ENABLED)
38470     int mem_base;
38471     int ret_val;
38472     int code; /* UCS code point */
38473     int n_code;
38474
38475     for (n_code = 0;n_code < gen_nb_int;n_code++) {
38476         mem_base = xmlMemBlocks();
38477         code = gen_int(n_code, 0);
38478
38479         ret_val = xmlUCSIsCatNd(code);
38480         desret_int(ret_val);
38481         call_tests++;
38482         des_int(n_code, code, 0);
38483         xmlResetLastError();
38484         if (mem_base != xmlMemBlocks()) {
38485             printf("Leak of %d blocks found in xmlUCSIsCatNd",
38486                    xmlMemBlocks() - mem_base);
38487             test_ret++;
38488             printf(" %d", n_code);
38489             printf("\n");
38490         }
38491     }
38492     function_tests++;
38493 #endif
38494
38495     return(test_ret);
38496 }
38497
38498
38499 static int
38500 test_xmlUCSIsCatNl(void) {
38501     int test_ret = 0;
38502
38503 #if defined(LIBXML_UNICODE_ENABLED)
38504     int mem_base;
38505     int ret_val;
38506     int code; /* UCS code point */
38507     int n_code;
38508
38509     for (n_code = 0;n_code < gen_nb_int;n_code++) {
38510         mem_base = xmlMemBlocks();
38511         code = gen_int(n_code, 0);
38512
38513         ret_val = xmlUCSIsCatNl(code);
38514         desret_int(ret_val);
38515         call_tests++;
38516         des_int(n_code, code, 0);
38517         xmlResetLastError();
38518         if (mem_base != xmlMemBlocks()) {
38519             printf("Leak of %d blocks found in xmlUCSIsCatNl",
38520                    xmlMemBlocks() - mem_base);
38521             test_ret++;
38522             printf(" %d", n_code);
38523             printf("\n");
38524         }
38525     }
38526     function_tests++;
38527 #endif
38528
38529     return(test_ret);
38530 }
38531
38532
38533 static int
38534 test_xmlUCSIsCatNo(void) {
38535     int test_ret = 0;
38536
38537 #if defined(LIBXML_UNICODE_ENABLED)
38538     int mem_base;
38539     int ret_val;
38540     int code; /* UCS code point */
38541     int n_code;
38542
38543     for (n_code = 0;n_code < gen_nb_int;n_code++) {
38544         mem_base = xmlMemBlocks();
38545         code = gen_int(n_code, 0);
38546
38547         ret_val = xmlUCSIsCatNo(code);
38548         desret_int(ret_val);
38549         call_tests++;
38550         des_int(n_code, code, 0);
38551         xmlResetLastError();
38552         if (mem_base != xmlMemBlocks()) {
38553             printf("Leak of %d blocks found in xmlUCSIsCatNo",
38554                    xmlMemBlocks() - mem_base);
38555             test_ret++;
38556             printf(" %d", n_code);
38557             printf("\n");
38558         }
38559     }
38560     function_tests++;
38561 #endif
38562
38563     return(test_ret);
38564 }
38565
38566
38567 static int
38568 test_xmlUCSIsCatP(void) {
38569     int test_ret = 0;
38570
38571 #if defined(LIBXML_UNICODE_ENABLED)
38572     int mem_base;
38573     int ret_val;
38574     int code; /* UCS code point */
38575     int n_code;
38576
38577     for (n_code = 0;n_code < gen_nb_int;n_code++) {
38578         mem_base = xmlMemBlocks();
38579         code = gen_int(n_code, 0);
38580
38581         ret_val = xmlUCSIsCatP(code);
38582         desret_int(ret_val);
38583         call_tests++;
38584         des_int(n_code, code, 0);
38585         xmlResetLastError();
38586         if (mem_base != xmlMemBlocks()) {
38587             printf("Leak of %d blocks found in xmlUCSIsCatP",
38588                    xmlMemBlocks() - mem_base);
38589             test_ret++;
38590             printf(" %d", n_code);
38591             printf("\n");
38592         }
38593     }
38594     function_tests++;
38595 #endif
38596
38597     return(test_ret);
38598 }
38599
38600
38601 static int
38602 test_xmlUCSIsCatPc(void) {
38603     int test_ret = 0;
38604
38605 #if defined(LIBXML_UNICODE_ENABLED)
38606     int mem_base;
38607     int ret_val;
38608     int code; /* UCS code point */
38609     int n_code;
38610
38611     for (n_code = 0;n_code < gen_nb_int;n_code++) {
38612         mem_base = xmlMemBlocks();
38613         code = gen_int(n_code, 0);
38614
38615         ret_val = xmlUCSIsCatPc(code);
38616         desret_int(ret_val);
38617         call_tests++;
38618         des_int(n_code, code, 0);
38619         xmlResetLastError();
38620         if (mem_base != xmlMemBlocks()) {
38621             printf("Leak of %d blocks found in xmlUCSIsCatPc",
38622                    xmlMemBlocks() - mem_base);
38623             test_ret++;
38624             printf(" %d", n_code);
38625             printf("\n");
38626         }
38627     }
38628     function_tests++;
38629 #endif
38630
38631     return(test_ret);
38632 }
38633
38634
38635 static int
38636 test_xmlUCSIsCatPd(void) {
38637     int test_ret = 0;
38638
38639 #if defined(LIBXML_UNICODE_ENABLED)
38640     int mem_base;
38641     int ret_val;
38642     int code; /* UCS code point */
38643     int n_code;
38644
38645     for (n_code = 0;n_code < gen_nb_int;n_code++) {
38646         mem_base = xmlMemBlocks();
38647         code = gen_int(n_code, 0);
38648
38649         ret_val = xmlUCSIsCatPd(code);
38650         desret_int(ret_val);
38651         call_tests++;
38652         des_int(n_code, code, 0);
38653         xmlResetLastError();
38654         if (mem_base != xmlMemBlocks()) {
38655             printf("Leak of %d blocks found in xmlUCSIsCatPd",
38656                    xmlMemBlocks() - mem_base);
38657             test_ret++;
38658             printf(" %d", n_code);
38659             printf("\n");
38660         }
38661     }
38662     function_tests++;
38663 #endif
38664
38665     return(test_ret);
38666 }
38667
38668
38669 static int
38670 test_xmlUCSIsCatPe(void) {
38671     int test_ret = 0;
38672
38673 #if defined(LIBXML_UNICODE_ENABLED)
38674     int mem_base;
38675     int ret_val;
38676     int code; /* UCS code point */
38677     int n_code;
38678
38679     for (n_code = 0;n_code < gen_nb_int;n_code++) {
38680         mem_base = xmlMemBlocks();
38681         code = gen_int(n_code, 0);
38682
38683         ret_val = xmlUCSIsCatPe(code);
38684         desret_int(ret_val);
38685         call_tests++;
38686         des_int(n_code, code, 0);
38687         xmlResetLastError();
38688         if (mem_base != xmlMemBlocks()) {
38689             printf("Leak of %d blocks found in xmlUCSIsCatPe",
38690                    xmlMemBlocks() - mem_base);
38691             test_ret++;
38692             printf(" %d", n_code);
38693             printf("\n");
38694         }
38695     }
38696     function_tests++;
38697 #endif
38698
38699     return(test_ret);
38700 }
38701
38702
38703 static int
38704 test_xmlUCSIsCatPf(void) {
38705     int test_ret = 0;
38706
38707 #if defined(LIBXML_UNICODE_ENABLED)
38708     int mem_base;
38709     int ret_val;
38710     int code; /* UCS code point */
38711     int n_code;
38712
38713     for (n_code = 0;n_code < gen_nb_int;n_code++) {
38714         mem_base = xmlMemBlocks();
38715         code = gen_int(n_code, 0);
38716
38717         ret_val = xmlUCSIsCatPf(code);
38718         desret_int(ret_val);
38719         call_tests++;
38720         des_int(n_code, code, 0);
38721         xmlResetLastError();
38722         if (mem_base != xmlMemBlocks()) {
38723             printf("Leak of %d blocks found in xmlUCSIsCatPf",
38724                    xmlMemBlocks() - mem_base);
38725             test_ret++;
38726             printf(" %d", n_code);
38727             printf("\n");
38728         }
38729     }
38730     function_tests++;
38731 #endif
38732
38733     return(test_ret);
38734 }
38735
38736
38737 static int
38738 test_xmlUCSIsCatPi(void) {
38739     int test_ret = 0;
38740
38741 #if defined(LIBXML_UNICODE_ENABLED)
38742     int mem_base;
38743     int ret_val;
38744     int code; /* UCS code point */
38745     int n_code;
38746
38747     for (n_code = 0;n_code < gen_nb_int;n_code++) {
38748         mem_base = xmlMemBlocks();
38749         code = gen_int(n_code, 0);
38750
38751         ret_val = xmlUCSIsCatPi(code);
38752         desret_int(ret_val);
38753         call_tests++;
38754         des_int(n_code, code, 0);
38755         xmlResetLastError();
38756         if (mem_base != xmlMemBlocks()) {
38757             printf("Leak of %d blocks found in xmlUCSIsCatPi",
38758                    xmlMemBlocks() - mem_base);
38759             test_ret++;
38760             printf(" %d", n_code);
38761             printf("\n");
38762         }
38763     }
38764     function_tests++;
38765 #endif
38766
38767     return(test_ret);
38768 }
38769
38770
38771 static int
38772 test_xmlUCSIsCatPo(void) {
38773     int test_ret = 0;
38774
38775 #if defined(LIBXML_UNICODE_ENABLED)
38776     int mem_base;
38777     int ret_val;
38778     int code; /* UCS code point */
38779     int n_code;
38780
38781     for (n_code = 0;n_code < gen_nb_int;n_code++) {
38782         mem_base = xmlMemBlocks();
38783         code = gen_int(n_code, 0);
38784
38785         ret_val = xmlUCSIsCatPo(code);
38786         desret_int(ret_val);
38787         call_tests++;
38788         des_int(n_code, code, 0);
38789         xmlResetLastError();
38790         if (mem_base != xmlMemBlocks()) {
38791             printf("Leak of %d blocks found in xmlUCSIsCatPo",
38792                    xmlMemBlocks() - mem_base);
38793             test_ret++;
38794             printf(" %d", n_code);
38795             printf("\n");
38796         }
38797     }
38798     function_tests++;
38799 #endif
38800
38801     return(test_ret);
38802 }
38803
38804
38805 static int
38806 test_xmlUCSIsCatPs(void) {
38807     int test_ret = 0;
38808
38809 #if defined(LIBXML_UNICODE_ENABLED)
38810     int mem_base;
38811     int ret_val;
38812     int code; /* UCS code point */
38813     int n_code;
38814
38815     for (n_code = 0;n_code < gen_nb_int;n_code++) {
38816         mem_base = xmlMemBlocks();
38817         code = gen_int(n_code, 0);
38818
38819         ret_val = xmlUCSIsCatPs(code);
38820         desret_int(ret_val);
38821         call_tests++;
38822         des_int(n_code, code, 0);
38823         xmlResetLastError();
38824         if (mem_base != xmlMemBlocks()) {
38825             printf("Leak of %d blocks found in xmlUCSIsCatPs",
38826                    xmlMemBlocks() - mem_base);
38827             test_ret++;
38828             printf(" %d", n_code);
38829             printf("\n");
38830         }
38831     }
38832     function_tests++;
38833 #endif
38834
38835     return(test_ret);
38836 }
38837
38838
38839 static int
38840 test_xmlUCSIsCatS(void) {
38841     int test_ret = 0;
38842
38843 #if defined(LIBXML_UNICODE_ENABLED)
38844     int mem_base;
38845     int ret_val;
38846     int code; /* UCS code point */
38847     int n_code;
38848
38849     for (n_code = 0;n_code < gen_nb_int;n_code++) {
38850         mem_base = xmlMemBlocks();
38851         code = gen_int(n_code, 0);
38852
38853         ret_val = xmlUCSIsCatS(code);
38854         desret_int(ret_val);
38855         call_tests++;
38856         des_int(n_code, code, 0);
38857         xmlResetLastError();
38858         if (mem_base != xmlMemBlocks()) {
38859             printf("Leak of %d blocks found in xmlUCSIsCatS",
38860                    xmlMemBlocks() - mem_base);
38861             test_ret++;
38862             printf(" %d", n_code);
38863             printf("\n");
38864         }
38865     }
38866     function_tests++;
38867 #endif
38868
38869     return(test_ret);
38870 }
38871
38872
38873 static int
38874 test_xmlUCSIsCatSc(void) {
38875     int test_ret = 0;
38876
38877 #if defined(LIBXML_UNICODE_ENABLED)
38878     int mem_base;
38879     int ret_val;
38880     int code; /* UCS code point */
38881     int n_code;
38882
38883     for (n_code = 0;n_code < gen_nb_int;n_code++) {
38884         mem_base = xmlMemBlocks();
38885         code = gen_int(n_code, 0);
38886
38887         ret_val = xmlUCSIsCatSc(code);
38888         desret_int(ret_val);
38889         call_tests++;
38890         des_int(n_code, code, 0);
38891         xmlResetLastError();
38892         if (mem_base != xmlMemBlocks()) {
38893             printf("Leak of %d blocks found in xmlUCSIsCatSc",
38894                    xmlMemBlocks() - mem_base);
38895             test_ret++;
38896             printf(" %d", n_code);
38897             printf("\n");
38898         }
38899     }
38900     function_tests++;
38901 #endif
38902
38903     return(test_ret);
38904 }
38905
38906
38907 static int
38908 test_xmlUCSIsCatSk(void) {
38909     int test_ret = 0;
38910
38911 #if defined(LIBXML_UNICODE_ENABLED)
38912     int mem_base;
38913     int ret_val;
38914     int code; /* UCS code point */
38915     int n_code;
38916
38917     for (n_code = 0;n_code < gen_nb_int;n_code++) {
38918         mem_base = xmlMemBlocks();
38919         code = gen_int(n_code, 0);
38920
38921         ret_val = xmlUCSIsCatSk(code);
38922         desret_int(ret_val);
38923         call_tests++;
38924         des_int(n_code, code, 0);
38925         xmlResetLastError();
38926         if (mem_base != xmlMemBlocks()) {
38927             printf("Leak of %d blocks found in xmlUCSIsCatSk",
38928                    xmlMemBlocks() - mem_base);
38929             test_ret++;
38930             printf(" %d", n_code);
38931             printf("\n");
38932         }
38933     }
38934     function_tests++;
38935 #endif
38936
38937     return(test_ret);
38938 }
38939
38940
38941 static int
38942 test_xmlUCSIsCatSm(void) {
38943     int test_ret = 0;
38944
38945 #if defined(LIBXML_UNICODE_ENABLED)
38946     int mem_base;
38947     int ret_val;
38948     int code; /* UCS code point */
38949     int n_code;
38950
38951     for (n_code = 0;n_code < gen_nb_int;n_code++) {
38952         mem_base = xmlMemBlocks();
38953         code = gen_int(n_code, 0);
38954
38955         ret_val = xmlUCSIsCatSm(code);
38956         desret_int(ret_val);
38957         call_tests++;
38958         des_int(n_code, code, 0);
38959         xmlResetLastError();
38960         if (mem_base != xmlMemBlocks()) {
38961             printf("Leak of %d blocks found in xmlUCSIsCatSm",
38962                    xmlMemBlocks() - mem_base);
38963             test_ret++;
38964             printf(" %d", n_code);
38965             printf("\n");
38966         }
38967     }
38968     function_tests++;
38969 #endif
38970
38971     return(test_ret);
38972 }
38973
38974
38975 static int
38976 test_xmlUCSIsCatSo(void) {
38977     int test_ret = 0;
38978
38979 #if defined(LIBXML_UNICODE_ENABLED)
38980     int mem_base;
38981     int ret_val;
38982     int code; /* UCS code point */
38983     int n_code;
38984
38985     for (n_code = 0;n_code < gen_nb_int;n_code++) {
38986         mem_base = xmlMemBlocks();
38987         code = gen_int(n_code, 0);
38988
38989         ret_val = xmlUCSIsCatSo(code);
38990         desret_int(ret_val);
38991         call_tests++;
38992         des_int(n_code, code, 0);
38993         xmlResetLastError();
38994         if (mem_base != xmlMemBlocks()) {
38995             printf("Leak of %d blocks found in xmlUCSIsCatSo",
38996                    xmlMemBlocks() - mem_base);
38997             test_ret++;
38998             printf(" %d", n_code);
38999             printf("\n");
39000         }
39001     }
39002     function_tests++;
39003 #endif
39004
39005     return(test_ret);
39006 }
39007
39008
39009 static int
39010 test_xmlUCSIsCatZ(void) {
39011     int test_ret = 0;
39012
39013 #if defined(LIBXML_UNICODE_ENABLED)
39014     int mem_base;
39015     int ret_val;
39016     int code; /* UCS code point */
39017     int n_code;
39018
39019     for (n_code = 0;n_code < gen_nb_int;n_code++) {
39020         mem_base = xmlMemBlocks();
39021         code = gen_int(n_code, 0);
39022
39023         ret_val = xmlUCSIsCatZ(code);
39024         desret_int(ret_val);
39025         call_tests++;
39026         des_int(n_code, code, 0);
39027         xmlResetLastError();
39028         if (mem_base != xmlMemBlocks()) {
39029             printf("Leak of %d blocks found in xmlUCSIsCatZ",
39030                    xmlMemBlocks() - mem_base);
39031             test_ret++;
39032             printf(" %d", n_code);
39033             printf("\n");
39034         }
39035     }
39036     function_tests++;
39037 #endif
39038
39039     return(test_ret);
39040 }
39041
39042
39043 static int
39044 test_xmlUCSIsCatZl(void) {
39045     int test_ret = 0;
39046
39047 #if defined(LIBXML_UNICODE_ENABLED)
39048     int mem_base;
39049     int ret_val;
39050     int code; /* UCS code point */
39051     int n_code;
39052
39053     for (n_code = 0;n_code < gen_nb_int;n_code++) {
39054         mem_base = xmlMemBlocks();
39055         code = gen_int(n_code, 0);
39056
39057         ret_val = xmlUCSIsCatZl(code);
39058         desret_int(ret_val);
39059         call_tests++;
39060         des_int(n_code, code, 0);
39061         xmlResetLastError();
39062         if (mem_base != xmlMemBlocks()) {
39063             printf("Leak of %d blocks found in xmlUCSIsCatZl",
39064                    xmlMemBlocks() - mem_base);
39065             test_ret++;
39066             printf(" %d", n_code);
39067             printf("\n");
39068         }
39069     }
39070     function_tests++;
39071 #endif
39072
39073     return(test_ret);
39074 }
39075
39076
39077 static int
39078 test_xmlUCSIsCatZp(void) {
39079     int test_ret = 0;
39080
39081 #if defined(LIBXML_UNICODE_ENABLED)
39082     int mem_base;
39083     int ret_val;
39084     int code; /* UCS code point */
39085     int n_code;
39086
39087     for (n_code = 0;n_code < gen_nb_int;n_code++) {
39088         mem_base = xmlMemBlocks();
39089         code = gen_int(n_code, 0);
39090
39091         ret_val = xmlUCSIsCatZp(code);
39092         desret_int(ret_val);
39093         call_tests++;
39094         des_int(n_code, code, 0);
39095         xmlResetLastError();
39096         if (mem_base != xmlMemBlocks()) {
39097             printf("Leak of %d blocks found in xmlUCSIsCatZp",
39098                    xmlMemBlocks() - mem_base);
39099             test_ret++;
39100             printf(" %d", n_code);
39101             printf("\n");
39102         }
39103     }
39104     function_tests++;
39105 #endif
39106
39107     return(test_ret);
39108 }
39109
39110
39111 static int
39112 test_xmlUCSIsCatZs(void) {
39113     int test_ret = 0;
39114
39115 #if defined(LIBXML_UNICODE_ENABLED)
39116     int mem_base;
39117     int ret_val;
39118     int code; /* UCS code point */
39119     int n_code;
39120
39121     for (n_code = 0;n_code < gen_nb_int;n_code++) {
39122         mem_base = xmlMemBlocks();
39123         code = gen_int(n_code, 0);
39124
39125         ret_val = xmlUCSIsCatZs(code);
39126         desret_int(ret_val);
39127         call_tests++;
39128         des_int(n_code, code, 0);
39129         xmlResetLastError();
39130         if (mem_base != xmlMemBlocks()) {
39131             printf("Leak of %d blocks found in xmlUCSIsCatZs",
39132                    xmlMemBlocks() - mem_base);
39133             test_ret++;
39134             printf(" %d", n_code);
39135             printf("\n");
39136         }
39137     }
39138     function_tests++;
39139 #endif
39140
39141     return(test_ret);
39142 }
39143
39144
39145 static int
39146 test_xmlUCSIsCherokee(void) {
39147     int test_ret = 0;
39148
39149 #if defined(LIBXML_UNICODE_ENABLED)
39150     int mem_base;
39151     int ret_val;
39152     int code; /* UCS code point */
39153     int n_code;
39154
39155     for (n_code = 0;n_code < gen_nb_int;n_code++) {
39156         mem_base = xmlMemBlocks();
39157         code = gen_int(n_code, 0);
39158
39159         ret_val = xmlUCSIsCherokee(code);
39160         desret_int(ret_val);
39161         call_tests++;
39162         des_int(n_code, code, 0);
39163         xmlResetLastError();
39164         if (mem_base != xmlMemBlocks()) {
39165             printf("Leak of %d blocks found in xmlUCSIsCherokee",
39166                    xmlMemBlocks() - mem_base);
39167             test_ret++;
39168             printf(" %d", n_code);
39169             printf("\n");
39170         }
39171     }
39172     function_tests++;
39173 #endif
39174
39175     return(test_ret);
39176 }
39177
39178
39179 static int
39180 test_xmlUCSIsCombiningDiacriticalMarks(void) {
39181     int test_ret = 0;
39182
39183 #if defined(LIBXML_UNICODE_ENABLED)
39184     int mem_base;
39185     int ret_val;
39186     int code; /* UCS code point */
39187     int n_code;
39188
39189     for (n_code = 0;n_code < gen_nb_int;n_code++) {
39190         mem_base = xmlMemBlocks();
39191         code = gen_int(n_code, 0);
39192
39193         ret_val = xmlUCSIsCombiningDiacriticalMarks(code);
39194         desret_int(ret_val);
39195         call_tests++;
39196         des_int(n_code, code, 0);
39197         xmlResetLastError();
39198         if (mem_base != xmlMemBlocks()) {
39199             printf("Leak of %d blocks found in xmlUCSIsCombiningDiacriticalMarks",
39200                    xmlMemBlocks() - mem_base);
39201             test_ret++;
39202             printf(" %d", n_code);
39203             printf("\n");
39204         }
39205     }
39206     function_tests++;
39207 #endif
39208
39209     return(test_ret);
39210 }
39211
39212
39213 static int
39214 test_xmlUCSIsCombiningDiacriticalMarksforSymbols(void) {
39215     int test_ret = 0;
39216
39217 #if defined(LIBXML_UNICODE_ENABLED)
39218     int mem_base;
39219     int ret_val;
39220     int code; /* UCS code point */
39221     int n_code;
39222
39223     for (n_code = 0;n_code < gen_nb_int;n_code++) {
39224         mem_base = xmlMemBlocks();
39225         code = gen_int(n_code, 0);
39226
39227         ret_val = xmlUCSIsCombiningDiacriticalMarksforSymbols(code);
39228         desret_int(ret_val);
39229         call_tests++;
39230         des_int(n_code, code, 0);
39231         xmlResetLastError();
39232         if (mem_base != xmlMemBlocks()) {
39233             printf("Leak of %d blocks found in xmlUCSIsCombiningDiacriticalMarksforSymbols",
39234                    xmlMemBlocks() - mem_base);
39235             test_ret++;
39236             printf(" %d", n_code);
39237             printf("\n");
39238         }
39239     }
39240     function_tests++;
39241 #endif
39242
39243     return(test_ret);
39244 }
39245
39246
39247 static int
39248 test_xmlUCSIsCombiningHalfMarks(void) {
39249     int test_ret = 0;
39250
39251 #if defined(LIBXML_UNICODE_ENABLED)
39252     int mem_base;
39253     int ret_val;
39254     int code; /* UCS code point */
39255     int n_code;
39256
39257     for (n_code = 0;n_code < gen_nb_int;n_code++) {
39258         mem_base = xmlMemBlocks();
39259         code = gen_int(n_code, 0);
39260
39261         ret_val = xmlUCSIsCombiningHalfMarks(code);
39262         desret_int(ret_val);
39263         call_tests++;
39264         des_int(n_code, code, 0);
39265         xmlResetLastError();
39266         if (mem_base != xmlMemBlocks()) {
39267             printf("Leak of %d blocks found in xmlUCSIsCombiningHalfMarks",
39268                    xmlMemBlocks() - mem_base);
39269             test_ret++;
39270             printf(" %d", n_code);
39271             printf("\n");
39272         }
39273     }
39274     function_tests++;
39275 #endif
39276
39277     return(test_ret);
39278 }
39279
39280
39281 static int
39282 test_xmlUCSIsCombiningMarksforSymbols(void) {
39283     int test_ret = 0;
39284
39285 #if defined(LIBXML_UNICODE_ENABLED)
39286     int mem_base;
39287     int ret_val;
39288     int code; /* UCS code point */
39289     int n_code;
39290
39291     for (n_code = 0;n_code < gen_nb_int;n_code++) {
39292         mem_base = xmlMemBlocks();
39293         code = gen_int(n_code, 0);
39294
39295         ret_val = xmlUCSIsCombiningMarksforSymbols(code);
39296         desret_int(ret_val);
39297         call_tests++;
39298         des_int(n_code, code, 0);
39299         xmlResetLastError();
39300         if (mem_base != xmlMemBlocks()) {
39301             printf("Leak of %d blocks found in xmlUCSIsCombiningMarksforSymbols",
39302                    xmlMemBlocks() - mem_base);
39303             test_ret++;
39304             printf(" %d", n_code);
39305             printf("\n");
39306         }
39307     }
39308     function_tests++;
39309 #endif
39310
39311     return(test_ret);
39312 }
39313
39314
39315 static int
39316 test_xmlUCSIsControlPictures(void) {
39317     int test_ret = 0;
39318
39319 #if defined(LIBXML_UNICODE_ENABLED)
39320     int mem_base;
39321     int ret_val;
39322     int code; /* UCS code point */
39323     int n_code;
39324
39325     for (n_code = 0;n_code < gen_nb_int;n_code++) {
39326         mem_base = xmlMemBlocks();
39327         code = gen_int(n_code, 0);
39328
39329         ret_val = xmlUCSIsControlPictures(code);
39330         desret_int(ret_val);
39331         call_tests++;
39332         des_int(n_code, code, 0);
39333         xmlResetLastError();
39334         if (mem_base != xmlMemBlocks()) {
39335             printf("Leak of %d blocks found in xmlUCSIsControlPictures",
39336                    xmlMemBlocks() - mem_base);
39337             test_ret++;
39338             printf(" %d", n_code);
39339             printf("\n");
39340         }
39341     }
39342     function_tests++;
39343 #endif
39344
39345     return(test_ret);
39346 }
39347
39348
39349 static int
39350 test_xmlUCSIsCurrencySymbols(void) {
39351     int test_ret = 0;
39352
39353 #if defined(LIBXML_UNICODE_ENABLED)
39354     int mem_base;
39355     int ret_val;
39356     int code; /* UCS code point */
39357     int n_code;
39358
39359     for (n_code = 0;n_code < gen_nb_int;n_code++) {
39360         mem_base = xmlMemBlocks();
39361         code = gen_int(n_code, 0);
39362
39363         ret_val = xmlUCSIsCurrencySymbols(code);
39364         desret_int(ret_val);
39365         call_tests++;
39366         des_int(n_code, code, 0);
39367         xmlResetLastError();
39368         if (mem_base != xmlMemBlocks()) {
39369             printf("Leak of %d blocks found in xmlUCSIsCurrencySymbols",
39370                    xmlMemBlocks() - mem_base);
39371             test_ret++;
39372             printf(" %d", n_code);
39373             printf("\n");
39374         }
39375     }
39376     function_tests++;
39377 #endif
39378
39379     return(test_ret);
39380 }
39381
39382
39383 static int
39384 test_xmlUCSIsCypriotSyllabary(void) {
39385     int test_ret = 0;
39386
39387 #if defined(LIBXML_UNICODE_ENABLED)
39388     int mem_base;
39389     int ret_val;
39390     int code; /* UCS code point */
39391     int n_code;
39392
39393     for (n_code = 0;n_code < gen_nb_int;n_code++) {
39394         mem_base = xmlMemBlocks();
39395         code = gen_int(n_code, 0);
39396
39397         ret_val = xmlUCSIsCypriotSyllabary(code);
39398         desret_int(ret_val);
39399         call_tests++;
39400         des_int(n_code, code, 0);
39401         xmlResetLastError();
39402         if (mem_base != xmlMemBlocks()) {
39403             printf("Leak of %d blocks found in xmlUCSIsCypriotSyllabary",
39404                    xmlMemBlocks() - mem_base);
39405             test_ret++;
39406             printf(" %d", n_code);
39407             printf("\n");
39408         }
39409     }
39410     function_tests++;
39411 #endif
39412
39413     return(test_ret);
39414 }
39415
39416
39417 static int
39418 test_xmlUCSIsCyrillic(void) {
39419     int test_ret = 0;
39420
39421 #if defined(LIBXML_UNICODE_ENABLED)
39422     int mem_base;
39423     int ret_val;
39424     int code; /* UCS code point */
39425     int n_code;
39426
39427     for (n_code = 0;n_code < gen_nb_int;n_code++) {
39428         mem_base = xmlMemBlocks();
39429         code = gen_int(n_code, 0);
39430
39431         ret_val = xmlUCSIsCyrillic(code);
39432         desret_int(ret_val);
39433         call_tests++;
39434         des_int(n_code, code, 0);
39435         xmlResetLastError();
39436         if (mem_base != xmlMemBlocks()) {
39437             printf("Leak of %d blocks found in xmlUCSIsCyrillic",
39438                    xmlMemBlocks() - mem_base);
39439             test_ret++;
39440             printf(" %d", n_code);
39441             printf("\n");
39442         }
39443     }
39444     function_tests++;
39445 #endif
39446
39447     return(test_ret);
39448 }
39449
39450
39451 static int
39452 test_xmlUCSIsCyrillicSupplement(void) {
39453     int test_ret = 0;
39454
39455 #if defined(LIBXML_UNICODE_ENABLED)
39456     int mem_base;
39457     int ret_val;
39458     int code; /* UCS code point */
39459     int n_code;
39460
39461     for (n_code = 0;n_code < gen_nb_int;n_code++) {
39462         mem_base = xmlMemBlocks();
39463         code = gen_int(n_code, 0);
39464
39465         ret_val = xmlUCSIsCyrillicSupplement(code);
39466         desret_int(ret_val);
39467         call_tests++;
39468         des_int(n_code, code, 0);
39469         xmlResetLastError();
39470         if (mem_base != xmlMemBlocks()) {
39471             printf("Leak of %d blocks found in xmlUCSIsCyrillicSupplement",
39472                    xmlMemBlocks() - mem_base);
39473             test_ret++;
39474             printf(" %d", n_code);
39475             printf("\n");
39476         }
39477     }
39478     function_tests++;
39479 #endif
39480
39481     return(test_ret);
39482 }
39483
39484
39485 static int
39486 test_xmlUCSIsDeseret(void) {
39487     int test_ret = 0;
39488
39489 #if defined(LIBXML_UNICODE_ENABLED)
39490     int mem_base;
39491     int ret_val;
39492     int code; /* UCS code point */
39493     int n_code;
39494
39495     for (n_code = 0;n_code < gen_nb_int;n_code++) {
39496         mem_base = xmlMemBlocks();
39497         code = gen_int(n_code, 0);
39498
39499         ret_val = xmlUCSIsDeseret(code);
39500         desret_int(ret_val);
39501         call_tests++;
39502         des_int(n_code, code, 0);
39503         xmlResetLastError();
39504         if (mem_base != xmlMemBlocks()) {
39505             printf("Leak of %d blocks found in xmlUCSIsDeseret",
39506                    xmlMemBlocks() - mem_base);
39507             test_ret++;
39508             printf(" %d", n_code);
39509             printf("\n");
39510         }
39511     }
39512     function_tests++;
39513 #endif
39514
39515     return(test_ret);
39516 }
39517
39518
39519 static int
39520 test_xmlUCSIsDevanagari(void) {
39521     int test_ret = 0;
39522
39523 #if defined(LIBXML_UNICODE_ENABLED)
39524     int mem_base;
39525     int ret_val;
39526     int code; /* UCS code point */
39527     int n_code;
39528
39529     for (n_code = 0;n_code < gen_nb_int;n_code++) {
39530         mem_base = xmlMemBlocks();
39531         code = gen_int(n_code, 0);
39532
39533         ret_val = xmlUCSIsDevanagari(code);
39534         desret_int(ret_val);
39535         call_tests++;
39536         des_int(n_code, code, 0);
39537         xmlResetLastError();
39538         if (mem_base != xmlMemBlocks()) {
39539             printf("Leak of %d blocks found in xmlUCSIsDevanagari",
39540                    xmlMemBlocks() - mem_base);
39541             test_ret++;
39542             printf(" %d", n_code);
39543             printf("\n");
39544         }
39545     }
39546     function_tests++;
39547 #endif
39548
39549     return(test_ret);
39550 }
39551
39552
39553 static int
39554 test_xmlUCSIsDingbats(void) {
39555     int test_ret = 0;
39556
39557 #if defined(LIBXML_UNICODE_ENABLED)
39558     int mem_base;
39559     int ret_val;
39560     int code; /* UCS code point */
39561     int n_code;
39562
39563     for (n_code = 0;n_code < gen_nb_int;n_code++) {
39564         mem_base = xmlMemBlocks();
39565         code = gen_int(n_code, 0);
39566
39567         ret_val = xmlUCSIsDingbats(code);
39568         desret_int(ret_val);
39569         call_tests++;
39570         des_int(n_code, code, 0);
39571         xmlResetLastError();
39572         if (mem_base != xmlMemBlocks()) {
39573             printf("Leak of %d blocks found in xmlUCSIsDingbats",
39574                    xmlMemBlocks() - mem_base);
39575             test_ret++;
39576             printf(" %d", n_code);
39577             printf("\n");
39578         }
39579     }
39580     function_tests++;
39581 #endif
39582
39583     return(test_ret);
39584 }
39585
39586
39587 static int
39588 test_xmlUCSIsEnclosedAlphanumerics(void) {
39589     int test_ret = 0;
39590
39591 #if defined(LIBXML_UNICODE_ENABLED)
39592     int mem_base;
39593     int ret_val;
39594     int code; /* UCS code point */
39595     int n_code;
39596
39597     for (n_code = 0;n_code < gen_nb_int;n_code++) {
39598         mem_base = xmlMemBlocks();
39599         code = gen_int(n_code, 0);
39600
39601         ret_val = xmlUCSIsEnclosedAlphanumerics(code);
39602         desret_int(ret_val);
39603         call_tests++;
39604         des_int(n_code, code, 0);
39605         xmlResetLastError();
39606         if (mem_base != xmlMemBlocks()) {
39607             printf("Leak of %d blocks found in xmlUCSIsEnclosedAlphanumerics",
39608                    xmlMemBlocks() - mem_base);
39609             test_ret++;
39610             printf(" %d", n_code);
39611             printf("\n");
39612         }
39613     }
39614     function_tests++;
39615 #endif
39616
39617     return(test_ret);
39618 }
39619
39620
39621 static int
39622 test_xmlUCSIsEnclosedCJKLettersandMonths(void) {
39623     int test_ret = 0;
39624
39625 #if defined(LIBXML_UNICODE_ENABLED)
39626     int mem_base;
39627     int ret_val;
39628     int code; /* UCS code point */
39629     int n_code;
39630
39631     for (n_code = 0;n_code < gen_nb_int;n_code++) {
39632         mem_base = xmlMemBlocks();
39633         code = gen_int(n_code, 0);
39634
39635         ret_val = xmlUCSIsEnclosedCJKLettersandMonths(code);
39636         desret_int(ret_val);
39637         call_tests++;
39638         des_int(n_code, code, 0);
39639         xmlResetLastError();
39640         if (mem_base != xmlMemBlocks()) {
39641             printf("Leak of %d blocks found in xmlUCSIsEnclosedCJKLettersandMonths",
39642                    xmlMemBlocks() - mem_base);
39643             test_ret++;
39644             printf(" %d", n_code);
39645             printf("\n");
39646         }
39647     }
39648     function_tests++;
39649 #endif
39650
39651     return(test_ret);
39652 }
39653
39654
39655 static int
39656 test_xmlUCSIsEthiopic(void) {
39657     int test_ret = 0;
39658
39659 #if defined(LIBXML_UNICODE_ENABLED)
39660     int mem_base;
39661     int ret_val;
39662     int code; /* UCS code point */
39663     int n_code;
39664
39665     for (n_code = 0;n_code < gen_nb_int;n_code++) {
39666         mem_base = xmlMemBlocks();
39667         code = gen_int(n_code, 0);
39668
39669         ret_val = xmlUCSIsEthiopic(code);
39670         desret_int(ret_val);
39671         call_tests++;
39672         des_int(n_code, code, 0);
39673         xmlResetLastError();
39674         if (mem_base != xmlMemBlocks()) {
39675             printf("Leak of %d blocks found in xmlUCSIsEthiopic",
39676                    xmlMemBlocks() - mem_base);
39677             test_ret++;
39678             printf(" %d", n_code);
39679             printf("\n");
39680         }
39681     }
39682     function_tests++;
39683 #endif
39684
39685     return(test_ret);
39686 }
39687
39688
39689 static int
39690 test_xmlUCSIsGeneralPunctuation(void) {
39691     int test_ret = 0;
39692
39693 #if defined(LIBXML_UNICODE_ENABLED)
39694     int mem_base;
39695     int ret_val;
39696     int code; /* UCS code point */
39697     int n_code;
39698
39699     for (n_code = 0;n_code < gen_nb_int;n_code++) {
39700         mem_base = xmlMemBlocks();
39701         code = gen_int(n_code, 0);
39702
39703         ret_val = xmlUCSIsGeneralPunctuation(code);
39704         desret_int(ret_val);
39705         call_tests++;
39706         des_int(n_code, code, 0);
39707         xmlResetLastError();
39708         if (mem_base != xmlMemBlocks()) {
39709             printf("Leak of %d blocks found in xmlUCSIsGeneralPunctuation",
39710                    xmlMemBlocks() - mem_base);
39711             test_ret++;
39712             printf(" %d", n_code);
39713             printf("\n");
39714         }
39715     }
39716     function_tests++;
39717 #endif
39718
39719     return(test_ret);
39720 }
39721
39722
39723 static int
39724 test_xmlUCSIsGeometricShapes(void) {
39725     int test_ret = 0;
39726
39727 #if defined(LIBXML_UNICODE_ENABLED)
39728     int mem_base;
39729     int ret_val;
39730     int code; /* UCS code point */
39731     int n_code;
39732
39733     for (n_code = 0;n_code < gen_nb_int;n_code++) {
39734         mem_base = xmlMemBlocks();
39735         code = gen_int(n_code, 0);
39736
39737         ret_val = xmlUCSIsGeometricShapes(code);
39738         desret_int(ret_val);
39739         call_tests++;
39740         des_int(n_code, code, 0);
39741         xmlResetLastError();
39742         if (mem_base != xmlMemBlocks()) {
39743             printf("Leak of %d blocks found in xmlUCSIsGeometricShapes",
39744                    xmlMemBlocks() - mem_base);
39745             test_ret++;
39746             printf(" %d", n_code);
39747             printf("\n");
39748         }
39749     }
39750     function_tests++;
39751 #endif
39752
39753     return(test_ret);
39754 }
39755
39756
39757 static int
39758 test_xmlUCSIsGeorgian(void) {
39759     int test_ret = 0;
39760
39761 #if defined(LIBXML_UNICODE_ENABLED)
39762     int mem_base;
39763     int ret_val;
39764     int code; /* UCS code point */
39765     int n_code;
39766
39767     for (n_code = 0;n_code < gen_nb_int;n_code++) {
39768         mem_base = xmlMemBlocks();
39769         code = gen_int(n_code, 0);
39770
39771         ret_val = xmlUCSIsGeorgian(code);
39772         desret_int(ret_val);
39773         call_tests++;
39774         des_int(n_code, code, 0);
39775         xmlResetLastError();
39776         if (mem_base != xmlMemBlocks()) {
39777             printf("Leak of %d blocks found in xmlUCSIsGeorgian",
39778                    xmlMemBlocks() - mem_base);
39779             test_ret++;
39780             printf(" %d", n_code);
39781             printf("\n");
39782         }
39783     }
39784     function_tests++;
39785 #endif
39786
39787     return(test_ret);
39788 }
39789
39790
39791 static int
39792 test_xmlUCSIsGothic(void) {
39793     int test_ret = 0;
39794
39795 #if defined(LIBXML_UNICODE_ENABLED)
39796     int mem_base;
39797     int ret_val;
39798     int code; /* UCS code point */
39799     int n_code;
39800
39801     for (n_code = 0;n_code < gen_nb_int;n_code++) {
39802         mem_base = xmlMemBlocks();
39803         code = gen_int(n_code, 0);
39804
39805         ret_val = xmlUCSIsGothic(code);
39806         desret_int(ret_val);
39807         call_tests++;
39808         des_int(n_code, code, 0);
39809         xmlResetLastError();
39810         if (mem_base != xmlMemBlocks()) {
39811             printf("Leak of %d blocks found in xmlUCSIsGothic",
39812                    xmlMemBlocks() - mem_base);
39813             test_ret++;
39814             printf(" %d", n_code);
39815             printf("\n");
39816         }
39817     }
39818     function_tests++;
39819 #endif
39820
39821     return(test_ret);
39822 }
39823
39824
39825 static int
39826 test_xmlUCSIsGreek(void) {
39827     int test_ret = 0;
39828
39829 #if defined(LIBXML_UNICODE_ENABLED)
39830     int mem_base;
39831     int ret_val;
39832     int code; /* UCS code point */
39833     int n_code;
39834
39835     for (n_code = 0;n_code < gen_nb_int;n_code++) {
39836         mem_base = xmlMemBlocks();
39837         code = gen_int(n_code, 0);
39838
39839         ret_val = xmlUCSIsGreek(code);
39840         desret_int(ret_val);
39841         call_tests++;
39842         des_int(n_code, code, 0);
39843         xmlResetLastError();
39844         if (mem_base != xmlMemBlocks()) {
39845             printf("Leak of %d blocks found in xmlUCSIsGreek",
39846                    xmlMemBlocks() - mem_base);
39847             test_ret++;
39848             printf(" %d", n_code);
39849             printf("\n");
39850         }
39851     }
39852     function_tests++;
39853 #endif
39854
39855     return(test_ret);
39856 }
39857
39858
39859 static int
39860 test_xmlUCSIsGreekExtended(void) {
39861     int test_ret = 0;
39862
39863 #if defined(LIBXML_UNICODE_ENABLED)
39864     int mem_base;
39865     int ret_val;
39866     int code; /* UCS code point */
39867     int n_code;
39868
39869     for (n_code = 0;n_code < gen_nb_int;n_code++) {
39870         mem_base = xmlMemBlocks();
39871         code = gen_int(n_code, 0);
39872
39873         ret_val = xmlUCSIsGreekExtended(code);
39874         desret_int(ret_val);
39875         call_tests++;
39876         des_int(n_code, code, 0);
39877         xmlResetLastError();
39878         if (mem_base != xmlMemBlocks()) {
39879             printf("Leak of %d blocks found in xmlUCSIsGreekExtended",
39880                    xmlMemBlocks() - mem_base);
39881             test_ret++;
39882             printf(" %d", n_code);
39883             printf("\n");
39884         }
39885     }
39886     function_tests++;
39887 #endif
39888
39889     return(test_ret);
39890 }
39891
39892
39893 static int
39894 test_xmlUCSIsGreekandCoptic(void) {
39895     int test_ret = 0;
39896
39897 #if defined(LIBXML_UNICODE_ENABLED)
39898     int mem_base;
39899     int ret_val;
39900     int code; /* UCS code point */
39901     int n_code;
39902
39903     for (n_code = 0;n_code < gen_nb_int;n_code++) {
39904         mem_base = xmlMemBlocks();
39905         code = gen_int(n_code, 0);
39906
39907         ret_val = xmlUCSIsGreekandCoptic(code);
39908         desret_int(ret_val);
39909         call_tests++;
39910         des_int(n_code, code, 0);
39911         xmlResetLastError();
39912         if (mem_base != xmlMemBlocks()) {
39913             printf("Leak of %d blocks found in xmlUCSIsGreekandCoptic",
39914                    xmlMemBlocks() - mem_base);
39915             test_ret++;
39916             printf(" %d", n_code);
39917             printf("\n");
39918         }
39919     }
39920     function_tests++;
39921 #endif
39922
39923     return(test_ret);
39924 }
39925
39926
39927 static int
39928 test_xmlUCSIsGujarati(void) {
39929     int test_ret = 0;
39930
39931 #if defined(LIBXML_UNICODE_ENABLED)
39932     int mem_base;
39933     int ret_val;
39934     int code; /* UCS code point */
39935     int n_code;
39936
39937     for (n_code = 0;n_code < gen_nb_int;n_code++) {
39938         mem_base = xmlMemBlocks();
39939         code = gen_int(n_code, 0);
39940
39941         ret_val = xmlUCSIsGujarati(code);
39942         desret_int(ret_val);
39943         call_tests++;
39944         des_int(n_code, code, 0);
39945         xmlResetLastError();
39946         if (mem_base != xmlMemBlocks()) {
39947             printf("Leak of %d blocks found in xmlUCSIsGujarati",
39948                    xmlMemBlocks() - mem_base);
39949             test_ret++;
39950             printf(" %d", n_code);
39951             printf("\n");
39952         }
39953     }
39954     function_tests++;
39955 #endif
39956
39957     return(test_ret);
39958 }
39959
39960
39961 static int
39962 test_xmlUCSIsGurmukhi(void) {
39963     int test_ret = 0;
39964
39965 #if defined(LIBXML_UNICODE_ENABLED)
39966     int mem_base;
39967     int ret_val;
39968     int code; /* UCS code point */
39969     int n_code;
39970
39971     for (n_code = 0;n_code < gen_nb_int;n_code++) {
39972         mem_base = xmlMemBlocks();
39973         code = gen_int(n_code, 0);
39974
39975         ret_val = xmlUCSIsGurmukhi(code);
39976         desret_int(ret_val);
39977         call_tests++;
39978         des_int(n_code, code, 0);
39979         xmlResetLastError();
39980         if (mem_base != xmlMemBlocks()) {
39981             printf("Leak of %d blocks found in xmlUCSIsGurmukhi",
39982                    xmlMemBlocks() - mem_base);
39983             test_ret++;
39984             printf(" %d", n_code);
39985             printf("\n");
39986         }
39987     }
39988     function_tests++;
39989 #endif
39990
39991     return(test_ret);
39992 }
39993
39994
39995 static int
39996 test_xmlUCSIsHalfwidthandFullwidthForms(void) {
39997     int test_ret = 0;
39998
39999 #if defined(LIBXML_UNICODE_ENABLED)
40000     int mem_base;
40001     int ret_val;
40002     int code; /* UCS code point */
40003     int n_code;
40004
40005     for (n_code = 0;n_code < gen_nb_int;n_code++) {
40006         mem_base = xmlMemBlocks();
40007         code = gen_int(n_code, 0);
40008
40009         ret_val = xmlUCSIsHalfwidthandFullwidthForms(code);
40010         desret_int(ret_val);
40011         call_tests++;
40012         des_int(n_code, code, 0);
40013         xmlResetLastError();
40014         if (mem_base != xmlMemBlocks()) {
40015             printf("Leak of %d blocks found in xmlUCSIsHalfwidthandFullwidthForms",
40016                    xmlMemBlocks() - mem_base);
40017             test_ret++;
40018             printf(" %d", n_code);
40019             printf("\n");
40020         }
40021     }
40022     function_tests++;
40023 #endif
40024
40025     return(test_ret);
40026 }
40027
40028
40029 static int
40030 test_xmlUCSIsHangulCompatibilityJamo(void) {
40031     int test_ret = 0;
40032
40033 #if defined(LIBXML_UNICODE_ENABLED)
40034     int mem_base;
40035     int ret_val;
40036     int code; /* UCS code point */
40037     int n_code;
40038
40039     for (n_code = 0;n_code < gen_nb_int;n_code++) {
40040         mem_base = xmlMemBlocks();
40041         code = gen_int(n_code, 0);
40042
40043         ret_val = xmlUCSIsHangulCompatibilityJamo(code);
40044         desret_int(ret_val);
40045         call_tests++;
40046         des_int(n_code, code, 0);
40047         xmlResetLastError();
40048         if (mem_base != xmlMemBlocks()) {
40049             printf("Leak of %d blocks found in xmlUCSIsHangulCompatibilityJamo",
40050                    xmlMemBlocks() - mem_base);
40051             test_ret++;
40052             printf(" %d", n_code);
40053             printf("\n");
40054         }
40055     }
40056     function_tests++;
40057 #endif
40058
40059     return(test_ret);
40060 }
40061
40062
40063 static int
40064 test_xmlUCSIsHangulJamo(void) {
40065     int test_ret = 0;
40066
40067 #if defined(LIBXML_UNICODE_ENABLED)
40068     int mem_base;
40069     int ret_val;
40070     int code; /* UCS code point */
40071     int n_code;
40072
40073     for (n_code = 0;n_code < gen_nb_int;n_code++) {
40074         mem_base = xmlMemBlocks();
40075         code = gen_int(n_code, 0);
40076
40077         ret_val = xmlUCSIsHangulJamo(code);
40078         desret_int(ret_val);
40079         call_tests++;
40080         des_int(n_code, code, 0);
40081         xmlResetLastError();
40082         if (mem_base != xmlMemBlocks()) {
40083             printf("Leak of %d blocks found in xmlUCSIsHangulJamo",
40084                    xmlMemBlocks() - mem_base);
40085             test_ret++;
40086             printf(" %d", n_code);
40087             printf("\n");
40088         }
40089     }
40090     function_tests++;
40091 #endif
40092
40093     return(test_ret);
40094 }
40095
40096
40097 static int
40098 test_xmlUCSIsHangulSyllables(void) {
40099     int test_ret = 0;
40100
40101 #if defined(LIBXML_UNICODE_ENABLED)
40102     int mem_base;
40103     int ret_val;
40104     int code; /* UCS code point */
40105     int n_code;
40106
40107     for (n_code = 0;n_code < gen_nb_int;n_code++) {
40108         mem_base = xmlMemBlocks();
40109         code = gen_int(n_code, 0);
40110
40111         ret_val = xmlUCSIsHangulSyllables(code);
40112         desret_int(ret_val);
40113         call_tests++;
40114         des_int(n_code, code, 0);
40115         xmlResetLastError();
40116         if (mem_base != xmlMemBlocks()) {
40117             printf("Leak of %d blocks found in xmlUCSIsHangulSyllables",
40118                    xmlMemBlocks() - mem_base);
40119             test_ret++;
40120             printf(" %d", n_code);
40121             printf("\n");
40122         }
40123     }
40124     function_tests++;
40125 #endif
40126
40127     return(test_ret);
40128 }
40129
40130
40131 static int
40132 test_xmlUCSIsHanunoo(void) {
40133     int test_ret = 0;
40134
40135 #if defined(LIBXML_UNICODE_ENABLED)
40136     int mem_base;
40137     int ret_val;
40138     int code; /* UCS code point */
40139     int n_code;
40140
40141     for (n_code = 0;n_code < gen_nb_int;n_code++) {
40142         mem_base = xmlMemBlocks();
40143         code = gen_int(n_code, 0);
40144
40145         ret_val = xmlUCSIsHanunoo(code);
40146         desret_int(ret_val);
40147         call_tests++;
40148         des_int(n_code, code, 0);
40149         xmlResetLastError();
40150         if (mem_base != xmlMemBlocks()) {
40151             printf("Leak of %d blocks found in xmlUCSIsHanunoo",
40152                    xmlMemBlocks() - mem_base);
40153             test_ret++;
40154             printf(" %d", n_code);
40155             printf("\n");
40156         }
40157     }
40158     function_tests++;
40159 #endif
40160
40161     return(test_ret);
40162 }
40163
40164
40165 static int
40166 test_xmlUCSIsHebrew(void) {
40167     int test_ret = 0;
40168
40169 #if defined(LIBXML_UNICODE_ENABLED)
40170     int mem_base;
40171     int ret_val;
40172     int code; /* UCS code point */
40173     int n_code;
40174
40175     for (n_code = 0;n_code < gen_nb_int;n_code++) {
40176         mem_base = xmlMemBlocks();
40177         code = gen_int(n_code, 0);
40178
40179         ret_val = xmlUCSIsHebrew(code);
40180         desret_int(ret_val);
40181         call_tests++;
40182         des_int(n_code, code, 0);
40183         xmlResetLastError();
40184         if (mem_base != xmlMemBlocks()) {
40185             printf("Leak of %d blocks found in xmlUCSIsHebrew",
40186                    xmlMemBlocks() - mem_base);
40187             test_ret++;
40188             printf(" %d", n_code);
40189             printf("\n");
40190         }
40191     }
40192     function_tests++;
40193 #endif
40194
40195     return(test_ret);
40196 }
40197
40198
40199 static int
40200 test_xmlUCSIsHighPrivateUseSurrogates(void) {
40201     int test_ret = 0;
40202
40203 #if defined(LIBXML_UNICODE_ENABLED)
40204     int mem_base;
40205     int ret_val;
40206     int code; /* UCS code point */
40207     int n_code;
40208
40209     for (n_code = 0;n_code < gen_nb_int;n_code++) {
40210         mem_base = xmlMemBlocks();
40211         code = gen_int(n_code, 0);
40212
40213         ret_val = xmlUCSIsHighPrivateUseSurrogates(code);
40214         desret_int(ret_val);
40215         call_tests++;
40216         des_int(n_code, code, 0);
40217         xmlResetLastError();
40218         if (mem_base != xmlMemBlocks()) {
40219             printf("Leak of %d blocks found in xmlUCSIsHighPrivateUseSurrogates",
40220                    xmlMemBlocks() - mem_base);
40221             test_ret++;
40222             printf(" %d", n_code);
40223             printf("\n");
40224         }
40225     }
40226     function_tests++;
40227 #endif
40228
40229     return(test_ret);
40230 }
40231
40232
40233 static int
40234 test_xmlUCSIsHighSurrogates(void) {
40235     int test_ret = 0;
40236
40237 #if defined(LIBXML_UNICODE_ENABLED)
40238     int mem_base;
40239     int ret_val;
40240     int code; /* UCS code point */
40241     int n_code;
40242
40243     for (n_code = 0;n_code < gen_nb_int;n_code++) {
40244         mem_base = xmlMemBlocks();
40245         code = gen_int(n_code, 0);
40246
40247         ret_val = xmlUCSIsHighSurrogates(code);
40248         desret_int(ret_val);
40249         call_tests++;
40250         des_int(n_code, code, 0);
40251         xmlResetLastError();
40252         if (mem_base != xmlMemBlocks()) {
40253             printf("Leak of %d blocks found in xmlUCSIsHighSurrogates",
40254                    xmlMemBlocks() - mem_base);
40255             test_ret++;
40256             printf(" %d", n_code);
40257             printf("\n");
40258         }
40259     }
40260     function_tests++;
40261 #endif
40262
40263     return(test_ret);
40264 }
40265
40266
40267 static int
40268 test_xmlUCSIsHiragana(void) {
40269     int test_ret = 0;
40270
40271 #if defined(LIBXML_UNICODE_ENABLED)
40272     int mem_base;
40273     int ret_val;
40274     int code; /* UCS code point */
40275     int n_code;
40276
40277     for (n_code = 0;n_code < gen_nb_int;n_code++) {
40278         mem_base = xmlMemBlocks();
40279         code = gen_int(n_code, 0);
40280
40281         ret_val = xmlUCSIsHiragana(code);
40282         desret_int(ret_val);
40283         call_tests++;
40284         des_int(n_code, code, 0);
40285         xmlResetLastError();
40286         if (mem_base != xmlMemBlocks()) {
40287             printf("Leak of %d blocks found in xmlUCSIsHiragana",
40288                    xmlMemBlocks() - mem_base);
40289             test_ret++;
40290             printf(" %d", n_code);
40291             printf("\n");
40292         }
40293     }
40294     function_tests++;
40295 #endif
40296
40297     return(test_ret);
40298 }
40299
40300
40301 static int
40302 test_xmlUCSIsIPAExtensions(void) {
40303     int test_ret = 0;
40304
40305 #if defined(LIBXML_UNICODE_ENABLED)
40306     int mem_base;
40307     int ret_val;
40308     int code; /* UCS code point */
40309     int n_code;
40310
40311     for (n_code = 0;n_code < gen_nb_int;n_code++) {
40312         mem_base = xmlMemBlocks();
40313         code = gen_int(n_code, 0);
40314
40315         ret_val = xmlUCSIsIPAExtensions(code);
40316         desret_int(ret_val);
40317         call_tests++;
40318         des_int(n_code, code, 0);
40319         xmlResetLastError();
40320         if (mem_base != xmlMemBlocks()) {
40321             printf("Leak of %d blocks found in xmlUCSIsIPAExtensions",
40322                    xmlMemBlocks() - mem_base);
40323             test_ret++;
40324             printf(" %d", n_code);
40325             printf("\n");
40326         }
40327     }
40328     function_tests++;
40329 #endif
40330
40331     return(test_ret);
40332 }
40333
40334
40335 static int
40336 test_xmlUCSIsIdeographicDescriptionCharacters(void) {
40337     int test_ret = 0;
40338
40339 #if defined(LIBXML_UNICODE_ENABLED)
40340     int mem_base;
40341     int ret_val;
40342     int code; /* UCS code point */
40343     int n_code;
40344
40345     for (n_code = 0;n_code < gen_nb_int;n_code++) {
40346         mem_base = xmlMemBlocks();
40347         code = gen_int(n_code, 0);
40348
40349         ret_val = xmlUCSIsIdeographicDescriptionCharacters(code);
40350         desret_int(ret_val);
40351         call_tests++;
40352         des_int(n_code, code, 0);
40353         xmlResetLastError();
40354         if (mem_base != xmlMemBlocks()) {
40355             printf("Leak of %d blocks found in xmlUCSIsIdeographicDescriptionCharacters",
40356                    xmlMemBlocks() - mem_base);
40357             test_ret++;
40358             printf(" %d", n_code);
40359             printf("\n");
40360         }
40361     }
40362     function_tests++;
40363 #endif
40364
40365     return(test_ret);
40366 }
40367
40368
40369 static int
40370 test_xmlUCSIsKanbun(void) {
40371     int test_ret = 0;
40372
40373 #if defined(LIBXML_UNICODE_ENABLED)
40374     int mem_base;
40375     int ret_val;
40376     int code; /* UCS code point */
40377     int n_code;
40378
40379     for (n_code = 0;n_code < gen_nb_int;n_code++) {
40380         mem_base = xmlMemBlocks();
40381         code = gen_int(n_code, 0);
40382
40383         ret_val = xmlUCSIsKanbun(code);
40384         desret_int(ret_val);
40385         call_tests++;
40386         des_int(n_code, code, 0);
40387         xmlResetLastError();
40388         if (mem_base != xmlMemBlocks()) {
40389             printf("Leak of %d blocks found in xmlUCSIsKanbun",
40390                    xmlMemBlocks() - mem_base);
40391             test_ret++;
40392             printf(" %d", n_code);
40393             printf("\n");
40394         }
40395     }
40396     function_tests++;
40397 #endif
40398
40399     return(test_ret);
40400 }
40401
40402
40403 static int
40404 test_xmlUCSIsKangxiRadicals(void) {
40405     int test_ret = 0;
40406
40407 #if defined(LIBXML_UNICODE_ENABLED)
40408     int mem_base;
40409     int ret_val;
40410     int code; /* UCS code point */
40411     int n_code;
40412
40413     for (n_code = 0;n_code < gen_nb_int;n_code++) {
40414         mem_base = xmlMemBlocks();
40415         code = gen_int(n_code, 0);
40416
40417         ret_val = xmlUCSIsKangxiRadicals(code);
40418         desret_int(ret_val);
40419         call_tests++;
40420         des_int(n_code, code, 0);
40421         xmlResetLastError();
40422         if (mem_base != xmlMemBlocks()) {
40423             printf("Leak of %d blocks found in xmlUCSIsKangxiRadicals",
40424                    xmlMemBlocks() - mem_base);
40425             test_ret++;
40426             printf(" %d", n_code);
40427             printf("\n");
40428         }
40429     }
40430     function_tests++;
40431 #endif
40432
40433     return(test_ret);
40434 }
40435
40436
40437 static int
40438 test_xmlUCSIsKannada(void) {
40439     int test_ret = 0;
40440
40441 #if defined(LIBXML_UNICODE_ENABLED)
40442     int mem_base;
40443     int ret_val;
40444     int code; /* UCS code point */
40445     int n_code;
40446
40447     for (n_code = 0;n_code < gen_nb_int;n_code++) {
40448         mem_base = xmlMemBlocks();
40449         code = gen_int(n_code, 0);
40450
40451         ret_val = xmlUCSIsKannada(code);
40452         desret_int(ret_val);
40453         call_tests++;
40454         des_int(n_code, code, 0);
40455         xmlResetLastError();
40456         if (mem_base != xmlMemBlocks()) {
40457             printf("Leak of %d blocks found in xmlUCSIsKannada",
40458                    xmlMemBlocks() - mem_base);
40459             test_ret++;
40460             printf(" %d", n_code);
40461             printf("\n");
40462         }
40463     }
40464     function_tests++;
40465 #endif
40466
40467     return(test_ret);
40468 }
40469
40470
40471 static int
40472 test_xmlUCSIsKatakana(void) {
40473     int test_ret = 0;
40474
40475 #if defined(LIBXML_UNICODE_ENABLED)
40476     int mem_base;
40477     int ret_val;
40478     int code; /* UCS code point */
40479     int n_code;
40480
40481     for (n_code = 0;n_code < gen_nb_int;n_code++) {
40482         mem_base = xmlMemBlocks();
40483         code = gen_int(n_code, 0);
40484
40485         ret_val = xmlUCSIsKatakana(code);
40486         desret_int(ret_val);
40487         call_tests++;
40488         des_int(n_code, code, 0);
40489         xmlResetLastError();
40490         if (mem_base != xmlMemBlocks()) {
40491             printf("Leak of %d blocks found in xmlUCSIsKatakana",
40492                    xmlMemBlocks() - mem_base);
40493             test_ret++;
40494             printf(" %d", n_code);
40495             printf("\n");
40496         }
40497     }
40498     function_tests++;
40499 #endif
40500
40501     return(test_ret);
40502 }
40503
40504
40505 static int
40506 test_xmlUCSIsKatakanaPhoneticExtensions(void) {
40507     int test_ret = 0;
40508
40509 #if defined(LIBXML_UNICODE_ENABLED)
40510     int mem_base;
40511     int ret_val;
40512     int code; /* UCS code point */
40513     int n_code;
40514
40515     for (n_code = 0;n_code < gen_nb_int;n_code++) {
40516         mem_base = xmlMemBlocks();
40517         code = gen_int(n_code, 0);
40518
40519         ret_val = xmlUCSIsKatakanaPhoneticExtensions(code);
40520         desret_int(ret_val);
40521         call_tests++;
40522         des_int(n_code, code, 0);
40523         xmlResetLastError();
40524         if (mem_base != xmlMemBlocks()) {
40525             printf("Leak of %d blocks found in xmlUCSIsKatakanaPhoneticExtensions",
40526                    xmlMemBlocks() - mem_base);
40527             test_ret++;
40528             printf(" %d", n_code);
40529             printf("\n");
40530         }
40531     }
40532     function_tests++;
40533 #endif
40534
40535     return(test_ret);
40536 }
40537
40538
40539 static int
40540 test_xmlUCSIsKhmer(void) {
40541     int test_ret = 0;
40542
40543 #if defined(LIBXML_UNICODE_ENABLED)
40544     int mem_base;
40545     int ret_val;
40546     int code; /* UCS code point */
40547     int n_code;
40548
40549     for (n_code = 0;n_code < gen_nb_int;n_code++) {
40550         mem_base = xmlMemBlocks();
40551         code = gen_int(n_code, 0);
40552
40553         ret_val = xmlUCSIsKhmer(code);
40554         desret_int(ret_val);
40555         call_tests++;
40556         des_int(n_code, code, 0);
40557         xmlResetLastError();
40558         if (mem_base != xmlMemBlocks()) {
40559             printf("Leak of %d blocks found in xmlUCSIsKhmer",
40560                    xmlMemBlocks() - mem_base);
40561             test_ret++;
40562             printf(" %d", n_code);
40563             printf("\n");
40564         }
40565     }
40566     function_tests++;
40567 #endif
40568
40569     return(test_ret);
40570 }
40571
40572
40573 static int
40574 test_xmlUCSIsKhmerSymbols(void) {
40575     int test_ret = 0;
40576
40577 #if defined(LIBXML_UNICODE_ENABLED)
40578     int mem_base;
40579     int ret_val;
40580     int code; /* UCS code point */
40581     int n_code;
40582
40583     for (n_code = 0;n_code < gen_nb_int;n_code++) {
40584         mem_base = xmlMemBlocks();
40585         code = gen_int(n_code, 0);
40586
40587         ret_val = xmlUCSIsKhmerSymbols(code);
40588         desret_int(ret_val);
40589         call_tests++;
40590         des_int(n_code, code, 0);
40591         xmlResetLastError();
40592         if (mem_base != xmlMemBlocks()) {
40593             printf("Leak of %d blocks found in xmlUCSIsKhmerSymbols",
40594                    xmlMemBlocks() - mem_base);
40595             test_ret++;
40596             printf(" %d", n_code);
40597             printf("\n");
40598         }
40599     }
40600     function_tests++;
40601 #endif
40602
40603     return(test_ret);
40604 }
40605
40606
40607 static int
40608 test_xmlUCSIsLao(void) {
40609     int test_ret = 0;
40610
40611 #if defined(LIBXML_UNICODE_ENABLED)
40612     int mem_base;
40613     int ret_val;
40614     int code; /* UCS code point */
40615     int n_code;
40616
40617     for (n_code = 0;n_code < gen_nb_int;n_code++) {
40618         mem_base = xmlMemBlocks();
40619         code = gen_int(n_code, 0);
40620
40621         ret_val = xmlUCSIsLao(code);
40622         desret_int(ret_val);
40623         call_tests++;
40624         des_int(n_code, code, 0);
40625         xmlResetLastError();
40626         if (mem_base != xmlMemBlocks()) {
40627             printf("Leak of %d blocks found in xmlUCSIsLao",
40628                    xmlMemBlocks() - mem_base);
40629             test_ret++;
40630             printf(" %d", n_code);
40631             printf("\n");
40632         }
40633     }
40634     function_tests++;
40635 #endif
40636
40637     return(test_ret);
40638 }
40639
40640
40641 static int
40642 test_xmlUCSIsLatin1Supplement(void) {
40643     int test_ret = 0;
40644
40645 #if defined(LIBXML_UNICODE_ENABLED)
40646     int mem_base;
40647     int ret_val;
40648     int code; /* UCS code point */
40649     int n_code;
40650
40651     for (n_code = 0;n_code < gen_nb_int;n_code++) {
40652         mem_base = xmlMemBlocks();
40653         code = gen_int(n_code, 0);
40654
40655         ret_val = xmlUCSIsLatin1Supplement(code);
40656         desret_int(ret_val);
40657         call_tests++;
40658         des_int(n_code, code, 0);
40659         xmlResetLastError();
40660         if (mem_base != xmlMemBlocks()) {
40661             printf("Leak of %d blocks found in xmlUCSIsLatin1Supplement",
40662                    xmlMemBlocks() - mem_base);
40663             test_ret++;
40664             printf(" %d", n_code);
40665             printf("\n");
40666         }
40667     }
40668     function_tests++;
40669 #endif
40670
40671     return(test_ret);
40672 }
40673
40674
40675 static int
40676 test_xmlUCSIsLatinExtendedA(void) {
40677     int test_ret = 0;
40678
40679 #if defined(LIBXML_UNICODE_ENABLED)
40680     int mem_base;
40681     int ret_val;
40682     int code; /* UCS code point */
40683     int n_code;
40684
40685     for (n_code = 0;n_code < gen_nb_int;n_code++) {
40686         mem_base = xmlMemBlocks();
40687         code = gen_int(n_code, 0);
40688
40689         ret_val = xmlUCSIsLatinExtendedA(code);
40690         desret_int(ret_val);
40691         call_tests++;
40692         des_int(n_code, code, 0);
40693         xmlResetLastError();
40694         if (mem_base != xmlMemBlocks()) {
40695             printf("Leak of %d blocks found in xmlUCSIsLatinExtendedA",
40696                    xmlMemBlocks() - mem_base);
40697             test_ret++;
40698             printf(" %d", n_code);
40699             printf("\n");
40700         }
40701     }
40702     function_tests++;
40703 #endif
40704
40705     return(test_ret);
40706 }
40707
40708
40709 static int
40710 test_xmlUCSIsLatinExtendedAdditional(void) {
40711     int test_ret = 0;
40712
40713 #if defined(LIBXML_UNICODE_ENABLED)
40714     int mem_base;
40715     int ret_val;
40716     int code; /* UCS code point */
40717     int n_code;
40718
40719     for (n_code = 0;n_code < gen_nb_int;n_code++) {
40720         mem_base = xmlMemBlocks();
40721         code = gen_int(n_code, 0);
40722
40723         ret_val = xmlUCSIsLatinExtendedAdditional(code);
40724         desret_int(ret_val);
40725         call_tests++;
40726         des_int(n_code, code, 0);
40727         xmlResetLastError();
40728         if (mem_base != xmlMemBlocks()) {
40729             printf("Leak of %d blocks found in xmlUCSIsLatinExtendedAdditional",
40730                    xmlMemBlocks() - mem_base);
40731             test_ret++;
40732             printf(" %d", n_code);
40733             printf("\n");
40734         }
40735     }
40736     function_tests++;
40737 #endif
40738
40739     return(test_ret);
40740 }
40741
40742
40743 static int
40744 test_xmlUCSIsLatinExtendedB(void) {
40745     int test_ret = 0;
40746
40747 #if defined(LIBXML_UNICODE_ENABLED)
40748     int mem_base;
40749     int ret_val;
40750     int code; /* UCS code point */
40751     int n_code;
40752
40753     for (n_code = 0;n_code < gen_nb_int;n_code++) {
40754         mem_base = xmlMemBlocks();
40755         code = gen_int(n_code, 0);
40756
40757         ret_val = xmlUCSIsLatinExtendedB(code);
40758         desret_int(ret_val);
40759         call_tests++;
40760         des_int(n_code, code, 0);
40761         xmlResetLastError();
40762         if (mem_base != xmlMemBlocks()) {
40763             printf("Leak of %d blocks found in xmlUCSIsLatinExtendedB",
40764                    xmlMemBlocks() - mem_base);
40765             test_ret++;
40766             printf(" %d", n_code);
40767             printf("\n");
40768         }
40769     }
40770     function_tests++;
40771 #endif
40772
40773     return(test_ret);
40774 }
40775
40776
40777 static int
40778 test_xmlUCSIsLetterlikeSymbols(void) {
40779     int test_ret = 0;
40780
40781 #if defined(LIBXML_UNICODE_ENABLED)
40782     int mem_base;
40783     int ret_val;
40784     int code; /* UCS code point */
40785     int n_code;
40786
40787     for (n_code = 0;n_code < gen_nb_int;n_code++) {
40788         mem_base = xmlMemBlocks();
40789         code = gen_int(n_code, 0);
40790
40791         ret_val = xmlUCSIsLetterlikeSymbols(code);
40792         desret_int(ret_val);
40793         call_tests++;
40794         des_int(n_code, code, 0);
40795         xmlResetLastError();
40796         if (mem_base != xmlMemBlocks()) {
40797             printf("Leak of %d blocks found in xmlUCSIsLetterlikeSymbols",
40798                    xmlMemBlocks() - mem_base);
40799             test_ret++;
40800             printf(" %d", n_code);
40801             printf("\n");
40802         }
40803     }
40804     function_tests++;
40805 #endif
40806
40807     return(test_ret);
40808 }
40809
40810
40811 static int
40812 test_xmlUCSIsLimbu(void) {
40813     int test_ret = 0;
40814
40815 #if defined(LIBXML_UNICODE_ENABLED)
40816     int mem_base;
40817     int ret_val;
40818     int code; /* UCS code point */
40819     int n_code;
40820
40821     for (n_code = 0;n_code < gen_nb_int;n_code++) {
40822         mem_base = xmlMemBlocks();
40823         code = gen_int(n_code, 0);
40824
40825         ret_val = xmlUCSIsLimbu(code);
40826         desret_int(ret_val);
40827         call_tests++;
40828         des_int(n_code, code, 0);
40829         xmlResetLastError();
40830         if (mem_base != xmlMemBlocks()) {
40831             printf("Leak of %d blocks found in xmlUCSIsLimbu",
40832                    xmlMemBlocks() - mem_base);
40833             test_ret++;
40834             printf(" %d", n_code);
40835             printf("\n");
40836         }
40837     }
40838     function_tests++;
40839 #endif
40840
40841     return(test_ret);
40842 }
40843
40844
40845 static int
40846 test_xmlUCSIsLinearBIdeograms(void) {
40847     int test_ret = 0;
40848
40849 #if defined(LIBXML_UNICODE_ENABLED)
40850     int mem_base;
40851     int ret_val;
40852     int code; /* UCS code point */
40853     int n_code;
40854
40855     for (n_code = 0;n_code < gen_nb_int;n_code++) {
40856         mem_base = xmlMemBlocks();
40857         code = gen_int(n_code, 0);
40858
40859         ret_val = xmlUCSIsLinearBIdeograms(code);
40860         desret_int(ret_val);
40861         call_tests++;
40862         des_int(n_code, code, 0);
40863         xmlResetLastError();
40864         if (mem_base != xmlMemBlocks()) {
40865             printf("Leak of %d blocks found in xmlUCSIsLinearBIdeograms",
40866                    xmlMemBlocks() - mem_base);
40867             test_ret++;
40868             printf(" %d", n_code);
40869             printf("\n");
40870         }
40871     }
40872     function_tests++;
40873 #endif
40874
40875     return(test_ret);
40876 }
40877
40878
40879 static int
40880 test_xmlUCSIsLinearBSyllabary(void) {
40881     int test_ret = 0;
40882
40883 #if defined(LIBXML_UNICODE_ENABLED)
40884     int mem_base;
40885     int ret_val;
40886     int code; /* UCS code point */
40887     int n_code;
40888
40889     for (n_code = 0;n_code < gen_nb_int;n_code++) {
40890         mem_base = xmlMemBlocks();
40891         code = gen_int(n_code, 0);
40892
40893         ret_val = xmlUCSIsLinearBSyllabary(code);
40894         desret_int(ret_val);
40895         call_tests++;
40896         des_int(n_code, code, 0);
40897         xmlResetLastError();
40898         if (mem_base != xmlMemBlocks()) {
40899             printf("Leak of %d blocks found in xmlUCSIsLinearBSyllabary",
40900                    xmlMemBlocks() - mem_base);
40901             test_ret++;
40902             printf(" %d", n_code);
40903             printf("\n");
40904         }
40905     }
40906     function_tests++;
40907 #endif
40908
40909     return(test_ret);
40910 }
40911
40912
40913 static int
40914 test_xmlUCSIsLowSurrogates(void) {
40915     int test_ret = 0;
40916
40917 #if defined(LIBXML_UNICODE_ENABLED)
40918     int mem_base;
40919     int ret_val;
40920     int code; /* UCS code point */
40921     int n_code;
40922
40923     for (n_code = 0;n_code < gen_nb_int;n_code++) {
40924         mem_base = xmlMemBlocks();
40925         code = gen_int(n_code, 0);
40926
40927         ret_val = xmlUCSIsLowSurrogates(code);
40928         desret_int(ret_val);
40929         call_tests++;
40930         des_int(n_code, code, 0);
40931         xmlResetLastError();
40932         if (mem_base != xmlMemBlocks()) {
40933             printf("Leak of %d blocks found in xmlUCSIsLowSurrogates",
40934                    xmlMemBlocks() - mem_base);
40935             test_ret++;
40936             printf(" %d", n_code);
40937             printf("\n");
40938         }
40939     }
40940     function_tests++;
40941 #endif
40942
40943     return(test_ret);
40944 }
40945
40946
40947 static int
40948 test_xmlUCSIsMalayalam(void) {
40949     int test_ret = 0;
40950
40951 #if defined(LIBXML_UNICODE_ENABLED)
40952     int mem_base;
40953     int ret_val;
40954     int code; /* UCS code point */
40955     int n_code;
40956
40957     for (n_code = 0;n_code < gen_nb_int;n_code++) {
40958         mem_base = xmlMemBlocks();
40959         code = gen_int(n_code, 0);
40960
40961         ret_val = xmlUCSIsMalayalam(code);
40962         desret_int(ret_val);
40963         call_tests++;
40964         des_int(n_code, code, 0);
40965         xmlResetLastError();
40966         if (mem_base != xmlMemBlocks()) {
40967             printf("Leak of %d blocks found in xmlUCSIsMalayalam",
40968                    xmlMemBlocks() - mem_base);
40969             test_ret++;
40970             printf(" %d", n_code);
40971             printf("\n");
40972         }
40973     }
40974     function_tests++;
40975 #endif
40976
40977     return(test_ret);
40978 }
40979
40980
40981 static int
40982 test_xmlUCSIsMathematicalAlphanumericSymbols(void) {
40983     int test_ret = 0;
40984
40985 #if defined(LIBXML_UNICODE_ENABLED)
40986     int mem_base;
40987     int ret_val;
40988     int code; /* UCS code point */
40989     int n_code;
40990
40991     for (n_code = 0;n_code < gen_nb_int;n_code++) {
40992         mem_base = xmlMemBlocks();
40993         code = gen_int(n_code, 0);
40994
40995         ret_val = xmlUCSIsMathematicalAlphanumericSymbols(code);
40996         desret_int(ret_val);
40997         call_tests++;
40998         des_int(n_code, code, 0);
40999         xmlResetLastError();
41000         if (mem_base != xmlMemBlocks()) {
41001             printf("Leak of %d blocks found in xmlUCSIsMathematicalAlphanumericSymbols",
41002                    xmlMemBlocks() - mem_base);
41003             test_ret++;
41004             printf(" %d", n_code);
41005             printf("\n");
41006         }
41007     }
41008     function_tests++;
41009 #endif
41010
41011     return(test_ret);
41012 }
41013
41014
41015 static int
41016 test_xmlUCSIsMathematicalOperators(void) {
41017     int test_ret = 0;
41018
41019 #if defined(LIBXML_UNICODE_ENABLED)
41020     int mem_base;
41021     int ret_val;
41022     int code; /* UCS code point */
41023     int n_code;
41024
41025     for (n_code = 0;n_code < gen_nb_int;n_code++) {
41026         mem_base = xmlMemBlocks();
41027         code = gen_int(n_code, 0);
41028
41029         ret_val = xmlUCSIsMathematicalOperators(code);
41030         desret_int(ret_val);
41031         call_tests++;
41032         des_int(n_code, code, 0);
41033         xmlResetLastError();
41034         if (mem_base != xmlMemBlocks()) {
41035             printf("Leak of %d blocks found in xmlUCSIsMathematicalOperators",
41036                    xmlMemBlocks() - mem_base);
41037             test_ret++;
41038             printf(" %d", n_code);
41039             printf("\n");
41040         }
41041     }
41042     function_tests++;
41043 #endif
41044
41045     return(test_ret);
41046 }
41047
41048
41049 static int
41050 test_xmlUCSIsMiscellaneousMathematicalSymbolsA(void) {
41051     int test_ret = 0;
41052
41053 #if defined(LIBXML_UNICODE_ENABLED)
41054     int mem_base;
41055     int ret_val;
41056     int code; /* UCS code point */
41057     int n_code;
41058
41059     for (n_code = 0;n_code < gen_nb_int;n_code++) {
41060         mem_base = xmlMemBlocks();
41061         code = gen_int(n_code, 0);
41062
41063         ret_val = xmlUCSIsMiscellaneousMathematicalSymbolsA(code);
41064         desret_int(ret_val);
41065         call_tests++;
41066         des_int(n_code, code, 0);
41067         xmlResetLastError();
41068         if (mem_base != xmlMemBlocks()) {
41069             printf("Leak of %d blocks found in xmlUCSIsMiscellaneousMathematicalSymbolsA",
41070                    xmlMemBlocks() - mem_base);
41071             test_ret++;
41072             printf(" %d", n_code);
41073             printf("\n");
41074         }
41075     }
41076     function_tests++;
41077 #endif
41078
41079     return(test_ret);
41080 }
41081
41082
41083 static int
41084 test_xmlUCSIsMiscellaneousMathematicalSymbolsB(void) {
41085     int test_ret = 0;
41086
41087 #if defined(LIBXML_UNICODE_ENABLED)
41088     int mem_base;
41089     int ret_val;
41090     int code; /* UCS code point */
41091     int n_code;
41092
41093     for (n_code = 0;n_code < gen_nb_int;n_code++) {
41094         mem_base = xmlMemBlocks();
41095         code = gen_int(n_code, 0);
41096
41097         ret_val = xmlUCSIsMiscellaneousMathematicalSymbolsB(code);
41098         desret_int(ret_val);
41099         call_tests++;
41100         des_int(n_code, code, 0);
41101         xmlResetLastError();
41102         if (mem_base != xmlMemBlocks()) {
41103             printf("Leak of %d blocks found in xmlUCSIsMiscellaneousMathematicalSymbolsB",
41104                    xmlMemBlocks() - mem_base);
41105             test_ret++;
41106             printf(" %d", n_code);
41107             printf("\n");
41108         }
41109     }
41110     function_tests++;
41111 #endif
41112
41113     return(test_ret);
41114 }
41115
41116
41117 static int
41118 test_xmlUCSIsMiscellaneousSymbols(void) {
41119     int test_ret = 0;
41120
41121 #if defined(LIBXML_UNICODE_ENABLED)
41122     int mem_base;
41123     int ret_val;
41124     int code; /* UCS code point */
41125     int n_code;
41126
41127     for (n_code = 0;n_code < gen_nb_int;n_code++) {
41128         mem_base = xmlMemBlocks();
41129         code = gen_int(n_code, 0);
41130
41131         ret_val = xmlUCSIsMiscellaneousSymbols(code);
41132         desret_int(ret_val);
41133         call_tests++;
41134         des_int(n_code, code, 0);
41135         xmlResetLastError();
41136         if (mem_base != xmlMemBlocks()) {
41137             printf("Leak of %d blocks found in xmlUCSIsMiscellaneousSymbols",
41138                    xmlMemBlocks() - mem_base);
41139             test_ret++;
41140             printf(" %d", n_code);
41141             printf("\n");
41142         }
41143     }
41144     function_tests++;
41145 #endif
41146
41147     return(test_ret);
41148 }
41149
41150
41151 static int
41152 test_xmlUCSIsMiscellaneousSymbolsandArrows(void) {
41153     int test_ret = 0;
41154
41155 #if defined(LIBXML_UNICODE_ENABLED)
41156     int mem_base;
41157     int ret_val;
41158     int code; /* UCS code point */
41159     int n_code;
41160
41161     for (n_code = 0;n_code < gen_nb_int;n_code++) {
41162         mem_base = xmlMemBlocks();
41163         code = gen_int(n_code, 0);
41164
41165         ret_val = xmlUCSIsMiscellaneousSymbolsandArrows(code);
41166         desret_int(ret_val);
41167         call_tests++;
41168         des_int(n_code, code, 0);
41169         xmlResetLastError();
41170         if (mem_base != xmlMemBlocks()) {
41171             printf("Leak of %d blocks found in xmlUCSIsMiscellaneousSymbolsandArrows",
41172                    xmlMemBlocks() - mem_base);
41173             test_ret++;
41174             printf(" %d", n_code);
41175             printf("\n");
41176         }
41177     }
41178     function_tests++;
41179 #endif
41180
41181     return(test_ret);
41182 }
41183
41184
41185 static int
41186 test_xmlUCSIsMiscellaneousTechnical(void) {
41187     int test_ret = 0;
41188
41189 #if defined(LIBXML_UNICODE_ENABLED)
41190     int mem_base;
41191     int ret_val;
41192     int code; /* UCS code point */
41193     int n_code;
41194
41195     for (n_code = 0;n_code < gen_nb_int;n_code++) {
41196         mem_base = xmlMemBlocks();
41197         code = gen_int(n_code, 0);
41198
41199         ret_val = xmlUCSIsMiscellaneousTechnical(code);
41200         desret_int(ret_val);
41201         call_tests++;
41202         des_int(n_code, code, 0);
41203         xmlResetLastError();
41204         if (mem_base != xmlMemBlocks()) {
41205             printf("Leak of %d blocks found in xmlUCSIsMiscellaneousTechnical",
41206                    xmlMemBlocks() - mem_base);
41207             test_ret++;
41208             printf(" %d", n_code);
41209             printf("\n");
41210         }
41211     }
41212     function_tests++;
41213 #endif
41214
41215     return(test_ret);
41216 }
41217
41218
41219 static int
41220 test_xmlUCSIsMongolian(void) {
41221     int test_ret = 0;
41222
41223 #if defined(LIBXML_UNICODE_ENABLED)
41224     int mem_base;
41225     int ret_val;
41226     int code; /* UCS code point */
41227     int n_code;
41228
41229     for (n_code = 0;n_code < gen_nb_int;n_code++) {
41230         mem_base = xmlMemBlocks();
41231         code = gen_int(n_code, 0);
41232
41233         ret_val = xmlUCSIsMongolian(code);
41234         desret_int(ret_val);
41235         call_tests++;
41236         des_int(n_code, code, 0);
41237         xmlResetLastError();
41238         if (mem_base != xmlMemBlocks()) {
41239             printf("Leak of %d blocks found in xmlUCSIsMongolian",
41240                    xmlMemBlocks() - mem_base);
41241             test_ret++;
41242             printf(" %d", n_code);
41243             printf("\n");
41244         }
41245     }
41246     function_tests++;
41247 #endif
41248
41249     return(test_ret);
41250 }
41251
41252
41253 static int
41254 test_xmlUCSIsMusicalSymbols(void) {
41255     int test_ret = 0;
41256
41257 #if defined(LIBXML_UNICODE_ENABLED)
41258     int mem_base;
41259     int ret_val;
41260     int code; /* UCS code point */
41261     int n_code;
41262
41263     for (n_code = 0;n_code < gen_nb_int;n_code++) {
41264         mem_base = xmlMemBlocks();
41265         code = gen_int(n_code, 0);
41266
41267         ret_val = xmlUCSIsMusicalSymbols(code);
41268         desret_int(ret_val);
41269         call_tests++;
41270         des_int(n_code, code, 0);
41271         xmlResetLastError();
41272         if (mem_base != xmlMemBlocks()) {
41273             printf("Leak of %d blocks found in xmlUCSIsMusicalSymbols",
41274                    xmlMemBlocks() - mem_base);
41275             test_ret++;
41276             printf(" %d", n_code);
41277             printf("\n");
41278         }
41279     }
41280     function_tests++;
41281 #endif
41282
41283     return(test_ret);
41284 }
41285
41286
41287 static int
41288 test_xmlUCSIsMyanmar(void) {
41289     int test_ret = 0;
41290
41291 #if defined(LIBXML_UNICODE_ENABLED)
41292     int mem_base;
41293     int ret_val;
41294     int code; /* UCS code point */
41295     int n_code;
41296
41297     for (n_code = 0;n_code < gen_nb_int;n_code++) {
41298         mem_base = xmlMemBlocks();
41299         code = gen_int(n_code, 0);
41300
41301         ret_val = xmlUCSIsMyanmar(code);
41302         desret_int(ret_val);
41303         call_tests++;
41304         des_int(n_code, code, 0);
41305         xmlResetLastError();
41306         if (mem_base != xmlMemBlocks()) {
41307             printf("Leak of %d blocks found in xmlUCSIsMyanmar",
41308                    xmlMemBlocks() - mem_base);
41309             test_ret++;
41310             printf(" %d", n_code);
41311             printf("\n");
41312         }
41313     }
41314     function_tests++;
41315 #endif
41316
41317     return(test_ret);
41318 }
41319
41320
41321 static int
41322 test_xmlUCSIsNumberForms(void) {
41323     int test_ret = 0;
41324
41325 #if defined(LIBXML_UNICODE_ENABLED)
41326     int mem_base;
41327     int ret_val;
41328     int code; /* UCS code point */
41329     int n_code;
41330
41331     for (n_code = 0;n_code < gen_nb_int;n_code++) {
41332         mem_base = xmlMemBlocks();
41333         code = gen_int(n_code, 0);
41334
41335         ret_val = xmlUCSIsNumberForms(code);
41336         desret_int(ret_val);
41337         call_tests++;
41338         des_int(n_code, code, 0);
41339         xmlResetLastError();
41340         if (mem_base != xmlMemBlocks()) {
41341             printf("Leak of %d blocks found in xmlUCSIsNumberForms",
41342                    xmlMemBlocks() - mem_base);
41343             test_ret++;
41344             printf(" %d", n_code);
41345             printf("\n");
41346         }
41347     }
41348     function_tests++;
41349 #endif
41350
41351     return(test_ret);
41352 }
41353
41354
41355 static int
41356 test_xmlUCSIsOgham(void) {
41357     int test_ret = 0;
41358
41359 #if defined(LIBXML_UNICODE_ENABLED)
41360     int mem_base;
41361     int ret_val;
41362     int code; /* UCS code point */
41363     int n_code;
41364
41365     for (n_code = 0;n_code < gen_nb_int;n_code++) {
41366         mem_base = xmlMemBlocks();
41367         code = gen_int(n_code, 0);
41368
41369         ret_val = xmlUCSIsOgham(code);
41370         desret_int(ret_val);
41371         call_tests++;
41372         des_int(n_code, code, 0);
41373         xmlResetLastError();
41374         if (mem_base != xmlMemBlocks()) {
41375             printf("Leak of %d blocks found in xmlUCSIsOgham",
41376                    xmlMemBlocks() - mem_base);
41377             test_ret++;
41378             printf(" %d", n_code);
41379             printf("\n");
41380         }
41381     }
41382     function_tests++;
41383 #endif
41384
41385     return(test_ret);
41386 }
41387
41388
41389 static int
41390 test_xmlUCSIsOldItalic(void) {
41391     int test_ret = 0;
41392
41393 #if defined(LIBXML_UNICODE_ENABLED)
41394     int mem_base;
41395     int ret_val;
41396     int code; /* UCS code point */
41397     int n_code;
41398
41399     for (n_code = 0;n_code < gen_nb_int;n_code++) {
41400         mem_base = xmlMemBlocks();
41401         code = gen_int(n_code, 0);
41402
41403         ret_val = xmlUCSIsOldItalic(code);
41404         desret_int(ret_val);
41405         call_tests++;
41406         des_int(n_code, code, 0);
41407         xmlResetLastError();
41408         if (mem_base != xmlMemBlocks()) {
41409             printf("Leak of %d blocks found in xmlUCSIsOldItalic",
41410                    xmlMemBlocks() - mem_base);
41411             test_ret++;
41412             printf(" %d", n_code);
41413             printf("\n");
41414         }
41415     }
41416     function_tests++;
41417 #endif
41418
41419     return(test_ret);
41420 }
41421
41422
41423 static int
41424 test_xmlUCSIsOpticalCharacterRecognition(void) {
41425     int test_ret = 0;
41426
41427 #if defined(LIBXML_UNICODE_ENABLED)
41428     int mem_base;
41429     int ret_val;
41430     int code; /* UCS code point */
41431     int n_code;
41432
41433     for (n_code = 0;n_code < gen_nb_int;n_code++) {
41434         mem_base = xmlMemBlocks();
41435         code = gen_int(n_code, 0);
41436
41437         ret_val = xmlUCSIsOpticalCharacterRecognition(code);
41438         desret_int(ret_val);
41439         call_tests++;
41440         des_int(n_code, code, 0);
41441         xmlResetLastError();
41442         if (mem_base != xmlMemBlocks()) {
41443             printf("Leak of %d blocks found in xmlUCSIsOpticalCharacterRecognition",
41444                    xmlMemBlocks() - mem_base);
41445             test_ret++;
41446             printf(" %d", n_code);
41447             printf("\n");
41448         }
41449     }
41450     function_tests++;
41451 #endif
41452
41453     return(test_ret);
41454 }
41455
41456
41457 static int
41458 test_xmlUCSIsOriya(void) {
41459     int test_ret = 0;
41460
41461 #if defined(LIBXML_UNICODE_ENABLED)
41462     int mem_base;
41463     int ret_val;
41464     int code; /* UCS code point */
41465     int n_code;
41466
41467     for (n_code = 0;n_code < gen_nb_int;n_code++) {
41468         mem_base = xmlMemBlocks();
41469         code = gen_int(n_code, 0);
41470
41471         ret_val = xmlUCSIsOriya(code);
41472         desret_int(ret_val);
41473         call_tests++;
41474         des_int(n_code, code, 0);
41475         xmlResetLastError();
41476         if (mem_base != xmlMemBlocks()) {
41477             printf("Leak of %d blocks found in xmlUCSIsOriya",
41478                    xmlMemBlocks() - mem_base);
41479             test_ret++;
41480             printf(" %d", n_code);
41481             printf("\n");
41482         }
41483     }
41484     function_tests++;
41485 #endif
41486
41487     return(test_ret);
41488 }
41489
41490
41491 static int
41492 test_xmlUCSIsOsmanya(void) {
41493     int test_ret = 0;
41494
41495 #if defined(LIBXML_UNICODE_ENABLED)
41496     int mem_base;
41497     int ret_val;
41498     int code; /* UCS code point */
41499     int n_code;
41500
41501     for (n_code = 0;n_code < gen_nb_int;n_code++) {
41502         mem_base = xmlMemBlocks();
41503         code = gen_int(n_code, 0);
41504
41505         ret_val = xmlUCSIsOsmanya(code);
41506         desret_int(ret_val);
41507         call_tests++;
41508         des_int(n_code, code, 0);
41509         xmlResetLastError();
41510         if (mem_base != xmlMemBlocks()) {
41511             printf("Leak of %d blocks found in xmlUCSIsOsmanya",
41512                    xmlMemBlocks() - mem_base);
41513             test_ret++;
41514             printf(" %d", n_code);
41515             printf("\n");
41516         }
41517     }
41518     function_tests++;
41519 #endif
41520
41521     return(test_ret);
41522 }
41523
41524
41525 static int
41526 test_xmlUCSIsPhoneticExtensions(void) {
41527     int test_ret = 0;
41528
41529 #if defined(LIBXML_UNICODE_ENABLED)
41530     int mem_base;
41531     int ret_val;
41532     int code; /* UCS code point */
41533     int n_code;
41534
41535     for (n_code = 0;n_code < gen_nb_int;n_code++) {
41536         mem_base = xmlMemBlocks();
41537         code = gen_int(n_code, 0);
41538
41539         ret_val = xmlUCSIsPhoneticExtensions(code);
41540         desret_int(ret_val);
41541         call_tests++;
41542         des_int(n_code, code, 0);
41543         xmlResetLastError();
41544         if (mem_base != xmlMemBlocks()) {
41545             printf("Leak of %d blocks found in xmlUCSIsPhoneticExtensions",
41546                    xmlMemBlocks() - mem_base);
41547             test_ret++;
41548             printf(" %d", n_code);
41549             printf("\n");
41550         }
41551     }
41552     function_tests++;
41553 #endif
41554
41555     return(test_ret);
41556 }
41557
41558
41559 static int
41560 test_xmlUCSIsPrivateUse(void) {
41561     int test_ret = 0;
41562
41563 #if defined(LIBXML_UNICODE_ENABLED)
41564     int mem_base;
41565     int ret_val;
41566     int code; /* UCS code point */
41567     int n_code;
41568
41569     for (n_code = 0;n_code < gen_nb_int;n_code++) {
41570         mem_base = xmlMemBlocks();
41571         code = gen_int(n_code, 0);
41572
41573         ret_val = xmlUCSIsPrivateUse(code);
41574         desret_int(ret_val);
41575         call_tests++;
41576         des_int(n_code, code, 0);
41577         xmlResetLastError();
41578         if (mem_base != xmlMemBlocks()) {
41579             printf("Leak of %d blocks found in xmlUCSIsPrivateUse",
41580                    xmlMemBlocks() - mem_base);
41581             test_ret++;
41582             printf(" %d", n_code);
41583             printf("\n");
41584         }
41585     }
41586     function_tests++;
41587 #endif
41588
41589     return(test_ret);
41590 }
41591
41592
41593 static int
41594 test_xmlUCSIsPrivateUseArea(void) {
41595     int test_ret = 0;
41596
41597 #if defined(LIBXML_UNICODE_ENABLED)
41598     int mem_base;
41599     int ret_val;
41600     int code; /* UCS code point */
41601     int n_code;
41602
41603     for (n_code = 0;n_code < gen_nb_int;n_code++) {
41604         mem_base = xmlMemBlocks();
41605         code = gen_int(n_code, 0);
41606
41607         ret_val = xmlUCSIsPrivateUseArea(code);
41608         desret_int(ret_val);
41609         call_tests++;
41610         des_int(n_code, code, 0);
41611         xmlResetLastError();
41612         if (mem_base != xmlMemBlocks()) {
41613             printf("Leak of %d blocks found in xmlUCSIsPrivateUseArea",
41614                    xmlMemBlocks() - mem_base);
41615             test_ret++;
41616             printf(" %d", n_code);
41617             printf("\n");
41618         }
41619     }
41620     function_tests++;
41621 #endif
41622
41623     return(test_ret);
41624 }
41625
41626
41627 static int
41628 test_xmlUCSIsRunic(void) {
41629     int test_ret = 0;
41630
41631 #if defined(LIBXML_UNICODE_ENABLED)
41632     int mem_base;
41633     int ret_val;
41634     int code; /* UCS code point */
41635     int n_code;
41636
41637     for (n_code = 0;n_code < gen_nb_int;n_code++) {
41638         mem_base = xmlMemBlocks();
41639         code = gen_int(n_code, 0);
41640
41641         ret_val = xmlUCSIsRunic(code);
41642         desret_int(ret_val);
41643         call_tests++;
41644         des_int(n_code, code, 0);
41645         xmlResetLastError();
41646         if (mem_base != xmlMemBlocks()) {
41647             printf("Leak of %d blocks found in xmlUCSIsRunic",
41648                    xmlMemBlocks() - mem_base);
41649             test_ret++;
41650             printf(" %d", n_code);
41651             printf("\n");
41652         }
41653     }
41654     function_tests++;
41655 #endif
41656
41657     return(test_ret);
41658 }
41659
41660
41661 static int
41662 test_xmlUCSIsShavian(void) {
41663     int test_ret = 0;
41664
41665 #if defined(LIBXML_UNICODE_ENABLED)
41666     int mem_base;
41667     int ret_val;
41668     int code; /* UCS code point */
41669     int n_code;
41670
41671     for (n_code = 0;n_code < gen_nb_int;n_code++) {
41672         mem_base = xmlMemBlocks();
41673         code = gen_int(n_code, 0);
41674
41675         ret_val = xmlUCSIsShavian(code);
41676         desret_int(ret_val);
41677         call_tests++;
41678         des_int(n_code, code, 0);
41679         xmlResetLastError();
41680         if (mem_base != xmlMemBlocks()) {
41681             printf("Leak of %d blocks found in xmlUCSIsShavian",
41682                    xmlMemBlocks() - mem_base);
41683             test_ret++;
41684             printf(" %d", n_code);
41685             printf("\n");
41686         }
41687     }
41688     function_tests++;
41689 #endif
41690
41691     return(test_ret);
41692 }
41693
41694
41695 static int
41696 test_xmlUCSIsSinhala(void) {
41697     int test_ret = 0;
41698
41699 #if defined(LIBXML_UNICODE_ENABLED)
41700     int mem_base;
41701     int ret_val;
41702     int code; /* UCS code point */
41703     int n_code;
41704
41705     for (n_code = 0;n_code < gen_nb_int;n_code++) {
41706         mem_base = xmlMemBlocks();
41707         code = gen_int(n_code, 0);
41708
41709         ret_val = xmlUCSIsSinhala(code);
41710         desret_int(ret_val);
41711         call_tests++;
41712         des_int(n_code, code, 0);
41713         xmlResetLastError();
41714         if (mem_base != xmlMemBlocks()) {
41715             printf("Leak of %d blocks found in xmlUCSIsSinhala",
41716                    xmlMemBlocks() - mem_base);
41717             test_ret++;
41718             printf(" %d", n_code);
41719             printf("\n");
41720         }
41721     }
41722     function_tests++;
41723 #endif
41724
41725     return(test_ret);
41726 }
41727
41728
41729 static int
41730 test_xmlUCSIsSmallFormVariants(void) {
41731     int test_ret = 0;
41732
41733 #if defined(LIBXML_UNICODE_ENABLED)
41734     int mem_base;
41735     int ret_val;
41736     int code; /* UCS code point */
41737     int n_code;
41738
41739     for (n_code = 0;n_code < gen_nb_int;n_code++) {
41740         mem_base = xmlMemBlocks();
41741         code = gen_int(n_code, 0);
41742
41743         ret_val = xmlUCSIsSmallFormVariants(code);
41744         desret_int(ret_val);
41745         call_tests++;
41746         des_int(n_code, code, 0);
41747         xmlResetLastError();
41748         if (mem_base != xmlMemBlocks()) {
41749             printf("Leak of %d blocks found in xmlUCSIsSmallFormVariants",
41750                    xmlMemBlocks() - mem_base);
41751             test_ret++;
41752             printf(" %d", n_code);
41753             printf("\n");
41754         }
41755     }
41756     function_tests++;
41757 #endif
41758
41759     return(test_ret);
41760 }
41761
41762
41763 static int
41764 test_xmlUCSIsSpacingModifierLetters(void) {
41765     int test_ret = 0;
41766
41767 #if defined(LIBXML_UNICODE_ENABLED)
41768     int mem_base;
41769     int ret_val;
41770     int code; /* UCS code point */
41771     int n_code;
41772
41773     for (n_code = 0;n_code < gen_nb_int;n_code++) {
41774         mem_base = xmlMemBlocks();
41775         code = gen_int(n_code, 0);
41776
41777         ret_val = xmlUCSIsSpacingModifierLetters(code);
41778         desret_int(ret_val);
41779         call_tests++;
41780         des_int(n_code, code, 0);
41781         xmlResetLastError();
41782         if (mem_base != xmlMemBlocks()) {
41783             printf("Leak of %d blocks found in xmlUCSIsSpacingModifierLetters",
41784                    xmlMemBlocks() - mem_base);
41785             test_ret++;
41786             printf(" %d", n_code);
41787             printf("\n");
41788         }
41789     }
41790     function_tests++;
41791 #endif
41792
41793     return(test_ret);
41794 }
41795
41796
41797 static int
41798 test_xmlUCSIsSpecials(void) {
41799     int test_ret = 0;
41800
41801 #if defined(LIBXML_UNICODE_ENABLED)
41802     int mem_base;
41803     int ret_val;
41804     int code; /* UCS code point */
41805     int n_code;
41806
41807     for (n_code = 0;n_code < gen_nb_int;n_code++) {
41808         mem_base = xmlMemBlocks();
41809         code = gen_int(n_code, 0);
41810
41811         ret_val = xmlUCSIsSpecials(code);
41812         desret_int(ret_val);
41813         call_tests++;
41814         des_int(n_code, code, 0);
41815         xmlResetLastError();
41816         if (mem_base != xmlMemBlocks()) {
41817             printf("Leak of %d blocks found in xmlUCSIsSpecials",
41818                    xmlMemBlocks() - mem_base);
41819             test_ret++;
41820             printf(" %d", n_code);
41821             printf("\n");
41822         }
41823     }
41824     function_tests++;
41825 #endif
41826
41827     return(test_ret);
41828 }
41829
41830
41831 static int
41832 test_xmlUCSIsSuperscriptsandSubscripts(void) {
41833     int test_ret = 0;
41834
41835 #if defined(LIBXML_UNICODE_ENABLED)
41836     int mem_base;
41837     int ret_val;
41838     int code; /* UCS code point */
41839     int n_code;
41840
41841     for (n_code = 0;n_code < gen_nb_int;n_code++) {
41842         mem_base = xmlMemBlocks();
41843         code = gen_int(n_code, 0);
41844
41845         ret_val = xmlUCSIsSuperscriptsandSubscripts(code);
41846         desret_int(ret_val);
41847         call_tests++;
41848         des_int(n_code, code, 0);
41849         xmlResetLastError();
41850         if (mem_base != xmlMemBlocks()) {
41851             printf("Leak of %d blocks found in xmlUCSIsSuperscriptsandSubscripts",
41852                    xmlMemBlocks() - mem_base);
41853             test_ret++;
41854             printf(" %d", n_code);
41855             printf("\n");
41856         }
41857     }
41858     function_tests++;
41859 #endif
41860
41861     return(test_ret);
41862 }
41863
41864
41865 static int
41866 test_xmlUCSIsSupplementalArrowsA(void) {
41867     int test_ret = 0;
41868
41869 #if defined(LIBXML_UNICODE_ENABLED)
41870     int mem_base;
41871     int ret_val;
41872     int code; /* UCS code point */
41873     int n_code;
41874
41875     for (n_code = 0;n_code < gen_nb_int;n_code++) {
41876         mem_base = xmlMemBlocks();
41877         code = gen_int(n_code, 0);
41878
41879         ret_val = xmlUCSIsSupplementalArrowsA(code);
41880         desret_int(ret_val);
41881         call_tests++;
41882         des_int(n_code, code, 0);
41883         xmlResetLastError();
41884         if (mem_base != xmlMemBlocks()) {
41885             printf("Leak of %d blocks found in xmlUCSIsSupplementalArrowsA",
41886                    xmlMemBlocks() - mem_base);
41887             test_ret++;
41888             printf(" %d", n_code);
41889             printf("\n");
41890         }
41891     }
41892     function_tests++;
41893 #endif
41894
41895     return(test_ret);
41896 }
41897
41898
41899 static int
41900 test_xmlUCSIsSupplementalArrowsB(void) {
41901     int test_ret = 0;
41902
41903 #if defined(LIBXML_UNICODE_ENABLED)
41904     int mem_base;
41905     int ret_val;
41906     int code; /* UCS code point */
41907     int n_code;
41908
41909     for (n_code = 0;n_code < gen_nb_int;n_code++) {
41910         mem_base = xmlMemBlocks();
41911         code = gen_int(n_code, 0);
41912
41913         ret_val = xmlUCSIsSupplementalArrowsB(code);
41914         desret_int(ret_val);
41915         call_tests++;
41916         des_int(n_code, code, 0);
41917         xmlResetLastError();
41918         if (mem_base != xmlMemBlocks()) {
41919             printf("Leak of %d blocks found in xmlUCSIsSupplementalArrowsB",
41920                    xmlMemBlocks() - mem_base);
41921             test_ret++;
41922             printf(" %d", n_code);
41923             printf("\n");
41924         }
41925     }
41926     function_tests++;
41927 #endif
41928
41929     return(test_ret);
41930 }
41931
41932
41933 static int
41934 test_xmlUCSIsSupplementalMathematicalOperators(void) {
41935     int test_ret = 0;
41936
41937 #if defined(LIBXML_UNICODE_ENABLED)
41938     int mem_base;
41939     int ret_val;
41940     int code; /* UCS code point */
41941     int n_code;
41942
41943     for (n_code = 0;n_code < gen_nb_int;n_code++) {
41944         mem_base = xmlMemBlocks();
41945         code = gen_int(n_code, 0);
41946
41947         ret_val = xmlUCSIsSupplementalMathematicalOperators(code);
41948         desret_int(ret_val);
41949         call_tests++;
41950         des_int(n_code, code, 0);
41951         xmlResetLastError();
41952         if (mem_base != xmlMemBlocks()) {
41953             printf("Leak of %d blocks found in xmlUCSIsSupplementalMathematicalOperators",
41954                    xmlMemBlocks() - mem_base);
41955             test_ret++;
41956             printf(" %d", n_code);
41957             printf("\n");
41958         }
41959     }
41960     function_tests++;
41961 #endif
41962
41963     return(test_ret);
41964 }
41965
41966
41967 static int
41968 test_xmlUCSIsSupplementaryPrivateUseAreaA(void) {
41969     int test_ret = 0;
41970
41971 #if defined(LIBXML_UNICODE_ENABLED)
41972     int mem_base;
41973     int ret_val;
41974     int code; /* UCS code point */
41975     int n_code;
41976
41977     for (n_code = 0;n_code < gen_nb_int;n_code++) {
41978         mem_base = xmlMemBlocks();
41979         code = gen_int(n_code, 0);
41980
41981         ret_val = xmlUCSIsSupplementaryPrivateUseAreaA(code);
41982         desret_int(ret_val);
41983         call_tests++;
41984         des_int(n_code, code, 0);
41985         xmlResetLastError();
41986         if (mem_base != xmlMemBlocks()) {
41987             printf("Leak of %d blocks found in xmlUCSIsSupplementaryPrivateUseAreaA",
41988                    xmlMemBlocks() - mem_base);
41989             test_ret++;
41990             printf(" %d", n_code);
41991             printf("\n");
41992         }
41993     }
41994     function_tests++;
41995 #endif
41996
41997     return(test_ret);
41998 }
41999
42000
42001 static int
42002 test_xmlUCSIsSupplementaryPrivateUseAreaB(void) {
42003     int test_ret = 0;
42004
42005 #if defined(LIBXML_UNICODE_ENABLED)
42006     int mem_base;
42007     int ret_val;
42008     int code; /* UCS code point */
42009     int n_code;
42010
42011     for (n_code = 0;n_code < gen_nb_int;n_code++) {
42012         mem_base = xmlMemBlocks();
42013         code = gen_int(n_code, 0);
42014
42015         ret_val = xmlUCSIsSupplementaryPrivateUseAreaB(code);
42016         desret_int(ret_val);
42017         call_tests++;
42018         des_int(n_code, code, 0);
42019         xmlResetLastError();
42020         if (mem_base != xmlMemBlocks()) {
42021             printf("Leak of %d blocks found in xmlUCSIsSupplementaryPrivateUseAreaB",
42022                    xmlMemBlocks() - mem_base);
42023             test_ret++;
42024             printf(" %d", n_code);
42025             printf("\n");
42026         }
42027     }
42028     function_tests++;
42029 #endif
42030
42031     return(test_ret);
42032 }
42033
42034
42035 static int
42036 test_xmlUCSIsSyriac(void) {
42037     int test_ret = 0;
42038
42039 #if defined(LIBXML_UNICODE_ENABLED)
42040     int mem_base;
42041     int ret_val;
42042     int code; /* UCS code point */
42043     int n_code;
42044
42045     for (n_code = 0;n_code < gen_nb_int;n_code++) {
42046         mem_base = xmlMemBlocks();
42047         code = gen_int(n_code, 0);
42048
42049         ret_val = xmlUCSIsSyriac(code);
42050         desret_int(ret_val);
42051         call_tests++;
42052         des_int(n_code, code, 0);
42053         xmlResetLastError();
42054         if (mem_base != xmlMemBlocks()) {
42055             printf("Leak of %d blocks found in xmlUCSIsSyriac",
42056                    xmlMemBlocks() - mem_base);
42057             test_ret++;
42058             printf(" %d", n_code);
42059             printf("\n");
42060         }
42061     }
42062     function_tests++;
42063 #endif
42064
42065     return(test_ret);
42066 }
42067
42068
42069 static int
42070 test_xmlUCSIsTagalog(void) {
42071     int test_ret = 0;
42072
42073 #if defined(LIBXML_UNICODE_ENABLED)
42074     int mem_base;
42075     int ret_val;
42076     int code; /* UCS code point */
42077     int n_code;
42078
42079     for (n_code = 0;n_code < gen_nb_int;n_code++) {
42080         mem_base = xmlMemBlocks();
42081         code = gen_int(n_code, 0);
42082
42083         ret_val = xmlUCSIsTagalog(code);
42084         desret_int(ret_val);
42085         call_tests++;
42086         des_int(n_code, code, 0);
42087         xmlResetLastError();
42088         if (mem_base != xmlMemBlocks()) {
42089             printf("Leak of %d blocks found in xmlUCSIsTagalog",
42090                    xmlMemBlocks() - mem_base);
42091             test_ret++;
42092             printf(" %d", n_code);
42093             printf("\n");
42094         }
42095     }
42096     function_tests++;
42097 #endif
42098
42099     return(test_ret);
42100 }
42101
42102
42103 static int
42104 test_xmlUCSIsTagbanwa(void) {
42105     int test_ret = 0;
42106
42107 #if defined(LIBXML_UNICODE_ENABLED)
42108     int mem_base;
42109     int ret_val;
42110     int code; /* UCS code point */
42111     int n_code;
42112
42113     for (n_code = 0;n_code < gen_nb_int;n_code++) {
42114         mem_base = xmlMemBlocks();
42115         code = gen_int(n_code, 0);
42116
42117         ret_val = xmlUCSIsTagbanwa(code);
42118         desret_int(ret_val);
42119         call_tests++;
42120         des_int(n_code, code, 0);
42121         xmlResetLastError();
42122         if (mem_base != xmlMemBlocks()) {
42123             printf("Leak of %d blocks found in xmlUCSIsTagbanwa",
42124                    xmlMemBlocks() - mem_base);
42125             test_ret++;
42126             printf(" %d", n_code);
42127             printf("\n");
42128         }
42129     }
42130     function_tests++;
42131 #endif
42132
42133     return(test_ret);
42134 }
42135
42136
42137 static int
42138 test_xmlUCSIsTags(void) {
42139     int test_ret = 0;
42140
42141 #if defined(LIBXML_UNICODE_ENABLED)
42142     int mem_base;
42143     int ret_val;
42144     int code; /* UCS code point */
42145     int n_code;
42146
42147     for (n_code = 0;n_code < gen_nb_int;n_code++) {
42148         mem_base = xmlMemBlocks();
42149         code = gen_int(n_code, 0);
42150
42151         ret_val = xmlUCSIsTags(code);
42152         desret_int(ret_val);
42153         call_tests++;
42154         des_int(n_code, code, 0);
42155         xmlResetLastError();
42156         if (mem_base != xmlMemBlocks()) {
42157             printf("Leak of %d blocks found in xmlUCSIsTags",
42158                    xmlMemBlocks() - mem_base);
42159             test_ret++;
42160             printf(" %d", n_code);
42161             printf("\n");
42162         }
42163     }
42164     function_tests++;
42165 #endif
42166
42167     return(test_ret);
42168 }
42169
42170
42171 static int
42172 test_xmlUCSIsTaiLe(void) {
42173     int test_ret = 0;
42174
42175 #if defined(LIBXML_UNICODE_ENABLED)
42176     int mem_base;
42177     int ret_val;
42178     int code; /* UCS code point */
42179     int n_code;
42180
42181     for (n_code = 0;n_code < gen_nb_int;n_code++) {
42182         mem_base = xmlMemBlocks();
42183         code = gen_int(n_code, 0);
42184
42185         ret_val = xmlUCSIsTaiLe(code);
42186         desret_int(ret_val);
42187         call_tests++;
42188         des_int(n_code, code, 0);
42189         xmlResetLastError();
42190         if (mem_base != xmlMemBlocks()) {
42191             printf("Leak of %d blocks found in xmlUCSIsTaiLe",
42192                    xmlMemBlocks() - mem_base);
42193             test_ret++;
42194             printf(" %d", n_code);
42195             printf("\n");
42196         }
42197     }
42198     function_tests++;
42199 #endif
42200
42201     return(test_ret);
42202 }
42203
42204
42205 static int
42206 test_xmlUCSIsTaiXuanJingSymbols(void) {
42207     int test_ret = 0;
42208
42209 #if defined(LIBXML_UNICODE_ENABLED)
42210     int mem_base;
42211     int ret_val;
42212     int code; /* UCS code point */
42213     int n_code;
42214
42215     for (n_code = 0;n_code < gen_nb_int;n_code++) {
42216         mem_base = xmlMemBlocks();
42217         code = gen_int(n_code, 0);
42218
42219         ret_val = xmlUCSIsTaiXuanJingSymbols(code);
42220         desret_int(ret_val);
42221         call_tests++;
42222         des_int(n_code, code, 0);
42223         xmlResetLastError();
42224         if (mem_base != xmlMemBlocks()) {
42225             printf("Leak of %d blocks found in xmlUCSIsTaiXuanJingSymbols",
42226                    xmlMemBlocks() - mem_base);
42227             test_ret++;
42228             printf(" %d", n_code);
42229             printf("\n");
42230         }
42231     }
42232     function_tests++;
42233 #endif
42234
42235     return(test_ret);
42236 }
42237
42238
42239 static int
42240 test_xmlUCSIsTamil(void) {
42241     int test_ret = 0;
42242
42243 #if defined(LIBXML_UNICODE_ENABLED)
42244     int mem_base;
42245     int ret_val;
42246     int code; /* UCS code point */
42247     int n_code;
42248
42249     for (n_code = 0;n_code < gen_nb_int;n_code++) {
42250         mem_base = xmlMemBlocks();
42251         code = gen_int(n_code, 0);
42252
42253         ret_val = xmlUCSIsTamil(code);
42254         desret_int(ret_val);
42255         call_tests++;
42256         des_int(n_code, code, 0);
42257         xmlResetLastError();
42258         if (mem_base != xmlMemBlocks()) {
42259             printf("Leak of %d blocks found in xmlUCSIsTamil",
42260                    xmlMemBlocks() - mem_base);
42261             test_ret++;
42262             printf(" %d", n_code);
42263             printf("\n");
42264         }
42265     }
42266     function_tests++;
42267 #endif
42268
42269     return(test_ret);
42270 }
42271
42272
42273 static int
42274 test_xmlUCSIsTelugu(void) {
42275     int test_ret = 0;
42276
42277 #if defined(LIBXML_UNICODE_ENABLED)
42278     int mem_base;
42279     int ret_val;
42280     int code; /* UCS code point */
42281     int n_code;
42282
42283     for (n_code = 0;n_code < gen_nb_int;n_code++) {
42284         mem_base = xmlMemBlocks();
42285         code = gen_int(n_code, 0);
42286
42287         ret_val = xmlUCSIsTelugu(code);
42288         desret_int(ret_val);
42289         call_tests++;
42290         des_int(n_code, code, 0);
42291         xmlResetLastError();
42292         if (mem_base != xmlMemBlocks()) {
42293             printf("Leak of %d blocks found in xmlUCSIsTelugu",
42294                    xmlMemBlocks() - mem_base);
42295             test_ret++;
42296             printf(" %d", n_code);
42297             printf("\n");
42298         }
42299     }
42300     function_tests++;
42301 #endif
42302
42303     return(test_ret);
42304 }
42305
42306
42307 static int
42308 test_xmlUCSIsThaana(void) {
42309     int test_ret = 0;
42310
42311 #if defined(LIBXML_UNICODE_ENABLED)
42312     int mem_base;
42313     int ret_val;
42314     int code; /* UCS code point */
42315     int n_code;
42316
42317     for (n_code = 0;n_code < gen_nb_int;n_code++) {
42318         mem_base = xmlMemBlocks();
42319         code = gen_int(n_code, 0);
42320
42321         ret_val = xmlUCSIsThaana(code);
42322         desret_int(ret_val);
42323         call_tests++;
42324         des_int(n_code, code, 0);
42325         xmlResetLastError();
42326         if (mem_base != xmlMemBlocks()) {
42327             printf("Leak of %d blocks found in xmlUCSIsThaana",
42328                    xmlMemBlocks() - mem_base);
42329             test_ret++;
42330             printf(" %d", n_code);
42331             printf("\n");
42332         }
42333     }
42334     function_tests++;
42335 #endif
42336
42337     return(test_ret);
42338 }
42339
42340
42341 static int
42342 test_xmlUCSIsThai(void) {
42343     int test_ret = 0;
42344
42345 #if defined(LIBXML_UNICODE_ENABLED)
42346     int mem_base;
42347     int ret_val;
42348     int code; /* UCS code point */
42349     int n_code;
42350
42351     for (n_code = 0;n_code < gen_nb_int;n_code++) {
42352         mem_base = xmlMemBlocks();
42353         code = gen_int(n_code, 0);
42354
42355         ret_val = xmlUCSIsThai(code);
42356         desret_int(ret_val);
42357         call_tests++;
42358         des_int(n_code, code, 0);
42359         xmlResetLastError();
42360         if (mem_base != xmlMemBlocks()) {
42361             printf("Leak of %d blocks found in xmlUCSIsThai",
42362                    xmlMemBlocks() - mem_base);
42363             test_ret++;
42364             printf(" %d", n_code);
42365             printf("\n");
42366         }
42367     }
42368     function_tests++;
42369 #endif
42370
42371     return(test_ret);
42372 }
42373
42374
42375 static int
42376 test_xmlUCSIsTibetan(void) {
42377     int test_ret = 0;
42378
42379 #if defined(LIBXML_UNICODE_ENABLED)
42380     int mem_base;
42381     int ret_val;
42382     int code; /* UCS code point */
42383     int n_code;
42384
42385     for (n_code = 0;n_code < gen_nb_int;n_code++) {
42386         mem_base = xmlMemBlocks();
42387         code = gen_int(n_code, 0);
42388
42389         ret_val = xmlUCSIsTibetan(code);
42390         desret_int(ret_val);
42391         call_tests++;
42392         des_int(n_code, code, 0);
42393         xmlResetLastError();
42394         if (mem_base != xmlMemBlocks()) {
42395             printf("Leak of %d blocks found in xmlUCSIsTibetan",
42396                    xmlMemBlocks() - mem_base);
42397             test_ret++;
42398             printf(" %d", n_code);
42399             printf("\n");
42400         }
42401     }
42402     function_tests++;
42403 #endif
42404
42405     return(test_ret);
42406 }
42407
42408
42409 static int
42410 test_xmlUCSIsUgaritic(void) {
42411     int test_ret = 0;
42412
42413 #if defined(LIBXML_UNICODE_ENABLED)
42414     int mem_base;
42415     int ret_val;
42416     int code; /* UCS code point */
42417     int n_code;
42418
42419     for (n_code = 0;n_code < gen_nb_int;n_code++) {
42420         mem_base = xmlMemBlocks();
42421         code = gen_int(n_code, 0);
42422
42423         ret_val = xmlUCSIsUgaritic(code);
42424         desret_int(ret_val);
42425         call_tests++;
42426         des_int(n_code, code, 0);
42427         xmlResetLastError();
42428         if (mem_base != xmlMemBlocks()) {
42429             printf("Leak of %d blocks found in xmlUCSIsUgaritic",
42430                    xmlMemBlocks() - mem_base);
42431             test_ret++;
42432             printf(" %d", n_code);
42433             printf("\n");
42434         }
42435     }
42436     function_tests++;
42437 #endif
42438
42439     return(test_ret);
42440 }
42441
42442
42443 static int
42444 test_xmlUCSIsUnifiedCanadianAboriginalSyllabics(void) {
42445     int test_ret = 0;
42446
42447 #if defined(LIBXML_UNICODE_ENABLED)
42448     int mem_base;
42449     int ret_val;
42450     int code; /* UCS code point */
42451     int n_code;
42452
42453     for (n_code = 0;n_code < gen_nb_int;n_code++) {
42454         mem_base = xmlMemBlocks();
42455         code = gen_int(n_code, 0);
42456
42457         ret_val = xmlUCSIsUnifiedCanadianAboriginalSyllabics(code);
42458         desret_int(ret_val);
42459         call_tests++;
42460         des_int(n_code, code, 0);
42461         xmlResetLastError();
42462         if (mem_base != xmlMemBlocks()) {
42463             printf("Leak of %d blocks found in xmlUCSIsUnifiedCanadianAboriginalSyllabics",
42464                    xmlMemBlocks() - mem_base);
42465             test_ret++;
42466             printf(" %d", n_code);
42467             printf("\n");
42468         }
42469     }
42470     function_tests++;
42471 #endif
42472
42473     return(test_ret);
42474 }
42475
42476
42477 static int
42478 test_xmlUCSIsVariationSelectors(void) {
42479     int test_ret = 0;
42480
42481 #if defined(LIBXML_UNICODE_ENABLED)
42482     int mem_base;
42483     int ret_val;
42484     int code; /* UCS code point */
42485     int n_code;
42486
42487     for (n_code = 0;n_code < gen_nb_int;n_code++) {
42488         mem_base = xmlMemBlocks();
42489         code = gen_int(n_code, 0);
42490
42491         ret_val = xmlUCSIsVariationSelectors(code);
42492         desret_int(ret_val);
42493         call_tests++;
42494         des_int(n_code, code, 0);
42495         xmlResetLastError();
42496         if (mem_base != xmlMemBlocks()) {
42497             printf("Leak of %d blocks found in xmlUCSIsVariationSelectors",
42498                    xmlMemBlocks() - mem_base);
42499             test_ret++;
42500             printf(" %d", n_code);
42501             printf("\n");
42502         }
42503     }
42504     function_tests++;
42505 #endif
42506
42507     return(test_ret);
42508 }
42509
42510
42511 static int
42512 test_xmlUCSIsVariationSelectorsSupplement(void) {
42513     int test_ret = 0;
42514
42515 #if defined(LIBXML_UNICODE_ENABLED)
42516     int mem_base;
42517     int ret_val;
42518     int code; /* UCS code point */
42519     int n_code;
42520
42521     for (n_code = 0;n_code < gen_nb_int;n_code++) {
42522         mem_base = xmlMemBlocks();
42523         code = gen_int(n_code, 0);
42524
42525         ret_val = xmlUCSIsVariationSelectorsSupplement(code);
42526         desret_int(ret_val);
42527         call_tests++;
42528         des_int(n_code, code, 0);
42529         xmlResetLastError();
42530         if (mem_base != xmlMemBlocks()) {
42531             printf("Leak of %d blocks found in xmlUCSIsVariationSelectorsSupplement",
42532                    xmlMemBlocks() - mem_base);
42533             test_ret++;
42534             printf(" %d", n_code);
42535             printf("\n");
42536         }
42537     }
42538     function_tests++;
42539 #endif
42540
42541     return(test_ret);
42542 }
42543
42544
42545 static int
42546 test_xmlUCSIsYiRadicals(void) {
42547     int test_ret = 0;
42548
42549 #if defined(LIBXML_UNICODE_ENABLED)
42550     int mem_base;
42551     int ret_val;
42552     int code; /* UCS code point */
42553     int n_code;
42554
42555     for (n_code = 0;n_code < gen_nb_int;n_code++) {
42556         mem_base = xmlMemBlocks();
42557         code = gen_int(n_code, 0);
42558
42559         ret_val = xmlUCSIsYiRadicals(code);
42560         desret_int(ret_val);
42561         call_tests++;
42562         des_int(n_code, code, 0);
42563         xmlResetLastError();
42564         if (mem_base != xmlMemBlocks()) {
42565             printf("Leak of %d blocks found in xmlUCSIsYiRadicals",
42566                    xmlMemBlocks() - mem_base);
42567             test_ret++;
42568             printf(" %d", n_code);
42569             printf("\n");
42570         }
42571     }
42572     function_tests++;
42573 #endif
42574
42575     return(test_ret);
42576 }
42577
42578
42579 static int
42580 test_xmlUCSIsYiSyllables(void) {
42581     int test_ret = 0;
42582
42583 #if defined(LIBXML_UNICODE_ENABLED)
42584     int mem_base;
42585     int ret_val;
42586     int code; /* UCS code point */
42587     int n_code;
42588
42589     for (n_code = 0;n_code < gen_nb_int;n_code++) {
42590         mem_base = xmlMemBlocks();
42591         code = gen_int(n_code, 0);
42592
42593         ret_val = xmlUCSIsYiSyllables(code);
42594         desret_int(ret_val);
42595         call_tests++;
42596         des_int(n_code, code, 0);
42597         xmlResetLastError();
42598         if (mem_base != xmlMemBlocks()) {
42599             printf("Leak of %d blocks found in xmlUCSIsYiSyllables",
42600                    xmlMemBlocks() - mem_base);
42601             test_ret++;
42602             printf(" %d", n_code);
42603             printf("\n");
42604         }
42605     }
42606     function_tests++;
42607 #endif
42608
42609     return(test_ret);
42610 }
42611
42612
42613 static int
42614 test_xmlUCSIsYijingHexagramSymbols(void) {
42615     int test_ret = 0;
42616
42617 #if defined(LIBXML_UNICODE_ENABLED)
42618     int mem_base;
42619     int ret_val;
42620     int code; /* UCS code point */
42621     int n_code;
42622
42623     for (n_code = 0;n_code < gen_nb_int;n_code++) {
42624         mem_base = xmlMemBlocks();
42625         code = gen_int(n_code, 0);
42626
42627         ret_val = xmlUCSIsYijingHexagramSymbols(code);
42628         desret_int(ret_val);
42629         call_tests++;
42630         des_int(n_code, code, 0);
42631         xmlResetLastError();
42632         if (mem_base != xmlMemBlocks()) {
42633             printf("Leak of %d blocks found in xmlUCSIsYijingHexagramSymbols",
42634                    xmlMemBlocks() - mem_base);
42635             test_ret++;
42636             printf(" %d", n_code);
42637             printf("\n");
42638         }
42639     }
42640     function_tests++;
42641 #endif
42642
42643     return(test_ret);
42644 }
42645
42646 static int
42647 test_xmlunicode(void) {
42648     int test_ret = 0;
42649
42650     if (quiet == 0) printf("Testing xmlunicode : 166 of 166 functions ...\n");
42651     test_ret += test_xmlUCSIsAegeanNumbers();
42652     test_ret += test_xmlUCSIsAlphabeticPresentationForms();
42653     test_ret += test_xmlUCSIsArabic();
42654     test_ret += test_xmlUCSIsArabicPresentationFormsA();
42655     test_ret += test_xmlUCSIsArabicPresentationFormsB();
42656     test_ret += test_xmlUCSIsArmenian();
42657     test_ret += test_xmlUCSIsArrows();
42658     test_ret += test_xmlUCSIsBasicLatin();
42659     test_ret += test_xmlUCSIsBengali();
42660     test_ret += test_xmlUCSIsBlock();
42661     test_ret += test_xmlUCSIsBlockElements();
42662     test_ret += test_xmlUCSIsBopomofo();
42663     test_ret += test_xmlUCSIsBopomofoExtended();
42664     test_ret += test_xmlUCSIsBoxDrawing();
42665     test_ret += test_xmlUCSIsBraillePatterns();
42666     test_ret += test_xmlUCSIsBuhid();
42667     test_ret += test_xmlUCSIsByzantineMusicalSymbols();
42668     test_ret += test_xmlUCSIsCJKCompatibility();
42669     test_ret += test_xmlUCSIsCJKCompatibilityForms();
42670     test_ret += test_xmlUCSIsCJKCompatibilityIdeographs();
42671     test_ret += test_xmlUCSIsCJKCompatibilityIdeographsSupplement();
42672     test_ret += test_xmlUCSIsCJKRadicalsSupplement();
42673     test_ret += test_xmlUCSIsCJKSymbolsandPunctuation();
42674     test_ret += test_xmlUCSIsCJKUnifiedIdeographs();
42675     test_ret += test_xmlUCSIsCJKUnifiedIdeographsExtensionA();
42676     test_ret += test_xmlUCSIsCJKUnifiedIdeographsExtensionB();
42677     test_ret += test_xmlUCSIsCat();
42678     test_ret += test_xmlUCSIsCatC();
42679     test_ret += test_xmlUCSIsCatCc();
42680     test_ret += test_xmlUCSIsCatCf();
42681     test_ret += test_xmlUCSIsCatCo();
42682     test_ret += test_xmlUCSIsCatCs();
42683     test_ret += test_xmlUCSIsCatL();
42684     test_ret += test_xmlUCSIsCatLl();
42685     test_ret += test_xmlUCSIsCatLm();
42686     test_ret += test_xmlUCSIsCatLo();
42687     test_ret += test_xmlUCSIsCatLt();
42688     test_ret += test_xmlUCSIsCatLu();
42689     test_ret += test_xmlUCSIsCatM();
42690     test_ret += test_xmlUCSIsCatMc();
42691     test_ret += test_xmlUCSIsCatMe();
42692     test_ret += test_xmlUCSIsCatMn();
42693     test_ret += test_xmlUCSIsCatN();
42694     test_ret += test_xmlUCSIsCatNd();
42695     test_ret += test_xmlUCSIsCatNl();
42696     test_ret += test_xmlUCSIsCatNo();
42697     test_ret += test_xmlUCSIsCatP();
42698     test_ret += test_xmlUCSIsCatPc();
42699     test_ret += test_xmlUCSIsCatPd();
42700     test_ret += test_xmlUCSIsCatPe();
42701     test_ret += test_xmlUCSIsCatPf();
42702     test_ret += test_xmlUCSIsCatPi();
42703     test_ret += test_xmlUCSIsCatPo();
42704     test_ret += test_xmlUCSIsCatPs();
42705     test_ret += test_xmlUCSIsCatS();
42706     test_ret += test_xmlUCSIsCatSc();
42707     test_ret += test_xmlUCSIsCatSk();
42708     test_ret += test_xmlUCSIsCatSm();
42709     test_ret += test_xmlUCSIsCatSo();
42710     test_ret += test_xmlUCSIsCatZ();
42711     test_ret += test_xmlUCSIsCatZl();
42712     test_ret += test_xmlUCSIsCatZp();
42713     test_ret += test_xmlUCSIsCatZs();
42714     test_ret += test_xmlUCSIsCherokee();
42715     test_ret += test_xmlUCSIsCombiningDiacriticalMarks();
42716     test_ret += test_xmlUCSIsCombiningDiacriticalMarksforSymbols();
42717     test_ret += test_xmlUCSIsCombiningHalfMarks();
42718     test_ret += test_xmlUCSIsCombiningMarksforSymbols();
42719     test_ret += test_xmlUCSIsControlPictures();
42720     test_ret += test_xmlUCSIsCurrencySymbols();
42721     test_ret += test_xmlUCSIsCypriotSyllabary();
42722     test_ret += test_xmlUCSIsCyrillic();
42723     test_ret += test_xmlUCSIsCyrillicSupplement();
42724     test_ret += test_xmlUCSIsDeseret();
42725     test_ret += test_xmlUCSIsDevanagari();
42726     test_ret += test_xmlUCSIsDingbats();
42727     test_ret += test_xmlUCSIsEnclosedAlphanumerics();
42728     test_ret += test_xmlUCSIsEnclosedCJKLettersandMonths();
42729     test_ret += test_xmlUCSIsEthiopic();
42730     test_ret += test_xmlUCSIsGeneralPunctuation();
42731     test_ret += test_xmlUCSIsGeometricShapes();
42732     test_ret += test_xmlUCSIsGeorgian();
42733     test_ret += test_xmlUCSIsGothic();
42734     test_ret += test_xmlUCSIsGreek();
42735     test_ret += test_xmlUCSIsGreekExtended();
42736     test_ret += test_xmlUCSIsGreekandCoptic();
42737     test_ret += test_xmlUCSIsGujarati();
42738     test_ret += test_xmlUCSIsGurmukhi();
42739     test_ret += test_xmlUCSIsHalfwidthandFullwidthForms();
42740     test_ret += test_xmlUCSIsHangulCompatibilityJamo();
42741     test_ret += test_xmlUCSIsHangulJamo();
42742     test_ret += test_xmlUCSIsHangulSyllables();
42743     test_ret += test_xmlUCSIsHanunoo();
42744     test_ret += test_xmlUCSIsHebrew();
42745     test_ret += test_xmlUCSIsHighPrivateUseSurrogates();
42746     test_ret += test_xmlUCSIsHighSurrogates();
42747     test_ret += test_xmlUCSIsHiragana();
42748     test_ret += test_xmlUCSIsIPAExtensions();
42749     test_ret += test_xmlUCSIsIdeographicDescriptionCharacters();
42750     test_ret += test_xmlUCSIsKanbun();
42751     test_ret += test_xmlUCSIsKangxiRadicals();
42752     test_ret += test_xmlUCSIsKannada();
42753     test_ret += test_xmlUCSIsKatakana();
42754     test_ret += test_xmlUCSIsKatakanaPhoneticExtensions();
42755     test_ret += test_xmlUCSIsKhmer();
42756     test_ret += test_xmlUCSIsKhmerSymbols();
42757     test_ret += test_xmlUCSIsLao();
42758     test_ret += test_xmlUCSIsLatin1Supplement();
42759     test_ret += test_xmlUCSIsLatinExtendedA();
42760     test_ret += test_xmlUCSIsLatinExtendedAdditional();
42761     test_ret += test_xmlUCSIsLatinExtendedB();
42762     test_ret += test_xmlUCSIsLetterlikeSymbols();
42763     test_ret += test_xmlUCSIsLimbu();
42764     test_ret += test_xmlUCSIsLinearBIdeograms();
42765     test_ret += test_xmlUCSIsLinearBSyllabary();
42766     test_ret += test_xmlUCSIsLowSurrogates();
42767     test_ret += test_xmlUCSIsMalayalam();
42768     test_ret += test_xmlUCSIsMathematicalAlphanumericSymbols();
42769     test_ret += test_xmlUCSIsMathematicalOperators();
42770     test_ret += test_xmlUCSIsMiscellaneousMathematicalSymbolsA();
42771     test_ret += test_xmlUCSIsMiscellaneousMathematicalSymbolsB();
42772     test_ret += test_xmlUCSIsMiscellaneousSymbols();
42773     test_ret += test_xmlUCSIsMiscellaneousSymbolsandArrows();
42774     test_ret += test_xmlUCSIsMiscellaneousTechnical();
42775     test_ret += test_xmlUCSIsMongolian();
42776     test_ret += test_xmlUCSIsMusicalSymbols();
42777     test_ret += test_xmlUCSIsMyanmar();
42778     test_ret += test_xmlUCSIsNumberForms();
42779     test_ret += test_xmlUCSIsOgham();
42780     test_ret += test_xmlUCSIsOldItalic();
42781     test_ret += test_xmlUCSIsOpticalCharacterRecognition();
42782     test_ret += test_xmlUCSIsOriya();
42783     test_ret += test_xmlUCSIsOsmanya();
42784     test_ret += test_xmlUCSIsPhoneticExtensions();
42785     test_ret += test_xmlUCSIsPrivateUse();
42786     test_ret += test_xmlUCSIsPrivateUseArea();
42787     test_ret += test_xmlUCSIsRunic();
42788     test_ret += test_xmlUCSIsShavian();
42789     test_ret += test_xmlUCSIsSinhala();
42790     test_ret += test_xmlUCSIsSmallFormVariants();
42791     test_ret += test_xmlUCSIsSpacingModifierLetters();
42792     test_ret += test_xmlUCSIsSpecials();
42793     test_ret += test_xmlUCSIsSuperscriptsandSubscripts();
42794     test_ret += test_xmlUCSIsSupplementalArrowsA();
42795     test_ret += test_xmlUCSIsSupplementalArrowsB();
42796     test_ret += test_xmlUCSIsSupplementalMathematicalOperators();
42797     test_ret += test_xmlUCSIsSupplementaryPrivateUseAreaA();
42798     test_ret += test_xmlUCSIsSupplementaryPrivateUseAreaB();
42799     test_ret += test_xmlUCSIsSyriac();
42800     test_ret += test_xmlUCSIsTagalog();
42801     test_ret += test_xmlUCSIsTagbanwa();
42802     test_ret += test_xmlUCSIsTags();
42803     test_ret += test_xmlUCSIsTaiLe();
42804     test_ret += test_xmlUCSIsTaiXuanJingSymbols();
42805     test_ret += test_xmlUCSIsTamil();
42806     test_ret += test_xmlUCSIsTelugu();
42807     test_ret += test_xmlUCSIsThaana();
42808     test_ret += test_xmlUCSIsThai();
42809     test_ret += test_xmlUCSIsTibetan();
42810     test_ret += test_xmlUCSIsUgaritic();
42811     test_ret += test_xmlUCSIsUnifiedCanadianAboriginalSyllabics();
42812     test_ret += test_xmlUCSIsVariationSelectors();
42813     test_ret += test_xmlUCSIsVariationSelectorsSupplement();
42814     test_ret += test_xmlUCSIsYiRadicals();
42815     test_ret += test_xmlUCSIsYiSyllables();
42816     test_ret += test_xmlUCSIsYijingHexagramSymbols();
42817
42818     if (test_ret != 0)
42819         printf("Module xmlunicode: %d errors\n", test_ret);
42820     return(test_ret);
42821 }
42822
42823 static int
42824 test_xmlNewTextWriter(void) {
42825     int test_ret = 0;
42826
42827 #if defined(LIBXML_WRITER_ENABLED)
42828     int mem_base;
42829     xmlTextWriterPtr ret_val;
42830     xmlOutputBufferPtr out; /* an xmlOutputBufferPtr */
42831     int n_out;
42832
42833     for (n_out = 0;n_out < gen_nb_xmlOutputBufferPtr;n_out++) {
42834         mem_base = xmlMemBlocks();
42835         out = gen_xmlOutputBufferPtr(n_out, 0);
42836
42837         ret_val = xmlNewTextWriter(out);
42838         if (ret_val != NULL) out = NULL;
42839         desret_xmlTextWriterPtr(ret_val);
42840         call_tests++;
42841         des_xmlOutputBufferPtr(n_out, out, 0);
42842         xmlResetLastError();
42843         if (mem_base != xmlMemBlocks()) {
42844             printf("Leak of %d blocks found in xmlNewTextWriter",
42845                    xmlMemBlocks() - mem_base);
42846             test_ret++;
42847             printf(" %d", n_out);
42848             printf("\n");
42849         }
42850     }
42851     function_tests++;
42852 #endif
42853
42854     return(test_ret);
42855 }
42856
42857
42858 static int
42859 test_xmlNewTextWriterFilename(void) {
42860     int test_ret = 0;
42861
42862 #if defined(LIBXML_WRITER_ENABLED)
42863     int mem_base;
42864     xmlTextWriterPtr ret_val;
42865     const char * uri; /* the URI of the resource for the output */
42866     int n_uri;
42867     int compression; /* compress the output? */
42868     int n_compression;
42869
42870     for (n_uri = 0;n_uri < gen_nb_fileoutput;n_uri++) {
42871     for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
42872         mem_base = xmlMemBlocks();
42873         uri = gen_fileoutput(n_uri, 0);
42874         compression = gen_int(n_compression, 1);
42875
42876         ret_val = xmlNewTextWriterFilename(uri, compression);
42877         desret_xmlTextWriterPtr(ret_val);
42878         call_tests++;
42879         des_fileoutput(n_uri, uri, 0);
42880         des_int(n_compression, compression, 1);
42881         xmlResetLastError();
42882         if (mem_base != xmlMemBlocks()) {
42883             printf("Leak of %d blocks found in xmlNewTextWriterFilename",
42884                    xmlMemBlocks() - mem_base);
42885             test_ret++;
42886             printf(" %d", n_uri);
42887             printf(" %d", n_compression);
42888             printf("\n");
42889         }
42890     }
42891     }
42892     function_tests++;
42893 #endif
42894
42895     return(test_ret);
42896 }
42897
42898
42899 static int
42900 test_xmlNewTextWriterMemory(void) {
42901     int test_ret = 0;
42902
42903 #if defined(LIBXML_WRITER_ENABLED)
42904     int mem_base;
42905     xmlTextWriterPtr ret_val;
42906     xmlBufferPtr buf; /* xmlBufferPtr */
42907     int n_buf;
42908     int compression; /* compress the output? */
42909     int n_compression;
42910
42911     for (n_buf = 0;n_buf < gen_nb_xmlBufferPtr;n_buf++) {
42912     for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
42913         mem_base = xmlMemBlocks();
42914         buf = gen_xmlBufferPtr(n_buf, 0);
42915         compression = gen_int(n_compression, 1);
42916
42917         ret_val = xmlNewTextWriterMemory(buf, compression);
42918         desret_xmlTextWriterPtr(ret_val);
42919         call_tests++;
42920         des_xmlBufferPtr(n_buf, buf, 0);
42921         des_int(n_compression, compression, 1);
42922         xmlResetLastError();
42923         if (mem_base != xmlMemBlocks()) {
42924             printf("Leak of %d blocks found in xmlNewTextWriterMemory",
42925                    xmlMemBlocks() - mem_base);
42926             test_ret++;
42927             printf(" %d", n_buf);
42928             printf(" %d", n_compression);
42929             printf("\n");
42930         }
42931     }
42932     }
42933     function_tests++;
42934 #endif
42935
42936     return(test_ret);
42937 }
42938
42939
42940 static int
42941 test_xmlNewTextWriterPushParser(void) {
42942     int test_ret = 0;
42943
42944 #if defined(LIBXML_WRITER_ENABLED)
42945     int mem_base;
42946     xmlTextWriterPtr ret_val;
42947     xmlParserCtxtPtr ctxt; /* xmlParserCtxtPtr to hold the new XML document tree */
42948     int n_ctxt;
42949     int compression; /* compress the output? */
42950     int n_compression;
42951
42952     for (n_ctxt = 0;n_ctxt < gen_nb_xmlParserCtxtPtr;n_ctxt++) {
42953     for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
42954         mem_base = xmlMemBlocks();
42955         ctxt = gen_xmlParserCtxtPtr(n_ctxt, 0);
42956         compression = gen_int(n_compression, 1);
42957
42958         ret_val = xmlNewTextWriterPushParser(ctxt, compression);
42959         if (ctxt != NULL) {xmlFreeDoc(ctxt->myDoc); ctxt->myDoc = NULL;} if (ret_val != NULL) ctxt = NULL;
42960         desret_xmlTextWriterPtr(ret_val);
42961         call_tests++;
42962         des_xmlParserCtxtPtr(n_ctxt, ctxt, 0);
42963         des_int(n_compression, compression, 1);
42964         xmlResetLastError();
42965         if (mem_base != xmlMemBlocks()) {
42966             printf("Leak of %d blocks found in xmlNewTextWriterPushParser",
42967                    xmlMemBlocks() - mem_base);
42968             test_ret++;
42969             printf(" %d", n_ctxt);
42970             printf(" %d", n_compression);
42971             printf("\n");
42972         }
42973     }
42974     }
42975     function_tests++;
42976 #endif
42977
42978     return(test_ret);
42979 }
42980
42981
42982 static int
42983 test_xmlNewTextWriterTree(void) {
42984     int test_ret = 0;
42985
42986 #if defined(LIBXML_WRITER_ENABLED)
42987     int mem_base;
42988     xmlTextWriterPtr ret_val;
42989     xmlDocPtr doc; /* xmlDocPtr */
42990     int n_doc;
42991     xmlNodePtr node; /* xmlNodePtr or NULL for doc->children */
42992     int n_node;
42993     int compression; /* compress the output? */
42994     int n_compression;
42995
42996     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
42997     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
42998     for (n_compression = 0;n_compression < gen_nb_int;n_compression++) {
42999         mem_base = xmlMemBlocks();
43000         doc = gen_xmlDocPtr(n_doc, 0);
43001         node = gen_xmlNodePtr(n_node, 1);
43002         compression = gen_int(n_compression, 2);
43003
43004         ret_val = xmlNewTextWriterTree(doc, node, compression);
43005         desret_xmlTextWriterPtr(ret_val);
43006         call_tests++;
43007         des_xmlDocPtr(n_doc, doc, 0);
43008         des_xmlNodePtr(n_node, node, 1);
43009         des_int(n_compression, compression, 2);
43010         xmlResetLastError();
43011         if (mem_base != xmlMemBlocks()) {
43012             printf("Leak of %d blocks found in xmlNewTextWriterTree",
43013                    xmlMemBlocks() - mem_base);
43014             test_ret++;
43015             printf(" %d", n_doc);
43016             printf(" %d", n_node);
43017             printf(" %d", n_compression);
43018             printf("\n");
43019         }
43020     }
43021     }
43022     }
43023     function_tests++;
43024 #endif
43025
43026     return(test_ret);
43027 }
43028
43029
43030 static int
43031 test_xmlTextWriterEndAttribute(void) {
43032     int test_ret = 0;
43033
43034 #if defined(LIBXML_WRITER_ENABLED)
43035     int mem_base;
43036     int ret_val;
43037     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43038     int n_writer;
43039
43040     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43041         mem_base = xmlMemBlocks();
43042         writer = gen_xmlTextWriterPtr(n_writer, 0);
43043
43044         ret_val = xmlTextWriterEndAttribute(writer);
43045         desret_int(ret_val);
43046         call_tests++;
43047         des_xmlTextWriterPtr(n_writer, writer, 0);
43048         xmlResetLastError();
43049         if (mem_base != xmlMemBlocks()) {
43050             printf("Leak of %d blocks found in xmlTextWriterEndAttribute",
43051                    xmlMemBlocks() - mem_base);
43052             test_ret++;
43053             printf(" %d", n_writer);
43054             printf("\n");
43055         }
43056     }
43057     function_tests++;
43058 #endif
43059
43060     return(test_ret);
43061 }
43062
43063
43064 static int
43065 test_xmlTextWriterEndCDATA(void) {
43066     int test_ret = 0;
43067
43068 #if defined(LIBXML_WRITER_ENABLED)
43069     int mem_base;
43070     int ret_val;
43071     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43072     int n_writer;
43073
43074     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43075         mem_base = xmlMemBlocks();
43076         writer = gen_xmlTextWriterPtr(n_writer, 0);
43077
43078         ret_val = xmlTextWriterEndCDATA(writer);
43079         desret_int(ret_val);
43080         call_tests++;
43081         des_xmlTextWriterPtr(n_writer, writer, 0);
43082         xmlResetLastError();
43083         if (mem_base != xmlMemBlocks()) {
43084             printf("Leak of %d blocks found in xmlTextWriterEndCDATA",
43085                    xmlMemBlocks() - mem_base);
43086             test_ret++;
43087             printf(" %d", n_writer);
43088             printf("\n");
43089         }
43090     }
43091     function_tests++;
43092 #endif
43093
43094     return(test_ret);
43095 }
43096
43097
43098 static int
43099 test_xmlTextWriterEndComment(void) {
43100     int test_ret = 0;
43101
43102 #if defined(LIBXML_WRITER_ENABLED)
43103     int mem_base;
43104     int ret_val;
43105     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43106     int n_writer;
43107
43108     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43109         mem_base = xmlMemBlocks();
43110         writer = gen_xmlTextWriterPtr(n_writer, 0);
43111
43112         ret_val = xmlTextWriterEndComment(writer);
43113         desret_int(ret_val);
43114         call_tests++;
43115         des_xmlTextWriterPtr(n_writer, writer, 0);
43116         xmlResetLastError();
43117         if (mem_base != xmlMemBlocks()) {
43118             printf("Leak of %d blocks found in xmlTextWriterEndComment",
43119                    xmlMemBlocks() - mem_base);
43120             test_ret++;
43121             printf(" %d", n_writer);
43122             printf("\n");
43123         }
43124     }
43125     function_tests++;
43126 #endif
43127
43128     return(test_ret);
43129 }
43130
43131
43132 static int
43133 test_xmlTextWriterEndDTD(void) {
43134     int test_ret = 0;
43135
43136 #if defined(LIBXML_WRITER_ENABLED)
43137     int mem_base;
43138     int ret_val;
43139     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43140     int n_writer;
43141
43142     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43143         mem_base = xmlMemBlocks();
43144         writer = gen_xmlTextWriterPtr(n_writer, 0);
43145
43146         ret_val = xmlTextWriterEndDTD(writer);
43147         desret_int(ret_val);
43148         call_tests++;
43149         des_xmlTextWriterPtr(n_writer, writer, 0);
43150         xmlResetLastError();
43151         if (mem_base != xmlMemBlocks()) {
43152             printf("Leak of %d blocks found in xmlTextWriterEndDTD",
43153                    xmlMemBlocks() - mem_base);
43154             test_ret++;
43155             printf(" %d", n_writer);
43156             printf("\n");
43157         }
43158     }
43159     function_tests++;
43160 #endif
43161
43162     return(test_ret);
43163 }
43164
43165
43166 static int
43167 test_xmlTextWriterEndDTDAttlist(void) {
43168     int test_ret = 0;
43169
43170 #if defined(LIBXML_WRITER_ENABLED)
43171     int mem_base;
43172     int ret_val;
43173     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43174     int n_writer;
43175
43176     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43177         mem_base = xmlMemBlocks();
43178         writer = gen_xmlTextWriterPtr(n_writer, 0);
43179
43180         ret_val = xmlTextWriterEndDTDAttlist(writer);
43181         desret_int(ret_val);
43182         call_tests++;
43183         des_xmlTextWriterPtr(n_writer, writer, 0);
43184         xmlResetLastError();
43185         if (mem_base != xmlMemBlocks()) {
43186             printf("Leak of %d blocks found in xmlTextWriterEndDTDAttlist",
43187                    xmlMemBlocks() - mem_base);
43188             test_ret++;
43189             printf(" %d", n_writer);
43190             printf("\n");
43191         }
43192     }
43193     function_tests++;
43194 #endif
43195
43196     return(test_ret);
43197 }
43198
43199
43200 static int
43201 test_xmlTextWriterEndDTDElement(void) {
43202     int test_ret = 0;
43203
43204 #if defined(LIBXML_WRITER_ENABLED)
43205     int mem_base;
43206     int ret_val;
43207     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43208     int n_writer;
43209
43210     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43211         mem_base = xmlMemBlocks();
43212         writer = gen_xmlTextWriterPtr(n_writer, 0);
43213
43214         ret_val = xmlTextWriterEndDTDElement(writer);
43215         desret_int(ret_val);
43216         call_tests++;
43217         des_xmlTextWriterPtr(n_writer, writer, 0);
43218         xmlResetLastError();
43219         if (mem_base != xmlMemBlocks()) {
43220             printf("Leak of %d blocks found in xmlTextWriterEndDTDElement",
43221                    xmlMemBlocks() - mem_base);
43222             test_ret++;
43223             printf(" %d", n_writer);
43224             printf("\n");
43225         }
43226     }
43227     function_tests++;
43228 #endif
43229
43230     return(test_ret);
43231 }
43232
43233
43234 static int
43235 test_xmlTextWriterEndDTDEntity(void) {
43236     int test_ret = 0;
43237
43238 #if defined(LIBXML_WRITER_ENABLED)
43239     int mem_base;
43240     int ret_val;
43241     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43242     int n_writer;
43243
43244     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43245         mem_base = xmlMemBlocks();
43246         writer = gen_xmlTextWriterPtr(n_writer, 0);
43247
43248         ret_val = xmlTextWriterEndDTDEntity(writer);
43249         desret_int(ret_val);
43250         call_tests++;
43251         des_xmlTextWriterPtr(n_writer, writer, 0);
43252         xmlResetLastError();
43253         if (mem_base != xmlMemBlocks()) {
43254             printf("Leak of %d blocks found in xmlTextWriterEndDTDEntity",
43255                    xmlMemBlocks() - mem_base);
43256             test_ret++;
43257             printf(" %d", n_writer);
43258             printf("\n");
43259         }
43260     }
43261     function_tests++;
43262 #endif
43263
43264     return(test_ret);
43265 }
43266
43267
43268 static int
43269 test_xmlTextWriterEndDocument(void) {
43270     int test_ret = 0;
43271
43272 #if defined(LIBXML_WRITER_ENABLED)
43273     int mem_base;
43274     int ret_val;
43275     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43276     int n_writer;
43277
43278     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43279         mem_base = xmlMemBlocks();
43280         writer = gen_xmlTextWriterPtr(n_writer, 0);
43281
43282         ret_val = xmlTextWriterEndDocument(writer);
43283         desret_int(ret_val);
43284         call_tests++;
43285         des_xmlTextWriterPtr(n_writer, writer, 0);
43286         xmlResetLastError();
43287         if (mem_base != xmlMemBlocks()) {
43288             printf("Leak of %d blocks found in xmlTextWriterEndDocument",
43289                    xmlMemBlocks() - mem_base);
43290             test_ret++;
43291             printf(" %d", n_writer);
43292             printf("\n");
43293         }
43294     }
43295     function_tests++;
43296 #endif
43297
43298     return(test_ret);
43299 }
43300
43301
43302 static int
43303 test_xmlTextWriterEndElement(void) {
43304     int test_ret = 0;
43305
43306 #if defined(LIBXML_WRITER_ENABLED)
43307     int mem_base;
43308     int ret_val;
43309     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43310     int n_writer;
43311
43312     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43313         mem_base = xmlMemBlocks();
43314         writer = gen_xmlTextWriterPtr(n_writer, 0);
43315
43316         ret_val = xmlTextWriterEndElement(writer);
43317         desret_int(ret_val);
43318         call_tests++;
43319         des_xmlTextWriterPtr(n_writer, writer, 0);
43320         xmlResetLastError();
43321         if (mem_base != xmlMemBlocks()) {
43322             printf("Leak of %d blocks found in xmlTextWriterEndElement",
43323                    xmlMemBlocks() - mem_base);
43324             test_ret++;
43325             printf(" %d", n_writer);
43326             printf("\n");
43327         }
43328     }
43329     function_tests++;
43330 #endif
43331
43332     return(test_ret);
43333 }
43334
43335
43336 static int
43337 test_xmlTextWriterEndPI(void) {
43338     int test_ret = 0;
43339
43340 #if defined(LIBXML_WRITER_ENABLED)
43341     int mem_base;
43342     int ret_val;
43343     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43344     int n_writer;
43345
43346     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43347         mem_base = xmlMemBlocks();
43348         writer = gen_xmlTextWriterPtr(n_writer, 0);
43349
43350         ret_val = xmlTextWriterEndPI(writer);
43351         desret_int(ret_val);
43352         call_tests++;
43353         des_xmlTextWriterPtr(n_writer, writer, 0);
43354         xmlResetLastError();
43355         if (mem_base != xmlMemBlocks()) {
43356             printf("Leak of %d blocks found in xmlTextWriterEndPI",
43357                    xmlMemBlocks() - mem_base);
43358             test_ret++;
43359             printf(" %d", n_writer);
43360             printf("\n");
43361         }
43362     }
43363     function_tests++;
43364 #endif
43365
43366     return(test_ret);
43367 }
43368
43369
43370 static int
43371 test_xmlTextWriterFlush(void) {
43372     int test_ret = 0;
43373
43374 #if defined(LIBXML_WRITER_ENABLED)
43375     int mem_base;
43376     int ret_val;
43377     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43378     int n_writer;
43379
43380     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43381         mem_base = xmlMemBlocks();
43382         writer = gen_xmlTextWriterPtr(n_writer, 0);
43383
43384         ret_val = xmlTextWriterFlush(writer);
43385         desret_int(ret_val);
43386         call_tests++;
43387         des_xmlTextWriterPtr(n_writer, writer, 0);
43388         xmlResetLastError();
43389         if (mem_base != xmlMemBlocks()) {
43390             printf("Leak of %d blocks found in xmlTextWriterFlush",
43391                    xmlMemBlocks() - mem_base);
43392             test_ret++;
43393             printf(" %d", n_writer);
43394             printf("\n");
43395         }
43396     }
43397     function_tests++;
43398 #endif
43399
43400     return(test_ret);
43401 }
43402
43403
43404 static int
43405 test_xmlTextWriterFullEndElement(void) {
43406     int test_ret = 0;
43407
43408 #if defined(LIBXML_WRITER_ENABLED)
43409     int mem_base;
43410     int ret_val;
43411     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43412     int n_writer;
43413
43414     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43415         mem_base = xmlMemBlocks();
43416         writer = gen_xmlTextWriterPtr(n_writer, 0);
43417
43418         ret_val = xmlTextWriterFullEndElement(writer);
43419         desret_int(ret_val);
43420         call_tests++;
43421         des_xmlTextWriterPtr(n_writer, writer, 0);
43422         xmlResetLastError();
43423         if (mem_base != xmlMemBlocks()) {
43424             printf("Leak of %d blocks found in xmlTextWriterFullEndElement",
43425                    xmlMemBlocks() - mem_base);
43426             test_ret++;
43427             printf(" %d", n_writer);
43428             printf("\n");
43429         }
43430     }
43431     function_tests++;
43432 #endif
43433
43434     return(test_ret);
43435 }
43436
43437
43438 static int
43439 test_xmlTextWriterSetIndent(void) {
43440     int test_ret = 0;
43441
43442 #if defined(LIBXML_WRITER_ENABLED)
43443     int mem_base;
43444     int ret_val;
43445     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43446     int n_writer;
43447     int indent; /* do indentation? */
43448     int n_indent;
43449
43450     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43451     for (n_indent = 0;n_indent < gen_nb_int;n_indent++) {
43452         mem_base = xmlMemBlocks();
43453         writer = gen_xmlTextWriterPtr(n_writer, 0);
43454         indent = gen_int(n_indent, 1);
43455
43456         ret_val = xmlTextWriterSetIndent(writer, indent);
43457         desret_int(ret_val);
43458         call_tests++;
43459         des_xmlTextWriterPtr(n_writer, writer, 0);
43460         des_int(n_indent, indent, 1);
43461         xmlResetLastError();
43462         if (mem_base != xmlMemBlocks()) {
43463             printf("Leak of %d blocks found in xmlTextWriterSetIndent",
43464                    xmlMemBlocks() - mem_base);
43465             test_ret++;
43466             printf(" %d", n_writer);
43467             printf(" %d", n_indent);
43468             printf("\n");
43469         }
43470     }
43471     }
43472     function_tests++;
43473 #endif
43474
43475     return(test_ret);
43476 }
43477
43478
43479 static int
43480 test_xmlTextWriterSetIndentString(void) {
43481     int test_ret = 0;
43482
43483 #if defined(LIBXML_WRITER_ENABLED)
43484     int mem_base;
43485     int ret_val;
43486     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43487     int n_writer;
43488     xmlChar * str; /* the xmlChar string */
43489     int n_str;
43490
43491     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43492     for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
43493         mem_base = xmlMemBlocks();
43494         writer = gen_xmlTextWriterPtr(n_writer, 0);
43495         str = gen_const_xmlChar_ptr(n_str, 1);
43496
43497         ret_val = xmlTextWriterSetIndentString(writer, (const xmlChar *)str);
43498         desret_int(ret_val);
43499         call_tests++;
43500         des_xmlTextWriterPtr(n_writer, writer, 0);
43501         des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 1);
43502         xmlResetLastError();
43503         if (mem_base != xmlMemBlocks()) {
43504             printf("Leak of %d blocks found in xmlTextWriterSetIndentString",
43505                    xmlMemBlocks() - mem_base);
43506             test_ret++;
43507             printf(" %d", n_writer);
43508             printf(" %d", n_str);
43509             printf("\n");
43510         }
43511     }
43512     }
43513     function_tests++;
43514 #endif
43515
43516     return(test_ret);
43517 }
43518
43519
43520 static int
43521 test_xmlTextWriterStartAttribute(void) {
43522     int test_ret = 0;
43523
43524 #if defined(LIBXML_WRITER_ENABLED)
43525     int mem_base;
43526     int ret_val;
43527     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43528     int n_writer;
43529     xmlChar * name; /* element name */
43530     int n_name;
43531
43532     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43533     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
43534         mem_base = xmlMemBlocks();
43535         writer = gen_xmlTextWriterPtr(n_writer, 0);
43536         name = gen_const_xmlChar_ptr(n_name, 1);
43537
43538         ret_val = xmlTextWriterStartAttribute(writer, (const xmlChar *)name);
43539         desret_int(ret_val);
43540         call_tests++;
43541         des_xmlTextWriterPtr(n_writer, writer, 0);
43542         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
43543         xmlResetLastError();
43544         if (mem_base != xmlMemBlocks()) {
43545             printf("Leak of %d blocks found in xmlTextWriterStartAttribute",
43546                    xmlMemBlocks() - mem_base);
43547             test_ret++;
43548             printf(" %d", n_writer);
43549             printf(" %d", n_name);
43550             printf("\n");
43551         }
43552     }
43553     }
43554     function_tests++;
43555 #endif
43556
43557     return(test_ret);
43558 }
43559
43560
43561 static int
43562 test_xmlTextWriterStartAttributeNS(void) {
43563     int test_ret = 0;
43564
43565 #if defined(LIBXML_WRITER_ENABLED)
43566     int mem_base;
43567     int ret_val;
43568     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43569     int n_writer;
43570     xmlChar * prefix; /* namespace prefix or NULL */
43571     int n_prefix;
43572     xmlChar * name; /* element local name */
43573     int n_name;
43574     xmlChar * namespaceURI; /* namespace URI or NULL */
43575     int n_namespaceURI;
43576
43577     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43578     for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
43579     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
43580     for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
43581         mem_base = xmlMemBlocks();
43582         writer = gen_xmlTextWriterPtr(n_writer, 0);
43583         prefix = gen_const_xmlChar_ptr(n_prefix, 1);
43584         name = gen_const_xmlChar_ptr(n_name, 2);
43585         namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 3);
43586
43587         ret_val = xmlTextWriterStartAttributeNS(writer, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)namespaceURI);
43588         desret_int(ret_val);
43589         call_tests++;
43590         des_xmlTextWriterPtr(n_writer, writer, 0);
43591         des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
43592         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
43593         des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 3);
43594         xmlResetLastError();
43595         if (mem_base != xmlMemBlocks()) {
43596             printf("Leak of %d blocks found in xmlTextWriterStartAttributeNS",
43597                    xmlMemBlocks() - mem_base);
43598             test_ret++;
43599             printf(" %d", n_writer);
43600             printf(" %d", n_prefix);
43601             printf(" %d", n_name);
43602             printf(" %d", n_namespaceURI);
43603             printf("\n");
43604         }
43605     }
43606     }
43607     }
43608     }
43609     function_tests++;
43610 #endif
43611
43612     return(test_ret);
43613 }
43614
43615
43616 static int
43617 test_xmlTextWriterStartCDATA(void) {
43618     int test_ret = 0;
43619
43620 #if defined(LIBXML_WRITER_ENABLED)
43621     int mem_base;
43622     int ret_val;
43623     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43624     int n_writer;
43625
43626     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43627         mem_base = xmlMemBlocks();
43628         writer = gen_xmlTextWriterPtr(n_writer, 0);
43629
43630         ret_val = xmlTextWriterStartCDATA(writer);
43631         desret_int(ret_val);
43632         call_tests++;
43633         des_xmlTextWriterPtr(n_writer, writer, 0);
43634         xmlResetLastError();
43635         if (mem_base != xmlMemBlocks()) {
43636             printf("Leak of %d blocks found in xmlTextWriterStartCDATA",
43637                    xmlMemBlocks() - mem_base);
43638             test_ret++;
43639             printf(" %d", n_writer);
43640             printf("\n");
43641         }
43642     }
43643     function_tests++;
43644 #endif
43645
43646     return(test_ret);
43647 }
43648
43649
43650 static int
43651 test_xmlTextWriterStartComment(void) {
43652     int test_ret = 0;
43653
43654 #if defined(LIBXML_WRITER_ENABLED)
43655     int mem_base;
43656     int ret_val;
43657     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43658     int n_writer;
43659
43660     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43661         mem_base = xmlMemBlocks();
43662         writer = gen_xmlTextWriterPtr(n_writer, 0);
43663
43664         ret_val = xmlTextWriterStartComment(writer);
43665         desret_int(ret_val);
43666         call_tests++;
43667         des_xmlTextWriterPtr(n_writer, writer, 0);
43668         xmlResetLastError();
43669         if (mem_base != xmlMemBlocks()) {
43670             printf("Leak of %d blocks found in xmlTextWriterStartComment",
43671                    xmlMemBlocks() - mem_base);
43672             test_ret++;
43673             printf(" %d", n_writer);
43674             printf("\n");
43675         }
43676     }
43677     function_tests++;
43678 #endif
43679
43680     return(test_ret);
43681 }
43682
43683
43684 static int
43685 test_xmlTextWriterStartDTD(void) {
43686     int test_ret = 0;
43687
43688 #if defined(LIBXML_WRITER_ENABLED)
43689     int mem_base;
43690     int ret_val;
43691     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43692     int n_writer;
43693     xmlChar * name; /* the name of the DTD */
43694     int n_name;
43695     xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
43696     int n_pubid;
43697     xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
43698     int n_sysid;
43699
43700     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43701     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
43702     for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
43703     for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
43704         mem_base = xmlMemBlocks();
43705         writer = gen_xmlTextWriterPtr(n_writer, 0);
43706         name = gen_const_xmlChar_ptr(n_name, 1);
43707         pubid = gen_const_xmlChar_ptr(n_pubid, 2);
43708         sysid = gen_const_xmlChar_ptr(n_sysid, 3);
43709
43710         ret_val = xmlTextWriterStartDTD(writer, (const xmlChar *)name, (const xmlChar *)pubid, (const xmlChar *)sysid);
43711         desret_int(ret_val);
43712         call_tests++;
43713         des_xmlTextWriterPtr(n_writer, writer, 0);
43714         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
43715         des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 2);
43716         des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 3);
43717         xmlResetLastError();
43718         if (mem_base != xmlMemBlocks()) {
43719             printf("Leak of %d blocks found in xmlTextWriterStartDTD",
43720                    xmlMemBlocks() - mem_base);
43721             test_ret++;
43722             printf(" %d", n_writer);
43723             printf(" %d", n_name);
43724             printf(" %d", n_pubid);
43725             printf(" %d", n_sysid);
43726             printf("\n");
43727         }
43728     }
43729     }
43730     }
43731     }
43732     function_tests++;
43733 #endif
43734
43735     return(test_ret);
43736 }
43737
43738
43739 static int
43740 test_xmlTextWriterStartDTDAttlist(void) {
43741     int test_ret = 0;
43742
43743 #if defined(LIBXML_WRITER_ENABLED)
43744     int mem_base;
43745     int ret_val;
43746     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43747     int n_writer;
43748     xmlChar * name; /* the name of the DTD ATTLIST */
43749     int n_name;
43750
43751     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43752     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
43753         mem_base = xmlMemBlocks();
43754         writer = gen_xmlTextWriterPtr(n_writer, 0);
43755         name = gen_const_xmlChar_ptr(n_name, 1);
43756
43757         ret_val = xmlTextWriterStartDTDAttlist(writer, (const xmlChar *)name);
43758         desret_int(ret_val);
43759         call_tests++;
43760         des_xmlTextWriterPtr(n_writer, writer, 0);
43761         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
43762         xmlResetLastError();
43763         if (mem_base != xmlMemBlocks()) {
43764             printf("Leak of %d blocks found in xmlTextWriterStartDTDAttlist",
43765                    xmlMemBlocks() - mem_base);
43766             test_ret++;
43767             printf(" %d", n_writer);
43768             printf(" %d", n_name);
43769             printf("\n");
43770         }
43771     }
43772     }
43773     function_tests++;
43774 #endif
43775
43776     return(test_ret);
43777 }
43778
43779
43780 static int
43781 test_xmlTextWriterStartDTDElement(void) {
43782     int test_ret = 0;
43783
43784 #if defined(LIBXML_WRITER_ENABLED)
43785     int mem_base;
43786     int ret_val;
43787     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43788     int n_writer;
43789     xmlChar * name; /* the name of the DTD element */
43790     int n_name;
43791
43792     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43793     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
43794         mem_base = xmlMemBlocks();
43795         writer = gen_xmlTextWriterPtr(n_writer, 0);
43796         name = gen_const_xmlChar_ptr(n_name, 1);
43797
43798         ret_val = xmlTextWriterStartDTDElement(writer, (const xmlChar *)name);
43799         desret_int(ret_val);
43800         call_tests++;
43801         des_xmlTextWriterPtr(n_writer, writer, 0);
43802         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
43803         xmlResetLastError();
43804         if (mem_base != xmlMemBlocks()) {
43805             printf("Leak of %d blocks found in xmlTextWriterStartDTDElement",
43806                    xmlMemBlocks() - mem_base);
43807             test_ret++;
43808             printf(" %d", n_writer);
43809             printf(" %d", n_name);
43810             printf("\n");
43811         }
43812     }
43813     }
43814     function_tests++;
43815 #endif
43816
43817     return(test_ret);
43818 }
43819
43820
43821 static int
43822 test_xmlTextWriterStartDTDEntity(void) {
43823     int test_ret = 0;
43824
43825 #if defined(LIBXML_WRITER_ENABLED)
43826     int mem_base;
43827     int ret_val;
43828     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43829     int n_writer;
43830     int pe; /* TRUE if this is a parameter entity, FALSE if not */
43831     int n_pe;
43832     xmlChar * name; /* the name of the DTD ATTLIST */
43833     int n_name;
43834
43835     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43836     for (n_pe = 0;n_pe < gen_nb_int;n_pe++) {
43837     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
43838         mem_base = xmlMemBlocks();
43839         writer = gen_xmlTextWriterPtr(n_writer, 0);
43840         pe = gen_int(n_pe, 1);
43841         name = gen_const_xmlChar_ptr(n_name, 2);
43842
43843         ret_val = xmlTextWriterStartDTDEntity(writer, pe, (const xmlChar *)name);
43844         desret_int(ret_val);
43845         call_tests++;
43846         des_xmlTextWriterPtr(n_writer, writer, 0);
43847         des_int(n_pe, pe, 1);
43848         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
43849         xmlResetLastError();
43850         if (mem_base != xmlMemBlocks()) {
43851             printf("Leak of %d blocks found in xmlTextWriterStartDTDEntity",
43852                    xmlMemBlocks() - mem_base);
43853             test_ret++;
43854             printf(" %d", n_writer);
43855             printf(" %d", n_pe);
43856             printf(" %d", n_name);
43857             printf("\n");
43858         }
43859     }
43860     }
43861     }
43862     function_tests++;
43863 #endif
43864
43865     return(test_ret);
43866 }
43867
43868
43869 static int
43870 test_xmlTextWriterStartDocument(void) {
43871     int test_ret = 0;
43872
43873 #if defined(LIBXML_WRITER_ENABLED)
43874     int mem_base;
43875     int ret_val;
43876     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43877     int n_writer;
43878     char * version; /* the xml version ("1.0") or NULL for default ("1.0") */
43879     int n_version;
43880     char * encoding; /* the encoding or NULL for default */
43881     int n_encoding;
43882     char * standalone; /* "yes" or "no" or NULL for default */
43883     int n_standalone;
43884
43885     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43886     for (n_version = 0;n_version < gen_nb_const_char_ptr;n_version++) {
43887     for (n_encoding = 0;n_encoding < gen_nb_const_char_ptr;n_encoding++) {
43888     for (n_standalone = 0;n_standalone < gen_nb_const_char_ptr;n_standalone++) {
43889         mem_base = xmlMemBlocks();
43890         writer = gen_xmlTextWriterPtr(n_writer, 0);
43891         version = gen_const_char_ptr(n_version, 1);
43892         encoding = gen_const_char_ptr(n_encoding, 2);
43893         standalone = gen_const_char_ptr(n_standalone, 3);
43894
43895         ret_val = xmlTextWriterStartDocument(writer, (const char *)version, (const char *)encoding, (const char *)standalone);
43896         desret_int(ret_val);
43897         call_tests++;
43898         des_xmlTextWriterPtr(n_writer, writer, 0);
43899         des_const_char_ptr(n_version, (const char *)version, 1);
43900         des_const_char_ptr(n_encoding, (const char *)encoding, 2);
43901         des_const_char_ptr(n_standalone, (const char *)standalone, 3);
43902         xmlResetLastError();
43903         if (mem_base != xmlMemBlocks()) {
43904             printf("Leak of %d blocks found in xmlTextWriterStartDocument",
43905                    xmlMemBlocks() - mem_base);
43906             test_ret++;
43907             printf(" %d", n_writer);
43908             printf(" %d", n_version);
43909             printf(" %d", n_encoding);
43910             printf(" %d", n_standalone);
43911             printf("\n");
43912         }
43913     }
43914     }
43915     }
43916     }
43917     function_tests++;
43918 #endif
43919
43920     return(test_ret);
43921 }
43922
43923
43924 static int
43925 test_xmlTextWriterStartElement(void) {
43926     int test_ret = 0;
43927
43928 #if defined(LIBXML_WRITER_ENABLED)
43929     int mem_base;
43930     int ret_val;
43931     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43932     int n_writer;
43933     xmlChar * name; /* element name */
43934     int n_name;
43935
43936     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43937     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
43938         mem_base = xmlMemBlocks();
43939         writer = gen_xmlTextWriterPtr(n_writer, 0);
43940         name = gen_const_xmlChar_ptr(n_name, 1);
43941
43942         ret_val = xmlTextWriterStartElement(writer, (const xmlChar *)name);
43943         desret_int(ret_val);
43944         call_tests++;
43945         des_xmlTextWriterPtr(n_writer, writer, 0);
43946         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
43947         xmlResetLastError();
43948         if (mem_base != xmlMemBlocks()) {
43949             printf("Leak of %d blocks found in xmlTextWriterStartElement",
43950                    xmlMemBlocks() - mem_base);
43951             test_ret++;
43952             printf(" %d", n_writer);
43953             printf(" %d", n_name);
43954             printf("\n");
43955         }
43956     }
43957     }
43958     function_tests++;
43959 #endif
43960
43961     return(test_ret);
43962 }
43963
43964
43965 static int
43966 test_xmlTextWriterStartElementNS(void) {
43967     int test_ret = 0;
43968
43969 #if defined(LIBXML_WRITER_ENABLED)
43970     int mem_base;
43971     int ret_val;
43972     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
43973     int n_writer;
43974     xmlChar * prefix; /* namespace prefix or NULL */
43975     int n_prefix;
43976     xmlChar * name; /* element local name */
43977     int n_name;
43978     xmlChar * namespaceURI; /* namespace URI or NULL */
43979     int n_namespaceURI;
43980
43981     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
43982     for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
43983     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
43984     for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
43985         mem_base = xmlMemBlocks();
43986         writer = gen_xmlTextWriterPtr(n_writer, 0);
43987         prefix = gen_const_xmlChar_ptr(n_prefix, 1);
43988         name = gen_const_xmlChar_ptr(n_name, 2);
43989         namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 3);
43990
43991         ret_val = xmlTextWriterStartElementNS(writer, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)namespaceURI);
43992         desret_int(ret_val);
43993         call_tests++;
43994         des_xmlTextWriterPtr(n_writer, writer, 0);
43995         des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
43996         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
43997         des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 3);
43998         xmlResetLastError();
43999         if (mem_base != xmlMemBlocks()) {
44000             printf("Leak of %d blocks found in xmlTextWriterStartElementNS",
44001                    xmlMemBlocks() - mem_base);
44002             test_ret++;
44003             printf(" %d", n_writer);
44004             printf(" %d", n_prefix);
44005             printf(" %d", n_name);
44006             printf(" %d", n_namespaceURI);
44007             printf("\n");
44008         }
44009     }
44010     }
44011     }
44012     }
44013     function_tests++;
44014 #endif
44015
44016     return(test_ret);
44017 }
44018
44019
44020 static int
44021 test_xmlTextWriterStartPI(void) {
44022     int test_ret = 0;
44023
44024 #if defined(LIBXML_WRITER_ENABLED)
44025     int mem_base;
44026     int ret_val;
44027     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44028     int n_writer;
44029     xmlChar * target; /* PI target */
44030     int n_target;
44031
44032     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44033     for (n_target = 0;n_target < gen_nb_const_xmlChar_ptr;n_target++) {
44034         mem_base = xmlMemBlocks();
44035         writer = gen_xmlTextWriterPtr(n_writer, 0);
44036         target = gen_const_xmlChar_ptr(n_target, 1);
44037
44038         ret_val = xmlTextWriterStartPI(writer, (const xmlChar *)target);
44039         desret_int(ret_val);
44040         call_tests++;
44041         des_xmlTextWriterPtr(n_writer, writer, 0);
44042         des_const_xmlChar_ptr(n_target, (const xmlChar *)target, 1);
44043         xmlResetLastError();
44044         if (mem_base != xmlMemBlocks()) {
44045             printf("Leak of %d blocks found in xmlTextWriterStartPI",
44046                    xmlMemBlocks() - mem_base);
44047             test_ret++;
44048             printf(" %d", n_writer);
44049             printf(" %d", n_target);
44050             printf("\n");
44051         }
44052     }
44053     }
44054     function_tests++;
44055 #endif
44056
44057     return(test_ret);
44058 }
44059
44060
44061 static int
44062 test_xmlTextWriterWriteAttribute(void) {
44063     int test_ret = 0;
44064
44065 #if defined(LIBXML_WRITER_ENABLED)
44066     int mem_base;
44067     int ret_val;
44068     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44069     int n_writer;
44070     xmlChar * name; /* attribute name */
44071     int n_name;
44072     xmlChar * content; /* attribute content */
44073     int n_content;
44074
44075     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44076     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44077     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44078         mem_base = xmlMemBlocks();
44079         writer = gen_xmlTextWriterPtr(n_writer, 0);
44080         name = gen_const_xmlChar_ptr(n_name, 1);
44081         content = gen_const_xmlChar_ptr(n_content, 2);
44082
44083         ret_val = xmlTextWriterWriteAttribute(writer, (const xmlChar *)name, (const xmlChar *)content);
44084         desret_int(ret_val);
44085         call_tests++;
44086         des_xmlTextWriterPtr(n_writer, writer, 0);
44087         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
44088         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2);
44089         xmlResetLastError();
44090         if (mem_base != xmlMemBlocks()) {
44091             printf("Leak of %d blocks found in xmlTextWriterWriteAttribute",
44092                    xmlMemBlocks() - mem_base);
44093             test_ret++;
44094             printf(" %d", n_writer);
44095             printf(" %d", n_name);
44096             printf(" %d", n_content);
44097             printf("\n");
44098         }
44099     }
44100     }
44101     }
44102     function_tests++;
44103 #endif
44104
44105     return(test_ret);
44106 }
44107
44108
44109 static int
44110 test_xmlTextWriterWriteAttributeNS(void) {
44111     int test_ret = 0;
44112
44113 #if defined(LIBXML_WRITER_ENABLED)
44114     int mem_base;
44115     int ret_val;
44116     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44117     int n_writer;
44118     xmlChar * prefix; /* namespace prefix */
44119     int n_prefix;
44120     xmlChar * name; /* attribute local name */
44121     int n_name;
44122     xmlChar * namespaceURI; /* namespace URI */
44123     int n_namespaceURI;
44124     xmlChar * content; /* attribute content */
44125     int n_content;
44126
44127     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44128     for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
44129     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44130     for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
44131     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44132         mem_base = xmlMemBlocks();
44133         writer = gen_xmlTextWriterPtr(n_writer, 0);
44134         prefix = gen_const_xmlChar_ptr(n_prefix, 1);
44135         name = gen_const_xmlChar_ptr(n_name, 2);
44136         namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 3);
44137         content = gen_const_xmlChar_ptr(n_content, 4);
44138
44139         ret_val = xmlTextWriterWriteAttributeNS(writer, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)namespaceURI, (const xmlChar *)content);
44140         desret_int(ret_val);
44141         call_tests++;
44142         des_xmlTextWriterPtr(n_writer, writer, 0);
44143         des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
44144         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
44145         des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 3);
44146         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 4);
44147         xmlResetLastError();
44148         if (mem_base != xmlMemBlocks()) {
44149             printf("Leak of %d blocks found in xmlTextWriterWriteAttributeNS",
44150                    xmlMemBlocks() - mem_base);
44151             test_ret++;
44152             printf(" %d", n_writer);
44153             printf(" %d", n_prefix);
44154             printf(" %d", n_name);
44155             printf(" %d", n_namespaceURI);
44156             printf(" %d", n_content);
44157             printf("\n");
44158         }
44159     }
44160     }
44161     }
44162     }
44163     }
44164     function_tests++;
44165 #endif
44166
44167     return(test_ret);
44168 }
44169
44170
44171 static int
44172 test_xmlTextWriterWriteBase64(void) {
44173     int test_ret = 0;
44174
44175 #if defined(LIBXML_WRITER_ENABLED)
44176     int mem_base;
44177     int ret_val;
44178     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44179     int n_writer;
44180     char * data; /* binary data */
44181     int n_data;
44182     int start; /* the position within the data of the first byte to encode */
44183     int n_start;
44184     int len; /* the number of bytes to encode */
44185     int n_len;
44186
44187     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44188     for (n_data = 0;n_data < gen_nb_const_char_ptr;n_data++) {
44189     for (n_start = 0;n_start < gen_nb_int;n_start++) {
44190     for (n_len = 0;n_len < gen_nb_int;n_len++) {
44191         mem_base = xmlMemBlocks();
44192         writer = gen_xmlTextWriterPtr(n_writer, 0);
44193         data = gen_const_char_ptr(n_data, 1);
44194         start = gen_int(n_start, 2);
44195         len = gen_int(n_len, 3);
44196
44197         ret_val = xmlTextWriterWriteBase64(writer, (const char *)data, start, len);
44198         desret_int(ret_val);
44199         call_tests++;
44200         des_xmlTextWriterPtr(n_writer, writer, 0);
44201         des_const_char_ptr(n_data, (const char *)data, 1);
44202         des_int(n_start, start, 2);
44203         des_int(n_len, len, 3);
44204         xmlResetLastError();
44205         if (mem_base != xmlMemBlocks()) {
44206             printf("Leak of %d blocks found in xmlTextWriterWriteBase64",
44207                    xmlMemBlocks() - mem_base);
44208             test_ret++;
44209             printf(" %d", n_writer);
44210             printf(" %d", n_data);
44211             printf(" %d", n_start);
44212             printf(" %d", n_len);
44213             printf("\n");
44214         }
44215     }
44216     }
44217     }
44218     }
44219     function_tests++;
44220 #endif
44221
44222     return(test_ret);
44223 }
44224
44225
44226 static int
44227 test_xmlTextWriterWriteBinHex(void) {
44228     int test_ret = 0;
44229
44230 #if defined(LIBXML_WRITER_ENABLED)
44231     int mem_base;
44232     int ret_val;
44233     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44234     int n_writer;
44235     char * data; /* binary data */
44236     int n_data;
44237     int start; /* the position within the data of the first byte to encode */
44238     int n_start;
44239     int len; /* the number of bytes to encode */
44240     int n_len;
44241
44242     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44243     for (n_data = 0;n_data < gen_nb_const_char_ptr;n_data++) {
44244     for (n_start = 0;n_start < gen_nb_int;n_start++) {
44245     for (n_len = 0;n_len < gen_nb_int;n_len++) {
44246         mem_base = xmlMemBlocks();
44247         writer = gen_xmlTextWriterPtr(n_writer, 0);
44248         data = gen_const_char_ptr(n_data, 1);
44249         start = gen_int(n_start, 2);
44250         len = gen_int(n_len, 3);
44251
44252         ret_val = xmlTextWriterWriteBinHex(writer, (const char *)data, start, len);
44253         desret_int(ret_val);
44254         call_tests++;
44255         des_xmlTextWriterPtr(n_writer, writer, 0);
44256         des_const_char_ptr(n_data, (const char *)data, 1);
44257         des_int(n_start, start, 2);
44258         des_int(n_len, len, 3);
44259         xmlResetLastError();
44260         if (mem_base != xmlMemBlocks()) {
44261             printf("Leak of %d blocks found in xmlTextWriterWriteBinHex",
44262                    xmlMemBlocks() - mem_base);
44263             test_ret++;
44264             printf(" %d", n_writer);
44265             printf(" %d", n_data);
44266             printf(" %d", n_start);
44267             printf(" %d", n_len);
44268             printf("\n");
44269         }
44270     }
44271     }
44272     }
44273     }
44274     function_tests++;
44275 #endif
44276
44277     return(test_ret);
44278 }
44279
44280
44281 static int
44282 test_xmlTextWriterWriteCDATA(void) {
44283     int test_ret = 0;
44284
44285 #if defined(LIBXML_WRITER_ENABLED)
44286     int mem_base;
44287     int ret_val;
44288     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44289     int n_writer;
44290     xmlChar * content; /* CDATA content */
44291     int n_content;
44292
44293     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44294     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44295         mem_base = xmlMemBlocks();
44296         writer = gen_xmlTextWriterPtr(n_writer, 0);
44297         content = gen_const_xmlChar_ptr(n_content, 1);
44298
44299         ret_val = xmlTextWriterWriteCDATA(writer, (const xmlChar *)content);
44300         desret_int(ret_val);
44301         call_tests++;
44302         des_xmlTextWriterPtr(n_writer, writer, 0);
44303         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
44304         xmlResetLastError();
44305         if (mem_base != xmlMemBlocks()) {
44306             printf("Leak of %d blocks found in xmlTextWriterWriteCDATA",
44307                    xmlMemBlocks() - mem_base);
44308             test_ret++;
44309             printf(" %d", n_writer);
44310             printf(" %d", n_content);
44311             printf("\n");
44312         }
44313     }
44314     }
44315     function_tests++;
44316 #endif
44317
44318     return(test_ret);
44319 }
44320
44321
44322 static int
44323 test_xmlTextWriterWriteComment(void) {
44324     int test_ret = 0;
44325
44326 #if defined(LIBXML_WRITER_ENABLED)
44327     int mem_base;
44328     int ret_val;
44329     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44330     int n_writer;
44331     xmlChar * content; /* comment string */
44332     int n_content;
44333
44334     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44335     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44336         mem_base = xmlMemBlocks();
44337         writer = gen_xmlTextWriterPtr(n_writer, 0);
44338         content = gen_const_xmlChar_ptr(n_content, 1);
44339
44340         ret_val = xmlTextWriterWriteComment(writer, (const xmlChar *)content);
44341         desret_int(ret_val);
44342         call_tests++;
44343         des_xmlTextWriterPtr(n_writer, writer, 0);
44344         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
44345         xmlResetLastError();
44346         if (mem_base != xmlMemBlocks()) {
44347             printf("Leak of %d blocks found in xmlTextWriterWriteComment",
44348                    xmlMemBlocks() - mem_base);
44349             test_ret++;
44350             printf(" %d", n_writer);
44351             printf(" %d", n_content);
44352             printf("\n");
44353         }
44354     }
44355     }
44356     function_tests++;
44357 #endif
44358
44359     return(test_ret);
44360 }
44361
44362
44363 static int
44364 test_xmlTextWriterWriteDTD(void) {
44365     int test_ret = 0;
44366
44367 #if defined(LIBXML_WRITER_ENABLED)
44368     int mem_base;
44369     int ret_val;
44370     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44371     int n_writer;
44372     xmlChar * name; /* the name of the DTD */
44373     int n_name;
44374     xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
44375     int n_pubid;
44376     xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
44377     int n_sysid;
44378     xmlChar * subset; /* string content of the DTD */
44379     int n_subset;
44380
44381     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44382     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44383     for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
44384     for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
44385     for (n_subset = 0;n_subset < gen_nb_const_xmlChar_ptr;n_subset++) {
44386         mem_base = xmlMemBlocks();
44387         writer = gen_xmlTextWriterPtr(n_writer, 0);
44388         name = gen_const_xmlChar_ptr(n_name, 1);
44389         pubid = gen_const_xmlChar_ptr(n_pubid, 2);
44390         sysid = gen_const_xmlChar_ptr(n_sysid, 3);
44391         subset = gen_const_xmlChar_ptr(n_subset, 4);
44392
44393         ret_val = xmlTextWriterWriteDTD(writer, (const xmlChar *)name, (const xmlChar *)pubid, (const xmlChar *)sysid, (const xmlChar *)subset);
44394         desret_int(ret_val);
44395         call_tests++;
44396         des_xmlTextWriterPtr(n_writer, writer, 0);
44397         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
44398         des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 2);
44399         des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 3);
44400         des_const_xmlChar_ptr(n_subset, (const xmlChar *)subset, 4);
44401         xmlResetLastError();
44402         if (mem_base != xmlMemBlocks()) {
44403             printf("Leak of %d blocks found in xmlTextWriterWriteDTD",
44404                    xmlMemBlocks() - mem_base);
44405             test_ret++;
44406             printf(" %d", n_writer);
44407             printf(" %d", n_name);
44408             printf(" %d", n_pubid);
44409             printf(" %d", n_sysid);
44410             printf(" %d", n_subset);
44411             printf("\n");
44412         }
44413     }
44414     }
44415     }
44416     }
44417     }
44418     function_tests++;
44419 #endif
44420
44421     return(test_ret);
44422 }
44423
44424
44425 static int
44426 test_xmlTextWriterWriteDTDAttlist(void) {
44427     int test_ret = 0;
44428
44429 #if defined(LIBXML_WRITER_ENABLED)
44430     int mem_base;
44431     int ret_val;
44432     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44433     int n_writer;
44434     xmlChar * name; /* the name of the DTD ATTLIST */
44435     int n_name;
44436     xmlChar * content; /* content of the ATTLIST */
44437     int n_content;
44438
44439     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44440     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44441     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44442         mem_base = xmlMemBlocks();
44443         writer = gen_xmlTextWriterPtr(n_writer, 0);
44444         name = gen_const_xmlChar_ptr(n_name, 1);
44445         content = gen_const_xmlChar_ptr(n_content, 2);
44446
44447         ret_val = xmlTextWriterWriteDTDAttlist(writer, (const xmlChar *)name, (const xmlChar *)content);
44448         desret_int(ret_val);
44449         call_tests++;
44450         des_xmlTextWriterPtr(n_writer, writer, 0);
44451         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
44452         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2);
44453         xmlResetLastError();
44454         if (mem_base != xmlMemBlocks()) {
44455             printf("Leak of %d blocks found in xmlTextWriterWriteDTDAttlist",
44456                    xmlMemBlocks() - mem_base);
44457             test_ret++;
44458             printf(" %d", n_writer);
44459             printf(" %d", n_name);
44460             printf(" %d", n_content);
44461             printf("\n");
44462         }
44463     }
44464     }
44465     }
44466     function_tests++;
44467 #endif
44468
44469     return(test_ret);
44470 }
44471
44472
44473 static int
44474 test_xmlTextWriterWriteDTDElement(void) {
44475     int test_ret = 0;
44476
44477 #if defined(LIBXML_WRITER_ENABLED)
44478     int mem_base;
44479     int ret_val;
44480     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44481     int n_writer;
44482     xmlChar * name; /* the name of the DTD element */
44483     int n_name;
44484     xmlChar * content; /* content of the element */
44485     int n_content;
44486
44487     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44488     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44489     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44490         mem_base = xmlMemBlocks();
44491         writer = gen_xmlTextWriterPtr(n_writer, 0);
44492         name = gen_const_xmlChar_ptr(n_name, 1);
44493         content = gen_const_xmlChar_ptr(n_content, 2);
44494
44495         ret_val = xmlTextWriterWriteDTDElement(writer, (const xmlChar *)name, (const xmlChar *)content);
44496         desret_int(ret_val);
44497         call_tests++;
44498         des_xmlTextWriterPtr(n_writer, writer, 0);
44499         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
44500         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2);
44501         xmlResetLastError();
44502         if (mem_base != xmlMemBlocks()) {
44503             printf("Leak of %d blocks found in xmlTextWriterWriteDTDElement",
44504                    xmlMemBlocks() - mem_base);
44505             test_ret++;
44506             printf(" %d", n_writer);
44507             printf(" %d", n_name);
44508             printf(" %d", n_content);
44509             printf("\n");
44510         }
44511     }
44512     }
44513     }
44514     function_tests++;
44515 #endif
44516
44517     return(test_ret);
44518 }
44519
44520
44521 static int
44522 test_xmlTextWriterWriteDTDEntity(void) {
44523     int test_ret = 0;
44524
44525 #if defined(LIBXML_WRITER_ENABLED)
44526     int mem_base;
44527     int ret_val;
44528     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44529     int n_writer;
44530     int pe; /* TRUE if this is a parameter entity, FALSE if not */
44531     int n_pe;
44532     xmlChar * name; /* the name of the DTD entity */
44533     int n_name;
44534     xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
44535     int n_pubid;
44536     xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
44537     int n_sysid;
44538     xmlChar * ndataid; /* the xml notation name. */
44539     int n_ndataid;
44540     xmlChar * content; /* content of the entity */
44541     int n_content;
44542
44543     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44544     for (n_pe = 0;n_pe < gen_nb_int;n_pe++) {
44545     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44546     for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
44547     for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
44548     for (n_ndataid = 0;n_ndataid < gen_nb_const_xmlChar_ptr;n_ndataid++) {
44549     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44550         mem_base = xmlMemBlocks();
44551         writer = gen_xmlTextWriterPtr(n_writer, 0);
44552         pe = gen_int(n_pe, 1);
44553         name = gen_const_xmlChar_ptr(n_name, 2);
44554         pubid = gen_const_xmlChar_ptr(n_pubid, 3);
44555         sysid = gen_const_xmlChar_ptr(n_sysid, 4);
44556         ndataid = gen_const_xmlChar_ptr(n_ndataid, 5);
44557         content = gen_const_xmlChar_ptr(n_content, 6);
44558
44559         ret_val = xmlTextWriterWriteDTDEntity(writer, pe, (const xmlChar *)name, (const xmlChar *)pubid, (const xmlChar *)sysid, (const xmlChar *)ndataid, (const xmlChar *)content);
44560         desret_int(ret_val);
44561         call_tests++;
44562         des_xmlTextWriterPtr(n_writer, writer, 0);
44563         des_int(n_pe, pe, 1);
44564         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
44565         des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 3);
44566         des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 4);
44567         des_const_xmlChar_ptr(n_ndataid, (const xmlChar *)ndataid, 5);
44568         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 6);
44569         xmlResetLastError();
44570         if (mem_base != xmlMemBlocks()) {
44571             printf("Leak of %d blocks found in xmlTextWriterWriteDTDEntity",
44572                    xmlMemBlocks() - mem_base);
44573             test_ret++;
44574             printf(" %d", n_writer);
44575             printf(" %d", n_pe);
44576             printf(" %d", n_name);
44577             printf(" %d", n_pubid);
44578             printf(" %d", n_sysid);
44579             printf(" %d", n_ndataid);
44580             printf(" %d", n_content);
44581             printf("\n");
44582         }
44583     }
44584     }
44585     }
44586     }
44587     }
44588     }
44589     }
44590     function_tests++;
44591 #endif
44592
44593     return(test_ret);
44594 }
44595
44596
44597 static int
44598 test_xmlTextWriterWriteDTDExternalEntity(void) {
44599     int test_ret = 0;
44600
44601 #if defined(LIBXML_WRITER_ENABLED)
44602     int mem_base;
44603     int ret_val;
44604     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44605     int n_writer;
44606     int pe; /* TRUE if this is a parameter entity, FALSE if not */
44607     int n_pe;
44608     xmlChar * name; /* the name of the DTD entity */
44609     int n_name;
44610     xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
44611     int n_pubid;
44612     xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
44613     int n_sysid;
44614     xmlChar * ndataid; /* the xml notation name. */
44615     int n_ndataid;
44616
44617     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44618     for (n_pe = 0;n_pe < gen_nb_int;n_pe++) {
44619     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44620     for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
44621     for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
44622     for (n_ndataid = 0;n_ndataid < gen_nb_const_xmlChar_ptr;n_ndataid++) {
44623         mem_base = xmlMemBlocks();
44624         writer = gen_xmlTextWriterPtr(n_writer, 0);
44625         pe = gen_int(n_pe, 1);
44626         name = gen_const_xmlChar_ptr(n_name, 2);
44627         pubid = gen_const_xmlChar_ptr(n_pubid, 3);
44628         sysid = gen_const_xmlChar_ptr(n_sysid, 4);
44629         ndataid = gen_const_xmlChar_ptr(n_ndataid, 5);
44630
44631         ret_val = xmlTextWriterWriteDTDExternalEntity(writer, pe, (const xmlChar *)name, (const xmlChar *)pubid, (const xmlChar *)sysid, (const xmlChar *)ndataid);
44632         desret_int(ret_val);
44633         call_tests++;
44634         des_xmlTextWriterPtr(n_writer, writer, 0);
44635         des_int(n_pe, pe, 1);
44636         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
44637         des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 3);
44638         des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 4);
44639         des_const_xmlChar_ptr(n_ndataid, (const xmlChar *)ndataid, 5);
44640         xmlResetLastError();
44641         if (mem_base != xmlMemBlocks()) {
44642             printf("Leak of %d blocks found in xmlTextWriterWriteDTDExternalEntity",
44643                    xmlMemBlocks() - mem_base);
44644             test_ret++;
44645             printf(" %d", n_writer);
44646             printf(" %d", n_pe);
44647             printf(" %d", n_name);
44648             printf(" %d", n_pubid);
44649             printf(" %d", n_sysid);
44650             printf(" %d", n_ndataid);
44651             printf("\n");
44652         }
44653     }
44654     }
44655     }
44656     }
44657     }
44658     }
44659     function_tests++;
44660 #endif
44661
44662     return(test_ret);
44663 }
44664
44665
44666 static int
44667 test_xmlTextWriterWriteDTDExternalEntityContents(void) {
44668     int test_ret = 0;
44669
44670 #if defined(LIBXML_WRITER_ENABLED)
44671     int mem_base;
44672     int ret_val;
44673     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44674     int n_writer;
44675     xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
44676     int n_pubid;
44677     xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
44678     int n_sysid;
44679     xmlChar * ndataid; /* the xml notation name. */
44680     int n_ndataid;
44681
44682     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44683     for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
44684     for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
44685     for (n_ndataid = 0;n_ndataid < gen_nb_const_xmlChar_ptr;n_ndataid++) {
44686         mem_base = xmlMemBlocks();
44687         writer = gen_xmlTextWriterPtr(n_writer, 0);
44688         pubid = gen_const_xmlChar_ptr(n_pubid, 1);
44689         sysid = gen_const_xmlChar_ptr(n_sysid, 2);
44690         ndataid = gen_const_xmlChar_ptr(n_ndataid, 3);
44691
44692         ret_val = xmlTextWriterWriteDTDExternalEntityContents(writer, (const xmlChar *)pubid, (const xmlChar *)sysid, (const xmlChar *)ndataid);
44693         desret_int(ret_val);
44694         call_tests++;
44695         des_xmlTextWriterPtr(n_writer, writer, 0);
44696         des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 1);
44697         des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 2);
44698         des_const_xmlChar_ptr(n_ndataid, (const xmlChar *)ndataid, 3);
44699         xmlResetLastError();
44700         if (mem_base != xmlMemBlocks()) {
44701             printf("Leak of %d blocks found in xmlTextWriterWriteDTDExternalEntityContents",
44702                    xmlMemBlocks() - mem_base);
44703             test_ret++;
44704             printf(" %d", n_writer);
44705             printf(" %d", n_pubid);
44706             printf(" %d", n_sysid);
44707             printf(" %d", n_ndataid);
44708             printf("\n");
44709         }
44710     }
44711     }
44712     }
44713     }
44714     function_tests++;
44715 #endif
44716
44717     return(test_ret);
44718 }
44719
44720
44721 static int
44722 test_xmlTextWriterWriteDTDInternalEntity(void) {
44723     int test_ret = 0;
44724
44725 #if defined(LIBXML_WRITER_ENABLED)
44726     int mem_base;
44727     int ret_val;
44728     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44729     int n_writer;
44730     int pe; /* TRUE if this is a parameter entity, FALSE if not */
44731     int n_pe;
44732     xmlChar * name; /* the name of the DTD entity */
44733     int n_name;
44734     xmlChar * content; /* content of the entity */
44735     int n_content;
44736
44737     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44738     for (n_pe = 0;n_pe < gen_nb_int;n_pe++) {
44739     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44740     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44741         mem_base = xmlMemBlocks();
44742         writer = gen_xmlTextWriterPtr(n_writer, 0);
44743         pe = gen_int(n_pe, 1);
44744         name = gen_const_xmlChar_ptr(n_name, 2);
44745         content = gen_const_xmlChar_ptr(n_content, 3);
44746
44747         ret_val = xmlTextWriterWriteDTDInternalEntity(writer, pe, (const xmlChar *)name, (const xmlChar *)content);
44748         desret_int(ret_val);
44749         call_tests++;
44750         des_xmlTextWriterPtr(n_writer, writer, 0);
44751         des_int(n_pe, pe, 1);
44752         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
44753         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 3);
44754         xmlResetLastError();
44755         if (mem_base != xmlMemBlocks()) {
44756             printf("Leak of %d blocks found in xmlTextWriterWriteDTDInternalEntity",
44757                    xmlMemBlocks() - mem_base);
44758             test_ret++;
44759             printf(" %d", n_writer);
44760             printf(" %d", n_pe);
44761             printf(" %d", n_name);
44762             printf(" %d", n_content);
44763             printf("\n");
44764         }
44765     }
44766     }
44767     }
44768     }
44769     function_tests++;
44770 #endif
44771
44772     return(test_ret);
44773 }
44774
44775
44776 static int
44777 test_xmlTextWriterWriteDTDNotation(void) {
44778     int test_ret = 0;
44779
44780 #if defined(LIBXML_WRITER_ENABLED)
44781     int mem_base;
44782     int ret_val;
44783     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44784     int n_writer;
44785     xmlChar * name; /* the name of the xml notation */
44786     int n_name;
44787     xmlChar * pubid; /* the public identifier, which is an alternative to the system identifier */
44788     int n_pubid;
44789     xmlChar * sysid; /* the system identifier, which is the URI of the DTD */
44790     int n_sysid;
44791
44792     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44793     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44794     for (n_pubid = 0;n_pubid < gen_nb_const_xmlChar_ptr;n_pubid++) {
44795     for (n_sysid = 0;n_sysid < gen_nb_const_xmlChar_ptr;n_sysid++) {
44796         mem_base = xmlMemBlocks();
44797         writer = gen_xmlTextWriterPtr(n_writer, 0);
44798         name = gen_const_xmlChar_ptr(n_name, 1);
44799         pubid = gen_const_xmlChar_ptr(n_pubid, 2);
44800         sysid = gen_const_xmlChar_ptr(n_sysid, 3);
44801
44802         ret_val = xmlTextWriterWriteDTDNotation(writer, (const xmlChar *)name, (const xmlChar *)pubid, (const xmlChar *)sysid);
44803         desret_int(ret_val);
44804         call_tests++;
44805         des_xmlTextWriterPtr(n_writer, writer, 0);
44806         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
44807         des_const_xmlChar_ptr(n_pubid, (const xmlChar *)pubid, 2);
44808         des_const_xmlChar_ptr(n_sysid, (const xmlChar *)sysid, 3);
44809         xmlResetLastError();
44810         if (mem_base != xmlMemBlocks()) {
44811             printf("Leak of %d blocks found in xmlTextWriterWriteDTDNotation",
44812                    xmlMemBlocks() - mem_base);
44813             test_ret++;
44814             printf(" %d", n_writer);
44815             printf(" %d", n_name);
44816             printf(" %d", n_pubid);
44817             printf(" %d", n_sysid);
44818             printf("\n");
44819         }
44820     }
44821     }
44822     }
44823     }
44824     function_tests++;
44825 #endif
44826
44827     return(test_ret);
44828 }
44829
44830
44831 static int
44832 test_xmlTextWriterWriteElement(void) {
44833     int test_ret = 0;
44834
44835 #if defined(LIBXML_WRITER_ENABLED)
44836     int mem_base;
44837     int ret_val;
44838     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44839     int n_writer;
44840     xmlChar * name; /* element name */
44841     int n_name;
44842     xmlChar * content; /* element content */
44843     int n_content;
44844
44845     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44846     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44847     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44848         mem_base = xmlMemBlocks();
44849         writer = gen_xmlTextWriterPtr(n_writer, 0);
44850         name = gen_const_xmlChar_ptr(n_name, 1);
44851         content = gen_const_xmlChar_ptr(n_content, 2);
44852
44853         ret_val = xmlTextWriterWriteElement(writer, (const xmlChar *)name, (const xmlChar *)content);
44854         desret_int(ret_val);
44855         call_tests++;
44856         des_xmlTextWriterPtr(n_writer, writer, 0);
44857         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
44858         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2);
44859         xmlResetLastError();
44860         if (mem_base != xmlMemBlocks()) {
44861             printf("Leak of %d blocks found in xmlTextWriterWriteElement",
44862                    xmlMemBlocks() - mem_base);
44863             test_ret++;
44864             printf(" %d", n_writer);
44865             printf(" %d", n_name);
44866             printf(" %d", n_content);
44867             printf("\n");
44868         }
44869     }
44870     }
44871     }
44872     function_tests++;
44873 #endif
44874
44875     return(test_ret);
44876 }
44877
44878
44879 static int
44880 test_xmlTextWriterWriteElementNS(void) {
44881     int test_ret = 0;
44882
44883 #if defined(LIBXML_WRITER_ENABLED)
44884     int mem_base;
44885     int ret_val;
44886     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
44887     int n_writer;
44888     xmlChar * prefix; /* namespace prefix */
44889     int n_prefix;
44890     xmlChar * name; /* element local name */
44891     int n_name;
44892     xmlChar * namespaceURI; /* namespace URI */
44893     int n_namespaceURI;
44894     xmlChar * content; /* element content */
44895     int n_content;
44896
44897     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
44898     for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
44899     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
44900     for (n_namespaceURI = 0;n_namespaceURI < gen_nb_const_xmlChar_ptr;n_namespaceURI++) {
44901     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
44902         mem_base = xmlMemBlocks();
44903         writer = gen_xmlTextWriterPtr(n_writer, 0);
44904         prefix = gen_const_xmlChar_ptr(n_prefix, 1);
44905         name = gen_const_xmlChar_ptr(n_name, 2);
44906         namespaceURI = gen_const_xmlChar_ptr(n_namespaceURI, 3);
44907         content = gen_const_xmlChar_ptr(n_content, 4);
44908
44909         ret_val = xmlTextWriterWriteElementNS(writer, (const xmlChar *)prefix, (const xmlChar *)name, (const xmlChar *)namespaceURI, (const xmlChar *)content);
44910         desret_int(ret_val);
44911         call_tests++;
44912         des_xmlTextWriterPtr(n_writer, writer, 0);
44913         des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
44914         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 2);
44915         des_const_xmlChar_ptr(n_namespaceURI, (const xmlChar *)namespaceURI, 3);
44916         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 4);
44917         xmlResetLastError();
44918         if (mem_base != xmlMemBlocks()) {
44919             printf("Leak of %d blocks found in xmlTextWriterWriteElementNS",
44920                    xmlMemBlocks() - mem_base);
44921             test_ret++;
44922             printf(" %d", n_writer);
44923             printf(" %d", n_prefix);
44924             printf(" %d", n_name);
44925             printf(" %d", n_namespaceURI);
44926             printf(" %d", n_content);
44927             printf("\n");
44928         }
44929     }
44930     }
44931     }
44932     }
44933     }
44934     function_tests++;
44935 #endif
44936
44937     return(test_ret);
44938 }
44939
44940
44941 static int
44942 test_xmlTextWriterWriteFormatAttribute(void) {
44943     int test_ret = 0;
44944
44945
44946     /* missing type support */
44947     return(test_ret);
44948 }
44949
44950
44951 static int
44952 test_xmlTextWriterWriteFormatAttributeNS(void) {
44953     int test_ret = 0;
44954
44955
44956     /* missing type support */
44957     return(test_ret);
44958 }
44959
44960
44961 static int
44962 test_xmlTextWriterWriteFormatCDATA(void) {
44963     int test_ret = 0;
44964
44965
44966     /* missing type support */
44967     return(test_ret);
44968 }
44969
44970
44971 static int
44972 test_xmlTextWriterWriteFormatComment(void) {
44973     int test_ret = 0;
44974
44975
44976     /* missing type support */
44977     return(test_ret);
44978 }
44979
44980
44981 static int
44982 test_xmlTextWriterWriteFormatDTD(void) {
44983     int test_ret = 0;
44984
44985
44986     /* missing type support */
44987     return(test_ret);
44988 }
44989
44990
44991 static int
44992 test_xmlTextWriterWriteFormatDTDAttlist(void) {
44993     int test_ret = 0;
44994
44995
44996     /* missing type support */
44997     return(test_ret);
44998 }
44999
45000
45001 static int
45002 test_xmlTextWriterWriteFormatDTDElement(void) {
45003     int test_ret = 0;
45004
45005
45006     /* missing type support */
45007     return(test_ret);
45008 }
45009
45010
45011 static int
45012 test_xmlTextWriterWriteFormatDTDInternalEntity(void) {
45013     int test_ret = 0;
45014
45015
45016     /* missing type support */
45017     return(test_ret);
45018 }
45019
45020
45021 static int
45022 test_xmlTextWriterWriteFormatElement(void) {
45023     int test_ret = 0;
45024
45025
45026     /* missing type support */
45027     return(test_ret);
45028 }
45029
45030
45031 static int
45032 test_xmlTextWriterWriteFormatElementNS(void) {
45033     int test_ret = 0;
45034
45035
45036     /* missing type support */
45037     return(test_ret);
45038 }
45039
45040
45041 static int
45042 test_xmlTextWriterWriteFormatPI(void) {
45043     int test_ret = 0;
45044
45045
45046     /* missing type support */
45047     return(test_ret);
45048 }
45049
45050
45051 static int
45052 test_xmlTextWriterWriteFormatRaw(void) {
45053     int test_ret = 0;
45054
45055
45056     /* missing type support */
45057     return(test_ret);
45058 }
45059
45060
45061 static int
45062 test_xmlTextWriterWriteFormatString(void) {
45063     int test_ret = 0;
45064
45065
45066     /* missing type support */
45067     return(test_ret);
45068 }
45069
45070
45071 static int
45072 test_xmlTextWriterWritePI(void) {
45073     int test_ret = 0;
45074
45075 #if defined(LIBXML_WRITER_ENABLED)
45076     int mem_base;
45077     int ret_val;
45078     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
45079     int n_writer;
45080     xmlChar * target; /* PI target */
45081     int n_target;
45082     xmlChar * content; /* PI content */
45083     int n_content;
45084
45085     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
45086     for (n_target = 0;n_target < gen_nb_const_xmlChar_ptr;n_target++) {
45087     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
45088         mem_base = xmlMemBlocks();
45089         writer = gen_xmlTextWriterPtr(n_writer, 0);
45090         target = gen_const_xmlChar_ptr(n_target, 1);
45091         content = gen_const_xmlChar_ptr(n_content, 2);
45092
45093         ret_val = xmlTextWriterWritePI(writer, (const xmlChar *)target, (const xmlChar *)content);
45094         desret_int(ret_val);
45095         call_tests++;
45096         des_xmlTextWriterPtr(n_writer, writer, 0);
45097         des_const_xmlChar_ptr(n_target, (const xmlChar *)target, 1);
45098         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 2);
45099         xmlResetLastError();
45100         if (mem_base != xmlMemBlocks()) {
45101             printf("Leak of %d blocks found in xmlTextWriterWritePI",
45102                    xmlMemBlocks() - mem_base);
45103             test_ret++;
45104             printf(" %d", n_writer);
45105             printf(" %d", n_target);
45106             printf(" %d", n_content);
45107             printf("\n");
45108         }
45109     }
45110     }
45111     }
45112     function_tests++;
45113 #endif
45114
45115     return(test_ret);
45116 }
45117
45118
45119 static int
45120 test_xmlTextWriterWriteRaw(void) {
45121     int test_ret = 0;
45122
45123 #if defined(LIBXML_WRITER_ENABLED)
45124     int mem_base;
45125     int ret_val;
45126     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
45127     int n_writer;
45128     xmlChar * content; /* text string */
45129     int n_content;
45130
45131     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
45132     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
45133         mem_base = xmlMemBlocks();
45134         writer = gen_xmlTextWriterPtr(n_writer, 0);
45135         content = gen_const_xmlChar_ptr(n_content, 1);
45136
45137         ret_val = xmlTextWriterWriteRaw(writer, (const xmlChar *)content);
45138         desret_int(ret_val);
45139         call_tests++;
45140         des_xmlTextWriterPtr(n_writer, writer, 0);
45141         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
45142         xmlResetLastError();
45143         if (mem_base != xmlMemBlocks()) {
45144             printf("Leak of %d blocks found in xmlTextWriterWriteRaw",
45145                    xmlMemBlocks() - mem_base);
45146             test_ret++;
45147             printf(" %d", n_writer);
45148             printf(" %d", n_content);
45149             printf("\n");
45150         }
45151     }
45152     }
45153     function_tests++;
45154 #endif
45155
45156     return(test_ret);
45157 }
45158
45159
45160 static int
45161 test_xmlTextWriterWriteRawLen(void) {
45162     int test_ret = 0;
45163
45164 #if defined(LIBXML_WRITER_ENABLED)
45165     int mem_base;
45166     int ret_val;
45167     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
45168     int n_writer;
45169     xmlChar * content; /* text string */
45170     int n_content;
45171     int len; /* length of the text string */
45172     int n_len;
45173
45174     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
45175     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
45176     for (n_len = 0;n_len < gen_nb_int;n_len++) {
45177         mem_base = xmlMemBlocks();
45178         writer = gen_xmlTextWriterPtr(n_writer, 0);
45179         content = gen_const_xmlChar_ptr(n_content, 1);
45180         len = gen_int(n_len, 2);
45181
45182         ret_val = xmlTextWriterWriteRawLen(writer, (const xmlChar *)content, len);
45183         desret_int(ret_val);
45184         call_tests++;
45185         des_xmlTextWriterPtr(n_writer, writer, 0);
45186         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
45187         des_int(n_len, len, 2);
45188         xmlResetLastError();
45189         if (mem_base != xmlMemBlocks()) {
45190             printf("Leak of %d blocks found in xmlTextWriterWriteRawLen",
45191                    xmlMemBlocks() - mem_base);
45192             test_ret++;
45193             printf(" %d", n_writer);
45194             printf(" %d", n_content);
45195             printf(" %d", n_len);
45196             printf("\n");
45197         }
45198     }
45199     }
45200     }
45201     function_tests++;
45202 #endif
45203
45204     return(test_ret);
45205 }
45206
45207
45208 static int
45209 test_xmlTextWriterWriteString(void) {
45210     int test_ret = 0;
45211
45212 #if defined(LIBXML_WRITER_ENABLED)
45213     int mem_base;
45214     int ret_val;
45215     xmlTextWriterPtr writer; /* the xmlTextWriterPtr */
45216     int n_writer;
45217     xmlChar * content; /* text string */
45218     int n_content;
45219
45220     for (n_writer = 0;n_writer < gen_nb_xmlTextWriterPtr;n_writer++) {
45221     for (n_content = 0;n_content < gen_nb_const_xmlChar_ptr;n_content++) {
45222         mem_base = xmlMemBlocks();
45223         writer = gen_xmlTextWriterPtr(n_writer, 0);
45224         content = gen_const_xmlChar_ptr(n_content, 1);
45225
45226         ret_val = xmlTextWriterWriteString(writer, (const xmlChar *)content);
45227         desret_int(ret_val);
45228         call_tests++;
45229         des_xmlTextWriterPtr(n_writer, writer, 0);
45230         des_const_xmlChar_ptr(n_content, (const xmlChar *)content, 1);
45231         xmlResetLastError();
45232         if (mem_base != xmlMemBlocks()) {
45233             printf("Leak of %d blocks found in xmlTextWriterWriteString",
45234                    xmlMemBlocks() - mem_base);
45235             test_ret++;
45236             printf(" %d", n_writer);
45237             printf(" %d", n_content);
45238             printf("\n");
45239         }
45240     }
45241     }
45242     function_tests++;
45243 #endif
45244
45245     return(test_ret);
45246 }
45247
45248
45249 static int
45250 test_xmlTextWriterWriteVFormatAttribute(void) {
45251     int test_ret = 0;
45252
45253
45254     /* missing type support */
45255     return(test_ret);
45256 }
45257
45258
45259 static int
45260 test_xmlTextWriterWriteVFormatAttributeNS(void) {
45261     int test_ret = 0;
45262
45263
45264     /* missing type support */
45265     return(test_ret);
45266 }
45267
45268
45269 static int
45270 test_xmlTextWriterWriteVFormatCDATA(void) {
45271     int test_ret = 0;
45272
45273
45274     /* missing type support */
45275     return(test_ret);
45276 }
45277
45278
45279 static int
45280 test_xmlTextWriterWriteVFormatComment(void) {
45281     int test_ret = 0;
45282
45283
45284     /* missing type support */
45285     return(test_ret);
45286 }
45287
45288
45289 static int
45290 test_xmlTextWriterWriteVFormatDTD(void) {
45291     int test_ret = 0;
45292
45293
45294     /* missing type support */
45295     return(test_ret);
45296 }
45297
45298
45299 static int
45300 test_xmlTextWriterWriteVFormatDTDAttlist(void) {
45301     int test_ret = 0;
45302
45303
45304     /* missing type support */
45305     return(test_ret);
45306 }
45307
45308
45309 static int
45310 test_xmlTextWriterWriteVFormatDTDElement(void) {
45311     int test_ret = 0;
45312
45313
45314     /* missing type support */
45315     return(test_ret);
45316 }
45317
45318
45319 static int
45320 test_xmlTextWriterWriteVFormatDTDInternalEntity(void) {
45321     int test_ret = 0;
45322
45323
45324     /* missing type support */
45325     return(test_ret);
45326 }
45327
45328
45329 static int
45330 test_xmlTextWriterWriteVFormatElement(void) {
45331     int test_ret = 0;
45332
45333
45334     /* missing type support */
45335     return(test_ret);
45336 }
45337
45338
45339 static int
45340 test_xmlTextWriterWriteVFormatElementNS(void) {
45341     int test_ret = 0;
45342
45343
45344     /* missing type support */
45345     return(test_ret);
45346 }
45347
45348
45349 static int
45350 test_xmlTextWriterWriteVFormatPI(void) {
45351     int test_ret = 0;
45352
45353
45354     /* missing type support */
45355     return(test_ret);
45356 }
45357
45358
45359 static int
45360 test_xmlTextWriterWriteVFormatRaw(void) {
45361     int test_ret = 0;
45362
45363
45364     /* missing type support */
45365     return(test_ret);
45366 }
45367
45368
45369 static int
45370 test_xmlTextWriterWriteVFormatString(void) {
45371     int test_ret = 0;
45372
45373
45374     /* missing type support */
45375     return(test_ret);
45376 }
45377
45378 static int
45379 test_xmlwriter(void) {
45380     int test_ret = 0;
45381
45382     if (quiet == 0) printf("Testing xmlwriter : 51 of 79 functions ...\n");
45383     test_ret += test_xmlNewTextWriter();
45384     test_ret += test_xmlNewTextWriterFilename();
45385     test_ret += test_xmlNewTextWriterMemory();
45386     test_ret += test_xmlNewTextWriterPushParser();
45387     test_ret += test_xmlNewTextWriterTree();
45388     test_ret += test_xmlTextWriterEndAttribute();
45389     test_ret += test_xmlTextWriterEndCDATA();
45390     test_ret += test_xmlTextWriterEndComment();
45391     test_ret += test_xmlTextWriterEndDTD();
45392     test_ret += test_xmlTextWriterEndDTDAttlist();
45393     test_ret += test_xmlTextWriterEndDTDElement();
45394     test_ret += test_xmlTextWriterEndDTDEntity();
45395     test_ret += test_xmlTextWriterEndDocument();
45396     test_ret += test_xmlTextWriterEndElement();
45397     test_ret += test_xmlTextWriterEndPI();
45398     test_ret += test_xmlTextWriterFlush();
45399     test_ret += test_xmlTextWriterFullEndElement();
45400     test_ret += test_xmlTextWriterSetIndent();
45401     test_ret += test_xmlTextWriterSetIndentString();
45402     test_ret += test_xmlTextWriterStartAttribute();
45403     test_ret += test_xmlTextWriterStartAttributeNS();
45404     test_ret += test_xmlTextWriterStartCDATA();
45405     test_ret += test_xmlTextWriterStartComment();
45406     test_ret += test_xmlTextWriterStartDTD();
45407     test_ret += test_xmlTextWriterStartDTDAttlist();
45408     test_ret += test_xmlTextWriterStartDTDElement();
45409     test_ret += test_xmlTextWriterStartDTDEntity();
45410     test_ret += test_xmlTextWriterStartDocument();
45411     test_ret += test_xmlTextWriterStartElement();
45412     test_ret += test_xmlTextWriterStartElementNS();
45413     test_ret += test_xmlTextWriterStartPI();
45414     test_ret += test_xmlTextWriterWriteAttribute();
45415     test_ret += test_xmlTextWriterWriteAttributeNS();
45416     test_ret += test_xmlTextWriterWriteBase64();
45417     test_ret += test_xmlTextWriterWriteBinHex();
45418     test_ret += test_xmlTextWriterWriteCDATA();
45419     test_ret += test_xmlTextWriterWriteComment();
45420     test_ret += test_xmlTextWriterWriteDTD();
45421     test_ret += test_xmlTextWriterWriteDTDAttlist();
45422     test_ret += test_xmlTextWriterWriteDTDElement();
45423     test_ret += test_xmlTextWriterWriteDTDEntity();
45424     test_ret += test_xmlTextWriterWriteDTDExternalEntity();
45425     test_ret += test_xmlTextWriterWriteDTDExternalEntityContents();
45426     test_ret += test_xmlTextWriterWriteDTDInternalEntity();
45427     test_ret += test_xmlTextWriterWriteDTDNotation();
45428     test_ret += test_xmlTextWriterWriteElement();
45429     test_ret += test_xmlTextWriterWriteElementNS();
45430     test_ret += test_xmlTextWriterWriteFormatAttribute();
45431     test_ret += test_xmlTextWriterWriteFormatAttributeNS();
45432     test_ret += test_xmlTextWriterWriteFormatCDATA();
45433     test_ret += test_xmlTextWriterWriteFormatComment();
45434     test_ret += test_xmlTextWriterWriteFormatDTD();
45435     test_ret += test_xmlTextWriterWriteFormatDTDAttlist();
45436     test_ret += test_xmlTextWriterWriteFormatDTDElement();
45437     test_ret += test_xmlTextWriterWriteFormatDTDInternalEntity();
45438     test_ret += test_xmlTextWriterWriteFormatElement();
45439     test_ret += test_xmlTextWriterWriteFormatElementNS();
45440     test_ret += test_xmlTextWriterWriteFormatPI();
45441     test_ret += test_xmlTextWriterWriteFormatRaw();
45442     test_ret += test_xmlTextWriterWriteFormatString();
45443     test_ret += test_xmlTextWriterWritePI();
45444     test_ret += test_xmlTextWriterWriteRaw();
45445     test_ret += test_xmlTextWriterWriteRawLen();
45446     test_ret += test_xmlTextWriterWriteString();
45447     test_ret += test_xmlTextWriterWriteVFormatAttribute();
45448     test_ret += test_xmlTextWriterWriteVFormatAttributeNS();
45449     test_ret += test_xmlTextWriterWriteVFormatCDATA();
45450     test_ret += test_xmlTextWriterWriteVFormatComment();
45451     test_ret += test_xmlTextWriterWriteVFormatDTD();
45452     test_ret += test_xmlTextWriterWriteVFormatDTDAttlist();
45453     test_ret += test_xmlTextWriterWriteVFormatDTDElement();
45454     test_ret += test_xmlTextWriterWriteVFormatDTDInternalEntity();
45455     test_ret += test_xmlTextWriterWriteVFormatElement();
45456     test_ret += test_xmlTextWriterWriteVFormatElementNS();
45457     test_ret += test_xmlTextWriterWriteVFormatPI();
45458     test_ret += test_xmlTextWriterWriteVFormatRaw();
45459     test_ret += test_xmlTextWriterWriteVFormatString();
45460
45461     if (test_ret != 0)
45462         printf("Module xmlwriter: %d errors\n", test_ret);
45463     return(test_ret);
45464 }
45465
45466 static int
45467 test_xmlXPathCastBooleanToNumber(void) {
45468     int test_ret = 0;
45469
45470 #if defined(LIBXML_XPATH_ENABLED)
45471     int mem_base;
45472     double ret_val;
45473     int val; /* a boolean */
45474     int n_val;
45475
45476     for (n_val = 0;n_val < gen_nb_int;n_val++) {
45477         mem_base = xmlMemBlocks();
45478         val = gen_int(n_val, 0);
45479
45480         ret_val = xmlXPathCastBooleanToNumber(val);
45481         desret_double(ret_val);
45482         call_tests++;
45483         des_int(n_val, val, 0);
45484         xmlResetLastError();
45485         if (mem_base != xmlMemBlocks()) {
45486             printf("Leak of %d blocks found in xmlXPathCastBooleanToNumber",
45487                    xmlMemBlocks() - mem_base);
45488             test_ret++;
45489             printf(" %d", n_val);
45490             printf("\n");
45491         }
45492     }
45493     function_tests++;
45494 #endif
45495
45496     return(test_ret);
45497 }
45498
45499
45500 static int
45501 test_xmlXPathCastBooleanToString(void) {
45502     int test_ret = 0;
45503
45504 #if defined(LIBXML_XPATH_ENABLED)
45505     int mem_base;
45506     xmlChar * ret_val;
45507     int val; /* a boolean */
45508     int n_val;
45509
45510     for (n_val = 0;n_val < gen_nb_int;n_val++) {
45511         mem_base = xmlMemBlocks();
45512         val = gen_int(n_val, 0);
45513
45514         ret_val = xmlXPathCastBooleanToString(val);
45515         desret_xmlChar_ptr(ret_val);
45516         call_tests++;
45517         des_int(n_val, val, 0);
45518         xmlResetLastError();
45519         if (mem_base != xmlMemBlocks()) {
45520             printf("Leak of %d blocks found in xmlXPathCastBooleanToString",
45521                    xmlMemBlocks() - mem_base);
45522             test_ret++;
45523             printf(" %d", n_val);
45524             printf("\n");
45525         }
45526     }
45527     function_tests++;
45528 #endif
45529
45530     return(test_ret);
45531 }
45532
45533
45534 static int
45535 test_xmlXPathCastNodeSetToBoolean(void) {
45536     int test_ret = 0;
45537
45538 #if defined(LIBXML_XPATH_ENABLED)
45539     int mem_base;
45540     int ret_val;
45541     xmlNodeSetPtr ns; /* a node-set */
45542     int n_ns;
45543
45544     for (n_ns = 0;n_ns < gen_nb_xmlNodeSetPtr;n_ns++) {
45545         mem_base = xmlMemBlocks();
45546         ns = gen_xmlNodeSetPtr(n_ns, 0);
45547
45548         ret_val = xmlXPathCastNodeSetToBoolean(ns);
45549         desret_int(ret_val);
45550         call_tests++;
45551         des_xmlNodeSetPtr(n_ns, ns, 0);
45552         xmlResetLastError();
45553         if (mem_base != xmlMemBlocks()) {
45554             printf("Leak of %d blocks found in xmlXPathCastNodeSetToBoolean",
45555                    xmlMemBlocks() - mem_base);
45556             test_ret++;
45557             printf(" %d", n_ns);
45558             printf("\n");
45559         }
45560     }
45561     function_tests++;
45562 #endif
45563
45564     return(test_ret);
45565 }
45566
45567
45568 static int
45569 test_xmlXPathCastNodeSetToNumber(void) {
45570     int test_ret = 0;
45571
45572 #if defined(LIBXML_XPATH_ENABLED)
45573     int mem_base;
45574     double ret_val;
45575     xmlNodeSetPtr ns; /* a node-set */
45576     int n_ns;
45577
45578     for (n_ns = 0;n_ns < gen_nb_xmlNodeSetPtr;n_ns++) {
45579         mem_base = xmlMemBlocks();
45580         ns = gen_xmlNodeSetPtr(n_ns, 0);
45581
45582         ret_val = xmlXPathCastNodeSetToNumber(ns);
45583         desret_double(ret_val);
45584         call_tests++;
45585         des_xmlNodeSetPtr(n_ns, ns, 0);
45586         xmlResetLastError();
45587         if (mem_base != xmlMemBlocks()) {
45588             printf("Leak of %d blocks found in xmlXPathCastNodeSetToNumber",
45589                    xmlMemBlocks() - mem_base);
45590             test_ret++;
45591             printf(" %d", n_ns);
45592             printf("\n");
45593         }
45594     }
45595     function_tests++;
45596 #endif
45597
45598     return(test_ret);
45599 }
45600
45601
45602 static int
45603 test_xmlXPathCastNodeSetToString(void) {
45604     int test_ret = 0;
45605
45606 #if defined(LIBXML_XPATH_ENABLED)
45607     int mem_base;
45608     xmlChar * ret_val;
45609     xmlNodeSetPtr ns; /* a node-set */
45610     int n_ns;
45611
45612     for (n_ns = 0;n_ns < gen_nb_xmlNodeSetPtr;n_ns++) {
45613         mem_base = xmlMemBlocks();
45614         ns = gen_xmlNodeSetPtr(n_ns, 0);
45615
45616         ret_val = xmlXPathCastNodeSetToString(ns);
45617         desret_xmlChar_ptr(ret_val);
45618         call_tests++;
45619         des_xmlNodeSetPtr(n_ns, ns, 0);
45620         xmlResetLastError();
45621         if (mem_base != xmlMemBlocks()) {
45622             printf("Leak of %d blocks found in xmlXPathCastNodeSetToString",
45623                    xmlMemBlocks() - mem_base);
45624             test_ret++;
45625             printf(" %d", n_ns);
45626             printf("\n");
45627         }
45628     }
45629     function_tests++;
45630 #endif
45631
45632     return(test_ret);
45633 }
45634
45635
45636 static int
45637 test_xmlXPathCastNodeToNumber(void) {
45638     int test_ret = 0;
45639
45640 #if defined(LIBXML_XPATH_ENABLED)
45641     int mem_base;
45642     double ret_val;
45643     xmlNodePtr node; /* a node */
45644     int n_node;
45645
45646     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
45647         mem_base = xmlMemBlocks();
45648         node = gen_xmlNodePtr(n_node, 0);
45649
45650         ret_val = xmlXPathCastNodeToNumber(node);
45651         desret_double(ret_val);
45652         call_tests++;
45653         des_xmlNodePtr(n_node, node, 0);
45654         xmlResetLastError();
45655         if (mem_base != xmlMemBlocks()) {
45656             printf("Leak of %d blocks found in xmlXPathCastNodeToNumber",
45657                    xmlMemBlocks() - mem_base);
45658             test_ret++;
45659             printf(" %d", n_node);
45660             printf("\n");
45661         }
45662     }
45663     function_tests++;
45664 #endif
45665
45666     return(test_ret);
45667 }
45668
45669
45670 static int
45671 test_xmlXPathCastNodeToString(void) {
45672     int test_ret = 0;
45673
45674 #if defined(LIBXML_XPATH_ENABLED)
45675     int mem_base;
45676     xmlChar * ret_val;
45677     xmlNodePtr node; /* a node */
45678     int n_node;
45679
45680     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
45681         mem_base = xmlMemBlocks();
45682         node = gen_xmlNodePtr(n_node, 0);
45683
45684         ret_val = xmlXPathCastNodeToString(node);
45685         desret_xmlChar_ptr(ret_val);
45686         call_tests++;
45687         des_xmlNodePtr(n_node, node, 0);
45688         xmlResetLastError();
45689         if (mem_base != xmlMemBlocks()) {
45690             printf("Leak of %d blocks found in xmlXPathCastNodeToString",
45691                    xmlMemBlocks() - mem_base);
45692             test_ret++;
45693             printf(" %d", n_node);
45694             printf("\n");
45695         }
45696     }
45697     function_tests++;
45698 #endif
45699
45700     return(test_ret);
45701 }
45702
45703
45704 static int
45705 test_xmlXPathCastNumberToBoolean(void) {
45706     int test_ret = 0;
45707
45708 #if defined(LIBXML_XPATH_ENABLED)
45709     int mem_base;
45710     int ret_val;
45711     double val; /* a number */
45712     int n_val;
45713
45714     for (n_val = 0;n_val < gen_nb_double;n_val++) {
45715         mem_base = xmlMemBlocks();
45716         val = gen_double(n_val, 0);
45717
45718         ret_val = xmlXPathCastNumberToBoolean(val);
45719         desret_int(ret_val);
45720         call_tests++;
45721         des_double(n_val, val, 0);
45722         xmlResetLastError();
45723         if (mem_base != xmlMemBlocks()) {
45724             printf("Leak of %d blocks found in xmlXPathCastNumberToBoolean",
45725                    xmlMemBlocks() - mem_base);
45726             test_ret++;
45727             printf(" %d", n_val);
45728             printf("\n");
45729         }
45730     }
45731     function_tests++;
45732 #endif
45733
45734     return(test_ret);
45735 }
45736
45737
45738 static int
45739 test_xmlXPathCastNumberToString(void) {
45740     int test_ret = 0;
45741
45742 #if defined(LIBXML_XPATH_ENABLED)
45743     int mem_base;
45744     xmlChar * ret_val;
45745     double val; /* a number */
45746     int n_val;
45747
45748     for (n_val = 0;n_val < gen_nb_double;n_val++) {
45749         mem_base = xmlMemBlocks();
45750         val = gen_double(n_val, 0);
45751
45752         ret_val = xmlXPathCastNumberToString(val);
45753         desret_xmlChar_ptr(ret_val);
45754         call_tests++;
45755         des_double(n_val, val, 0);
45756         xmlResetLastError();
45757         if (mem_base != xmlMemBlocks()) {
45758             printf("Leak of %d blocks found in xmlXPathCastNumberToString",
45759                    xmlMemBlocks() - mem_base);
45760             test_ret++;
45761             printf(" %d", n_val);
45762             printf("\n");
45763         }
45764     }
45765     function_tests++;
45766 #endif
45767
45768     return(test_ret);
45769 }
45770
45771
45772 static int
45773 test_xmlXPathCastStringToBoolean(void) {
45774     int test_ret = 0;
45775
45776 #if defined(LIBXML_XPATH_ENABLED)
45777     int mem_base;
45778     int ret_val;
45779     xmlChar * val; /* a string */
45780     int n_val;
45781
45782     for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) {
45783         mem_base = xmlMemBlocks();
45784         val = gen_const_xmlChar_ptr(n_val, 0);
45785
45786         ret_val = xmlXPathCastStringToBoolean((const xmlChar *)val);
45787         desret_int(ret_val);
45788         call_tests++;
45789         des_const_xmlChar_ptr(n_val, (const xmlChar *)val, 0);
45790         xmlResetLastError();
45791         if (mem_base != xmlMemBlocks()) {
45792             printf("Leak of %d blocks found in xmlXPathCastStringToBoolean",
45793                    xmlMemBlocks() - mem_base);
45794             test_ret++;
45795             printf(" %d", n_val);
45796             printf("\n");
45797         }
45798     }
45799     function_tests++;
45800 #endif
45801
45802     return(test_ret);
45803 }
45804
45805
45806 static int
45807 test_xmlXPathCastStringToNumber(void) {
45808     int test_ret = 0;
45809
45810 #if defined(LIBXML_XPATH_ENABLED)
45811     int mem_base;
45812     double ret_val;
45813     xmlChar * val; /* a string */
45814     int n_val;
45815
45816     for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) {
45817         mem_base = xmlMemBlocks();
45818         val = gen_const_xmlChar_ptr(n_val, 0);
45819
45820         ret_val = xmlXPathCastStringToNumber((const xmlChar *)val);
45821         desret_double(ret_val);
45822         call_tests++;
45823         des_const_xmlChar_ptr(n_val, (const xmlChar *)val, 0);
45824         xmlResetLastError();
45825         if (mem_base != xmlMemBlocks()) {
45826             printf("Leak of %d blocks found in xmlXPathCastStringToNumber",
45827                    xmlMemBlocks() - mem_base);
45828             test_ret++;
45829             printf(" %d", n_val);
45830             printf("\n");
45831         }
45832     }
45833     function_tests++;
45834 #endif
45835
45836     return(test_ret);
45837 }
45838
45839
45840 static int
45841 test_xmlXPathCastToBoolean(void) {
45842     int test_ret = 0;
45843
45844 #if defined(LIBXML_XPATH_ENABLED)
45845     int mem_base;
45846     int ret_val;
45847     xmlXPathObjectPtr val; /* an XPath object */
45848     int n_val;
45849
45850     for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
45851         mem_base = xmlMemBlocks();
45852         val = gen_xmlXPathObjectPtr(n_val, 0);
45853
45854         ret_val = xmlXPathCastToBoolean(val);
45855         desret_int(ret_val);
45856         call_tests++;
45857         des_xmlXPathObjectPtr(n_val, val, 0);
45858         xmlResetLastError();
45859         if (mem_base != xmlMemBlocks()) {
45860             printf("Leak of %d blocks found in xmlXPathCastToBoolean",
45861                    xmlMemBlocks() - mem_base);
45862             test_ret++;
45863             printf(" %d", n_val);
45864             printf("\n");
45865         }
45866     }
45867     function_tests++;
45868 #endif
45869
45870     return(test_ret);
45871 }
45872
45873
45874 static int
45875 test_xmlXPathCastToNumber(void) {
45876     int test_ret = 0;
45877
45878 #if defined(LIBXML_XPATH_ENABLED)
45879     int mem_base;
45880     double ret_val;
45881     xmlXPathObjectPtr val; /* an XPath object */
45882     int n_val;
45883
45884     for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
45885         mem_base = xmlMemBlocks();
45886         val = gen_xmlXPathObjectPtr(n_val, 0);
45887
45888         ret_val = xmlXPathCastToNumber(val);
45889         desret_double(ret_val);
45890         call_tests++;
45891         des_xmlXPathObjectPtr(n_val, val, 0);
45892         xmlResetLastError();
45893         if (mem_base != xmlMemBlocks()) {
45894             printf("Leak of %d blocks found in xmlXPathCastToNumber",
45895                    xmlMemBlocks() - mem_base);
45896             test_ret++;
45897             printf(" %d", n_val);
45898             printf("\n");
45899         }
45900     }
45901     function_tests++;
45902 #endif
45903
45904     return(test_ret);
45905 }
45906
45907
45908 static int
45909 test_xmlXPathCastToString(void) {
45910     int test_ret = 0;
45911
45912 #if defined(LIBXML_XPATH_ENABLED)
45913     int mem_base;
45914     xmlChar * ret_val;
45915     xmlXPathObjectPtr val; /* an XPath object */
45916     int n_val;
45917
45918     for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
45919         mem_base = xmlMemBlocks();
45920         val = gen_xmlXPathObjectPtr(n_val, 0);
45921
45922         ret_val = xmlXPathCastToString(val);
45923         desret_xmlChar_ptr(ret_val);
45924         call_tests++;
45925         des_xmlXPathObjectPtr(n_val, val, 0);
45926         xmlResetLastError();
45927         if (mem_base != xmlMemBlocks()) {
45928             printf("Leak of %d blocks found in xmlXPathCastToString",
45929                    xmlMemBlocks() - mem_base);
45930             test_ret++;
45931             printf(" %d", n_val);
45932             printf("\n");
45933         }
45934     }
45935     function_tests++;
45936 #endif
45937
45938     return(test_ret);
45939 }
45940
45941
45942 static int
45943 test_xmlXPathCmpNodes(void) {
45944     int test_ret = 0;
45945
45946 #if defined(LIBXML_XPATH_ENABLED)
45947     int mem_base;
45948     int ret_val;
45949     xmlNodePtr node1; /* the first node */
45950     int n_node1;
45951     xmlNodePtr node2; /* the second node */
45952     int n_node2;
45953
45954     for (n_node1 = 0;n_node1 < gen_nb_xmlNodePtr;n_node1++) {
45955     for (n_node2 = 0;n_node2 < gen_nb_xmlNodePtr;n_node2++) {
45956         mem_base = xmlMemBlocks();
45957         node1 = gen_xmlNodePtr(n_node1, 0);
45958         node2 = gen_xmlNodePtr(n_node2, 1);
45959
45960         ret_val = xmlXPathCmpNodes(node1, node2);
45961         desret_int(ret_val);
45962         call_tests++;
45963         des_xmlNodePtr(n_node1, node1, 0);
45964         des_xmlNodePtr(n_node2, node2, 1);
45965         xmlResetLastError();
45966         if (mem_base != xmlMemBlocks()) {
45967             printf("Leak of %d blocks found in xmlXPathCmpNodes",
45968                    xmlMemBlocks() - mem_base);
45969             test_ret++;
45970             printf(" %d", n_node1);
45971             printf(" %d", n_node2);
45972             printf("\n");
45973         }
45974     }
45975     }
45976     function_tests++;
45977 #endif
45978
45979     return(test_ret);
45980 }
45981
45982
45983 static int
45984 test_xmlXPathCompile(void) {
45985     int test_ret = 0;
45986
45987
45988     /* missing type support */
45989     return(test_ret);
45990 }
45991
45992 #ifdef LIBXML_XPATH_ENABLED
45993
45994 #define gen_nb_xmlXPathCompExprPtr 1
45995 static xmlXPathCompExprPtr gen_xmlXPathCompExprPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
45996     return(NULL);
45997 }
45998 static void des_xmlXPathCompExprPtr(int no ATTRIBUTE_UNUSED, xmlXPathCompExprPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
45999 }
46000 #endif
46001
46002 #ifdef LIBXML_XPATH_ENABLED
46003
46004 #define gen_nb_xmlXPathContextPtr 1
46005 static xmlXPathContextPtr gen_xmlXPathContextPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
46006     return(NULL);
46007 }
46008 static void des_xmlXPathContextPtr(int no ATTRIBUTE_UNUSED, xmlXPathContextPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
46009 }
46010 #endif
46011
46012
46013 static int
46014 test_xmlXPathCompiledEval(void) {
46015     int test_ret = 0;
46016
46017 #if defined(LIBXML_XPATH_ENABLED)
46018     int mem_base;
46019     xmlXPathObjectPtr ret_val;
46020     xmlXPathCompExprPtr comp; /* the compiled XPath expression */
46021     int n_comp;
46022     xmlXPathContextPtr ctx; /* the XPath context */
46023     int n_ctx;
46024
46025     for (n_comp = 0;n_comp < gen_nb_xmlXPathCompExprPtr;n_comp++) {
46026     for (n_ctx = 0;n_ctx < gen_nb_xmlXPathContextPtr;n_ctx++) {
46027         mem_base = xmlMemBlocks();
46028         comp = gen_xmlXPathCompExprPtr(n_comp, 0);
46029         ctx = gen_xmlXPathContextPtr(n_ctx, 1);
46030
46031         ret_val = xmlXPathCompiledEval(comp, ctx);
46032         desret_xmlXPathObjectPtr(ret_val);
46033         call_tests++;
46034         des_xmlXPathCompExprPtr(n_comp, comp, 0);
46035         des_xmlXPathContextPtr(n_ctx, ctx, 1);
46036         xmlResetLastError();
46037         if (mem_base != xmlMemBlocks()) {
46038             printf("Leak of %d blocks found in xmlXPathCompiledEval",
46039                    xmlMemBlocks() - mem_base);
46040             test_ret++;
46041             printf(" %d", n_comp);
46042             printf(" %d", n_ctx);
46043             printf("\n");
46044         }
46045     }
46046     }
46047     function_tests++;
46048 #endif
46049
46050     return(test_ret);
46051 }
46052
46053
46054 static int
46055 test_xmlXPathCompiledEvalToBoolean(void) {
46056     int test_ret = 0;
46057
46058 #if defined(LIBXML_XPATH_ENABLED)
46059     int mem_base;
46060     int ret_val;
46061     xmlXPathCompExprPtr comp; /* the compiled XPath expression */
46062     int n_comp;
46063     xmlXPathContextPtr ctxt; /* the XPath context */
46064     int n_ctxt;
46065
46066     for (n_comp = 0;n_comp < gen_nb_xmlXPathCompExprPtr;n_comp++) {
46067     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
46068         mem_base = xmlMemBlocks();
46069         comp = gen_xmlXPathCompExprPtr(n_comp, 0);
46070         ctxt = gen_xmlXPathContextPtr(n_ctxt, 1);
46071
46072         ret_val = xmlXPathCompiledEvalToBoolean(comp, ctxt);
46073         desret_int(ret_val);
46074         call_tests++;
46075         des_xmlXPathCompExprPtr(n_comp, comp, 0);
46076         des_xmlXPathContextPtr(n_ctxt, ctxt, 1);
46077         xmlResetLastError();
46078         if (mem_base != xmlMemBlocks()) {
46079             printf("Leak of %d blocks found in xmlXPathCompiledEvalToBoolean",
46080                    xmlMemBlocks() - mem_base);
46081             test_ret++;
46082             printf(" %d", n_comp);
46083             printf(" %d", n_ctxt);
46084             printf("\n");
46085         }
46086     }
46087     }
46088     function_tests++;
46089 #endif
46090
46091     return(test_ret);
46092 }
46093
46094
46095 static int
46096 test_xmlXPathContextSetCache(void) {
46097     int test_ret = 0;
46098
46099 #if defined(LIBXML_XPATH_ENABLED)
46100     int mem_base;
46101     int ret_val;
46102     xmlXPathContextPtr ctxt; /* the XPath context */
46103     int n_ctxt;
46104     int active; /* enables/disables (creates/frees) the cache */
46105     int n_active;
46106     int value; /* a value with semantics dependant on @options */
46107     int n_value;
46108     int options; /* options (currently only the value 0 is used) */
46109     int n_options;
46110
46111     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
46112     for (n_active = 0;n_active < gen_nb_int;n_active++) {
46113     for (n_value = 0;n_value < gen_nb_int;n_value++) {
46114     for (n_options = 0;n_options < gen_nb_int;n_options++) {
46115         mem_base = xmlMemBlocks();
46116         ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
46117         active = gen_int(n_active, 1);
46118         value = gen_int(n_value, 2);
46119         options = gen_int(n_options, 3);
46120
46121         ret_val = xmlXPathContextSetCache(ctxt, active, value, options);
46122         desret_int(ret_val);
46123         call_tests++;
46124         des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
46125         des_int(n_active, active, 1);
46126         des_int(n_value, value, 2);
46127         des_int(n_options, options, 3);
46128         xmlResetLastError();
46129         if (mem_base != xmlMemBlocks()) {
46130             printf("Leak of %d blocks found in xmlXPathContextSetCache",
46131                    xmlMemBlocks() - mem_base);
46132             test_ret++;
46133             printf(" %d", n_ctxt);
46134             printf(" %d", n_active);
46135             printf(" %d", n_value);
46136             printf(" %d", n_options);
46137             printf("\n");
46138         }
46139     }
46140     }
46141     }
46142     }
46143     function_tests++;
46144 #endif
46145
46146     return(test_ret);
46147 }
46148
46149
46150 static int
46151 test_xmlXPathConvertBoolean(void) {
46152     int test_ret = 0;
46153
46154 #if defined(LIBXML_XPATH_ENABLED)
46155     int mem_base;
46156     xmlXPathObjectPtr ret_val;
46157     xmlXPathObjectPtr val; /* an XPath object */
46158     int n_val;
46159
46160     for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
46161         mem_base = xmlMemBlocks();
46162         val = gen_xmlXPathObjectPtr(n_val, 0);
46163
46164         ret_val = xmlXPathConvertBoolean(val);
46165         val = NULL;
46166         desret_xmlXPathObjectPtr(ret_val);
46167         call_tests++;
46168         des_xmlXPathObjectPtr(n_val, val, 0);
46169         xmlResetLastError();
46170         if (mem_base != xmlMemBlocks()) {
46171             printf("Leak of %d blocks found in xmlXPathConvertBoolean",
46172                    xmlMemBlocks() - mem_base);
46173             test_ret++;
46174             printf(" %d", n_val);
46175             printf("\n");
46176         }
46177     }
46178     function_tests++;
46179 #endif
46180
46181     return(test_ret);
46182 }
46183
46184
46185 static int
46186 test_xmlXPathConvertNumber(void) {
46187     int test_ret = 0;
46188
46189 #if defined(LIBXML_XPATH_ENABLED)
46190     int mem_base;
46191     xmlXPathObjectPtr ret_val;
46192     xmlXPathObjectPtr val; /* an XPath object */
46193     int n_val;
46194
46195     for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
46196         mem_base = xmlMemBlocks();
46197         val = gen_xmlXPathObjectPtr(n_val, 0);
46198
46199         ret_val = xmlXPathConvertNumber(val);
46200         val = NULL;
46201         desret_xmlXPathObjectPtr(ret_val);
46202         call_tests++;
46203         des_xmlXPathObjectPtr(n_val, val, 0);
46204         xmlResetLastError();
46205         if (mem_base != xmlMemBlocks()) {
46206             printf("Leak of %d blocks found in xmlXPathConvertNumber",
46207                    xmlMemBlocks() - mem_base);
46208             test_ret++;
46209             printf(" %d", n_val);
46210             printf("\n");
46211         }
46212     }
46213     function_tests++;
46214 #endif
46215
46216     return(test_ret);
46217 }
46218
46219
46220 static int
46221 test_xmlXPathConvertString(void) {
46222     int test_ret = 0;
46223
46224 #if defined(LIBXML_XPATH_ENABLED)
46225     int mem_base;
46226     xmlXPathObjectPtr ret_val;
46227     xmlXPathObjectPtr val; /* an XPath object */
46228     int n_val;
46229
46230     for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
46231         mem_base = xmlMemBlocks();
46232         val = gen_xmlXPathObjectPtr(n_val, 0);
46233
46234         ret_val = xmlXPathConvertString(val);
46235         val = NULL;
46236         desret_xmlXPathObjectPtr(ret_val);
46237         call_tests++;
46238         des_xmlXPathObjectPtr(n_val, val, 0);
46239         xmlResetLastError();
46240         if (mem_base != xmlMemBlocks()) {
46241             printf("Leak of %d blocks found in xmlXPathConvertString",
46242                    xmlMemBlocks() - mem_base);
46243             test_ret++;
46244             printf(" %d", n_val);
46245             printf("\n");
46246         }
46247     }
46248     function_tests++;
46249 #endif
46250
46251     return(test_ret);
46252 }
46253
46254
46255 static int
46256 test_xmlXPathCtxtCompile(void) {
46257     int test_ret = 0;
46258
46259
46260     /* missing type support */
46261     return(test_ret);
46262 }
46263
46264
46265 static int
46266 test_xmlXPathEval(void) {
46267     int test_ret = 0;
46268
46269 #if defined(LIBXML_XPATH_ENABLED)
46270     int mem_base;
46271     xmlXPathObjectPtr ret_val;
46272     xmlChar * str; /* the XPath expression */
46273     int n_str;
46274     xmlXPathContextPtr ctx; /* the XPath context */
46275     int n_ctx;
46276
46277     for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
46278     for (n_ctx = 0;n_ctx < gen_nb_xmlXPathContextPtr;n_ctx++) {
46279         mem_base = xmlMemBlocks();
46280         str = gen_const_xmlChar_ptr(n_str, 0);
46281         ctx = gen_xmlXPathContextPtr(n_ctx, 1);
46282
46283         ret_val = xmlXPathEval((const xmlChar *)str, ctx);
46284         desret_xmlXPathObjectPtr(ret_val);
46285         call_tests++;
46286         des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
46287         des_xmlXPathContextPtr(n_ctx, ctx, 1);
46288         xmlResetLastError();
46289         if (mem_base != xmlMemBlocks()) {
46290             printf("Leak of %d blocks found in xmlXPathEval",
46291                    xmlMemBlocks() - mem_base);
46292             test_ret++;
46293             printf(" %d", n_str);
46294             printf(" %d", n_ctx);
46295             printf("\n");
46296         }
46297     }
46298     }
46299     function_tests++;
46300 #endif
46301
46302     return(test_ret);
46303 }
46304
46305
46306 static int
46307 test_xmlXPathEvalExpression(void) {
46308     int test_ret = 0;
46309
46310 #if defined(LIBXML_XPATH_ENABLED)
46311     int mem_base;
46312     xmlXPathObjectPtr ret_val;
46313     xmlChar * str; /* the XPath expression */
46314     int n_str;
46315     xmlXPathContextPtr ctxt; /* the XPath context */
46316     int n_ctxt;
46317
46318     for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
46319     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
46320         mem_base = xmlMemBlocks();
46321         str = gen_const_xmlChar_ptr(n_str, 0);
46322         ctxt = gen_xmlXPathContextPtr(n_ctxt, 1);
46323
46324         ret_val = xmlXPathEvalExpression((const xmlChar *)str, ctxt);
46325         desret_xmlXPathObjectPtr(ret_val);
46326         call_tests++;
46327         des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
46328         des_xmlXPathContextPtr(n_ctxt, ctxt, 1);
46329         xmlResetLastError();
46330         if (mem_base != xmlMemBlocks()) {
46331             printf("Leak of %d blocks found in xmlXPathEvalExpression",
46332                    xmlMemBlocks() - mem_base);
46333             test_ret++;
46334             printf(" %d", n_str);
46335             printf(" %d", n_ctxt);
46336             printf("\n");
46337         }
46338     }
46339     }
46340     function_tests++;
46341 #endif
46342
46343     return(test_ret);
46344 }
46345
46346
46347 static int
46348 test_xmlXPathEvalPredicate(void) {
46349     int test_ret = 0;
46350
46351 #if defined(LIBXML_XPATH_ENABLED)
46352     int mem_base;
46353     int ret_val;
46354     xmlXPathContextPtr ctxt; /* the XPath context */
46355     int n_ctxt;
46356     xmlXPathObjectPtr res; /* the Predicate Expression evaluation result */
46357     int n_res;
46358
46359     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
46360     for (n_res = 0;n_res < gen_nb_xmlXPathObjectPtr;n_res++) {
46361         mem_base = xmlMemBlocks();
46362         ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
46363         res = gen_xmlXPathObjectPtr(n_res, 1);
46364
46365         ret_val = xmlXPathEvalPredicate(ctxt, res);
46366         desret_int(ret_val);
46367         call_tests++;
46368         des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
46369         des_xmlXPathObjectPtr(n_res, res, 1);
46370         xmlResetLastError();
46371         if (mem_base != xmlMemBlocks()) {
46372             printf("Leak of %d blocks found in xmlXPathEvalPredicate",
46373                    xmlMemBlocks() - mem_base);
46374             test_ret++;
46375             printf(" %d", n_ctxt);
46376             printf(" %d", n_res);
46377             printf("\n");
46378         }
46379     }
46380     }
46381     function_tests++;
46382 #endif
46383
46384     return(test_ret);
46385 }
46386
46387
46388 static int
46389 test_xmlXPathInit(void) {
46390     int test_ret = 0;
46391
46392 #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
46393     int mem_base;
46394
46395         mem_base = xmlMemBlocks();
46396
46397         xmlXPathInit();
46398         call_tests++;
46399         xmlResetLastError();
46400         if (mem_base != xmlMemBlocks()) {
46401             printf("Leak of %d blocks found in xmlXPathInit",
46402                    xmlMemBlocks() - mem_base);
46403             test_ret++;
46404             printf("\n");
46405         }
46406     function_tests++;
46407 #endif
46408
46409     return(test_ret);
46410 }
46411
46412
46413 static int
46414 test_xmlXPathIsInf(void) {
46415     int test_ret = 0;
46416
46417 #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
46418     int mem_base;
46419     int ret_val;
46420     double val; /* a double value */
46421     int n_val;
46422
46423     for (n_val = 0;n_val < gen_nb_double;n_val++) {
46424         mem_base = xmlMemBlocks();
46425         val = gen_double(n_val, 0);
46426
46427         ret_val = xmlXPathIsInf(val);
46428         desret_int(ret_val);
46429         call_tests++;
46430         des_double(n_val, val, 0);
46431         xmlResetLastError();
46432         if (mem_base != xmlMemBlocks()) {
46433             printf("Leak of %d blocks found in xmlXPathIsInf",
46434                    xmlMemBlocks() - mem_base);
46435             test_ret++;
46436             printf(" %d", n_val);
46437             printf("\n");
46438         }
46439     }
46440     function_tests++;
46441 #endif
46442
46443     return(test_ret);
46444 }
46445
46446
46447 static int
46448 test_xmlXPathIsNaN(void) {
46449     int test_ret = 0;
46450
46451 #if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
46452     int mem_base;
46453     int ret_val;
46454     double val; /* a double value */
46455     int n_val;
46456
46457     for (n_val = 0;n_val < gen_nb_double;n_val++) {
46458         mem_base = xmlMemBlocks();
46459         val = gen_double(n_val, 0);
46460
46461         ret_val = xmlXPathIsNaN(val);
46462         desret_int(ret_val);
46463         call_tests++;
46464         des_double(n_val, val, 0);
46465         xmlResetLastError();
46466         if (mem_base != xmlMemBlocks()) {
46467             printf("Leak of %d blocks found in xmlXPathIsNaN",
46468                    xmlMemBlocks() - mem_base);
46469             test_ret++;
46470             printf(" %d", n_val);
46471             printf("\n");
46472         }
46473     }
46474     function_tests++;
46475 #endif
46476
46477     return(test_ret);
46478 }
46479
46480
46481 static int
46482 test_xmlXPathNewContext(void) {
46483     int test_ret = 0;
46484
46485
46486     /* missing type support */
46487     return(test_ret);
46488 }
46489
46490
46491 static int
46492 test_xmlXPathNodeSetCreate(void) {
46493     int test_ret = 0;
46494
46495 #if defined(LIBXML_XPATH_ENABLED)
46496     int mem_base;
46497     xmlNodeSetPtr ret_val;
46498     xmlNodePtr val; /* an initial xmlNodePtr, or NULL */
46499     int n_val;
46500
46501     for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
46502         mem_base = xmlMemBlocks();
46503         val = gen_xmlNodePtr(n_val, 0);
46504
46505         ret_val = xmlXPathNodeSetCreate(val);
46506         desret_xmlNodeSetPtr(ret_val);
46507         call_tests++;
46508         des_xmlNodePtr(n_val, val, 0);
46509         xmlResetLastError();
46510         if (mem_base != xmlMemBlocks()) {
46511             printf("Leak of %d blocks found in xmlXPathNodeSetCreate",
46512                    xmlMemBlocks() - mem_base);
46513             test_ret++;
46514             printf(" %d", n_val);
46515             printf("\n");
46516         }
46517     }
46518     function_tests++;
46519 #endif
46520
46521     return(test_ret);
46522 }
46523
46524
46525 static int
46526 test_xmlXPathObjectCopy(void) {
46527     int test_ret = 0;
46528
46529 #if defined(LIBXML_XPATH_ENABLED)
46530     int mem_base;
46531     xmlXPathObjectPtr ret_val;
46532     xmlXPathObjectPtr val; /* the original object */
46533     int n_val;
46534
46535     for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
46536         mem_base = xmlMemBlocks();
46537         val = gen_xmlXPathObjectPtr(n_val, 0);
46538
46539         ret_val = xmlXPathObjectCopy(val);
46540         desret_xmlXPathObjectPtr(ret_val);
46541         call_tests++;
46542         des_xmlXPathObjectPtr(n_val, val, 0);
46543         xmlResetLastError();
46544         if (mem_base != xmlMemBlocks()) {
46545             printf("Leak of %d blocks found in xmlXPathObjectCopy",
46546                    xmlMemBlocks() - mem_base);
46547             test_ret++;
46548             printf(" %d", n_val);
46549             printf("\n");
46550         }
46551     }
46552     function_tests++;
46553 #endif
46554
46555     return(test_ret);
46556 }
46557
46558
46559 static int
46560 test_xmlXPathOrderDocElems(void) {
46561     int test_ret = 0;
46562
46563 #if defined(LIBXML_XPATH_ENABLED)
46564     int mem_base;
46565     long ret_val;
46566     xmlDocPtr doc; /* an input document */
46567     int n_doc;
46568
46569     for (n_doc = 0;n_doc < gen_nb_xmlDocPtr;n_doc++) {
46570         mem_base = xmlMemBlocks();
46571         doc = gen_xmlDocPtr(n_doc, 0);
46572
46573         ret_val = xmlXPathOrderDocElems(doc);
46574         desret_long(ret_val);
46575         call_tests++;
46576         des_xmlDocPtr(n_doc, doc, 0);
46577         xmlResetLastError();
46578         if (mem_base != xmlMemBlocks()) {
46579             printf("Leak of %d blocks found in xmlXPathOrderDocElems",
46580                    xmlMemBlocks() - mem_base);
46581             test_ret++;
46582             printf(" %d", n_doc);
46583             printf("\n");
46584         }
46585     }
46586     function_tests++;
46587 #endif
46588
46589     return(test_ret);
46590 }
46591
46592 static int
46593 test_xpath(void) {
46594     int test_ret = 0;
46595
46596     if (quiet == 0) printf("Testing xpath : 30 of 38 functions ...\n");
46597     test_ret += test_xmlXPathCastBooleanToNumber();
46598     test_ret += test_xmlXPathCastBooleanToString();
46599     test_ret += test_xmlXPathCastNodeSetToBoolean();
46600     test_ret += test_xmlXPathCastNodeSetToNumber();
46601     test_ret += test_xmlXPathCastNodeSetToString();
46602     test_ret += test_xmlXPathCastNodeToNumber();
46603     test_ret += test_xmlXPathCastNodeToString();
46604     test_ret += test_xmlXPathCastNumberToBoolean();
46605     test_ret += test_xmlXPathCastNumberToString();
46606     test_ret += test_xmlXPathCastStringToBoolean();
46607     test_ret += test_xmlXPathCastStringToNumber();
46608     test_ret += test_xmlXPathCastToBoolean();
46609     test_ret += test_xmlXPathCastToNumber();
46610     test_ret += test_xmlXPathCastToString();
46611     test_ret += test_xmlXPathCmpNodes();
46612     test_ret += test_xmlXPathCompile();
46613     test_ret += test_xmlXPathCompiledEval();
46614     test_ret += test_xmlXPathCompiledEvalToBoolean();
46615     test_ret += test_xmlXPathContextSetCache();
46616     test_ret += test_xmlXPathConvertBoolean();
46617     test_ret += test_xmlXPathConvertNumber();
46618     test_ret += test_xmlXPathConvertString();
46619     test_ret += test_xmlXPathCtxtCompile();
46620     test_ret += test_xmlXPathEval();
46621     test_ret += test_xmlXPathEvalExpression();
46622     test_ret += test_xmlXPathEvalPredicate();
46623     test_ret += test_xmlXPathInit();
46624     test_ret += test_xmlXPathIsInf();
46625     test_ret += test_xmlXPathIsNaN();
46626     test_ret += test_xmlXPathNewContext();
46627     test_ret += test_xmlXPathNodeSetCreate();
46628     test_ret += test_xmlXPathObjectCopy();
46629     test_ret += test_xmlXPathOrderDocElems();
46630
46631     if (test_ret != 0)
46632         printf("Module xpath: %d errors\n", test_ret);
46633     return(test_ret);
46634 }
46635 #ifdef LIBXML_XPATH_ENABLED
46636
46637 #define gen_nb_xmlXPathParserContextPtr 1
46638 static xmlXPathParserContextPtr gen_xmlXPathParserContextPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
46639     return(NULL);
46640 }
46641 static void des_xmlXPathParserContextPtr(int no ATTRIBUTE_UNUSED, xmlXPathParserContextPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
46642 }
46643 #endif
46644
46645
46646 static int
46647 test_valuePop(void) {
46648     int test_ret = 0;
46649
46650 #if defined(LIBXML_XPATH_ENABLED)
46651     int mem_base;
46652     xmlXPathObjectPtr ret_val;
46653     xmlXPathParserContextPtr ctxt; /* an XPath evaluation context */
46654     int n_ctxt;
46655
46656     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
46657         mem_base = xmlMemBlocks();
46658         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
46659
46660         ret_val = valuePop(ctxt);
46661         desret_xmlXPathObjectPtr(ret_val);
46662         call_tests++;
46663         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
46664         xmlResetLastError();
46665         if (mem_base != xmlMemBlocks()) {
46666             printf("Leak of %d blocks found in valuePop",
46667                    xmlMemBlocks() - mem_base);
46668             test_ret++;
46669             printf(" %d", n_ctxt);
46670             printf("\n");
46671         }
46672     }
46673     function_tests++;
46674 #endif
46675
46676     return(test_ret);
46677 }
46678
46679
46680 static int
46681 test_valuePush(void) {
46682     int test_ret = 0;
46683
46684 #if defined(LIBXML_XPATH_ENABLED)
46685     int mem_base;
46686     int ret_val;
46687     xmlXPathParserContextPtr ctxt; /* an XPath evaluation context */
46688     int n_ctxt;
46689     xmlXPathObjectPtr value; /* the XPath object */
46690     int n_value;
46691
46692     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
46693     for (n_value = 0;n_value < gen_nb_xmlXPathObjectPtr;n_value++) {
46694         mem_base = xmlMemBlocks();
46695         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
46696         value = gen_xmlXPathObjectPtr(n_value, 1);
46697
46698         ret_val = valuePush(ctxt, value);
46699         desret_int(ret_val);
46700         call_tests++;
46701         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
46702         des_xmlXPathObjectPtr(n_value, value, 1);
46703         xmlResetLastError();
46704         if (mem_base != xmlMemBlocks()) {
46705             printf("Leak of %d blocks found in valuePush",
46706                    xmlMemBlocks() - mem_base);
46707             test_ret++;
46708             printf(" %d", n_ctxt);
46709             printf(" %d", n_value);
46710             printf("\n");
46711         }
46712     }
46713     }
46714     function_tests++;
46715 #endif
46716
46717     return(test_ret);
46718 }
46719
46720
46721 static int
46722 test_xmlXPathAddValues(void) {
46723     int test_ret = 0;
46724
46725 #if defined(LIBXML_XPATH_ENABLED)
46726     int mem_base;
46727     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
46728     int n_ctxt;
46729
46730     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
46731         mem_base = xmlMemBlocks();
46732         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
46733
46734         xmlXPathAddValues(ctxt);
46735         call_tests++;
46736         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
46737         xmlResetLastError();
46738         if (mem_base != xmlMemBlocks()) {
46739             printf("Leak of %d blocks found in xmlXPathAddValues",
46740                    xmlMemBlocks() - mem_base);
46741             test_ret++;
46742             printf(" %d", n_ctxt);
46743             printf("\n");
46744         }
46745     }
46746     function_tests++;
46747 #endif
46748
46749     return(test_ret);
46750 }
46751
46752
46753 static int
46754 test_xmlXPathBooleanFunction(void) {
46755     int test_ret = 0;
46756
46757 #if defined(LIBXML_XPATH_ENABLED)
46758     int mem_base;
46759     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
46760     int n_ctxt;
46761     int nargs; /* the number of arguments */
46762     int n_nargs;
46763
46764     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
46765     for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
46766         mem_base = xmlMemBlocks();
46767         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
46768         nargs = gen_int(n_nargs, 1);
46769
46770         xmlXPathBooleanFunction(ctxt, nargs);
46771         call_tests++;
46772         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
46773         des_int(n_nargs, nargs, 1);
46774         xmlResetLastError();
46775         if (mem_base != xmlMemBlocks()) {
46776             printf("Leak of %d blocks found in xmlXPathBooleanFunction",
46777                    xmlMemBlocks() - mem_base);
46778             test_ret++;
46779             printf(" %d", n_ctxt);
46780             printf(" %d", n_nargs);
46781             printf("\n");
46782         }
46783     }
46784     }
46785     function_tests++;
46786 #endif
46787
46788     return(test_ret);
46789 }
46790
46791
46792 static int
46793 test_xmlXPathCeilingFunction(void) {
46794     int test_ret = 0;
46795
46796 #if defined(LIBXML_XPATH_ENABLED)
46797     int mem_base;
46798     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
46799     int n_ctxt;
46800     int nargs; /* the number of arguments */
46801     int n_nargs;
46802
46803     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
46804     for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
46805         mem_base = xmlMemBlocks();
46806         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
46807         nargs = gen_int(n_nargs, 1);
46808
46809         xmlXPathCeilingFunction(ctxt, nargs);
46810         call_tests++;
46811         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
46812         des_int(n_nargs, nargs, 1);
46813         xmlResetLastError();
46814         if (mem_base != xmlMemBlocks()) {
46815             printf("Leak of %d blocks found in xmlXPathCeilingFunction",
46816                    xmlMemBlocks() - mem_base);
46817             test_ret++;
46818             printf(" %d", n_ctxt);
46819             printf(" %d", n_nargs);
46820             printf("\n");
46821         }
46822     }
46823     }
46824     function_tests++;
46825 #endif
46826
46827     return(test_ret);
46828 }
46829
46830
46831 static int
46832 test_xmlXPathCompareValues(void) {
46833     int test_ret = 0;
46834
46835 #if defined(LIBXML_XPATH_ENABLED)
46836     int mem_base;
46837     int ret_val;
46838     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
46839     int n_ctxt;
46840     int inf; /* less than (1) or greater than (0) */
46841     int n_inf;
46842     int strict; /* is the comparison strict */
46843     int n_strict;
46844
46845     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
46846     for (n_inf = 0;n_inf < gen_nb_int;n_inf++) {
46847     for (n_strict = 0;n_strict < gen_nb_int;n_strict++) {
46848         mem_base = xmlMemBlocks();
46849         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
46850         inf = gen_int(n_inf, 1);
46851         strict = gen_int(n_strict, 2);
46852
46853         ret_val = xmlXPathCompareValues(ctxt, inf, strict);
46854         desret_int(ret_val);
46855         call_tests++;
46856         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
46857         des_int(n_inf, inf, 1);
46858         des_int(n_strict, strict, 2);
46859         xmlResetLastError();
46860         if (mem_base != xmlMemBlocks()) {
46861             printf("Leak of %d blocks found in xmlXPathCompareValues",
46862                    xmlMemBlocks() - mem_base);
46863             test_ret++;
46864             printf(" %d", n_ctxt);
46865             printf(" %d", n_inf);
46866             printf(" %d", n_strict);
46867             printf("\n");
46868         }
46869     }
46870     }
46871     }
46872     function_tests++;
46873 #endif
46874
46875     return(test_ret);
46876 }
46877
46878
46879 static int
46880 test_xmlXPathConcatFunction(void) {
46881     int test_ret = 0;
46882
46883 #if defined(LIBXML_XPATH_ENABLED)
46884     int mem_base;
46885     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
46886     int n_ctxt;
46887     int nargs; /* the number of arguments */
46888     int n_nargs;
46889
46890     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
46891     for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
46892         mem_base = xmlMemBlocks();
46893         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
46894         nargs = gen_int(n_nargs, 1);
46895
46896         xmlXPathConcatFunction(ctxt, nargs);
46897         call_tests++;
46898         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
46899         des_int(n_nargs, nargs, 1);
46900         xmlResetLastError();
46901         if (mem_base != xmlMemBlocks()) {
46902             printf("Leak of %d blocks found in xmlXPathConcatFunction",
46903                    xmlMemBlocks() - mem_base);
46904             test_ret++;
46905             printf(" %d", n_ctxt);
46906             printf(" %d", n_nargs);
46907             printf("\n");
46908         }
46909     }
46910     }
46911     function_tests++;
46912 #endif
46913
46914     return(test_ret);
46915 }
46916
46917
46918 static int
46919 test_xmlXPathContainsFunction(void) {
46920     int test_ret = 0;
46921
46922 #if defined(LIBXML_XPATH_ENABLED)
46923     int mem_base;
46924     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
46925     int n_ctxt;
46926     int nargs; /* the number of arguments */
46927     int n_nargs;
46928
46929     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
46930     for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
46931         mem_base = xmlMemBlocks();
46932         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
46933         nargs = gen_int(n_nargs, 1);
46934
46935         xmlXPathContainsFunction(ctxt, nargs);
46936         call_tests++;
46937         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
46938         des_int(n_nargs, nargs, 1);
46939         xmlResetLastError();
46940         if (mem_base != xmlMemBlocks()) {
46941             printf("Leak of %d blocks found in xmlXPathContainsFunction",
46942                    xmlMemBlocks() - mem_base);
46943             test_ret++;
46944             printf(" %d", n_ctxt);
46945             printf(" %d", n_nargs);
46946             printf("\n");
46947         }
46948     }
46949     }
46950     function_tests++;
46951 #endif
46952
46953     return(test_ret);
46954 }
46955
46956
46957 static int
46958 test_xmlXPathCountFunction(void) {
46959     int test_ret = 0;
46960
46961 #if defined(LIBXML_XPATH_ENABLED)
46962     int mem_base;
46963     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
46964     int n_ctxt;
46965     int nargs; /* the number of arguments */
46966     int n_nargs;
46967
46968     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
46969     for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
46970         mem_base = xmlMemBlocks();
46971         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
46972         nargs = gen_int(n_nargs, 1);
46973
46974         xmlXPathCountFunction(ctxt, nargs);
46975         call_tests++;
46976         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
46977         des_int(n_nargs, nargs, 1);
46978         xmlResetLastError();
46979         if (mem_base != xmlMemBlocks()) {
46980             printf("Leak of %d blocks found in xmlXPathCountFunction",
46981                    xmlMemBlocks() - mem_base);
46982             test_ret++;
46983             printf(" %d", n_ctxt);
46984             printf(" %d", n_nargs);
46985             printf("\n");
46986         }
46987     }
46988     }
46989     function_tests++;
46990 #endif
46991
46992     return(test_ret);
46993 }
46994
46995
46996 static int
46997 test_xmlXPathDebugDumpCompExpr(void) {
46998     int test_ret = 0;
46999
47000 #if defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_DEBUG_ENABLED)
47001     int mem_base;
47002     FILE * output; /* the FILE * for the output */
47003     int n_output;
47004     xmlXPathCompExprPtr comp; /* the precompiled XPath expression */
47005     int n_comp;
47006     int depth; /* the indentation level. */
47007     int n_depth;
47008
47009     for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
47010     for (n_comp = 0;n_comp < gen_nb_xmlXPathCompExprPtr;n_comp++) {
47011     for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
47012         mem_base = xmlMemBlocks();
47013         output = gen_FILE_ptr(n_output, 0);
47014         comp = gen_xmlXPathCompExprPtr(n_comp, 1);
47015         depth = gen_int(n_depth, 2);
47016
47017         xmlXPathDebugDumpCompExpr(output, comp, depth);
47018         call_tests++;
47019         des_FILE_ptr(n_output, output, 0);
47020         des_xmlXPathCompExprPtr(n_comp, comp, 1);
47021         des_int(n_depth, depth, 2);
47022         xmlResetLastError();
47023         if (mem_base != xmlMemBlocks()) {
47024             printf("Leak of %d blocks found in xmlXPathDebugDumpCompExpr",
47025                    xmlMemBlocks() - mem_base);
47026             test_ret++;
47027             printf(" %d", n_output);
47028             printf(" %d", n_comp);
47029             printf(" %d", n_depth);
47030             printf("\n");
47031         }
47032     }
47033     }
47034     }
47035     function_tests++;
47036 #endif
47037
47038     return(test_ret);
47039 }
47040
47041
47042 static int
47043 test_xmlXPathDebugDumpObject(void) {
47044     int test_ret = 0;
47045
47046 #if defined(LIBXML_XPATH_ENABLED) && defined(LIBXML_DEBUG_ENABLED)
47047     int mem_base;
47048     FILE * output; /* the FILE * to dump the output */
47049     int n_output;
47050     xmlXPathObjectPtr cur; /* the object to inspect */
47051     int n_cur;
47052     int depth; /* indentation level */
47053     int n_depth;
47054
47055     for (n_output = 0;n_output < gen_nb_FILE_ptr;n_output++) {
47056     for (n_cur = 0;n_cur < gen_nb_xmlXPathObjectPtr;n_cur++) {
47057     for (n_depth = 0;n_depth < gen_nb_int;n_depth++) {
47058         mem_base = xmlMemBlocks();
47059         output = gen_FILE_ptr(n_output, 0);
47060         cur = gen_xmlXPathObjectPtr(n_cur, 1);
47061         depth = gen_int(n_depth, 2);
47062
47063         xmlXPathDebugDumpObject(output, cur, depth);
47064         call_tests++;
47065         des_FILE_ptr(n_output, output, 0);
47066         des_xmlXPathObjectPtr(n_cur, cur, 1);
47067         des_int(n_depth, depth, 2);
47068         xmlResetLastError();
47069         if (mem_base != xmlMemBlocks()) {
47070             printf("Leak of %d blocks found in xmlXPathDebugDumpObject",
47071                    xmlMemBlocks() - mem_base);
47072             test_ret++;
47073             printf(" %d", n_output);
47074             printf(" %d", n_cur);
47075             printf(" %d", n_depth);
47076             printf("\n");
47077         }
47078     }
47079     }
47080     }
47081     function_tests++;
47082 #endif
47083
47084     return(test_ret);
47085 }
47086
47087
47088 static int
47089 test_xmlXPathDifference(void) {
47090     int test_ret = 0;
47091
47092 #if defined(LIBXML_XPATH_ENABLED)
47093     int mem_base;
47094     xmlNodeSetPtr ret_val;
47095     xmlNodeSetPtr nodes1; /* a node-set */
47096     int n_nodes1;
47097     xmlNodeSetPtr nodes2; /* a node-set */
47098     int n_nodes2;
47099
47100     for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
47101     for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
47102         mem_base = xmlMemBlocks();
47103         nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
47104         nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
47105
47106         ret_val = xmlXPathDifference(nodes1, nodes2);
47107         desret_xmlNodeSetPtr(ret_val);
47108         call_tests++;
47109         des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
47110         des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
47111         xmlResetLastError();
47112         if (mem_base != xmlMemBlocks()) {
47113             printf("Leak of %d blocks found in xmlXPathDifference",
47114                    xmlMemBlocks() - mem_base);
47115             test_ret++;
47116             printf(" %d", n_nodes1);
47117             printf(" %d", n_nodes2);
47118             printf("\n");
47119         }
47120     }
47121     }
47122     function_tests++;
47123 #endif
47124
47125     return(test_ret);
47126 }
47127
47128
47129 static int
47130 test_xmlXPathDistinct(void) {
47131     int test_ret = 0;
47132
47133 #if defined(LIBXML_XPATH_ENABLED)
47134     int mem_base;
47135     xmlNodeSetPtr ret_val;
47136     xmlNodeSetPtr nodes; /* a node-set */
47137     int n_nodes;
47138
47139     for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
47140         mem_base = xmlMemBlocks();
47141         nodes = gen_xmlNodeSetPtr(n_nodes, 0);
47142
47143         ret_val = xmlXPathDistinct(nodes);
47144         desret_xmlNodeSetPtr(ret_val);
47145         call_tests++;
47146         des_xmlNodeSetPtr(n_nodes, nodes, 0);
47147         xmlResetLastError();
47148         if (mem_base != xmlMemBlocks()) {
47149             printf("Leak of %d blocks found in xmlXPathDistinct",
47150                    xmlMemBlocks() - mem_base);
47151             test_ret++;
47152             printf(" %d", n_nodes);
47153             printf("\n");
47154         }
47155     }
47156     function_tests++;
47157 #endif
47158
47159     return(test_ret);
47160 }
47161
47162
47163 static int
47164 test_xmlXPathDistinctSorted(void) {
47165     int test_ret = 0;
47166
47167 #if defined(LIBXML_XPATH_ENABLED)
47168     int mem_base;
47169     xmlNodeSetPtr ret_val;
47170     xmlNodeSetPtr nodes; /* a node-set, sorted by document order */
47171     int n_nodes;
47172
47173     for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
47174         mem_base = xmlMemBlocks();
47175         nodes = gen_xmlNodeSetPtr(n_nodes, 0);
47176
47177         ret_val = xmlXPathDistinctSorted(nodes);
47178         desret_xmlNodeSetPtr(ret_val);
47179         call_tests++;
47180         des_xmlNodeSetPtr(n_nodes, nodes, 0);
47181         xmlResetLastError();
47182         if (mem_base != xmlMemBlocks()) {
47183             printf("Leak of %d blocks found in xmlXPathDistinctSorted",
47184                    xmlMemBlocks() - mem_base);
47185             test_ret++;
47186             printf(" %d", n_nodes);
47187             printf("\n");
47188         }
47189     }
47190     function_tests++;
47191 #endif
47192
47193     return(test_ret);
47194 }
47195
47196
47197 static int
47198 test_xmlXPathDivValues(void) {
47199     int test_ret = 0;
47200
47201 #if defined(LIBXML_XPATH_ENABLED)
47202     int mem_base;
47203     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47204     int n_ctxt;
47205
47206     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47207         mem_base = xmlMemBlocks();
47208         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47209
47210         xmlXPathDivValues(ctxt);
47211         call_tests++;
47212         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47213         xmlResetLastError();
47214         if (mem_base != xmlMemBlocks()) {
47215             printf("Leak of %d blocks found in xmlXPathDivValues",
47216                    xmlMemBlocks() - mem_base);
47217             test_ret++;
47218             printf(" %d", n_ctxt);
47219             printf("\n");
47220         }
47221     }
47222     function_tests++;
47223 #endif
47224
47225     return(test_ret);
47226 }
47227
47228
47229 static int
47230 test_xmlXPathEqualValues(void) {
47231     int test_ret = 0;
47232
47233 #if defined(LIBXML_XPATH_ENABLED)
47234     int mem_base;
47235     int ret_val;
47236     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47237     int n_ctxt;
47238
47239     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47240         mem_base = xmlMemBlocks();
47241         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47242
47243         ret_val = xmlXPathEqualValues(ctxt);
47244         desret_int(ret_val);
47245         call_tests++;
47246         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47247         xmlResetLastError();
47248         if (mem_base != xmlMemBlocks()) {
47249             printf("Leak of %d blocks found in xmlXPathEqualValues",
47250                    xmlMemBlocks() - mem_base);
47251             test_ret++;
47252             printf(" %d", n_ctxt);
47253             printf("\n");
47254         }
47255     }
47256     function_tests++;
47257 #endif
47258
47259     return(test_ret);
47260 }
47261
47262
47263 static int
47264 test_xmlXPathErr(void) {
47265     int test_ret = 0;
47266
47267 #if defined(LIBXML_XPATH_ENABLED)
47268     int mem_base;
47269     xmlXPathParserContextPtr ctxt; /* a XPath parser context */
47270     int n_ctxt;
47271     int error; /* the error code */
47272     int n_error;
47273
47274     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47275     for (n_error = 0;n_error < gen_nb_int;n_error++) {
47276         mem_base = xmlMemBlocks();
47277         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47278         error = gen_int(n_error, 1);
47279
47280         xmlXPathErr(ctxt, error);
47281         call_tests++;
47282         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47283         des_int(n_error, error, 1);
47284         xmlResetLastError();
47285         if (mem_base != xmlMemBlocks()) {
47286             printf("Leak of %d blocks found in xmlXPathErr",
47287                    xmlMemBlocks() - mem_base);
47288             test_ret++;
47289             printf(" %d", n_ctxt);
47290             printf(" %d", n_error);
47291             printf("\n");
47292         }
47293     }
47294     }
47295     function_tests++;
47296 #endif
47297
47298     return(test_ret);
47299 }
47300
47301
47302 static int
47303 test_xmlXPathEvalExpr(void) {
47304     int test_ret = 0;
47305
47306 #if defined(LIBXML_XPATH_ENABLED)
47307     int mem_base;
47308     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47309     int n_ctxt;
47310
47311     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47312         mem_base = xmlMemBlocks();
47313         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47314
47315         xmlXPathEvalExpr(ctxt);
47316         call_tests++;
47317         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47318         xmlResetLastError();
47319         if (mem_base != xmlMemBlocks()) {
47320             printf("Leak of %d blocks found in xmlXPathEvalExpr",
47321                    xmlMemBlocks() - mem_base);
47322             test_ret++;
47323             printf(" %d", n_ctxt);
47324             printf("\n");
47325         }
47326     }
47327     function_tests++;
47328 #endif
47329
47330     return(test_ret);
47331 }
47332
47333
47334 static int
47335 test_xmlXPathEvaluatePredicateResult(void) {
47336     int test_ret = 0;
47337
47338 #if defined(LIBXML_XPATH_ENABLED)
47339     int mem_base;
47340     int ret_val;
47341     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47342     int n_ctxt;
47343     xmlXPathObjectPtr res; /* the Predicate Expression evaluation result */
47344     int n_res;
47345
47346     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47347     for (n_res = 0;n_res < gen_nb_xmlXPathObjectPtr;n_res++) {
47348         mem_base = xmlMemBlocks();
47349         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47350         res = gen_xmlXPathObjectPtr(n_res, 1);
47351
47352         ret_val = xmlXPathEvaluatePredicateResult(ctxt, res);
47353         desret_int(ret_val);
47354         call_tests++;
47355         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47356         des_xmlXPathObjectPtr(n_res, res, 1);
47357         xmlResetLastError();
47358         if (mem_base != xmlMemBlocks()) {
47359             printf("Leak of %d blocks found in xmlXPathEvaluatePredicateResult",
47360                    xmlMemBlocks() - mem_base);
47361             test_ret++;
47362             printf(" %d", n_ctxt);
47363             printf(" %d", n_res);
47364             printf("\n");
47365         }
47366     }
47367     }
47368     function_tests++;
47369 #endif
47370
47371     return(test_ret);
47372 }
47373
47374
47375 static int
47376 test_xmlXPathFalseFunction(void) {
47377     int test_ret = 0;
47378
47379 #if defined(LIBXML_XPATH_ENABLED)
47380     int mem_base;
47381     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47382     int n_ctxt;
47383     int nargs; /* the number of arguments */
47384     int n_nargs;
47385
47386     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47387     for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
47388         mem_base = xmlMemBlocks();
47389         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47390         nargs = gen_int(n_nargs, 1);
47391
47392         xmlXPathFalseFunction(ctxt, nargs);
47393         call_tests++;
47394         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47395         des_int(n_nargs, nargs, 1);
47396         xmlResetLastError();
47397         if (mem_base != xmlMemBlocks()) {
47398             printf("Leak of %d blocks found in xmlXPathFalseFunction",
47399                    xmlMemBlocks() - mem_base);
47400             test_ret++;
47401             printf(" %d", n_ctxt);
47402             printf(" %d", n_nargs);
47403             printf("\n");
47404         }
47405     }
47406     }
47407     function_tests++;
47408 #endif
47409
47410     return(test_ret);
47411 }
47412
47413
47414 static int
47415 test_xmlXPathFloorFunction(void) {
47416     int test_ret = 0;
47417
47418 #if defined(LIBXML_XPATH_ENABLED)
47419     int mem_base;
47420     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47421     int n_ctxt;
47422     int nargs; /* the number of arguments */
47423     int n_nargs;
47424
47425     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47426     for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
47427         mem_base = xmlMemBlocks();
47428         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47429         nargs = gen_int(n_nargs, 1);
47430
47431         xmlXPathFloorFunction(ctxt, nargs);
47432         call_tests++;
47433         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47434         des_int(n_nargs, nargs, 1);
47435         xmlResetLastError();
47436         if (mem_base != xmlMemBlocks()) {
47437             printf("Leak of %d blocks found in xmlXPathFloorFunction",
47438                    xmlMemBlocks() - mem_base);
47439             test_ret++;
47440             printf(" %d", n_ctxt);
47441             printf(" %d", n_nargs);
47442             printf("\n");
47443         }
47444     }
47445     }
47446     function_tests++;
47447 #endif
47448
47449     return(test_ret);
47450 }
47451
47452
47453 static int
47454 test_xmlXPathFunctionLookup(void) {
47455     int test_ret = 0;
47456
47457
47458     /* missing type support */
47459     return(test_ret);
47460 }
47461
47462
47463 static int
47464 test_xmlXPathFunctionLookupNS(void) {
47465     int test_ret = 0;
47466
47467
47468     /* missing type support */
47469     return(test_ret);
47470 }
47471
47472
47473 static int
47474 test_xmlXPathHasSameNodes(void) {
47475     int test_ret = 0;
47476
47477 #if defined(LIBXML_XPATH_ENABLED)
47478     int mem_base;
47479     int ret_val;
47480     xmlNodeSetPtr nodes1; /* a node-set */
47481     int n_nodes1;
47482     xmlNodeSetPtr nodes2; /* a node-set */
47483     int n_nodes2;
47484
47485     for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
47486     for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
47487         mem_base = xmlMemBlocks();
47488         nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
47489         nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
47490
47491         ret_val = xmlXPathHasSameNodes(nodes1, nodes2);
47492         desret_int(ret_val);
47493         call_tests++;
47494         des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
47495         des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
47496         xmlResetLastError();
47497         if (mem_base != xmlMemBlocks()) {
47498             printf("Leak of %d blocks found in xmlXPathHasSameNodes",
47499                    xmlMemBlocks() - mem_base);
47500             test_ret++;
47501             printf(" %d", n_nodes1);
47502             printf(" %d", n_nodes2);
47503             printf("\n");
47504         }
47505     }
47506     }
47507     function_tests++;
47508 #endif
47509
47510     return(test_ret);
47511 }
47512
47513
47514 static int
47515 test_xmlXPathIdFunction(void) {
47516     int test_ret = 0;
47517
47518 #if defined(LIBXML_XPATH_ENABLED)
47519     int mem_base;
47520     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47521     int n_ctxt;
47522     int nargs; /* the number of arguments */
47523     int n_nargs;
47524
47525     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47526     for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
47527         mem_base = xmlMemBlocks();
47528         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47529         nargs = gen_int(n_nargs, 1);
47530
47531         xmlXPathIdFunction(ctxt, nargs);
47532         call_tests++;
47533         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47534         des_int(n_nargs, nargs, 1);
47535         xmlResetLastError();
47536         if (mem_base != xmlMemBlocks()) {
47537             printf("Leak of %d blocks found in xmlXPathIdFunction",
47538                    xmlMemBlocks() - mem_base);
47539             test_ret++;
47540             printf(" %d", n_ctxt);
47541             printf(" %d", n_nargs);
47542             printf("\n");
47543         }
47544     }
47545     }
47546     function_tests++;
47547 #endif
47548
47549     return(test_ret);
47550 }
47551
47552
47553 static int
47554 test_xmlXPathIntersection(void) {
47555     int test_ret = 0;
47556
47557 #if defined(LIBXML_XPATH_ENABLED)
47558     int mem_base;
47559     xmlNodeSetPtr ret_val;
47560     xmlNodeSetPtr nodes1; /* a node-set */
47561     int n_nodes1;
47562     xmlNodeSetPtr nodes2; /* a node-set */
47563     int n_nodes2;
47564
47565     for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
47566     for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
47567         mem_base = xmlMemBlocks();
47568         nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
47569         nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
47570
47571         ret_val = xmlXPathIntersection(nodes1, nodes2);
47572         desret_xmlNodeSetPtr(ret_val);
47573         call_tests++;
47574         des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
47575         des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
47576         xmlResetLastError();
47577         if (mem_base != xmlMemBlocks()) {
47578             printf("Leak of %d blocks found in xmlXPathIntersection",
47579                    xmlMemBlocks() - mem_base);
47580             test_ret++;
47581             printf(" %d", n_nodes1);
47582             printf(" %d", n_nodes2);
47583             printf("\n");
47584         }
47585     }
47586     }
47587     function_tests++;
47588 #endif
47589
47590     return(test_ret);
47591 }
47592
47593
47594 static int
47595 test_xmlXPathIsNodeType(void) {
47596     int test_ret = 0;
47597
47598 #if defined(LIBXML_XPATH_ENABLED)
47599     int mem_base;
47600     int ret_val;
47601     xmlChar * name; /* a name string */
47602     int n_name;
47603
47604     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
47605         mem_base = xmlMemBlocks();
47606         name = gen_const_xmlChar_ptr(n_name, 0);
47607
47608         ret_val = xmlXPathIsNodeType((const xmlChar *)name);
47609         desret_int(ret_val);
47610         call_tests++;
47611         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 0);
47612         xmlResetLastError();
47613         if (mem_base != xmlMemBlocks()) {
47614             printf("Leak of %d blocks found in xmlXPathIsNodeType",
47615                    xmlMemBlocks() - mem_base);
47616             test_ret++;
47617             printf(" %d", n_name);
47618             printf("\n");
47619         }
47620     }
47621     function_tests++;
47622 #endif
47623
47624     return(test_ret);
47625 }
47626
47627
47628 static int
47629 test_xmlXPathLangFunction(void) {
47630     int test_ret = 0;
47631
47632 #if defined(LIBXML_XPATH_ENABLED)
47633     int mem_base;
47634     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47635     int n_ctxt;
47636     int nargs; /* the number of arguments */
47637     int n_nargs;
47638
47639     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47640     for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
47641         mem_base = xmlMemBlocks();
47642         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47643         nargs = gen_int(n_nargs, 1);
47644
47645         xmlXPathLangFunction(ctxt, nargs);
47646         call_tests++;
47647         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47648         des_int(n_nargs, nargs, 1);
47649         xmlResetLastError();
47650         if (mem_base != xmlMemBlocks()) {
47651             printf("Leak of %d blocks found in xmlXPathLangFunction",
47652                    xmlMemBlocks() - mem_base);
47653             test_ret++;
47654             printf(" %d", n_ctxt);
47655             printf(" %d", n_nargs);
47656             printf("\n");
47657         }
47658     }
47659     }
47660     function_tests++;
47661 #endif
47662
47663     return(test_ret);
47664 }
47665
47666
47667 static int
47668 test_xmlXPathLastFunction(void) {
47669     int test_ret = 0;
47670
47671 #if defined(LIBXML_XPATH_ENABLED)
47672     int mem_base;
47673     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47674     int n_ctxt;
47675     int nargs; /* the number of arguments */
47676     int n_nargs;
47677
47678     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47679     for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
47680         mem_base = xmlMemBlocks();
47681         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47682         nargs = gen_int(n_nargs, 1);
47683
47684         xmlXPathLastFunction(ctxt, nargs);
47685         call_tests++;
47686         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47687         des_int(n_nargs, nargs, 1);
47688         xmlResetLastError();
47689         if (mem_base != xmlMemBlocks()) {
47690             printf("Leak of %d blocks found in xmlXPathLastFunction",
47691                    xmlMemBlocks() - mem_base);
47692             test_ret++;
47693             printf(" %d", n_ctxt);
47694             printf(" %d", n_nargs);
47695             printf("\n");
47696         }
47697     }
47698     }
47699     function_tests++;
47700 #endif
47701
47702     return(test_ret);
47703 }
47704
47705
47706 static int
47707 test_xmlXPathLeading(void) {
47708     int test_ret = 0;
47709
47710 #if defined(LIBXML_XPATH_ENABLED)
47711     int mem_base;
47712     xmlNodeSetPtr ret_val;
47713     xmlNodeSetPtr nodes1; /* a node-set */
47714     int n_nodes1;
47715     xmlNodeSetPtr nodes2; /* a node-set */
47716     int n_nodes2;
47717
47718     for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
47719     for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
47720         mem_base = xmlMemBlocks();
47721         nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
47722         nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
47723
47724         ret_val = xmlXPathLeading(nodes1, nodes2);
47725         desret_xmlNodeSetPtr(ret_val);
47726         call_tests++;
47727         des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
47728         des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
47729         xmlResetLastError();
47730         if (mem_base != xmlMemBlocks()) {
47731             printf("Leak of %d blocks found in xmlXPathLeading",
47732                    xmlMemBlocks() - mem_base);
47733             test_ret++;
47734             printf(" %d", n_nodes1);
47735             printf(" %d", n_nodes2);
47736             printf("\n");
47737         }
47738     }
47739     }
47740     function_tests++;
47741 #endif
47742
47743     return(test_ret);
47744 }
47745
47746
47747 static int
47748 test_xmlXPathLeadingSorted(void) {
47749     int test_ret = 0;
47750
47751 #if defined(LIBXML_XPATH_ENABLED)
47752     int mem_base;
47753     xmlNodeSetPtr ret_val;
47754     xmlNodeSetPtr nodes1; /* a node-set, sorted by document order */
47755     int n_nodes1;
47756     xmlNodeSetPtr nodes2; /* a node-set, sorted by document order */
47757     int n_nodes2;
47758
47759     for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
47760     for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
47761         mem_base = xmlMemBlocks();
47762         nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
47763         nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
47764
47765         ret_val = xmlXPathLeadingSorted(nodes1, nodes2);
47766         desret_xmlNodeSetPtr(ret_val);
47767         call_tests++;
47768         des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
47769         des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
47770         xmlResetLastError();
47771         if (mem_base != xmlMemBlocks()) {
47772             printf("Leak of %d blocks found in xmlXPathLeadingSorted",
47773                    xmlMemBlocks() - mem_base);
47774             test_ret++;
47775             printf(" %d", n_nodes1);
47776             printf(" %d", n_nodes2);
47777             printf("\n");
47778         }
47779     }
47780     }
47781     function_tests++;
47782 #endif
47783
47784     return(test_ret);
47785 }
47786
47787
47788 static int
47789 test_xmlXPathLocalNameFunction(void) {
47790     int test_ret = 0;
47791
47792 #if defined(LIBXML_XPATH_ENABLED)
47793     int mem_base;
47794     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47795     int n_ctxt;
47796     int nargs; /* the number of arguments */
47797     int n_nargs;
47798
47799     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47800     for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
47801         mem_base = xmlMemBlocks();
47802         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47803         nargs = gen_int(n_nargs, 1);
47804
47805         xmlXPathLocalNameFunction(ctxt, nargs);
47806         call_tests++;
47807         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47808         des_int(n_nargs, nargs, 1);
47809         xmlResetLastError();
47810         if (mem_base != xmlMemBlocks()) {
47811             printf("Leak of %d blocks found in xmlXPathLocalNameFunction",
47812                    xmlMemBlocks() - mem_base);
47813             test_ret++;
47814             printf(" %d", n_ctxt);
47815             printf(" %d", n_nargs);
47816             printf("\n");
47817         }
47818     }
47819     }
47820     function_tests++;
47821 #endif
47822
47823     return(test_ret);
47824 }
47825
47826
47827 static int
47828 test_xmlXPathModValues(void) {
47829     int test_ret = 0;
47830
47831 #if defined(LIBXML_XPATH_ENABLED)
47832     int mem_base;
47833     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47834     int n_ctxt;
47835
47836     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47837         mem_base = xmlMemBlocks();
47838         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47839
47840         xmlXPathModValues(ctxt);
47841         call_tests++;
47842         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47843         xmlResetLastError();
47844         if (mem_base != xmlMemBlocks()) {
47845             printf("Leak of %d blocks found in xmlXPathModValues",
47846                    xmlMemBlocks() - mem_base);
47847             test_ret++;
47848             printf(" %d", n_ctxt);
47849             printf("\n");
47850         }
47851     }
47852     function_tests++;
47853 #endif
47854
47855     return(test_ret);
47856 }
47857
47858
47859 static int
47860 test_xmlXPathMultValues(void) {
47861     int test_ret = 0;
47862
47863 #if defined(LIBXML_XPATH_ENABLED)
47864     int mem_base;
47865     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47866     int n_ctxt;
47867
47868     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47869         mem_base = xmlMemBlocks();
47870         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47871
47872         xmlXPathMultValues(ctxt);
47873         call_tests++;
47874         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47875         xmlResetLastError();
47876         if (mem_base != xmlMemBlocks()) {
47877             printf("Leak of %d blocks found in xmlXPathMultValues",
47878                    xmlMemBlocks() - mem_base);
47879             test_ret++;
47880             printf(" %d", n_ctxt);
47881             printf("\n");
47882         }
47883     }
47884     function_tests++;
47885 #endif
47886
47887     return(test_ret);
47888 }
47889
47890
47891 static int
47892 test_xmlXPathNamespaceURIFunction(void) {
47893     int test_ret = 0;
47894
47895 #if defined(LIBXML_XPATH_ENABLED)
47896     int mem_base;
47897     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
47898     int n_ctxt;
47899     int nargs; /* the number of arguments */
47900     int n_nargs;
47901
47902     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
47903     for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
47904         mem_base = xmlMemBlocks();
47905         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
47906         nargs = gen_int(n_nargs, 1);
47907
47908         xmlXPathNamespaceURIFunction(ctxt, nargs);
47909         call_tests++;
47910         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
47911         des_int(n_nargs, nargs, 1);
47912         xmlResetLastError();
47913         if (mem_base != xmlMemBlocks()) {
47914             printf("Leak of %d blocks found in xmlXPathNamespaceURIFunction",
47915                    xmlMemBlocks() - mem_base);
47916             test_ret++;
47917             printf(" %d", n_ctxt);
47918             printf(" %d", n_nargs);
47919             printf("\n");
47920         }
47921     }
47922     }
47923     function_tests++;
47924 #endif
47925
47926     return(test_ret);
47927 }
47928
47929
47930 static int
47931 test_xmlXPathNewBoolean(void) {
47932     int test_ret = 0;
47933
47934 #if defined(LIBXML_XPATH_ENABLED)
47935     int mem_base;
47936     xmlXPathObjectPtr ret_val;
47937     int val; /* the boolean value */
47938     int n_val;
47939
47940     for (n_val = 0;n_val < gen_nb_int;n_val++) {
47941         mem_base = xmlMemBlocks();
47942         val = gen_int(n_val, 0);
47943
47944         ret_val = xmlXPathNewBoolean(val);
47945         desret_xmlXPathObjectPtr(ret_val);
47946         call_tests++;
47947         des_int(n_val, val, 0);
47948         xmlResetLastError();
47949         if (mem_base != xmlMemBlocks()) {
47950             printf("Leak of %d blocks found in xmlXPathNewBoolean",
47951                    xmlMemBlocks() - mem_base);
47952             test_ret++;
47953             printf(" %d", n_val);
47954             printf("\n");
47955         }
47956     }
47957     function_tests++;
47958 #endif
47959
47960     return(test_ret);
47961 }
47962
47963
47964 static int
47965 test_xmlXPathNewCString(void) {
47966     int test_ret = 0;
47967
47968 #if defined(LIBXML_XPATH_ENABLED)
47969     int mem_base;
47970     xmlXPathObjectPtr ret_val;
47971     char * val; /* the char * value */
47972     int n_val;
47973
47974     for (n_val = 0;n_val < gen_nb_const_char_ptr;n_val++) {
47975         mem_base = xmlMemBlocks();
47976         val = gen_const_char_ptr(n_val, 0);
47977
47978         ret_val = xmlXPathNewCString((const char *)val);
47979         desret_xmlXPathObjectPtr(ret_val);
47980         call_tests++;
47981         des_const_char_ptr(n_val, (const char *)val, 0);
47982         xmlResetLastError();
47983         if (mem_base != xmlMemBlocks()) {
47984             printf("Leak of %d blocks found in xmlXPathNewCString",
47985                    xmlMemBlocks() - mem_base);
47986             test_ret++;
47987             printf(" %d", n_val);
47988             printf("\n");
47989         }
47990     }
47991     function_tests++;
47992 #endif
47993
47994     return(test_ret);
47995 }
47996
47997
47998 static int
47999 test_xmlXPathNewFloat(void) {
48000     int test_ret = 0;
48001
48002 #if defined(LIBXML_XPATH_ENABLED)
48003     int mem_base;
48004     xmlXPathObjectPtr ret_val;
48005     double val; /* the double value */
48006     int n_val;
48007
48008     for (n_val = 0;n_val < gen_nb_double;n_val++) {
48009         mem_base = xmlMemBlocks();
48010         val = gen_double(n_val, 0);
48011
48012         ret_val = xmlXPathNewFloat(val);
48013         desret_xmlXPathObjectPtr(ret_val);
48014         call_tests++;
48015         des_double(n_val, val, 0);
48016         xmlResetLastError();
48017         if (mem_base != xmlMemBlocks()) {
48018             printf("Leak of %d blocks found in xmlXPathNewFloat",
48019                    xmlMemBlocks() - mem_base);
48020             test_ret++;
48021             printf(" %d", n_val);
48022             printf("\n");
48023         }
48024     }
48025     function_tests++;
48026 #endif
48027
48028     return(test_ret);
48029 }
48030
48031
48032 static int
48033 test_xmlXPathNewNodeSet(void) {
48034     int test_ret = 0;
48035
48036 #if defined(LIBXML_XPATH_ENABLED)
48037     int mem_base;
48038     xmlXPathObjectPtr ret_val;
48039     xmlNodePtr val; /* the NodePtr value */
48040     int n_val;
48041
48042     for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
48043         mem_base = xmlMemBlocks();
48044         val = gen_xmlNodePtr(n_val, 0);
48045
48046         ret_val = xmlXPathNewNodeSet(val);
48047         desret_xmlXPathObjectPtr(ret_val);
48048         call_tests++;
48049         des_xmlNodePtr(n_val, val, 0);
48050         xmlResetLastError();
48051         if (mem_base != xmlMemBlocks()) {
48052             printf("Leak of %d blocks found in xmlXPathNewNodeSet",
48053                    xmlMemBlocks() - mem_base);
48054             test_ret++;
48055             printf(" %d", n_val);
48056             printf("\n");
48057         }
48058     }
48059     function_tests++;
48060 #endif
48061
48062     return(test_ret);
48063 }
48064
48065
48066 static int
48067 test_xmlXPathNewNodeSetList(void) {
48068     int test_ret = 0;
48069
48070 #if defined(LIBXML_XPATH_ENABLED)
48071     int mem_base;
48072     xmlXPathObjectPtr ret_val;
48073     xmlNodeSetPtr val; /* an existing NodeSet */
48074     int n_val;
48075
48076     for (n_val = 0;n_val < gen_nb_xmlNodeSetPtr;n_val++) {
48077         mem_base = xmlMemBlocks();
48078         val = gen_xmlNodeSetPtr(n_val, 0);
48079
48080         ret_val = xmlXPathNewNodeSetList(val);
48081         desret_xmlXPathObjectPtr(ret_val);
48082         call_tests++;
48083         des_xmlNodeSetPtr(n_val, val, 0);
48084         xmlResetLastError();
48085         if (mem_base != xmlMemBlocks()) {
48086             printf("Leak of %d blocks found in xmlXPathNewNodeSetList",
48087                    xmlMemBlocks() - mem_base);
48088             test_ret++;
48089             printf(" %d", n_val);
48090             printf("\n");
48091         }
48092     }
48093     function_tests++;
48094 #endif
48095
48096     return(test_ret);
48097 }
48098
48099
48100 static int
48101 test_xmlXPathNewParserContext(void) {
48102     int test_ret = 0;
48103
48104
48105     /* missing type support */
48106     return(test_ret);
48107 }
48108
48109
48110 static int
48111 test_xmlXPathNewString(void) {
48112     int test_ret = 0;
48113
48114 #if defined(LIBXML_XPATH_ENABLED)
48115     int mem_base;
48116     xmlXPathObjectPtr ret_val;
48117     xmlChar * val; /* the xmlChar * value */
48118     int n_val;
48119
48120     for (n_val = 0;n_val < gen_nb_const_xmlChar_ptr;n_val++) {
48121         mem_base = xmlMemBlocks();
48122         val = gen_const_xmlChar_ptr(n_val, 0);
48123
48124         ret_val = xmlXPathNewString((const xmlChar *)val);
48125         desret_xmlXPathObjectPtr(ret_val);
48126         call_tests++;
48127         des_const_xmlChar_ptr(n_val, (const xmlChar *)val, 0);
48128         xmlResetLastError();
48129         if (mem_base != xmlMemBlocks()) {
48130             printf("Leak of %d blocks found in xmlXPathNewString",
48131                    xmlMemBlocks() - mem_base);
48132             test_ret++;
48133             printf(" %d", n_val);
48134             printf("\n");
48135         }
48136     }
48137     function_tests++;
48138 #endif
48139
48140     return(test_ret);
48141 }
48142
48143
48144 static int
48145 test_xmlXPathNextAncestor(void) {
48146     int test_ret = 0;
48147
48148 #if defined(LIBXML_XPATH_ENABLED)
48149     int mem_base;
48150     xmlNodePtr ret_val;
48151     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48152     int n_ctxt;
48153     xmlNodePtr cur; /* the current node in the traversal */
48154     int n_cur;
48155
48156     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48157     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48158         mem_base = xmlMemBlocks();
48159         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48160         cur = gen_xmlNodePtr(n_cur, 1);
48161
48162         ret_val = xmlXPathNextAncestor(ctxt, cur);
48163         desret_xmlNodePtr(ret_val);
48164         call_tests++;
48165         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48166         des_xmlNodePtr(n_cur, cur, 1);
48167         xmlResetLastError();
48168         if (mem_base != xmlMemBlocks()) {
48169             printf("Leak of %d blocks found in xmlXPathNextAncestor",
48170                    xmlMemBlocks() - mem_base);
48171             test_ret++;
48172             printf(" %d", n_ctxt);
48173             printf(" %d", n_cur);
48174             printf("\n");
48175         }
48176     }
48177     }
48178     function_tests++;
48179 #endif
48180
48181     return(test_ret);
48182 }
48183
48184
48185 static int
48186 test_xmlXPathNextAncestorOrSelf(void) {
48187     int test_ret = 0;
48188
48189 #if defined(LIBXML_XPATH_ENABLED)
48190     int mem_base;
48191     xmlNodePtr ret_val;
48192     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48193     int n_ctxt;
48194     xmlNodePtr cur; /* the current node in the traversal */
48195     int n_cur;
48196
48197     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48198     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48199         mem_base = xmlMemBlocks();
48200         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48201         cur = gen_xmlNodePtr(n_cur, 1);
48202
48203         ret_val = xmlXPathNextAncestorOrSelf(ctxt, cur);
48204         desret_xmlNodePtr(ret_val);
48205         call_tests++;
48206         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48207         des_xmlNodePtr(n_cur, cur, 1);
48208         xmlResetLastError();
48209         if (mem_base != xmlMemBlocks()) {
48210             printf("Leak of %d blocks found in xmlXPathNextAncestorOrSelf",
48211                    xmlMemBlocks() - mem_base);
48212             test_ret++;
48213             printf(" %d", n_ctxt);
48214             printf(" %d", n_cur);
48215             printf("\n");
48216         }
48217     }
48218     }
48219     function_tests++;
48220 #endif
48221
48222     return(test_ret);
48223 }
48224
48225
48226 static int
48227 test_xmlXPathNextAttribute(void) {
48228     int test_ret = 0;
48229
48230 #if defined(LIBXML_XPATH_ENABLED)
48231     int mem_base;
48232     xmlNodePtr ret_val;
48233     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48234     int n_ctxt;
48235     xmlNodePtr cur; /* the current attribute in the traversal */
48236     int n_cur;
48237
48238     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48239     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48240         mem_base = xmlMemBlocks();
48241         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48242         cur = gen_xmlNodePtr(n_cur, 1);
48243
48244         ret_val = xmlXPathNextAttribute(ctxt, cur);
48245         desret_xmlNodePtr(ret_val);
48246         call_tests++;
48247         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48248         des_xmlNodePtr(n_cur, cur, 1);
48249         xmlResetLastError();
48250         if (mem_base != xmlMemBlocks()) {
48251             printf("Leak of %d blocks found in xmlXPathNextAttribute",
48252                    xmlMemBlocks() - mem_base);
48253             test_ret++;
48254             printf(" %d", n_ctxt);
48255             printf(" %d", n_cur);
48256             printf("\n");
48257         }
48258     }
48259     }
48260     function_tests++;
48261 #endif
48262
48263     return(test_ret);
48264 }
48265
48266
48267 static int
48268 test_xmlXPathNextChild(void) {
48269     int test_ret = 0;
48270
48271 #if defined(LIBXML_XPATH_ENABLED)
48272     int mem_base;
48273     xmlNodePtr ret_val;
48274     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48275     int n_ctxt;
48276     xmlNodePtr cur; /* the current node in the traversal */
48277     int n_cur;
48278
48279     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48280     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48281         mem_base = xmlMemBlocks();
48282         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48283         cur = gen_xmlNodePtr(n_cur, 1);
48284
48285         ret_val = xmlXPathNextChild(ctxt, cur);
48286         desret_xmlNodePtr(ret_val);
48287         call_tests++;
48288         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48289         des_xmlNodePtr(n_cur, cur, 1);
48290         xmlResetLastError();
48291         if (mem_base != xmlMemBlocks()) {
48292             printf("Leak of %d blocks found in xmlXPathNextChild",
48293                    xmlMemBlocks() - mem_base);
48294             test_ret++;
48295             printf(" %d", n_ctxt);
48296             printf(" %d", n_cur);
48297             printf("\n");
48298         }
48299     }
48300     }
48301     function_tests++;
48302 #endif
48303
48304     return(test_ret);
48305 }
48306
48307
48308 static int
48309 test_xmlXPathNextDescendant(void) {
48310     int test_ret = 0;
48311
48312 #if defined(LIBXML_XPATH_ENABLED)
48313     int mem_base;
48314     xmlNodePtr ret_val;
48315     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48316     int n_ctxt;
48317     xmlNodePtr cur; /* the current node in the traversal */
48318     int n_cur;
48319
48320     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48321     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48322         mem_base = xmlMemBlocks();
48323         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48324         cur = gen_xmlNodePtr(n_cur, 1);
48325
48326         ret_val = xmlXPathNextDescendant(ctxt, cur);
48327         desret_xmlNodePtr(ret_val);
48328         call_tests++;
48329         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48330         des_xmlNodePtr(n_cur, cur, 1);
48331         xmlResetLastError();
48332         if (mem_base != xmlMemBlocks()) {
48333             printf("Leak of %d blocks found in xmlXPathNextDescendant",
48334                    xmlMemBlocks() - mem_base);
48335             test_ret++;
48336             printf(" %d", n_ctxt);
48337             printf(" %d", n_cur);
48338             printf("\n");
48339         }
48340     }
48341     }
48342     function_tests++;
48343 #endif
48344
48345     return(test_ret);
48346 }
48347
48348
48349 static int
48350 test_xmlXPathNextDescendantOrSelf(void) {
48351     int test_ret = 0;
48352
48353 #if defined(LIBXML_XPATH_ENABLED)
48354     int mem_base;
48355     xmlNodePtr ret_val;
48356     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48357     int n_ctxt;
48358     xmlNodePtr cur; /* the current node in the traversal */
48359     int n_cur;
48360
48361     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48362     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48363         mem_base = xmlMemBlocks();
48364         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48365         cur = gen_xmlNodePtr(n_cur, 1);
48366
48367         ret_val = xmlXPathNextDescendantOrSelf(ctxt, cur);
48368         desret_xmlNodePtr(ret_val);
48369         call_tests++;
48370         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48371         des_xmlNodePtr(n_cur, cur, 1);
48372         xmlResetLastError();
48373         if (mem_base != xmlMemBlocks()) {
48374             printf("Leak of %d blocks found in xmlXPathNextDescendantOrSelf",
48375                    xmlMemBlocks() - mem_base);
48376             test_ret++;
48377             printf(" %d", n_ctxt);
48378             printf(" %d", n_cur);
48379             printf("\n");
48380         }
48381     }
48382     }
48383     function_tests++;
48384 #endif
48385
48386     return(test_ret);
48387 }
48388
48389
48390 static int
48391 test_xmlXPathNextFollowing(void) {
48392     int test_ret = 0;
48393
48394 #if defined(LIBXML_XPATH_ENABLED)
48395     int mem_base;
48396     xmlNodePtr ret_val;
48397     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48398     int n_ctxt;
48399     xmlNodePtr cur; /* the current node in the traversal */
48400     int n_cur;
48401
48402     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48403     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48404         mem_base = xmlMemBlocks();
48405         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48406         cur = gen_xmlNodePtr(n_cur, 1);
48407
48408         ret_val = xmlXPathNextFollowing(ctxt, cur);
48409         desret_xmlNodePtr(ret_val);
48410         call_tests++;
48411         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48412         des_xmlNodePtr(n_cur, cur, 1);
48413         xmlResetLastError();
48414         if (mem_base != xmlMemBlocks()) {
48415             printf("Leak of %d blocks found in xmlXPathNextFollowing",
48416                    xmlMemBlocks() - mem_base);
48417             test_ret++;
48418             printf(" %d", n_ctxt);
48419             printf(" %d", n_cur);
48420             printf("\n");
48421         }
48422     }
48423     }
48424     function_tests++;
48425 #endif
48426
48427     return(test_ret);
48428 }
48429
48430
48431 static int
48432 test_xmlXPathNextFollowingSibling(void) {
48433     int test_ret = 0;
48434
48435 #if defined(LIBXML_XPATH_ENABLED)
48436     int mem_base;
48437     xmlNodePtr ret_val;
48438     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48439     int n_ctxt;
48440     xmlNodePtr cur; /* the current node in the traversal */
48441     int n_cur;
48442
48443     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48444     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48445         mem_base = xmlMemBlocks();
48446         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48447         cur = gen_xmlNodePtr(n_cur, 1);
48448
48449         ret_val = xmlXPathNextFollowingSibling(ctxt, cur);
48450         desret_xmlNodePtr(ret_val);
48451         call_tests++;
48452         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48453         des_xmlNodePtr(n_cur, cur, 1);
48454         xmlResetLastError();
48455         if (mem_base != xmlMemBlocks()) {
48456             printf("Leak of %d blocks found in xmlXPathNextFollowingSibling",
48457                    xmlMemBlocks() - mem_base);
48458             test_ret++;
48459             printf(" %d", n_ctxt);
48460             printf(" %d", n_cur);
48461             printf("\n");
48462         }
48463     }
48464     }
48465     function_tests++;
48466 #endif
48467
48468     return(test_ret);
48469 }
48470
48471
48472 static int
48473 test_xmlXPathNextNamespace(void) {
48474     int test_ret = 0;
48475
48476 #if defined(LIBXML_XPATH_ENABLED)
48477     int mem_base;
48478     xmlNodePtr ret_val;
48479     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48480     int n_ctxt;
48481     xmlNodePtr cur; /* the current attribute in the traversal */
48482     int n_cur;
48483
48484     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48485     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48486         mem_base = xmlMemBlocks();
48487         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48488         cur = gen_xmlNodePtr(n_cur, 1);
48489
48490         ret_val = xmlXPathNextNamespace(ctxt, cur);
48491         desret_xmlNodePtr(ret_val);
48492         call_tests++;
48493         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48494         des_xmlNodePtr(n_cur, cur, 1);
48495         xmlResetLastError();
48496         if (mem_base != xmlMemBlocks()) {
48497             printf("Leak of %d blocks found in xmlXPathNextNamespace",
48498                    xmlMemBlocks() - mem_base);
48499             test_ret++;
48500             printf(" %d", n_ctxt);
48501             printf(" %d", n_cur);
48502             printf("\n");
48503         }
48504     }
48505     }
48506     function_tests++;
48507 #endif
48508
48509     return(test_ret);
48510 }
48511
48512
48513 static int
48514 test_xmlXPathNextParent(void) {
48515     int test_ret = 0;
48516
48517 #if defined(LIBXML_XPATH_ENABLED)
48518     int mem_base;
48519     xmlNodePtr ret_val;
48520     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48521     int n_ctxt;
48522     xmlNodePtr cur; /* the current node in the traversal */
48523     int n_cur;
48524
48525     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48526     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48527         mem_base = xmlMemBlocks();
48528         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48529         cur = gen_xmlNodePtr(n_cur, 1);
48530
48531         ret_val = xmlXPathNextParent(ctxt, cur);
48532         desret_xmlNodePtr(ret_val);
48533         call_tests++;
48534         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48535         des_xmlNodePtr(n_cur, cur, 1);
48536         xmlResetLastError();
48537         if (mem_base != xmlMemBlocks()) {
48538             printf("Leak of %d blocks found in xmlXPathNextParent",
48539                    xmlMemBlocks() - mem_base);
48540             test_ret++;
48541             printf(" %d", n_ctxt);
48542             printf(" %d", n_cur);
48543             printf("\n");
48544         }
48545     }
48546     }
48547     function_tests++;
48548 #endif
48549
48550     return(test_ret);
48551 }
48552
48553
48554 static int
48555 test_xmlXPathNextPreceding(void) {
48556     int test_ret = 0;
48557
48558 #if defined(LIBXML_XPATH_ENABLED)
48559     int mem_base;
48560     xmlNodePtr ret_val;
48561     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48562     int n_ctxt;
48563     xmlNodePtr cur; /* the current node in the traversal */
48564     int n_cur;
48565
48566     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48567     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48568         mem_base = xmlMemBlocks();
48569         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48570         cur = gen_xmlNodePtr(n_cur, 1);
48571
48572         ret_val = xmlXPathNextPreceding(ctxt, cur);
48573         desret_xmlNodePtr(ret_val);
48574         call_tests++;
48575         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48576         des_xmlNodePtr(n_cur, cur, 1);
48577         xmlResetLastError();
48578         if (mem_base != xmlMemBlocks()) {
48579             printf("Leak of %d blocks found in xmlXPathNextPreceding",
48580                    xmlMemBlocks() - mem_base);
48581             test_ret++;
48582             printf(" %d", n_ctxt);
48583             printf(" %d", n_cur);
48584             printf("\n");
48585         }
48586     }
48587     }
48588     function_tests++;
48589 #endif
48590
48591     return(test_ret);
48592 }
48593
48594
48595 static int
48596 test_xmlXPathNextPrecedingSibling(void) {
48597     int test_ret = 0;
48598
48599 #if defined(LIBXML_XPATH_ENABLED)
48600     int mem_base;
48601     xmlNodePtr ret_val;
48602     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48603     int n_ctxt;
48604     xmlNodePtr cur; /* the current node in the traversal */
48605     int n_cur;
48606
48607     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48608     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48609         mem_base = xmlMemBlocks();
48610         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48611         cur = gen_xmlNodePtr(n_cur, 1);
48612
48613         ret_val = xmlXPathNextPrecedingSibling(ctxt, cur);
48614         desret_xmlNodePtr(ret_val);
48615         call_tests++;
48616         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48617         des_xmlNodePtr(n_cur, cur, 1);
48618         xmlResetLastError();
48619         if (mem_base != xmlMemBlocks()) {
48620             printf("Leak of %d blocks found in xmlXPathNextPrecedingSibling",
48621                    xmlMemBlocks() - mem_base);
48622             test_ret++;
48623             printf(" %d", n_ctxt);
48624             printf(" %d", n_cur);
48625             printf("\n");
48626         }
48627     }
48628     }
48629     function_tests++;
48630 #endif
48631
48632     return(test_ret);
48633 }
48634
48635
48636 static int
48637 test_xmlXPathNextSelf(void) {
48638     int test_ret = 0;
48639
48640 #if defined(LIBXML_XPATH_ENABLED)
48641     int mem_base;
48642     xmlNodePtr ret_val;
48643     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
48644     int n_ctxt;
48645     xmlNodePtr cur; /* the current node in the traversal */
48646     int n_cur;
48647
48648     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
48649     for (n_cur = 0;n_cur < gen_nb_xmlNodePtr;n_cur++) {
48650         mem_base = xmlMemBlocks();
48651         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
48652         cur = gen_xmlNodePtr(n_cur, 1);
48653
48654         ret_val = xmlXPathNextSelf(ctxt, cur);
48655         desret_xmlNodePtr(ret_val);
48656         call_tests++;
48657         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
48658         des_xmlNodePtr(n_cur, cur, 1);
48659         xmlResetLastError();
48660         if (mem_base != xmlMemBlocks()) {
48661             printf("Leak of %d blocks found in xmlXPathNextSelf",
48662                    xmlMemBlocks() - mem_base);
48663             test_ret++;
48664             printf(" %d", n_ctxt);
48665             printf(" %d", n_cur);
48666             printf("\n");
48667         }
48668     }
48669     }
48670     function_tests++;
48671 #endif
48672
48673     return(test_ret);
48674 }
48675
48676
48677 static int
48678 test_xmlXPathNodeLeading(void) {
48679     int test_ret = 0;
48680
48681 #if defined(LIBXML_XPATH_ENABLED)
48682     int mem_base;
48683     xmlNodeSetPtr ret_val;
48684     xmlNodeSetPtr nodes; /* a node-set */
48685     int n_nodes;
48686     xmlNodePtr node; /* a node */
48687     int n_node;
48688
48689     for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
48690     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
48691         mem_base = xmlMemBlocks();
48692         nodes = gen_xmlNodeSetPtr(n_nodes, 0);
48693         node = gen_xmlNodePtr(n_node, 1);
48694
48695         ret_val = xmlXPathNodeLeading(nodes, node);
48696         desret_xmlNodeSetPtr(ret_val);
48697         call_tests++;
48698         des_xmlNodeSetPtr(n_nodes, nodes, 0);
48699         des_xmlNodePtr(n_node, node, 1);
48700         xmlResetLastError();
48701         if (mem_base != xmlMemBlocks()) {
48702             printf("Leak of %d blocks found in xmlXPathNodeLeading",
48703                    xmlMemBlocks() - mem_base);
48704             test_ret++;
48705             printf(" %d", n_nodes);
48706             printf(" %d", n_node);
48707             printf("\n");
48708         }
48709     }
48710     }
48711     function_tests++;
48712 #endif
48713
48714     return(test_ret);
48715 }
48716
48717
48718 static int
48719 test_xmlXPathNodeLeadingSorted(void) {
48720     int test_ret = 0;
48721
48722 #if defined(LIBXML_XPATH_ENABLED)
48723     int mem_base;
48724     xmlNodeSetPtr ret_val;
48725     xmlNodeSetPtr nodes; /* a node-set, sorted by document order */
48726     int n_nodes;
48727     xmlNodePtr node; /* a node */
48728     int n_node;
48729
48730     for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
48731     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
48732         mem_base = xmlMemBlocks();
48733         nodes = gen_xmlNodeSetPtr(n_nodes, 0);
48734         node = gen_xmlNodePtr(n_node, 1);
48735
48736         ret_val = xmlXPathNodeLeadingSorted(nodes, node);
48737         desret_xmlNodeSetPtr(ret_val);
48738         call_tests++;
48739         des_xmlNodeSetPtr(n_nodes, nodes, 0);
48740         des_xmlNodePtr(n_node, node, 1);
48741         xmlResetLastError();
48742         if (mem_base != xmlMemBlocks()) {
48743             printf("Leak of %d blocks found in xmlXPathNodeLeadingSorted",
48744                    xmlMemBlocks() - mem_base);
48745             test_ret++;
48746             printf(" %d", n_nodes);
48747             printf(" %d", n_node);
48748             printf("\n");
48749         }
48750     }
48751     }
48752     function_tests++;
48753 #endif
48754
48755     return(test_ret);
48756 }
48757
48758
48759 static int
48760 test_xmlXPathNodeSetAdd(void) {
48761     int test_ret = 0;
48762
48763 #if defined(LIBXML_XPATH_ENABLED)
48764     int mem_base;
48765     xmlNodeSetPtr cur; /* the initial node set */
48766     int n_cur;
48767     xmlNodePtr val; /* a new xmlNodePtr */
48768     int n_val;
48769
48770     for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
48771     for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
48772         mem_base = xmlMemBlocks();
48773         cur = gen_xmlNodeSetPtr(n_cur, 0);
48774         val = gen_xmlNodePtr(n_val, 1);
48775
48776         xmlXPathNodeSetAdd(cur, val);
48777         call_tests++;
48778         des_xmlNodeSetPtr(n_cur, cur, 0);
48779         des_xmlNodePtr(n_val, val, 1);
48780         xmlResetLastError();
48781         if (mem_base != xmlMemBlocks()) {
48782             printf("Leak of %d blocks found in xmlXPathNodeSetAdd",
48783                    xmlMemBlocks() - mem_base);
48784             test_ret++;
48785             printf(" %d", n_cur);
48786             printf(" %d", n_val);
48787             printf("\n");
48788         }
48789     }
48790     }
48791     function_tests++;
48792 #endif
48793
48794     return(test_ret);
48795 }
48796
48797
48798 static int
48799 test_xmlXPathNodeSetAddNs(void) {
48800     int test_ret = 0;
48801
48802 #if defined(LIBXML_XPATH_ENABLED)
48803     int mem_base;
48804     xmlNodeSetPtr cur; /* the initial node set */
48805     int n_cur;
48806     xmlNodePtr node; /* the hosting node */
48807     int n_node;
48808     xmlNsPtr ns; /* a the namespace node */
48809     int n_ns;
48810
48811     for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
48812     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
48813     for (n_ns = 0;n_ns < gen_nb_xmlNsPtr;n_ns++) {
48814         mem_base = xmlMemBlocks();
48815         cur = gen_xmlNodeSetPtr(n_cur, 0);
48816         node = gen_xmlNodePtr(n_node, 1);
48817         ns = gen_xmlNsPtr(n_ns, 2);
48818
48819         xmlXPathNodeSetAddNs(cur, node, ns);
48820         call_tests++;
48821         des_xmlNodeSetPtr(n_cur, cur, 0);
48822         des_xmlNodePtr(n_node, node, 1);
48823         des_xmlNsPtr(n_ns, ns, 2);
48824         xmlResetLastError();
48825         if (mem_base != xmlMemBlocks()) {
48826             printf("Leak of %d blocks found in xmlXPathNodeSetAddNs",
48827                    xmlMemBlocks() - mem_base);
48828             test_ret++;
48829             printf(" %d", n_cur);
48830             printf(" %d", n_node);
48831             printf(" %d", n_ns);
48832             printf("\n");
48833         }
48834     }
48835     }
48836     }
48837     function_tests++;
48838 #endif
48839
48840     return(test_ret);
48841 }
48842
48843
48844 static int
48845 test_xmlXPathNodeSetAddUnique(void) {
48846     int test_ret = 0;
48847
48848 #if defined(LIBXML_XPATH_ENABLED)
48849     int mem_base;
48850     xmlNodeSetPtr cur; /* the initial node set */
48851     int n_cur;
48852     xmlNodePtr val; /* a new xmlNodePtr */
48853     int n_val;
48854
48855     for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
48856     for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
48857         mem_base = xmlMemBlocks();
48858         cur = gen_xmlNodeSetPtr(n_cur, 0);
48859         val = gen_xmlNodePtr(n_val, 1);
48860
48861         xmlXPathNodeSetAddUnique(cur, val);
48862         call_tests++;
48863         des_xmlNodeSetPtr(n_cur, cur, 0);
48864         des_xmlNodePtr(n_val, val, 1);
48865         xmlResetLastError();
48866         if (mem_base != xmlMemBlocks()) {
48867             printf("Leak of %d blocks found in xmlXPathNodeSetAddUnique",
48868                    xmlMemBlocks() - mem_base);
48869             test_ret++;
48870             printf(" %d", n_cur);
48871             printf(" %d", n_val);
48872             printf("\n");
48873         }
48874     }
48875     }
48876     function_tests++;
48877 #endif
48878
48879     return(test_ret);
48880 }
48881
48882
48883 static int
48884 test_xmlXPathNodeSetContains(void) {
48885     int test_ret = 0;
48886
48887 #if defined(LIBXML_XPATH_ENABLED)
48888     int mem_base;
48889     int ret_val;
48890     xmlNodeSetPtr cur; /* the node-set */
48891     int n_cur;
48892     xmlNodePtr val; /* the node */
48893     int n_val;
48894
48895     for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
48896     for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
48897         mem_base = xmlMemBlocks();
48898         cur = gen_xmlNodeSetPtr(n_cur, 0);
48899         val = gen_xmlNodePtr(n_val, 1);
48900
48901         ret_val = xmlXPathNodeSetContains(cur, val);
48902         desret_int(ret_val);
48903         call_tests++;
48904         des_xmlNodeSetPtr(n_cur, cur, 0);
48905         des_xmlNodePtr(n_val, val, 1);
48906         xmlResetLastError();
48907         if (mem_base != xmlMemBlocks()) {
48908             printf("Leak of %d blocks found in xmlXPathNodeSetContains",
48909                    xmlMemBlocks() - mem_base);
48910             test_ret++;
48911             printf(" %d", n_cur);
48912             printf(" %d", n_val);
48913             printf("\n");
48914         }
48915     }
48916     }
48917     function_tests++;
48918 #endif
48919
48920     return(test_ret);
48921 }
48922
48923
48924 static int
48925 test_xmlXPathNodeSetDel(void) {
48926     int test_ret = 0;
48927
48928 #if defined(LIBXML_XPATH_ENABLED)
48929     int mem_base;
48930     xmlNodeSetPtr cur; /* the initial node set */
48931     int n_cur;
48932     xmlNodePtr val; /* an xmlNodePtr */
48933     int n_val;
48934
48935     for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
48936     for (n_val = 0;n_val < gen_nb_xmlNodePtr;n_val++) {
48937         mem_base = xmlMemBlocks();
48938         cur = gen_xmlNodeSetPtr(n_cur, 0);
48939         val = gen_xmlNodePtr(n_val, 1);
48940
48941         xmlXPathNodeSetDel(cur, val);
48942         call_tests++;
48943         des_xmlNodeSetPtr(n_cur, cur, 0);
48944         des_xmlNodePtr(n_val, val, 1);
48945         xmlResetLastError();
48946         if (mem_base != xmlMemBlocks()) {
48947             printf("Leak of %d blocks found in xmlXPathNodeSetDel",
48948                    xmlMemBlocks() - mem_base);
48949             test_ret++;
48950             printf(" %d", n_cur);
48951             printf(" %d", n_val);
48952             printf("\n");
48953         }
48954     }
48955     }
48956     function_tests++;
48957 #endif
48958
48959     return(test_ret);
48960 }
48961
48962
48963 static int
48964 test_xmlXPathNodeSetMerge(void) {
48965     int test_ret = 0;
48966
48967 #if defined(LIBXML_XPATH_ENABLED)
48968     int mem_base;
48969     xmlNodeSetPtr ret_val;
48970     xmlNodeSetPtr val1; /* the first NodeSet or NULL */
48971     int n_val1;
48972     xmlNodeSetPtr val2; /* the second NodeSet */
48973     int n_val2;
48974
48975     for (n_val1 = 0;n_val1 < gen_nb_xmlNodeSetPtr;n_val1++) {
48976     for (n_val2 = 0;n_val2 < gen_nb_xmlNodeSetPtr;n_val2++) {
48977         mem_base = xmlMemBlocks();
48978         val1 = gen_xmlNodeSetPtr(n_val1, 0);
48979         val2 = gen_xmlNodeSetPtr(n_val2, 1);
48980
48981         ret_val = xmlXPathNodeSetMerge(val1, val2);
48982         desret_xmlNodeSetPtr(ret_val);
48983         call_tests++;
48984         des_xmlNodeSetPtr(n_val1, val1, 0);
48985         des_xmlNodeSetPtr(n_val2, val2, 1);
48986         xmlResetLastError();
48987         if (mem_base != xmlMemBlocks()) {
48988             printf("Leak of %d blocks found in xmlXPathNodeSetMerge",
48989                    xmlMemBlocks() - mem_base);
48990             test_ret++;
48991             printf(" %d", n_val1);
48992             printf(" %d", n_val2);
48993             printf("\n");
48994         }
48995     }
48996     }
48997     function_tests++;
48998 #endif
48999
49000     return(test_ret);
49001 }
49002
49003
49004 static int
49005 test_xmlXPathNodeSetRemove(void) {
49006     int test_ret = 0;
49007
49008 #if defined(LIBXML_XPATH_ENABLED)
49009     int mem_base;
49010     xmlNodeSetPtr cur; /* the initial node set */
49011     int n_cur;
49012     int val; /* the index to remove */
49013     int n_val;
49014
49015     for (n_cur = 0;n_cur < gen_nb_xmlNodeSetPtr;n_cur++) {
49016     for (n_val = 0;n_val < gen_nb_int;n_val++) {
49017         mem_base = xmlMemBlocks();
49018         cur = gen_xmlNodeSetPtr(n_cur, 0);
49019         val = gen_int(n_val, 1);
49020
49021         xmlXPathNodeSetRemove(cur, val);
49022         call_tests++;
49023         des_xmlNodeSetPtr(n_cur, cur, 0);
49024         des_int(n_val, val, 1);
49025         xmlResetLastError();
49026         if (mem_base != xmlMemBlocks()) {
49027             printf("Leak of %d blocks found in xmlXPathNodeSetRemove",
49028                    xmlMemBlocks() - mem_base);
49029             test_ret++;
49030             printf(" %d", n_cur);
49031             printf(" %d", n_val);
49032             printf("\n");
49033         }
49034     }
49035     }
49036     function_tests++;
49037 #endif
49038
49039     return(test_ret);
49040 }
49041
49042
49043 static int
49044 test_xmlXPathNodeSetSort(void) {
49045     int test_ret = 0;
49046
49047 #if defined(LIBXML_XPATH_ENABLED)
49048     int mem_base;
49049     xmlNodeSetPtr set; /* the node set */
49050     int n_set;
49051
49052     for (n_set = 0;n_set < gen_nb_xmlNodeSetPtr;n_set++) {
49053         mem_base = xmlMemBlocks();
49054         set = gen_xmlNodeSetPtr(n_set, 0);
49055
49056         xmlXPathNodeSetSort(set);
49057         call_tests++;
49058         des_xmlNodeSetPtr(n_set, set, 0);
49059         xmlResetLastError();
49060         if (mem_base != xmlMemBlocks()) {
49061             printf("Leak of %d blocks found in xmlXPathNodeSetSort",
49062                    xmlMemBlocks() - mem_base);
49063             test_ret++;
49064             printf(" %d", n_set);
49065             printf("\n");
49066         }
49067     }
49068     function_tests++;
49069 #endif
49070
49071     return(test_ret);
49072 }
49073
49074
49075 static int
49076 test_xmlXPathNodeTrailing(void) {
49077     int test_ret = 0;
49078
49079 #if defined(LIBXML_XPATH_ENABLED)
49080     int mem_base;
49081     xmlNodeSetPtr ret_val;
49082     xmlNodeSetPtr nodes; /* a node-set */
49083     int n_nodes;
49084     xmlNodePtr node; /* a node */
49085     int n_node;
49086
49087     for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
49088     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
49089         mem_base = xmlMemBlocks();
49090         nodes = gen_xmlNodeSetPtr(n_nodes, 0);
49091         node = gen_xmlNodePtr(n_node, 1);
49092
49093         ret_val = xmlXPathNodeTrailing(nodes, node);
49094         desret_xmlNodeSetPtr(ret_val);
49095         call_tests++;
49096         des_xmlNodeSetPtr(n_nodes, nodes, 0);
49097         des_xmlNodePtr(n_node, node, 1);
49098         xmlResetLastError();
49099         if (mem_base != xmlMemBlocks()) {
49100             printf("Leak of %d blocks found in xmlXPathNodeTrailing",
49101                    xmlMemBlocks() - mem_base);
49102             test_ret++;
49103             printf(" %d", n_nodes);
49104             printf(" %d", n_node);
49105             printf("\n");
49106         }
49107     }
49108     }
49109     function_tests++;
49110 #endif
49111
49112     return(test_ret);
49113 }
49114
49115
49116 static int
49117 test_xmlXPathNodeTrailingSorted(void) {
49118     int test_ret = 0;
49119
49120 #if defined(LIBXML_XPATH_ENABLED)
49121     int mem_base;
49122     xmlNodeSetPtr ret_val;
49123     xmlNodeSetPtr nodes; /* a node-set, sorted by document order */
49124     int n_nodes;
49125     xmlNodePtr node; /* a node */
49126     int n_node;
49127
49128     for (n_nodes = 0;n_nodes < gen_nb_xmlNodeSetPtr;n_nodes++) {
49129     for (n_node = 0;n_node < gen_nb_xmlNodePtr;n_node++) {
49130         mem_base = xmlMemBlocks();
49131         nodes = gen_xmlNodeSetPtr(n_nodes, 0);
49132         node = gen_xmlNodePtr(n_node, 1);
49133
49134         ret_val = xmlXPathNodeTrailingSorted(nodes, node);
49135         desret_xmlNodeSetPtr(ret_val);
49136         call_tests++;
49137         des_xmlNodeSetPtr(n_nodes, nodes, 0);
49138         des_xmlNodePtr(n_node, node, 1);
49139         xmlResetLastError();
49140         if (mem_base != xmlMemBlocks()) {
49141             printf("Leak of %d blocks found in xmlXPathNodeTrailingSorted",
49142                    xmlMemBlocks() - mem_base);
49143             test_ret++;
49144             printf(" %d", n_nodes);
49145             printf(" %d", n_node);
49146             printf("\n");
49147         }
49148     }
49149     }
49150     function_tests++;
49151 #endif
49152
49153     return(test_ret);
49154 }
49155
49156
49157 static int
49158 test_xmlXPathNormalizeFunction(void) {
49159     int test_ret = 0;
49160
49161 #if defined(LIBXML_XPATH_ENABLED)
49162     int mem_base;
49163     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49164     int n_ctxt;
49165     int nargs; /* the number of arguments */
49166     int n_nargs;
49167
49168     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49169     for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
49170         mem_base = xmlMemBlocks();
49171         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49172         nargs = gen_int(n_nargs, 1);
49173
49174         xmlXPathNormalizeFunction(ctxt, nargs);
49175         call_tests++;
49176         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49177         des_int(n_nargs, nargs, 1);
49178         xmlResetLastError();
49179         if (mem_base != xmlMemBlocks()) {
49180             printf("Leak of %d blocks found in xmlXPathNormalizeFunction",
49181                    xmlMemBlocks() - mem_base);
49182             test_ret++;
49183             printf(" %d", n_ctxt);
49184             printf(" %d", n_nargs);
49185             printf("\n");
49186         }
49187     }
49188     }
49189     function_tests++;
49190 #endif
49191
49192     return(test_ret);
49193 }
49194
49195
49196 static int
49197 test_xmlXPathNotEqualValues(void) {
49198     int test_ret = 0;
49199
49200 #if defined(LIBXML_XPATH_ENABLED)
49201     int mem_base;
49202     int ret_val;
49203     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49204     int n_ctxt;
49205
49206     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49207         mem_base = xmlMemBlocks();
49208         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49209
49210         ret_val = xmlXPathNotEqualValues(ctxt);
49211         desret_int(ret_val);
49212         call_tests++;
49213         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49214         xmlResetLastError();
49215         if (mem_base != xmlMemBlocks()) {
49216             printf("Leak of %d blocks found in xmlXPathNotEqualValues",
49217                    xmlMemBlocks() - mem_base);
49218             test_ret++;
49219             printf(" %d", n_ctxt);
49220             printf("\n");
49221         }
49222     }
49223     function_tests++;
49224 #endif
49225
49226     return(test_ret);
49227 }
49228
49229
49230 static int
49231 test_xmlXPathNotFunction(void) {
49232     int test_ret = 0;
49233
49234 #if defined(LIBXML_XPATH_ENABLED)
49235     int mem_base;
49236     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49237     int n_ctxt;
49238     int nargs; /* the number of arguments */
49239     int n_nargs;
49240
49241     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49242     for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
49243         mem_base = xmlMemBlocks();
49244         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49245         nargs = gen_int(n_nargs, 1);
49246
49247         xmlXPathNotFunction(ctxt, nargs);
49248         call_tests++;
49249         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49250         des_int(n_nargs, nargs, 1);
49251         xmlResetLastError();
49252         if (mem_base != xmlMemBlocks()) {
49253             printf("Leak of %d blocks found in xmlXPathNotFunction",
49254                    xmlMemBlocks() - mem_base);
49255             test_ret++;
49256             printf(" %d", n_ctxt);
49257             printf(" %d", n_nargs);
49258             printf("\n");
49259         }
49260     }
49261     }
49262     function_tests++;
49263 #endif
49264
49265     return(test_ret);
49266 }
49267
49268
49269 static int
49270 test_xmlXPathNsLookup(void) {
49271     int test_ret = 0;
49272
49273 #if defined(LIBXML_XPATH_ENABLED)
49274     int mem_base;
49275     const xmlChar * ret_val;
49276     xmlXPathContextPtr ctxt; /* the XPath context */
49277     int n_ctxt;
49278     xmlChar * prefix; /* the namespace prefix value */
49279     int n_prefix;
49280
49281     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
49282     for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
49283         mem_base = xmlMemBlocks();
49284         ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
49285         prefix = gen_const_xmlChar_ptr(n_prefix, 1);
49286
49287         ret_val = xmlXPathNsLookup(ctxt, (const xmlChar *)prefix);
49288         desret_const_xmlChar_ptr(ret_val);
49289         call_tests++;
49290         des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
49291         des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
49292         xmlResetLastError();
49293         if (mem_base != xmlMemBlocks()) {
49294             printf("Leak of %d blocks found in xmlXPathNsLookup",
49295                    xmlMemBlocks() - mem_base);
49296             test_ret++;
49297             printf(" %d", n_ctxt);
49298             printf(" %d", n_prefix);
49299             printf("\n");
49300         }
49301     }
49302     }
49303     function_tests++;
49304 #endif
49305
49306     return(test_ret);
49307 }
49308
49309
49310 static int
49311 test_xmlXPathNumberFunction(void) {
49312     int test_ret = 0;
49313
49314 #if defined(LIBXML_XPATH_ENABLED)
49315     int mem_base;
49316     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49317     int n_ctxt;
49318     int nargs; /* the number of arguments */
49319     int n_nargs;
49320
49321     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49322     for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
49323         mem_base = xmlMemBlocks();
49324         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49325         nargs = gen_int(n_nargs, 1);
49326
49327         xmlXPathNumberFunction(ctxt, nargs);
49328         call_tests++;
49329         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49330         des_int(n_nargs, nargs, 1);
49331         xmlResetLastError();
49332         if (mem_base != xmlMemBlocks()) {
49333             printf("Leak of %d blocks found in xmlXPathNumberFunction",
49334                    xmlMemBlocks() - mem_base);
49335             test_ret++;
49336             printf(" %d", n_ctxt);
49337             printf(" %d", n_nargs);
49338             printf("\n");
49339         }
49340     }
49341     }
49342     function_tests++;
49343 #endif
49344
49345     return(test_ret);
49346 }
49347
49348
49349 static int
49350 test_xmlXPathParseNCName(void) {
49351     int test_ret = 0;
49352
49353 #if defined(LIBXML_XPATH_ENABLED)
49354     int mem_base;
49355     xmlChar * ret_val;
49356     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49357     int n_ctxt;
49358
49359     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49360         mem_base = xmlMemBlocks();
49361         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49362
49363         ret_val = xmlXPathParseNCName(ctxt);
49364         desret_xmlChar_ptr(ret_val);
49365         call_tests++;
49366         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49367         xmlResetLastError();
49368         if (mem_base != xmlMemBlocks()) {
49369             printf("Leak of %d blocks found in xmlXPathParseNCName",
49370                    xmlMemBlocks() - mem_base);
49371             test_ret++;
49372             printf(" %d", n_ctxt);
49373             printf("\n");
49374         }
49375     }
49376     function_tests++;
49377 #endif
49378
49379     return(test_ret);
49380 }
49381
49382
49383 static int
49384 test_xmlXPathParseName(void) {
49385     int test_ret = 0;
49386
49387 #if defined(LIBXML_XPATH_ENABLED)
49388     int mem_base;
49389     xmlChar * ret_val;
49390     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49391     int n_ctxt;
49392
49393     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49394         mem_base = xmlMemBlocks();
49395         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49396
49397         ret_val = xmlXPathParseName(ctxt);
49398         desret_xmlChar_ptr(ret_val);
49399         call_tests++;
49400         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49401         xmlResetLastError();
49402         if (mem_base != xmlMemBlocks()) {
49403             printf("Leak of %d blocks found in xmlXPathParseName",
49404                    xmlMemBlocks() - mem_base);
49405             test_ret++;
49406             printf(" %d", n_ctxt);
49407             printf("\n");
49408         }
49409     }
49410     function_tests++;
49411 #endif
49412
49413     return(test_ret);
49414 }
49415
49416
49417 static int
49418 test_xmlXPathPopBoolean(void) {
49419     int test_ret = 0;
49420
49421 #if defined(LIBXML_XPATH_ENABLED)
49422     int mem_base;
49423     int ret_val;
49424     xmlXPathParserContextPtr ctxt; /* an XPath parser context */
49425     int n_ctxt;
49426
49427     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49428         mem_base = xmlMemBlocks();
49429         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49430
49431         ret_val = xmlXPathPopBoolean(ctxt);
49432         desret_int(ret_val);
49433         call_tests++;
49434         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49435         xmlResetLastError();
49436         if (mem_base != xmlMemBlocks()) {
49437             printf("Leak of %d blocks found in xmlXPathPopBoolean",
49438                    xmlMemBlocks() - mem_base);
49439             test_ret++;
49440             printf(" %d", n_ctxt);
49441             printf("\n");
49442         }
49443     }
49444     function_tests++;
49445 #endif
49446
49447     return(test_ret);
49448 }
49449
49450
49451 static int
49452 test_xmlXPathPopExternal(void) {
49453     int test_ret = 0;
49454
49455 #if defined(LIBXML_XPATH_ENABLED)
49456     int mem_base;
49457     void * ret_val;
49458     xmlXPathParserContextPtr ctxt; /* an XPath parser context */
49459     int n_ctxt;
49460
49461     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49462         mem_base = xmlMemBlocks();
49463         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49464
49465         ret_val = xmlXPathPopExternal(ctxt);
49466         desret_void_ptr(ret_val);
49467         call_tests++;
49468         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49469         xmlResetLastError();
49470         if (mem_base != xmlMemBlocks()) {
49471             printf("Leak of %d blocks found in xmlXPathPopExternal",
49472                    xmlMemBlocks() - mem_base);
49473             test_ret++;
49474             printf(" %d", n_ctxt);
49475             printf("\n");
49476         }
49477     }
49478     function_tests++;
49479 #endif
49480
49481     return(test_ret);
49482 }
49483
49484
49485 static int
49486 test_xmlXPathPopNodeSet(void) {
49487     int test_ret = 0;
49488
49489 #if defined(LIBXML_XPATH_ENABLED)
49490     int mem_base;
49491     xmlNodeSetPtr ret_val;
49492     xmlXPathParserContextPtr ctxt; /* an XPath parser context */
49493     int n_ctxt;
49494
49495     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49496         mem_base = xmlMemBlocks();
49497         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49498
49499         ret_val = xmlXPathPopNodeSet(ctxt);
49500         desret_xmlNodeSetPtr(ret_val);
49501         call_tests++;
49502         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49503         xmlResetLastError();
49504         if (mem_base != xmlMemBlocks()) {
49505             printf("Leak of %d blocks found in xmlXPathPopNodeSet",
49506                    xmlMemBlocks() - mem_base);
49507             test_ret++;
49508             printf(" %d", n_ctxt);
49509             printf("\n");
49510         }
49511     }
49512     function_tests++;
49513 #endif
49514
49515     return(test_ret);
49516 }
49517
49518
49519 static int
49520 test_xmlXPathPopNumber(void) {
49521     int test_ret = 0;
49522
49523 #if defined(LIBXML_XPATH_ENABLED)
49524     int mem_base;
49525     double ret_val;
49526     xmlXPathParserContextPtr ctxt; /* an XPath parser context */
49527     int n_ctxt;
49528
49529     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49530         mem_base = xmlMemBlocks();
49531         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49532
49533         ret_val = xmlXPathPopNumber(ctxt);
49534         desret_double(ret_val);
49535         call_tests++;
49536         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49537         xmlResetLastError();
49538         if (mem_base != xmlMemBlocks()) {
49539             printf("Leak of %d blocks found in xmlXPathPopNumber",
49540                    xmlMemBlocks() - mem_base);
49541             test_ret++;
49542             printf(" %d", n_ctxt);
49543             printf("\n");
49544         }
49545     }
49546     function_tests++;
49547 #endif
49548
49549     return(test_ret);
49550 }
49551
49552
49553 static int
49554 test_xmlXPathPopString(void) {
49555     int test_ret = 0;
49556
49557 #if defined(LIBXML_XPATH_ENABLED)
49558     int mem_base;
49559     xmlChar * ret_val;
49560     xmlXPathParserContextPtr ctxt; /* an XPath parser context */
49561     int n_ctxt;
49562
49563     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49564         mem_base = xmlMemBlocks();
49565         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49566
49567         ret_val = xmlXPathPopString(ctxt);
49568         desret_xmlChar_ptr(ret_val);
49569         call_tests++;
49570         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49571         xmlResetLastError();
49572         if (mem_base != xmlMemBlocks()) {
49573             printf("Leak of %d blocks found in xmlXPathPopString",
49574                    xmlMemBlocks() - mem_base);
49575             test_ret++;
49576             printf(" %d", n_ctxt);
49577             printf("\n");
49578         }
49579     }
49580     function_tests++;
49581 #endif
49582
49583     return(test_ret);
49584 }
49585
49586
49587 static int
49588 test_xmlXPathPositionFunction(void) {
49589     int test_ret = 0;
49590
49591 #if defined(LIBXML_XPATH_ENABLED)
49592     int mem_base;
49593     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49594     int n_ctxt;
49595     int nargs; /* the number of arguments */
49596     int n_nargs;
49597
49598     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49599     for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
49600         mem_base = xmlMemBlocks();
49601         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49602         nargs = gen_int(n_nargs, 1);
49603
49604         xmlXPathPositionFunction(ctxt, nargs);
49605         call_tests++;
49606         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49607         des_int(n_nargs, nargs, 1);
49608         xmlResetLastError();
49609         if (mem_base != xmlMemBlocks()) {
49610             printf("Leak of %d blocks found in xmlXPathPositionFunction",
49611                    xmlMemBlocks() - mem_base);
49612             test_ret++;
49613             printf(" %d", n_ctxt);
49614             printf(" %d", n_nargs);
49615             printf("\n");
49616         }
49617     }
49618     }
49619     function_tests++;
49620 #endif
49621
49622     return(test_ret);
49623 }
49624
49625
49626 static int
49627 test_xmlXPathRegisterAllFunctions(void) {
49628     int test_ret = 0;
49629
49630 #if defined(LIBXML_XPATH_ENABLED)
49631     int mem_base;
49632     xmlXPathContextPtr ctxt; /* the XPath context */
49633     int n_ctxt;
49634
49635     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
49636         mem_base = xmlMemBlocks();
49637         ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
49638
49639         xmlXPathRegisterAllFunctions(ctxt);
49640         call_tests++;
49641         des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
49642         xmlResetLastError();
49643         if (mem_base != xmlMemBlocks()) {
49644             printf("Leak of %d blocks found in xmlXPathRegisterAllFunctions",
49645                    xmlMemBlocks() - mem_base);
49646             test_ret++;
49647             printf(" %d", n_ctxt);
49648             printf("\n");
49649         }
49650     }
49651     function_tests++;
49652 #endif
49653
49654     return(test_ret);
49655 }
49656
49657
49658 static int
49659 test_xmlXPathRegisterFunc(void) {
49660     int test_ret = 0;
49661
49662
49663     /* missing type support */
49664     return(test_ret);
49665 }
49666
49667
49668 static int
49669 test_xmlXPathRegisterFuncLookup(void) {
49670     int test_ret = 0;
49671
49672
49673     /* missing type support */
49674     return(test_ret);
49675 }
49676
49677
49678 static int
49679 test_xmlXPathRegisterFuncNS(void) {
49680     int test_ret = 0;
49681
49682
49683     /* missing type support */
49684     return(test_ret);
49685 }
49686
49687
49688 static int
49689 test_xmlXPathRegisterNs(void) {
49690     int test_ret = 0;
49691
49692 #if defined(LIBXML_XPATH_ENABLED)
49693     int mem_base;
49694     int ret_val;
49695     xmlXPathContextPtr ctxt; /* the XPath context */
49696     int n_ctxt;
49697     xmlChar * prefix; /* the namespace prefix cannot be NULL or empty string */
49698     int n_prefix;
49699     xmlChar * ns_uri; /* the namespace name */
49700     int n_ns_uri;
49701
49702     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
49703     for (n_prefix = 0;n_prefix < gen_nb_const_xmlChar_ptr;n_prefix++) {
49704     for (n_ns_uri = 0;n_ns_uri < gen_nb_const_xmlChar_ptr;n_ns_uri++) {
49705         mem_base = xmlMemBlocks();
49706         ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
49707         prefix = gen_const_xmlChar_ptr(n_prefix, 1);
49708         ns_uri = gen_const_xmlChar_ptr(n_ns_uri, 2);
49709
49710         ret_val = xmlXPathRegisterNs(ctxt, (const xmlChar *)prefix, (const xmlChar *)ns_uri);
49711         desret_int(ret_val);
49712         call_tests++;
49713         des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
49714         des_const_xmlChar_ptr(n_prefix, (const xmlChar *)prefix, 1);
49715         des_const_xmlChar_ptr(n_ns_uri, (const xmlChar *)ns_uri, 2);
49716         xmlResetLastError();
49717         if (mem_base != xmlMemBlocks()) {
49718             printf("Leak of %d blocks found in xmlXPathRegisterNs",
49719                    xmlMemBlocks() - mem_base);
49720             test_ret++;
49721             printf(" %d", n_ctxt);
49722             printf(" %d", n_prefix);
49723             printf(" %d", n_ns_uri);
49724             printf("\n");
49725         }
49726     }
49727     }
49728     }
49729     function_tests++;
49730 #endif
49731
49732     return(test_ret);
49733 }
49734
49735
49736 static int
49737 test_xmlXPathRegisterVariable(void) {
49738     int test_ret = 0;
49739
49740 #if defined(LIBXML_XPATH_ENABLED)
49741     int mem_base;
49742     int ret_val;
49743     xmlXPathContextPtr ctxt; /* the XPath context */
49744     int n_ctxt;
49745     xmlChar * name; /* the variable name */
49746     int n_name;
49747     xmlXPathObjectPtr value; /* the variable value or NULL */
49748     int n_value;
49749
49750     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
49751     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
49752     for (n_value = 0;n_value < gen_nb_xmlXPathObjectPtr;n_value++) {
49753         mem_base = xmlMemBlocks();
49754         ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
49755         name = gen_const_xmlChar_ptr(n_name, 1);
49756         value = gen_xmlXPathObjectPtr(n_value, 2);
49757
49758         ret_val = xmlXPathRegisterVariable(ctxt, (const xmlChar *)name, value);
49759         desret_int(ret_val);
49760         call_tests++;
49761         des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
49762         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
49763         des_xmlXPathObjectPtr(n_value, value, 2);
49764         xmlResetLastError();
49765         if (mem_base != xmlMemBlocks()) {
49766             printf("Leak of %d blocks found in xmlXPathRegisterVariable",
49767                    xmlMemBlocks() - mem_base);
49768             test_ret++;
49769             printf(" %d", n_ctxt);
49770             printf(" %d", n_name);
49771             printf(" %d", n_value);
49772             printf("\n");
49773         }
49774     }
49775     }
49776     }
49777     function_tests++;
49778 #endif
49779
49780     return(test_ret);
49781 }
49782
49783
49784 static int
49785 test_xmlXPathRegisterVariableLookup(void) {
49786     int test_ret = 0;
49787
49788
49789     /* missing type support */
49790     return(test_ret);
49791 }
49792
49793
49794 static int
49795 test_xmlXPathRegisterVariableNS(void) {
49796     int test_ret = 0;
49797
49798 #if defined(LIBXML_XPATH_ENABLED)
49799     int mem_base;
49800     int ret_val;
49801     xmlXPathContextPtr ctxt; /* the XPath context */
49802     int n_ctxt;
49803     xmlChar * name; /* the variable name */
49804     int n_name;
49805     xmlChar * ns_uri; /* the variable namespace URI */
49806     int n_ns_uri;
49807     xmlXPathObjectPtr value; /* the variable value or NULL */
49808     int n_value;
49809
49810     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
49811     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
49812     for (n_ns_uri = 0;n_ns_uri < gen_nb_const_xmlChar_ptr;n_ns_uri++) {
49813     for (n_value = 0;n_value < gen_nb_xmlXPathObjectPtr;n_value++) {
49814         mem_base = xmlMemBlocks();
49815         ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
49816         name = gen_const_xmlChar_ptr(n_name, 1);
49817         ns_uri = gen_const_xmlChar_ptr(n_ns_uri, 2);
49818         value = gen_xmlXPathObjectPtr(n_value, 3);
49819
49820         ret_val = xmlXPathRegisterVariableNS(ctxt, (const xmlChar *)name, (const xmlChar *)ns_uri, value);
49821         desret_int(ret_val);
49822         call_tests++;
49823         des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
49824         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
49825         des_const_xmlChar_ptr(n_ns_uri, (const xmlChar *)ns_uri, 2);
49826         des_xmlXPathObjectPtr(n_value, value, 3);
49827         xmlResetLastError();
49828         if (mem_base != xmlMemBlocks()) {
49829             printf("Leak of %d blocks found in xmlXPathRegisterVariableNS",
49830                    xmlMemBlocks() - mem_base);
49831             test_ret++;
49832             printf(" %d", n_ctxt);
49833             printf(" %d", n_name);
49834             printf(" %d", n_ns_uri);
49835             printf(" %d", n_value);
49836             printf("\n");
49837         }
49838     }
49839     }
49840     }
49841     }
49842     function_tests++;
49843 #endif
49844
49845     return(test_ret);
49846 }
49847
49848
49849 static int
49850 test_xmlXPathRegisteredFuncsCleanup(void) {
49851     int test_ret = 0;
49852
49853 #if defined(LIBXML_XPATH_ENABLED)
49854     int mem_base;
49855     xmlXPathContextPtr ctxt; /* the XPath context */
49856     int n_ctxt;
49857
49858     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
49859         mem_base = xmlMemBlocks();
49860         ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
49861
49862         xmlXPathRegisteredFuncsCleanup(ctxt);
49863         call_tests++;
49864         des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
49865         xmlResetLastError();
49866         if (mem_base != xmlMemBlocks()) {
49867             printf("Leak of %d blocks found in xmlXPathRegisteredFuncsCleanup",
49868                    xmlMemBlocks() - mem_base);
49869             test_ret++;
49870             printf(" %d", n_ctxt);
49871             printf("\n");
49872         }
49873     }
49874     function_tests++;
49875 #endif
49876
49877     return(test_ret);
49878 }
49879
49880
49881 static int
49882 test_xmlXPathRegisteredNsCleanup(void) {
49883     int test_ret = 0;
49884
49885 #if defined(LIBXML_XPATH_ENABLED)
49886     int mem_base;
49887     xmlXPathContextPtr ctxt; /* the XPath context */
49888     int n_ctxt;
49889
49890     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
49891         mem_base = xmlMemBlocks();
49892         ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
49893
49894         xmlXPathRegisteredNsCleanup(ctxt);
49895         call_tests++;
49896         des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
49897         xmlResetLastError();
49898         if (mem_base != xmlMemBlocks()) {
49899             printf("Leak of %d blocks found in xmlXPathRegisteredNsCleanup",
49900                    xmlMemBlocks() - mem_base);
49901             test_ret++;
49902             printf(" %d", n_ctxt);
49903             printf("\n");
49904         }
49905     }
49906     function_tests++;
49907 #endif
49908
49909     return(test_ret);
49910 }
49911
49912
49913 static int
49914 test_xmlXPathRegisteredVariablesCleanup(void) {
49915     int test_ret = 0;
49916
49917 #if defined(LIBXML_XPATH_ENABLED)
49918     int mem_base;
49919     xmlXPathContextPtr ctxt; /* the XPath context */
49920     int n_ctxt;
49921
49922     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
49923         mem_base = xmlMemBlocks();
49924         ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
49925
49926         xmlXPathRegisteredVariablesCleanup(ctxt);
49927         call_tests++;
49928         des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
49929         xmlResetLastError();
49930         if (mem_base != xmlMemBlocks()) {
49931             printf("Leak of %d blocks found in xmlXPathRegisteredVariablesCleanup",
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_xmlXPathRoot(void) {
49947     int test_ret = 0;
49948
49949 #if defined(LIBXML_XPATH_ENABLED)
49950     int mem_base;
49951     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49952     int n_ctxt;
49953
49954     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49955         mem_base = xmlMemBlocks();
49956         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49957
49958         xmlXPathRoot(ctxt);
49959         call_tests++;
49960         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49961         xmlResetLastError();
49962         if (mem_base != xmlMemBlocks()) {
49963             printf("Leak of %d blocks found in xmlXPathRoot",
49964                    xmlMemBlocks() - mem_base);
49965             test_ret++;
49966             printf(" %d", n_ctxt);
49967             printf("\n");
49968         }
49969     }
49970     function_tests++;
49971 #endif
49972
49973     return(test_ret);
49974 }
49975
49976
49977 static int
49978 test_xmlXPathRoundFunction(void) {
49979     int test_ret = 0;
49980
49981 #if defined(LIBXML_XPATH_ENABLED)
49982     int mem_base;
49983     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
49984     int n_ctxt;
49985     int nargs; /* the number of arguments */
49986     int n_nargs;
49987
49988     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
49989     for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
49990         mem_base = xmlMemBlocks();
49991         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
49992         nargs = gen_int(n_nargs, 1);
49993
49994         xmlXPathRoundFunction(ctxt, nargs);
49995         call_tests++;
49996         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
49997         des_int(n_nargs, nargs, 1);
49998         xmlResetLastError();
49999         if (mem_base != xmlMemBlocks()) {
50000             printf("Leak of %d blocks found in xmlXPathRoundFunction",
50001                    xmlMemBlocks() - mem_base);
50002             test_ret++;
50003             printf(" %d", n_ctxt);
50004             printf(" %d", n_nargs);
50005             printf("\n");
50006         }
50007     }
50008     }
50009     function_tests++;
50010 #endif
50011
50012     return(test_ret);
50013 }
50014
50015
50016 static int
50017 test_xmlXPathStartsWithFunction(void) {
50018     int test_ret = 0;
50019
50020 #if defined(LIBXML_XPATH_ENABLED)
50021     int mem_base;
50022     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50023     int n_ctxt;
50024     int nargs; /* the number of arguments */
50025     int n_nargs;
50026
50027     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50028     for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50029         mem_base = xmlMemBlocks();
50030         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50031         nargs = gen_int(n_nargs, 1);
50032
50033         xmlXPathStartsWithFunction(ctxt, nargs);
50034         call_tests++;
50035         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50036         des_int(n_nargs, nargs, 1);
50037         xmlResetLastError();
50038         if (mem_base != xmlMemBlocks()) {
50039             printf("Leak of %d blocks found in xmlXPathStartsWithFunction",
50040                    xmlMemBlocks() - mem_base);
50041             test_ret++;
50042             printf(" %d", n_ctxt);
50043             printf(" %d", n_nargs);
50044             printf("\n");
50045         }
50046     }
50047     }
50048     function_tests++;
50049 #endif
50050
50051     return(test_ret);
50052 }
50053
50054
50055 static int
50056 test_xmlXPathStringEvalNumber(void) {
50057     int test_ret = 0;
50058
50059 #if defined(LIBXML_XPATH_ENABLED)
50060     int mem_base;
50061     double ret_val;
50062     xmlChar * str; /* A string to scan */
50063     int n_str;
50064
50065     for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
50066         mem_base = xmlMemBlocks();
50067         str = gen_const_xmlChar_ptr(n_str, 0);
50068
50069         ret_val = xmlXPathStringEvalNumber((const xmlChar *)str);
50070         desret_double(ret_val);
50071         call_tests++;
50072         des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
50073         xmlResetLastError();
50074         if (mem_base != xmlMemBlocks()) {
50075             printf("Leak of %d blocks found in xmlXPathStringEvalNumber",
50076                    xmlMemBlocks() - mem_base);
50077             test_ret++;
50078             printf(" %d", n_str);
50079             printf("\n");
50080         }
50081     }
50082     function_tests++;
50083 #endif
50084
50085     return(test_ret);
50086 }
50087
50088
50089 static int
50090 test_xmlXPathStringFunction(void) {
50091     int test_ret = 0;
50092
50093 #if defined(LIBXML_XPATH_ENABLED)
50094     int mem_base;
50095     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50096     int n_ctxt;
50097     int nargs; /* the number of arguments */
50098     int n_nargs;
50099
50100     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50101     for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50102         mem_base = xmlMemBlocks();
50103         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50104         nargs = gen_int(n_nargs, 1);
50105
50106         xmlXPathStringFunction(ctxt, nargs);
50107         call_tests++;
50108         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50109         des_int(n_nargs, nargs, 1);
50110         xmlResetLastError();
50111         if (mem_base != xmlMemBlocks()) {
50112             printf("Leak of %d blocks found in xmlXPathStringFunction",
50113                    xmlMemBlocks() - mem_base);
50114             test_ret++;
50115             printf(" %d", n_ctxt);
50116             printf(" %d", n_nargs);
50117             printf("\n");
50118         }
50119     }
50120     }
50121     function_tests++;
50122 #endif
50123
50124     return(test_ret);
50125 }
50126
50127
50128 static int
50129 test_xmlXPathStringLengthFunction(void) {
50130     int test_ret = 0;
50131
50132 #if defined(LIBXML_XPATH_ENABLED)
50133     int mem_base;
50134     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50135     int n_ctxt;
50136     int nargs; /* the number of arguments */
50137     int n_nargs;
50138
50139     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50140     for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50141         mem_base = xmlMemBlocks();
50142         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50143         nargs = gen_int(n_nargs, 1);
50144
50145         xmlXPathStringLengthFunction(ctxt, nargs);
50146         call_tests++;
50147         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50148         des_int(n_nargs, nargs, 1);
50149         xmlResetLastError();
50150         if (mem_base != xmlMemBlocks()) {
50151             printf("Leak of %d blocks found in xmlXPathStringLengthFunction",
50152                    xmlMemBlocks() - mem_base);
50153             test_ret++;
50154             printf(" %d", n_ctxt);
50155             printf(" %d", n_nargs);
50156             printf("\n");
50157         }
50158     }
50159     }
50160     function_tests++;
50161 #endif
50162
50163     return(test_ret);
50164 }
50165
50166
50167 static int
50168 test_xmlXPathSubValues(void) {
50169     int test_ret = 0;
50170
50171 #if defined(LIBXML_XPATH_ENABLED)
50172     int mem_base;
50173     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50174     int n_ctxt;
50175
50176     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50177         mem_base = xmlMemBlocks();
50178         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50179
50180         xmlXPathSubValues(ctxt);
50181         call_tests++;
50182         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50183         xmlResetLastError();
50184         if (mem_base != xmlMemBlocks()) {
50185             printf("Leak of %d blocks found in xmlXPathSubValues",
50186                    xmlMemBlocks() - mem_base);
50187             test_ret++;
50188             printf(" %d", n_ctxt);
50189             printf("\n");
50190         }
50191     }
50192     function_tests++;
50193 #endif
50194
50195     return(test_ret);
50196 }
50197
50198
50199 static int
50200 test_xmlXPathSubstringAfterFunction(void) {
50201     int test_ret = 0;
50202
50203 #if defined(LIBXML_XPATH_ENABLED)
50204     int mem_base;
50205     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50206     int n_ctxt;
50207     int nargs; /* the number of arguments */
50208     int n_nargs;
50209
50210     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50211     for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50212         mem_base = xmlMemBlocks();
50213         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50214         nargs = gen_int(n_nargs, 1);
50215
50216         xmlXPathSubstringAfterFunction(ctxt, nargs);
50217         call_tests++;
50218         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50219         des_int(n_nargs, nargs, 1);
50220         xmlResetLastError();
50221         if (mem_base != xmlMemBlocks()) {
50222             printf("Leak of %d blocks found in xmlXPathSubstringAfterFunction",
50223                    xmlMemBlocks() - mem_base);
50224             test_ret++;
50225             printf(" %d", n_ctxt);
50226             printf(" %d", n_nargs);
50227             printf("\n");
50228         }
50229     }
50230     }
50231     function_tests++;
50232 #endif
50233
50234     return(test_ret);
50235 }
50236
50237
50238 static int
50239 test_xmlXPathSubstringBeforeFunction(void) {
50240     int test_ret = 0;
50241
50242 #if defined(LIBXML_XPATH_ENABLED)
50243     int mem_base;
50244     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50245     int n_ctxt;
50246     int nargs; /* the number of arguments */
50247     int n_nargs;
50248
50249     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50250     for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50251         mem_base = xmlMemBlocks();
50252         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50253         nargs = gen_int(n_nargs, 1);
50254
50255         xmlXPathSubstringBeforeFunction(ctxt, nargs);
50256         call_tests++;
50257         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50258         des_int(n_nargs, nargs, 1);
50259         xmlResetLastError();
50260         if (mem_base != xmlMemBlocks()) {
50261             printf("Leak of %d blocks found in xmlXPathSubstringBeforeFunction",
50262                    xmlMemBlocks() - mem_base);
50263             test_ret++;
50264             printf(" %d", n_ctxt);
50265             printf(" %d", n_nargs);
50266             printf("\n");
50267         }
50268     }
50269     }
50270     function_tests++;
50271 #endif
50272
50273     return(test_ret);
50274 }
50275
50276
50277 static int
50278 test_xmlXPathSubstringFunction(void) {
50279     int test_ret = 0;
50280
50281 #if defined(LIBXML_XPATH_ENABLED)
50282     int mem_base;
50283     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50284     int n_ctxt;
50285     int nargs; /* the number of arguments */
50286     int n_nargs;
50287
50288     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50289     for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50290         mem_base = xmlMemBlocks();
50291         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50292         nargs = gen_int(n_nargs, 1);
50293
50294         xmlXPathSubstringFunction(ctxt, nargs);
50295         call_tests++;
50296         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50297         des_int(n_nargs, nargs, 1);
50298         xmlResetLastError();
50299         if (mem_base != xmlMemBlocks()) {
50300             printf("Leak of %d blocks found in xmlXPathSubstringFunction",
50301                    xmlMemBlocks() - mem_base);
50302             test_ret++;
50303             printf(" %d", n_ctxt);
50304             printf(" %d", n_nargs);
50305             printf("\n");
50306         }
50307     }
50308     }
50309     function_tests++;
50310 #endif
50311
50312     return(test_ret);
50313 }
50314
50315
50316 static int
50317 test_xmlXPathSumFunction(void) {
50318     int test_ret = 0;
50319
50320 #if defined(LIBXML_XPATH_ENABLED)
50321     int mem_base;
50322     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50323     int n_ctxt;
50324     int nargs; /* the number of arguments */
50325     int n_nargs;
50326
50327     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50328     for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
50329         mem_base = xmlMemBlocks();
50330         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50331         nargs = gen_int(n_nargs, 1);
50332
50333         xmlXPathSumFunction(ctxt, nargs);
50334         call_tests++;
50335         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50336         des_int(n_nargs, nargs, 1);
50337         xmlResetLastError();
50338         if (mem_base != xmlMemBlocks()) {
50339             printf("Leak of %d blocks found in xmlXPathSumFunction",
50340                    xmlMemBlocks() - mem_base);
50341             test_ret++;
50342             printf(" %d", n_ctxt);
50343             printf(" %d", n_nargs);
50344             printf("\n");
50345         }
50346     }
50347     }
50348     function_tests++;
50349 #endif
50350
50351     return(test_ret);
50352 }
50353
50354
50355 static int
50356 test_xmlXPathTrailing(void) {
50357     int test_ret = 0;
50358
50359 #if defined(LIBXML_XPATH_ENABLED)
50360     int mem_base;
50361     xmlNodeSetPtr ret_val;
50362     xmlNodeSetPtr nodes1; /* a node-set */
50363     int n_nodes1;
50364     xmlNodeSetPtr nodes2; /* a node-set */
50365     int n_nodes2;
50366
50367     for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
50368     for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
50369         mem_base = xmlMemBlocks();
50370         nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
50371         nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
50372
50373         ret_val = xmlXPathTrailing(nodes1, nodes2);
50374         desret_xmlNodeSetPtr(ret_val);
50375         call_tests++;
50376         des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
50377         des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
50378         xmlResetLastError();
50379         if (mem_base != xmlMemBlocks()) {
50380             printf("Leak of %d blocks found in xmlXPathTrailing",
50381                    xmlMemBlocks() - mem_base);
50382             test_ret++;
50383             printf(" %d", n_nodes1);
50384             printf(" %d", n_nodes2);
50385             printf("\n");
50386         }
50387     }
50388     }
50389     function_tests++;
50390 #endif
50391
50392     return(test_ret);
50393 }
50394
50395
50396 static int
50397 test_xmlXPathTrailingSorted(void) {
50398     int test_ret = 0;
50399
50400 #if defined(LIBXML_XPATH_ENABLED)
50401     int mem_base;
50402     xmlNodeSetPtr ret_val;
50403     xmlNodeSetPtr nodes1; /* a node-set, sorted by document order */
50404     int n_nodes1;
50405     xmlNodeSetPtr nodes2; /* a node-set, sorted by document order */
50406     int n_nodes2;
50407
50408     for (n_nodes1 = 0;n_nodes1 < gen_nb_xmlNodeSetPtr;n_nodes1++) {
50409     for (n_nodes2 = 0;n_nodes2 < gen_nb_xmlNodeSetPtr;n_nodes2++) {
50410         mem_base = xmlMemBlocks();
50411         nodes1 = gen_xmlNodeSetPtr(n_nodes1, 0);
50412         nodes2 = gen_xmlNodeSetPtr(n_nodes2, 1);
50413
50414         ret_val = xmlXPathTrailingSorted(nodes1, nodes2);
50415         desret_xmlNodeSetPtr(ret_val);
50416         call_tests++;
50417         des_xmlNodeSetPtr(n_nodes1, nodes1, 0);
50418         des_xmlNodeSetPtr(n_nodes2, nodes2, 1);
50419         xmlResetLastError();
50420         if (mem_base != xmlMemBlocks()) {
50421             printf("Leak of %d blocks found in xmlXPathTrailingSorted",
50422                    xmlMemBlocks() - mem_base);
50423             test_ret++;
50424             printf(" %d", n_nodes1);
50425             printf(" %d", n_nodes2);
50426             printf("\n");
50427         }
50428     }
50429     }
50430     function_tests++;
50431 #endif
50432
50433     return(test_ret);
50434 }
50435
50436
50437 static int
50438 test_xmlXPathTranslateFunction(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         xmlXPathTranslateFunction(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 xmlXPathTranslateFunction",
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_xmlXPathTrueFunction(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         xmlXPathTrueFunction(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 xmlXPathTrueFunction",
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_xmlXPathValueFlipSign(void) {
50517     int test_ret = 0;
50518
50519 #if defined(LIBXML_XPATH_ENABLED)
50520     int mem_base;
50521     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50522     int n_ctxt;
50523
50524     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50525         mem_base = xmlMemBlocks();
50526         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50527
50528         xmlXPathValueFlipSign(ctxt);
50529         call_tests++;
50530         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50531         xmlResetLastError();
50532         if (mem_base != xmlMemBlocks()) {
50533             printf("Leak of %d blocks found in xmlXPathValueFlipSign",
50534                    xmlMemBlocks() - mem_base);
50535             test_ret++;
50536             printf(" %d", n_ctxt);
50537             printf("\n");
50538         }
50539     }
50540     function_tests++;
50541 #endif
50542
50543     return(test_ret);
50544 }
50545
50546
50547 static int
50548 test_xmlXPathVariableLookup(void) {
50549     int test_ret = 0;
50550
50551 #if defined(LIBXML_XPATH_ENABLED)
50552     int mem_base;
50553     xmlXPathObjectPtr ret_val;
50554     xmlXPathContextPtr ctxt; /* the XPath context */
50555     int n_ctxt;
50556     xmlChar * name; /* the variable name */
50557     int n_name;
50558
50559     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
50560     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
50561         mem_base = xmlMemBlocks();
50562         ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
50563         name = gen_const_xmlChar_ptr(n_name, 1);
50564
50565         ret_val = xmlXPathVariableLookup(ctxt, (const xmlChar *)name);
50566         desret_xmlXPathObjectPtr(ret_val);
50567         call_tests++;
50568         des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
50569         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
50570         xmlResetLastError();
50571         if (mem_base != xmlMemBlocks()) {
50572             printf("Leak of %d blocks found in xmlXPathVariableLookup",
50573                    xmlMemBlocks() - mem_base);
50574             test_ret++;
50575             printf(" %d", n_ctxt);
50576             printf(" %d", n_name);
50577             printf("\n");
50578         }
50579     }
50580     }
50581     function_tests++;
50582 #endif
50583
50584     return(test_ret);
50585 }
50586
50587
50588 static int
50589 test_xmlXPathVariableLookupNS(void) {
50590     int test_ret = 0;
50591
50592 #if defined(LIBXML_XPATH_ENABLED)
50593     int mem_base;
50594     xmlXPathObjectPtr ret_val;
50595     xmlXPathContextPtr ctxt; /* the XPath context */
50596     int n_ctxt;
50597     xmlChar * name; /* the variable name */
50598     int n_name;
50599     xmlChar * ns_uri; /* the variable namespace URI */
50600     int n_ns_uri;
50601
50602     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathContextPtr;n_ctxt++) {
50603     for (n_name = 0;n_name < gen_nb_const_xmlChar_ptr;n_name++) {
50604     for (n_ns_uri = 0;n_ns_uri < gen_nb_const_xmlChar_ptr;n_ns_uri++) {
50605         mem_base = xmlMemBlocks();
50606         ctxt = gen_xmlXPathContextPtr(n_ctxt, 0);
50607         name = gen_const_xmlChar_ptr(n_name, 1);
50608         ns_uri = gen_const_xmlChar_ptr(n_ns_uri, 2);
50609
50610         ret_val = xmlXPathVariableLookupNS(ctxt, (const xmlChar *)name, (const xmlChar *)ns_uri);
50611         desret_xmlXPathObjectPtr(ret_val);
50612         call_tests++;
50613         des_xmlXPathContextPtr(n_ctxt, ctxt, 0);
50614         des_const_xmlChar_ptr(n_name, (const xmlChar *)name, 1);
50615         des_const_xmlChar_ptr(n_ns_uri, (const xmlChar *)ns_uri, 2);
50616         xmlResetLastError();
50617         if (mem_base != xmlMemBlocks()) {
50618             printf("Leak of %d blocks found in xmlXPathVariableLookupNS",
50619                    xmlMemBlocks() - mem_base);
50620             test_ret++;
50621             printf(" %d", n_ctxt);
50622             printf(" %d", n_name);
50623             printf(" %d", n_ns_uri);
50624             printf("\n");
50625         }
50626     }
50627     }
50628     }
50629     function_tests++;
50630 #endif
50631
50632     return(test_ret);
50633 }
50634
50635
50636 static int
50637 test_xmlXPathWrapCString(void) {
50638     int test_ret = 0;
50639
50640 #if defined(LIBXML_XPATH_ENABLED)
50641     int mem_base;
50642     xmlXPathObjectPtr ret_val;
50643     char * val; /* the char * value */
50644     int n_val;
50645
50646     for (n_val = 0;n_val < gen_nb_char_ptr;n_val++) {
50647         mem_base = xmlMemBlocks();
50648         val = gen_char_ptr(n_val, 0);
50649
50650         ret_val = xmlXPathWrapCString(val);
50651         desret_xmlXPathObjectPtr(ret_val);
50652         call_tests++;
50653         des_char_ptr(n_val, val, 0);
50654         xmlResetLastError();
50655         if (mem_base != xmlMemBlocks()) {
50656             printf("Leak of %d blocks found in xmlXPathWrapCString",
50657                    xmlMemBlocks() - mem_base);
50658             test_ret++;
50659             printf(" %d", n_val);
50660             printf("\n");
50661         }
50662     }
50663     function_tests++;
50664 #endif
50665
50666     return(test_ret);
50667 }
50668
50669
50670 static int
50671 test_xmlXPathWrapExternal(void) {
50672     int test_ret = 0;
50673
50674 #if defined(LIBXML_XPATH_ENABLED)
50675     int mem_base;
50676     xmlXPathObjectPtr ret_val;
50677     void * val; /* the user data */
50678     int n_val;
50679
50680     for (n_val = 0;n_val < gen_nb_void_ptr;n_val++) {
50681         mem_base = xmlMemBlocks();
50682         val = gen_void_ptr(n_val, 0);
50683
50684         ret_val = xmlXPathWrapExternal(val);
50685         desret_xmlXPathObjectPtr(ret_val);
50686         call_tests++;
50687         des_void_ptr(n_val, val, 0);
50688         xmlResetLastError();
50689         if (mem_base != xmlMemBlocks()) {
50690             printf("Leak of %d blocks found in xmlXPathWrapExternal",
50691                    xmlMemBlocks() - mem_base);
50692             test_ret++;
50693             printf(" %d", n_val);
50694             printf("\n");
50695         }
50696     }
50697     function_tests++;
50698 #endif
50699
50700     return(test_ret);
50701 }
50702
50703
50704 static int
50705 test_xmlXPathWrapNodeSet(void) {
50706     int test_ret = 0;
50707
50708 #if defined(LIBXML_XPATH_ENABLED)
50709     int mem_base;
50710     xmlXPathObjectPtr ret_val;
50711     xmlNodeSetPtr val; /* the NodePtr value */
50712     int n_val;
50713
50714     for (n_val = 0;n_val < gen_nb_xmlNodeSetPtr;n_val++) {
50715         mem_base = xmlMemBlocks();
50716         val = gen_xmlNodeSetPtr(n_val, 0);
50717
50718         ret_val = xmlXPathWrapNodeSet(val);
50719         desret_xmlXPathObjectPtr(ret_val);
50720         call_tests++;
50721         des_xmlNodeSetPtr(n_val, val, 0);
50722         xmlResetLastError();
50723         if (mem_base != xmlMemBlocks()) {
50724             printf("Leak of %d blocks found in xmlXPathWrapNodeSet",
50725                    xmlMemBlocks() - mem_base);
50726             test_ret++;
50727             printf(" %d", n_val);
50728             printf("\n");
50729         }
50730     }
50731     function_tests++;
50732 #endif
50733
50734     return(test_ret);
50735 }
50736
50737
50738 static int
50739 test_xmlXPatherror(void) {
50740     int test_ret = 0;
50741
50742 #if defined(LIBXML_XPATH_ENABLED)
50743     int mem_base;
50744     xmlXPathParserContextPtr ctxt; /* the XPath Parser context */
50745     int n_ctxt;
50746     const char * file; /* the file name */
50747     int n_file;
50748     int line; /* the line number */
50749     int n_line;
50750     int no; /* the error number */
50751     int n_no;
50752
50753     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50754     for (n_file = 0;n_file < gen_nb_filepath;n_file++) {
50755     for (n_line = 0;n_line < gen_nb_int;n_line++) {
50756     for (n_no = 0;n_no < gen_nb_int;n_no++) {
50757         mem_base = xmlMemBlocks();
50758         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
50759         file = gen_filepath(n_file, 1);
50760         line = gen_int(n_line, 2);
50761         no = gen_int(n_no, 3);
50762
50763         xmlXPatherror(ctxt, file, line, no);
50764         call_tests++;
50765         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
50766         des_filepath(n_file, file, 1);
50767         des_int(n_line, line, 2);
50768         des_int(n_no, no, 3);
50769         xmlResetLastError();
50770         if (mem_base != xmlMemBlocks()) {
50771             printf("Leak of %d blocks found in xmlXPatherror",
50772                    xmlMemBlocks() - mem_base);
50773             test_ret++;
50774             printf(" %d", n_ctxt);
50775             printf(" %d", n_file);
50776             printf(" %d", n_line);
50777             printf(" %d", n_no);
50778             printf("\n");
50779         }
50780     }
50781     }
50782     }
50783     }
50784     function_tests++;
50785 #endif
50786
50787     return(test_ret);
50788 }
50789
50790 static int
50791 test_xpathInternals(void) {
50792     int test_ret = 0;
50793
50794     if (quiet == 0) printf("Testing xpathInternals : 106 of 117 functions ...\n");
50795     test_ret += test_valuePop();
50796     test_ret += test_valuePush();
50797     test_ret += test_xmlXPathAddValues();
50798     test_ret += test_xmlXPathBooleanFunction();
50799     test_ret += test_xmlXPathCeilingFunction();
50800     test_ret += test_xmlXPathCompareValues();
50801     test_ret += test_xmlXPathConcatFunction();
50802     test_ret += test_xmlXPathContainsFunction();
50803     test_ret += test_xmlXPathCountFunction();
50804     test_ret += test_xmlXPathDebugDumpCompExpr();
50805     test_ret += test_xmlXPathDebugDumpObject();
50806     test_ret += test_xmlXPathDifference();
50807     test_ret += test_xmlXPathDistinct();
50808     test_ret += test_xmlXPathDistinctSorted();
50809     test_ret += test_xmlXPathDivValues();
50810     test_ret += test_xmlXPathEqualValues();
50811     test_ret += test_xmlXPathErr();
50812     test_ret += test_xmlXPathEvalExpr();
50813     test_ret += test_xmlXPathEvaluatePredicateResult();
50814     test_ret += test_xmlXPathFalseFunction();
50815     test_ret += test_xmlXPathFloorFunction();
50816     test_ret += test_xmlXPathFunctionLookup();
50817     test_ret += test_xmlXPathFunctionLookupNS();
50818     test_ret += test_xmlXPathHasSameNodes();
50819     test_ret += test_xmlXPathIdFunction();
50820     test_ret += test_xmlXPathIntersection();
50821     test_ret += test_xmlXPathIsNodeType();
50822     test_ret += test_xmlXPathLangFunction();
50823     test_ret += test_xmlXPathLastFunction();
50824     test_ret += test_xmlXPathLeading();
50825     test_ret += test_xmlXPathLeadingSorted();
50826     test_ret += test_xmlXPathLocalNameFunction();
50827     test_ret += test_xmlXPathModValues();
50828     test_ret += test_xmlXPathMultValues();
50829     test_ret += test_xmlXPathNamespaceURIFunction();
50830     test_ret += test_xmlXPathNewBoolean();
50831     test_ret += test_xmlXPathNewCString();
50832     test_ret += test_xmlXPathNewFloat();
50833     test_ret += test_xmlXPathNewNodeSet();
50834     test_ret += test_xmlXPathNewNodeSetList();
50835     test_ret += test_xmlXPathNewParserContext();
50836     test_ret += test_xmlXPathNewString();
50837     test_ret += test_xmlXPathNextAncestor();
50838     test_ret += test_xmlXPathNextAncestorOrSelf();
50839     test_ret += test_xmlXPathNextAttribute();
50840     test_ret += test_xmlXPathNextChild();
50841     test_ret += test_xmlXPathNextDescendant();
50842     test_ret += test_xmlXPathNextDescendantOrSelf();
50843     test_ret += test_xmlXPathNextFollowing();
50844     test_ret += test_xmlXPathNextFollowingSibling();
50845     test_ret += test_xmlXPathNextNamespace();
50846     test_ret += test_xmlXPathNextParent();
50847     test_ret += test_xmlXPathNextPreceding();
50848     test_ret += test_xmlXPathNextPrecedingSibling();
50849     test_ret += test_xmlXPathNextSelf();
50850     test_ret += test_xmlXPathNodeLeading();
50851     test_ret += test_xmlXPathNodeLeadingSorted();
50852     test_ret += test_xmlXPathNodeSetAdd();
50853     test_ret += test_xmlXPathNodeSetAddNs();
50854     test_ret += test_xmlXPathNodeSetAddUnique();
50855     test_ret += test_xmlXPathNodeSetContains();
50856     test_ret += test_xmlXPathNodeSetDel();
50857     test_ret += test_xmlXPathNodeSetMerge();
50858     test_ret += test_xmlXPathNodeSetRemove();
50859     test_ret += test_xmlXPathNodeSetSort();
50860     test_ret += test_xmlXPathNodeTrailing();
50861     test_ret += test_xmlXPathNodeTrailingSorted();
50862     test_ret += test_xmlXPathNormalizeFunction();
50863     test_ret += test_xmlXPathNotEqualValues();
50864     test_ret += test_xmlXPathNotFunction();
50865     test_ret += test_xmlXPathNsLookup();
50866     test_ret += test_xmlXPathNumberFunction();
50867     test_ret += test_xmlXPathParseNCName();
50868     test_ret += test_xmlXPathParseName();
50869     test_ret += test_xmlXPathPopBoolean();
50870     test_ret += test_xmlXPathPopExternal();
50871     test_ret += test_xmlXPathPopNodeSet();
50872     test_ret += test_xmlXPathPopNumber();
50873     test_ret += test_xmlXPathPopString();
50874     test_ret += test_xmlXPathPositionFunction();
50875     test_ret += test_xmlXPathRegisterAllFunctions();
50876     test_ret += test_xmlXPathRegisterFunc();
50877     test_ret += test_xmlXPathRegisterFuncLookup();
50878     test_ret += test_xmlXPathRegisterFuncNS();
50879     test_ret += test_xmlXPathRegisterNs();
50880     test_ret += test_xmlXPathRegisterVariable();
50881     test_ret += test_xmlXPathRegisterVariableLookup();
50882     test_ret += test_xmlXPathRegisterVariableNS();
50883     test_ret += test_xmlXPathRegisteredFuncsCleanup();
50884     test_ret += test_xmlXPathRegisteredNsCleanup();
50885     test_ret += test_xmlXPathRegisteredVariablesCleanup();
50886     test_ret += test_xmlXPathRoot();
50887     test_ret += test_xmlXPathRoundFunction();
50888     test_ret += test_xmlXPathStartsWithFunction();
50889     test_ret += test_xmlXPathStringEvalNumber();
50890     test_ret += test_xmlXPathStringFunction();
50891     test_ret += test_xmlXPathStringLengthFunction();
50892     test_ret += test_xmlXPathSubValues();
50893     test_ret += test_xmlXPathSubstringAfterFunction();
50894     test_ret += test_xmlXPathSubstringBeforeFunction();
50895     test_ret += test_xmlXPathSubstringFunction();
50896     test_ret += test_xmlXPathSumFunction();
50897     test_ret += test_xmlXPathTrailing();
50898     test_ret += test_xmlXPathTrailingSorted();
50899     test_ret += test_xmlXPathTranslateFunction();
50900     test_ret += test_xmlXPathTrueFunction();
50901     test_ret += test_xmlXPathValueFlipSign();
50902     test_ret += test_xmlXPathVariableLookup();
50903     test_ret += test_xmlXPathVariableLookupNS();
50904     test_ret += test_xmlXPathWrapCString();
50905     test_ret += test_xmlXPathWrapExternal();
50906     test_ret += test_xmlXPathWrapNodeSet();
50907     test_ret += test_xmlXPatherror();
50908
50909     if (test_ret != 0)
50910         printf("Module xpathInternals: %d errors\n", test_ret);
50911     return(test_ret);
50912 }
50913
50914 static int
50915 test_xmlXPtrBuildNodeList(void) {
50916     int test_ret = 0;
50917
50918 #if defined(LIBXML_XPTR_ENABLED)
50919     int mem_base;
50920     xmlNodePtr ret_val;
50921     xmlXPathObjectPtr obj; /* the XPointer result from the evaluation. */
50922     int n_obj;
50923
50924     for (n_obj = 0;n_obj < gen_nb_xmlXPathObjectPtr;n_obj++) {
50925         mem_base = xmlMemBlocks();
50926         obj = gen_xmlXPathObjectPtr(n_obj, 0);
50927
50928         ret_val = xmlXPtrBuildNodeList(obj);
50929         desret_xmlNodePtr(ret_val);
50930         call_tests++;
50931         des_xmlXPathObjectPtr(n_obj, obj, 0);
50932         xmlResetLastError();
50933         if (mem_base != xmlMemBlocks()) {
50934             printf("Leak of %d blocks found in xmlXPtrBuildNodeList",
50935                    xmlMemBlocks() - mem_base);
50936             test_ret++;
50937             printf(" %d", n_obj);
50938             printf("\n");
50939         }
50940     }
50941     function_tests++;
50942 #endif
50943
50944     return(test_ret);
50945 }
50946
50947
50948 static int
50949 test_xmlXPtrEval(void) {
50950     int test_ret = 0;
50951
50952 #if defined(LIBXML_XPTR_ENABLED)
50953     int mem_base;
50954     xmlXPathObjectPtr ret_val;
50955     xmlChar * str; /* the XPointer expression */
50956     int n_str;
50957     xmlXPathContextPtr ctx; /* the XPointer context */
50958     int n_ctx;
50959
50960     for (n_str = 0;n_str < gen_nb_const_xmlChar_ptr;n_str++) {
50961     for (n_ctx = 0;n_ctx < gen_nb_xmlXPathContextPtr;n_ctx++) {
50962         mem_base = xmlMemBlocks();
50963         str = gen_const_xmlChar_ptr(n_str, 0);
50964         ctx = gen_xmlXPathContextPtr(n_ctx, 1);
50965
50966         ret_val = xmlXPtrEval((const xmlChar *)str, ctx);
50967         desret_xmlXPathObjectPtr(ret_val);
50968         call_tests++;
50969         des_const_xmlChar_ptr(n_str, (const xmlChar *)str, 0);
50970         des_xmlXPathContextPtr(n_ctx, ctx, 1);
50971         xmlResetLastError();
50972         if (mem_base != xmlMemBlocks()) {
50973             printf("Leak of %d blocks found in xmlXPtrEval",
50974                    xmlMemBlocks() - mem_base);
50975             test_ret++;
50976             printf(" %d", n_str);
50977             printf(" %d", n_ctx);
50978             printf("\n");
50979         }
50980     }
50981     }
50982     function_tests++;
50983 #endif
50984
50985     return(test_ret);
50986 }
50987
50988
50989 static int
50990 test_xmlXPtrEvalRangePredicate(void) {
50991     int test_ret = 0;
50992
50993 #if defined(LIBXML_XPTR_ENABLED)
50994     int mem_base;
50995     xmlXPathParserContextPtr ctxt; /* the XPointer Parser context */
50996     int n_ctxt;
50997
50998     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
50999         mem_base = xmlMemBlocks();
51000         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
51001
51002         xmlXPtrEvalRangePredicate(ctxt);
51003         call_tests++;
51004         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
51005         xmlResetLastError();
51006         if (mem_base != xmlMemBlocks()) {
51007             printf("Leak of %d blocks found in xmlXPtrEvalRangePredicate",
51008                    xmlMemBlocks() - mem_base);
51009             test_ret++;
51010             printf(" %d", n_ctxt);
51011             printf("\n");
51012         }
51013     }
51014     function_tests++;
51015 #endif
51016
51017     return(test_ret);
51018 }
51019
51020 #ifdef LIBXML_XPTR_ENABLED
51021
51022 #define gen_nb_xmlLocationSetPtr 1
51023 static xmlLocationSetPtr gen_xmlLocationSetPtr(int no ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
51024     return(NULL);
51025 }
51026 static void des_xmlLocationSetPtr(int no ATTRIBUTE_UNUSED, xmlLocationSetPtr val ATTRIBUTE_UNUSED, int nr ATTRIBUTE_UNUSED) {
51027 }
51028 #endif
51029
51030
51031 static int
51032 test_xmlXPtrLocationSetAdd(void) {
51033     int test_ret = 0;
51034
51035 #if defined(LIBXML_XPTR_ENABLED)
51036     int mem_base;
51037     xmlLocationSetPtr cur; /* the initial range set */
51038     int n_cur;
51039     xmlXPathObjectPtr val; /* a new xmlXPathObjectPtr */
51040     int n_val;
51041
51042     for (n_cur = 0;n_cur < gen_nb_xmlLocationSetPtr;n_cur++) {
51043     for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
51044         mem_base = xmlMemBlocks();
51045         cur = gen_xmlLocationSetPtr(n_cur, 0);
51046         val = gen_xmlXPathObjectPtr(n_val, 1);
51047
51048         xmlXPtrLocationSetAdd(cur, val);
51049         call_tests++;
51050         des_xmlLocationSetPtr(n_cur, cur, 0);
51051         des_xmlXPathObjectPtr(n_val, val, 1);
51052         xmlResetLastError();
51053         if (mem_base != xmlMemBlocks()) {
51054             printf("Leak of %d blocks found in xmlXPtrLocationSetAdd",
51055                    xmlMemBlocks() - mem_base);
51056             test_ret++;
51057             printf(" %d", n_cur);
51058             printf(" %d", n_val);
51059             printf("\n");
51060         }
51061     }
51062     }
51063     function_tests++;
51064 #endif
51065
51066     return(test_ret);
51067 }
51068
51069
51070 static int
51071 test_xmlXPtrLocationSetCreate(void) {
51072     int test_ret = 0;
51073
51074
51075     /* missing type support */
51076     return(test_ret);
51077 }
51078
51079
51080 static int
51081 test_xmlXPtrLocationSetDel(void) {
51082     int test_ret = 0;
51083
51084 #if defined(LIBXML_XPTR_ENABLED)
51085     int mem_base;
51086     xmlLocationSetPtr cur; /* the initial range set */
51087     int n_cur;
51088     xmlXPathObjectPtr val; /* an xmlXPathObjectPtr */
51089     int n_val;
51090
51091     for (n_cur = 0;n_cur < gen_nb_xmlLocationSetPtr;n_cur++) {
51092     for (n_val = 0;n_val < gen_nb_xmlXPathObjectPtr;n_val++) {
51093         mem_base = xmlMemBlocks();
51094         cur = gen_xmlLocationSetPtr(n_cur, 0);
51095         val = gen_xmlXPathObjectPtr(n_val, 1);
51096
51097         xmlXPtrLocationSetDel(cur, val);
51098         call_tests++;
51099         des_xmlLocationSetPtr(n_cur, cur, 0);
51100         des_xmlXPathObjectPtr(n_val, val, 1);
51101         xmlResetLastError();
51102         if (mem_base != xmlMemBlocks()) {
51103             printf("Leak of %d blocks found in xmlXPtrLocationSetDel",
51104                    xmlMemBlocks() - mem_base);
51105             test_ret++;
51106             printf(" %d", n_cur);
51107             printf(" %d", n_val);
51108             printf("\n");
51109         }
51110     }
51111     }
51112     function_tests++;
51113 #endif
51114
51115     return(test_ret);
51116 }
51117
51118
51119 static int
51120 test_xmlXPtrLocationSetMerge(void) {
51121     int test_ret = 0;
51122
51123
51124     /* missing type support */
51125     return(test_ret);
51126 }
51127
51128
51129 static int
51130 test_xmlXPtrLocationSetRemove(void) {
51131     int test_ret = 0;
51132
51133 #if defined(LIBXML_XPTR_ENABLED)
51134     int mem_base;
51135     xmlLocationSetPtr cur; /* the initial range set */
51136     int n_cur;
51137     int val; /* the index to remove */
51138     int n_val;
51139
51140     for (n_cur = 0;n_cur < gen_nb_xmlLocationSetPtr;n_cur++) {
51141     for (n_val = 0;n_val < gen_nb_int;n_val++) {
51142         mem_base = xmlMemBlocks();
51143         cur = gen_xmlLocationSetPtr(n_cur, 0);
51144         val = gen_int(n_val, 1);
51145
51146         xmlXPtrLocationSetRemove(cur, val);
51147         call_tests++;
51148         des_xmlLocationSetPtr(n_cur, cur, 0);
51149         des_int(n_val, val, 1);
51150         xmlResetLastError();
51151         if (mem_base != xmlMemBlocks()) {
51152             printf("Leak of %d blocks found in xmlXPtrLocationSetRemove",
51153                    xmlMemBlocks() - mem_base);
51154             test_ret++;
51155             printf(" %d", n_cur);
51156             printf(" %d", n_val);
51157             printf("\n");
51158         }
51159     }
51160     }
51161     function_tests++;
51162 #endif
51163
51164     return(test_ret);
51165 }
51166
51167
51168 static int
51169 test_xmlXPtrNewCollapsedRange(void) {
51170     int test_ret = 0;
51171
51172 #if defined(LIBXML_XPTR_ENABLED)
51173     int mem_base;
51174     xmlXPathObjectPtr ret_val;
51175     xmlNodePtr start; /* the starting and ending node */
51176     int n_start;
51177
51178     for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
51179         mem_base = xmlMemBlocks();
51180         start = gen_xmlNodePtr(n_start, 0);
51181
51182         ret_val = xmlXPtrNewCollapsedRange(start);
51183         desret_xmlXPathObjectPtr(ret_val);
51184         call_tests++;
51185         des_xmlNodePtr(n_start, start, 0);
51186         xmlResetLastError();
51187         if (mem_base != xmlMemBlocks()) {
51188             printf("Leak of %d blocks found in xmlXPtrNewCollapsedRange",
51189                    xmlMemBlocks() - mem_base);
51190             test_ret++;
51191             printf(" %d", n_start);
51192             printf("\n");
51193         }
51194     }
51195     function_tests++;
51196 #endif
51197
51198     return(test_ret);
51199 }
51200
51201
51202 static int
51203 test_xmlXPtrNewContext(void) {
51204     int test_ret = 0;
51205
51206
51207     /* missing type support */
51208     return(test_ret);
51209 }
51210
51211
51212 static int
51213 test_xmlXPtrNewLocationSetNodeSet(void) {
51214     int test_ret = 0;
51215
51216 #if defined(LIBXML_XPTR_ENABLED)
51217     int mem_base;
51218     xmlXPathObjectPtr ret_val;
51219     xmlNodeSetPtr set; /* a node set */
51220     int n_set;
51221
51222     for (n_set = 0;n_set < gen_nb_xmlNodeSetPtr;n_set++) {
51223         mem_base = xmlMemBlocks();
51224         set = gen_xmlNodeSetPtr(n_set, 0);
51225
51226         ret_val = xmlXPtrNewLocationSetNodeSet(set);
51227         desret_xmlXPathObjectPtr(ret_val);
51228         call_tests++;
51229         des_xmlNodeSetPtr(n_set, set, 0);
51230         xmlResetLastError();
51231         if (mem_base != xmlMemBlocks()) {
51232             printf("Leak of %d blocks found in xmlXPtrNewLocationSetNodeSet",
51233                    xmlMemBlocks() - mem_base);
51234             test_ret++;
51235             printf(" %d", n_set);
51236             printf("\n");
51237         }
51238     }
51239     function_tests++;
51240 #endif
51241
51242     return(test_ret);
51243 }
51244
51245
51246 static int
51247 test_xmlXPtrNewLocationSetNodes(void) {
51248     int test_ret = 0;
51249
51250 #if defined(LIBXML_XPTR_ENABLED)
51251     int mem_base;
51252     xmlXPathObjectPtr ret_val;
51253     xmlNodePtr start; /* the start NodePtr value */
51254     int n_start;
51255     xmlNodePtr end; /* the end NodePtr value or NULL */
51256     int n_end;
51257
51258     for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
51259     for (n_end = 0;n_end < gen_nb_xmlNodePtr;n_end++) {
51260         mem_base = xmlMemBlocks();
51261         start = gen_xmlNodePtr(n_start, 0);
51262         end = gen_xmlNodePtr(n_end, 1);
51263
51264         ret_val = xmlXPtrNewLocationSetNodes(start, end);
51265         desret_xmlXPathObjectPtr(ret_val);
51266         call_tests++;
51267         des_xmlNodePtr(n_start, start, 0);
51268         des_xmlNodePtr(n_end, end, 1);
51269         xmlResetLastError();
51270         if (mem_base != xmlMemBlocks()) {
51271             printf("Leak of %d blocks found in xmlXPtrNewLocationSetNodes",
51272                    xmlMemBlocks() - mem_base);
51273             test_ret++;
51274             printf(" %d", n_start);
51275             printf(" %d", n_end);
51276             printf("\n");
51277         }
51278     }
51279     }
51280     function_tests++;
51281 #endif
51282
51283     return(test_ret);
51284 }
51285
51286
51287 static int
51288 test_xmlXPtrNewRange(void) {
51289     int test_ret = 0;
51290
51291 #if defined(LIBXML_XPTR_ENABLED)
51292     int mem_base;
51293     xmlXPathObjectPtr ret_val;
51294     xmlNodePtr start; /* the starting node */
51295     int n_start;
51296     int startindex; /* the start index */
51297     int n_startindex;
51298     xmlNodePtr end; /* the ending point */
51299     int n_end;
51300     int endindex; /* the ending index */
51301     int n_endindex;
51302
51303     for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
51304     for (n_startindex = 0;n_startindex < gen_nb_int;n_startindex++) {
51305     for (n_end = 0;n_end < gen_nb_xmlNodePtr;n_end++) {
51306     for (n_endindex = 0;n_endindex < gen_nb_int;n_endindex++) {
51307         mem_base = xmlMemBlocks();
51308         start = gen_xmlNodePtr(n_start, 0);
51309         startindex = gen_int(n_startindex, 1);
51310         end = gen_xmlNodePtr(n_end, 2);
51311         endindex = gen_int(n_endindex, 3);
51312
51313         ret_val = xmlXPtrNewRange(start, startindex, end, endindex);
51314         desret_xmlXPathObjectPtr(ret_val);
51315         call_tests++;
51316         des_xmlNodePtr(n_start, start, 0);
51317         des_int(n_startindex, startindex, 1);
51318         des_xmlNodePtr(n_end, end, 2);
51319         des_int(n_endindex, endindex, 3);
51320         xmlResetLastError();
51321         if (mem_base != xmlMemBlocks()) {
51322             printf("Leak of %d blocks found in xmlXPtrNewRange",
51323                    xmlMemBlocks() - mem_base);
51324             test_ret++;
51325             printf(" %d", n_start);
51326             printf(" %d", n_startindex);
51327             printf(" %d", n_end);
51328             printf(" %d", n_endindex);
51329             printf("\n");
51330         }
51331     }
51332     }
51333     }
51334     }
51335     function_tests++;
51336 #endif
51337
51338     return(test_ret);
51339 }
51340
51341
51342 static int
51343 test_xmlXPtrNewRangeNodeObject(void) {
51344     int test_ret = 0;
51345
51346 #if defined(LIBXML_XPTR_ENABLED)
51347     int mem_base;
51348     xmlXPathObjectPtr ret_val;
51349     xmlNodePtr start; /* the starting node */
51350     int n_start;
51351     xmlXPathObjectPtr end; /* the ending object */
51352     int n_end;
51353
51354     for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
51355     for (n_end = 0;n_end < gen_nb_xmlXPathObjectPtr;n_end++) {
51356         mem_base = xmlMemBlocks();
51357         start = gen_xmlNodePtr(n_start, 0);
51358         end = gen_xmlXPathObjectPtr(n_end, 1);
51359
51360         ret_val = xmlXPtrNewRangeNodeObject(start, end);
51361         desret_xmlXPathObjectPtr(ret_val);
51362         call_tests++;
51363         des_xmlNodePtr(n_start, start, 0);
51364         des_xmlXPathObjectPtr(n_end, end, 1);
51365         xmlResetLastError();
51366         if (mem_base != xmlMemBlocks()) {
51367             printf("Leak of %d blocks found in xmlXPtrNewRangeNodeObject",
51368                    xmlMemBlocks() - mem_base);
51369             test_ret++;
51370             printf(" %d", n_start);
51371             printf(" %d", n_end);
51372             printf("\n");
51373         }
51374     }
51375     }
51376     function_tests++;
51377 #endif
51378
51379     return(test_ret);
51380 }
51381
51382
51383 static int
51384 test_xmlXPtrNewRangeNodePoint(void) {
51385     int test_ret = 0;
51386
51387 #if defined(LIBXML_XPTR_ENABLED)
51388     int mem_base;
51389     xmlXPathObjectPtr ret_val;
51390     xmlNodePtr start; /* the starting node */
51391     int n_start;
51392     xmlXPathObjectPtr end; /* the ending point */
51393     int n_end;
51394
51395     for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
51396     for (n_end = 0;n_end < gen_nb_xmlXPathObjectPtr;n_end++) {
51397         mem_base = xmlMemBlocks();
51398         start = gen_xmlNodePtr(n_start, 0);
51399         end = gen_xmlXPathObjectPtr(n_end, 1);
51400
51401         ret_val = xmlXPtrNewRangeNodePoint(start, end);
51402         desret_xmlXPathObjectPtr(ret_val);
51403         call_tests++;
51404         des_xmlNodePtr(n_start, start, 0);
51405         des_xmlXPathObjectPtr(n_end, end, 1);
51406         xmlResetLastError();
51407         if (mem_base != xmlMemBlocks()) {
51408             printf("Leak of %d blocks found in xmlXPtrNewRangeNodePoint",
51409                    xmlMemBlocks() - mem_base);
51410             test_ret++;
51411             printf(" %d", n_start);
51412             printf(" %d", n_end);
51413             printf("\n");
51414         }
51415     }
51416     }
51417     function_tests++;
51418 #endif
51419
51420     return(test_ret);
51421 }
51422
51423
51424 static int
51425 test_xmlXPtrNewRangeNodes(void) {
51426     int test_ret = 0;
51427
51428 #if defined(LIBXML_XPTR_ENABLED)
51429     int mem_base;
51430     xmlXPathObjectPtr ret_val;
51431     xmlNodePtr start; /* the starting node */
51432     int n_start;
51433     xmlNodePtr end; /* the ending node */
51434     int n_end;
51435
51436     for (n_start = 0;n_start < gen_nb_xmlNodePtr;n_start++) {
51437     for (n_end = 0;n_end < gen_nb_xmlNodePtr;n_end++) {
51438         mem_base = xmlMemBlocks();
51439         start = gen_xmlNodePtr(n_start, 0);
51440         end = gen_xmlNodePtr(n_end, 1);
51441
51442         ret_val = xmlXPtrNewRangeNodes(start, end);
51443         desret_xmlXPathObjectPtr(ret_val);
51444         call_tests++;
51445         des_xmlNodePtr(n_start, start, 0);
51446         des_xmlNodePtr(n_end, end, 1);
51447         xmlResetLastError();
51448         if (mem_base != xmlMemBlocks()) {
51449             printf("Leak of %d blocks found in xmlXPtrNewRangeNodes",
51450                    xmlMemBlocks() - mem_base);
51451             test_ret++;
51452             printf(" %d", n_start);
51453             printf(" %d", n_end);
51454             printf("\n");
51455         }
51456     }
51457     }
51458     function_tests++;
51459 #endif
51460
51461     return(test_ret);
51462 }
51463
51464
51465 static int
51466 test_xmlXPtrNewRangePointNode(void) {
51467     int test_ret = 0;
51468
51469 #if defined(LIBXML_XPTR_ENABLED)
51470     int mem_base;
51471     xmlXPathObjectPtr ret_val;
51472     xmlXPathObjectPtr start; /* the starting point */
51473     int n_start;
51474     xmlNodePtr end; /* the ending node */
51475     int n_end;
51476
51477     for (n_start = 0;n_start < gen_nb_xmlXPathObjectPtr;n_start++) {
51478     for (n_end = 0;n_end < gen_nb_xmlNodePtr;n_end++) {
51479         mem_base = xmlMemBlocks();
51480         start = gen_xmlXPathObjectPtr(n_start, 0);
51481         end = gen_xmlNodePtr(n_end, 1);
51482
51483         ret_val = xmlXPtrNewRangePointNode(start, end);
51484         desret_xmlXPathObjectPtr(ret_val);
51485         call_tests++;
51486         des_xmlXPathObjectPtr(n_start, start, 0);
51487         des_xmlNodePtr(n_end, end, 1);
51488         xmlResetLastError();
51489         if (mem_base != xmlMemBlocks()) {
51490             printf("Leak of %d blocks found in xmlXPtrNewRangePointNode",
51491                    xmlMemBlocks() - mem_base);
51492             test_ret++;
51493             printf(" %d", n_start);
51494             printf(" %d", n_end);
51495             printf("\n");
51496         }
51497     }
51498     }
51499     function_tests++;
51500 #endif
51501
51502     return(test_ret);
51503 }
51504
51505
51506 static int
51507 test_xmlXPtrNewRangePoints(void) {
51508     int test_ret = 0;
51509
51510 #if defined(LIBXML_XPTR_ENABLED)
51511     int mem_base;
51512     xmlXPathObjectPtr ret_val;
51513     xmlXPathObjectPtr start; /* the starting point */
51514     int n_start;
51515     xmlXPathObjectPtr end; /* the ending point */
51516     int n_end;
51517
51518     for (n_start = 0;n_start < gen_nb_xmlXPathObjectPtr;n_start++) {
51519     for (n_end = 0;n_end < gen_nb_xmlXPathObjectPtr;n_end++) {
51520         mem_base = xmlMemBlocks();
51521         start = gen_xmlXPathObjectPtr(n_start, 0);
51522         end = gen_xmlXPathObjectPtr(n_end, 1);
51523
51524         ret_val = xmlXPtrNewRangePoints(start, end);
51525         desret_xmlXPathObjectPtr(ret_val);
51526         call_tests++;
51527         des_xmlXPathObjectPtr(n_start, start, 0);
51528         des_xmlXPathObjectPtr(n_end, end, 1);
51529         xmlResetLastError();
51530         if (mem_base != xmlMemBlocks()) {
51531             printf("Leak of %d blocks found in xmlXPtrNewRangePoints",
51532                    xmlMemBlocks() - mem_base);
51533             test_ret++;
51534             printf(" %d", n_start);
51535             printf(" %d", n_end);
51536             printf("\n");
51537         }
51538     }
51539     }
51540     function_tests++;
51541 #endif
51542
51543     return(test_ret);
51544 }
51545
51546
51547 static int
51548 test_xmlXPtrRangeToFunction(void) {
51549     int test_ret = 0;
51550
51551 #if defined(LIBXML_XPTR_ENABLED)
51552     int mem_base;
51553     xmlXPathParserContextPtr ctxt; /* the XPointer Parser context */
51554     int n_ctxt;
51555     int nargs; /* the number of args */
51556     int n_nargs;
51557
51558     for (n_ctxt = 0;n_ctxt < gen_nb_xmlXPathParserContextPtr;n_ctxt++) {
51559     for (n_nargs = 0;n_nargs < gen_nb_int;n_nargs++) {
51560         mem_base = xmlMemBlocks();
51561         ctxt = gen_xmlXPathParserContextPtr(n_ctxt, 0);
51562         nargs = gen_int(n_nargs, 1);
51563
51564         xmlXPtrRangeToFunction(ctxt, nargs);
51565         call_tests++;
51566         des_xmlXPathParserContextPtr(n_ctxt, ctxt, 0);
51567         des_int(n_nargs, nargs, 1);
51568         xmlResetLastError();
51569         if (mem_base != xmlMemBlocks()) {
51570             printf("Leak of %d blocks found in xmlXPtrRangeToFunction",
51571                    xmlMemBlocks() - mem_base);
51572             test_ret++;
51573             printf(" %d", n_ctxt);
51574             printf(" %d", n_nargs);
51575             printf("\n");
51576         }
51577     }
51578     }
51579     function_tests++;
51580 #endif
51581
51582     return(test_ret);
51583 }
51584
51585
51586 static int
51587 test_xmlXPtrWrapLocationSet(void) {
51588     int test_ret = 0;
51589
51590 #if defined(LIBXML_XPTR_ENABLED)
51591     int mem_base;
51592     xmlXPathObjectPtr ret_val;
51593     xmlLocationSetPtr val; /* the LocationSet value */
51594     int n_val;
51595
51596     for (n_val = 0;n_val < gen_nb_xmlLocationSetPtr;n_val++) {
51597         mem_base = xmlMemBlocks();
51598         val = gen_xmlLocationSetPtr(n_val, 0);
51599
51600         ret_val = xmlXPtrWrapLocationSet(val);
51601         desret_xmlXPathObjectPtr(ret_val);
51602         call_tests++;
51603         des_xmlLocationSetPtr(n_val, val, 0);
51604         xmlResetLastError();
51605         if (mem_base != xmlMemBlocks()) {
51606             printf("Leak of %d blocks found in xmlXPtrWrapLocationSet",
51607                    xmlMemBlocks() - mem_base);
51608             test_ret++;
51609             printf(" %d", n_val);
51610             printf("\n");
51611         }
51612     }
51613     function_tests++;
51614 #endif
51615
51616     return(test_ret);
51617 }
51618
51619 static int
51620 test_xpointer(void) {
51621     int test_ret = 0;
51622
51623     if (quiet == 0) printf("Testing xpointer : 17 of 21 functions ...\n");
51624     test_ret += test_xmlXPtrBuildNodeList();
51625     test_ret += test_xmlXPtrEval();
51626     test_ret += test_xmlXPtrEvalRangePredicate();
51627     test_ret += test_xmlXPtrLocationSetAdd();
51628     test_ret += test_xmlXPtrLocationSetCreate();
51629     test_ret += test_xmlXPtrLocationSetDel();
51630     test_ret += test_xmlXPtrLocationSetMerge();
51631     test_ret += test_xmlXPtrLocationSetRemove();
51632     test_ret += test_xmlXPtrNewCollapsedRange();
51633     test_ret += test_xmlXPtrNewContext();
51634     test_ret += test_xmlXPtrNewLocationSetNodeSet();
51635     test_ret += test_xmlXPtrNewLocationSetNodes();
51636     test_ret += test_xmlXPtrNewRange();
51637     test_ret += test_xmlXPtrNewRangeNodeObject();
51638     test_ret += test_xmlXPtrNewRangeNodePoint();
51639     test_ret += test_xmlXPtrNewRangeNodes();
51640     test_ret += test_xmlXPtrNewRangePointNode();
51641     test_ret += test_xmlXPtrNewRangePoints();
51642     test_ret += test_xmlXPtrRangeToFunction();
51643     test_ret += test_xmlXPtrWrapLocationSet();
51644
51645     if (test_ret != 0)
51646         printf("Module xpointer: %d errors\n", test_ret);
51647     return(test_ret);
51648 }
51649 static int
51650 test_module(const char *module) {
51651     if (!strcmp(module, "HTMLparser")) return(test_HTMLparser());
51652     if (!strcmp(module, "HTMLtree")) return(test_HTMLtree());
51653     if (!strcmp(module, "SAX2")) return(test_SAX2());
51654     if (!strcmp(module, "c14n")) return(test_c14n());
51655     if (!strcmp(module, "catalog")) return(test_catalog());
51656     if (!strcmp(module, "chvalid")) return(test_chvalid());
51657     if (!strcmp(module, "debugXML")) return(test_debugXML());
51658     if (!strcmp(module, "dict")) return(test_dict());
51659     if (!strcmp(module, "encoding")) return(test_encoding());
51660     if (!strcmp(module, "entities")) return(test_entities());
51661     if (!strcmp(module, "hash")) return(test_hash());
51662     if (!strcmp(module, "list")) return(test_list());
51663     if (!strcmp(module, "nanoftp")) return(test_nanoftp());
51664     if (!strcmp(module, "nanohttp")) return(test_nanohttp());
51665     if (!strcmp(module, "parser")) return(test_parser());
51666     if (!strcmp(module, "parserInternals")) return(test_parserInternals());
51667     if (!strcmp(module, "pattern")) return(test_pattern());
51668     if (!strcmp(module, "relaxng")) return(test_relaxng());
51669     if (!strcmp(module, "schemasInternals")) return(test_schemasInternals());
51670     if (!strcmp(module, "schematron")) return(test_schematron());
51671     if (!strcmp(module, "tree")) return(test_tree());
51672     if (!strcmp(module, "uri")) return(test_uri());
51673     if (!strcmp(module, "valid")) return(test_valid());
51674     if (!strcmp(module, "xinclude")) return(test_xinclude());
51675     if (!strcmp(module, "xmlIO")) return(test_xmlIO());
51676     if (!strcmp(module, "xmlautomata")) return(test_xmlautomata());
51677     if (!strcmp(module, "xmlerror")) return(test_xmlerror());
51678     if (!strcmp(module, "xmlmodule")) return(test_xmlmodule());
51679     if (!strcmp(module, "xmlreader")) return(test_xmlreader());
51680     if (!strcmp(module, "xmlregexp")) return(test_xmlregexp());
51681     if (!strcmp(module, "xmlsave")) return(test_xmlsave());
51682     if (!strcmp(module, "xmlschemas")) return(test_xmlschemas());
51683     if (!strcmp(module, "xmlschemastypes")) return(test_xmlschemastypes());
51684     if (!strcmp(module, "xmlstring")) return(test_xmlstring());
51685     if (!strcmp(module, "xmlunicode")) return(test_xmlunicode());
51686     if (!strcmp(module, "xmlwriter")) return(test_xmlwriter());
51687     if (!strcmp(module, "xpath")) return(test_xpath());
51688     if (!strcmp(module, "xpathInternals")) return(test_xpathInternals());
51689     if (!strcmp(module, "xpointer")) return(test_xpointer());
51690     return(0);
51691 }